示例#1
0
namespace dynamics {

Void B2BodyDef_obj::__construct()
{
    HX_STACK_PUSH("B2BodyDef::new","box2D/dynamics/B2BodyDef.hx",35);
    {
        HX_STACK_LINE(36)
        this->position = ::box2D::common::math::B2Vec2_obj::__new(null(),null());
        HX_STACK_LINE(37)
        this->linearVelocity = ::box2D::common::math::B2Vec2_obj::__new(null(),null());
        HX_STACK_LINE(39)
        this->userData = null();
        HX_STACK_LINE(41)
        this->angle = 0.0;
        HX_STACK_LINE(43)
        this->angularVelocity = 0.0;
        HX_STACK_LINE(44)
        this->linearDamping = 0.0;
        HX_STACK_LINE(45)
        this->angularDamping = 0.0;
        HX_STACK_LINE(46)
        this->allowSleep = true;
        HX_STACK_LINE(47)
        this->awake = true;
        HX_STACK_LINE(48)
        this->fixedRotation = false;
        HX_STACK_LINE(49)
        this->bullet = false;
        HX_STACK_LINE(50)
        this->type = ::box2D::dynamics::B2Body_obj::b2_staticBody;
        HX_STACK_LINE(51)
        this->active = true;
        HX_STACK_LINE(52)
        this->inertiaScale = 1.0;
        HX_STACK_LINE(55)
        this->groupID = (int)3;
    }
    ;
    return null();
}

B2BodyDef_obj::~B2BodyDef_obj() { }

Dynamic B2BodyDef_obj::__CreateEmpty() {
    return  new B2BodyDef_obj;
}
hx::ObjectPtr< B2BodyDef_obj > B2BodyDef_obj::__new()
{   hx::ObjectPtr< B2BodyDef_obj > result = new B2BodyDef_obj();
    result->__construct();
    return result;
}

Dynamic B2BodyDef_obj::__Create(hx::DynamicArray inArgs)
{   hx::ObjectPtr< B2BodyDef_obj > result = new B2BodyDef_obj();
    result->__construct();
    return result;
}


B2BodyDef_obj::B2BodyDef_obj()
{
}

void B2BodyDef_obj::__Mark(HX_MARK_PARAMS)
{
    HX_MARK_BEGIN_CLASS(B2BodyDef);
    HX_MARK_MEMBER_NAME(aMass,"aMass");
    HX_MARK_MEMBER_NAME(mass,"mass");
    HX_MARK_MEMBER_NAME(bounciness,"bounciness");
    HX_MARK_MEMBER_NAME(friction,"friction");
    HX_MARK_MEMBER_NAME(ignoreGravity,"ignoreGravity");
    HX_MARK_MEMBER_NAME(groupID,"groupID");
    HX_MARK_MEMBER_NAME(inertiaScale,"inertiaScale");
    HX_MARK_MEMBER_NAME(userData,"userData");
    HX_MARK_MEMBER_NAME(active,"active");
    HX_MARK_MEMBER_NAME(bullet,"bullet");
    HX_MARK_MEMBER_NAME(fixedRotation,"fixedRotation");
    HX_MARK_MEMBER_NAME(awake,"awake");
    HX_MARK_MEMBER_NAME(allowSleep,"allowSleep");
    HX_MARK_MEMBER_NAME(angularDamping,"angularDamping");
    HX_MARK_MEMBER_NAME(linearDamping,"linearDamping");
    HX_MARK_MEMBER_NAME(angularVelocity,"angularVelocity");
    HX_MARK_MEMBER_NAME(linearVelocity,"linearVelocity");
    HX_MARK_MEMBER_NAME(angle,"angle");
    HX_MARK_MEMBER_NAME(position,"position");
    HX_MARK_MEMBER_NAME(type,"type");
    HX_MARK_END_CLASS();
}

void B2BodyDef_obj::__Visit(HX_VISIT_PARAMS)
{
    HX_VISIT_MEMBER_NAME(aMass,"aMass");
    HX_VISIT_MEMBER_NAME(mass,"mass");
    HX_VISIT_MEMBER_NAME(bounciness,"bounciness");
    HX_VISIT_MEMBER_NAME(friction,"friction");
    HX_VISIT_MEMBER_NAME(ignoreGravity,"ignoreGravity");
    HX_VISIT_MEMBER_NAME(groupID,"groupID");
    HX_VISIT_MEMBER_NAME(inertiaScale,"inertiaScale");
    HX_VISIT_MEMBER_NAME(userData,"userData");
    HX_VISIT_MEMBER_NAME(active,"active");
    HX_VISIT_MEMBER_NAME(bullet,"bullet");
    HX_VISIT_MEMBER_NAME(fixedRotation,"fixedRotation");
    HX_VISIT_MEMBER_NAME(awake,"awake");
    HX_VISIT_MEMBER_NAME(allowSleep,"allowSleep");
    HX_VISIT_MEMBER_NAME(angularDamping,"angularDamping");
    HX_VISIT_MEMBER_NAME(linearDamping,"linearDamping");
    HX_VISIT_MEMBER_NAME(angularVelocity,"angularVelocity");
    HX_VISIT_MEMBER_NAME(linearVelocity,"linearVelocity");
    HX_VISIT_MEMBER_NAME(angle,"angle");
    HX_VISIT_MEMBER_NAME(position,"position");
    HX_VISIT_MEMBER_NAME(type,"type");
}

Dynamic B2BodyDef_obj::__Field(const ::String &inName,bool inCallProp)
{
    switch(inName.length) {
    case 4:
        if (HX_FIELD_EQ(inName,"mass") ) {
            return mass;
        }
        if (HX_FIELD_EQ(inName,"type") ) {
            return type;
        }
        break;
    case 5:
        if (HX_FIELD_EQ(inName,"aMass") ) {
            return aMass;
        }
        if (HX_FIELD_EQ(inName,"awake") ) {
            return awake;
        }
        if (HX_FIELD_EQ(inName,"angle") ) {
            return angle;
        }
        break;
    case 6:
        if (HX_FIELD_EQ(inName,"active") ) {
            return active;
        }
        if (HX_FIELD_EQ(inName,"bullet") ) {
            return bullet;
        }
        break;
    case 7:
        if (HX_FIELD_EQ(inName,"groupID") ) {
            return groupID;
        }
        break;
    case 8:
        if (HX_FIELD_EQ(inName,"friction") ) {
            return friction;
        }
        if (HX_FIELD_EQ(inName,"userData") ) {
            return userData;
        }
        if (HX_FIELD_EQ(inName,"position") ) {
            return position;
        }
        break;
    case 10:
        if (HX_FIELD_EQ(inName,"bounciness") ) {
            return bounciness;
        }
        if (HX_FIELD_EQ(inName,"allowSleep") ) {
            return allowSleep;
        }
        break;
    case 12:
        if (HX_FIELD_EQ(inName,"inertiaScale") ) {
            return inertiaScale;
        }
        break;
    case 13:
        if (HX_FIELD_EQ(inName,"ignoreGravity") ) {
            return ignoreGravity;
        }
        if (HX_FIELD_EQ(inName,"fixedRotation") ) {
            return fixedRotation;
        }
        if (HX_FIELD_EQ(inName,"linearDamping") ) {
            return linearDamping;
        }
        break;
    case 14:
        if (HX_FIELD_EQ(inName,"angularDamping") ) {
            return angularDamping;
        }
        if (HX_FIELD_EQ(inName,"linearVelocity") ) {
            return linearVelocity;
        }
        break;
    case 15:
        if (HX_FIELD_EQ(inName,"angularVelocity") ) {
            return angularVelocity;
        }
    }
    return super::__Field(inName,inCallProp);
}

Dynamic B2BodyDef_obj::__SetField(const ::String &inName,const Dynamic &inValue,bool inCallProp)
{
    switch(inName.length) {
    case 4:
        if (HX_FIELD_EQ(inName,"mass") ) {
            mass=inValue.Cast< Float >();
            return inValue;
        }
        if (HX_FIELD_EQ(inName,"type") ) {
            type=inValue.Cast< int >();
            return inValue;
        }
        break;
    case 5:
        if (HX_FIELD_EQ(inName,"aMass") ) {
            aMass=inValue.Cast< Float >();
            return inValue;
        }
        if (HX_FIELD_EQ(inName,"awake") ) {
            awake=inValue.Cast< bool >();
            return inValue;
        }
        if (HX_FIELD_EQ(inName,"angle") ) {
            angle=inValue.Cast< Float >();
            return inValue;
        }
        break;
    case 6:
        if (HX_FIELD_EQ(inName,"active") ) {
            active=inValue.Cast< bool >();
            return inValue;
        }
        if (HX_FIELD_EQ(inName,"bullet") ) {
            bullet=inValue.Cast< bool >();
            return inValue;
        }
        break;
    case 7:
        if (HX_FIELD_EQ(inName,"groupID") ) {
            groupID=inValue.Cast< int >();
            return inValue;
        }
        break;
    case 8:
        if (HX_FIELD_EQ(inName,"friction") ) {
            friction=inValue.Cast< Float >();
            return inValue;
        }
        if (HX_FIELD_EQ(inName,"userData") ) {
            userData=inValue.Cast< Dynamic >();
            return inValue;
        }
        if (HX_FIELD_EQ(inName,"position") ) {
            position=inValue.Cast< ::box2D::common::math::B2Vec2 >();
            return inValue;
        }
        break;
    case 10:
        if (HX_FIELD_EQ(inName,"bounciness") ) {
            bounciness=inValue.Cast< Float >();
            return inValue;
        }
        if (HX_FIELD_EQ(inName,"allowSleep") ) {
            allowSleep=inValue.Cast< bool >();
            return inValue;
        }
        break;
    case 12:
        if (HX_FIELD_EQ(inName,"inertiaScale") ) {
            inertiaScale=inValue.Cast< Float >();
            return inValue;
        }
        break;
    case 13:
        if (HX_FIELD_EQ(inName,"ignoreGravity") ) {
            ignoreGravity=inValue.Cast< bool >();
            return inValue;
        }
        if (HX_FIELD_EQ(inName,"fixedRotation") ) {
            fixedRotation=inValue.Cast< bool >();
            return inValue;
        }
        if (HX_FIELD_EQ(inName,"linearDamping") ) {
            linearDamping=inValue.Cast< Float >();
            return inValue;
        }
        break;
    case 14:
        if (HX_FIELD_EQ(inName,"angularDamping") ) {
            angularDamping=inValue.Cast< Float >();
            return inValue;
        }
        if (HX_FIELD_EQ(inName,"linearVelocity") ) {
            linearVelocity=inValue.Cast< ::box2D::common::math::B2Vec2 >();
            return inValue;
        }
        break;
    case 15:
        if (HX_FIELD_EQ(inName,"angularVelocity") ) {
            angularVelocity=inValue.Cast< Float >();
            return inValue;
        }
    }
    return super::__SetField(inName,inValue,inCallProp);
}

void B2BodyDef_obj::__GetFields(Array< ::String> &outFields)
{
    outFields->push(HX_CSTRING("aMass"));
    outFields->push(HX_CSTRING("mass"));
    outFields->push(HX_CSTRING("bounciness"));
    outFields->push(HX_CSTRING("friction"));
    outFields->push(HX_CSTRING("ignoreGravity"));
    outFields->push(HX_CSTRING("groupID"));
    outFields->push(HX_CSTRING("inertiaScale"));
    outFields->push(HX_CSTRING("userData"));
    outFields->push(HX_CSTRING("active"));
    outFields->push(HX_CSTRING("bullet"));
    outFields->push(HX_CSTRING("fixedRotation"));
    outFields->push(HX_CSTRING("awake"));
    outFields->push(HX_CSTRING("allowSleep"));
    outFields->push(HX_CSTRING("angularDamping"));
    outFields->push(HX_CSTRING("linearDamping"));
    outFields->push(HX_CSTRING("angularVelocity"));
    outFields->push(HX_CSTRING("linearVelocity"));
    outFields->push(HX_CSTRING("angle"));
    outFields->push(HX_CSTRING("position"));
    outFields->push(HX_CSTRING("type"));
    super::__GetFields(outFields);
};

static ::String sStaticFields[] = {
    String(null())
};

static ::String sMemberFields[] = {
    HX_CSTRING("aMass"),
    HX_CSTRING("mass"),
    HX_CSTRING("bounciness"),
    HX_CSTRING("friction"),
    HX_CSTRING("ignoreGravity"),
    HX_CSTRING("groupID"),
    HX_CSTRING("inertiaScale"),
    HX_CSTRING("userData"),
    HX_CSTRING("active"),
    HX_CSTRING("bullet"),
    HX_CSTRING("fixedRotation"),
    HX_CSTRING("awake"),
    HX_CSTRING("allowSleep"),
    HX_CSTRING("angularDamping"),
    HX_CSTRING("linearDamping"),
    HX_CSTRING("angularVelocity"),
    HX_CSTRING("linearVelocity"),
    HX_CSTRING("angle"),
    HX_CSTRING("position"),
    HX_CSTRING("type"),
    String(null())
};

static void sMarkStatics(HX_MARK_PARAMS) {
    HX_MARK_MEMBER_NAME(B2BodyDef_obj::__mClass,"__mClass");
};

static void sVisitStatics(HX_VISIT_PARAMS) {
    HX_VISIT_MEMBER_NAME(B2BodyDef_obj::__mClass,"__mClass");
};

Class B2BodyDef_obj::__mClass;

void B2BodyDef_obj::__register()
{
    hx::Static(__mClass) = hx::RegisterClass(HX_CSTRING("box2D.dynamics.B2BodyDef"), hx::TCanCast< B2BodyDef_obj> ,sStaticFields,sMemberFields,
                           &__CreateEmpty, &__Create,
                           &super::__SGetClass(), 0, sMarkStatics, sVisitStatics);
}

void B2BodyDef_obj::__boot()
{
}

} // end namespace box2D
void ZNPNode_ZPP_GeomPoly_obj::__boot()
{
	zpp_pool= null();
}
namespace media{

Void SoundLoaderContext_obj::__construct(hx::Null< Float >  __o_bufferTime,hx::Null< bool >  __o_checkPolicyFile)
{
HX_STACK_FRAME("openfl.media.SoundLoaderContext","new",0xafd95147,"openfl.media.SoundLoaderContext.new","openfl/media/SoundLoaderContext.hx",154,0x79afda07)
HX_STACK_THIS(this)
HX_STACK_ARG(__o_bufferTime,"bufferTime")
HX_STACK_ARG(__o_checkPolicyFile,"checkPolicyFile")
Float bufferTime = __o_bufferTime.Default(0);
bool checkPolicyFile = __o_checkPolicyFile.Default(false);
{
	HX_STACK_LINE(156)
	this->bufferTime = bufferTime;
	HX_STACK_LINE(157)
	this->checkPolicyFile = checkPolicyFile;
}
;
	return null();
}

//SoundLoaderContext_obj::~SoundLoaderContext_obj() { }

Dynamic SoundLoaderContext_obj::__CreateEmpty() { return  new SoundLoaderContext_obj; }
hx::ObjectPtr< SoundLoaderContext_obj > SoundLoaderContext_obj::__new(hx::Null< Float >  __o_bufferTime,hx::Null< bool >  __o_checkPolicyFile)
{  hx::ObjectPtr< SoundLoaderContext_obj > result = new SoundLoaderContext_obj();
	result->__construct(__o_bufferTime,__o_checkPolicyFile);
	return result;}

Dynamic SoundLoaderContext_obj::__Create(hx::DynamicArray inArgs)
{  hx::ObjectPtr< SoundLoaderContext_obj > result = new SoundLoaderContext_obj();
	result->__construct(inArgs[0],inArgs[1]);
	return result;}


SoundLoaderContext_obj::SoundLoaderContext_obj()
{
}

Dynamic SoundLoaderContext_obj::__Field(const ::String &inName,bool inCallProp)
{
	switch(inName.length) {
	case 10:
		if (HX_FIELD_EQ(inName,"bufferTime") ) { return bufferTime; }
		break;
	case 15:
		if (HX_FIELD_EQ(inName,"checkPolicyFile") ) { return checkPolicyFile; }
	}
	return super::__Field(inName,inCallProp);
}

Dynamic SoundLoaderContext_obj::__SetField(const ::String &inName,const Dynamic &inValue,bool inCallProp)
{
	switch(inName.length) {
	case 10:
		if (HX_FIELD_EQ(inName,"bufferTime") ) { bufferTime=inValue.Cast< Float >(); return inValue; }
		break;
	case 15:
		if (HX_FIELD_EQ(inName,"checkPolicyFile") ) { checkPolicyFile=inValue.Cast< bool >(); return inValue; }
	}
	return super::__SetField(inName,inValue,inCallProp);
}

void SoundLoaderContext_obj::__GetFields(Array< ::String> &outFields)
{
	outFields->push(HX_CSTRING("bufferTime"));
	outFields->push(HX_CSTRING("checkPolicyFile"));
	super::__GetFields(outFields);
};

static ::String sStaticFields[] = {
	String(null()) };

#if HXCPP_SCRIPTABLE
static hx::StorageInfo sMemberStorageInfo[] = {
	{hx::fsFloat,(int)offsetof(SoundLoaderContext_obj,bufferTime),HX_CSTRING("bufferTime")},
	{hx::fsBool,(int)offsetof(SoundLoaderContext_obj,checkPolicyFile),HX_CSTRING("checkPolicyFile")},
	{ hx::fsUnknown, 0, null()}
};
#endif

static ::String sMemberFields[] = {
	HX_CSTRING("bufferTime"),
	HX_CSTRING("checkPolicyFile"),
	String(null()) };

static void sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(SoundLoaderContext_obj::__mClass,"__mClass");
};

#ifdef HXCPP_VISIT_ALLOCS
static void sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(SoundLoaderContext_obj::__mClass,"__mClass");
};

#endif

Class SoundLoaderContext_obj::__mClass;

void SoundLoaderContext_obj::__register()
{
	hx::Static(__mClass) = hx::RegisterClass(HX_CSTRING("openfl.media.SoundLoaderContext"), hx::TCanCast< SoundLoaderContext_obj> ,sStaticFields,sMemberFields,
	&__CreateEmpty, &__Create,
	&super::__SGetClass(), 0, sMarkStatics
#ifdef HXCPP_VISIT_ALLOCS
    , sVisitStatics
#endif
#ifdef HXCPP_SCRIPTABLE
    , sMemberStorageInfo
#endif
);
}

void SoundLoaderContext_obj::__boot()
{
}

} // end namespace openfl
示例#4
0
sub_generator::sub_generator()
{
	null();
}
示例#5
0
Void SystemEvents_obj::__construct()
{
	return null();
}
示例#6
0
					while((true)){
						HX_STACK_LINE(83)
						if ((!(((_g1 < _g))))){
							HX_STACK_LINE(83)
							break;
						}
						HX_STACK_LINE(83)
						int i = (_g1)++;		HX_STACK_VAR(i,"i");
						HX_STACK_LINE(86)
						::__hxcpp_memory_set_i32(this->bytes,(int(i) << int((int)2)),ints->__get((i + start)));
					}
				}
			}
			else{
				HX_STACK_LINE(95)
				super::__construct(bufferOrArray,start,(  (((length != null()))) ? Dynamic((int(length) << int((int)2))) : Dynamic(null()) ));
				HX_STACK_LINE(97)
				if (((((int(this->byteLength) & int((int)3))) > (int)0))){
					HX_STACK_LINE(99)
					HX_STACK_DO_THROW(HX_CSTRING("Invalid array size"));
				}
				HX_STACK_LINE(103)
				this->length = (int(this->byteLength) >> int((int)2));
				HX_STACK_LINE(105)
				if ((((int(this->length) << int((int)2)) != this->byteLength))){
					HX_STACK_LINE(107)
					HX_STACK_DO_THROW(HX_CSTRING("Invalid length multiple"));
				}
			}
		}
	}
示例#7
0
Dynamic Xml_obj::__CreateEmpty() { return  new Xml_obj; }
hx::ObjectPtr< Xml_obj > Xml_obj::__new()
{  hx::ObjectPtr< Xml_obj > result = new Xml_obj();
	result->__construct();
	return result;}

Dynamic Xml_obj::__Create(hx::DynamicArray inArgs)
{  hx::ObjectPtr< Xml_obj > result = new Xml_obj();
	result->__construct();
	return result;}

void Xml_obj::__init__() {
HX_STACK_FRAME("Xml","__init__","Xml.__init__","Xml.hx",403)
{
	HX_STACK_LINE(404)
	::Xml_obj::PCData = ::Type_obj::createEnum(hx::ClassOf< ::XmlType >(),HX_CSTRING("__"),null());
	HX_STACK_LINE(405)
	::Xml_obj::Element = ::Type_obj::createEnum(hx::ClassOf< ::XmlType >(),HX_CSTRING("__"),null());
	HX_STACK_LINE(406)
	::Xml_obj::CData = ::Type_obj::createEnum(hx::ClassOf< ::XmlType >(),HX_CSTRING("__"),null());
	HX_STACK_LINE(407)
	::Xml_obj::Comment = ::Type_obj::createEnum(hx::ClassOf< ::XmlType >(),HX_CSTRING("__"),null());
	HX_STACK_LINE(408)
	::Xml_obj::DocType = ::Type_obj::createEnum(hx::ClassOf< ::XmlType >(),HX_CSTRING("__"),null());
	HX_STACK_LINE(409)
	::Xml_obj::ProcessingInstruction = ::Type_obj::createEnum(hx::ClassOf< ::XmlType >(),HX_CSTRING("__"),null());
	HX_STACK_LINE(410)
	::Xml_obj::Document = ::Type_obj::createEnum(hx::ClassOf< ::XmlType >(),HX_CSTRING("__"),null());
	HX_STACK_LINE(411)
	::__hxcpp_enum_force(::Xml_obj::PCData,HX_CSTRING("pcdata"),(int)0);
	HX_STACK_LINE(412)
示例#8
0
文件: Object.cpp 项目: Gama11/hxcpp
Dynamic Object::__GetItem(int inIndex) const { return null(); }
示例#9
0
文件: Object.cpp 项目: Gama11/hxcpp
Dynamic Object::__SetItem(int inIndex,Dynamic) { return null();  }
示例#10
0
文件: Object.cpp 项目: Gama11/hxcpp
Dynamic Object::__SetField(const String &inField,const Dynamic &inValue, hx::PropertyAccess inCallProp)
{
	throw Dynamic( HX_CSTRING("Invalid field:") + inField );
	return null();
}
示例#11
0
文件: Object.cpp 项目: Gama11/hxcpp
namespace hx
{

String sNone[] = { String(null()) };

Dynamic Object::__IField(int inFieldID)
{
   return __Field( __hxcpp_field_from_id(inFieldID), HX_PROP_DYNAMIC );
}

double Object::__INumField(int inFieldID)
{
	return __IField(inFieldID);
}

Dynamic *Object::__GetFieldMap() { return 0; }


int Object::__Compare(const Object *inRHS) const
{
   return (int)(inRHS-this);
}


Dynamic Object::__Field(const String &inString, hx::PropertyAccess inCallProp)
{
   #if 0
   // Will be true for 'Implements dynamic'
   if (inCallProp && __GetFieldMap())
   {
      Dynamic resolve = __Field(HX_CSTRING("resolve"), false);
      if (resolve.mPtr)
         return resolve(inString);
   }
   #endif
   return null();
}

bool Object::__HasField(const String &inString)
{
   return false;
}
Dynamic Object::__Run(const Array<Dynamic> &inArgs) { return 0; }
Dynamic Object::__GetItem(int inIndex) const { return null(); }
Dynamic Object::__SetItem(int inIndex,Dynamic) { return null();  }
DynamicArray Object::__EnumParams() { return DynamicArray(); }
String Object::__Tag() const { return HX_CSTRING("<not enum>"); }
int Object::__Index() const { return -1; }

void Object::__SetThis(Dynamic inThis) { }

bool Object::__Is(Dynamic inClass ) const { return __Is(inClass.GetPtr()); }

hx::Class Object__mClass;

bool AlwaysCast(Object *inPtr) { return inPtr!=0; }



#ifdef HXCPP_SCRIPTABLE

class Object__scriptable : public hx::Object {
   typedef Object__scriptable __ME;
   void __construct() { }
   typedef hx::Object super;
   typedef hx::Object __superString;
   HX_DEFINE_SCRIPTABLE(HX_ARR_LIST0);
	HX_DEFINE_SCRIPTABLE_DYNAMIC;
};

hx::ScriptFunction Object::__script_construct;

static void __s_toString(hx::CppiaCtx *ctx) {
   ctx->returnString((ctx->getThis())->toString());
}
static hx::ScriptNamedFunction __scriptableFunctions[] = {
  hx::ScriptNamedFunction("toString",__s_toString,"s"),
  hx::ScriptNamedFunction(0,0,0) };

#endif

void Object::__boot()
{
   Static(Object__mClass) = hx::RegisterClass(HX_CSTRING("Dynamic"),AlwaysCast,sNone,sNone,0,0, 0, 0 );

   #ifdef HXCPP_SCRIPTABLE
   hx::ScriptableRegisterClass( HX_CSTRING("hx.Object"), (int)sizeof(hx::Object__scriptable), __scriptableFunctions, Object__scriptable::__script_create, Object::__script_construct );
   #endif
}


hx::Class &Object::__SGetClass() { return Object__mClass; }

hx::Class Object::__GetClass() const { return Object__mClass; }

hx::FieldRef Object::__FieldRef(const String &inString) { return hx::FieldRef(this,inString); }

String Object::__ToString() const { return HX_CSTRING("Object"); }

const char * Object::__CStr() const { return __ToString().__CStr(); }


Dynamic Object::__SetField(const String &inField,const Dynamic &inValue, hx::PropertyAccess inCallProp)
{
	throw Dynamic( HX_CSTRING("Invalid field:") + inField );
	return null();
}

Dynamic Object::__run()
{
   return __Run(Array_obj<Dynamic>::__new());
}

Dynamic Object::__run(D a)
{
   return __Run( Array_obj<Dynamic>::__new(0,1) << a );
}

Dynamic Object::__run(D a,D b)
{
   return __Run( Array_obj<Dynamic>::__new(0,2) << a << b );
}

Dynamic Object::__run(D a,D b,D c)
{
   return __Run( Array_obj<Dynamic>::__new(0,3) << a << b << c);
}
Dynamic Object::__run(D a,D b,D c,D d)
{
   return __Run( Array_obj<Dynamic>::__new(0,4) << a << b << c << d);
}
Dynamic Object::__run(D a,D b,D c,D d,D e)
{
   return __Run( Array_obj<Dynamic>::__new(0,5) << a << b << c << d << e);
}

void Object::__GetFields(Array<String> &outFields)
{
}


String Object::toString()
{
   Dynamic *m = __GetFieldMap();
   if (m)
   {
      Dynamic func;
      if (FieldMapGet(m,HX_CSTRING("toString"),func))
         return func();
   }
   return __ToString();
}


} // end namespace hx
示例#12
0
Void URLRequestMethod_obj::__construct()
{
	return null();
}
示例#13
0
namespace net{

Void URLRequestMethod_obj::__construct()
{
	return null();
}

URLRequestMethod_obj::~URLRequestMethod_obj() { }

Dynamic URLRequestMethod_obj::__CreateEmpty() { return  new URLRequestMethod_obj; }
hx::ObjectPtr< URLRequestMethod_obj > URLRequestMethod_obj::__new()
{  hx::ObjectPtr< URLRequestMethod_obj > result = new URLRequestMethod_obj();
	result->__construct();
	return result;}

Dynamic URLRequestMethod_obj::__Create(hx::DynamicArray inArgs)
{  hx::ObjectPtr< URLRequestMethod_obj > result = new URLRequestMethod_obj();
	result->__construct();
	return result;}


URLRequestMethod_obj::URLRequestMethod_obj()
{
}

void URLRequestMethod_obj::__Mark(HX_MARK_PARAMS)
{
	HX_MARK_BEGIN_CLASS(URLRequestMethod);
	HX_MARK_END_CLASS();
}

void URLRequestMethod_obj::__Visit(HX_VISIT_PARAMS)
{
}

Dynamic URLRequestMethod_obj::__Field(const ::String &inName,bool inCallProp)
{
	return super::__Field(inName,inCallProp);
}

Dynamic URLRequestMethod_obj::__SetField(const ::String &inName,const Dynamic &inValue,bool inCallProp)
{
	return super::__SetField(inName,inValue,inCallProp);
}

void URLRequestMethod_obj::__GetFields(Array< ::String> &outFields)
{
	super::__GetFields(outFields);
};

static ::String sStaticFields[] = {
	String(null()) };

static ::String sMemberFields[] = {
	String(null()) };

static void sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(URLRequestMethod_obj::__mClass,"__mClass");
};

static void sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(URLRequestMethod_obj::__mClass,"__mClass");
};

Class URLRequestMethod_obj::__mClass;

void URLRequestMethod_obj::__register()
{
	hx::Static(__mClass) = hx::RegisterClass(HX_CSTRING("native.net.URLRequestMethod"), hx::TCanCast< URLRequestMethod_obj> ,sStaticFields,sMemberFields,
	&__CreateEmpty, &__Create,
	&super::__SGetClass(), 0, sMarkStatics, sVisitStatics);
}

void URLRequestMethod_obj::__boot()
{
}

} // end namespace native
示例#14
0
	HX_STACK_LINE(17)
	this->MAX_HEALTH = (int)10;
	HX_STACK_LINE(42)
	super::__construct(X,Y,null());
	HX_STACK_LINE(45)
	this->drag->set((this->RUN_SPEED * (int)6),(this->JUMP_SPEED * (int)5));
	HX_STACK_LINE(46)
	this->maxVelocity->set(this->RUN_SPEED,this->GRAVITY);
	HX_STACK_LINE(47)
	this->acceleration->set_y(this->GRAVITY);
	HX_STACK_LINE(51)
	this->_target = Target;
	HX_STACK_LINE(53)
	this->health = this->MAX_HEALTH;
	HX_STACK_LINE(58)
	this->makeGraphic((int)12,(int)16,(int)-65536,null(),null());
	HX_STACK_LINE(61)
	this->set_width((int)10);
	HX_STACK_LINE(62)
	this->set_height((int)16);
	HX_STACK_LINE(65)
	this->offset->set_x((int)2);
	HX_STACK_LINE(68)
	this->animation->add(HX_CSTRING("idle"),Array_obj< int >::__new().Add((int)0).Add((int)1),(int)5,true);
	HX_STACK_LINE(69)
	this->animation->add(HX_CSTRING("walk"),Array_obj< int >::__new().Add((int)7).Add((int)8).Add((int)9).Add((int)10).Add((int)11),(int)10,true);
	HX_STACK_LINE(70)
	this->animation->add(HX_CSTRING("run"),Array_obj< int >::__new().Add((int)2).Add((int)3).Add((int)4).Add((int)5).Add((int)6),(int)10,true);
	HX_STACK_LINE(71)
	this->animation->add(HX_CSTRING("jump"),Array_obj< int >::__new().Add((int)3).Add((int)4),(int)4,false);
	HX_STACK_LINE(72)
示例#15
0
 /// Destroy a logger implementation.
 void destroy(impl_type& impl)
 {
   delete impl;
   impl = null();
 }
示例#16
0
#include <haxe/ds/StringMap.h>
#endif
#ifndef INCLUDED_haxe_io_Path
#include <haxe/io/Path.h>
#endif

Void LevelLoader_obj::__construct(Dynamic level)
{
HX_STACK_FRAME("LevelLoader","new",0x19e79d09,"LevelLoader.new","LevelLoader.hx",25,0x32a09687)
HX_STACK_THIS(this)
HX_STACK_ARG(level,"level")
{
	HX_STACK_LINE(26)
	super::__construct(level);
	HX_STACK_LINE(28)
	::flixel::group::FlxGroup _g = ::flixel::group::FlxGroup_obj::__new(null());		HX_STACK_VAR(_g,"_g");
	HX_STACK_LINE(28)
	this->foregroundTiles = _g;
	HX_STACK_LINE(29)
	::flixel::group::FlxGroup _g1 = ::flixel::group::FlxGroup_obj::__new(null());		HX_STACK_VAR(_g1,"_g1");
	HX_STACK_LINE(29)
	this->backgroundTiles = _g1;
	HX_STACK_LINE(31)
	::flixel::FlxG_obj::camera->setBounds((int)0,(int)0,this->fullWidth,this->fullHeight,true);
	HX_STACK_LINE(33)
	{
		HX_STACK_LINE(33)
		int _g2 = (int)0;		HX_STACK_VAR(_g2,"_g2");
		HX_STACK_LINE(33)
		Array< ::Dynamic > _g11 = this->layers;		HX_STACK_VAR(_g11,"_g11");
		HX_STACK_LINE(33)
示例#17
0
namespace particle{

Void GravityModeData_obj::__construct()
{
{
}
;
	return null();
}

GravityModeData_obj::~GravityModeData_obj() { }

Dynamic GravityModeData_obj::__CreateEmpty() { return  new GravityModeData_obj; }
hx::ObjectPtr< GravityModeData_obj > GravityModeData_obj::__new()
{  hx::ObjectPtr< GravityModeData_obj > result = new GravityModeData_obj();
	result->__construct();
	return result;}

Dynamic GravityModeData_obj::__Create(hx::DynamicArray inArgs)
{  hx::ObjectPtr< GravityModeData_obj > result = new GravityModeData_obj();
	result->__construct();
	return result;}


GravityModeData_obj::GravityModeData_obj()
{
}

void GravityModeData_obj::__Mark(HX_MARK_PARAMS)
{
	HX_MARK_BEGIN_CLASS(GravityModeData);
	HX_MARK_MEMBER_NAME(keepSize,"keepSize");
	HX_MARK_MEMBER_NAME(keepColor,"keepColor");
	HX_MARK_MEMBER_NAME(keepRotationAngle,"keepRotationAngle");
	HX_MARK_MEMBER_NAME(maxParticles,"maxParticles");
	HX_MARK_MEMBER_NAME(duration,"duration");
	HX_MARK_MEMBER_NAME(lifespan,"lifespan");
	HX_MARK_MEMBER_NAME(lifespanVariance,"lifespanVariance");
	HX_MARK_MEMBER_NAME(startSize,"startSize");
	HX_MARK_MEMBER_NAME(startSizeVariance,"startSizeVariance");
	HX_MARK_MEMBER_NAME(endSize,"endSize");
	HX_MARK_MEMBER_NAME(endSizeVariance,"endSizeVariance");
	HX_MARK_MEMBER_NAME(startRotation,"startRotation");
	HX_MARK_MEMBER_NAME(startRotationVariance,"startRotationVariance");
	HX_MARK_MEMBER_NAME(endRotation,"endRotation");
	HX_MARK_MEMBER_NAME(endRotationVariance,"endRotationVariance");
	HX_MARK_MEMBER_NAME(startColor,"startColor");
	HX_MARK_MEMBER_NAME(startColorVariance,"startColorVariance");
	HX_MARK_MEMBER_NAME(endColor,"endColor");
	HX_MARK_MEMBER_NAME(endColorVariance,"endColorVariance");
	HX_MARK_MEMBER_NAME(emitterPosition,"emitterPosition");
	HX_MARK_MEMBER_NAME(emitterPosVariance,"emitterPosVariance");
	HX_MARK_MEMBER_NAME(emitterAngle,"emitterAngle");
	HX_MARK_MEMBER_NAME(emitterAngleVariance,"emitterAngleVariance");
	HX_MARK_MEMBER_NAME(emitRate,"emitRate");
	HX_MARK_MEMBER_NAME(speed,"speed");
	HX_MARK_MEMBER_NAME(speedVariance,"speedVariance");
	HX_MARK_MEMBER_NAME(gravity,"gravity");
	HX_MARK_MEMBER_NAME(radialAcceleration,"radialAcceleration");
	HX_MARK_MEMBER_NAME(radialAccelVariance,"radialAccelVariance");
	HX_MARK_MEMBER_NAME(tangentialAcceleration,"tangentialAcceleration");
	HX_MARK_MEMBER_NAME(tangentialAccelVariance,"tangentialAccelVariance");
	HX_MARK_END_CLASS();
}

Dynamic GravityModeData_obj::__Field(const ::String &inName)
{
	switch(inName.length) {
	case 5:
		if (HX_FIELD_EQ(inName,"speed") ) { return speed; }
		break;
	case 7:
		if (HX_FIELD_EQ(inName,"endSize") ) { return endSize; }
		if (HX_FIELD_EQ(inName,"gravity") ) { return gravity; }
		break;
	case 8:
		if (HX_FIELD_EQ(inName,"keepSize") ) { return keepSize; }
		if (HX_FIELD_EQ(inName,"duration") ) { return duration; }
		if (HX_FIELD_EQ(inName,"lifespan") ) { return lifespan; }
		if (HX_FIELD_EQ(inName,"endColor") ) { return endColor; }
		if (HX_FIELD_EQ(inName,"emitRate") ) { return emitRate; }
		break;
	case 9:
		if (HX_FIELD_EQ(inName,"keepColor") ) { return keepColor; }
		if (HX_FIELD_EQ(inName,"startSize") ) { return startSize; }
		break;
	case 10:
		if (HX_FIELD_EQ(inName,"startColor") ) { return startColor; }
		break;
	case 11:
		if (HX_FIELD_EQ(inName,"endRotation") ) { return endRotation; }
		break;
	case 12:
		if (HX_FIELD_EQ(inName,"maxParticles") ) { return maxParticles; }
		if (HX_FIELD_EQ(inName,"emitterAngle") ) { return emitterAngle; }
		break;
	case 13:
		if (HX_FIELD_EQ(inName,"startRotation") ) { return startRotation; }
		if (HX_FIELD_EQ(inName,"speedVariance") ) { return speedVariance; }
		break;
	case 15:
		if (HX_FIELD_EQ(inName,"endSizeVariance") ) { return endSizeVariance; }
		if (HX_FIELD_EQ(inName,"emitterPosition") ) { return emitterPosition; }
		break;
	case 16:
		if (HX_FIELD_EQ(inName,"lifespanVariance") ) { return lifespanVariance; }
		if (HX_FIELD_EQ(inName,"endColorVariance") ) { return endColorVariance; }
		break;
	case 17:
		if (HX_FIELD_EQ(inName,"keepRotationAngle") ) { return keepRotationAngle; }
		if (HX_FIELD_EQ(inName,"startSizeVariance") ) { return startSizeVariance; }
		break;
	case 18:
		if (HX_FIELD_EQ(inName,"startColorVariance") ) { return startColorVariance; }
		if (HX_FIELD_EQ(inName,"emitterPosVariance") ) { return emitterPosVariance; }
		if (HX_FIELD_EQ(inName,"radialAcceleration") ) { return radialAcceleration; }
		break;
	case 19:
		if (HX_FIELD_EQ(inName,"endRotationVariance") ) { return endRotationVariance; }
		if (HX_FIELD_EQ(inName,"radialAccelVariance") ) { return radialAccelVariance; }
		break;
	case 20:
		if (HX_FIELD_EQ(inName,"emitterAngleVariance") ) { return emitterAngleVariance; }
		break;
	case 21:
		if (HX_FIELD_EQ(inName,"startRotationVariance") ) { return startRotationVariance; }
		break;
	case 22:
		if (HX_FIELD_EQ(inName,"tangentialAcceleration") ) { return tangentialAcceleration; }
		break;
	case 23:
		if (HX_FIELD_EQ(inName,"tangentialAccelVariance") ) { return tangentialAccelVariance; }
	}
	return super::__Field(inName);
}

Dynamic GravityModeData_obj::__SetField(const ::String &inName,const Dynamic &inValue)
{
	switch(inName.length) {
	case 5:
		if (HX_FIELD_EQ(inName,"speed") ) { speed=inValue.Cast< double >(); return inValue; }
		break;
	case 7:
		if (HX_FIELD_EQ(inName,"endSize") ) { endSize=inValue.Cast< double >(); return inValue; }
		if (HX_FIELD_EQ(inName,"gravity") ) { gravity=inValue.Cast< ::com::mybo::framework::particle::Vector >(); return inValue; }
		break;
	case 8:
		if (HX_FIELD_EQ(inName,"keepSize") ) { keepSize=inValue.Cast< bool >(); return inValue; }
		if (HX_FIELD_EQ(inName,"duration") ) { duration=inValue.Cast< double >(); return inValue; }
		if (HX_FIELD_EQ(inName,"lifespan") ) { lifespan=inValue.Cast< double >(); return inValue; }
		if (HX_FIELD_EQ(inName,"endColor") ) { endColor=inValue.Cast< ::com::mybo::framework::particle::RGBA >(); return inValue; }
		if (HX_FIELD_EQ(inName,"emitRate") ) { emitRate=inValue.Cast< int >(); return inValue; }
		break;
	case 9:
		if (HX_FIELD_EQ(inName,"keepColor") ) { keepColor=inValue.Cast< bool >(); return inValue; }
		if (HX_FIELD_EQ(inName,"startSize") ) { startSize=inValue.Cast< double >(); return inValue; }
		break;
	case 10:
		if (HX_FIELD_EQ(inName,"startColor") ) { startColor=inValue.Cast< ::com::mybo::framework::particle::RGBA >(); return inValue; }
		break;
	case 11:
		if (HX_FIELD_EQ(inName,"endRotation") ) { endRotation=inValue.Cast< double >(); return inValue; }
		break;
	case 12:
		if (HX_FIELD_EQ(inName,"maxParticles") ) { maxParticles=inValue.Cast< int >(); return inValue; }
		if (HX_FIELD_EQ(inName,"emitterAngle") ) { emitterAngle=inValue.Cast< double >(); return inValue; }
		break;
	case 13:
		if (HX_FIELD_EQ(inName,"startRotation") ) { startRotation=inValue.Cast< double >(); return inValue; }
		if (HX_FIELD_EQ(inName,"speedVariance") ) { speedVariance=inValue.Cast< double >(); return inValue; }
		break;
	case 15:
		if (HX_FIELD_EQ(inName,"endSizeVariance") ) { endSizeVariance=inValue.Cast< double >(); return inValue; }
		if (HX_FIELD_EQ(inName,"emitterPosition") ) { emitterPosition=inValue.Cast< ::com::mybo::framework::particle::Vector >(); return inValue; }
		break;
	case 16:
		if (HX_FIELD_EQ(inName,"lifespanVariance") ) { lifespanVariance=inValue.Cast< double >(); return inValue; }
		if (HX_FIELD_EQ(inName,"endColorVariance") ) { endColorVariance=inValue.Cast< ::com::mybo::framework::particle::RGBA >(); return inValue; }
		break;
	case 17:
		if (HX_FIELD_EQ(inName,"keepRotationAngle") ) { keepRotationAngle=inValue.Cast< bool >(); return inValue; }
		if (HX_FIELD_EQ(inName,"startSizeVariance") ) { startSizeVariance=inValue.Cast< double >(); return inValue; }
		break;
	case 18:
		if (HX_FIELD_EQ(inName,"startColorVariance") ) { startColorVariance=inValue.Cast< ::com::mybo::framework::particle::RGBA >(); return inValue; }
		if (HX_FIELD_EQ(inName,"emitterPosVariance") ) { emitterPosVariance=inValue.Cast< ::com::mybo::framework::particle::Vector >(); return inValue; }
		if (HX_FIELD_EQ(inName,"radialAcceleration") ) { radialAcceleration=inValue.Cast< double >(); return inValue; }
		break;
	case 19:
		if (HX_FIELD_EQ(inName,"endRotationVariance") ) { endRotationVariance=inValue.Cast< double >(); return inValue; }
		if (HX_FIELD_EQ(inName,"radialAccelVariance") ) { radialAccelVariance=inValue.Cast< double >(); return inValue; }
		break;
	case 20:
		if (HX_FIELD_EQ(inName,"emitterAngleVariance") ) { emitterAngleVariance=inValue.Cast< double >(); return inValue; }
		break;
	case 21:
		if (HX_FIELD_EQ(inName,"startRotationVariance") ) { startRotationVariance=inValue.Cast< double >(); return inValue; }
		break;
	case 22:
		if (HX_FIELD_EQ(inName,"tangentialAcceleration") ) { tangentialAcceleration=inValue.Cast< double >(); return inValue; }
		break;
	case 23:
		if (HX_FIELD_EQ(inName,"tangentialAccelVariance") ) { tangentialAccelVariance=inValue.Cast< double >(); return inValue; }
	}
	return super::__SetField(inName,inValue);
}

void GravityModeData_obj::__GetFields(Array< ::String> &outFields)
{
	outFields->push(HX_CSTRING("keepSize"));
	outFields->push(HX_CSTRING("keepColor"));
	outFields->push(HX_CSTRING("keepRotationAngle"));
	outFields->push(HX_CSTRING("maxParticles"));
	outFields->push(HX_CSTRING("duration"));
	outFields->push(HX_CSTRING("lifespan"));
	outFields->push(HX_CSTRING("lifespanVariance"));
	outFields->push(HX_CSTRING("startSize"));
	outFields->push(HX_CSTRING("startSizeVariance"));
	outFields->push(HX_CSTRING("endSize"));
	outFields->push(HX_CSTRING("endSizeVariance"));
	outFields->push(HX_CSTRING("startRotation"));
	outFields->push(HX_CSTRING("startRotationVariance"));
	outFields->push(HX_CSTRING("endRotation"));
	outFields->push(HX_CSTRING("endRotationVariance"));
	outFields->push(HX_CSTRING("startColor"));
	outFields->push(HX_CSTRING("startColorVariance"));
	outFields->push(HX_CSTRING("endColor"));
	outFields->push(HX_CSTRING("endColorVariance"));
	outFields->push(HX_CSTRING("emitterPosition"));
	outFields->push(HX_CSTRING("emitterPosVariance"));
	outFields->push(HX_CSTRING("emitterAngle"));
	outFields->push(HX_CSTRING("emitterAngleVariance"));
	outFields->push(HX_CSTRING("emitRate"));
	outFields->push(HX_CSTRING("speed"));
	outFields->push(HX_CSTRING("speedVariance"));
	outFields->push(HX_CSTRING("gravity"));
	outFields->push(HX_CSTRING("radialAcceleration"));
	outFields->push(HX_CSTRING("radialAccelVariance"));
	outFields->push(HX_CSTRING("tangentialAcceleration"));
	outFields->push(HX_CSTRING("tangentialAccelVariance"));
	super::__GetFields(outFields);
};

static ::String sStaticFields[] = {
	String(null()) };

static ::String sMemberFields[] = {
	HX_CSTRING("keepSize"),
	HX_CSTRING("keepColor"),
	HX_CSTRING("keepRotationAngle"),
	HX_CSTRING("maxParticles"),
	HX_CSTRING("duration"),
	HX_CSTRING("lifespan"),
	HX_CSTRING("lifespanVariance"),
	HX_CSTRING("startSize"),
	HX_CSTRING("startSizeVariance"),
	HX_CSTRING("endSize"),
	HX_CSTRING("endSizeVariance"),
	HX_CSTRING("startRotation"),
	HX_CSTRING("startRotationVariance"),
	HX_CSTRING("endRotation"),
	HX_CSTRING("endRotationVariance"),
	HX_CSTRING("startColor"),
	HX_CSTRING("startColorVariance"),
	HX_CSTRING("endColor"),
	HX_CSTRING("endColorVariance"),
	HX_CSTRING("emitterPosition"),
	HX_CSTRING("emitterPosVariance"),
	HX_CSTRING("emitterAngle"),
	HX_CSTRING("emitterAngleVariance"),
	HX_CSTRING("emitRate"),
	HX_CSTRING("speed"),
	HX_CSTRING("speedVariance"),
	HX_CSTRING("gravity"),
	HX_CSTRING("radialAcceleration"),
	HX_CSTRING("radialAccelVariance"),
	HX_CSTRING("tangentialAcceleration"),
	HX_CSTRING("tangentialAccelVariance"),
	String(null()) };

static void sMarkStatics(HX_MARK_PARAMS) {
};

Class GravityModeData_obj::__mClass;

void GravityModeData_obj::__register()
{
	Static(__mClass) = hx::RegisterClass(HX_CSTRING("com.mybo.framework.particle.GravityModeData"), hx::TCanCast< GravityModeData_obj> ,sStaticFields,sMemberFields,
	&__CreateEmpty, &__Create,
	&super::__SGetClass(), 0, sMarkStatics);
}

void GravityModeData_obj::__boot()
{
}

} // end namespace com
示例#18
0
::String Path_Impl__obj::win32Separator;

Bool Path_Impl__obj::isValidNix(::Array< ::String > path){
            		HX_BEGIN_LOCAL_FUNC_S0(hx::LocalFunc,_hx_Closure_0) HXARGC(1)
            		Bool _hx_run(::String _){
            			HX_STACK_FRAME("thx._Path.Path_Impl_","isValidNix",0x2025d6c0,"thx._Path.Path_Impl_.isValidNix","thx/Path.hx",29,0xbb25524e)
            			HX_STACK_ARG(_,"_")
HXLINE(  29)			Int _hx_tmp1 = _.indexOf(HX_("/",2f,00,00,00),null());
HXDLIN(  29)			return (_hx_tmp1 < (int)0);
            		}
            		HX_END_LOCAL_FUNC1(return)

            	HX_STACK_FRAME("thx._Path.Path_Impl_","isValidNix",0x2025d6c0,"thx._Path.Path_Impl_.isValidNix","thx/Path.hx",29,0xbb25524e)
            	HX_STACK_ARG(path,"path")
HXLINE(  29)		::Array< ::String > _hx_tmp = path->slice((int)2,null());
HXDLIN(  29)		return ::thx::Arrays_obj::any(_hx_tmp, ::Dynamic(new _hx_Closure_0()));
            	}


STATIC_HX_DEFINE_DYNAMIC_FUNC1(Path_Impl__obj,isValidNix,return )

Bool Path_Impl__obj::isValidWin32(::Array< ::String > path){
            		HX_BEGIN_LOCAL_FUNC_S0(hx::LocalFunc,_hx_Closure_0) HXARGC(1)
            		Bool _hx_run(::String _){
            			HX_STACK_FRAME("thx._Path.Path_Impl_","isValidWin32",0x04ecd55e,"thx._Path.Path_Impl_.isValidWin32","thx/Path.hx",32,0xbb25524e)
            			HX_STACK_ARG(_,"_")
HXLINE(  32)			return !( ::EReg_obj::__new(HX_("[<>:/\\|?*\"]",78,dd,23,e7),HX_("g",67,00,00,00))->match(_));
            		}
            		HX_END_LOCAL_FUNC1(return)
示例#19
0
action_on_grassmannian::action_on_grassmannian()
{
	null();
}
namespace media{

Void SoundLoaderContext_obj::__construct()
{
HX_STACK_FRAME("flash.media.SoundLoaderContext","new",0x3bea6b27,"flash.media.SoundLoaderContext.new","flash/media/SoundLoaderContext.hx",7,0x53489c27)
{
}
;
	return null();
}

//SoundLoaderContext_obj::~SoundLoaderContext_obj() { }

Dynamic SoundLoaderContext_obj::__CreateEmpty() { return  new SoundLoaderContext_obj; }
hx::ObjectPtr< SoundLoaderContext_obj > SoundLoaderContext_obj::__new()
{  hx::ObjectPtr< SoundLoaderContext_obj > result = new SoundLoaderContext_obj();
	result->__construct();
	return result;}

Dynamic SoundLoaderContext_obj::__Create(hx::DynamicArray inArgs)
{  hx::ObjectPtr< SoundLoaderContext_obj > result = new SoundLoaderContext_obj();
	result->__construct();
	return result;}


SoundLoaderContext_obj::SoundLoaderContext_obj()
{
}

Dynamic SoundLoaderContext_obj::__Field(const ::String &inName,bool inCallProp)
{
	return super::__Field(inName,inCallProp);
}

Dynamic SoundLoaderContext_obj::__SetField(const ::String &inName,const Dynamic &inValue,bool inCallProp)
{
	return super::__SetField(inName,inValue,inCallProp);
}

void SoundLoaderContext_obj::__GetFields(Array< ::String> &outFields)
{
	super::__GetFields(outFields);
};

static ::String sStaticFields[] = {
	String(null()) };

#if HXCPP_SCRIPTABLE
static hx::StorageInfo *sMemberStorageInfo = 0;
#endif

static ::String sMemberFields[] = {
	String(null()) };

static void sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(SoundLoaderContext_obj::__mClass,"__mClass");
};

#ifdef HXCPP_VISIT_ALLOCS
static void sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(SoundLoaderContext_obj::__mClass,"__mClass");
};

#endif

Class SoundLoaderContext_obj::__mClass;

void SoundLoaderContext_obj::__register()
{
	hx::Static(__mClass) = hx::RegisterClass(HX_CSTRING("flash.media.SoundLoaderContext"), hx::TCanCast< SoundLoaderContext_obj> ,sStaticFields,sMemberFields,
	&__CreateEmpty, &__Create,
	&super::__SGetClass(), 0, sMarkStatics
#ifdef HXCPP_VISIT_ALLOCS
    , sVisitStatics
#endif
#ifdef HXCPP_SCRIPTABLE
    , sMemberStorageInfo
#endif
);
}

void SoundLoaderContext_obj::__boot()
{
}

} // end namespace flash
示例#21
0
namespace hx
{

ArrayBase::ArrayBase(int inSize,int inReserve,int inElementSize,bool inAtomic)
{
   length = inSize;
   mAlloc = inSize < inReserve ? inReserve : inSize;
   if (mAlloc)
   {
      mBase = (char *)( (!inAtomic) ?
        hx::NewGCBytes(0, mAlloc * inElementSize ) : hx::NewGCPrivate(0,mAlloc*inElementSize));
   }
   else
      mBase = 0;
}


void ArrayBase::EnsureSize(int inSize) const
{
   int s = inSize;
   if (s>length)
   {
      if (s>mAlloc)
      {
         mAlloc = s*3/2 + 10;
         int bytes = mAlloc * GetElementSize();
         if (mBase)
         {
            mBase = (char *)hx::GCRealloc(mBase, bytes );
         }
         else if (AllocAtomic())
         {
            mBase = (char *)hx::NewGCPrivate(0,bytes);
         }
         else
         {
            mBase = (char *)hx::NewGCBytes(0,bytes);
         }
      }
      length = s;
   }
}

// Set numeric values to 0, pointers to null, bools to false
void ArrayBase::zero(Dynamic inFirst, Dynamic inCount)
{
   int first = inFirst==null() ? 0 : inFirst->__ToInt();
   if (first<0)
      first+=length;
   if (first<0 || first>=length)
      return;

   int count = length;
   if (inCount!=null())
      count = inCount->__ToInt();
   if (count<0)
      count += length;
   if (count<0)
      return;

   if (first+count > length)
      count = length - first;

   int size = GetElementSize();
   memset(mBase + first*size, 0, count*size);
}

int ArrayBase::Memcmp(ArrayBase *inOther)
{
   int bytesA = length * GetElementSize();
   int bytesB = inOther->length * inOther->GetElementSize();
   int common = bytesA<bytesB ? bytesA : bytesB;
   int result = memcmp(mBase, inOther->mBase, common);
   if (result)
      return result;
   return bytesA - bytesB;
}

void ArrayBase::Blit(int inDestElement, ArrayBase *inSourceArray, int inSourceElement, int inElementCount)
{
   int srcSize = inSourceArray->GetElementSize();
   int srcElems = inSourceArray->length;
   if (inDestElement<0 || inSourceElement<0 || inSourceElement+inElementCount>srcElems)
      hx::Throw( HX_CSTRING("blit out of bounds") );
   if (srcSize!=GetElementSize())
      hx::Throw( HX_CSTRING("blit array mismatch") );

   int newSize = inDestElement + inElementCount;
   if (newSize>length)
      __SetSize(newSize);

   const char *src = inSourceArray->mBase + inSourceElement*srcSize;
   char *dest = mBase + inDestElement*srcSize;
   int len = inElementCount*srcSize;
   if (src+len < dest || dest+len<src)
      memcpy(dest,src,len);
   else
      memmove(dest,src,len);
}



String ArrayBase::__ToString() const { return HX_CSTRING("Array"); }
String ArrayBase::toString()
{
   // Byte-array (not bool!)
   if (IsByteArray())
   {
      return String( (const char *) mBase, length);
   }

   return HX_CSTRING("[") + join(HX_CSTRING(",")) + HX_CSTRING("]");
}

void ArrayBase::__SetSize(int inSize)
{
   if (inSize<length)
   {
      int s = GetElementSize();
      memset(mBase + inSize*s, 0, (length-inSize)*s);
      length = inSize;
   }
   else if (inSize>length)
   {
      EnsureSize(inSize);
      length = inSize;
   }
}

 
void ArrayBase::__SetSizeExact(int inSize)
{
   if (inSize!=length || inSize!=mAlloc)
   {
      int bytes = inSize * GetElementSize();
      if (mBase)
      {
         mBase = (char *)hx::GCRealloc(mBase, bytes );
      }
      else if (AllocAtomic())
      {
         mBase = (char *)hx::NewGCPrivate(0,bytes);
      }
      else
      {
         mBase = (char *)hx::NewGCBytes(0,bytes);
      }
      mAlloc = length = inSize;
   }
}

 




void ArrayBase::Insert(int inPos)
{
   if (inPos>=length)
      __SetSize(length+1);
   else
   {
      __SetSize(length+1);
      int s = GetElementSize();
      memmove(mBase + inPos*s + s, mBase+inPos*s, (length-inPos-1)*s );
   }
}

void ArrayBase::Splice(ArrayBase *outResult,int inPos,int inLen)
{
   if (inPos>=length)
   {
      return;
   }
   else if (inPos<0)
   {
      inPos += length;
      if (inPos<0)
         inPos =0;
   }
   if (inLen<0)
      return;
   if (inPos+inLen>length)
      inLen = length - inPos;

   outResult->__SetSize(inLen);
   int s = GetElementSize();
   memcpy(outResult->mBase, mBase+inPos*s, s*inLen);
   memmove(mBase+inPos*s, mBase + (inPos+inLen)*s, (length-(inPos+inLen))*s);
   __SetSize(length-inLen);
}

void ArrayBase::Slice(ArrayBase *outResult,int inPos,int inEnd)
{
   if (inPos<0)
   {
      inPos += length;
      if (inPos<0)
         inPos =0;
   }
   if (inEnd<0)
      inEnd += length;
   if (inEnd>length)
      inEnd = length;
   int n = inEnd - inPos;
   if (n<=0)
      outResult->__SetSize(0);
   else
   {
      outResult->__SetSize(n);
      int s = GetElementSize();
      memcpy(outResult->mBase, mBase+inPos*s, n*s);
   }
}

void ArrayBase::RemoveElement(int inPos)
{
   if (inPos<length)
   {
      int s = GetElementSize();
      memmove(mBase + inPos*s, mBase+inPos*s + s, (length-inPos-1)*s );
      __SetSize(length-1);
   }

}

void ArrayBase::Concat(ArrayBase *outResult,const char *inSecond,int inLen)
{
   char *ptr =  outResult->GetBase();
   int n = length * GetElementSize();
   memcpy(ptr,mBase,n);
   ptr += n;
   memcpy(ptr,inSecond,inLen*GetElementSize());

}


String ArrayBase::join(String inSeparator)
{
   int len = 0;
   for(int i=0;i<length;i++)
   {
      len += ItemString(i).length;
   }
   if (length) len += (length-1) * inSeparator.length;

   HX_CHAR *buf = hx::NewString(len);

   int pos = 0;
   bool separated = inSeparator.length>0;
   for(int i=0;i<length;i++)
   {
      String s = ItemString(i);
      memcpy(buf+pos,s.__s,s.length*sizeof(HX_CHAR));
      pos += s.length;
      if (separated && (i+1<length) )
      {
         memcpy(buf+pos,inSeparator.__s,inSeparator.length*sizeof(HX_CHAR));
         pos += inSeparator.length;
      }
   }
   buf[len] = '\0';

   return String(buf,len);
}

template<typename T>
struct ArrayBaseSorter
{
   ArrayBaseSorter(Dynamic inFunc) : mFunc(inFunc) { }
   bool operator()(const T &inA, const T &inB)
      { return mFunc(inA, inB)->__ToInt() < 0; }
   Dynamic mFunc;
};

void ArrayBase::safeSort(Dynamic inSorter, bool inIsString)
{
   if (inIsString)
   {
      String *array = (String *)mBase;
      std::sort(array, array+length, ArrayBaseSorter<String>(inSorter) );
   }
   else
   {
      Dynamic *array = (Dynamic *)mBase;
      std::sort(array, array+length, ArrayBaseSorter<Dynamic>(inSorter) );
   }
}



#define DEFINE_ARRAY_FUNC(func,array_list,dynamic_arg_list,arg_list,ARG_C) \
struct ArrayBase_##func : public hx::Object \
{ \
   bool __IsFunction() const { return true; } \
   ArrayBase *mThis; \
   ArrayBase_##func(ArrayBase *inThis) : mThis(inThis) { } \
   String toString() const{ return HX_CSTRING(#func) ; } \
   String __ToString() const{ return HX_CSTRING(#func) ; } \
   int __GetType() const { return vtFunction; } \
   void *__GetHandle() const { return mThis; } \
   int __ArgCount() const { return ARG_C; } \
   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER(mThis); } \
   void __Visit(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER(mThis); } \
   Dynamic __Run(const Array<Dynamic> &inArgs) \
   { \
      return mThis->__##func(array_list); return Dynamic(); \
   } \
   Dynamic __run(dynamic_arg_list) \
   { \
      return mThis->__##func(arg_list); return Dynamic(); \
   } \
}; \
Dynamic ArrayBase::func##_dyn()  { return new ArrayBase_##func(this);  }


#define DEFINE_ARRAY_FUNC0(func) DEFINE_ARRAY_FUNC(func,HX_ARR_LIST0,HX_DYNAMIC_ARG_LIST0,HX_ARG_LIST0,0)
#define DEFINE_ARRAY_FUNC1(func) DEFINE_ARRAY_FUNC(func,HX_ARR_LIST1,HX_DYNAMIC_ARG_LIST1,HX_ARG_LIST1,1)
#define DEFINE_ARRAY_FUNC2(func) DEFINE_ARRAY_FUNC(func,HX_ARR_LIST2,HX_DYNAMIC_ARG_LIST2,HX_ARG_LIST2,2)
#define DEFINE_ARRAY_FUNC3(func) DEFINE_ARRAY_FUNC(func,HX_ARR_LIST3,HX_DYNAMIC_ARG_LIST3,HX_ARG_LIST3,3)
#define DEFINE_ARRAY_FUNC4(func) DEFINE_ARRAY_FUNC(func,HX_ARR_LIST4,HX_DYNAMIC_ARG_LIST4,HX_ARG_LIST4,4)


DEFINE_ARRAY_FUNC1(concat);
DEFINE_ARRAY_FUNC2(insert);
DEFINE_ARRAY_FUNC0(iterator);
DEFINE_ARRAY_FUNC1(join);
DEFINE_ARRAY_FUNC0(pop);
DEFINE_ARRAY_FUNC0(copy);
DEFINE_ARRAY_FUNC1(push);
DEFINE_ARRAY_FUNC1(remove);
DEFINE_ARRAY_FUNC2(indexOf);
DEFINE_ARRAY_FUNC2(lastIndexOf);
DEFINE_ARRAY_FUNC0(reverse);
DEFINE_ARRAY_FUNC0(shift);
DEFINE_ARRAY_FUNC2(slice);
DEFINE_ARRAY_FUNC2(splice);
DEFINE_ARRAY_FUNC1(sort);
DEFINE_ARRAY_FUNC0(toString);
DEFINE_ARRAY_FUNC1(unshift);
DEFINE_ARRAY_FUNC1(map);
DEFINE_ARRAY_FUNC1(filter);
DEFINE_ARRAY_FUNC1(__SetSize);
DEFINE_ARRAY_FUNC1(__SetSizeExact);
DEFINE_ARRAY_FUNC1(__unsafe_get);
DEFINE_ARRAY_FUNC2(__unsafe_set);
DEFINE_ARRAY_FUNC4(blit);
DEFINE_ARRAY_FUNC2(zero);
DEFINE_ARRAY_FUNC1(memcmp);

Dynamic ArrayBase::__Field(const String &inString, hx::PropertyAccess inCallProp)
{
   if (inString==HX_CSTRING("length")) return Dynamic((int)size());
   if (inString==HX_CSTRING("concat")) return concat_dyn();
   if (inString==HX_CSTRING("insert")) return insert_dyn();
   if (inString==HX_CSTRING("copy")) return copy_dyn();
   if (inString==HX_CSTRING("iterator")) return iterator_dyn();
   if (inString==HX_CSTRING("join")) return join_dyn();
   if (inString==HX_CSTRING("pop")) return pop_dyn();
   if (inString==HX_CSTRING("push")) return push_dyn();
   if (inString==HX_CSTRING("remove")) return remove_dyn();
   if (inString==HX_CSTRING("indexOf")) return indexOf_dyn();
   if (inString==HX_CSTRING("lastIndexOf")) return lastIndexOf_dyn();
   if (inString==HX_CSTRING("reverse")) return reverse_dyn();
   if (inString==HX_CSTRING("shift")) return shift_dyn();
   if (inString==HX_CSTRING("splice")) return splice_dyn();
   if (inString==HX_CSTRING("slice")) return slice_dyn();
   if (inString==HX_CSTRING("sort")) return sort_dyn();
   if (inString==HX_CSTRING("toString")) return toString_dyn();
   if (inString==HX_CSTRING("unshift")) return unshift_dyn();
   if (inString==HX_CSTRING("filter")) return filter_dyn();
   if (inString==HX_CSTRING("map")) return map_dyn();
   if (inString==HX_CSTRING("__SetSize")) return __SetSize_dyn();
   if (inString==HX_CSTRING("__SetSizeExact")) return __SetSizeExact_dyn();
   if (inString==HX_CSTRING("__unsafe_get")) return __unsafe_get_dyn();
   if (inString==HX_CSTRING("__unsafe_set")) return __unsafe_set_dyn();
   if (inString==HX_CSTRING("blit")) return blit_dyn();
   if (inString==HX_CSTRING("zero")) return zero_dyn();
   if (inString==HX_CSTRING("memcmp")) return memcmp_dyn();
   return null();
}


static String sArrayFields[] = {
   HX_CSTRING("length"),
   HX_CSTRING("concat"),
   HX_CSTRING("insert"),
   HX_CSTRING("iterator"),
   HX_CSTRING("join"),
   HX_CSTRING("copy"),
   HX_CSTRING("pop"),
   HX_CSTRING("push"),
   HX_CSTRING("remove"),
   HX_CSTRING("indexOf"),
   HX_CSTRING("lastIndexOf"),
   HX_CSTRING("reverse"),
   HX_CSTRING("shift"),
   HX_CSTRING("slice"),
   HX_CSTRING("splice"),
   HX_CSTRING("sort"),
   HX_CSTRING("toString"),
   HX_CSTRING("unshift"),
   HX_CSTRING("filter"),
   HX_CSTRING("map"),
   String(null())
};



// TODO;
Class ArrayBase::__mClass;

Dynamic ArrayCreateEmpty() { return new Array<Dynamic>(0,0); }
Dynamic ArrayCreateArgs(DynamicArray inArgs)
{
   return inArgs->__copy();
}

void ArrayBase::__boot()
{
   Static(__mClass) = hx::RegisterClass(HX_CSTRING("Array"),TCanCast<ArrayBase>,sNone,sArrayFields,
                                    ArrayCreateEmpty,ArrayCreateArgs,0,0);
}




// -------- ArrayIterator -------------------------------------

} // End namespace hx
	::String(null()) };

static void sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(URLLoaderDataFormat_obj::BINARY,"BINARY");
	HX_MARK_MEMBER_NAME(URLLoaderDataFormat_obj::TEXT,"TEXT");
	HX_MARK_MEMBER_NAME(URLLoaderDataFormat_obj::VARIABLES,"VARIABLES");
};

static void sVisitStatic(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(URLLoaderDataFormat_obj::__mClass,"__mClass");
	HX_VISIT_MEMBER_NAME(URLLoaderDataFormat_obj::BINARY,"BINARY");
	HX_VISIT_MEMBER_NAME(URLLoaderDataFormat_obj::TEXT,"TEXT");
	HX_VISIT_MEMBER_NAME(URLLoaderDataFormat_obj::VARIABLES,"VARIABLES");
};

static ::String sMemberFields[] = { ::String(null()) };
Class URLLoaderDataFormat_obj::__mClass;

Dynamic __Create_URLLoaderDataFormat_obj() { return new URLLoaderDataFormat_obj; }

void URLLoaderDataFormat_obj::__register()
{

Static(__mClass) = hx::RegisterClass(HX_CSTRING("native.net.URLLoaderDataFormat"), hx::TCanCast< URLLoaderDataFormat_obj >,sStaticFields,sMemberFields,
	&__Create_URLLoaderDataFormat_obj, &__Create,
	&super::__SGetClass(), &CreateURLLoaderDataFormat_obj, sMarkStatics, sVisitStatic);
}

void URLLoaderDataFormat_obj::__boot()
{
Static(BINARY) = hx::CreateEnum< URLLoaderDataFormat_obj >(HX_CSTRING("BINARY"),0);
示例#23
0
namespace lime{

Void SystemEvents_obj::__construct()
{
	return null();
}

//SystemEvents_obj::~SystemEvents_obj() { }

Dynamic SystemEvents_obj::__CreateEmpty() { return  new SystemEvents_obj; }
hx::ObjectPtr< SystemEvents_obj > SystemEvents_obj::__new()
{  hx::ObjectPtr< SystemEvents_obj > result = new SystemEvents_obj();
	result->__construct();
	return result;}

Dynamic SystemEvents_obj::__Create(hx::DynamicArray inArgs)
{  hx::ObjectPtr< SystemEvents_obj > result = new SystemEvents_obj();
	result->__construct();
	return result;}

int SystemEvents_obj::_char;

int SystemEvents_obj::keydown;

int SystemEvents_obj::keyup;

int SystemEvents_obj::mousemove;

int SystemEvents_obj::mousedown;

int SystemEvents_obj::mouseclick;

int SystemEvents_obj::mouseup;

int SystemEvents_obj::resize;

int SystemEvents_obj::poll;

int SystemEvents_obj::quit;

int SystemEvents_obj::focus;

int SystemEvents_obj::shouldrotate;

int SystemEvents_obj::redraw;

int SystemEvents_obj::touchbegin;

int SystemEvents_obj::touchmove;

int SystemEvents_obj::touchend;

int SystemEvents_obj::touchtap;

int SystemEvents_obj::change;

int SystemEvents_obj::activate;

int SystemEvents_obj::deactivate;

int SystemEvents_obj::gotinputfocus;

int SystemEvents_obj::lostinputfocus;

int SystemEvents_obj::joyaxismove;

int SystemEvents_obj::joyballmove;

int SystemEvents_obj::joyhatmove;

int SystemEvents_obj::joybuttondown;

int SystemEvents_obj::joybuttonup;

int SystemEvents_obj::joydeviceadded;

int SystemEvents_obj::joydeviceremoved;

int SystemEvents_obj::syswm;


SystemEvents_obj::SystemEvents_obj()
{
}

Dynamic SystemEvents_obj::__Field(const ::String &inName,bool inCallProp)
{
	switch(inName.length) {
	case 4:
		if (HX_FIELD_EQ(inName,"char") ) { return _char; }
		if (HX_FIELD_EQ(inName,"poll") ) { return poll; }
		if (HX_FIELD_EQ(inName,"quit") ) { return quit; }
		break;
	case 5:
		if (HX_FIELD_EQ(inName,"keyup") ) { return keyup; }
		if (HX_FIELD_EQ(inName,"focus") ) { return focus; }
		if (HX_FIELD_EQ(inName,"syswm") ) { return syswm; }
		break;
	case 6:
		if (HX_FIELD_EQ(inName,"resize") ) { return resize; }
		if (HX_FIELD_EQ(inName,"redraw") ) { return redraw; }
		if (HX_FIELD_EQ(inName,"change") ) { return change; }
		break;
	case 7:
		if (HX_FIELD_EQ(inName,"keydown") ) { return keydown; }
		if (HX_FIELD_EQ(inName,"mouseup") ) { return mouseup; }
		break;
	case 8:
		if (HX_FIELD_EQ(inName,"touchend") ) { return touchend; }
		if (HX_FIELD_EQ(inName,"touchtap") ) { return touchtap; }
		if (HX_FIELD_EQ(inName,"activate") ) { return activate; }
		break;
	case 9:
		if (HX_FIELD_EQ(inName,"mousemove") ) { return mousemove; }
		if (HX_FIELD_EQ(inName,"mousedown") ) { return mousedown; }
		if (HX_FIELD_EQ(inName,"touchmove") ) { return touchmove; }
		break;
	case 10:
		if (HX_FIELD_EQ(inName,"mouseclick") ) { return mouseclick; }
		if (HX_FIELD_EQ(inName,"touchbegin") ) { return touchbegin; }
		if (HX_FIELD_EQ(inName,"deactivate") ) { return deactivate; }
		if (HX_FIELD_EQ(inName,"joyhatmove") ) { return joyhatmove; }
		break;
	case 11:
		if (HX_FIELD_EQ(inName,"joyaxismove") ) { return joyaxismove; }
		if (HX_FIELD_EQ(inName,"joyballmove") ) { return joyballmove; }
		if (HX_FIELD_EQ(inName,"joybuttonup") ) { return joybuttonup; }
		break;
	case 12:
		if (HX_FIELD_EQ(inName,"shouldrotate") ) { return shouldrotate; }
		break;
	case 13:
		if (HX_FIELD_EQ(inName,"gotinputfocus") ) { return gotinputfocus; }
		if (HX_FIELD_EQ(inName,"joybuttondown") ) { return joybuttondown; }
		break;
	case 14:
		if (HX_FIELD_EQ(inName,"lostinputfocus") ) { return lostinputfocus; }
		if (HX_FIELD_EQ(inName,"joydeviceadded") ) { return joydeviceadded; }
		break;
	case 16:
		if (HX_FIELD_EQ(inName,"joydeviceremoved") ) { return joydeviceremoved; }
	}
	return super::__Field(inName,inCallProp);
}

Dynamic SystemEvents_obj::__SetField(const ::String &inName,const Dynamic &inValue,bool inCallProp)
{
	switch(inName.length) {
	case 4:
		if (HX_FIELD_EQ(inName,"char") ) { _char=inValue.Cast< int >(); return inValue; }
		if (HX_FIELD_EQ(inName,"poll") ) { poll=inValue.Cast< int >(); return inValue; }
		if (HX_FIELD_EQ(inName,"quit") ) { quit=inValue.Cast< int >(); return inValue; }
		break;
	case 5:
		if (HX_FIELD_EQ(inName,"keyup") ) { keyup=inValue.Cast< int >(); return inValue; }
		if (HX_FIELD_EQ(inName,"focus") ) { focus=inValue.Cast< int >(); return inValue; }
		if (HX_FIELD_EQ(inName,"syswm") ) { syswm=inValue.Cast< int >(); return inValue; }
		break;
	case 6:
		if (HX_FIELD_EQ(inName,"resize") ) { resize=inValue.Cast< int >(); return inValue; }
		if (HX_FIELD_EQ(inName,"redraw") ) { redraw=inValue.Cast< int >(); return inValue; }
		if (HX_FIELD_EQ(inName,"change") ) { change=inValue.Cast< int >(); return inValue; }
		break;
	case 7:
		if (HX_FIELD_EQ(inName,"keydown") ) { keydown=inValue.Cast< int >(); return inValue; }
		if (HX_FIELD_EQ(inName,"mouseup") ) { mouseup=inValue.Cast< int >(); return inValue; }
		break;
	case 8:
		if (HX_FIELD_EQ(inName,"touchend") ) { touchend=inValue.Cast< int >(); return inValue; }
		if (HX_FIELD_EQ(inName,"touchtap") ) { touchtap=inValue.Cast< int >(); return inValue; }
		if (HX_FIELD_EQ(inName,"activate") ) { activate=inValue.Cast< int >(); return inValue; }
		break;
	case 9:
		if (HX_FIELD_EQ(inName,"mousemove") ) { mousemove=inValue.Cast< int >(); return inValue; }
		if (HX_FIELD_EQ(inName,"mousedown") ) { mousedown=inValue.Cast< int >(); return inValue; }
		if (HX_FIELD_EQ(inName,"touchmove") ) { touchmove=inValue.Cast< int >(); return inValue; }
		break;
	case 10:
		if (HX_FIELD_EQ(inName,"mouseclick") ) { mouseclick=inValue.Cast< int >(); return inValue; }
		if (HX_FIELD_EQ(inName,"touchbegin") ) { touchbegin=inValue.Cast< int >(); return inValue; }
		if (HX_FIELD_EQ(inName,"deactivate") ) { deactivate=inValue.Cast< int >(); return inValue; }
		if (HX_FIELD_EQ(inName,"joyhatmove") ) { joyhatmove=inValue.Cast< int >(); return inValue; }
		break;
	case 11:
		if (HX_FIELD_EQ(inName,"joyaxismove") ) { joyaxismove=inValue.Cast< int >(); return inValue; }
		if (HX_FIELD_EQ(inName,"joyballmove") ) { joyballmove=inValue.Cast< int >(); return inValue; }
		if (HX_FIELD_EQ(inName,"joybuttonup") ) { joybuttonup=inValue.Cast< int >(); return inValue; }
		break;
	case 12:
		if (HX_FIELD_EQ(inName,"shouldrotate") ) { shouldrotate=inValue.Cast< int >(); return inValue; }
		break;
	case 13:
		if (HX_FIELD_EQ(inName,"gotinputfocus") ) { gotinputfocus=inValue.Cast< int >(); return inValue; }
		if (HX_FIELD_EQ(inName,"joybuttondown") ) { joybuttondown=inValue.Cast< int >(); return inValue; }
		break;
	case 14:
		if (HX_FIELD_EQ(inName,"lostinputfocus") ) { lostinputfocus=inValue.Cast< int >(); return inValue; }
		if (HX_FIELD_EQ(inName,"joydeviceadded") ) { joydeviceadded=inValue.Cast< int >(); return inValue; }
		break;
	case 16:
		if (HX_FIELD_EQ(inName,"joydeviceremoved") ) { joydeviceremoved=inValue.Cast< int >(); return inValue; }
	}
	return super::__SetField(inName,inValue,inCallProp);
}

void SystemEvents_obj::__GetFields(Array< ::String> &outFields)
{
	super::__GetFields(outFields);
};

static ::String sStaticFields[] = {
	HX_CSTRING("char"),
	HX_CSTRING("keydown"),
	HX_CSTRING("keyup"),
	HX_CSTRING("mousemove"),
	HX_CSTRING("mousedown"),
	HX_CSTRING("mouseclick"),
	HX_CSTRING("mouseup"),
	HX_CSTRING("resize"),
	HX_CSTRING("poll"),
	HX_CSTRING("quit"),
	HX_CSTRING("focus"),
	HX_CSTRING("shouldrotate"),
	HX_CSTRING("redraw"),
	HX_CSTRING("touchbegin"),
	HX_CSTRING("touchmove"),
	HX_CSTRING("touchend"),
	HX_CSTRING("touchtap"),
	HX_CSTRING("change"),
	HX_CSTRING("activate"),
	HX_CSTRING("deactivate"),
	HX_CSTRING("gotinputfocus"),
	HX_CSTRING("lostinputfocus"),
	HX_CSTRING("joyaxismove"),
	HX_CSTRING("joyballmove"),
	HX_CSTRING("joyhatmove"),
	HX_CSTRING("joybuttondown"),
	HX_CSTRING("joybuttonup"),
	HX_CSTRING("joydeviceadded"),
	HX_CSTRING("joydeviceremoved"),
	HX_CSTRING("syswm"),
	String(null()) };

#if HXCPP_SCRIPTABLE
static hx::StorageInfo *sMemberStorageInfo = 0;
#endif

static ::String sMemberFields[] = {
	String(null()) };

static void sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(SystemEvents_obj::__mClass,"__mClass");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::_char,"char");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::keydown,"keydown");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::keyup,"keyup");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::mousemove,"mousemove");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::mousedown,"mousedown");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::mouseclick,"mouseclick");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::mouseup,"mouseup");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::resize,"resize");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::poll,"poll");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::quit,"quit");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::focus,"focus");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::shouldrotate,"shouldrotate");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::redraw,"redraw");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::touchbegin,"touchbegin");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::touchmove,"touchmove");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::touchend,"touchend");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::touchtap,"touchtap");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::change,"change");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::activate,"activate");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::deactivate,"deactivate");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::gotinputfocus,"gotinputfocus");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::lostinputfocus,"lostinputfocus");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::joyaxismove,"joyaxismove");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::joyballmove,"joyballmove");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::joyhatmove,"joyhatmove");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::joybuttondown,"joybuttondown");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::joybuttonup,"joybuttonup");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::joydeviceadded,"joydeviceadded");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::joydeviceremoved,"joydeviceremoved");
	HX_MARK_MEMBER_NAME(SystemEvents_obj::syswm,"syswm");
};

#ifdef HXCPP_VISIT_ALLOCS
static void sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::__mClass,"__mClass");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::_char,"char");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::keydown,"keydown");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::keyup,"keyup");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::mousemove,"mousemove");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::mousedown,"mousedown");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::mouseclick,"mouseclick");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::mouseup,"mouseup");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::resize,"resize");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::poll,"poll");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::quit,"quit");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::focus,"focus");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::shouldrotate,"shouldrotate");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::redraw,"redraw");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::touchbegin,"touchbegin");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::touchmove,"touchmove");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::touchend,"touchend");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::touchtap,"touchtap");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::change,"change");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::activate,"activate");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::deactivate,"deactivate");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::gotinputfocus,"gotinputfocus");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::lostinputfocus,"lostinputfocus");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::joyaxismove,"joyaxismove");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::joyballmove,"joyballmove");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::joyhatmove,"joyhatmove");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::joybuttondown,"joybuttondown");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::joybuttonup,"joybuttonup");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::joydeviceadded,"joydeviceadded");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::joydeviceremoved,"joydeviceremoved");
	HX_VISIT_MEMBER_NAME(SystemEvents_obj::syswm,"syswm");
};

#endif

Class SystemEvents_obj::__mClass;

void SystemEvents_obj::__register()
{
	hx::Static(__mClass) = hx::RegisterClass(HX_CSTRING("lime.SystemEvents"), hx::TCanCast< SystemEvents_obj> ,sStaticFields,sMemberFields,
	&__CreateEmpty, &__Create,
	&super::__SGetClass(), 0, sMarkStatics
#ifdef HXCPP_VISIT_ALLOCS
    , sVisitStatics
#endif
#ifdef HXCPP_SCRIPTABLE
    , sMemberStorageInfo
#endif
);
}

void SystemEvents_obj::__boot()
{
	_char= (int)1;
	keydown= (int)2;
	keyup= (int)3;
	mousemove= (int)4;
	mousedown= (int)5;
	mouseclick= (int)6;
	mouseup= (int)7;
	resize= (int)8;
	poll= (int)9;
	quit= (int)10;
	focus= (int)11;
	shouldrotate= (int)12;
	redraw= (int)14;
	touchbegin= (int)15;
	touchmove= (int)16;
	touchend= (int)17;
	touchtap= (int)18;
	change= (int)19;
	activate= (int)20;
	deactivate= (int)21;
	gotinputfocus= (int)22;
	lostinputfocus= (int)23;
	joyaxismove= (int)24;
	joyballmove= (int)25;
	joyhatmove= (int)26;
	joybuttondown= (int)27;
	joybuttonup= (int)28;
	joydeviceadded= (int)29;
	joydeviceremoved= (int)30;
	syswm= (int)31;
}

} // end namespace lime
示例#24
0
namespace _Fast{

Void NodeListAccess_obj::__construct(::Xml x)
{
HX_STACK_PUSH("NodeListAccess::new","haxe/xml/Fast.hx",96);
{
	HX_STACK_LINE(96)
	this->__x = x;
}
;
	return null();
}

NodeListAccess_obj::~NodeListAccess_obj() { }

Dynamic NodeListAccess_obj::__CreateEmpty() { return  new NodeListAccess_obj; }
hx::ObjectPtr< NodeListAccess_obj > NodeListAccess_obj::__new(::Xml x)
{  hx::ObjectPtr< NodeListAccess_obj > result = new NodeListAccess_obj();
	result->__construct(x);
	return result;}

Dynamic NodeListAccess_obj::__Create(hx::DynamicArray inArgs)
{  hx::ObjectPtr< NodeListAccess_obj > result = new NodeListAccess_obj();
	result->__construct(inArgs[0]);
	return result;}


NodeListAccess_obj::NodeListAccess_obj()
{
	HX_INIT_IMPLEMENT_DYNAMIC;
}

void NodeListAccess_obj::__Mark(HX_MARK_PARAMS)
{
	HX_MARK_BEGIN_CLASS(NodeListAccess);
	HX_MARK_DYNAMIC;
	HX_MARK_MEMBER_NAME(__x,"__x");
	HX_MARK_END_CLASS();
}

void NodeListAccess_obj::__Visit(HX_VISIT_PARAMS)
{
	HX_VISIT_DYNAMIC;
	HX_VISIT_MEMBER_NAME(__x,"__x");
}

Dynamic NodeListAccess_obj::__Field(const ::String &inName,bool inCallProp)
{
	switch(inName.length) {
	case 3:
		if (HX_FIELD_EQ(inName,"__x") ) { return __x; }
	}
	HX_CHECK_DYNAMIC_GET_FIELD(inName);
	return super::__Field(inName,inCallProp);
}

Dynamic NodeListAccess_obj::__SetField(const ::String &inName,const Dynamic &inValue,bool inCallProp)
{
	switch(inName.length) {
	case 3:
		if (HX_FIELD_EQ(inName,"__x") ) { __x=inValue.Cast< ::Xml >(); return inValue; }
	}
	try { return super::__SetField(inName,inValue,inCallProp); }
	catch(Dynamic e) { HX_DYNAMIC_SET_FIELD(inName,inValue); }
	return inValue;
}

void NodeListAccess_obj::__GetFields(Array< ::String> &outFields)
{
	outFields->push(HX_CSTRING("__x"));
	HX_APPEND_DYNAMIC_FIELDS(outFields);
	super::__GetFields(outFields);
};

static ::String sStaticFields[] = {
	String(null()) };

static ::String sMemberFields[] = {
	HX_CSTRING("__x"),
	String(null()) };

static void sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(NodeListAccess_obj::__mClass,"__mClass");
};

static void sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(NodeListAccess_obj::__mClass,"__mClass");
};

Class NodeListAccess_obj::__mClass;

void NodeListAccess_obj::__register()
{
	hx::Static(__mClass) = hx::RegisterClass(HX_CSTRING("haxe.xml._Fast.NodeListAccess"), hx::TCanCast< NodeListAccess_obj> ,sStaticFields,sMemberFields,
	&__CreateEmpty, &__Create,
	&super::__SGetClass(), 0, sMarkStatics, sVisitStatics);
}

void NodeListAccess_obj::__boot()
{
}

} // end namespace haxe
	}
	return false;
}

void ZNPNode_ZPP_GeomPoly_obj::__GetFields(Array< ::String> &outFields)
{
	outFields->push(HX_HCSTRING("next","\xf3","\x84","\x02","\x49"));
	outFields->push(HX_HCSTRING("elt","\x2d","\x02","\x4d","\x00"));
	super::__GetFields(outFields);
};

#if HXCPP_SCRIPTABLE
static hx::StorageInfo sMemberStorageInfo[] = {
	{hx::fsObject /*::zpp_nape::util::ZNPNode_ZPP_GeomPoly*/ ,(int)offsetof(ZNPNode_ZPP_GeomPoly_obj,next),HX_HCSTRING("next","\xf3","\x84","\x02","\x49")},
	{hx::fsObject /*::zpp_nape::geom::ZPP_GeomPoly*/ ,(int)offsetof(ZNPNode_ZPP_GeomPoly_obj,elt),HX_HCSTRING("elt","\x2d","\x02","\x4d","\x00")},
	{ hx::fsUnknown, 0, null()}
};
static hx::StaticInfo sStaticStorageInfo[] = {
	{hx::fsObject /*::zpp_nape::util::ZNPNode_ZPP_GeomPoly*/ ,(void *) &ZNPNode_ZPP_GeomPoly_obj::zpp_pool,HX_HCSTRING("zpp_pool","\x81","\x5d","\xd4","\x38")},
	{ hx::fsUnknown, 0, null()}
};
#endif

static ::String sMemberFields[] = {
	HX_HCSTRING("next","\xf3","\x84","\x02","\x49"),
	HX_HCSTRING("alloc","\x75","\xa4","\x93","\x21"),
	HX_HCSTRING("free","\xac","\x9c","\xc2","\x43"),
	HX_HCSTRING("elt","\x2d","\x02","\x4d","\x00"),
	HX_HCSTRING("elem","\x8f","\xd8","\x14","\x43"),
	::String(null()) };
示例#26
0
namespace openfl{

Void AssetData_obj::__construct()
{
HX_STACK_PUSH("AssetData::new","openfl/Assets.hx",1214);
{
}
;
	return null();
}

AssetData_obj::~AssetData_obj() { }

Dynamic AssetData_obj::__CreateEmpty() { return  new AssetData_obj; }
hx::ObjectPtr< AssetData_obj > AssetData_obj::__new()
{  hx::ObjectPtr< AssetData_obj > result = new AssetData_obj();
	result->__construct();
	return result;}

Dynamic AssetData_obj::__Create(hx::DynamicArray inArgs)
{  hx::ObjectPtr< AssetData_obj > result = new AssetData_obj();
	result->__construct();
	return result;}


AssetData_obj::AssetData_obj()
{
}

void AssetData_obj::__Mark(HX_MARK_PARAMS)
{
	HX_MARK_BEGIN_CLASS(AssetData);
	HX_MARK_MEMBER_NAME(type,"type");
	HX_MARK_MEMBER_NAME(path,"path");
	HX_MARK_MEMBER_NAME(id,"id");
	HX_MARK_END_CLASS();
}

void AssetData_obj::__Visit(HX_VISIT_PARAMS)
{
	HX_VISIT_MEMBER_NAME(type,"type");
	HX_VISIT_MEMBER_NAME(path,"path");
	HX_VISIT_MEMBER_NAME(id,"id");
}

Dynamic AssetData_obj::__Field(const ::String &inName,bool inCallProp)
{
	switch(inName.length) {
	case 2:
		if (HX_FIELD_EQ(inName,"id") ) { return id; }
		break;
	case 4:
		if (HX_FIELD_EQ(inName,"type") ) { return type; }
		if (HX_FIELD_EQ(inName,"path") ) { return path; }
	}
	return super::__Field(inName,inCallProp);
}

Dynamic AssetData_obj::__SetField(const ::String &inName,const Dynamic &inValue,bool inCallProp)
{
	switch(inName.length) {
	case 2:
		if (HX_FIELD_EQ(inName,"id") ) { id=inValue.Cast< ::String >(); return inValue; }
		break;
	case 4:
		if (HX_FIELD_EQ(inName,"type") ) { type=inValue.Cast< ::openfl::AssetType >(); return inValue; }
		if (HX_FIELD_EQ(inName,"path") ) { path=inValue.Cast< ::String >(); return inValue; }
	}
	return super::__SetField(inName,inValue,inCallProp);
}

void AssetData_obj::__GetFields(Array< ::String> &outFields)
{
	outFields->push(HX_CSTRING("type"));
	outFields->push(HX_CSTRING("path"));
	outFields->push(HX_CSTRING("id"));
	super::__GetFields(outFields);
};

static ::String sStaticFields[] = {
	String(null()) };

static ::String sMemberFields[] = {
	HX_CSTRING("type"),
	HX_CSTRING("path"),
	HX_CSTRING("id"),
	String(null()) };

static void sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(AssetData_obj::__mClass,"__mClass");
};

static void sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(AssetData_obj::__mClass,"__mClass");
};

Class AssetData_obj::__mClass;

void AssetData_obj::__register()
{
	hx::Static(__mClass) = hx::RegisterClass(HX_CSTRING("openfl.AssetData"), hx::TCanCast< AssetData_obj> ,sStaticFields,sMemberFields,
	&__CreateEmpty, &__Create,
	&super::__SGetClass(), 0, sMarkStatics, sVisitStatics);
}

void AssetData_obj::__boot()
{
}

} // end namespace openfl
{
	switch(inName.length) {
	case 12:
		if (HX_FIELD_EQ(inName,"resourceName") ) { resourceName=inValue.Cast< ::String >(); return inValue; }
	}
	return super::__SetField(inName,inValue,inCallProp);
}

void GraphicStep_obj::__GetFields(Array< ::String> &outFields)
{
	super::__GetFields(outFields);
};

static ::String sStaticFields[] = {
	HX_CSTRING("resourceName"),
	String(null()) };

#if HXCPP_SCRIPTABLE
static hx::StorageInfo *sMemberStorageInfo = 0;
#endif

static ::String sMemberFields[] = {
	String(null()) };

static void sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(GraphicStep_obj::__mClass,"__mClass");
	HX_MARK_MEMBER_NAME(GraphicStep_obj::resourceName,"resourceName");
};

#ifdef HXCPP_VISIT_ALLOCS
static void sVisitStatics(HX_VISIT_PARAMS) {
示例#28
0
文件: Std.cpp 项目: mgrimald/gomoku
Void Std_obj::__construct()
{
	return null();
}
示例#29
0
hx::ObjectPtr< Reflect_obj > Reflect_obj::__new()
{  hx::ObjectPtr< Reflect_obj > _result_ = new Reflect_obj();
	_result_->__construct();
	return _result_;}

Dynamic Reflect_obj::__Create(hx::DynamicArray inArgs)
{  hx::ObjectPtr< Reflect_obj > _result_ = new Reflect_obj();
	_result_->__construct();
	return _result_;}

Dynamic Reflect_obj::field( Dynamic o,::String field){
	HX_STACK_FRAME("Reflect","field",0x54b04da9,"Reflect.field","/usr/local/lib/haxe/std/cpp/_std/Reflect.hx",28,0x1c2422c3)
	HX_STACK_ARG(o,"o")
	HX_STACK_ARG(field,"field")
	HX_STACK_LINE(29)
	bool tmp = (o == null());		HX_STACK_VAR(tmp,"tmp");
	HX_STACK_LINE(29)
	Dynamic tmp1;		HX_STACK_VAR(tmp1,"tmp1");
	HX_STACK_LINE(29)
	if ((tmp)){
		HX_STACK_LINE(29)
		tmp1 = null();
	}
	else{
		HX_STACK_LINE(29)
		tmp1 = o->__Field(field,hx::paccNever);
	}
	HX_STACK_LINE(29)
	return tmp1;
}
namespace _Fast{

void HasNodeAccess_obj::__construct( ::Xml x){
            	HX_STACK_FRAME("haxe.xml._Fast.HasNodeAccess","new",0xd184aba0,"haxe.xml._Fast.HasNodeAccess.new","C:\\HaxeToolkit\\haxe\\std/haxe/xml/Fast.hx",83,0x60a2153a)
            	HX_STACK_THIS(this)
            	HX_STACK_ARG(x,"x")
HXLINE(  83)		this->_hx___x = x;
            	}

Dynamic HasNodeAccess_obj::__CreateEmpty() { return new HasNodeAccess_obj; }

hx::ObjectPtr< HasNodeAccess_obj > HasNodeAccess_obj::__new( ::Xml x)
{
	hx::ObjectPtr< HasNodeAccess_obj > _hx_result = new HasNodeAccess_obj();
	_hx_result->__construct(x);
	return _hx_result;
}

Dynamic HasNodeAccess_obj::__Create(hx::DynamicArray inArgs)
{
	hx::ObjectPtr< HasNodeAccess_obj > _hx_result = new HasNodeAccess_obj();
	_hx_result->__construct(inArgs[0]);
	return _hx_result;
}


HasNodeAccess_obj::HasNodeAccess_obj()
{
	HX_INIT_IMPLEMENT_DYNAMIC;
}

void HasNodeAccess_obj::__Mark(HX_MARK_PARAMS)
{
	HX_MARK_BEGIN_CLASS(HasNodeAccess);
	HX_MARK_DYNAMIC;
	HX_MARK_MEMBER_NAME(_hx___x,"__x");
	HX_MARK_END_CLASS();
}

void HasNodeAccess_obj::__Visit(HX_VISIT_PARAMS)
{
	HX_VISIT_DYNAMIC;
	HX_VISIT_MEMBER_NAME(_hx___x,"__x");
}

hx::Val HasNodeAccess_obj::__Field(const ::String &inName,hx::PropertyAccess inCallProp)
{
	switch(inName.length) {
	case 3:
		if (HX_FIELD_EQ(inName,"__x") ) { return hx::Val( _hx___x); }
	}
	HX_CHECK_DYNAMIC_GET_FIELD(inName);
	return super::__Field(inName,inCallProp);
}

hx::Val HasNodeAccess_obj::__SetField(const ::String &inName,const hx::Val &inValue,hx::PropertyAccess inCallProp)
{
	switch(inName.length) {
	case 3:
		if (HX_FIELD_EQ(inName,"__x") ) { _hx___x=inValue.Cast<  ::Xml >(); return inValue; }
	}
	try { return super::__SetField(inName,inValue,inCallProp); }
	catch(Dynamic e) { HX_DYNAMIC_SET_FIELD(inName,inValue); }
	return inValue;
}

void HasNodeAccess_obj::__GetFields(Array< ::String> &outFields)
{
	outFields->push(HX_HCSTRING("__x","\x58","\x69","\x48","\x00"));
	HX_APPEND_DYNAMIC_FIELDS(outFields);
	super::__GetFields(outFields);
};

#if HXCPP_SCRIPTABLE
static hx::StorageInfo HasNodeAccess_obj_sMemberStorageInfo[] = {
	{hx::fsObject /*::Xml*/ ,(int)offsetof(HasNodeAccess_obj,_hx___x),HX_HCSTRING("__x","\x58","\x69","\x48","\x00")},
	{ hx::fsUnknown, 0, null()}
};
static hx::StaticInfo *HasNodeAccess_obj_sStaticStorageInfo = 0;
#endif

static ::String HasNodeAccess_obj_sMemberFields[] = {
	HX_HCSTRING("__x","\x58","\x69","\x48","\x00"),
	::String(null()) };

static void HasNodeAccess_obj_sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(HasNodeAccess_obj::__mClass,"__mClass");
};

#ifdef HXCPP_VISIT_ALLOCS
static void HasNodeAccess_obj_sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(HasNodeAccess_obj::__mClass,"__mClass");
};

#endif

hx::Class HasNodeAccess_obj::__mClass;

void HasNodeAccess_obj::__register()
{
	hx::Static(__mClass) = new hx::Class_obj();
	__mClass->mName = HX_HCSTRING("haxe.xml._Fast.HasNodeAccess","\xae","\x9b","\x26","\x5c");
	__mClass->mSuper = &super::__SGetClass();
	__mClass->mConstructEmpty = &__CreateEmpty;
	__mClass->mConstructArgs = &__Create;
	__mClass->mGetStaticField = &hx::Class_obj::GetNoStaticField;
	__mClass->mSetStaticField = &hx::Class_obj::SetNoStaticField;
	__mClass->mMarkFunc = HasNodeAccess_obj_sMarkStatics;
	__mClass->mStatics = hx::Class_obj::dupFunctions(0 /* sStaticFields */);
	__mClass->mMembers = hx::Class_obj::dupFunctions(HasNodeAccess_obj_sMemberFields);
	__mClass->mCanCast = hx::TCanCast< HasNodeAccess_obj >;
#ifdef HXCPP_VISIT_ALLOCS
	__mClass->mVisitFunc = HasNodeAccess_obj_sVisitStatics;
#endif
#ifdef HXCPP_SCRIPTABLE
	__mClass->mMemberStorageInfo = HasNodeAccess_obj_sMemberStorageInfo;
#endif
#ifdef HXCPP_SCRIPTABLE
	__mClass->mStaticStorageInfo = HasNodeAccess_obj_sStaticStorageInfo;
#endif
	hx::_hx_RegisterClass(__mClass->mName, __mClass);
}

} // end namespace haxe