city41

function _composite(under, over) {
	var alphaO = over[3],
		alphaU = under[3],
		invAlphaO = 1 - alphaO,
		i,
		len;

	for(i = 0, len = under.length - 1; i < len; ++i) {
		under[i] = Math.round((over[i] * alphaO) 
			+ ((under[i] * alphaU) * invAlphaO));

adamawolf

i386 : iPhone Simulator
x86_64 : iPhone Simulator
arm64 : iPhone Simulator
iPhone1,1 : iPhone
iPhone1,2 : iPhone 3G
iPhone2,1 : iPhone 3GS
iPhone3,1 : iPhone 4
iPhone3,2 : iPhone 4 GSM Rev A
iPhone3,3 : iPhone 4 CDMA
iPhone4,1 : iPhone 4S

tong

<!-- NativeClient hxcpp toolchain -->

<xml>

	<include name="gcc-toolchain.xml"/>
	
	<path name="${NACL_SDK_ROOT}/toolchain/linux_x86_newlib/bin"/>
	
	<set name="M" value="32" unless="HXCPP_M64" />

Simn

import haxe.macro.Context;
import haxe.macro.Expr;
import haxe.macro.Type;

class AbstractBuilder {
  macro static public function build():Array<Field> {
		var fields = Context.getBuildFields();
		var cCur = Context.getLocalClass().get();
		var fieldMap = [for (f in fields) f.name => true];
		function loop(c:ClassType) {

Simn

typedef Constructible = {
  public function new():Void;
}

@:generic
class Gen<T:(Constructible, Main)> {
	public function new() { }
	
	public function make() {
		return new T();

nadako

#if macro
import haxe.macro.Context;
import haxe.macro.Expr;

class SchemaTypeBuilder
{
    public static function build(ref:String):haxe.macro.Type
    {
        var schema = haxe.Json.parse(sys.io.File.getContent(ref));
        var type:ComplexType = parseType(schema);

dpeek

import haxe.macro.Expr;

class FTW
{
	public static function build()
	{
		return haxe.macro.Context.getBuildFields().map(transformField);
	}

	static function transformField(field:Field)

RealyUniqueName

package fst.exception;

import haxe.CallStack;


/**
* Exceptions base
*
*/
class Exception {

nadako

/**
 * Simple wrapper for anonymous structures that are meant to be used as a
 * keyed collection of objects of the same type (i.e. json object).
 *
 * Wraps Reflect calls with nice syntax and static typing without any
 * runtime overhead.
 */
abstract DynamicMap<V>(Dynamic<V>) from Dynamic<V>
{
    /**

nadako

class Main
{
    static function main()
    {
        var a = ["a", "b", "c"];

        for (p in new IndexIter(a))
        {
            trace(p.idx);
            trace(p.val);