forked from LeenkxTeam/LNXSDK
Update Files
This commit is contained in:
1292
Kha/Backends/Kinc-hxcpp/khacpp/include/Array.h
Normal file
1292
Kha/Backends/Kinc-hxcpp/khacpp/include/Array.h
Normal file
File diff suppressed because it is too large
Load Diff
498
Kha/Backends/Kinc-hxcpp/khacpp/include/Dynamic.h
Normal file
498
Kha/Backends/Kinc-hxcpp/khacpp/include/Dynamic.h
Normal file
@ -0,0 +1,498 @@
|
||||
#ifndef HX_DYNAMIC_H
|
||||
#define HX_DYNAMIC_H
|
||||
|
||||
// --- Dynamic ---------------------------------------------------------------
|
||||
//
|
||||
// The Dynamic class views all classes through the hx::Object interface, and
|
||||
// provides generic access to its pointer.
|
||||
// It uses dynamic_cast to provide strongly-typed access to the real class.
|
||||
|
||||
namespace hx { class Interface; }
|
||||
|
||||
|
||||
|
||||
class HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic : public hx::ObjectPtr<hx::Object>
|
||||
{
|
||||
typedef hx::ObjectPtr<hx::Object> super;
|
||||
|
||||
public:
|
||||
|
||||
Dynamic() {};
|
||||
Dynamic(int inVal);
|
||||
Dynamic(short inVal);
|
||||
Dynamic(unsigned int inVal);
|
||||
Dynamic(unsigned short inVal);
|
||||
Dynamic(unsigned char inVal);
|
||||
Dynamic(signed char inVal);
|
||||
Dynamic(const cpp::CppInt32__ &inVal);
|
||||
Dynamic(bool inVal);
|
||||
Dynamic(double inVal);
|
||||
Dynamic(float inVal);
|
||||
Dynamic(cpp::Int64 inVal);
|
||||
Dynamic(cpp::UInt64 inVal);
|
||||
Dynamic(hx::Object *inObj) : super(inObj) { }
|
||||
Dynamic(const String &inString);
|
||||
Dynamic(const null &inNull) : super(0) { }
|
||||
Dynamic(const Dynamic &inRHS) : super(inRHS.mPtr) { }
|
||||
explicit Dynamic(const HX_CHAR *inStr);
|
||||
Dynamic(const cpp::Variant &inRHS) : super(inRHS.asDynamic()) { }
|
||||
template<typename T>
|
||||
Dynamic(const hx::Native<T *> &inInterface):super(inInterface.ptr ? inInterface->__GetRealObject() : (hx::Object *)0 ) { }
|
||||
#if !defined(__GNUC__) || (defined(__WORDSIZE) && (__WORDSIZE != 64))
|
||||
Dynamic(long inVal);
|
||||
Dynamic(unsigned long inVal);
|
||||
#endif
|
||||
#ifdef __OBJC__
|
||||
#ifdef HXCPP_OBJC
|
||||
Dynamic(const id inObjc);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
template<typename T,typename S>
|
||||
explicit Dynamic(const cpp::Struct<T,S> &inRHS) { *this = inRHS; }
|
||||
template<typename T>
|
||||
explicit Dynamic(const cpp::Pointer<T> &inRHS) { *this = inRHS; }
|
||||
|
||||
|
||||
void Set(bool inVal);
|
||||
void Set(int inVal);
|
||||
void Set(double inVal);
|
||||
void Set(float inVal);
|
||||
|
||||
|
||||
template<typename RESULT> RESULT StaticCast() const;
|
||||
|
||||
inline operator double () const { return mPtr ? mPtr->__ToDouble() : 0.0; }
|
||||
inline operator float () const { return mPtr ? (float)mPtr->__ToDouble() : 0.0f; }
|
||||
inline operator int () const { return mPtr ? mPtr->__ToInt() : 0; }
|
||||
inline operator unsigned int () const { return mPtr ? mPtr->__ToInt() : 0; }
|
||||
inline operator short () const { return mPtr ? mPtr->__ToInt() : 0; }
|
||||
inline operator unsigned short () const { return mPtr ? mPtr->__ToInt() : 0; }
|
||||
inline operator unsigned char () const { return mPtr ? mPtr->__ToInt() : 0; }
|
||||
inline operator char () const { return mPtr ? mPtr->__ToInt() : 0; }
|
||||
inline operator signed char () const { return mPtr ? mPtr->__ToInt() : 0; }
|
||||
inline operator bool() const { return mPtr && mPtr->__ToInt(); }
|
||||
inline operator cpp::Int64() const { return mPtr ? mPtr->__ToInt64() : 0; }
|
||||
inline operator cpp::UInt64() const { return mPtr ? mPtr->__ToInt64() : 0; }
|
||||
|
||||
// Conversion to generic pointer requires you to tag the class with a typedef
|
||||
template<typename T>
|
||||
inline operator typename hx::Native<T *> () const {
|
||||
return hx::Native<T *>(dynamic_cast<T *>(mPtr));
|
||||
}
|
||||
|
||||
|
||||
//inline operator cpp::Variant() const { return cpp::Variant(mPtr); }
|
||||
#ifdef __OBJC__
|
||||
#ifdef HXCPP_OBJC
|
||||
#ifdef OBJC_ARC
|
||||
inline operator id() const { return mPtr ? (__bridge id)mPtr->__GetHandle() : 0; }
|
||||
#else
|
||||
inline operator id() const { return mPtr ? (id)mPtr->__GetHandle() : 0; }
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
inline bool operator !() const { return !mPtr || !mPtr->__ToInt(); }
|
||||
|
||||
hx::IndexRef operator[](int inIndex);
|
||||
inline Dynamic __get(int inIndex) const { return mPtr->__GetItem(inIndex); }
|
||||
|
||||
template<typename SOURCE_>
|
||||
Dynamic(const hx::ObjectPtr<SOURCE_> &inObjectPtr) :
|
||||
hx::ObjectPtr<hx::Object>(inObjectPtr.mPtr) { }
|
||||
|
||||
Dynamic Default(const Dynamic &inDef) { return mPtr ? *this : inDef; }
|
||||
|
||||
template<typename RETURN_>
|
||||
RETURN_ Cast() const { return RETURN_(*this); }
|
||||
|
||||
template<typename CLASS_>
|
||||
bool IsClass() { return CLASS_(mPtr,false).mPtr; }
|
||||
|
||||
static void __boot();
|
||||
|
||||
inline bool IsNumeric() const
|
||||
{
|
||||
if (!mPtr) return false;
|
||||
int t = mPtr->__GetType();
|
||||
return t==vtInt || t==vtFloat;
|
||||
}
|
||||
|
||||
inline bool IsBool() const
|
||||
{
|
||||
if (!mPtr) return false;
|
||||
int t = mPtr->__GetType();
|
||||
return t==vtBool;
|
||||
}
|
||||
|
||||
|
||||
int Compare(const Dynamic &inRHS) const
|
||||
{
|
||||
if (mPtr==0) return inRHS.mPtr==0 ? 0 : -1;
|
||||
if (inRHS.mPtr==0) return -1;
|
||||
#if (HXCPP_API_LEVEL>=331)
|
||||
return mPtr->__Compare(inRHS.mPtr);
|
||||
#else
|
||||
return mPtr->__Compare(inRHS.mPtr->__GetRealObject());
|
||||
#endif
|
||||
}
|
||||
|
||||
bool operator==(const null &inRHS) const { return mPtr==0; }
|
||||
bool operator!=(const null &inRHS) const { return mPtr!=0; }
|
||||
|
||||
bool operator == (const Dynamic &inRHS) const
|
||||
{
|
||||
// Comparing pointers fails in the case on Nan==Nan
|
||||
//if (mPtr==inRHS.mPtr) return true;
|
||||
if (!mPtr && !inRHS.mPtr) return true;
|
||||
if (!mPtr || !inRHS.mPtr) return false;
|
||||
#if (HXCPP_API_LEVEL>=331)
|
||||
return mPtr->__Compare(inRHS.mPtr)==0;
|
||||
#else
|
||||
return mPtr->__Compare(inRHS.mPtr->__GetRealObject())==0;
|
||||
#endif
|
||||
}
|
||||
|
||||
bool operator != (const Dynamic &inRHS) const
|
||||
{
|
||||
// Comparing pointers fails in the case on Nan==Nan
|
||||
//if (mPtr==inRHS.mPtr) return true;
|
||||
if (!mPtr && !inRHS.mPtr) return false;
|
||||
if (!mPtr || !inRHS.mPtr) return true;
|
||||
#if (HXCPP_API_LEVEL>=331)
|
||||
return mPtr->__Compare(inRHS.mPtr)!=0;
|
||||
#else
|
||||
return mPtr->__Compare(inRHS.mPtr->__GetRealObject())!=0;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
bool operator == (const cpp::Variant &inRHS) const { return (*this) == Dynamic(inRHS); }
|
||||
bool operator != (const cpp::Variant &inRHS) const { return (*this) != Dynamic(inRHS); }
|
||||
|
||||
|
||||
#define DYNAMIC_COMPARE_OP( op ) \
|
||||
bool operator op (const String &inRHS) const { return mPtr && ((String)(*this) op inRHS); } \
|
||||
bool operator op (double inRHS) const { return IsNumeric() && ((double)(*this) op inRHS); } \
|
||||
bool operator op (cpp::Int64 inRHS) const { return IsNumeric() && ((cpp::Int64)(*this) op inRHS); } \
|
||||
bool operator op (cpp::UInt64 inRHS) const { return IsNumeric() && ((cpp::Int64)(*this) op inRHS); } \
|
||||
bool operator op (float inRHS) const { return IsNumeric() && ((double)(*this) op inRHS); } \
|
||||
bool operator op (int inRHS) const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
|
||||
bool operator op (unsigned int inRHS) const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
|
||||
bool operator op (short inRHS) const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
|
||||
bool operator op (unsigned short inRHS) const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
|
||||
bool operator op (signed char inRHS) const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
|
||||
bool operator op (unsigned char inRHS) const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
|
||||
bool operator op (bool inRHS) const { return IsBool() && ((double)(*this) op (double)inRHS); } \
|
||||
|
||||
bool operator != (const String &inRHS) const { return !mPtr || ((String)(*this) != inRHS); }
|
||||
bool operator != (double inRHS) const { return !IsNumeric() || ((double)(*this) != inRHS); }
|
||||
bool operator != (cpp::Int64 inRHS) const { return !IsNumeric() || ((cpp::Int64)(*this) != inRHS); }
|
||||
bool operator != (cpp::UInt64 inRHS) const { return !IsNumeric() || ((cpp::Int64)(*this) != inRHS); }
|
||||
bool operator != (float inRHS) const { return !IsNumeric() || ((double)(*this) != inRHS); }
|
||||
bool operator != (int inRHS) const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
|
||||
bool operator != (unsigned int inRHS) const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
|
||||
bool operator != (short inRHS) const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
|
||||
bool operator != (unsigned short inRHS) const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
|
||||
bool operator != (signed char inRHS) const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
|
||||
bool operator != (unsigned char inRHS) const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
|
||||
bool operator != (bool inRHS) const { return !IsBool() || ((double)(*this) != (double)inRHS); }
|
||||
|
||||
|
||||
|
||||
#define DYNAMIC_COMPARE_OP_ALL( op ) \
|
||||
bool operator op (const Dynamic &inRHS) const { return mPtr && (Compare(inRHS) op 0); } \
|
||||
bool operator op (const cpp::Variant &inRHS) const { return *this op Dynamic(inRHS); } \
|
||||
DYNAMIC_COMPARE_OP(op)
|
||||
|
||||
|
||||
DYNAMIC_COMPARE_OP( == )
|
||||
DYNAMIC_COMPARE_OP_ALL( < )
|
||||
DYNAMIC_COMPARE_OP_ALL( <= )
|
||||
DYNAMIC_COMPARE_OP_ALL( >= )
|
||||
DYNAMIC_COMPARE_OP_ALL( > )
|
||||
|
||||
template<typename T_>
|
||||
bool operator==(const hx::ObjectPtr<T_> &inRHS) const
|
||||
{
|
||||
if (mPtr==inRHS.mPtr) return true;
|
||||
if (!mPtr || !inRHS.mPtr) return false;
|
||||
#if (HXCPP_API_LEVEL>=331)
|
||||
return mPtr == inRHS.mPtr;
|
||||
#else
|
||||
return mPtr->__GetRealObject() == inRHS.mPtr->__GetRealObject();
|
||||
#endif
|
||||
}
|
||||
|
||||
template<typename T_>
|
||||
bool operator!=(const hx::ObjectPtr<T_> &inRHS) const
|
||||
{
|
||||
if (mPtr==inRHS.mPtr) return false;
|
||||
if (!mPtr || !inRHS.mPtr) return true;
|
||||
#if (HXCPP_API_LEVEL>=331)
|
||||
return mPtr != inRHS.mPtr;
|
||||
#else
|
||||
return mPtr->__GetRealObject() != inRHS.mPtr->__GetRealObject();
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
// Operator + is different, since it must consider strings too...
|
||||
Dynamic operator+(const Dynamic &inRHS) const;
|
||||
inline String operator+(const String &s) const;
|
||||
|
||||
Dynamic operator+(const cpp::UInt64 &i) const;
|
||||
Dynamic operator+(const cpp::Int64 &i) const;
|
||||
Dynamic operator+(const int &i) const;
|
||||
Dynamic operator+(const unsigned int &i) const;
|
||||
Dynamic operator+(const short &i) const;
|
||||
Dynamic operator+(const unsigned short &i) const;
|
||||
Dynamic operator+(const signed char &i) const;
|
||||
Dynamic operator+(const unsigned char &i) const;
|
||||
Dynamic operator+(const double &d) const;
|
||||
Dynamic operator+(const float &d) const;
|
||||
Dynamic operator+(const cpp::Variant &d) const;
|
||||
|
||||
double operator%(const Dynamic &inRHS) const;
|
||||
double operator-() const { return mPtr ? - mPtr->__ToDouble() : 0.0; }
|
||||
double operator++() { double val = mPtr->__ToDouble() + 1; *this = val; return val; }
|
||||
double operator++(int) {double val = mPtr->__ToDouble(); *this = val+1; return val; }
|
||||
double operator--() { double val = mPtr->__ToDouble() - 1; *this = val; return val; }
|
||||
double operator--(int) {double val = mPtr->__ToDouble(); *this = val-1; return val; }
|
||||
|
||||
|
||||
double operator / (const cpp::Variant &inRHS) const { return (double)(*this) / (double)inRHS; } \
|
||||
double operator / (const Dynamic &inRHS) const { return (double)(*this) / (double)inRHS; } \
|
||||
double operator / (const double &inRHS) const { return (double)(*this) / (double)inRHS; } \
|
||||
double operator / (const float &inRHS) const { return (double)(*this) / (double)inRHS; } \
|
||||
double operator / (const int &inRHS) const { return (double)(*this) / (double)inRHS; }
|
||||
|
||||
#define DYNAMIC_ARITH( op ) \
|
||||
Dynamic operator op (const cpp::Variant &inRHS) const \
|
||||
{ return mPtr->__GetType()==vtInt && inRHS.isInt() ? \
|
||||
Dynamic((int)(*this) op (int)inRHS) : \
|
||||
Dynamic( (double)(*this) op (double)inRHS); } \
|
||||
Dynamic operator op (const Dynamic &inRHS) const \
|
||||
{ return mPtr->__GetType()==vtInt && inRHS.mPtr->__GetType()==vtInt ? \
|
||||
Dynamic((int)(*this) op (int)inRHS) : \
|
||||
Dynamic( (double)(*this) op (double)inRHS); } \
|
||||
double operator op (const double &inRHS) const { return (double)(*this) op (double)inRHS; } \
|
||||
double operator op (const float &inRHS) const { return (double)(*this) op (double)inRHS; } \
|
||||
Dynamic operator op (const int &inRHS) const \
|
||||
{ return mPtr->__GetType()==vtInt ? Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
|
||||
Dynamic operator op (const unsigned int &inRHS) const \
|
||||
{ return mPtr->__GetType()==vtInt ? Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
|
||||
Dynamic operator op (const short &inRHS) const \
|
||||
{ return mPtr->__GetType()==vtInt ? Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
|
||||
Dynamic operator op (const unsigned short &inRHS) const \
|
||||
{ return mPtr->__GetType()==vtInt ? Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
|
||||
Dynamic operator op (const signed char &inRHS) const \
|
||||
{ return mPtr->__GetType()==vtInt ? Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
|
||||
Dynamic operator op (const unsigned char &inRHS) const \
|
||||
{ return mPtr->__GetType()==vtInt ? Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
|
||||
Dynamic operator op (const cpp::Int64 &inRHS) const \
|
||||
{ return Dynamic((double)(*this) op inRHS); } \
|
||||
Dynamic operator op (const cpp::UInt64 &inRHS) const \
|
||||
{ return Dynamic((double)(*this) op inRHS); } \
|
||||
|
||||
DYNAMIC_ARITH( - )
|
||||
DYNAMIC_ARITH( * )
|
||||
|
||||
static void ThrowBadFunctionError();
|
||||
inline void CheckFPtr() { if (!mPtr) ThrowBadFunctionError(); }
|
||||
|
||||
inline ::Dynamic operator()() { CheckFPtr(); return mPtr->__run(); }
|
||||
inline ::Dynamic operator()(const Dynamic &inArg0) { CheckFPtr(); return mPtr->__run(inArg0); }
|
||||
inline ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1) { CheckFPtr(); return mPtr->__run(inArg0,inArg1); }
|
||||
inline ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2) { CheckFPtr(); return mPtr->__run(inArg0,inArg1,inArg2); }
|
||||
inline ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3) { CheckFPtr(); return mPtr->__run(inArg0,inArg1,inArg2,inArg3); }
|
||||
inline ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4) { CheckFPtr(); return mPtr->__run(inArg0,inArg1,inArg2,inArg3,inArg4); }
|
||||
|
||||
HX_DECLARE_DYNAMIC_FUNCTIONS;
|
||||
|
||||
|
||||
typedef const Dynamic &D;
|
||||
};
|
||||
|
||||
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
inline hx::Object *DynamicPtr(Dynamic inVal) { return inVal.mPtr; }
|
||||
|
||||
typedef Dynamic (*MemberFunction0)(hx::Object *inObj);
|
||||
typedef Dynamic (*MemberFunction1)(hx::Object *inObj,const Dynamic &inArg0);
|
||||
typedef Dynamic (*MemberFunction2)(hx::Object *inObj,const Dynamic &inArg0,const Dynamic &inArg1);
|
||||
typedef Dynamic (*MemberFunction3)(hx::Object *inObj,const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2);
|
||||
typedef Dynamic (*MemberFunction4)(hx::Object *inObj,const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3);
|
||||
typedef Dynamic (*MemberFunction5)(hx::Object *inObj,const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4);
|
||||
typedef Dynamic (*MemberFunctionVar)(hx::Object *inObj,const Array<Dynamic> &inArgs);
|
||||
|
||||
typedef Dynamic (*StaticFunction0)();
|
||||
typedef Dynamic (*StaticFunction1)(const Dynamic &inArg0);
|
||||
typedef Dynamic (*StaticFunction2)(const Dynamic &inArg0,const Dynamic &inArg1);
|
||||
typedef Dynamic (*StaticFunction3)(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2);
|
||||
typedef Dynamic (*StaticFunction4)(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3);
|
||||
typedef Dynamic (*StaticFunction5)(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4);
|
||||
typedef Dynamic (*StaticFunction6)(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5);
|
||||
typedef Dynamic (*StaticFunctionVar)(const Array<Dynamic> &inArgs);
|
||||
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic CreateMemberFunction0(const char *,hx::Object *, MemberFunction0);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic CreateMemberFunction1(const char *,hx::Object *, MemberFunction1);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic CreateMemberFunction2(const char *,hx::Object *, MemberFunction2);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic CreateMemberFunction3(const char *,hx::Object *, MemberFunction3);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic CreateMemberFunction4(const char *,hx::Object *, MemberFunction4);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic CreateMemberFunction5(const char *,hx::Object *, MemberFunction5);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic CreateMemberFunctionVar(const char *,hx::Object *, MemberFunctionVar,int inN);
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic CreateStaticFunction0(const char *,StaticFunction0);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic CreateStaticFunction1(const char *,StaticFunction1);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic CreateStaticFunction2(const char *,StaticFunction2);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic CreateStaticFunction3(const char *,StaticFunction3);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic CreateStaticFunction4(const char *,StaticFunction4);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic CreateStaticFunction5(const char *,StaticFunction5);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic CreateStaticFunction6(const char *,StaticFunction6);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic CreateStaticFunctionVar(const char *,StaticFunctionVar,int inN);
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<>
|
||||
inline int Dynamic::Cast<int>() const { return mPtr ? mPtr->__ToInt() : 0; }
|
||||
template<>
|
||||
inline bool Dynamic::Cast<bool>() const { return mPtr ? mPtr->__ToInt() : 0; }
|
||||
template<>
|
||||
inline double Dynamic::Cast<double>() const { return mPtr ? mPtr->__ToDouble() : 0; }
|
||||
template<>
|
||||
inline float Dynamic::Cast<float>() const { return mPtr ? mPtr->__ToDouble() : 0; }
|
||||
template<>
|
||||
inline String Dynamic::Cast<String>() const { return mPtr ? mPtr->toString() : String(null()); }
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Gets the class definition that relates to a specific type.
|
||||
// Most classes have their own class data, by the standard types (non-classes)
|
||||
// use the template traits to get the class
|
||||
|
||||
namespace hx
|
||||
{
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetIntClass();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetFloatClass();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetBoolClass();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetVoidClass();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetStringClass();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetInt64Class();
|
||||
}
|
||||
|
||||
template<>
|
||||
inline bool Dynamic::IsClass<int>() { return mPtr && mPtr->__GetClass()==hx::GetIntClass(); }
|
||||
template<>
|
||||
inline bool Dynamic::IsClass<double>() { return mPtr &&
|
||||
( mPtr->__GetClass()==hx::GetIntClass() || mPtr->__GetClass()==hx::GetFloatClass()) ; }
|
||||
template<>
|
||||
inline bool Dynamic::IsClass<float>() { return mPtr && mPtr->__GetClass()==hx::GetFloatClass(); }
|
||||
template<>
|
||||
inline bool Dynamic::IsClass<bool>() { return mPtr && mPtr->__GetClass()==hx::GetBoolClass(); }
|
||||
template<>
|
||||
inline bool Dynamic::IsClass<null>() { return !mPtr; }
|
||||
template<>
|
||||
inline bool Dynamic::IsClass<String>() { return mPtr && mPtr->__GetClass()==hx::GetStringClass(); }
|
||||
template<>
|
||||
inline bool Dynamic::IsClass<Dynamic>() { return true; }
|
||||
template<>
|
||||
inline bool Dynamic::IsClass< ::cpp::Int64>() { return mPtr && mPtr->__GetClass()==hx::GetInt64Class(); }
|
||||
|
||||
inline String Dynamic::operator+(const String &s) const { return Cast<String>() + s; }
|
||||
|
||||
#define HX_DYNAMIC_OP_ISEQ(T) \
|
||||
inline bool operator == (const T &inLHS,const Dynamic &inRHS) { return inRHS==inLHS; } \
|
||||
inline bool operator != (const T &inLHS,const Dynamic &inRHS) { return inRHS!=inLHS; }
|
||||
|
||||
HX_DYNAMIC_OP_ISEQ(String)
|
||||
HX_DYNAMIC_OP_ISEQ(double)
|
||||
HX_DYNAMIC_OP_ISEQ(float)
|
||||
HX_DYNAMIC_OP_ISEQ(int)
|
||||
HX_DYNAMIC_OP_ISEQ(bool)
|
||||
|
||||
inline bool operator < (bool inLHS,const Dynamic &inRHS) { return false; }
|
||||
inline bool operator <= (bool inLHS,const Dynamic &inRHS) { return false; }
|
||||
inline bool operator >= (bool inLHS,const Dynamic &inRHS) { return false; }
|
||||
inline bool operator > (bool inLHS,const Dynamic &inRHS) { return false; }
|
||||
|
||||
#if defined(HX_WINRT) && defined(__cplusplus_winrt)
|
||||
// Try to avoid the compiler using injected Box::operator int and Dynamic(null) when doing ==
|
||||
template<typename T>
|
||||
bool operator==(Platform::Box<T> ^inPtr, nullptr_t)
|
||||
{
|
||||
void* ptr = (void*) reinterpret_cast<void*>(inPtr);
|
||||
return ptr==nullptr;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#define COMPARE_DYNAMIC_OP( op ) \
|
||||
inline bool operator op (double inLHS,const ::Dynamic &inRHS) \
|
||||
{ return inRHS.IsNumeric() && (inLHS op (double)inRHS); } \
|
||||
inline bool operator op (float inLHS,const ::Dynamic &inRHS) \
|
||||
{ return inRHS.IsNumeric() && ((double)inLHS op (double)inRHS); } \
|
||||
inline bool operator op (int inLHS,const ::Dynamic &inRHS) \
|
||||
{ return inRHS.IsNumeric() && (inLHS op (double)inRHS); }
|
||||
|
||||
COMPARE_DYNAMIC_OP( < )
|
||||
COMPARE_DYNAMIC_OP( <= )
|
||||
COMPARE_DYNAMIC_OP( >= )
|
||||
COMPARE_DYNAMIC_OP( > )
|
||||
|
||||
|
||||
#define ARITH_DYNAMIC( op ) \
|
||||
inline double operator op (const cpp::Int64 &inLHS,const Dynamic &inRHS) { return inLHS op (cpp::Int64)inRHS;} \
|
||||
inline double operator op (const cpp::UInt64 &inLHS,const Dynamic &inRHS) { return inLHS op (cpp::UInt64)inRHS;} \
|
||||
inline double operator op (const double &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS;} \
|
||||
inline double operator op (const float &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS;} \
|
||||
inline double operator op (const int &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
|
||||
inline double operator op (const unsigned int &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
|
||||
inline double operator op (const short &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
|
||||
inline double operator op (const unsigned short &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
|
||||
inline double operator op (const signed char &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
|
||||
inline double operator op (const unsigned char &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
|
||||
|
||||
ARITH_DYNAMIC( - )
|
||||
ARITH_DYNAMIC( + )
|
||||
ARITH_DYNAMIC( / )
|
||||
ARITH_DYNAMIC( * )
|
||||
|
||||
double operator%(const int &inLHS,const Dynamic &inRHS);
|
||||
double operator%(const double &inLHS,const Dynamic &inRHS);
|
||||
double operator%(const float &inLHS,const Dynamic &inRHS);
|
||||
|
||||
template<typename T,typename H> String::String(const cpp::Struct<T,H> &inRHS) { *this = (String)inRHS; }
|
||||
template<typename OBJ> String::String(const hx::ObjectPtr<OBJ> &inRHS) { *this = Dynamic(inRHS); }
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
196
Kha/Backends/Kinc-hxcpp/khacpp/include/Enum.h
Normal file
196
Kha/Backends/Kinc-hxcpp/khacpp/include/Enum.h
Normal file
@ -0,0 +1,196 @@
|
||||
#ifndef HX_ENUM_H
|
||||
#define HX_ENUM_H
|
||||
|
||||
|
||||
|
||||
// Enum (ie enum object class def) is the same as Class.
|
||||
typedef hx::Class Enum;
|
||||
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
// --- hx::EnumBase_obj ----------------------------------------------------------
|
||||
//
|
||||
// Base class for Enums.
|
||||
// Specializations of this class don't actually add more data, just extra constructors
|
||||
// and type information.
|
||||
|
||||
class HXCPP_EXTERN_CLASS_ATTRIBUTES EnumBase_obj : public hx::Object
|
||||
{
|
||||
typedef hx::Object super;
|
||||
typedef EnumBase_obj OBJ_;
|
||||
|
||||
|
||||
protected:
|
||||
#if (HXCPP_API_LEVEL >= 330)
|
||||
String _hx_tag;
|
||||
int mFixedFields;
|
||||
#ifdef HXCPP_SCRIPTABLE
|
||||
struct CppiaClassInfo *classInfo;
|
||||
#endif
|
||||
#else
|
||||
String tag;
|
||||
DynamicArray mArgs;
|
||||
#endif
|
||||
public:
|
||||
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdEnum };
|
||||
|
||||
int index;
|
||||
|
||||
public:
|
||||
inline void *operator new( size_t inSize, int inExtra=0)
|
||||
{
|
||||
return hx::Object::operator new(inSize+inExtra, true, 0);
|
||||
}
|
||||
inline void operator delete(void *, int inExtra ) { }
|
||||
inline void operator delete(void *, size_t inSize ) { }
|
||||
inline void operator delete(void *, size_t inSize, int inExtra ) { }
|
||||
|
||||
|
||||
HX_DO_ENUM_RTTI_INTERNAL;
|
||||
static hx::ObjectPtr<hx::Class_obj> &__SGetClass();
|
||||
|
||||
|
||||
String toString();
|
||||
|
||||
EnumBase_obj() : index(-1) { }
|
||||
EnumBase_obj(const null &inNull) : index(-1) { }
|
||||
int __GetType() const { return vtEnum; }
|
||||
static Dynamic __CreateEmpty();
|
||||
static Dynamic __Create(DynamicArray inArgs);
|
||||
static void __boot();
|
||||
|
||||
void __Mark(hx::MarkContext *__inCtx);
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
void __Visit(hx::VisitContext *__inCtx);
|
||||
#endif
|
||||
|
||||
static hx::ObjectPtr<EnumBase_obj> Resolve(String inName);
|
||||
inline static bool __GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp) { return false; }
|
||||
|
||||
#if (HXCPP_API_LEVEL >= 330)
|
||||
inline cpp::Variant *_hx_getFixed() { return (cpp::Variant *)(this + 1); }
|
||||
inline const cpp::Variant *_hx_getFixed() const { return (cpp::Variant *)(this + 1); }
|
||||
inline ::Dynamic __Param(int inID) { return _hx_getFixed()[inID]; }
|
||||
template<typename T>
|
||||
inline EnumBase_obj *_hx_init(int inIndex,const T &inValue)
|
||||
{
|
||||
#ifdef HXCPP_GC_GENERATIONAL
|
||||
cpp::Variant &v = _hx_getFixed()[inIndex];
|
||||
v = inValue;
|
||||
if (v.type<=cpp::Variant::typeString)
|
||||
HX_OBJ_WB_GET(this, v.valObject);
|
||||
#else
|
||||
_hx_getFixed()[inIndex] = inValue;
|
||||
#endif
|
||||
return this;
|
||||
}
|
||||
inline void _hx_setIdentity(const String &inTag, int inIndex,int inFixedFields)
|
||||
{
|
||||
_hx_tag = inTag;
|
||||
HX_OBJ_WB_GET(this, _hx_tag.__s);
|
||||
index = inIndex;
|
||||
mFixedFields = inFixedFields;
|
||||
}
|
||||
DynamicArray _hx_getParameters();
|
||||
|
||||
inline ::Dynamic _hx_getObject(int inId) { return _hx_getFixed()[inId].asDynamic(); }
|
||||
inline int _hx_getInt(int inId) { return _hx_getFixed()[inId]; }
|
||||
inline ::cpp::Int64 _hx_getInt64(int inId) { return _hx_getFixed()[inId].asInt64(); }
|
||||
inline Float _hx_getFloat(int inId) { return _hx_getFixed()[inId]; }
|
||||
inline bool _hx_getBool(int inId) { return _hx_getFixed()[inId]; }
|
||||
inline ::String _hx_getString(int inId) { return _hx_getFixed()[inId].asString(); }
|
||||
inline ::Dynamic _hx_getParamI(int inId) { return _hx_getFixed()[inId]; }
|
||||
inline int _hx_getParamCount() { return mFixedFields; }
|
||||
// Alias for _hx_getParamI
|
||||
Dynamic __GetItem(int inIndex) const;
|
||||
|
||||
// For legacy
|
||||
inline String __Tag() const { return _hx_tag; }
|
||||
|
||||
|
||||
String _hx_getTag() const { return _hx_tag; }
|
||||
int _hx_getIndex() const { return index; }
|
||||
#else
|
||||
Dynamic __Param(int inID) { return mArgs[inID]; }
|
||||
DynamicArray __EnumParams() { return mArgs; }
|
||||
String __Tag() const { return tag; }
|
||||
int __Index() const { return index; }
|
||||
|
||||
void __Set( const String &inName,int inIndex,DynamicArray inArgs)
|
||||
{
|
||||
tag = inName;
|
||||
index = inIndex;
|
||||
mArgs = inArgs;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
int __Compare(const hx::Object *inRHS) const;
|
||||
|
||||
virtual String GetEnumName( ) const { return HX_CSTRING("Enum"); }
|
||||
};
|
||||
|
||||
|
||||
typedef hx::ObjectPtr<EnumBase_obj> EnumBase;
|
||||
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __hxcpp_enum_eq( ::hx::EnumBase a, ::hx::EnumBase b);
|
||||
|
||||
// --- CreateEnum -------------------------------------------------------------
|
||||
//
|
||||
// Template function to return a strongly-typed version fo the Enum.
|
||||
// Most of the common stuff is in "Set".
|
||||
|
||||
#if (HXCPP_API_LEVEL >= 330)
|
||||
template<typename ENUM>
|
||||
ENUM *CreateEnum(const String &inName,int inIndex, int inFields)
|
||||
{
|
||||
ENUM *result = new (inFields*sizeof(cpp::Variant)) ENUM;
|
||||
result->_hx_setIdentity(inName,inIndex,inFields);
|
||||
return result;
|
||||
}
|
||||
|
||||
template<typename ENUM>
|
||||
ENUM *CreateConstEnum(const String &inName,int inIndex)
|
||||
{
|
||||
ENUM vtable;
|
||||
ENUM *result = (ENUM *)hx::InternalCreateConstBuffer(&vtable,sizeof(ENUM));
|
||||
result->_hx_setIdentity(inName,inIndex,0);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
#else
|
||||
template<typename ENUM>
|
||||
hx::ObjectPtr<ENUM> CreateEnum(const String &inName,int inIndex, DynamicArray inArgs=DynamicArray())
|
||||
{
|
||||
ENUM *result = new ENUM;
|
||||
result->__Set(inName,inIndex,inArgs);
|
||||
return result;
|
||||
}
|
||||
#endif
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
#if (HXCPP_API_LEVEL >= 330)
|
||||
inline int _hx_getEnumValueIndex(hx::EnumBase inEnum)
|
||||
{
|
||||
return inEnum->_hx_getIndex();
|
||||
}
|
||||
#endif
|
||||
|
||||
inline void __hxcpp_enum_force(hx::EnumBase inEnum,String inForceName, int inIndex)
|
||||
{
|
||||
#if (HXCPP_API_LEVEL >= 330)
|
||||
inEnum->_hx_setIdentity(inForceName, inIndex,0);
|
||||
#else
|
||||
hx::DynamicArray empty;
|
||||
inEnum->__Set(inForceName, inIndex, empty);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
92
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp/CppInt32__.h
Normal file
92
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp/CppInt32__.h
Normal file
@ -0,0 +1,92 @@
|
||||
#ifndef INCLUDED_haxe_CppInt32__
|
||||
#define INCLUDED_haxe_CppInt32__
|
||||
|
||||
#include <hxcpp.h>
|
||||
|
||||
namespace cpp
|
||||
{
|
||||
|
||||
#define HX_I32_DEF_FUNC1(Name) \
|
||||
static inline Dynamic __##Name(const Dynamic &a) { return Name(a); } \
|
||||
static inline Dynamic Name##_dyn() { return hx::CreateStaticFunction1(#Name,&CppInt32__::__##Name); }
|
||||
|
||||
#define HX_I32_DEF_FUNC2(Name) \
|
||||
static inline Dynamic __##Name(const Dynamic &a, const Dynamic &b) { return Name(a,b); } \
|
||||
static inline Dynamic Name##_dyn() { return hx::CreateStaticFunction2(#Name,&CppInt32__::__##Name); }
|
||||
|
||||
class CppInt32__
|
||||
{
|
||||
public:
|
||||
CppInt32__(int inX=0) : mValue(inX) { }
|
||||
CppInt32__(const null &inNull) : mValue(0) { }
|
||||
CppInt32__(const Dynamic &inD);
|
||||
operator int() const { return mValue; }
|
||||
template<typename T>
|
||||
inline CppInt32__ &operator=(T inValue) { mValue = inValue; return *this; }
|
||||
|
||||
static inline CppInt32__ make(int a,int b) { return CppInt32__( (a<<16) | b ); }
|
||||
static inline CppInt32__ ofInt(int a) { return CppInt32__( a ); }
|
||||
static inline int toInt(CppInt32__ a) { __hxcpp_check_overflow(a); return a.mValue; }
|
||||
static inline int toNativeInt(CppInt32__ a) { return a.mValue; }
|
||||
static inline CppInt32__ add(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue + b.mValue ); }
|
||||
static inline CppInt32__ sub(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue - b.mValue ); }
|
||||
static inline CppInt32__ mul(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue * b.mValue ); }
|
||||
static inline CppInt32__ div(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue / b.mValue ); }
|
||||
static inline CppInt32__ mod(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue % b.mValue ); }
|
||||
static inline CppInt32__ shl(CppInt32__ a,int b) { return CppInt32__( a.mValue << (b&31) ); }
|
||||
static inline CppInt32__ shr(CppInt32__ a,int b) { return CppInt32__( a.mValue >> (b&31) ); }
|
||||
static inline CppInt32__ ushr(CppInt32__ a,int b) { return CppInt32__( ((unsigned int)a.mValue) >> (b&31) ); }
|
||||
static inline CppInt32__ _and(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue & b.mValue ); }
|
||||
static inline CppInt32__ _or(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue | b.mValue ); }
|
||||
static inline CppInt32__ _xor(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue ^ b.mValue ); }
|
||||
static inline CppInt32__ neg(CppInt32__ a) { return CppInt32__( -a.mValue ); }
|
||||
static inline CppInt32__ complement(CppInt32__ a) { return CppInt32__( ~a.mValue ); }
|
||||
static inline int compare(CppInt32__ a,CppInt32__ b) { return ( a.mValue - b.mValue ); }
|
||||
static inline bool isNeg(CppInt32__ a) { return a.mValue < 0; }
|
||||
static inline bool isZero(CppInt32__ a) { return a.mValue == 0; }
|
||||
static inline int ucompare(CppInt32__ a,CppInt32__ b) { unsigned int am = a.mValue, bm = b.mValue; return (am == bm) ? 0 : ((am > bm) ? 1 : -1); }
|
||||
|
||||
|
||||
inline bool operator==(const CppInt32__ &inRHS) const { return mValue == inRHS.mValue; }
|
||||
|
||||
inline int operator-(CppInt32__ b) { return mValue - b.mValue; }
|
||||
inline int operator+(CppInt32__ b) { return mValue + b.mValue; }
|
||||
inline int operator*(CppInt32__ b) { return mValue * b.mValue; }
|
||||
inline int operator/(CppInt32__ b) { return mValue / b.mValue; }
|
||||
inline int operator%(CppInt32__ b) { return mValue % b.mValue; }
|
||||
|
||||
HX_I32_DEF_FUNC2(make)
|
||||
HX_I32_DEF_FUNC1(ofInt)
|
||||
HX_I32_DEF_FUNC1(toInt)
|
||||
HX_I32_DEF_FUNC1(toNativeInt)
|
||||
HX_I32_DEF_FUNC2(add)
|
||||
HX_I32_DEF_FUNC2(sub)
|
||||
HX_I32_DEF_FUNC2(mul)
|
||||
HX_I32_DEF_FUNC2(div)
|
||||
HX_I32_DEF_FUNC2(mod)
|
||||
HX_I32_DEF_FUNC2(shl)
|
||||
HX_I32_DEF_FUNC2(shr)
|
||||
HX_I32_DEF_FUNC2(ushr)
|
||||
HX_I32_DEF_FUNC2(_and)
|
||||
HX_I32_DEF_FUNC2(_or)
|
||||
HX_I32_DEF_FUNC2(_xor)
|
||||
HX_I32_DEF_FUNC1(neg)
|
||||
HX_I32_DEF_FUNC1(complement)
|
||||
HX_I32_DEF_FUNC2(compare)
|
||||
HX_I32_DEF_FUNC2(ucompare)
|
||||
HX_I32_DEF_FUNC1(isNeg)
|
||||
HX_I32_DEF_FUNC1(isZero)
|
||||
|
||||
int mValue;
|
||||
};
|
||||
|
||||
typedef CppInt32__ CppInt32___obj;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
108
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp/FastIterator.h
Normal file
108
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp/FastIterator.h
Normal file
@ -0,0 +1,108 @@
|
||||
#ifndef INCLUDED_cpp_FastIterator
|
||||
#define INCLUDED_cpp_FastIterator
|
||||
|
||||
namespace cpp
|
||||
{
|
||||
|
||||
class HXCPP_EXTERN_CLASS_ATTRIBUTES IteratorBase : public hx::Object
|
||||
{
|
||||
public:
|
||||
hx::Val __Field(const String &inString ,hx::PropertyAccess inCallProp);
|
||||
virtual bool hasNext() = 0;
|
||||
virtual Dynamic _dynamicNext() = 0;
|
||||
|
||||
Dynamic hasNext_dyn( );
|
||||
Dynamic next_dyn( );
|
||||
Dynamic _dynamicNext_dyn( );
|
||||
};
|
||||
|
||||
|
||||
template<typename T>
|
||||
class HXCPP_EXTERN_CLASS_ATTRIBUTES FastIterator_obj : public IteratorBase
|
||||
{
|
||||
public:
|
||||
virtual bool hasNext() = 0;
|
||||
virtual T next() = 0;
|
||||
|
||||
virtual Dynamic _dynamicNext() { return next(); }
|
||||
};
|
||||
|
||||
|
||||
|
||||
template<typename T>
|
||||
class HXCPP_EXTERN_CLASS_ATTRIBUTES DynamicIterator : public FastIterator_obj<T>
|
||||
{
|
||||
public:
|
||||
Dynamic mNext;
|
||||
Dynamic mHasNext;
|
||||
|
||||
DynamicIterator(Dynamic inValue)
|
||||
{
|
||||
mNext = inValue->__Field(HX_CSTRING("next"), HX_PROP_ALWAYS);
|
||||
mHasNext = inValue->__Field(HX_CSTRING("hasNext"), HX_PROP_ALWAYS);
|
||||
}
|
||||
|
||||
bool hasNext() { return mHasNext(); }
|
||||
T next() { return mNext(); }
|
||||
|
||||
void __Mark(hx::MarkContext *__inCtx)
|
||||
{
|
||||
HX_MARK_MEMBER_NAME(mNext,"mNext");
|
||||
HX_MARK_MEMBER_NAME(mHasNext,"mHasNext");
|
||||
}
|
||||
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
void __Visit(hx::VisitContext *__inCtx)
|
||||
{
|
||||
HX_VISIT_MEMBER_NAME(mNext,"mNext");
|
||||
HX_VISIT_MEMBER_NAME(mHasNext,"mHasNext");
|
||||
}
|
||||
#endif
|
||||
|
||||
};
|
||||
|
||||
|
||||
template<typename T>
|
||||
FastIterator_obj<T> *CreateFastIterator(Dynamic inValue)
|
||||
{
|
||||
FastIterator_obj<T> *result = dynamic_cast< FastIterator_obj<T> *>(inValue.GetPtr());
|
||||
if (result) return result;
|
||||
return new DynamicIterator<T>(inValue);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
class HXCPP_EXTERN_CLASS_ATTRIBUTES StringIterator : public cpp::FastIterator_obj<T>
|
||||
{
|
||||
public:
|
||||
String value;
|
||||
int pos;
|
||||
|
||||
StringIterator(const String &inValue) : value(inValue), pos(0) { }
|
||||
|
||||
bool hasNext() { return pos<value.length; }
|
||||
void __Mark(hx::MarkContext *__inCtx)
|
||||
{
|
||||
cpp::FastIterator_obj<T>::__Mark(__inCtx);
|
||||
HX_MARK_MEMBER_NAME(value,"value");
|
||||
}
|
||||
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
void __Visit(hx::VisitContext *__inCtx)
|
||||
{
|
||||
cpp::FastIterator_obj<T>::__Visit(__inCtx);
|
||||
HX_VISIT_MEMBER_NAME(value,"value");
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
148
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp/Int64.h
Normal file
148
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp/Int64.h
Normal file
@ -0,0 +1,148 @@
|
||||
#ifndef CPP_INT64_INCLUDED
|
||||
#define CPP_INT64_INCLUDED
|
||||
|
||||
namespace cpp
|
||||
{
|
||||
|
||||
class Int64Handler
|
||||
{
|
||||
public:
|
||||
static inline const char *getName() { return "cpp.Int64"; }
|
||||
static inline String toString( const void *inValue ) { return String( *(Int64 *)inValue ); }
|
||||
static inline void handler(DynamicHandlerOp op, void *ioValue,int inSize, void *outResult)
|
||||
{
|
||||
if (op==dhoToString)
|
||||
*(String *)outResult = toString(ioValue);
|
||||
else if (op==dhoGetClassName)
|
||||
*(const char **)outResult = getName();
|
||||
else if (op==dhoFromDynamic)
|
||||
{
|
||||
StructHandlerDynamicParams *params = (StructHandlerDynamicParams *)outResult;
|
||||
cpp::Int64 &value = *(cpp::Int64 *)ioValue;
|
||||
params->outProcessed = true;
|
||||
if (!params->inData)
|
||||
value = 0;
|
||||
else
|
||||
value = params->inData->__ToInt64();
|
||||
}
|
||||
else if (op==dhoToDynamic)
|
||||
{
|
||||
Dynamic value = *(cpp::Int64 *)ioValue;
|
||||
*(hx::Object **)outResult = value.mPtr;
|
||||
}
|
||||
else if (op==dhoIs)
|
||||
{
|
||||
StructHandlerDynamicParams *params = (StructHandlerDynamicParams *)outResult;
|
||||
hx::Object *obj = params->inData;
|
||||
int type = obj->__GetType();
|
||||
params->outProcessed = type==vtInt || type==vtInt64;
|
||||
}
|
||||
else
|
||||
return DefaultStructHandler::handler(op,ioValue,inSize, outResult);
|
||||
}
|
||||
};
|
||||
|
||||
typedef Struct<Int64,Int64Handler> Int64Struct;
|
||||
|
||||
|
||||
}
|
||||
|
||||
#if (HXCPP_API_LEVEL >= 420)
|
||||
|
||||
inline cpp::Int64 _hx_int64_make(int a, int b) { return (((cpp::Int64)(unsigned int)a)<<32) | (unsigned int)b; }
|
||||
inline bool _hx_int64_is_neg(cpp::Int64 a) { return a<0; }
|
||||
inline bool _hx_int64_is_zero(cpp::Int64 a) { return a==0; }
|
||||
inline bool _hx_int64_eq(cpp::Int64 a, cpp::Int64 b) { return a==b; }
|
||||
inline bool _hx_int64_neq(cpp::Int64 a, cpp::Int64 b) { return a!=b; }
|
||||
inline int _hx_int64_compare(cpp::Int64 a, cpp::Int64 b)
|
||||
{
|
||||
return a==b ? 0 : a<b ? -1 : 1;
|
||||
}
|
||||
inline int _hx_int64_ucompare(cpp::Int64 a, cpp::Int64 b)
|
||||
{
|
||||
return a==b ? 0 : ( ::cpp::UInt64)a<( ::cpp::UInt64)b ? -1 : 1;
|
||||
}
|
||||
inline String _hx_int64_to_string(cpp::Int64 a) { return a; }
|
||||
|
||||
inline cpp::Int64 _hx_int64_neg(cpp::Int64 a) { return -a; }
|
||||
inline cpp::Int64 _hx_int64_complement(cpp::Int64 a) { return ~a; }
|
||||
|
||||
inline cpp::Int64 _hx_int64_pre_increment(cpp::Int64 &ioVal) {
|
||||
return ++ioVal;
|
||||
}
|
||||
inline cpp::Int64 _hx_int64_post_increment(cpp::Int64 &ioVal) {
|
||||
return ioVal++;
|
||||
}
|
||||
inline cpp::Int64 _hx_int64_pre_decrement(cpp::Int64 &ioVal) {
|
||||
return --ioVal;
|
||||
}
|
||||
inline cpp::Int64 _hx_int64_post_decrement(cpp::Int64 &ioVal) {
|
||||
return ioVal--;
|
||||
}
|
||||
|
||||
inline cpp::Int64 _hx_int64_sub(cpp::Int64 a, cpp::Int64 b) { return a-b; }
|
||||
inline cpp::Int64 _hx_int64_add(cpp::Int64 a, cpp::Int64 b) { return a+b; }
|
||||
inline cpp::Int64 _hx_int64_mul(cpp::Int64 a, cpp::Int64 b) { return a*b; }
|
||||
inline cpp::Int64 _hx_int64_div(cpp::Int64 a, cpp::Int64 b) { return a/b; }
|
||||
inline cpp::Int64 _hx_int64_mod(cpp::Int64 a, cpp::Int64 b) { return a%b; }
|
||||
inline cpp::Int64 _hx_int64_and(cpp::Int64 a, cpp::Int64 b) { return a&b; }
|
||||
inline cpp::Int64 _hx_int64_or(cpp::Int64 a, cpp::Int64 b) { return a|b; }
|
||||
inline cpp::Int64 _hx_int64_xor(cpp::Int64 a, cpp::Int64 b) { return a^b; }
|
||||
inline cpp::Int64 _hx_int64_shl(cpp::Int64 a, int b) { return a<<(b&63); }
|
||||
inline cpp::Int64 _hx_int64_shr(cpp::Int64 a, int b) { return a>>(b&63); }
|
||||
inline cpp::Int64 _hx_int64_ushr(cpp::Int64 a, int b) { return ((cpp::UInt64)a)>>(b&63); }
|
||||
inline int _hx_int64_high(cpp::Int64 a) { return (int)( a >> 32 ); }
|
||||
inline int _hx_int64_low(cpp::Int64 a) { return (int)( a & 0xffffffff ); }
|
||||
|
||||
#else
|
||||
|
||||
inline cpp::Int64Struct _hx_int64_make(int a, int b) { return (((cpp::Int64)(unsigned int)a)<<32) | (unsigned int)b; }
|
||||
inline bool _hx_int64_is_neg(cpp::Int64 a) { return a<0; }
|
||||
inline bool _hx_int64_is_zero(cpp::Int64 a) { return a==0; }
|
||||
inline bool _hx_int64_eq(cpp::Int64 a, cpp::Int64 b) { return a==b; }
|
||||
inline bool _hx_int64_neq(cpp::Int64 a, cpp::Int64 b) { return a!=b; }
|
||||
inline int _hx_int64_compare(cpp::Int64 a, cpp::Int64 b)
|
||||
{
|
||||
return a==b ? 0 : a<b ? -1 : 1;
|
||||
}
|
||||
inline int _hx_int64_ucompare(cpp::Int64 a, cpp::Int64 b)
|
||||
{
|
||||
return a==b ? 0 : ( ::cpp::UInt64)a<( ::cpp::UInt64)b ? -1 : 1;
|
||||
}
|
||||
inline String _hx_int64_to_string(cpp::Int64Struct a) { return a; }
|
||||
|
||||
inline cpp::Int64Struct _hx_int64_neg(cpp::Int64 a) { return -a; }
|
||||
inline cpp::Int64Struct _hx_int64_complement(cpp::Int64 a) { return ~a; }
|
||||
|
||||
inline cpp::Int64Struct _hx_int64_pre_increment(cpp::Int64Struct &ioVal) {
|
||||
return ++ioVal.get();
|
||||
}
|
||||
inline cpp::Int64Struct _hx_int64_post_increment(cpp::Int64Struct &ioVal) {
|
||||
return ioVal.get()++;
|
||||
}
|
||||
inline cpp::Int64Struct _hx_int64_pre_decrement(cpp::Int64Struct &ioVal) {
|
||||
return --ioVal.get();
|
||||
}
|
||||
inline cpp::Int64Struct _hx_int64_post_decrement(cpp::Int64Struct &ioVal) {
|
||||
return ioVal.get()--;
|
||||
}
|
||||
|
||||
inline cpp::Int64Struct _hx_int64_sub(cpp::Int64 a, cpp::Int64 b) { return a-b; }
|
||||
inline cpp::Int64Struct _hx_int64_add(cpp::Int64 a, cpp::Int64 b) { return a+b; }
|
||||
inline cpp::Int64Struct _hx_int64_mul(cpp::Int64 a, cpp::Int64 b) { return a*b; }
|
||||
inline cpp::Int64Struct _hx_int64_div(cpp::Int64 a, cpp::Int64 b) { return a/b; }
|
||||
inline cpp::Int64Struct _hx_int64_mod(cpp::Int64 a, cpp::Int64 b) { return a%b; }
|
||||
inline cpp::Int64Struct _hx_int64_and(cpp::Int64 a, cpp::Int64 b) { return a&b; }
|
||||
inline cpp::Int64Struct _hx_int64_or(cpp::Int64 a, cpp::Int64 b) { return a|b; }
|
||||
inline cpp::Int64Struct _hx_int64_xor(cpp::Int64 a, cpp::Int64 b) { return a^b; }
|
||||
inline cpp::Int64Struct _hx_int64_shl(cpp::Int64 a, int b) { return a<<(b&63); }
|
||||
inline cpp::Int64Struct _hx_int64_shr(cpp::Int64 a, int b) { return a>>(b&63); }
|
||||
inline cpp::Int64Struct _hx_int64_ushr(cpp::Int64 a, int b) { return ((cpp::UInt64)a)>>(b&63); }
|
||||
inline int _hx_int64_high(cpp::Int64Struct a) { return (int)( a.get() >>32 ); }
|
||||
inline int _hx_int64_low(cpp::Int64Struct a) { return (int)( a.get() & 0xffffffff ); }
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
562
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp/Pointer.h
Normal file
562
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp/Pointer.h
Normal file
@ -0,0 +1,562 @@
|
||||
#ifndef CPP_POINTER_H
|
||||
#define CPP_POINTER_H
|
||||
|
||||
namespace cpp
|
||||
{
|
||||
|
||||
struct AutoCast
|
||||
{
|
||||
void *value;
|
||||
|
||||
explicit inline AutoCast(void *inValue) : value(inValue) { }
|
||||
};
|
||||
|
||||
|
||||
struct RawAutoCast
|
||||
{
|
||||
void *value;
|
||||
|
||||
explicit inline RawAutoCast(void *inValue) : value(inValue) { }
|
||||
|
||||
template<typename T>
|
||||
operator T*() const { return (T*)value; }
|
||||
};
|
||||
|
||||
|
||||
Dynamic CreateDynamicPointer(void *inValue);
|
||||
|
||||
enum DynamicHandlerOp
|
||||
{
|
||||
dhoGetClassName,
|
||||
dhoToString,
|
||||
dhoFromDynamic,
|
||||
dhoToDynamic,
|
||||
dhoIs,
|
||||
};
|
||||
typedef void (*DynamicHandlerFunc)(DynamicHandlerOp op, void *ioValue, int inSize, void *outResult);
|
||||
Dynamic CreateDynamicStruct(const void *inValue, int inSize, DynamicHandlerFunc inFunc);
|
||||
|
||||
template<typename T> class Reference;
|
||||
|
||||
|
||||
|
||||
struct StructHandlerDynamicParams
|
||||
{
|
||||
StructHandlerDynamicParams(hx::Object *data,const char *inName) :
|
||||
outProcessed(false), inName(inName), inData(data) { }
|
||||
bool outProcessed;
|
||||
hx::Object *inData;
|
||||
const char *inName;
|
||||
};
|
||||
|
||||
|
||||
class DefaultStructHandler
|
||||
{
|
||||
public:
|
||||
static inline const char *getName() { return "unknown"; }
|
||||
static inline String toString( const void *inValue ) { return HX_CSTRING("Struct"); }
|
||||
static inline void handler(DynamicHandlerOp op, void *ioValue, int inSize, void *outResult)
|
||||
{
|
||||
if (op==dhoToString)
|
||||
*(String *)outResult = toString(ioValue);
|
||||
else if (op==dhoGetClassName)
|
||||
*(const char **)outResult = getName();
|
||||
else if (op==dhoToDynamic)
|
||||
{
|
||||
// Handle outsize..
|
||||
*(hx::Object **)outResult = 0;
|
||||
}
|
||||
else if (op==dhoFromDynamic)
|
||||
{
|
||||
StructHandlerDynamicParams *params = (StructHandlerDynamicParams *)outResult;
|
||||
hx::Object *ptr= params->inData;
|
||||
void *data = (void *)ptr->__GetHandle();
|
||||
int len = ptr->__length();
|
||||
if (data && len>=inSize && ptr->__CStr()==params->inName)
|
||||
{
|
||||
memcpy(ioValue,data,inSize);
|
||||
params->outProcessed = true;
|
||||
}
|
||||
}
|
||||
else if (op==dhoIs)
|
||||
{
|
||||
StructHandlerDynamicParams *params = (StructHandlerDynamicParams *)outResult;
|
||||
hx::Object *ptr= params->inData;
|
||||
void *data = (void *)ptr->__GetHandle();
|
||||
int len = ptr->__length();
|
||||
params->outProcessed = data && len>=inSize && ptr->__CStr()==params->inName;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
class EnumHandler
|
||||
{
|
||||
public:
|
||||
static inline const char *getName() { return "enum"; }
|
||||
static inline String toString( const void *inValue ) {
|
||||
int val = inValue ? *(int *)inValue : 0;
|
||||
return HX_CSTRING("enum(") + String(val) + HX_CSTRING(")");
|
||||
}
|
||||
|
||||
static inline void handler(DynamicHandlerOp op, void *ioValue, int inSize, void *outResult)
|
||||
{
|
||||
if (op==dhoToString)
|
||||
*(String *)outResult = toString(ioValue);
|
||||
else if (op==dhoGetClassName)
|
||||
*(const char **)outResult = getName();
|
||||
else if (op==dhoFromDynamic)
|
||||
{
|
||||
StructHandlerDynamicParams *params = (StructHandlerDynamicParams *)outResult;
|
||||
if (params->inData->__GetType()==vtInt)
|
||||
{
|
||||
*(int *)ioValue = params->inData->__ToInt();
|
||||
params->outProcessed = true;
|
||||
}
|
||||
else
|
||||
DefaultStructHandler::handler(op,ioValue, inSize, outResult);
|
||||
}
|
||||
else
|
||||
DefaultStructHandler::handler(op,ioValue, inSize, outResult);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
template<typename T, typename HANDLER = DefaultStructHandler >
|
||||
class Struct
|
||||
{
|
||||
public:
|
||||
T value;
|
||||
// This allows 'StaticCast' to be used from arrays
|
||||
typedef Dynamic Ptr;
|
||||
|
||||
inline Struct( ) { }
|
||||
inline Struct( const T &inRHS ) : value(inRHS) { }
|
||||
inline Struct( const null &) { value = T(); }
|
||||
inline Struct( const Reference<T> &);
|
||||
inline Struct( const Dynamic &inRHS) { fromDynamic(inRHS.mPtr); }
|
||||
|
||||
inline Struct<T,HANDLER> &operator=( const T &inRHS ) { value = inRHS; return *this; }
|
||||
inline Struct<T,HANDLER> &operator=( const null & ) { value = T(); return *this; }
|
||||
inline Struct<T,HANDLER> &operator=( const Dynamic &inRHS ) { return *this = Struct<T,HANDLER>(inRHS); }
|
||||
|
||||
operator Dynamic() const
|
||||
{
|
||||
hx::Object *result = 0;
|
||||
HANDLER::handler(dhoToDynamic, (void *)&value, sizeof(T), &result );
|
||||
if (result)
|
||||
return result;
|
||||
return CreateDynamicStruct( &value, sizeof(T), HANDLER::handler);
|
||||
}
|
||||
operator String() const { return HANDLER::toString(&value); }
|
||||
|
||||
#if (HXCPP_API_LEVEL >= 330)
|
||||
inline Struct( const hx::Val &inRHS) { fromDynamic(inRHS.asObject()); }
|
||||
operator hx::Val() const { return operator Dynamic(); }
|
||||
#endif
|
||||
|
||||
bool operator==(const Struct<T,HANDLER> &inRHS) const { return value==inRHS.value; }
|
||||
bool operator==(const null &inRHS) const { return false; }
|
||||
bool operator!=(const null &inRHS) const { return true; }
|
||||
|
||||
// Haxe uses -> notation
|
||||
inline T *operator->() { return &value; }
|
||||
|
||||
T &get() { return value; }
|
||||
|
||||
static inline bool is( const Dynamic &inRHS)
|
||||
{
|
||||
hx::Object *ptr = inRHS.mPtr;
|
||||
if (!ptr)
|
||||
return false;
|
||||
StructHandlerDynamicParams convert(ptr, ptr->__CStr());
|
||||
HANDLER::handler(dhoIs, 0, sizeof(T), &convert );
|
||||
return convert.outProcessed;
|
||||
}
|
||||
|
||||
|
||||
inline void fromDynamic( hx::Object *ptr)
|
||||
{
|
||||
if (!ptr)
|
||||
{
|
||||
value = T();
|
||||
return;
|
||||
}
|
||||
StructHandlerDynamicParams convert(ptr, ptr->__CStr());
|
||||
HANDLER::handler(dhoFromDynamic, &value, sizeof(T), &convert );
|
||||
if (!convert.outProcessed)
|
||||
{
|
||||
hx::NullReference("DynamicData", true);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
inline operator T& () { return value; }
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename T>
|
||||
class Pointer
|
||||
{
|
||||
public:
|
||||
typedef T elementType;
|
||||
|
||||
T *ptr;
|
||||
|
||||
inline Pointer( ) : ptr(0) { }
|
||||
inline Pointer( const Pointer &inRHS ) : ptr(inRHS.ptr) { }
|
||||
inline Pointer( const Dynamic &inRHS) { ptr = inRHS==null()?0: (T*)inRHS->__GetHandle(); }
|
||||
inline Pointer( const null &inRHS ) : ptr(0) { }
|
||||
inline Pointer( const cpp::Variant &inVariant ) {
|
||||
hx::Object *obj = inVariant.asObject();
|
||||
ptr = obj ? (T*)inVariant.valObject->__GetHandle() : 0;
|
||||
}
|
||||
|
||||
template<typename O>
|
||||
inline Pointer( const O *inValue ) : ptr( (T*) inValue) { }
|
||||
//inline Pointer( T *inValue ) : ptr(inValue) { }
|
||||
inline Pointer( AutoCast inValue ) : ptr( (T*)inValue.value) { }
|
||||
|
||||
template<typename H>
|
||||
inline Pointer( const Struct<T,H> &structVal ) : ptr( &structVal.value ) { }
|
||||
|
||||
template<typename O>
|
||||
inline void setRaw(const O *inValue ) { ptr = (T*) inValue; }
|
||||
|
||||
|
||||
inline Pointer operator=( const Pointer &inRHS ) { return ptr = inRHS.ptr; }
|
||||
inline Dynamic operator=( Dynamic &inValue )
|
||||
{
|
||||
ptr = inValue==null() ? 0 : (T*) inValue->__GetHandle();
|
||||
return inValue;
|
||||
}
|
||||
inline Dynamic operator=( null &inValue ) { ptr=0; return inValue; }
|
||||
|
||||
template<typename O>
|
||||
inline Pointer operator=( const Pointer<O> &inValue ) { ptr = (T*) inValue.ptr; return *this; }
|
||||
|
||||
template<typename O>
|
||||
inline Pointer operator=( const O *inValue ) { ptr = (T*) inValue; return *this; }
|
||||
|
||||
template<typename H>
|
||||
inline Pointer operator=( const Struct<T,H> &structVal ) { ptr = &structVal.value; return *this; }
|
||||
|
||||
|
||||
|
||||
inline AutoCast reinterpret() { return AutoCast(ptr); }
|
||||
inline RawAutoCast rawCast() { return RawAutoCast(ptr); }
|
||||
|
||||
inline bool operator==( const null &inValue ) const { return ptr==0; }
|
||||
inline bool operator!=( const null &inValue ) const { return ptr!=0; }
|
||||
|
||||
// Allow '->' syntax
|
||||
inline Pointer *operator->() { return this; }
|
||||
inline Pointer inc() { return ++ptr; }
|
||||
inline Pointer dec() { return --ptr; }
|
||||
inline Pointer add(int inInt) { return ptr+inInt; }
|
||||
inline Pointer sub(int inInt) { return ptr-inInt; }
|
||||
inline Pointer incBy(int inDiff) { ptr+=inDiff; return ptr; }
|
||||
inline Pointer decBy(int inDiff) { ptr-=inDiff; return ptr; }
|
||||
inline T &postIncRef() { return *ptr++; }
|
||||
inline T &postIncVal() { return *ptr++; }
|
||||
|
||||
inline T &at(int inIndex) { return ptr[inIndex]; }
|
||||
inline void setAt(int inIndex, const T &test) { ptr[inIndex] = test; }
|
||||
|
||||
inline T &__get(int inIndex) { return ptr[inIndex]; }
|
||||
inline T &__set(int inIndex, const T &inValue) { T *p = ptr+inIndex; *p = inValue; return *p; }
|
||||
|
||||
inline T &get_value() { return *ptr; }
|
||||
inline T &get_ref() { return *ptr; }
|
||||
inline T &set_ref(const T &inValue) { return *ptr = inValue; }
|
||||
|
||||
operator Dynamic () const { return CreateDynamicPointer((void *)ptr); }
|
||||
#if (HXCPP_API_LEVEL >= 330)
|
||||
operator cpp::Variant () const { return CreateDynamicPointer((void *)ptr); }
|
||||
#endif
|
||||
|
||||
operator T * () { return ptr; }
|
||||
T * get_raw() { return ptr; }
|
||||
const T * get_constRaw() { return ptr; }
|
||||
|
||||
inline void destroy() { delete ptr; }
|
||||
inline void destroyArray() { delete [] ptr; }
|
||||
|
||||
inline bool lt(Pointer inOther) { return ptr < inOther.ptr; }
|
||||
inline bool gt(Pointer inOther) { return ptr > inOther.ptr; }
|
||||
inline bool leq(Pointer inOther) { return ptr <= inOther.ptr; }
|
||||
inline bool geq(Pointer inOther) { return ptr >= inOther.ptr; }
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<>
|
||||
class Pointer<void>
|
||||
{
|
||||
public:
|
||||
enum { elementSize = 0 };
|
||||
|
||||
void *ptr;
|
||||
|
||||
inline Pointer( ) : ptr(0) { }
|
||||
inline Pointer( const Pointer &inRHS ) : ptr(inRHS.ptr) { }
|
||||
inline Pointer( const Dynamic &inRHS) { ptr = inRHS==null()?0: (void*)inRHS->__GetHandle(); }
|
||||
inline Pointer( const null &inRHS ) : ptr(0) { }
|
||||
|
||||
template<typename O>
|
||||
inline Pointer( const O *inValue ) : ptr( (void*) inValue) { }
|
||||
//inline Pointer( T *inValue ) : ptr(inValue) { }
|
||||
inline Pointer( AutoCast inValue ) : ptr( (void*)inValue.value) { }
|
||||
|
||||
inline Pointer operator=( const Pointer &inRHS ) { return ptr = inRHS.ptr; }
|
||||
inline Dynamic operator=( Dynamic &inValue )
|
||||
{
|
||||
ptr = inValue==null() ? 0 : (void*) inValue->__GetHandle();
|
||||
return inValue;
|
||||
}
|
||||
inline Dynamic operator=( null &inValue ) { ptr=0; return inValue; }
|
||||
inline AutoCast reinterpret() { return AutoCast(ptr); }
|
||||
inline RawAutoCast rawCast() { return RawAutoCast(ptr); }
|
||||
|
||||
inline bool operator==( const null &inValue ) const { return ptr==0; }
|
||||
inline bool operator!=( const null &inValue ) const { return ptr!=0; }
|
||||
|
||||
// Allow '->' syntax
|
||||
inline Pointer *operator->() { return this; }
|
||||
inline Pointer inc() { return ptr; }
|
||||
inline Pointer dec() { return ptr; }
|
||||
inline Pointer add(int inInt) { return ptr; }
|
||||
inline Pointer sub(int inInt) { return ptr; }
|
||||
inline Pointer incBy(int inDiff) { return ptr; }
|
||||
inline Pointer decBy(int inDiff) { return ptr; }
|
||||
inline void postIncRef() { }
|
||||
inline void postIncVal() { }
|
||||
|
||||
inline void at(int inIndex) { }
|
||||
|
||||
inline void __get(int inIndex) { }
|
||||
|
||||
template<typename O>
|
||||
inline void __set(int inIndex, O inValue) { }
|
||||
|
||||
inline void get_value() { }
|
||||
inline void get_ref() { }
|
||||
template<typename O> inline void set_ref(O val) { }
|
||||
|
||||
operator Dynamic () const { return CreateDynamicPointer(ptr); }
|
||||
//operator hx::Val () const { return CreateDynamicPointer((void *)ptr); }
|
||||
operator void * () { return ptr; }
|
||||
void * get_raw() { return ptr; }
|
||||
const void * get_constRaw() { return ptr; }
|
||||
|
||||
inline void destroy() { }
|
||||
inline void destroyArray() { }
|
||||
|
||||
inline bool lt(Pointer inOther) { return ptr < inOther.ptr; }
|
||||
inline bool gt(Pointer inOther) { return ptr > inOther.ptr; }
|
||||
inline bool leq(Pointer inOther) { return ptr <= inOther.ptr; }
|
||||
inline bool geq(Pointer inOther) { return ptr >= inOther.ptr; }
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename T>
|
||||
inline bool operator == (const null &, Pointer<T> inPtr) { return inPtr.ptr==0; }
|
||||
template<typename T>
|
||||
inline bool operator != (const null &, Pointer<T> inPtr) { return inPtr.ptr!=0; }
|
||||
|
||||
|
||||
|
||||
template<typename T>
|
||||
class Reference : public Pointer<T>
|
||||
{
|
||||
public:
|
||||
using Pointer<T>::ptr;
|
||||
|
||||
|
||||
inline Reference( const T &inRHS ) : Pointer<T>(&inRHS) { }
|
||||
inline Reference( T &inRHS ) : Pointer<T>(&inRHS) { }
|
||||
|
||||
inline Reference( ) : Pointer<T>((T*)0) { }
|
||||
inline Reference( const Reference &inRHS ) : Pointer<T>(inRHS.ptr) { }
|
||||
inline Reference( const Dynamic &inRHS) { ptr = inRHS==null()?0: (T*)inRHS->__GetHandle(); }
|
||||
inline Reference( const null &inRHS ) : Pointer<T>((T*)0) { }
|
||||
inline Reference( const T *inValue ) : Pointer<T>( (T*) inValue) { }
|
||||
//inline Reference( T *inValue ) : Pointer(inValue) { }
|
||||
inline Reference( AutoCast inValue ) : Pointer<T>( (T*)inValue.value) { }
|
||||
|
||||
template<typename OTHER>
|
||||
inline Reference( const Reference<OTHER> &inOther )
|
||||
{
|
||||
// Allow reinterpret or not?
|
||||
ptr = (T*)inOther.ptr;
|
||||
}
|
||||
|
||||
template<typename H>
|
||||
inline Reference( const Struct<T,H> &structVal ) : Pointer<T>( &structVal.value ) { }
|
||||
|
||||
inline Reference operator=( const Reference &inRHS ) { return ptr = inRHS.ptr; }
|
||||
|
||||
|
||||
inline T *operator->() const { return ptr; }
|
||||
|
||||
inline operator T &() { return *ptr; }
|
||||
|
||||
};
|
||||
|
||||
template<typename T,typename H>
|
||||
Struct<T,H>::Struct( const Reference<T> &ref ) : value(*ref.ptr) { };
|
||||
|
||||
|
||||
|
||||
template<typename T>
|
||||
class Function
|
||||
{
|
||||
public:
|
||||
T *call;
|
||||
|
||||
inline Function( ) { }
|
||||
inline Function( const Function &inRHS ) : call(inRHS.call) { }
|
||||
inline Function( const Dynamic &inRHS) { call = inRHS==null()?0: (T*)inRHS->__GetHandle(); }
|
||||
inline Function( const null &inRHS ) { call = 0; }
|
||||
inline Function( T *inValue ) : call((T*)(inValue)) { }
|
||||
//inline Function( T *inValue ) : call(inValue) { }
|
||||
inline Function( AutoCast inValue ) : call( (T*)inValue.value) { }
|
||||
inline Function( const hx::AnyCast &inValue ) : call( (T*)inValue.mPtr) { }
|
||||
|
||||
template<typename FROM>
|
||||
inline static Function __new(FROM from)
|
||||
{
|
||||
return Function(from);
|
||||
}
|
||||
|
||||
inline Function operator=( const Function &inRHS ) { return call = inRHS.call; }
|
||||
inline Dynamic operator=( Dynamic &inValue )
|
||||
{
|
||||
call = inValue==null() ? 0 : (T*) inValue->__GetHandle();
|
||||
return inValue;
|
||||
}
|
||||
inline Dynamic operator=( null &inValue ) { call=0; return inValue; }
|
||||
inline bool operator==( const null &inValue ) const { return call==0; }
|
||||
inline bool operator!=( const null &inValue ) const { return call!=0; }
|
||||
|
||||
|
||||
operator Dynamic () const { return CreateDynamicPointer((void *)call); }
|
||||
//operator hx::Val () const { return CreateDynamicPointer((void *)call); }
|
||||
operator T * () { return call; }
|
||||
operator void * () { return (void *)call; }
|
||||
|
||||
inline T &get_call() { return *call; }
|
||||
|
||||
inline bool lt(Function inOther) { return call < inOther.call; }
|
||||
inline bool gt(Function inOther) { return call > inOther.call; }
|
||||
inline bool leq(Function inOther) { return call <= inOther.call; }
|
||||
inline bool geq(Function inOther) { return call >= inOther.call; }
|
||||
|
||||
};
|
||||
|
||||
|
||||
template<typename T>
|
||||
inline bool operator == (const null &, Function<T> inPtr) { return inPtr.call==0; }
|
||||
template<typename T>
|
||||
inline bool operator != (const null &, Function<T> inPtr) { return inPtr.call!=0; }
|
||||
|
||||
|
||||
|
||||
class Function_obj
|
||||
{
|
||||
public:
|
||||
|
||||
inline static AutoCast getProcAddress(String inLib, String inPrim)
|
||||
{
|
||||
return AutoCast(__hxcpp_get_proc_address(inLib, inPrim,false));
|
||||
}
|
||||
|
||||
|
||||
template<typename T>
|
||||
inline static AutoCast fromStaticFunction(T *inFunction)
|
||||
{
|
||||
return AutoCast(inFunction);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
class Pointer_obj
|
||||
{
|
||||
public:
|
||||
template<typename T>
|
||||
inline static AutoCast arrayElem(::Array<T> array, int inIndex) { return AutoCast(&array[inIndex]); }
|
||||
inline static AutoCast arrayElem(Dynamic inVal, int inIndex)
|
||||
{
|
||||
if (inVal==null() || !inVal->__IsArray())
|
||||
return AutoCast(0);
|
||||
hx::ArrayBase *base = (hx::ArrayBase *)inVal.GetPtr();
|
||||
return AutoCast(base->GetBase() + inIndex*base->GetElementSize());
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline static AutoCast ofArray(::Array<T> array) { return AutoCast(&array[0]); }
|
||||
inline static AutoCast ofArray(Dynamic inVal)
|
||||
{
|
||||
if (inVal==null() || !inVal->__IsArray())
|
||||
return AutoCast(0);
|
||||
hx::ArrayBase *base = (hx::ArrayBase *)inVal.GetPtr();
|
||||
return AutoCast(base->GetBase());
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<typename T>
|
||||
inline static Pointer<T> addressOf(T &value) { return Pointer<T>(&value); }
|
||||
|
||||
template<typename T>
|
||||
inline static Pointer<void> endOf(hx::ObjectPtr<T> value) { return (void *)(value.mPtr+1); }
|
||||
|
||||
template<typename T>
|
||||
inline static Pointer<T> fromPointer(T *value) { return Pointer<T>(value); }
|
||||
template<typename T>
|
||||
inline static Pointer<T> fromPointer(const T *value) { return Pointer<T>(value); }
|
||||
|
||||
template<typename T>
|
||||
inline static Pointer<T> fromRaw(T *value) { return Pointer<T>(value); }
|
||||
template<typename T>
|
||||
inline static Pointer<T> fromRaw(const T *value) { return Pointer<T>(value); }
|
||||
inline static Pointer<void> fromRaw(const AutoCast &inAutoCast) { return Pointer<void>(inAutoCast.value); }
|
||||
inline static Pointer<void> fromRaw(const RawAutoCast &inAutoCast) { return Pointer<void>(inAutoCast.value); }
|
||||
|
||||
|
||||
inline static AutoCast fromHandle(Dynamic inValue, String inKind)
|
||||
{
|
||||
if (inValue==null() || (inKind!=null() && inKind!=__hxcpp_get_kind(inValue)))
|
||||
return AutoCast(0);
|
||||
return AutoCast(inValue->__GetHandle());
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
class Reference_obj
|
||||
{
|
||||
public:
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
} // end namespace cpp
|
||||
|
||||
namespace hx
|
||||
{
|
||||
template <typename T>
|
||||
T *StarOf(T &x) { return &x; }
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
676
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp/Variant.h
Normal file
676
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp/Variant.h
Normal file
@ -0,0 +1,676 @@
|
||||
#ifndef CPP_VARIANT_TWICE_H
|
||||
|
||||
|
||||
namespace cpp
|
||||
{
|
||||
#ifndef CPP_VARIANT_ONCE_H
|
||||
#define CPP_VARIANT_ONCE_H
|
||||
|
||||
template<typename T>
|
||||
inline bool isIntType(const T &inRHS) { return false; }
|
||||
template<> inline bool isIntType(const int &inRHS) { return true; }
|
||||
template<> inline bool isIntType(const Dynamic &inRHS);
|
||||
template<> inline bool isIntType(const cpp::Variant &inRHS);
|
||||
|
||||
template<typename T>
|
||||
inline bool isStringType(const T &inRHS) { return false; }
|
||||
template<> inline bool isStringType(const String &inRHS) { return true; }
|
||||
template<> inline bool isStringType(const Dynamic &inRHS);
|
||||
template<> inline bool isStringType(const cpp::Variant &inRHS);
|
||||
|
||||
struct Variant
|
||||
{
|
||||
enum Type
|
||||
{
|
||||
typeObject = 0,
|
||||
typeString,
|
||||
typeDouble,
|
||||
typeInt,
|
||||
typeInt64,
|
||||
typeBool,
|
||||
};
|
||||
|
||||
union
|
||||
{
|
||||
// Although this is typed as 'char', it might be char16_t in the case of smart strings
|
||||
const char *valStringPtr;
|
||||
hx::Object *valObject;
|
||||
double valDouble;
|
||||
cpp::Int64 valInt64;
|
||||
int valInt;
|
||||
bool valBool;
|
||||
};
|
||||
Type type;
|
||||
unsigned int valStringLen;
|
||||
|
||||
|
||||
|
||||
inline bool isNull() const {
|
||||
return (type==typeObject && !valObject) || (type==typeString && !valStringPtr); }
|
||||
inline bool isNumeric() const;
|
||||
inline bool isBool() const;
|
||||
inline int asInt() const;
|
||||
inline bool isInt() const;
|
||||
inline cpp::Int64 asInt64() const;
|
||||
inline bool isInt64() const;
|
||||
inline bool isString() const;
|
||||
inline double asDouble() const;
|
||||
inline hx::Object *asObject() const { return type==typeObject ? valObject : 0; }
|
||||
inline hx::Object *asDynamic() const{ return type==typeObject ? valObject : toDynamic(); }
|
||||
inline hx::Object *toDynamic() const; // later
|
||||
inline String asString() const;
|
||||
inline String getString() const;
|
||||
|
||||
inline Variant() : valInt64(0), type(typeObject) { }
|
||||
//inline Variant() { copyBuf.b[0] = copyBuf.b[1] = 0; }
|
||||
inline Variant(const null &) : type(typeObject), valObject(0) { }
|
||||
inline Variant(bool inValue) : type(typeBool), valBool(inValue) { }
|
||||
inline Variant(double inValue) : type(typeDouble), valDouble(inValue) { }
|
||||
inline Variant(const ::String &inValue); // later
|
||||
|
||||
inline Variant(cpp::Int64 inValue) : type(typeInt64), valInt64(inValue) { }
|
||||
inline Variant(cpp::UInt64 inValue) : type(typeInt64), valInt64(inValue) { }
|
||||
inline Variant(int inValue) : type(typeInt), valInt(inValue) { }
|
||||
inline Variant(cpp::UInt32 inValue) : type(typeInt), valInt(inValue) { }
|
||||
inline Variant(cpp::Int16 inValue) : type(typeInt), valInt(inValue) { }
|
||||
inline Variant(cpp::UInt16 inValue) : type(typeInt), valInt(inValue) { }
|
||||
inline Variant(cpp::Int8 inValue) : type(typeInt), valInt(inValue) { }
|
||||
inline Variant(cpp::UInt8 inValue) : type(typeInt), valInt(inValue) { }
|
||||
#if defined(__OBJC__) && defined(HXCPP_OBJC)
|
||||
inline Variant(const id inObjc);
|
||||
inline operator id() const;
|
||||
#endif
|
||||
|
||||
|
||||
template<typename SOURCE_>
|
||||
Variant(const hx::ObjectPtr<SOURCE_> &inObjectPtr);
|
||||
|
||||
inline Variant(const Dynamic &inRHS); // later
|
||||
inline Variant(hx::Object *inValue) : type(typeObject), valObject(inValue) { }
|
||||
|
||||
template<typename T,typename H>
|
||||
explicit inline Variant(const cpp::Struct<T,H> &inVal);
|
||||
template<typename T>
|
||||
explicit inline Variant(const cpp::Pointer<T> &inRHS) ;
|
||||
template<typename T>
|
||||
explicit inline Variant(const cpp::Function<T> &inRHS) ;
|
||||
template<typename T>
|
||||
explicit inline Variant(const hx::Native<T> &inRHS) ;
|
||||
|
||||
//inline operator Dynamic() const; // later
|
||||
//inline operator String() const;
|
||||
inline operator double() const { return asDouble(); }
|
||||
inline operator int() const { return asInt(); }
|
||||
inline operator bool() const { return asInt(); }
|
||||
inline operator float () const { return asDouble(); }
|
||||
inline operator unsigned int () const { return asInt(); }
|
||||
inline operator short () const { return asInt(); }
|
||||
inline operator unsigned short () const { return asInt(); }
|
||||
inline operator unsigned char () const { return asInt(); }
|
||||
inline operator char () const { return asInt(); }
|
||||
inline operator signed char () const { return asInt(); }
|
||||
inline operator cpp::Int64 () const { return asInt64(); }
|
||||
inline operator cpp::UInt64 () const { return asInt64(); }
|
||||
inline bool operator !() const { return !asInt(); }
|
||||
|
||||
inline int Compare(hx::Object *inRHS) const;
|
||||
inline int Compare(const Dynamic &inRHS) const;
|
||||
inline int Compare(const cpp::Variant &inRHS) const;
|
||||
|
||||
inline double set(const double &inValue) { type=typeDouble; return valDouble=inValue; }
|
||||
inline double set(const float &inValue) { type=typeDouble; return valDouble=inValue; }
|
||||
|
||||
inline void mark(hx::MarkContext *__inCtx); // later
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
inline void visit(hx::VisitContext *__inCtx); // later
|
||||
#endif
|
||||
|
||||
|
||||
//inline Variant &operator=(const Variant &inRhs) { copyBuf = inRhs.copyBuf; return *this; }
|
||||
|
||||
template<typename T>
|
||||
bool operator==(const T &inRHS) const;
|
||||
|
||||
template<typename T>
|
||||
bool operator==(const hx::ObjectPtr<T> &inRHS) const
|
||||
{ return Compare(inRHS.mPtr)==0; }
|
||||
|
||||
|
||||
template<typename T>
|
||||
bool operator!=(const hx::ObjectPtr<T> &inRHS) const
|
||||
{ return Compare(inRHS.mPtr)!=0; }
|
||||
|
||||
|
||||
|
||||
inline bool operator==(const null &inRHS) const { return isNull(); }
|
||||
inline bool operator==(const String &inRHS) const;
|
||||
|
||||
inline bool operator!=(const null &inRHS) const { return !isNull(); }
|
||||
inline bool operator!=(const Variant &inRHS) const { return !operator==(inRHS); }
|
||||
inline bool operator!=(const String &inRHS) const;
|
||||
|
||||
|
||||
template<typename RETURN_>
|
||||
RETURN_ Cast() const { return RETURN_(*this); }
|
||||
|
||||
void CheckFPtr();
|
||||
HX_DECLARE_VARIANT_FUNCTIONS
|
||||
|
||||
|
||||
// Operator + is different, since it must consider strings too...
|
||||
inline String operator+(const String &s) const;
|
||||
template<typename T>
|
||||
inline cpp::Variant operator + (const T &inRHS) const;
|
||||
|
||||
inline double operator%(const Dynamic &inRHS) const;
|
||||
inline double operator-() const { return -asDouble(); }
|
||||
inline double operator++() { return set(asDouble()+1); }
|
||||
inline double operator++(int) {double val = asDouble(); set(val+1); return val; }
|
||||
inline double operator--() { return set(asDouble()-1); }
|
||||
inline double operator--(int) {double val = asDouble(); set(val-1); return val; }
|
||||
|
||||
template<typename T>
|
||||
inline double operator / (const T &inRHS) const { return asDouble() / (double)inRHS; } \
|
||||
|
||||
template<typename T>
|
||||
inline cpp::Variant operator - (const T &inRHS) const
|
||||
{
|
||||
if (::cpp::isIntType(inRHS) && isInt() )
|
||||
return asInt() - (int)inRHS;
|
||||
return asDouble() - (double)inRHS;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline cpp::Variant operator * (const T &inRHS) const
|
||||
{
|
||||
if (::cpp::isIntType(inRHS) && isInt())
|
||||
return asInt() * (int)inRHS;
|
||||
return asDouble() * (double)inRHS;
|
||||
}
|
||||
|
||||
inline bool operator < (const String &inRHS) const;
|
||||
inline bool operator <= (const String &inRHS) const;
|
||||
inline bool operator > (const String &inRHS) const;
|
||||
inline bool operator >= (const String &inRHS) const;
|
||||
|
||||
|
||||
|
||||
#define HX_VARIANT_COMPARE_OP( op ) \
|
||||
inline bool operator op (double inRHS) const { return isNumeric() && (asDouble() op inRHS); } \
|
||||
inline bool operator op (cpp::Int64 inRHS) const { return isNumeric() && (asInt64() op inRHS); } \
|
||||
inline bool operator op (cpp::UInt64 inRHS) const { return isNumeric() && ((cpp::UInt64)(asInt64()) op inRHS); } \
|
||||
inline bool operator op (float inRHS) const { return isNumeric() && (asDouble() op inRHS); } \
|
||||
inline bool operator op (int inRHS) const { return isNumeric() && (asDouble() op (double)inRHS); } \
|
||||
inline bool operator op (unsigned int inRHS) const { return isNumeric() && (asDouble() op (double)inRHS); } \
|
||||
inline bool operator op (short inRHS) const { return isNumeric() && (asDouble() op (double)inRHS); } \
|
||||
inline bool operator op (unsigned short inRHS) const { return isNumeric() && (asDouble() op (double)inRHS); } \
|
||||
inline bool operator op (signed char inRHS) const { return isNumeric() && (asDouble() op (double)inRHS); } \
|
||||
inline bool operator op (unsigned char inRHS) const { return isNumeric() && (asDouble() op (double)inRHS); } \
|
||||
inline bool operator op (bool inRHS) const { return isBool() && (asDouble() op (double)inRHS); } \
|
||||
inline bool operator op (const Dynamic &inRHS) const { return Compare(inRHS) op 0; } \
|
||||
|
||||
#define HX_VARIANT_COMPARE_OP_ALL( op ) \
|
||||
inline bool operator op (const null &inRHS) const { return false; } \
|
||||
inline bool operator op (const cpp::Variant &inRHS) const { return Compare(inRHS) op 0; } \
|
||||
HX_VARIANT_COMPARE_OP(op)
|
||||
|
||||
HX_VARIANT_COMPARE_OP( == )
|
||||
HX_VARIANT_COMPARE_OP( != )
|
||||
HX_VARIANT_COMPARE_OP_ALL( < )
|
||||
HX_VARIANT_COMPARE_OP_ALL( <= )
|
||||
HX_VARIANT_COMPARE_OP_ALL( >= )
|
||||
HX_VARIANT_COMPARE_OP_ALL( > )
|
||||
|
||||
|
||||
};
|
||||
|
||||
#else // Second time ...
|
||||
#define CPP_VARIANT_TWICE_H
|
||||
|
||||
bool Variant::isInt() const
|
||||
{
|
||||
return type==typeInt || (type==typeObject && valObject && valObject->__GetType()==vtInt);
|
||||
}
|
||||
bool Variant::isInt64() const
|
||||
{
|
||||
return type==typeInt64 || (type==typeObject && valObject && valObject->__GetType()==vtInt64);
|
||||
}
|
||||
bool Variant::isString() const
|
||||
{
|
||||
return type==typeString || (type==typeObject && valObject && valObject->__GetType()==vtString);
|
||||
}
|
||||
|
||||
|
||||
#if defined(__OBJC__) && defined(HXCPP_OBJC)
|
||||
// Variant type neither adds nor releases references counts while holding the value as an id on the stack
|
||||
// The Dynamic created here owns the id, and we refer to the Dynamic and use his reference count to keep the id alive
|
||||
inline Variant::Variant(const id inObjc) { type=typeObject; valObject = Dynamic(inObjc).mPtr; }
|
||||
#ifdef OBJC_ARC
|
||||
inline Variant::operator id () const { return type==typeObject && valObject ? (__bridge id)valObject->__GetHandle() : 0; }
|
||||
#else
|
||||
inline Variant::operator id () const { return type==typeObject && valObject ? (id)valObject->__GetHandle() : 0; }
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
template<> inline bool isIntType(const Dynamic &inRHS) { return inRHS->__GetType()==vtInt; }
|
||||
template<> inline bool isIntType(const cpp::Variant &inRHS) { return inRHS.isInt(); }
|
||||
template<> inline bool isStringType(const Dynamic &inRHS) { return inRHS.mPtr && inRHS->__GetType()==vtString; }
|
||||
template<> inline bool isStringType(const cpp::Variant &inRHS) { return inRHS.isString(); }
|
||||
|
||||
template<typename T,typename H>
|
||||
Variant::Variant(const cpp::Struct<T,H> &inVal) :
|
||||
type(typeObject), valObject(Dynamic(inVal).mPtr) { }
|
||||
|
||||
template<typename T>
|
||||
Variant::Variant(const cpp::Pointer<T> &inRHS) : type(typeObject), valObject( Dynamic(inRHS).mPtr ) { }
|
||||
template<typename T>
|
||||
Variant::Variant(const cpp::Function<T> &inRHS) : type(typeObject), valObject( Dynamic(inRHS).mPtr ) { }
|
||||
template<typename T>
|
||||
Variant::Variant(const hx::Native<T> &inRHS) : type(typeObject), valObject( CreateDynamicPointer(inRHS.ptr).mPtr ) { }
|
||||
|
||||
|
||||
#define HX_ARITH_VARIANT( op ) \
|
||||
inline double operator op (const double &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS;} \
|
||||
inline double operator op (const float &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS;} \
|
||||
inline double operator op (const int &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
|
||||
inline double operator op (const unsigned int &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
|
||||
inline double operator op (const signed char &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
|
||||
inline double operator op (const unsigned char &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
|
||||
inline double operator op (const signed short &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
|
||||
inline double operator op (const unsigned short &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
|
||||
inline double operator op (const cpp::Int64 &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
|
||||
inline double operator op (const cpp::UInt64 &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
|
||||
|
||||
HX_ARITH_VARIANT( - )
|
||||
HX_ARITH_VARIANT( + )
|
||||
HX_ARITH_VARIANT( / )
|
||||
HX_ARITH_VARIANT( * )
|
||||
|
||||
inline bool Variant::operator==(const String &inString) const
|
||||
{
|
||||
if (isNull()) return inString==null();
|
||||
return type==typeString && asString()==inString;
|
||||
}
|
||||
inline bool Variant::operator!=(const String &inString) const
|
||||
{
|
||||
if (isNull()) return inString!=null();
|
||||
return type!=typeString || asString()!=inString;
|
||||
}
|
||||
inline bool Variant::operator < (const String &inRHS) const { return asString() < inRHS; }
|
||||
inline bool Variant::operator <= (const String &inRHS) const { return asString() < inRHS; }
|
||||
inline bool Variant::operator > (const String &inRHS) const { return asString() > inRHS; }
|
||||
inline bool Variant::operator >= (const String &inRHS) const { return asString() >= inRHS; }
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Variant::Variant(const ::String &inValue) :
|
||||
type(typeString), valStringPtr(inValue.raw_ptr()), valStringLen(inValue.length) { }
|
||||
|
||||
Variant::Variant(const Dynamic &inRHS) : type(typeObject), valObject(inRHS.mPtr) { }
|
||||
|
||||
template<typename SOURCE_>
|
||||
Variant::Variant(const hx::ObjectPtr<SOURCE_> &inObjectPtr) :
|
||||
type(typeObject), valObject(inObjectPtr.mPtr) { }
|
||||
|
||||
inline void Variant::CheckFPtr()
|
||||
{
|
||||
if (isNull()) Dynamic::ThrowBadFunctionError();
|
||||
}
|
||||
|
||||
HX_IMPLEMENT_INLINE_VARIANT_FUNCTIONS
|
||||
|
||||
|
||||
int Variant::asInt() const
|
||||
{
|
||||
if (type==typeInt)
|
||||
return valInt;
|
||||
|
||||
switch(type)
|
||||
{
|
||||
case typeDouble: return valDouble;
|
||||
case typeInt64: return (int)valInt64;
|
||||
case typeBool: return valBool;
|
||||
case typeObject: return valObject ? valObject->__ToInt() : 0;
|
||||
default: ;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
cpp::Int64 Variant::asInt64() const
|
||||
{
|
||||
if (type==typeInt64)
|
||||
return valInt64;
|
||||
|
||||
switch(type)
|
||||
{
|
||||
case typeDouble: return valDouble;
|
||||
case typeInt: return valInt;
|
||||
case typeBool: return valBool;
|
||||
case typeObject: return valObject ? valObject->__ToInt64() : 0;
|
||||
default: ;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
double Variant::asDouble() const
|
||||
{
|
||||
if (type==typeDouble)
|
||||
return valDouble;
|
||||
else if (type==typeInt)
|
||||
return valInt;
|
||||
else if (type==typeBool)
|
||||
return valBool ? 1.0 : 0.0;
|
||||
else if (type==typeInt64)
|
||||
return valInt64;
|
||||
else if (type==typeObject)
|
||||
return valObject ? valObject->__ToDouble() : 0.0;
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
|
||||
inline hx::Object *Variant::toDynamic() const
|
||||
{
|
||||
switch(type)
|
||||
{
|
||||
case typeInt: return Dynamic(valInt).mPtr;
|
||||
case typeDouble: return Dynamic(valDouble).mPtr;
|
||||
case typeBool: return Dynamic(valBool).mPtr;
|
||||
case typeString: return Dynamic(String(valStringPtr, valStringLen)).mPtr;
|
||||
case typeInt64: return Dynamic(valInt64).mPtr;
|
||||
case typeObject: return valObject;
|
||||
default: ;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
Variant::operator Dynamic() const
|
||||
{
|
||||
switch(type)
|
||||
{
|
||||
case typeInt: return valInt;
|
||||
case typeDouble: return valDouble;
|
||||
case typeBool: return valBool;
|
||||
case typeString: return String(valStringPtr, valStringLen);
|
||||
case typeObject: return valObject;
|
||||
default: ;
|
||||
}
|
||||
return null();
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
bool Variant::isNumeric() const
|
||||
{
|
||||
if (type==typeInt || type==typeDouble || type==typeInt64)
|
||||
return true;
|
||||
if (type!=typeObject || valObject==0)
|
||||
return false;
|
||||
|
||||
int t = valObject->__GetType();
|
||||
return t==vtInt || t==vtFloat;
|
||||
}
|
||||
|
||||
bool Variant::isBool() const
|
||||
{
|
||||
if (type==typeBool)
|
||||
return true;
|
||||
if (type!=typeObject || valObject==0)
|
||||
return false;
|
||||
|
||||
return valObject->__GetType() == vtBool;
|
||||
}
|
||||
|
||||
|
||||
String Variant::getString() const { return String(valStringPtr, valStringLen); }
|
||||
String Variant::asString() const
|
||||
{
|
||||
switch(type)
|
||||
{
|
||||
case typeInt: return String(valInt);
|
||||
case typeDouble: return String(valDouble);
|
||||
case typeBool: return String(valBool);
|
||||
case typeString: return String(valStringPtr, valStringLen);
|
||||
case typeInt64: return String(valInt64);
|
||||
case typeObject: return valObject ? valObject->toString() : String();
|
||||
default: ;
|
||||
}
|
||||
return String();
|
||||
}
|
||||
//Variant::operator String() const { return asString(); }
|
||||
|
||||
|
||||
void Variant::mark(hx::MarkContext *__inCtx)
|
||||
{
|
||||
if (type==typeString)
|
||||
{
|
||||
HX_MARK_STRING(valStringPtr);
|
||||
}
|
||||
else if (type==typeObject)
|
||||
{
|
||||
HX_MARK_OBJECT(valObject);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool Variant::operator==(const T &inRHS) const
|
||||
{
|
||||
switch(type)
|
||||
{
|
||||
case typeInt: return valInt==(double)inRHS;
|
||||
case typeDouble:return valDouble==(double)inRHS;
|
||||
case typeBool: return valBool==(bool)inRHS;
|
||||
case typeInt64: return valInt64==(cpp::Int64)inRHS;
|
||||
case typeString: return getString()==String(inRHS);
|
||||
case typeObject:
|
||||
if (!valObject)
|
||||
return inRHS == null();
|
||||
return valObject->__Compare( Dynamic(inRHS).mPtr )==0;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
int Variant::Compare(hx::Object *inPtr) const
|
||||
{
|
||||
if (!inPtr)
|
||||
return isNull() ? 0 : 1;
|
||||
|
||||
switch(type)
|
||||
{
|
||||
case typeInt:
|
||||
{
|
||||
double diff = valInt - inPtr->__ToDouble();
|
||||
return diff<0 ? -1 : diff==0 ? 0 : 1;
|
||||
}
|
||||
case typeDouble:
|
||||
{
|
||||
double diff = valDouble - inPtr->__ToDouble();
|
||||
return diff<0 ? -1 : diff==0 ? 0 : 1;
|
||||
}
|
||||
case typeInt64:
|
||||
{
|
||||
cpp::Int64 diff = valInt64 - inPtr->__ToInt64();
|
||||
return diff<0 ? -1 : diff==0 ? 0 : 1;
|
||||
}
|
||||
case typeBool:
|
||||
if (!inPtr) return 1;
|
||||
return valBool==(bool)(inPtr->__ToInt()) ? 1 : 0;
|
||||
case typeString:
|
||||
if (!inPtr) return valStringPtr ? 1 : 0;
|
||||
if (inPtr->__GetType()!=vtString)
|
||||
return 1;
|
||||
return String(valStringPtr, valStringLen)==inPtr->toString() ? 1 : 0;
|
||||
case typeObject:
|
||||
#if (HXCPP_API_LEVEL>=331)
|
||||
return valObject->__Compare( inPtr );
|
||||
#else
|
||||
return valObject->__Compare( inPtr->__GetRealObject() );
|
||||
#endif
|
||||
default: ;
|
||||
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int Variant::Compare(const Dynamic &inD) const { return Compare(inD.mPtr); }
|
||||
int Variant::Compare(const cpp::Variant &inVar) const
|
||||
{
|
||||
if (inVar.type==typeObject)
|
||||
return Compare(inVar.valObject);
|
||||
|
||||
switch(type)
|
||||
{
|
||||
case typeInt:
|
||||
{
|
||||
double diff = valInt - inVar.asDouble();
|
||||
return diff<0 ? -1 : diff==0 ? 0 : 1;
|
||||
}
|
||||
case typeDouble:
|
||||
{
|
||||
double diff = valDouble - inVar.asDouble();
|
||||
return diff<0 ? -1 : diff==0 ? 0 : 1;
|
||||
}
|
||||
case typeInt64:
|
||||
{
|
||||
cpp::Int64 diff = valInt64 - inVar.asInt64();
|
||||
return diff<0 ? -1 : diff==0 ? 0 : 1;
|
||||
}
|
||||
case typeBool:
|
||||
return valBool==(bool)(inVar.asInt()) ? 1 : 0;
|
||||
case typeString:
|
||||
if (inVar.type!=typeString)
|
||||
return 1;
|
||||
return String(valStringPtr, valStringLen)==inVar.asString();
|
||||
case typeObject:
|
||||
if (!valObject)
|
||||
return 1;
|
||||
return - inVar.Compare(*this);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
String cpp::Variant::operator+(const String &s) const
|
||||
{
|
||||
return asString() + s;
|
||||
}
|
||||
template<typename T>
|
||||
cpp::Variant Variant::operator + (const T &inRHS) const
|
||||
{
|
||||
if (isString() || ::cpp::isStringType(inRHS))
|
||||
return asString() + String(inRHS);
|
||||
return asDouble() + (double)inRHS;
|
||||
}
|
||||
|
||||
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
void Variant::visit(hx::VisitContext *__inCtx)
|
||||
{
|
||||
if (type==typeString)
|
||||
{
|
||||
HX_VISIT_STRING(valStringPtr);
|
||||
}
|
||||
else if (type==typeObject)
|
||||
{
|
||||
HX_VISIT_OBJECT(valObject);
|
||||
}
|
||||
}
|
||||
#endif // HXCPP_VISIT_ALLOCS
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#define HX_VARIANT_OP_ISEQ(T) \
|
||||
inline bool operator == (const T &inLHS,const cpp::Variant &inRHS) { return inRHS==inLHS; } \
|
||||
inline bool operator != (const T &inLHS,const cpp::Variant &inRHS) { return inRHS!=inLHS; }
|
||||
|
||||
|
||||
#define HX_VARIANT_OP_ISEQ(T) \
|
||||
inline bool operator == (const T &inLHS,const cpp::Variant &inRHS) { return inRHS==inLHS; } \
|
||||
inline bool operator != (const T &inLHS,const cpp::Variant &inRHS) { return inRHS!=inLHS; }
|
||||
|
||||
HX_VARIANT_OP_ISEQ(String)
|
||||
HX_VARIANT_OP_ISEQ(double)
|
||||
HX_VARIANT_OP_ISEQ(float)
|
||||
HX_VARIANT_OP_ISEQ(cpp::Int64)
|
||||
HX_VARIANT_OP_ISEQ(cpp::UInt64)
|
||||
HX_VARIANT_OP_ISEQ(int)
|
||||
HX_VARIANT_OP_ISEQ(unsigned int)
|
||||
HX_VARIANT_OP_ISEQ(short)
|
||||
HX_VARIANT_OP_ISEQ(unsigned short)
|
||||
HX_VARIANT_OP_ISEQ(signed char)
|
||||
HX_VARIANT_OP_ISEQ(unsigned char)
|
||||
HX_VARIANT_OP_ISEQ(bool)
|
||||
|
||||
inline bool operator < (bool inLHS,const cpp::Variant &inRHS) { return false; }
|
||||
inline bool operator <= (bool inLHS,const cpp::Variant &inRHS) { return false; }
|
||||
inline bool operator >= (bool inLHS,const cpp::Variant &inRHS) { return false; }
|
||||
inline bool operator > (bool inLHS,const cpp::Variant &inRHS) { return false; }
|
||||
|
||||
|
||||
#define HX_COMPARE_VARIANT_OP( op ) \
|
||||
inline bool operator op (double inLHS,const ::cpp::Variant &inRHS) \
|
||||
{ return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
|
||||
inline bool operator op (float inLHS,const ::cpp::Variant &inRHS) \
|
||||
{ return inRHS.isNumeric() && ((double)inLHS op (double)inRHS); } \
|
||||
inline bool operator op (cpp::Int64 inLHS,const ::cpp::Variant &inRHS) \
|
||||
{ return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
|
||||
inline bool operator op (cpp::UInt64 inLHS,const ::cpp::Variant &inRHS) \
|
||||
{ return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
|
||||
inline bool operator op (int inLHS,const ::cpp::Variant &inRHS) \
|
||||
{ return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
|
||||
inline bool operator op (unsigned int inLHS,const ::cpp::Variant &inRHS) \
|
||||
{ return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
|
||||
inline bool operator op (short inLHS,const ::cpp::Variant &inRHS) \
|
||||
{ return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
|
||||
inline bool operator op (unsigned short inLHS,const ::cpp::Variant &inRHS) \
|
||||
{ return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
|
||||
inline bool operator op (signed char inLHS,const ::cpp::Variant &inRHS) \
|
||||
{ return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
|
||||
inline bool operator op (unsigned char inLHS,const ::cpp::Variant &inRHS) \
|
||||
{ return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
|
||||
inline bool operator op (const null &,const ::cpp::Variant &inRHS) \
|
||||
{ return false; } \
|
||||
|
||||
HX_COMPARE_VARIANT_OP( < )
|
||||
HX_COMPARE_VARIANT_OP( <= )
|
||||
HX_COMPARE_VARIANT_OP( >= )
|
||||
HX_COMPARE_VARIANT_OP( > )
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
} // close cpp
|
||||
namespace hx {
|
||||
template<typename T>
|
||||
bool ObjectPtr<T>::operator==(const cpp::Variant &inRHS) const {
|
||||
return inRHS.Compare(mPtr)==0;
|
||||
}
|
||||
template<typename T>
|
||||
bool ObjectPtr<T>::operator!=(const cpp::Variant &inRHS) const {
|
||||
return inRHS.Compare(mPtr)!=0;
|
||||
}
|
||||
|
||||
} // close hx
|
||||
namespace cpp {
|
||||
|
||||
#endif // not twice
|
||||
|
||||
|
||||
|
||||
} // end namespace cpp
|
||||
|
||||
|
||||
|
||||
|
||||
#endif // CPP_VARIANT_TWICE_H
|
||||
727
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp/VirtualArray.h
Normal file
727
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp/VirtualArray.h
Normal file
@ -0,0 +1,727 @@
|
||||
namespace cpp
|
||||
{
|
||||
|
||||
// This file is included twice - either side of the Array definition
|
||||
#ifndef HX_VARRAY_DEFINED
|
||||
#define HX_VARRAY_DEFINED
|
||||
|
||||
|
||||
class VirtualArray : public hx::ObjectPtr<VirtualArray_obj>
|
||||
{
|
||||
typedef hx::ObjectPtr<VirtualArray_obj> super;
|
||||
public:
|
||||
typedef Dynamic Elem;
|
||||
|
||||
inline VirtualArray() : super(0) { }
|
||||
inline VirtualArray(VirtualArray_obj *inObj) : super(inObj) { }
|
||||
inline VirtualArray(const null &inNull) : super(0) { }
|
||||
inline VirtualArray(const VirtualArray &inOther) : super( inOther.mPtr ) { }
|
||||
|
||||
// Build from foreign array
|
||||
template<typename SOURCE_> inline VirtualArray( const Array<SOURCE_> &inRHS );
|
||||
|
||||
|
||||
inline VirtualArray( const Dynamic &inRHS ) : super(0) { setDynamic(inRHS); }
|
||||
inline VirtualArray( const cpp::ArrayBase &inRHS ) : super(0) { setDynamic(inRHS); }
|
||||
inline VirtualArray(const ::cpp::Variant &inVariant) { setDynamic(inVariant.asObject()); }
|
||||
|
||||
|
||||
|
||||
|
||||
inline VirtualArray &operator=(const null &inNull) { mPtr = 0; return *this; }
|
||||
inline VirtualArray &operator=(Ptr inRHS) { mPtr = inRHS; return *this; }
|
||||
inline VirtualArray &operator=(const VirtualArray &inRHS) { mPtr = inRHS.mPtr; return *this; }
|
||||
|
||||
inline void setDynamic( const Dynamic &inRHS );
|
||||
|
||||
template<typename T>
|
||||
inline VirtualArray Add(const T &inVal);
|
||||
|
||||
|
||||
inline bool operator==(const Dynamic &value) const { return value==*this; }
|
||||
template<typename SOURCE_> inline bool operator==( const Array<SOURCE_> &inRHS );
|
||||
|
||||
inline bool operator!=(Dynamic value) const { return value!=*this; }
|
||||
template<typename SOURCE_> inline bool operator!=( const Array<SOURCE_> &inRHS ) { return inRHS!=*this; }
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class HXCPP_EXTERN_CLASS_ATTRIBUTES VirtualArray_obj : public hx::ArrayCommon
|
||||
{
|
||||
typedef hx::ArrayStore ArrayStore;
|
||||
typedef hx::ArrayBase ArrayBase;
|
||||
|
||||
public:
|
||||
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdVirtualArray };
|
||||
|
||||
typedef hx::Object super;
|
||||
ArrayStore store;
|
||||
ArrayBase *base;
|
||||
|
||||
VirtualArray_obj(ArrayBase *inBase=0, bool inFixed=false) : base(inBase)
|
||||
{
|
||||
mArrayConvertId = hx::aciVirtualArray;
|
||||
store = inFixed && inBase ? hx::arrayFixed : base ? base->getStoreType() : hx::arrayEmpty;
|
||||
#ifdef HXCPP_GC_GENERATIONAL
|
||||
if (base)
|
||||
HX_OBJ_WB_GET(this,base);
|
||||
#endif
|
||||
}
|
||||
|
||||
VirtualArray_obj(ArrayStore inStore)
|
||||
{
|
||||
mArrayConvertId = hx::aciVirtualArray;
|
||||
store = inStore;
|
||||
}
|
||||
|
||||
hx::Object *__GetRealObject() { return base?(hx::Object *)base:(hx::Object *)this; }
|
||||
|
||||
inline static VirtualArray __new(int inSize=0,int inReserve=0)
|
||||
{
|
||||
VirtualArray result = new VirtualArray_obj(hx::arrayEmpty);
|
||||
if (inSize>0)
|
||||
result->__SetSizeExact(inSize);
|
||||
if (inReserve>0)
|
||||
result->reserve(inReserve);
|
||||
return result;
|
||||
}
|
||||
|
||||
#if (HXCPP_API_LEVEL>330)
|
||||
int __Compare(const hx::Object *inRHS) const;
|
||||
#endif
|
||||
|
||||
|
||||
inline int get_length() const
|
||||
{
|
||||
return base ? base->length : 0;
|
||||
}
|
||||
|
||||
inline void checkBase() const
|
||||
{
|
||||
#ifdef HXCPP_CHECK_POINTER
|
||||
if (store==hx::arrayNull)
|
||||
{
|
||||
hx::NullReference("Array", true);
|
||||
// The handler might have fixed up the null value
|
||||
if (store==hx::arrayNull) hx::NullReference("Array", false);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void EnsureStorage(const Dynamic &inValue)
|
||||
{
|
||||
if (!inValue.mPtr)
|
||||
{
|
||||
EnsureNullStorage();
|
||||
}
|
||||
else switch(inValue->__GetType())
|
||||
{
|
||||
case vtBool: EnsureBoolStorage(); break;
|
||||
case vtInt: EnsureIntStorage(); break;
|
||||
case vtFloat: EnsureFloatStorage(); break;
|
||||
case vtString: EnsureStringStorage(); break;
|
||||
case vtInt64: EnsureInt64Storage(); break;
|
||||
default: EnsureObjectStorage();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void EnsureStorage(const cpp::Variant &inValue)
|
||||
{
|
||||
switch(inValue.type)
|
||||
{
|
||||
case Variant::typeObject:
|
||||
if (!inValue.valObject)
|
||||
EnsureNullStorage();
|
||||
else
|
||||
EnsureObjectStorage();
|
||||
break;
|
||||
case Variant::typeString: EnsureStringStorage(); break;
|
||||
case Variant::typeDouble: EnsureFloatStorage(); break;
|
||||
case Variant::typeInt: EnsureIntStorage(); break;
|
||||
case Variant::typeBool: EnsureBoolStorage(); break;
|
||||
case Variant::typeInt64: EnsureInt64Storage(); break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void MakeIntArray();
|
||||
void MakeInt64Array();
|
||||
void MakeObjectArray();
|
||||
void MakeFloatArray();
|
||||
void MakeBoolArray();
|
||||
void MakeStringArray();
|
||||
|
||||
void EnsureStorage(const VirtualArray &inValue) { EnsureObjectStorage(); }
|
||||
void EnsureStorage(const unsigned char &inValue) { EnsureIntStorage(); }
|
||||
void EnsureStorage(const bool &inValue) { EnsureBoolStorage(); }
|
||||
void EnsureStorage(const String &inValue) { EnsureStringStorage(); }
|
||||
void EnsureStorage(const double &inValue) { EnsureFloatStorage(); }
|
||||
void EnsureStorage(const float &inValue) { EnsureFloatStorage(); }
|
||||
void EnsureStorage(const int &inValue) { EnsureIntStorage(); }
|
||||
void EnsureStorage(const cpp::Int64 &inValue) { EnsureInt64Storage(); }
|
||||
void EnsureStorage(const cpp::UInt64 &inValue) { EnsureInt64Storage(); }
|
||||
void EnsureStorage(const null &inValue) { EnsureNullStorage(); }
|
||||
template<typename T>
|
||||
void EnsureStorage(const T &inValue) { EnsureObjectStorage(); }
|
||||
|
||||
inline void EnsureBoolStorage()
|
||||
{
|
||||
switch(store)
|
||||
{
|
||||
case hx::arrayNull:
|
||||
case hx::arrayObject:
|
||||
case hx::arrayFixed:
|
||||
case hx::arrayBool:
|
||||
return;
|
||||
case hx::arrayEmpty:
|
||||
MakeBoolArray();
|
||||
break;
|
||||
case hx::arrayInt:
|
||||
case hx::arrayInt64:
|
||||
case hx::arrayFloat:
|
||||
case hx::arrayString:
|
||||
MakeObjectArray();
|
||||
break;
|
||||
}
|
||||
}
|
||||
inline void EnsureStringStorage()
|
||||
{
|
||||
switch(store)
|
||||
{
|
||||
case hx::arrayNull:
|
||||
case hx::arrayObject:
|
||||
case hx::arrayFixed:
|
||||
case hx::arrayString:
|
||||
return;
|
||||
case hx::arrayEmpty:
|
||||
MakeStringArray();
|
||||
break;
|
||||
case hx::arrayInt:
|
||||
case hx::arrayInt64:
|
||||
case hx::arrayFloat:
|
||||
case hx::arrayBool:
|
||||
MakeObjectArray();
|
||||
break;
|
||||
}
|
||||
}
|
||||
inline void EnsureFloatStorage()
|
||||
{
|
||||
switch(store)
|
||||
{
|
||||
case hx::arrayNull:
|
||||
case hx::arrayFloat:
|
||||
case hx::arrayObject:
|
||||
case hx::arrayFixed:
|
||||
return;
|
||||
case hx::arrayInt:
|
||||
case hx::arrayInt64:
|
||||
case hx::arrayEmpty:
|
||||
MakeFloatArray();
|
||||
break;
|
||||
case hx::arrayBool:
|
||||
case hx::arrayString:
|
||||
MakeObjectArray();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
inline void EnsureIntStorage()
|
||||
{
|
||||
switch(store)
|
||||
{
|
||||
case hx::arrayNull:
|
||||
case hx::arrayInt:
|
||||
case hx::arrayInt64:
|
||||
case hx::arrayFloat:
|
||||
case hx::arrayObject:
|
||||
case hx::arrayFixed:
|
||||
return;
|
||||
case hx::arrayEmpty:
|
||||
MakeIntArray();
|
||||
break;
|
||||
case hx::arrayBool:
|
||||
case hx::arrayString:
|
||||
MakeObjectArray();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
inline void EnsureInt64Storage()
|
||||
{
|
||||
switch(store)
|
||||
{
|
||||
case hx::arrayNull:
|
||||
case hx::arrayInt64:
|
||||
case hx::arrayFloat:
|
||||
case hx::arrayObject:
|
||||
case hx::arrayFixed:
|
||||
return;
|
||||
case hx::arrayInt:
|
||||
case hx::arrayEmpty:
|
||||
MakeInt64Array();
|
||||
break;
|
||||
case hx::arrayBool:
|
||||
case hx::arrayString:
|
||||
MakeObjectArray();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
inline void EnsureObjectStorage()
|
||||
{
|
||||
switch(store)
|
||||
{
|
||||
case hx::arrayNull:
|
||||
case hx::arrayObject:
|
||||
case hx::arrayFixed:
|
||||
return;
|
||||
case hx::arrayEmpty:
|
||||
case hx::arrayInt:
|
||||
case hx::arrayInt64:
|
||||
case hx::arrayFloat:
|
||||
case hx::arrayBool:
|
||||
case hx::arrayString:
|
||||
MakeObjectArray();
|
||||
break;
|
||||
}
|
||||
}
|
||||
inline void EnsureNullStorage()
|
||||
{
|
||||
switch(store)
|
||||
{
|
||||
case hx::arrayNull:
|
||||
case hx::arrayObject:
|
||||
case hx::arrayFixed:
|
||||
case hx::arrayString:
|
||||
return;
|
||||
case hx::arrayEmpty:
|
||||
case hx::arrayInt:
|
||||
case hx::arrayInt64:
|
||||
case hx::arrayFloat:
|
||||
case hx::arrayBool:
|
||||
MakeObjectArray();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename F> void fixType();
|
||||
template<typename F> F castArray();
|
||||
|
||||
void EnsureBase();
|
||||
void CreateEmptyArray(int inLen);
|
||||
|
||||
void EnsureArrayStorage(ArrayStore inValue);
|
||||
void EnsureArrayStorage(VirtualArray inValue);
|
||||
|
||||
void __Mark(hx::MarkContext *__inCtx)
|
||||
{
|
||||
HX_MARK_OBJECT(base);
|
||||
}
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
void __Visit(hx::VisitContext *__inCtx)
|
||||
{
|
||||
if (base)
|
||||
__inCtx->visitObject( (hx::Object **)&base);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
// Used by cpp.ArrayBase
|
||||
inline int getElementSize() const { return base ? base->GetElementSize() : 0; }
|
||||
inline int getByteCount() const { return base ? base->getByteCount() : 0; }
|
||||
inline char * getBase() const { return base ? base->GetBase() : 0; }
|
||||
hx::Val __SetField(const String &inString,const hx::Val &inValue ,hx::PropertyAccess inCallProp) { return null(); }
|
||||
|
||||
static hx::Class &__SGetClass() { return hx::ArrayBase::__mClass; }
|
||||
hx::Class __GetClass() const;
|
||||
String toString();
|
||||
String __ToString() const { return const_cast<VirtualArray_obj *>(this)->toString(); }
|
||||
|
||||
void setData(void *inData, int inElements) { EnsureBase(); base->setData(inData, inElements); }
|
||||
void setUnmanagedData(void *inData, int inElements) { EnsureBase(); base->setUnmanagedData(inData, inElements); }
|
||||
|
||||
int __GetType() const { return vtArray; }
|
||||
|
||||
inline size_t size() const { checkBase(); return store==hx::arrayEmpty ? 0 : base->length; }
|
||||
inline int __length() const { checkBase(); return store==hx::arrayEmpty ? 0 : (int)base->length; }
|
||||
|
||||
String ItemString(int inI) { checkBase(); return store==hx::arrayEmpty ? null() : base->ItemString(inI); }
|
||||
|
||||
const char * __CStr() const { return store==hx::arrayEmpty ? "[]" : store==hx::arrayNull ? "null" : base->__CStr(); }
|
||||
inline const char *GetBase() const { return base ? base->GetBase() : 0; }
|
||||
inline char *GetBase() { return base ? base->GetBase() : 0; }
|
||||
|
||||
int GetElementSize() const { checkBase(); return store==hx::arrayEmpty ? 0 : base->GetElementSize(); }
|
||||
|
||||
inline void reserve(int inSize) const
|
||||
{
|
||||
if (base)
|
||||
base->reserve(inSize);
|
||||
}
|
||||
|
||||
inline int capacity()
|
||||
{
|
||||
if (base)
|
||||
return base->capacity();
|
||||
return 0;
|
||||
}
|
||||
|
||||
void resize(int inLen)
|
||||
{
|
||||
if (!base)
|
||||
CreateEmptyArray(inLen);
|
||||
else
|
||||
base->resize(inLen);
|
||||
}
|
||||
void __SetSize(int inLen) { resize(inLen); }
|
||||
|
||||
VirtualArray __SetSizeExact(int inLen=0)
|
||||
{
|
||||
if (!base && inLen)
|
||||
CreateEmptyArray(inLen);
|
||||
else if (base)
|
||||
base->__SetSizeExact(inLen);
|
||||
return this;
|
||||
}
|
||||
|
||||
void safeSort(Dynamic sorter, bool isString) { checkBase(); if (store!=hx::arrayEmpty) base->safeSort(sorter,isString); }
|
||||
|
||||
inline void __unsafeStringReference(String inString) { if (base) base->__unsafeStringReference(inString); }
|
||||
|
||||
|
||||
Dynamic __GetItem(int inIndex) const;
|
||||
Dynamic __SetItem(int inIndex,Dynamic inValue);
|
||||
hx::Val __Field(const String &inString, hx::PropertyAccess inCallProp);
|
||||
|
||||
template<typename T>
|
||||
inline const T &set(int inIdx, const T &inVal)
|
||||
{
|
||||
if (store!=hx::arrayFixed)
|
||||
{
|
||||
if (inIdx>(store==hx::arrayEmpty ? 0 : (int)base->length) )
|
||||
EnsureObjectStorage();
|
||||
else
|
||||
EnsureStorage(inVal);
|
||||
}
|
||||
base->set(inIdx, inVal);
|
||||
return inVal;
|
||||
}
|
||||
|
||||
|
||||
template<typename T>
|
||||
inline int push(const T &inVal)
|
||||
{
|
||||
if (store!=hx::arrayFixed) EnsureStorage(inVal);
|
||||
return base->__push(Dynamic(inVal));
|
||||
}
|
||||
|
||||
|
||||
template<typename T>
|
||||
inline VirtualArray_obj *Add(const T &inVal)
|
||||
{
|
||||
if (store!=hx::arrayFixed) EnsureStorage(inVal);
|
||||
base->__push(Dynamic(inVal));
|
||||
return this;
|
||||
}
|
||||
|
||||
inline Dynamic pop() { checkBase(); return store==hx::arrayEmpty ? null() : base->__pop(); }
|
||||
|
||||
inline bool contains(Dynamic inValue)
|
||||
{
|
||||
checkBase();
|
||||
if (store==hx::arrayEmpty)
|
||||
return false;
|
||||
EnsureStorage(inValue);
|
||||
return base->__contains(inValue);
|
||||
}
|
||||
|
||||
inline bool remove(Dynamic inValue)
|
||||
{
|
||||
checkBase();
|
||||
if (store==hx::arrayEmpty)
|
||||
return false;
|
||||
EnsureStorage(inValue);
|
||||
return base->__remove(inValue);
|
||||
}
|
||||
|
||||
inline bool removeAt(int inIndex) { checkBase(); return (store!=hx::arrayEmpty) && base->__removeAt(inIndex); }
|
||||
|
||||
int indexOf(Dynamic inValue, Dynamic fromIndex = null())
|
||||
{
|
||||
checkBase();
|
||||
if (store==hx::arrayEmpty)
|
||||
return -1;
|
||||
EnsureStorage(inValue);
|
||||
return (int)base->__indexOf(inValue,fromIndex);
|
||||
}
|
||||
int lastIndexOf(Dynamic inValue, Dynamic fromIndex = null())
|
||||
{
|
||||
checkBase();
|
||||
if (store==hx::arrayEmpty)
|
||||
return -1;
|
||||
EnsureStorage(inValue);
|
||||
return (int)base->__lastIndexOf(inValue,fromIndex);
|
||||
}
|
||||
|
||||
Dynamic shift() { checkBase(); return store==hx::arrayEmpty ? null() : base->__shift(); }
|
||||
|
||||
VirtualArray concat( VirtualArray inTail )
|
||||
{
|
||||
inTail->checkBase();
|
||||
EnsureArrayStorage(inTail);
|
||||
if (inTail->__length()<1)
|
||||
return copy();
|
||||
return new VirtualArray_obj( base->__concat(inTail), store==hx::arrayFixed );
|
||||
}
|
||||
VirtualArray copy( )
|
||||
{
|
||||
checkBase();
|
||||
if (store==hx::arrayEmpty)
|
||||
return new VirtualArray_obj(hx::arrayEmpty);
|
||||
|
||||
return new VirtualArray_obj(base->__copy(), store==hx::arrayFixed);
|
||||
}
|
||||
VirtualArray slice(int inPos, Dynamic end = null())
|
||||
{
|
||||
checkBase();
|
||||
if (store==hx::arrayEmpty)
|
||||
return new VirtualArray_obj(hx::arrayEmpty);
|
||||
return new VirtualArray_obj(base->__slice(inPos,end), store==hx::arrayFixed);
|
||||
}
|
||||
VirtualArray splice(int inPos, int len);
|
||||
VirtualArray map(Dynamic inFunc);
|
||||
VirtualArray filter(Dynamic inFunc);
|
||||
|
||||
template<typename T>
|
||||
inline VirtualArray init(int inIndex, const T &inVal)
|
||||
{
|
||||
if (store!=hx::arrayFixed) EnsureStorage(inVal);
|
||||
__SetItem(inIndex,inVal);
|
||||
return this;
|
||||
}
|
||||
|
||||
inline Dynamic __unsafe_set(int inIndex, const Dynamic &val) { return __SetItem(inIndex,val); }
|
||||
inline Dynamic __unsafe_get(int inIndex) { return __GetItem(inIndex); }
|
||||
|
||||
|
||||
template<typename T>
|
||||
inline void insert(int inPos, const T &inValue)
|
||||
{
|
||||
if (store!=hx::arrayFixed)
|
||||
{
|
||||
if (inPos>(store==hx::arrayEmpty ? 0 : (int)base->length) )
|
||||
EnsureObjectStorage();
|
||||
else
|
||||
EnsureStorage(inValue);
|
||||
}
|
||||
|
||||
base->__insert(inPos,inValue);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline void unshift(const T& inValue)
|
||||
{
|
||||
if (store!=hx::arrayFixed) EnsureStorage(inValue);
|
||||
base->__unshift(inValue);
|
||||
}
|
||||
|
||||
inline void reverse() { checkBase(); if (store!=hx::arrayEmpty) base->__reverse(); }
|
||||
|
||||
inline void qsort(Dynamic inSorter) { checkBase(); if (base) base->__qsort(inSorter); }
|
||||
|
||||
inline void sort(Dynamic inSorter) { checkBase(); if (base) base->__sort(inSorter); }
|
||||
|
||||
Dynamic iterator() { checkBase(); return !base ? getEmptyIterator() : base->__iterator(); }
|
||||
static Dynamic getEmptyIterator();
|
||||
|
||||
Dynamic keyValueIterator() { checkBase(); return !base ? getEmptyIterator() : base->__keyValueIterator(); }
|
||||
|
||||
bool IsByteArray() const { checkBase(); return store!=hx::arrayEmpty && base->IsByteArray(); }
|
||||
|
||||
void zero(Dynamic inFirst, Dynamic inCount) { checkBase(); if (store!=hx::arrayEmpty) base->zero(inFirst,inCount); }
|
||||
|
||||
inline int memcmp(VirtualArray inOther)
|
||||
{
|
||||
checkBase();
|
||||
if (store==hx::arrayEmpty)
|
||||
return inOther->__length() == 0;
|
||||
return base->__memcmp(inOther);
|
||||
}
|
||||
inline void blit(int inDestElement, cpp::VirtualArray inSourceArray, int inSourceElement, int inElementCount)
|
||||
{
|
||||
inSourceArray->checkBase();
|
||||
EnsureArrayStorage(inSourceArray);
|
||||
if (base)
|
||||
base->__blit(inDestElement, inSourceArray, inSourceElement, inElementCount);
|
||||
}
|
||||
|
||||
String join(String inSeparator) { checkBase(); if (!base) return HX_CSTRING(""); return base->__join(inSeparator); }
|
||||
|
||||
|
||||
Dynamic __get(int inIndex) const { checkBase(); if (store==hx::arrayEmpty) return null(); return base->__GetItem(inIndex); }
|
||||
|
||||
Dynamic concat_dyn();
|
||||
Dynamic copy_dyn();
|
||||
Dynamic insert_dyn();
|
||||
Dynamic iterator_dyn();
|
||||
Dynamic keyValueIterator_dyn();
|
||||
Dynamic join_dyn();
|
||||
Dynamic pop_dyn();
|
||||
Dynamic push_dyn();
|
||||
Dynamic contains_dyn();
|
||||
Dynamic remove_dyn();
|
||||
Dynamic removeAt_dyn();
|
||||
Dynamic indexOf_dyn();
|
||||
Dynamic lastIndexOf_dyn();
|
||||
Dynamic reverse_dyn();
|
||||
Dynamic shift_dyn();
|
||||
Dynamic slice_dyn();
|
||||
Dynamic splice_dyn();
|
||||
Dynamic sort_dyn();
|
||||
Dynamic toString_dyn();
|
||||
Dynamic unshift_dyn();
|
||||
Dynamic map_dyn();
|
||||
Dynamic filter_dyn();
|
||||
Dynamic __SetSize_dyn();
|
||||
Dynamic __SetSizeExact_dyn();
|
||||
Dynamic __unsafe_get_dyn();
|
||||
Dynamic __unsafe_set_dyn();
|
||||
Dynamic blit_dyn();
|
||||
Dynamic zero_dyn();
|
||||
Dynamic memcmp_dyn();
|
||||
Dynamic resize_dyn();
|
||||
};
|
||||
|
||||
|
||||
//typedef hx::ObjectPtr< VirtualArray_obj > VirtualArray;
|
||||
|
||||
|
||||
|
||||
#else // !HX_VARRAY_DEFINED
|
||||
|
||||
|
||||
// Build dynamic array from foreign array
|
||||
template<typename SOURCE_>
|
||||
VirtualArray::VirtualArray( const Array<SOURCE_> &inRHS )
|
||||
: super( !inRHS.mPtr ? 0 : new VirtualArray_obj( inRHS.mPtr, true) )
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
template<typename T>
|
||||
inline VirtualArray VirtualArray::Add(const T &inVal)
|
||||
{
|
||||
mPtr->push(inVal);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline void VirtualArray::setDynamic( const Dynamic &inRHS )
|
||||
{
|
||||
hx::Object *ptr = inRHS.GetPtr();
|
||||
if (ptr)
|
||||
{
|
||||
if (ptr->__GetClass().mPtr == super::__SGetClass().mPtr )
|
||||
{
|
||||
cpp::VirtualArray_obj *varray = dynamic_cast<cpp::VirtualArray_obj *>(ptr);
|
||||
if (varray)
|
||||
mPtr = varray;
|
||||
else
|
||||
mPtr = new VirtualArray_obj(dynamic_cast<cpp::ArrayBase_obj *>(ptr), true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<typename F>
|
||||
void VirtualArray_obj::fixType()
|
||||
{
|
||||
if (store==hx::arrayFixed)
|
||||
return;
|
||||
|
||||
store = hx::arrayFixed;
|
||||
if (base && base->length>0)
|
||||
{
|
||||
Array<F> fixedArray = Dynamic(base);
|
||||
base = fixedArray.mPtr;
|
||||
}
|
||||
else
|
||||
{
|
||||
base = new Array_obj<F>(0,0);
|
||||
}
|
||||
#ifdef HXCPP_GC_GENERATIONAL
|
||||
if (base)
|
||||
HX_OBJ_WB_GET(this,base);
|
||||
#endif
|
||||
}
|
||||
|
||||
template<typename ARRAY >
|
||||
ARRAY VirtualArray_obj::castArray()
|
||||
{
|
||||
if (store==hx::arrayFixed)
|
||||
return Dynamic(base);
|
||||
|
||||
store = hx::arrayFixed;
|
||||
if (base && base->length>0)
|
||||
{
|
||||
ARRAY fixedArray = Dynamic(base);
|
||||
base = fixedArray.mPtr;
|
||||
#ifdef HXCPP_GC_GENERATIONAL
|
||||
if (base)
|
||||
HX_OBJ_WB_GET(this,base);
|
||||
#endif
|
||||
return fixedArray;
|
||||
}
|
||||
else
|
||||
{
|
||||
ARRAY fixedArray(0,0);
|
||||
base = fixedArray.mPtr;
|
||||
#ifdef HXCPP_GC_GENERATIONAL
|
||||
if (base)
|
||||
HX_OBJ_WB_GET(this,base);
|
||||
#endif
|
||||
return fixedArray;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename SOURCE_>
|
||||
inline bool VirtualArray::operator==( const Array<SOURCE_> &inRHS )
|
||||
{
|
||||
if (!mPtr)
|
||||
return inRHS.mPtr;
|
||||
return mPtr->castArray< Array<SOURCE_> >() == inRHS;
|
||||
}
|
||||
|
||||
} // end namespace cpp
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_reslove_virtual_array(cpp::VirtualArray inArray);
|
||||
|
||||
|
||||
|
||||
namespace hx
|
||||
{
|
||||
// For type inference when marking
|
||||
template<> inline void MarkMember(cpp::VirtualArray &outT,hx::MarkContext *__inCtx)
|
||||
{ HX_MARK_OBJECT(outT.mPtr); }
|
||||
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
template<> inline void VisitMember(cpp::VirtualArray &outT,hx::VisitContext *__inCtx)
|
||||
{
|
||||
HX_VISIT_OBJECT(outT.mPtr);
|
||||
}
|
||||
#endif
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
namespace cpp
|
||||
{
|
||||
#endif // HX_VARRAY_DEFINED
|
||||
}
|
||||
|
||||
38
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp_bytearray.h
Normal file
38
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp_bytearray.h
Normal file
@ -0,0 +1,38 @@
|
||||
#pragma once
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdint.h>
|
||||
|
||||
struct bytearray {
|
||||
uint8_t *data;
|
||||
int refCount;
|
||||
|
||||
bytearray() {
|
||||
data = NULL;
|
||||
refCount = 0;
|
||||
}
|
||||
|
||||
void alloc(int length) {
|
||||
data = new uint8_t[length];
|
||||
}
|
||||
|
||||
void addRef() {
|
||||
++refCount;
|
||||
}
|
||||
|
||||
void subRef() {
|
||||
--refCount;
|
||||
if (refCount == 0) {
|
||||
delete[] data;
|
||||
data = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
float get(int index) {
|
||||
return data[index];
|
||||
}
|
||||
|
||||
float set(int index, float value) {
|
||||
return data[index] = value;
|
||||
}
|
||||
};
|
||||
755
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Anon.h
Normal file
755
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Anon.h
Normal file
@ -0,0 +1,755 @@
|
||||
#ifndef HX_ANON_H
|
||||
#define HX_ANON_H
|
||||
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
typedef Dynamic FieldMap;
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic FieldMapCreate();
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
bool FieldMapGet(Dynamic *inMap, const ::String &inName, ::Dynamic &outValue);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
bool FieldMapHas(Dynamic *inMap, const ::String &inName);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
bool FieldMapGet(Dynamic *inMap, int inID, ::Dynamic &outValue);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
#ifdef HXCPP_GC_GENERATIONAL
|
||||
void FieldMapSet(hx::Object *inThis,Dynamic *inMap, const ::String &inName, const ::Dynamic &inValue);
|
||||
#else
|
||||
void FieldMapSet(Dynamic *inMap, const ::String &inName, const ::Dynamic &inValue);
|
||||
#endif
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
void FieldMapAppendFields(Dynamic *inMap,::Array< ::String> &outFields);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
void FieldMapMark(Dynamic *inMap,hx::MarkContext *__inCtx);
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
void FieldMapVisit(Dynamic **inMap,hx::VisitContext *__inCtx);
|
||||
#endif
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
|
||||
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
// --- hx::Anon_obj ----------------------------------------------
|
||||
//
|
||||
// The hx::Anon_obj contains an arbitrary string map of fields.
|
||||
|
||||
class HXCPP_EXTERN_CLASS_ATTRIBUTES Anon_obj : public hx::Object
|
||||
{
|
||||
typedef hx::Anon_obj OBJ_;
|
||||
typedef hx::ObjectPtr<hx::Anon_obj> Anon;
|
||||
typedef hx::Object super;
|
||||
|
||||
inline void *operator new( size_t inSize, int inExtra )
|
||||
{
|
||||
return hx::Object::operator new(inSize+inExtra, true, 0);
|
||||
}
|
||||
|
||||
struct VariantKey
|
||||
{
|
||||
int hash;
|
||||
String key;
|
||||
cpp::Variant value;
|
||||
};
|
||||
|
||||
Dynamic mFields;
|
||||
int mFixedFields;
|
||||
|
||||
public:
|
||||
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdDynamic };
|
||||
|
||||
inline void *operator new( size_t inSize )
|
||||
{
|
||||
return hx::Object::operator new(inSize, true, 0);
|
||||
}
|
||||
inline void operator delete(void *, size_t inSize ) { }
|
||||
inline void operator delete(void *, size_t inSize, int inExtra ) { }
|
||||
|
||||
inline Anon_obj *setFixed(int index, const String &inName, const ::cpp::Variant &inValue)
|
||||
{
|
||||
VariantKey *fixed = getFixed() + index;
|
||||
fixed->hash = inName.hash();
|
||||
fixed->key = inName;
|
||||
fixed->value = inValue;
|
||||
if (inValue.type == ::cpp::Variant::typeObject) {
|
||||
HX_OBJ_WB_GET(this, inValue.valObject);
|
||||
}
|
||||
else if (inValue.type == ::cpp::Variant::typeString) {
|
||||
HX_OBJ_WB_GET(this, inValue.valStringPtr);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
inline VariantKey *getFixed()
|
||||
{
|
||||
return (VariantKey *)(this + 1);
|
||||
}
|
||||
inline int findFixed(const ::String &inKey,bool inSkip5 = false);
|
||||
|
||||
|
||||
|
||||
|
||||
Anon_obj(int inFixedFields = 0);
|
||||
|
||||
static Anon Create(int inElements)
|
||||
{
|
||||
return Anon(new (inElements*sizeof(VariantKey) ) hx::Anon_obj(inElements) );
|
||||
}
|
||||
|
||||
static Anon Create() { return Anon(new (0) hx::Anon_obj); }
|
||||
static Anon Create(const Dynamic &inSrc) { return Anon(new (0) hx::Anon_obj); }
|
||||
|
||||
static Dynamic __CreateEmpty() { return Anon(new (0) hx::Anon_obj); }
|
||||
static Dynamic __Create(DynamicArray inArgs);
|
||||
static void __boot();
|
||||
|
||||
void operator delete( void *, int) { }
|
||||
|
||||
|
||||
hx::Val __Field(const String &inString ,hx::PropertyAccess inCallProp);
|
||||
bool __HasField(const String &inString);
|
||||
hx::Val __SetField(const String &inString,const hx::Val &inValue ,hx::PropertyAccess inCallProp);
|
||||
virtual void __GetFields(Array<String> &outFields);
|
||||
Dynamic *__GetFieldMap() { return &mFields; }
|
||||
|
||||
virtual int __GetType() const { return vtObject; }
|
||||
|
||||
hx::Anon_obj *Add(const String &inName,const Dynamic &inValue,bool inSetThisPointer=true);
|
||||
void __Mark(hx::MarkContext *__inCtx);
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
void __Visit(hx::VisitContext *__inCtx);
|
||||
#endif
|
||||
|
||||
String __ToString() const;
|
||||
String toString();
|
||||
|
||||
static hx::ObjectPtr<hx::Class_obj> __mClass; \
|
||||
static hx::ObjectPtr<hx::Class_obj> &__SGetClass() { return __mClass; }
|
||||
#if (HXCPP_API_LEVEL<331)
|
||||
bool __Is(hx::Object *inObj) const { return dynamic_cast<OBJ_ *>(inObj)!=0; }
|
||||
#endif
|
||||
hx::ObjectPtr<hx::Class_obj > __GetClass() const { return __mClass; }
|
||||
|
||||
bool __Remove(String inKey);
|
||||
};
|
||||
|
||||
|
||||
typedef hx::ObjectPtr<hx::Anon_obj> Anon;
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Anon SourceInfo(String inFile, int inLine, String inClass, String inMethod);
|
||||
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String StringFromAnonFields(hx::Object *inPtr);
|
||||
|
||||
|
||||
template<typename _hx_T0>
|
||||
class AnonStruct1_obj : public hx::Object
|
||||
{
|
||||
public:
|
||||
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdDynamic };
|
||||
|
||||
String name0; _hx_T0 t0;
|
||||
|
||||
inline static hx::Object *Create(const String &inName0, _hx_T0 inT0)
|
||||
{
|
||||
AnonStruct1_obj *result = new AnonStruct1_obj;
|
||||
result->name0 = inName0; result->t0 = inT0;
|
||||
if (hx::ContainsPointers<_hx_T0>()) {
|
||||
HX_OBJ_WB_GET(result, hx::PointerOf(inT0));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
hx::Val __Field(const String &inField, hx::PropertyAccess)
|
||||
{
|
||||
if (HX_QSTR_EQ(inField,name0)) return t0;
|
||||
return null();
|
||||
}
|
||||
hx::Val __SetField(const String &inField,const hx::Val &inValue, hx::PropertyAccess inCallProp)
|
||||
{
|
||||
if (inField.__s==name0.__s || HX_QSTR_EQ(inField,name0)) {
|
||||
t0 = inValue.Cast< _hx_T0 >();
|
||||
if (hx::ContainsPointers<_hx_T0>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t0));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
hx::Throw(HX_CSTRING("Missing field ") + inField);
|
||||
return inValue;
|
||||
}
|
||||
|
||||
void __Mark(hx::MarkContext *__inCtx)
|
||||
{
|
||||
HX_MARK_MEMBER(t0);
|
||||
}
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
void __Visit(hx::VisitContext *__inCtx)
|
||||
{
|
||||
HX_VISIT_MEMBER(t0);
|
||||
}
|
||||
#endif
|
||||
|
||||
void __GetFields(Array<String> &outFields)
|
||||
{
|
||||
outFields->push(name0);
|
||||
}
|
||||
|
||||
String toString() { return StringFromAnonFields(this); }
|
||||
};
|
||||
|
||||
|
||||
|
||||
template<typename _hx_T0, typename _hx_T1>
|
||||
class AnonStruct2_obj : public hx::Object
|
||||
{
|
||||
public:
|
||||
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdDynamic };
|
||||
|
||||
String name0; _hx_T0 t0;
|
||||
String name1; _hx_T1 t1;
|
||||
|
||||
inline static hx::Object *Create(const String &inName0, _hx_T0 inT0,
|
||||
const String &inName1, _hx_T1 inT1)
|
||||
{
|
||||
AnonStruct2_obj *result = new AnonStruct2_obj;
|
||||
result->name0 = inName0; result->t0 = inT0;
|
||||
if (hx::ContainsPointers<_hx_T0>()) {
|
||||
HX_OBJ_WB_GET(result, hx::PointerOf(inT0));
|
||||
}
|
||||
result->name1 = inName1; result->t1 = inT1;
|
||||
if (hx::ContainsPointers<_hx_T1>()) {
|
||||
HX_OBJ_WB_GET(result, hx::PointerOf(inT1));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
hx::Val __Field(const String &inField, hx::PropertyAccess)
|
||||
{
|
||||
if (inField.__s==name0.__s) return t0;
|
||||
if (inField.__s==name1.__s) return t1;
|
||||
|
||||
#ifdef HX_SMART_STRINGS
|
||||
if (!inField.isAsciiEncodedQ())
|
||||
return null();
|
||||
#endif
|
||||
|
||||
if (HX_QSTR_EQ_AE(inField,name0)) return t0;
|
||||
if (HX_QSTR_EQ_AE(inField,name1)) return t1;
|
||||
return null();
|
||||
}
|
||||
hx::Val __SetField(const String &inField,const hx::Val &inValue, hx::PropertyAccess inCallProp)
|
||||
{
|
||||
if (inField.__s==name0.__s) {
|
||||
t0 = inValue.Cast< _hx_T0 >();
|
||||
if (hx::ContainsPointers<_hx_T0>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t0));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (inField.__s==name1.__s) {
|
||||
t1 = inValue.Cast< _hx_T1 >();
|
||||
if (hx::ContainsPointers<_hx_T1>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t1));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
|
||||
if (HX_QSTR_EQ(inField,name0)) {
|
||||
t0 = inValue.Cast< _hx_T0 >();
|
||||
if (hx::ContainsPointers<_hx_T0>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t0));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (HX_QSTR_EQ(inField,name1)) {
|
||||
t1 = inValue.Cast< _hx_T1 >();
|
||||
if (hx::ContainsPointers<_hx_T1>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t1));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
hx::Throw(HX_CSTRING("Missing field ") + inField);
|
||||
return inValue;
|
||||
}
|
||||
|
||||
void __Mark(hx::MarkContext *__inCtx)
|
||||
{
|
||||
HX_MARK_MEMBER(t0);
|
||||
HX_MARK_MEMBER(t1);
|
||||
}
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
void __Visit(hx::VisitContext *__inCtx)
|
||||
{
|
||||
HX_VISIT_MEMBER(t0);
|
||||
HX_VISIT_MEMBER(t1);
|
||||
}
|
||||
#endif
|
||||
|
||||
void __GetFields(Array<String> &outFields)
|
||||
{
|
||||
outFields->push(name0);
|
||||
outFields->push(name1);
|
||||
}
|
||||
|
||||
String toString() { return StringFromAnonFields(this); }
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
template<typename _hx_T0, typename _hx_T1, typename _hx_T2>
|
||||
class AnonStruct3_obj : public hx::Object
|
||||
{
|
||||
public:
|
||||
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdDynamic };
|
||||
|
||||
String name0; _hx_T0 t0;
|
||||
String name1; _hx_T1 t1;
|
||||
String name2; _hx_T2 t2;
|
||||
|
||||
inline static hx::Object *Create(const String &inName0, _hx_T0 inT0,
|
||||
const String &inName1, _hx_T1 inT1,
|
||||
const String &inName2, _hx_T2 inT2)
|
||||
{
|
||||
AnonStruct3_obj *result = new AnonStruct3_obj;
|
||||
result->name0 = inName0; result->t0 = inT0;
|
||||
if (hx::ContainsPointers<_hx_T0>()) {
|
||||
HX_OBJ_WB_GET(result, hx::PointerOf(inT0));
|
||||
}
|
||||
result->name1 = inName1; result->t1 = inT1;
|
||||
if (hx::ContainsPointers<_hx_T1>()) {
|
||||
HX_OBJ_WB_GET(result, hx::PointerOf(inT1));
|
||||
}
|
||||
result->name2 = inName2; result->t2 = inT2;
|
||||
if (hx::ContainsPointers<_hx_T2>()) {
|
||||
HX_OBJ_WB_GET(result, hx::PointerOf(inT2));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
hx::Val __Field(const String &inField, hx::PropertyAccess)
|
||||
{
|
||||
if (inField.__s==name0.__s) return t0;
|
||||
if (inField.__s==name1.__s) return t1;
|
||||
if (inField.__s==name2.__s) return t2;
|
||||
#ifdef HX_SMART_STRINGS
|
||||
if (!inField.isAsciiEncodedQ())
|
||||
return null();
|
||||
#endif
|
||||
if (HX_QSTR_EQ_AE(inField,name0)) return t0;
|
||||
if (HX_QSTR_EQ_AE(inField,name1)) return t1;
|
||||
if (HX_QSTR_EQ_AE(inField,name2)) return t2;
|
||||
return null();
|
||||
}
|
||||
hx::Val __SetField(const String &inField,const hx::Val &inValue, hx::PropertyAccess inCallProp)
|
||||
{
|
||||
if (inField.__s==name0.__s) {
|
||||
t0 = inValue.Cast< _hx_T0 >();
|
||||
if (hx::ContainsPointers<_hx_T0>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t0));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (inField.__s==name1.__s) {
|
||||
t1 = inValue.Cast< _hx_T1 >();
|
||||
if (hx::ContainsPointers<_hx_T1>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t1));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (inField.__s==name2.__s) {
|
||||
t2 = inValue.Cast< _hx_T2 >();
|
||||
if (hx::ContainsPointers<_hx_T2>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t2));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
|
||||
|
||||
if (HX_QSTR_EQ(inField,name0)) {
|
||||
t0 = inValue.Cast< _hx_T0 >();
|
||||
if (hx::ContainsPointers<_hx_T0>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t0));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (HX_QSTR_EQ(inField,name1)) {
|
||||
t1 = inValue.Cast< _hx_T1 >();
|
||||
if (hx::ContainsPointers<_hx_T1>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t1));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (HX_QSTR_EQ(inField,name2)) {
|
||||
t2 = inValue.Cast< _hx_T2 >();
|
||||
if (hx::ContainsPointers<_hx_T2>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t2));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
hx::Throw(HX_CSTRING("Missing field ") + inField);
|
||||
return inValue;
|
||||
}
|
||||
|
||||
void __Mark(hx::MarkContext *__inCtx)
|
||||
{
|
||||
HX_MARK_MEMBER(t0);
|
||||
HX_MARK_MEMBER(t1);
|
||||
HX_MARK_MEMBER(t2);
|
||||
}
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
void __Visit(hx::VisitContext *__inCtx)
|
||||
{
|
||||
HX_VISIT_MEMBER(t0);
|
||||
HX_VISIT_MEMBER(t1);
|
||||
HX_VISIT_MEMBER(t2);
|
||||
}
|
||||
#endif
|
||||
|
||||
void __GetFields(Array<String> &outFields)
|
||||
{
|
||||
outFields->push(name0);
|
||||
outFields->push(name1);
|
||||
outFields->push(name2);
|
||||
}
|
||||
|
||||
String toString() { return StringFromAnonFields(this); }
|
||||
};
|
||||
|
||||
|
||||
template<typename _hx_T0, typename _hx_T1, typename _hx_T2, typename _hx_T3>
|
||||
class AnonStruct4_obj : public hx::Object
|
||||
{
|
||||
public:
|
||||
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdDynamic };
|
||||
|
||||
String name0; _hx_T0 t0;
|
||||
String name1; _hx_T1 t1;
|
||||
String name2; _hx_T2 t2;
|
||||
String name3; _hx_T3 t3;
|
||||
|
||||
inline static hx::Object *Create(const String &inName0, _hx_T0 inT0,
|
||||
const String &inName1, _hx_T1 inT1,
|
||||
const String &inName2, _hx_T2 inT2,
|
||||
const String &inName3, _hx_T3 inT3
|
||||
)
|
||||
{
|
||||
AnonStruct4_obj *result = new AnonStruct4_obj;
|
||||
result->name0 = inName0; result->t0 = inT0;
|
||||
if (hx::ContainsPointers<_hx_T0>()) {
|
||||
HX_OBJ_WB_GET(result, hx::PointerOf(inT0));
|
||||
}
|
||||
result->name1 = inName1; result->t1 = inT1;
|
||||
if (hx::ContainsPointers<_hx_T1>()) {
|
||||
HX_OBJ_WB_GET(result, hx::PointerOf(inT1));
|
||||
}
|
||||
result->name2 = inName2; result->t2 = inT2;
|
||||
if (hx::ContainsPointers<_hx_T2>()) {
|
||||
HX_OBJ_WB_GET(result, hx::PointerOf(inT2));
|
||||
}
|
||||
result->name3 = inName3; result->t3 = inT3;
|
||||
if (hx::ContainsPointers<_hx_T3>()) {
|
||||
HX_OBJ_WB_GET(result, hx::PointerOf(inT3));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
hx::Val __Field(const String &inField, hx::PropertyAccess)
|
||||
{
|
||||
if (inField.__s==name0.__s) return t0;
|
||||
if (inField.__s==name1.__s) return t1;
|
||||
if (inField.__s==name2.__s) return t2;
|
||||
if (inField.__s==name3.__s) return t3;
|
||||
#ifdef HX_SMART_STRINGS
|
||||
if (!inField.isAsciiEncodedQ())
|
||||
return null();
|
||||
#endif
|
||||
if (HX_QSTR_EQ_AE(inField,name0)) return t0;
|
||||
if (HX_QSTR_EQ_AE(inField,name1)) return t1;
|
||||
if (HX_QSTR_EQ_AE(inField,name2)) return t2;
|
||||
if (HX_QSTR_EQ_AE(inField,name3)) return t3;
|
||||
return null();
|
||||
}
|
||||
hx::Val __SetField(const String &inField,const hx::Val &inValue, hx::PropertyAccess inCallProp)
|
||||
{
|
||||
if (inField.__s==name0.__s) {
|
||||
t0 = inValue.Cast< _hx_T0 >();
|
||||
if (hx::ContainsPointers<_hx_T0>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t0));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (inField.__s==name1.__s) {
|
||||
t1 = inValue.Cast< _hx_T1 >();
|
||||
if (hx::ContainsPointers<_hx_T1>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t1));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (inField.__s==name2.__s) {
|
||||
t2 = inValue.Cast< _hx_T2 >();
|
||||
if (hx::ContainsPointers<_hx_T2>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t2));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (inField.__s==name3.__s) {
|
||||
t3 = inValue.Cast< _hx_T3 >();
|
||||
if (hx::ContainsPointers<_hx_T3>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t3));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
|
||||
|
||||
|
||||
if (HX_QSTR_EQ(inField,name0)) {
|
||||
t0 = inValue.Cast< _hx_T0 >();
|
||||
if (hx::ContainsPointers<_hx_T0>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t0));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (HX_QSTR_EQ(inField,name1)) {
|
||||
t1 = inValue.Cast< _hx_T1 >();
|
||||
if (hx::ContainsPointers<_hx_T1>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t1));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (HX_QSTR_EQ(inField,name2)) {
|
||||
t2 = inValue.Cast< _hx_T2 >();
|
||||
if (hx::ContainsPointers<_hx_T2>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t2));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (HX_QSTR_EQ(inField,name3)) {
|
||||
t3 = inValue.Cast< _hx_T3 >();
|
||||
if (hx::ContainsPointers<_hx_T3>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t3));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
hx::Throw(HX_CSTRING("Missing field ") + inField);
|
||||
return inValue;
|
||||
}
|
||||
|
||||
void __Mark(hx::MarkContext *__inCtx)
|
||||
{
|
||||
HX_MARK_MEMBER(t0);
|
||||
HX_MARK_MEMBER(t1);
|
||||
HX_MARK_MEMBER(t2);
|
||||
HX_MARK_MEMBER(t3);
|
||||
}
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
void __Visit(hx::VisitContext *__inCtx)
|
||||
{
|
||||
HX_VISIT_MEMBER(t0);
|
||||
HX_VISIT_MEMBER(t1);
|
||||
HX_VISIT_MEMBER(t2);
|
||||
HX_VISIT_MEMBER(t3);
|
||||
}
|
||||
#endif
|
||||
|
||||
void __GetFields(Array<String> &outFields)
|
||||
{
|
||||
outFields->push(name0);
|
||||
outFields->push(name1);
|
||||
outFields->push(name2);
|
||||
outFields->push(name3);
|
||||
}
|
||||
|
||||
String toString() { return StringFromAnonFields(this); }
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename _hx_T0, typename _hx_T1, typename _hx_T2, typename _hx_T3, typename _hx_T4>
|
||||
class AnonStruct5_obj : public hx::Object
|
||||
{
|
||||
public:
|
||||
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdDynamic };
|
||||
|
||||
String name0; _hx_T0 t0;
|
||||
String name1; _hx_T1 t1;
|
||||
String name2; _hx_T2 t2;
|
||||
String name3; _hx_T3 t3;
|
||||
String name4; _hx_T4 t4;
|
||||
|
||||
inline static hx::Object *Create(const String &inName0, _hx_T0 inT0,
|
||||
const String &inName1, _hx_T1 inT1,
|
||||
const String &inName2, _hx_T2 inT2,
|
||||
const String &inName3, _hx_T3 inT3,
|
||||
const String &inName4, _hx_T4 inT4
|
||||
)
|
||||
{
|
||||
AnonStruct5_obj *result = new AnonStruct5_obj;
|
||||
result->name0 = inName0; result->t0 = inT0;
|
||||
if (hx::ContainsPointers<_hx_T0>()) {
|
||||
HX_OBJ_WB_GET(result, hx::PointerOf(inT0));
|
||||
}
|
||||
result->name1 = inName1; result->t1 = inT1;
|
||||
if (hx::ContainsPointers<_hx_T1>()) {
|
||||
HX_OBJ_WB_GET(result, hx::PointerOf(inT1));
|
||||
}
|
||||
result->name2 = inName2; result->t2 = inT2;
|
||||
if (hx::ContainsPointers<_hx_T2>()) {
|
||||
HX_OBJ_WB_GET(result, hx::PointerOf(inT2));
|
||||
}
|
||||
result->name3 = inName3; result->t3 = inT3;
|
||||
if (hx::ContainsPointers<_hx_T3>()) {
|
||||
HX_OBJ_WB_GET(result, hx::PointerOf(inT3));
|
||||
}
|
||||
result->name4 = inName4; result->t4 = inT4;
|
||||
if (hx::ContainsPointers<_hx_T4>()) {
|
||||
HX_OBJ_WB_GET(result, hx::PointerOf(inT4));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
hx::Val __Field(const String &inField, hx::PropertyAccess)
|
||||
{
|
||||
if (inField.__s==name0.__s) return t0;
|
||||
if (inField.__s==name1.__s) return t1;
|
||||
if (inField.__s==name2.__s) return t2;
|
||||
if (inField.__s==name3.__s) return t3;
|
||||
if (inField.__s==name4.__s) return t4;
|
||||
#ifdef HX_SMART_STRINGS
|
||||
if (!inField.isAsciiEncodedQ())
|
||||
return null();
|
||||
#endif
|
||||
if (HX_QSTR_EQ_AE(inField,name0)) return t0;
|
||||
if (HX_QSTR_EQ_AE(inField,name1)) return t1;
|
||||
if (HX_QSTR_EQ_AE(inField,name2)) return t2;
|
||||
if (HX_QSTR_EQ_AE(inField,name3)) return t3;
|
||||
if (HX_QSTR_EQ_AE(inField,name4)) return t4;
|
||||
return null();
|
||||
}
|
||||
hx::Val __SetField(const String &inField,const hx::Val &inValue, hx::PropertyAccess inCallProp)
|
||||
{
|
||||
if (inField.__s==name0.__s) {
|
||||
t0 = inValue.Cast< _hx_T0 >();
|
||||
if (hx::ContainsPointers<_hx_T0>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t0));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (inField.__s==name1.__s) {
|
||||
t1 = inValue.Cast< _hx_T1 >();
|
||||
if (hx::ContainsPointers<_hx_T1>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t1));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (inField.__s==name2.__s) {
|
||||
t2 = inValue.Cast< _hx_T2 >();
|
||||
if (hx::ContainsPointers<_hx_T2>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t2));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (inField.__s==name3.__s) {
|
||||
t3 = inValue.Cast< _hx_T3 >();
|
||||
if (hx::ContainsPointers<_hx_T3>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t3));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (inField.__s==name4.__s) {
|
||||
t4 = inValue.Cast< _hx_T4 >();
|
||||
if (hx::ContainsPointers<_hx_T4>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t4));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
if (HX_QSTR_EQ(inField,name0)) {
|
||||
t0 = inValue.Cast< _hx_T0 >();
|
||||
if (hx::ContainsPointers<_hx_T0>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t0));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (HX_QSTR_EQ(inField,name1)) {
|
||||
t1 = inValue.Cast< _hx_T1 >();
|
||||
if (hx::ContainsPointers<_hx_T1>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t1));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (HX_QSTR_EQ(inField,name2)) {
|
||||
t2 = inValue.Cast< _hx_T2 >();
|
||||
if (hx::ContainsPointers<_hx_T2>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t2));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (HX_QSTR_EQ(inField,name3)) {
|
||||
t3 = inValue.Cast< _hx_T3 >();
|
||||
if (hx::ContainsPointers<_hx_T3>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t3));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
if (HX_QSTR_EQ(inField,name4)) {
|
||||
t4 = inValue.Cast< _hx_T4 >();
|
||||
if (hx::ContainsPointers<_hx_T4>()) {
|
||||
HX_OBJ_WB_GET(this, hx::PointerOf(t4));
|
||||
}
|
||||
return inValue;
|
||||
}
|
||||
hx::Throw(HX_CSTRING("Missing field ") + inField);
|
||||
return inValue;
|
||||
}
|
||||
|
||||
void __Mark(hx::MarkContext *__inCtx)
|
||||
{
|
||||
HX_MARK_MEMBER(t0);
|
||||
HX_MARK_MEMBER(t1);
|
||||
HX_MARK_MEMBER(t2);
|
||||
HX_MARK_MEMBER(t3);
|
||||
HX_MARK_MEMBER(t4);
|
||||
}
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
void __Visit(hx::VisitContext *__inCtx)
|
||||
{
|
||||
HX_VISIT_MEMBER(t0);
|
||||
HX_VISIT_MEMBER(t1);
|
||||
HX_VISIT_MEMBER(t2);
|
||||
HX_VISIT_MEMBER(t3);
|
||||
HX_VISIT_MEMBER(t4);
|
||||
}
|
||||
#endif
|
||||
|
||||
void __GetFields(Array<String> &outFields)
|
||||
{
|
||||
outFields->push(name0);
|
||||
outFields->push(name1);
|
||||
outFields->push(name2);
|
||||
outFields->push(name3);
|
||||
outFields->push(name4);
|
||||
}
|
||||
|
||||
String toString() { return StringFromAnonFields(this); }
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
bool __hxcpp_anon_remove(Dynamic inObj,::String inKey);
|
||||
|
||||
#endif
|
||||
15
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Boot.h
Normal file
15
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Boot.h
Normal file
@ -0,0 +1,15 @@
|
||||
#ifndef HX_BOOT_H
|
||||
#define HX_BOOT_H
|
||||
|
||||
// Properly construct all the classes defined in the haxe code
|
||||
void __boot_all();
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
// Initializer the hxcpp runtime system
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void Boot();
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
469
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFI.h
Normal file
469
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFI.h
Normal file
@ -0,0 +1,469 @@
|
||||
#ifndef HX_CFFI_H
|
||||
#define HX_CFFI_H
|
||||
|
||||
// 410 - adds gc_try_unblocking
|
||||
#define HX_CFFI_API_VERSION 410
|
||||
|
||||
#ifdef HXCPP_JS_PRIME
|
||||
#include <emscripten/bind.h>
|
||||
using namespace emscripten;
|
||||
|
||||
typedef struct emscripten::val value;
|
||||
typedef struct _vkind *vkind;
|
||||
typedef struct _buffer *buffer;
|
||||
#define HAVE_NEKO_TYPES 1
|
||||
#endif
|
||||
|
||||
#include "OS.h"
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#if defined(BLACKBERRY)
|
||||
using namespace std;
|
||||
#endif
|
||||
// --- Register functions (primitives) ----
|
||||
|
||||
#ifdef STATIC_LINK
|
||||
|
||||
#define DEFINE_PRIM_MULT(func) \
|
||||
int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func)); \
|
||||
|
||||
#define DEFINE_PRIM(func,nargs) \
|
||||
int __reg_##func = hx_register_prim(#func "__" #nargs,(void *)(&func)); \
|
||||
|
||||
|
||||
#define DEFINE_PRIM_MULT_NATIVE(func,ext) \
|
||||
int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func)) + \
|
||||
hx_register_prim(#func "__" #ext,(void *)(&func##_##ext)) ;
|
||||
|
||||
#define DEFINE_PRIM_NATIVE(func,nargs,ext) \
|
||||
int __reg_##func = hx_register_prim(#func "__" #nargs,(void *)(&func)) + \
|
||||
hx_register_prim(#func "__" #ext,(void *)(&func##_##ext)) ;
|
||||
|
||||
|
||||
#define DEFINE_LIB_PRIM_MULT(lib,func) \
|
||||
int __reg_##func = hx_register_prim(lib "_" #func "__MULT",(void *)(&func)); \
|
||||
|
||||
#define DEFINE_LIB_PRIM(lib,func,nargs) \
|
||||
int __reg_##func = hx_register_prim(lib "_" #func "__" #nargs,(void *)(&func)); \
|
||||
|
||||
|
||||
#elif defined(HXCPP_JS_PRIME)
|
||||
|
||||
//#define DEFINE_PRIM_MULT(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
|
||||
//TODO
|
||||
#define DEFINE_PRIM_MULT(func)
|
||||
|
||||
#define DEFINE_PRIM(func,nargs) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
|
||||
|
||||
|
||||
#else
|
||||
|
||||
|
||||
#define DEFINE_PRIM_MULT(func) extern "C" { \
|
||||
EXPORT void *func##__MULT() { return (void*)(&func); } \
|
||||
}
|
||||
|
||||
|
||||
#define DEFINE_PRIM(func,nargs) extern "C" { \
|
||||
EXPORT void *func##__##nargs() { return (void*)(&func); } \
|
||||
}
|
||||
|
||||
|
||||
#define DEFINE_PRIM_MULT_NATIVE(func,ext) extern "C" { \
|
||||
EXPORT void *func##__MULT() { return (void*)(&func); } \
|
||||
EXPORT void *func##__##ext() { return (void*)(&func##_##ext); } \
|
||||
}
|
||||
|
||||
|
||||
#define DEFINE_PRIM_NATIVE(func,nargs,ext) extern "C" { \
|
||||
EXPORT void *func##__##nargs() { return (void*)(&func); } \
|
||||
EXPORT void *func##__##ext() { return (void*)(&func##_##ext); } \
|
||||
}
|
||||
|
||||
|
||||
#define DEFINE_LIB_PRIM_MULT(lib,func) extern "C" { \
|
||||
EXPORT void *func##__MULT() { return (void*)(&func); } \
|
||||
}
|
||||
|
||||
|
||||
#define DEFINE_LIB_PRIM(lib,func,nargs) extern "C" { \
|
||||
EXPORT void *func##__##nargs() { return (void*)(&func); } \
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif // !STATIC_LINK
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#define DEFFUNC_0(ret,name) DEFFUNC(name,ret, (), ())
|
||||
#define DEFFUNC_1(ret,name,t1) DEFFUNC(name,ret, (t1 a1), (a1))
|
||||
#define DEFFUNC_2(ret,name,t1,t2) DEFFUNC(name,ret, (t1 a1, t2 a2), (a1,a2))
|
||||
#define DEFFUNC_3(ret,name,t1,t2,t3) DEFFUNC(name,ret, (t1 a1, t2 a2, t3 a3), (a1,a2,a3))
|
||||
#define DEFFUNC_4(ret,name,t1,t2,t3,t4) DEFFUNC(name,ret, (t1 a1, t2 a2, t3 a3, t4 a4), (a1,a2,a3,a4))
|
||||
#define DEFFUNC_5(ret,name,t1,t2,t3,t4,t5) DEFFUNC(name,ret, (t1 a1, t2 a2, t3 a3, t4 a4,t5 a5), (a1,a2,a3,a4,a5))
|
||||
|
||||
|
||||
enum hxValueType
|
||||
{
|
||||
valtUnknown = -1,
|
||||
valtInt = 0xff,
|
||||
valtNull = 0,
|
||||
valtFloat = 1,
|
||||
valtBool = 2,
|
||||
valtString = 3,
|
||||
valtObject = 4,
|
||||
valtArray = 5,
|
||||
valtFunction = 6,
|
||||
valtEnum,
|
||||
valtClass,
|
||||
valtRoot = 0xff,
|
||||
valtAbstractBase = 0x100,
|
||||
};
|
||||
|
||||
namespace hx
|
||||
{
|
||||
enum StringEncoding
|
||||
{
|
||||
StringAscii,
|
||||
StringUtf8,
|
||||
StringUtf16
|
||||
};
|
||||
}
|
||||
|
||||
// val_fun_nargs may return a special value
|
||||
enum { faNotFunction = -2, faVarArgs=-1, faArgs0=0 /* ... */ };
|
||||
|
||||
typedef int field;
|
||||
|
||||
|
||||
|
||||
#ifdef IMPLEMENT_API
|
||||
#include "CFFILoader.h"
|
||||
#endif
|
||||
|
||||
|
||||
#if !defined(HAVE_NEKO_TYPES)
|
||||
#ifdef HXCPP_NATIVE_CFFI_VALUE
|
||||
namespace hx { class Object; }
|
||||
typedef hx::Object _value;
|
||||
#else
|
||||
struct _value;
|
||||
#endif
|
||||
typedef _value *value;
|
||||
typedef struct _vkind *vkind;
|
||||
typedef struct _buffer *buffer;
|
||||
#endif
|
||||
|
||||
typedef buffer cffiByteBuffer;
|
||||
|
||||
typedef struct _gcroot *gcroot;
|
||||
|
||||
typedef void (*hxFinalizer)(value v);
|
||||
typedef void (*hxPtrFinalizer)(void *v);
|
||||
|
||||
typedef void (__hx_field_iter)(value v,field f,void *);
|
||||
|
||||
#define hx_failure(msg) hx_fail(msg,__FILE__,__LINE__)
|
||||
|
||||
#ifndef IGNORE_CFFI_API_H
|
||||
|
||||
|
||||
#ifndef IMPLEMENT_API
|
||||
|
||||
#if defined(STATIC_LINK) || defined(HXCPP_JS_PRIME)
|
||||
|
||||
#define DEFFUNC(name,ret,def_args,call_args) \
|
||||
extern "C" ret name def_args;
|
||||
|
||||
|
||||
#else
|
||||
|
||||
#define DEFFUNC(name,ret,def_args,call_args) \
|
||||
typedef ret (*FUNC_##name) def_args; \
|
||||
extern FUNC_##name name;
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#include "CFFIAPI.h"
|
||||
|
||||
|
||||
#ifdef WANT_DYNALLOC_ALLOC_BYTES
|
||||
void *DynAlloc::allocBytes(size_t n)
|
||||
{
|
||||
return hx_alloc((int)n);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#define DEFINE_KIND(name) extern "C" { vkind name = 0; }
|
||||
|
||||
#ifdef STATIC_LINK
|
||||
# define DEFINE_ENTRY_POINT(name)
|
||||
#else
|
||||
# define DEFINE_ENTRY_POINT(name) extern "C" { void name(); EXPORT void *__neko_entry_point() { return (void *)&name; } }
|
||||
#endif
|
||||
|
||||
#ifdef HEADER_IMPORTS
|
||||
# define H_EXTERN IMPORT
|
||||
#else
|
||||
# define H_EXTERN EXPORT
|
||||
#endif
|
||||
|
||||
#define DECLARE_PRIM(func,nargs) extern "C" { H_EXTERN void *func##__##nargs(); }
|
||||
#define DECLARE_KIND(name) extern "C" { H_EXTERN extern vkind name; }
|
||||
|
||||
|
||||
|
||||
// --- Helpers ----------------------------------------------------------------
|
||||
|
||||
// Check type...
|
||||
inline bool val_is_null(value inVal) { return val_type(inVal)==valtNull; }
|
||||
inline bool val_is_int(value inVal) { return val_type(inVal)==valtInt; }
|
||||
inline bool val_is_bool(value inVal) { return val_type(inVal)==valtBool; }
|
||||
inline bool val_is_float(value inVal) { return val_type(inVal)==valtFloat; }
|
||||
inline bool val_is_string(value inVal) { return val_type(inVal)==valtString; }
|
||||
inline bool val_is_function(value inVal) { return val_type(inVal)==valtFunction; }
|
||||
inline bool val_is_array(value inVal) { return val_type(inVal)==valtArray; }
|
||||
inline bool val_is_abstract(value inVal) { return val_type(inVal)>=valtAbstractBase; }
|
||||
inline bool val_is_kind(value inVal,vkind inKind) { return val_to_kind(inVal,inKind)!=0; }
|
||||
|
||||
inline bool val_is_number(value inVal)
|
||||
{
|
||||
int t = val_type(inVal);
|
||||
return t==valtInt || t==valtFloat;
|
||||
}
|
||||
inline bool val_is_object(value inVal)
|
||||
{
|
||||
int t = val_type(inVal);
|
||||
return t==valtObject || t==valtEnum ||t==valtClass;
|
||||
}
|
||||
|
||||
class AutoGCBlocking
|
||||
{
|
||||
public:
|
||||
inline AutoGCBlocking(bool inSoftUnlock=false) :
|
||||
mSoftUnlock(inSoftUnlock), mLocked( gc_try_blocking() ) { }
|
||||
inline ~AutoGCBlocking() { Close(); }
|
||||
inline void Close()
|
||||
{
|
||||
if (mLocked)
|
||||
{
|
||||
if (mSoftUnlock)
|
||||
gc_try_unblocking();
|
||||
else
|
||||
gc_exit_blocking();
|
||||
}
|
||||
mLocked = false;
|
||||
}
|
||||
|
||||
bool mLocked;
|
||||
bool mSoftUnlock;
|
||||
};
|
||||
|
||||
class AutoGCUnblocking
|
||||
{
|
||||
public:
|
||||
AutoGCUnblocking() : mUnlocked( gc_try_unblocking() ) { }
|
||||
~AutoGCUnblocking() { Close(); }
|
||||
void Close() { if (mUnlocked) gc_enter_blocking(); mUnlocked = false; }
|
||||
|
||||
bool mUnlocked;
|
||||
};
|
||||
|
||||
|
||||
class AutoGCRoot
|
||||
{
|
||||
public:
|
||||
AutoGCRoot(value inValue)
|
||||
{
|
||||
mRoot = 0;
|
||||
mPtr = alloc_root();
|
||||
if (mPtr)
|
||||
*mPtr = inValue;
|
||||
else
|
||||
mRoot = create_root(inValue);
|
||||
}
|
||||
|
||||
~AutoGCRoot()
|
||||
{
|
||||
if (mPtr)
|
||||
free_root(mPtr);
|
||||
else if (mRoot)
|
||||
destroy_root(mRoot);
|
||||
}
|
||||
value get()const { return mPtr ? *mPtr : query_root(mRoot); }
|
||||
void set(value inValue)
|
||||
{
|
||||
if (mPtr)
|
||||
*mPtr = inValue;
|
||||
else
|
||||
{
|
||||
if (mRoot) destroy_root(mRoot);
|
||||
mRoot = create_root(inValue);
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
value *mPtr;
|
||||
gcroot mRoot;
|
||||
AutoGCRoot(const AutoGCRoot &);
|
||||
void operator=(const AutoGCRoot &);
|
||||
};
|
||||
|
||||
struct CffiBytes
|
||||
{
|
||||
CffiBytes( unsigned char *inData=0, int inLength=0) : data(inData), length(inLength) {}
|
||||
|
||||
unsigned char *data;
|
||||
int length;
|
||||
};
|
||||
|
||||
inline CffiBytes getByteData(value inValue)
|
||||
{
|
||||
static field bField = 0;
|
||||
static field lengthField = 0;
|
||||
if (bField==0)
|
||||
{
|
||||
bField = val_id("b");
|
||||
lengthField = val_id("length");
|
||||
}
|
||||
|
||||
if (val_is_object(inValue))
|
||||
{
|
||||
value b = val_field(inValue, bField);
|
||||
value len = val_field(inValue, lengthField);
|
||||
if (val_is_string(b) && val_is_int(len))
|
||||
return CffiBytes( (unsigned char *)val_string(b), val_int(len) );
|
||||
if (val_is_buffer(b) && val_is_int(len))
|
||||
return CffiBytes( (unsigned char *)buffer_data(val_to_buffer(b)), val_int(len) );
|
||||
}
|
||||
else if (val_is_buffer(inValue))
|
||||
{
|
||||
value len = val_field(inValue, lengthField);
|
||||
if (val_is_int(len))
|
||||
{
|
||||
buffer b = val_to_buffer(inValue);
|
||||
return CffiBytes( (unsigned char *)buffer_data(b), val_int(len) );
|
||||
}
|
||||
}
|
||||
return CffiBytes();
|
||||
}
|
||||
|
||||
inline bool resizeByteData(value inValue, int inNewLen)
|
||||
{
|
||||
if (!val_is_object(inValue))
|
||||
return false;
|
||||
|
||||
static field bField = 0;
|
||||
static field lengthField = 0;
|
||||
if (bField==0)
|
||||
{
|
||||
bField = val_id("b");
|
||||
lengthField = val_id("length");
|
||||
}
|
||||
value len = val_field(inValue, lengthField);
|
||||
if (!val_is_int(len))
|
||||
return false;
|
||||
int oldLen = val_int(len);
|
||||
value b = val_field(inValue, bField);
|
||||
if (val_is_string(b))
|
||||
{
|
||||
if (inNewLen>oldLen)
|
||||
{
|
||||
value newString = alloc_raw_string(inNewLen);
|
||||
memcpy( (char *)val_string(newString), val_string(b), inNewLen);
|
||||
alloc_field(inValue, bField, newString );
|
||||
}
|
||||
alloc_field(inValue, lengthField, alloc_int(inNewLen) );
|
||||
}
|
||||
else if (val_is_buffer(b))
|
||||
{
|
||||
cffiByteBuffer buf = val_to_buffer(b);
|
||||
buffer_set_size(buf,inNewLen);
|
||||
alloc_field(inValue, lengthField, alloc_int(inNewLen) );
|
||||
}
|
||||
else
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
#define val_null alloc_null()
|
||||
|
||||
#define bfailure(x) val_throw(buffer_to_string(x))
|
||||
|
||||
#define copy_string(str,len) alloc_string_len(str,len)
|
||||
|
||||
|
||||
// The "Check" macros throw an error if assumtion is false
|
||||
#define val_check_kind(v,t) if( !val_is_kind(v,t) ) hx_failure("invalid kind");
|
||||
#define val_check_function(f,n) if( !val_is_function(f) || (val_fun_nargs(f) != (n) && val_fun_nargs(f) != faVarArgs) ) hx_failure("Bad function");
|
||||
#define val_check(v,t) if( !val_is_##t(v) ) hx_failure("type not " #t);
|
||||
|
||||
// The "Get" function will return or force an error
|
||||
inline bool val_get_bool(value inVal) { val_check(inVal,bool); return val_bool(inVal); }
|
||||
inline int val_get_int(value inVal) { val_check(inVal,int); return val_int(inVal); }
|
||||
inline double val_get_double(value inVal) { val_check(inVal,number); return val_number(inVal); }
|
||||
inline const char *val_get_string(value inVal) { val_check(inVal,string); return val_string(inVal); }
|
||||
inline void *val_get_handle(value inVal,vkind inKind)
|
||||
{ val_check_kind(inVal,inKind); return val_to_kind(inVal,inKind); }
|
||||
|
||||
|
||||
inline value alloc_string(const char *inStr)
|
||||
{
|
||||
const char *end = inStr;
|
||||
while(*end) end++;
|
||||
return alloc_string_len(inStr,(int)(end-inStr));
|
||||
}
|
||||
|
||||
inline value alloc_wstring(const wchar_t *inStr)
|
||||
{
|
||||
const wchar_t *end = inStr;
|
||||
while(*end) end++;
|
||||
return alloc_wstring_len(inStr,(int)(end-inStr));
|
||||
}
|
||||
|
||||
inline void hxcpp_unscramble(const unsigned char *bytes, int len, const char *key, unsigned char *dest)
|
||||
{
|
||||
int keyLen = 0;
|
||||
while(key[keyLen])
|
||||
keyLen++;
|
||||
int state = 0;
|
||||
//state = ((state + key[i]) ^ ch) & 0xff);
|
||||
for(int i=0;i<len;i++)
|
||||
{
|
||||
dest[i] = ( (state + key[i%keyLen]) ^ bytes[i] ) & 0xff;
|
||||
state = bytes[i];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//additional glue for easier neko modules compilation
|
||||
#define val_true alloc_bool(true)
|
||||
#define val_false alloc_bool(false)
|
||||
inline void neko_error() { hx_error(); }
|
||||
|
||||
|
||||
// Conservative marking within a buffer is not yet supported.
|
||||
//inline void * alloc(int i) { return hx_alloc(i); }
|
||||
|
||||
// The bytes themselves will be GC'd, but not the pointers contained within.
|
||||
inline void * alloc_private(int i) { return hx_alloc(i); }
|
||||
|
||||
// You should use alloc_buffer_len/buffer_data instead
|
||||
//value alloc_empty_string(int len) { }
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#endif
|
||||
189
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFIAPI.h
Normal file
189
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFIAPI.h
Normal file
@ -0,0 +1,189 @@
|
||||
/*
|
||||
This bit of Macro magic is used to define extern function pointers
|
||||
in ndlls, define stub implementations that link back to the hxcpp dll
|
||||
and glue up the implementation in the hxcpp runtime.
|
||||
*/
|
||||
|
||||
DEFFUNC_1(void,val_throw,value)
|
||||
DEFFUNC_0(void,hx_error)
|
||||
DEFFUNC_3(void,hx_fail,const char *,const char *,int)
|
||||
|
||||
// Determine value type
|
||||
DEFFUNC_1(int,val_type,value)
|
||||
DEFFUNC_1(vkind,val_kind,value)
|
||||
DEFFUNC_2(void *,val_to_kind,value,vkind)
|
||||
// don't check the 'kind' ...
|
||||
DEFFUNC_1(void *,val_data,value)
|
||||
DEFFUNC_1(int,val_fun_nargs,value)
|
||||
|
||||
|
||||
// Extract value type
|
||||
DEFFUNC_1(bool,val_bool,value)
|
||||
DEFFUNC_1(int,val_int,value)
|
||||
DEFFUNC_1(double,val_float,value)
|
||||
DEFFUNC_1(double,val_number,value)
|
||||
|
||||
// Create value type
|
||||
|
||||
DEFFUNC_0(value,alloc_null)
|
||||
DEFFUNC_1(value,alloc_bool,bool)
|
||||
DEFFUNC_1(value,alloc_int,int)
|
||||
DEFFUNC_1(value,alloc_float,double)
|
||||
DEFFUNC_0(value,alloc_empty_object)
|
||||
DEFFUNC_2(value,alloc_abstract,vkind,void *)
|
||||
// Allocates conservative-collected memory
|
||||
DEFFUNC_3(value,create_abstract,vkind,int,hxFinalizer)
|
||||
DEFFUNC_1(void,free_abstract,value)
|
||||
DEFFUNC_1(value,alloc_best_int,int)
|
||||
DEFFUNC_1(value,alloc_int32,int)
|
||||
|
||||
// String access
|
||||
DEFFUNC_1(int,val_strlen,value)
|
||||
DEFFUNC_2(value,alloc_string_len,const char *,int)
|
||||
DEFFUNC_2(value,alloc_wstring_len,const wchar_t *,int)
|
||||
|
||||
DEFFUNC_1(const wchar_t *,val_wstring,value)
|
||||
DEFFUNC_1(const char *,val_string,value)
|
||||
DEFFUNC_1(wchar_t *,val_dup_wstring,value)
|
||||
DEFFUNC_1(char *,val_dup_string,value)
|
||||
DEFFUNC_2(char *,alloc_string_data,const char *,int)
|
||||
|
||||
#ifdef HXCPP_PRIME
|
||||
/*DEFFUNC_2(HxString,alloc_hxs_wchar,const wchar_t *,int)
|
||||
DEFFUNC_2(HxString,alloc_hxs_utf16,const char16_t *,int)
|
||||
DEFFUNC_2(HxString,alloc_hxs_utf8,const char *,int)*/
|
||||
|
||||
DEFFUNC_2(const char *,hxs_utf8,const HxString &,hx::IStringAlloc *)
|
||||
DEFFUNC_2(const wchar_t *,hxs_wchar,const HxString &,hx::IStringAlloc *)
|
||||
DEFFUNC_2(const char16_t *,hxs_utf16,const HxString &,hx::IStringAlloc *)
|
||||
|
||||
DEFFUNC_1(hx::StringEncoding,hxs_encoding,const HxString &)
|
||||
#endif
|
||||
|
||||
|
||||
// Array access - generic
|
||||
DEFFUNC_1(value,alloc_array,int)
|
||||
DEFFUNC_1(int,val_array_size,value)
|
||||
DEFFUNC_2(void,val_array_set_size,value,int)
|
||||
DEFFUNC_2(value,val_array_i,value,int)
|
||||
DEFFUNC_3(void,val_array_set_i,value,int,value)
|
||||
DEFFUNC_2(void,val_array_push,value,value)
|
||||
|
||||
|
||||
// Array access - fast if possible - may return null
|
||||
// Resizing the array may invalidate the pointer
|
||||
DEFFUNC_1(bool *,val_array_bool,value)
|
||||
DEFFUNC_1(int *,val_array_int,value)
|
||||
DEFFUNC_1(double *,val_array_double,value)
|
||||
DEFFUNC_1(float *,val_array_float,value)
|
||||
DEFFUNC_1(value *,val_array_value,value)
|
||||
|
||||
// String Buffer
|
||||
// A 'buffer' is a tool for joining strings together.
|
||||
// The C++ implementation is haxe.io.BytesData
|
||||
// The neko implementation is something else again, and can't be passes as a value, only copied to a string
|
||||
|
||||
// Create a buffer from string of an empty buffer of a given length
|
||||
DEFFUNC_1(buffer,alloc_buffer,const char *)
|
||||
DEFFUNC_1(buffer,alloc_buffer_len,int)
|
||||
|
||||
// Append a string representation of a value to the buffer
|
||||
DEFFUNC_2(void,val_buffer,buffer,value)
|
||||
|
||||
// Append a c-string to a buffer
|
||||
DEFFUNC_2(void,buffer_append,buffer,const char *)
|
||||
|
||||
// Append given number of bytes of a c-string to the buffer
|
||||
DEFFUNC_3(void,buffer_append_sub,buffer,const char *,int)
|
||||
|
||||
// Append given character to string
|
||||
DEFFUNC_2(void,buffer_append_char,buffer,int)
|
||||
|
||||
// Convert buffer back into string value
|
||||
DEFFUNC_1(value,buffer_to_string,buffer)
|
||||
|
||||
|
||||
|
||||
// These routines are for direct access to the c++ BytesData structure
|
||||
// Use getByteData and resizeByteData for more generic access to haxe.io.Bytes
|
||||
|
||||
// This will never return true on a neko host.
|
||||
DEFFUNC_1(bool,val_is_buffer,value)
|
||||
|
||||
// These functions are only valid if val_is_buffer returns true
|
||||
// Currently, cffiByteBuffer is the same struct as buffer, but the usage is quite different
|
||||
DEFFUNC_1(cffiByteBuffer,val_to_buffer,value)
|
||||
|
||||
// Number of byes in the array
|
||||
DEFFUNC_1(int,buffer_size,cffiByteBuffer)
|
||||
|
||||
// Pointer to the byte data - will become invalid if the array is resized
|
||||
DEFFUNC_1(char *,buffer_data,cffiByteBuffer)
|
||||
|
||||
// Convert c++ ByteBuffer back to 'value' - no copy involved
|
||||
DEFFUNC_1(value,buffer_val,cffiByteBuffer)
|
||||
|
||||
// Resize the array - will invalidate the data
|
||||
DEFFUNC_2(void,buffer_set_size,cffiByteBuffer,int)
|
||||
|
||||
// This is used by resizeByteData for manipulating bytes directly on neko
|
||||
DEFFUNC_1(value,alloc_raw_string,int)
|
||||
|
||||
// Call Function
|
||||
DEFFUNC_1(value,val_call0,value)
|
||||
DEFFUNC_2(value,val_call1,value,value)
|
||||
DEFFUNC_3(value,val_call2,value,value,value)
|
||||
DEFFUNC_4(value,val_call3,value,value,value,value)
|
||||
DEFFUNC_3(value,val_callN,value,value *,int)
|
||||
|
||||
// Call the function - catch and print any exceptions
|
||||
DEFFUNC_1(value,val_call0_traceexcept,value)
|
||||
|
||||
// Call object field
|
||||
DEFFUNC_2(value,val_ocall0,value,int)
|
||||
DEFFUNC_3(value,val_ocall1,value,int,value)
|
||||
DEFFUNC_4(value,val_ocall2,value,int,value,value)
|
||||
DEFFUNC_4(value,val_ocallN,value,int,value *,int)
|
||||
|
||||
// Objects access
|
||||
DEFFUNC_1(int,val_id,const char *)
|
||||
DEFFUNC_3(void,alloc_field,value,int,value)
|
||||
DEFFUNC_3(void,alloc_field_numeric,value,int,double)
|
||||
DEFFUNC_2(value,val_field,value,int)
|
||||
DEFFUNC_2(double,val_field_numeric,value,int)
|
||||
|
||||
DEFFUNC_1(value,val_field_name,field)
|
||||
DEFFUNC_3(void,val_iter_fields,value,__hx_field_iter,void *)
|
||||
DEFFUNC_3(void,val_iter_field_vals,value,__hx_field_iter,void *)
|
||||
|
||||
// Abstract types
|
||||
DEFFUNC_0(vkind,alloc_kind)
|
||||
DEFFUNC_2(void,kind_share,vkind *,const char *)
|
||||
|
||||
// Garbage Collection
|
||||
DEFFUNC_1(void *,hx_alloc,int)
|
||||
DEFFUNC_2(void, val_gc,value,hxFinalizer)
|
||||
DEFFUNC_2(void, val_gc_ptr,void *,hxPtrFinalizer)
|
||||
DEFFUNC_0(value *, alloc_root)
|
||||
DEFFUNC_1(void, free_root,value *)
|
||||
DEFFUNC_2(void, gc_change_managed_memory,int,const char *)
|
||||
|
||||
// Only available on cpp target...
|
||||
DEFFUNC_1(void, val_gc_add_root,value *)
|
||||
DEFFUNC_1(void, val_gc_remove_root,value *)
|
||||
// Only available on js target - use AutoGCRoot to assist
|
||||
DEFFUNC_1(gcroot, create_root,value)
|
||||
DEFFUNC_1(value, query_root,gcroot)
|
||||
DEFFUNC_1(void, destroy_root,gcroot)
|
||||
|
||||
DEFFUNC_0(void, gc_enter_blocking)
|
||||
DEFFUNC_0(void, gc_exit_blocking)
|
||||
DEFFUNC_0(bool, gc_try_blocking)
|
||||
DEFFUNC_0(void, gc_safe_point)
|
||||
DEFFUNC_2(void, gc_set_top_of_stack,int *,bool)
|
||||
DEFFUNC_0(bool, gc_try_unblocking)
|
||||
|
||||
// Used for finding functions in static libraries
|
||||
DEFFUNC_2(int, hx_register_prim, const char *, void*)
|
||||
|
||||
|
||||
202
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFIJsPrime.h
Normal file
202
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFIJsPrime.h
Normal file
@ -0,0 +1,202 @@
|
||||
|
||||
extern "C"
|
||||
{
|
||||
|
||||
typedef std::map<std::string,int> IdMap;
|
||||
static IdMap sIdMap;
|
||||
static std::vector<val> sIdKeys;
|
||||
|
||||
int val_id(const char *inName)
|
||||
{
|
||||
IdMap::iterator id = sIdMap.find(inName);
|
||||
if (id==sIdMap.end())
|
||||
{
|
||||
int result = sIdMap.size();
|
||||
sIdMap[inName] = result;
|
||||
sIdKeys.push_back(value(inName));
|
||||
return result;
|
||||
}
|
||||
return id->second;
|
||||
}
|
||||
|
||||
|
||||
double val_field_numeric(value inObject, int inFieldId)
|
||||
{
|
||||
return inObject[sIdKeys[inFieldId]].as<double>();
|
||||
}
|
||||
|
||||
int val_int(value inValue) { return inValue.as<int>(); }
|
||||
bool val_bool(value inValue) { return inValue.as<bool>(); }
|
||||
double val_number(value inValue) { return inValue.as<double>(); }
|
||||
double val_float(value inValue) { return inValue.as<double>(); }
|
||||
|
||||
value alloc_null() { return emscripten::val::null(); }
|
||||
value alloc_int(int inValue) { return value(inValue); }
|
||||
value alloc_best_int(int inValue) { return value(inValue); }
|
||||
value alloc_int32(int inValue) { return value(inValue); }
|
||||
value alloc_bool(bool inValue) { return value(inValue); }
|
||||
value alloc_float(double inValue) { return value(inValue); }
|
||||
|
||||
value val_field(value inObject, int inIndex) { return inObject[sIdKeys[inIndex]]; }
|
||||
void alloc_field(value inObject, int inIndex, value inValue) { inObject.set(sIdKeys[inIndex],inValue); }
|
||||
|
||||
|
||||
|
||||
/*
|
||||
DEFFUNC_1(void,val_throw,value)
|
||||
DEFFUNC_0(void,hx_error)
|
||||
DEFFUNC_3(void,hx_fail,const char *,const char *,int)
|
||||
|
||||
// Determine value type
|
||||
DEFFUNC_1(int,val_type,value)
|
||||
DEFFUNC_1(vkind,val_kind,value)
|
||||
DEFFUNC_2(void *,val_to_kind,value,vkind)
|
||||
// don't check the 'kind' ...
|
||||
DEFFUNC_1(void *,val_data,value)
|
||||
DEFFUNC_1(int,val_fun_nargs,value)
|
||||
|
||||
|
||||
|
||||
// Create value type
|
||||
|
||||
DEFFUNC_0(value,alloc_empty_object)
|
||||
DEFFUNC_2(value,alloc_abstract,vkind,void *)
|
||||
// Allocates conservative-collected memory
|
||||
DEFFUNC_3(value,create_abstract,vkind,int,hxFinalizer)
|
||||
DEFFUNC_1(void,free_abstract,value)
|
||||
|
||||
// String access
|
||||
DEFFUNC_1(int,val_strlen,value)
|
||||
DEFFUNC_1(const wchar_t *,val_wstring,value)
|
||||
DEFFUNC_1(const char *,val_string,value)
|
||||
DEFFUNC_1(wchar_t *,val_dup_wstring,value)
|
||||
DEFFUNC_1(char *,val_dup_string,value)
|
||||
DEFFUNC_2(char *,alloc_string_data,const char *,int)
|
||||
DEFFUNC_2(value,alloc_string_len,const char *,int)
|
||||
DEFFUNC_2(value,alloc_wstring_len,const wchar_t *,int)
|
||||
|
||||
// Array access - generic
|
||||
DEFFUNC_1(value,alloc_array,int)
|
||||
DEFFUNC_1(int,val_array_size,value)
|
||||
DEFFUNC_2(void,val_array_set_size,value,int)
|
||||
DEFFUNC_2(value,val_array_i,value,int)
|
||||
DEFFUNC_3(void,val_array_set_i,value,int,value)
|
||||
DEFFUNC_2(void,val_array_push,value,value)
|
||||
|
||||
|
||||
// Array access - fast if possible - may return null
|
||||
// Resizing the array may invalidate the pointer
|
||||
DEFFUNC_1(bool *,val_array_bool,value)
|
||||
DEFFUNC_1(int *,val_array_int,value)
|
||||
DEFFUNC_1(double *,val_array_double,value)
|
||||
DEFFUNC_1(float *,val_array_float,value)
|
||||
DEFFUNC_1(value *,val_array_value,value)
|
||||
|
||||
// String Buffer
|
||||
// A 'buffer' is a tool for joining strings together.
|
||||
// The C++ implementation is haxe.io.BytesData
|
||||
// The neko implementation is something else again, and can't be passes as a value, only copied to a string
|
||||
|
||||
// Create a buffer from string of an empty buffer of a given length
|
||||
DEFFUNC_1(buffer,alloc_buffer,const char *)
|
||||
DEFFUNC_1(buffer,alloc_buffer_len,int)
|
||||
|
||||
// Append a string representation of a value to the buffer
|
||||
DEFFUNC_2(void,val_buffer,buffer,value)
|
||||
|
||||
// Append a c-string to a buffer
|
||||
DEFFUNC_2(void,buffer_append,buffer,const char *)
|
||||
|
||||
// Append given number of bytes of a c-string to the buffer
|
||||
DEFFUNC_3(void,buffer_append_sub,buffer,const char *,int)
|
||||
|
||||
// Append given character to string
|
||||
DEFFUNC_2(void,buffer_append_char,buffer,int)
|
||||
|
||||
// Convert buffer back into string value
|
||||
DEFFUNC_1(value,buffer_to_string,buffer)
|
||||
|
||||
|
||||
|
||||
// These routines are for direct access to the c++ BytesData structure
|
||||
// Use getByteData and resizeByteData for more generic access to haxe.io.Bytes
|
||||
|
||||
// This will never return true on a neko host.
|
||||
DEFFUNC_1(bool,val_is_buffer,value)
|
||||
|
||||
// These functions are only valid if val_is_buffer returns true
|
||||
// Currently, cffiByteBuffer is the same struct as buffer, but the usage is quite different
|
||||
DEFFUNC_1(cffiByteBuffer,val_to_buffer,value)
|
||||
|
||||
// Number of byes in the array
|
||||
DEFFUNC_1(int,buffer_size,cffiByteBuffer)
|
||||
|
||||
// Pointer to the byte data - will become invalid if the array is resized
|
||||
DEFFUNC_1(char *,buffer_data,cffiByteBuffer)
|
||||
|
||||
// Convert c++ ByteBuffer back to 'value' - no copy involved
|
||||
DEFFUNC_1(value,buffer_val,cffiByteBuffer)
|
||||
|
||||
// Resize the array - will invalidate the data
|
||||
DEFFUNC_2(void,buffer_set_size,cffiByteBuffer,int)
|
||||
|
||||
// This is used by resizeByteData for manipulating bytes directly on neko
|
||||
DEFFUNC_1(value,alloc_raw_string,int)
|
||||
|
||||
// Call Function
|
||||
DEFFUNC_1(value,val_call0,value)
|
||||
DEFFUNC_2(value,val_call1,value,value)
|
||||
DEFFUNC_3(value,val_call2,value,value,value)
|
||||
DEFFUNC_4(value,val_call3,value,value,value,value)
|
||||
DEFFUNC_3(value,val_callN,value,value *,int)
|
||||
|
||||
// Call the function - catch and print any exceptions
|
||||
DEFFUNC_1(value,val_call0_traceexcept,value)
|
||||
|
||||
// Call object field
|
||||
DEFFUNC_2(value,val_ocall0,value,int)
|
||||
DEFFUNC_3(value,val_ocall1,value,int,value)
|
||||
DEFFUNC_4(value,val_ocall2,value,int,value,value)
|
||||
DEFFUNC_4(value,val_ocallN,value,int,value *,int)
|
||||
|
||||
// Objects access
|
||||
DEFFUNC_1(int,val_id,const char *)
|
||||
DEFFUNC_3(void,alloc_field,value,int,value)
|
||||
DEFFUNC_2(value,val_field,value,int)
|
||||
DEFFUNC_2(double,val_field_numeric,value,int)
|
||||
|
||||
DEFFUNC_1(value,val_field_name,field)
|
||||
DEFFUNC_3(void,val_iter_fields,value,__hx_field_iter,void *)
|
||||
DEFFUNC_3(void,val_iter_field_vals,value,__hx_field_iter,void *)
|
||||
|
||||
// Abstract types
|
||||
DEFFUNC_0(vkind,alloc_kind)
|
||||
DEFFUNC_2(void,kind_share,vkind *,const char *)
|
||||
|
||||
// Garbage Collection
|
||||
DEFFUNC_1(void *,hx_alloc,int)
|
||||
DEFFUNC_2(void, val_gc,value,hxFinalizer)
|
||||
DEFFUNC_2(void, val_gc_ptr,void *,hxPtrFinalizer)
|
||||
DEFFUNC_0(value *, alloc_root)
|
||||
DEFFUNC_1(void, free_root,value *)
|
||||
DEFFUNC_2(void, gc_change_managed_memory,int,const char *)
|
||||
|
||||
// Only available on cpp target...
|
||||
DEFFUNC_1(void, val_gc_add_root,value *)
|
||||
DEFFUNC_1(void, val_gc_remove_root,value *)
|
||||
// Only available on js target - use AutoGCRoot to assist
|
||||
DEFFUNC_1(gcroot, create_root,value)
|
||||
DEFFUNC_1(value, query_root,gcroot)
|
||||
DEFFUNC_1(void, destroy_root,gcroot)
|
||||
|
||||
DEFFUNC_0(void, gc_enter_blocking)
|
||||
DEFFUNC_0(void, gc_exit_blocking)
|
||||
DEFFUNC_0(void, gc_safe_point)
|
||||
DEFFUNC_2(void, gc_set_top_of_stack,int *,bool)
|
||||
|
||||
// Used for finding functions in static libraries
|
||||
DEFFUNC_2(int, hx_register_prim, const char *, void*)
|
||||
*/
|
||||
|
||||
|
||||
}
|
||||
330
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFILoader.h
Normal file
330
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFILoader.h
Normal file
@ -0,0 +1,330 @@
|
||||
#ifndef HX_CFFI_LOADER_H
|
||||
#define HX_CFFI_LOADER_H
|
||||
|
||||
/*
|
||||
This file will only be incuded in one cpp file in the ndll library -
|
||||
the one with IMPLEMENT_API #defined.
|
||||
|
||||
The other files will refer to the val_ functions via the "extern" in CFFI.h
|
||||
|
||||
For dynamic linking, a macro (DEFFUNC) implements the "val_..." functions as function pointers,
|
||||
and the cpp code calls these function pointers directly.
|
||||
The pointers starts off as function pointers to bootstrap code, so when they are first called
|
||||
the bootstrap uses the "ResolveProc" to find the correct version of the function for the particular
|
||||
platform, and replaces the function pointer with this value. Subsequent calls then go directly
|
||||
to the correct fucntion.
|
||||
|
||||
The ResolveProc can come from:
|
||||
Explicitly setting - the proc is set when a dll is loaded into the hxcpp exe
|
||||
Via 'GetProcAddress' on the exe - if symbols are needed and the proc has not been set
|
||||
Internal implementation (CFFINekoLoader) - when linking agaist a neko process.
|
||||
- Old code used to find this in NekoApi.dll, but the glue code is now built into each ndll directly.
|
||||
|
||||
For static linking, the functions are resolved at link time.
|
||||
|
||||
For HXCPP_JS_PRIME, these functions are implemented in CFFIJsPrime
|
||||
*/
|
||||
|
||||
#ifdef ANDROID
|
||||
#include <android/log.h>
|
||||
#endif
|
||||
|
||||
#ifdef NEKO_WINDOWS
|
||||
#include <windows.h>
|
||||
#include <stdio.h>
|
||||
// Stoopid windows ...
|
||||
#ifdef RegisterClass
|
||||
#undef RegisterClass
|
||||
#endif
|
||||
#ifdef abs
|
||||
#undef abs
|
||||
#endif
|
||||
|
||||
#else // NOT NEKO_WINDOWS
|
||||
|
||||
#ifdef NEKO_LINUX
|
||||
#define EXT "dso"
|
||||
#define NEKO_EXT "so"
|
||||
//#define __USE_GNU 1
|
||||
|
||||
#elif defined(HX_MACOS)
|
||||
#include <mach-o/dyld.h>
|
||||
#define EXT "dylib"
|
||||
#define NEKO_EXT "dylib"
|
||||
|
||||
#else
|
||||
#if defined(EMSCRIPTEN)
|
||||
#define EXT "ll"
|
||||
#else
|
||||
#define EXT "so"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#include <dlfcn.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <memory.h>
|
||||
|
||||
|
||||
#endif
|
||||
#if defined(BLACKBERRY)
|
||||
using namespace std;
|
||||
#endif
|
||||
typedef void *(*ResolveProc)(const char *inName);
|
||||
static ResolveProc sResolveProc = 0;
|
||||
|
||||
extern "C" {
|
||||
EXPORT void hx_set_loader(ResolveProc inProc)
|
||||
{
|
||||
#ifdef ANDROID
|
||||
__android_log_print(ANDROID_LOG_INFO, "haxe plugin", "Got Load Proc %p", inProc );
|
||||
#endif
|
||||
sResolveProc = inProc;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
#ifdef HXCPP_JS_PRIME // { js prime
|
||||
|
||||
#define DEFFUNC(name,ret,def_args,call_args) \
|
||||
extern "C" ret name def_args;
|
||||
|
||||
#include "CFFIJsPrime.h"
|
||||
|
||||
#elif defined(STATIC_LINK) // js prime } { not js prime, static link
|
||||
|
||||
#define DEFFUNC(name,ret,def_args,call_args) \
|
||||
extern "C" ret name def_args;
|
||||
|
||||
#else // static link } { Dynamic link
|
||||
|
||||
#ifdef NEKO_COMPATIBLE
|
||||
|
||||
#include "CFFINekoLoader.h"
|
||||
|
||||
#endif // NEKO_COMPATIBLE
|
||||
|
||||
|
||||
// This code will get run when the library is compiled against a newer version of hxcpp,
|
||||
// and the application code uses an older version.
|
||||
bool default_val_is_buffer(void *inBuffer)
|
||||
{
|
||||
typedef void *(ValToBufferFunc)(void *);
|
||||
static ValToBufferFunc *valToBuffer = 0;
|
||||
if (!valToBuffer)
|
||||
valToBuffer = (ValToBufferFunc *)sResolveProc("val_to_buffer");
|
||||
|
||||
if (valToBuffer)
|
||||
return valToBuffer(inBuffer)!=0;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
// Neko, old cpp and js_prime are all utf8 based - and go through here
|
||||
#ifdef HXCPP_PRIME
|
||||
struct DynAlloc : public hx::IStringAlloc
|
||||
{
|
||||
#define WANT_DYNALLOC_ALLOC_BYTES
|
||||
void *allocBytes(size_t n);
|
||||
};
|
||||
|
||||
|
||||
HxString default_string_wchar(const wchar_t *src,int len)
|
||||
{
|
||||
hx::strbuf buf;
|
||||
const char *str = cffi::to_utf8(src,len,&buf);
|
||||
return HxString(str,len);
|
||||
}
|
||||
HxString default_string_utf8(const char *str,int len)
|
||||
{
|
||||
return HxString(str,len);
|
||||
}
|
||||
HxString default_string_utf16(const char16_t *src,int len)
|
||||
{
|
||||
hx::strbuf buf;
|
||||
const char *str = cffi::to_utf8(src,len,&buf);
|
||||
return HxString(str,len);
|
||||
}
|
||||
|
||||
const char *default_to_utf8(const HxString &str,hx::IStringAlloc *alloc)
|
||||
{
|
||||
return str.c_str();
|
||||
}
|
||||
const wchar_t *default_to_wchar(const HxString &str,hx::IStringAlloc *alloc)
|
||||
{
|
||||
DynAlloc d;
|
||||
if (!alloc)
|
||||
alloc = &d;
|
||||
return cffi::from_utf8<wchar_t>(str.c_str(),str.size(),alloc);
|
||||
}
|
||||
const char16_t *default_to_utf16(const HxString &str,hx::IStringAlloc *alloc)
|
||||
{
|
||||
DynAlloc d;
|
||||
if (!alloc)
|
||||
alloc = &d;
|
||||
return cffi::from_utf8<char16_t>(str.c_str(),str.size(),alloc);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
hx::StringEncoding default_get_encoding(void *inPtr) { return hx::StringUtf8; }
|
||||
|
||||
void * default_alloc_empty_string(int) { return 0; }
|
||||
|
||||
// Do nothing on earlier versions of hxcpp that do not know what to do
|
||||
void default_gc_change_managed_memory(int,const char *) { }
|
||||
|
||||
void *ResolveDefault(const char *inName)
|
||||
{
|
||||
void *result = sResolveProc(inName);
|
||||
if (result)
|
||||
return result;
|
||||
if (!strcmp(inName,"val_is_buffer"))
|
||||
return (void *)default_val_is_buffer;
|
||||
if (!strcmp(inName,"alloc_empty_string"))
|
||||
return (void *)default_alloc_empty_string;
|
||||
if (!strcmp(inName,"gc_change_managed_memory"))
|
||||
return (void *)default_gc_change_managed_memory;
|
||||
if (!strcmp(inName,"hxs_encoding"))
|
||||
return (void *)default_get_encoding;
|
||||
#ifdef HXCPP_PRIME
|
||||
if (!strcmp(inName,"alloc_hxs_wchar"))
|
||||
return (void *)default_string_wchar;
|
||||
if (!strcmp(inName,"alloc_hxs_utf16"))
|
||||
return (void *)default_string_utf16;
|
||||
if (!strcmp(inName,"alloc_hxs_utf8"))
|
||||
return (void *)default_string_utf8;
|
||||
if (!strcmp(inName,"hxs_utf8"))
|
||||
return (void *)default_to_utf8;
|
||||
if (!strcmp(inName,"hxs_utf16"))
|
||||
return (void *)default_to_utf16;
|
||||
if (!strcmp(inName,"hxs_wchar"))
|
||||
return (void *)default_to_wchar;
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef NEKO_WINDOWS // {
|
||||
|
||||
void *LoadFunc(const char *inName)
|
||||
{
|
||||
#ifndef HX_WINRT
|
||||
static const char *modules[] = { 0, "hxcpp", "hxcpp-debug" };
|
||||
for(int i=0; i<3 && sResolveProc==0; i++)
|
||||
{
|
||||
HMODULE handle = GetModuleHandleA(modules[i]);
|
||||
if (handle)
|
||||
{
|
||||
sResolveProc = (ResolveProc)GetProcAddress(handle,"hx_cffi");
|
||||
if (sResolveProc==0)
|
||||
FreeLibrary(handle);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef NEKO_COMPATIBLE
|
||||
if (sResolveProc==0)
|
||||
{
|
||||
sResolveProc = InitDynamicNekoLoader();
|
||||
}
|
||||
#endif
|
||||
|
||||
if (sResolveProc==0)
|
||||
{
|
||||
fprintf(stderr,"Could not link plugin to process (hxCFFILoader.h %d)\n",__LINE__);
|
||||
exit(1);
|
||||
}
|
||||
return ResolveDefault(inName);
|
||||
}
|
||||
|
||||
#else // windows } { not windows
|
||||
|
||||
|
||||
void *LoadFunc(const char *inName)
|
||||
{
|
||||
#ifndef ANDROID // {
|
||||
if (sResolveProc==0)
|
||||
{
|
||||
sResolveProc = (ResolveProc)dlsym(RTLD_DEFAULT,"hx_cffi");
|
||||
}
|
||||
|
||||
#ifdef NEKO_COMPATIBLE
|
||||
if (sResolveProc==0)
|
||||
{
|
||||
sResolveProc = InitDynamicNekoLoader();
|
||||
}
|
||||
#endif
|
||||
#endif // !Android }
|
||||
|
||||
if (sResolveProc==0)
|
||||
{
|
||||
#ifdef ANDROID
|
||||
__android_log_print(ANDROID_LOG_ERROR, "CFFILoader.h", "Could not API %s", inName);
|
||||
return 0;
|
||||
#else
|
||||
#ifdef NEKO_COMPATIBLE
|
||||
fprintf(stderr,"Could not link plugin to process (CFFILoader.h %d) - with neko\n",__LINE__);
|
||||
#else
|
||||
fprintf(stderr,"Could not link plugin to process (CFFILoader.h %d)\n",__LINE__);
|
||||
#endif
|
||||
exit(1);
|
||||
#endif
|
||||
}
|
||||
return ResolveDefault(inName);
|
||||
}
|
||||
|
||||
#undef EXT
|
||||
|
||||
#endif // not windows }
|
||||
|
||||
|
||||
|
||||
#ifndef ANDROID // not android {
|
||||
|
||||
#define DEFFUNC(name,ret,def_args,call_args) \
|
||||
typedef ret (*FUNC_##name)def_args; \
|
||||
extern FUNC_##name name; \
|
||||
ret IMPL_##name def_args \
|
||||
{ \
|
||||
name = (FUNC_##name)LoadFunc(#name); \
|
||||
if (!name) \
|
||||
{ \
|
||||
fprintf(stderr,"Could not find function:" #name " \n"); \
|
||||
exit(1); \
|
||||
} \
|
||||
return name call_args; \
|
||||
}\
|
||||
FUNC_##name name = IMPL_##name;
|
||||
|
||||
#ifdef NEKO_COMPATIBLE
|
||||
DEFINE_PRIM(neko_init,5)
|
||||
#endif
|
||||
|
||||
#else // not android } { android
|
||||
|
||||
|
||||
#define DEFFUNC(name,ret,def_args,call_args) \
|
||||
typedef ret (*FUNC_##name)def_args; \
|
||||
extern FUNC_##name name; \
|
||||
ret IMPL_##name def_args \
|
||||
{ \
|
||||
name = (FUNC_##name)LoadFunc(#name); \
|
||||
if (!name) \
|
||||
{ \
|
||||
__android_log_print(ANDROID_LOG_ERROR,"CFFILoader", "Could not find function:" #name "\n"); \
|
||||
} \
|
||||
return name call_args; \
|
||||
}\
|
||||
FUNC_##name name = IMPL_##name;
|
||||
|
||||
|
||||
#endif // android }
|
||||
|
||||
#endif // dynamic link }
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
723
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFINekoLoader.h
Normal file
723
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFINekoLoader.h
Normal file
@ -0,0 +1,723 @@
|
||||
#ifndef HX_CFFI_NEKO_LOADER_H
|
||||
#define HX_CFFI_NEKO_LOADER_H
|
||||
|
||||
//-------- NEKO Interface -----------------------------------------------------
|
||||
namespace
|
||||
{
|
||||
|
||||
#include <hx/NekoFunc.h>
|
||||
|
||||
|
||||
void *sNekoDllHandle = 0;
|
||||
|
||||
void *LoadNekoFunc(const char *inName)
|
||||
{
|
||||
#ifdef HX_WINRT
|
||||
return 0;
|
||||
#else
|
||||
static bool tried = false;
|
||||
if (tried && !sNekoDllHandle)
|
||||
return 0;
|
||||
tried = true;
|
||||
|
||||
if (!sNekoDllHandle)
|
||||
{
|
||||
#ifdef HX_WINDOWS
|
||||
sNekoDllHandle = GetModuleHandleA("neko.dll");
|
||||
#else
|
||||
sNekoDllHandle = dlopen("libneko." NEKO_EXT, RTLD_NOW);
|
||||
// The debian package creates libneko.so.0 without libneko.so...
|
||||
// The fedora/openSUSE rpm packages create libneko.so.1...
|
||||
if (!sNekoDllHandle)
|
||||
sNekoDllHandle = dlopen("libneko." NEKO_EXT ".0", RTLD_NOW);
|
||||
if (!sNekoDllHandle)
|
||||
sNekoDllHandle = dlopen("libneko." NEKO_EXT ".1", RTLD_NOW);
|
||||
if (!sNekoDllHandle)
|
||||
sNekoDllHandle = dlopen("libneko." NEKO_EXT ".2", RTLD_NOW);
|
||||
#endif
|
||||
|
||||
if (!sNekoDllHandle)
|
||||
{
|
||||
fprintf(stderr,"Could not link to neko.\n");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#ifdef HX_WINDOWS
|
||||
void *result = (void *)GetProcAddress((HMODULE)sNekoDllHandle,inName);
|
||||
#else
|
||||
void *result = dlsym(sNekoDllHandle,inName);
|
||||
#endif
|
||||
|
||||
//printf(" %s = %p\n", inName, result );
|
||||
return result;
|
||||
#endif // !HX_WINRT
|
||||
}
|
||||
|
||||
|
||||
static int __a_id = 0;
|
||||
static int __s_id = 0;
|
||||
static int b_id = 0;
|
||||
static int length_id = 0;
|
||||
static int push_id = 0;
|
||||
|
||||
neko_value *gNeko2HaxeString = 0;
|
||||
neko_value *gNekoNewArray = 0;
|
||||
neko_value gNekoNull = 0;
|
||||
neko_value gNekoTrue = 0;
|
||||
neko_value gNekoFalse = 0;
|
||||
|
||||
|
||||
namespace
|
||||
{
|
||||
void CheckInitDynamicNekoLoader()
|
||||
{
|
||||
if (!gNekoNull)
|
||||
{
|
||||
printf("Haxe code is missing a call to cpp.Prime.nekoInit().\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
|
||||
|
||||
*/
|
||||
|
||||
void *DynamicNekoLoader(const char *inName);
|
||||
|
||||
typedef neko_value (*alloc_object_func)(neko_value);
|
||||
typedef neko_value (*alloc_string_func)(const char *);
|
||||
typedef neko_value (*alloc_abstract_func)(neko_vkind,void *);
|
||||
typedef neko_value (*val_call1_func)(neko_value,neko_value);
|
||||
typedef neko_value (*val_field_func)(neko_value,int);
|
||||
typedef neko_value (*alloc_float_func)(double);
|
||||
typedef void (*alloc_field_func)(neko_value,int,neko_value);
|
||||
typedef neko_value *(*alloc_root_func)(int);
|
||||
typedef char *(*alloc_private_func)(int);
|
||||
typedef neko_value (*copy_string_func)(const char *,int);
|
||||
typedef int (*val_id_func)(const char *);
|
||||
typedef neko_buffer (*alloc_buffer_func)(const char *);
|
||||
typedef neko_value (*val_buffer_func)(neko_buffer);
|
||||
typedef void (*buffer_append_sub_func)(neko_buffer,const char *,int);
|
||||
typedef void (*fail_func)(neko_value,const char *,int);
|
||||
typedef neko_value (*alloc_array_func)(unsigned int);
|
||||
typedef void (*val_gc_func)(neko_value,void *);
|
||||
typedef void (*val_ocall1_func)(neko_value,int,neko_value);
|
||||
typedef neko_value (*alloc_empty_string_func)(int);
|
||||
|
||||
static alloc_object_func dyn_alloc_object = 0;
|
||||
static alloc_string_func dyn_alloc_string = 0;
|
||||
static alloc_abstract_func dyn_alloc_abstract = 0;
|
||||
static val_call1_func dyn_val_call1 = 0;
|
||||
static val_field_func dyn_val_field = 0;
|
||||
static alloc_field_func dyn_alloc_field = 0;
|
||||
static alloc_float_func dyn_alloc_float = 0;
|
||||
static alloc_root_func dyn_alloc_root = 0;
|
||||
static alloc_private_func dyn_alloc_private = 0;
|
||||
static alloc_private_func dyn_alloc = 0;
|
||||
static copy_string_func dyn_copy_string = 0;
|
||||
static val_id_func dyn_val_id = 0;
|
||||
static alloc_buffer_func dyn_alloc_buffer = 0;
|
||||
static val_buffer_func dyn_val_buffer = 0;
|
||||
static fail_func dyn_fail = 0;
|
||||
static buffer_append_sub_func dyn_buffer_append_sub = 0;
|
||||
static alloc_array_func dyn_alloc_array = 0;
|
||||
static val_gc_func dyn_val_gc = 0;
|
||||
static val_ocall1_func dyn_val_ocall1 = 0;
|
||||
static alloc_empty_string_func dyn_alloc_empty_string = 0;
|
||||
|
||||
|
||||
neko_value api_alloc_string(const char *inString)
|
||||
{
|
||||
CheckInitDynamicNekoLoader();
|
||||
neko_value neko_string = dyn_alloc_string(inString);
|
||||
if (gNeko2HaxeString)
|
||||
return dyn_val_call1(*gNeko2HaxeString,neko_string);
|
||||
return neko_string;
|
||||
}
|
||||
|
||||
|
||||
char *api_alloc_string_data(const char *inString,int inLength)
|
||||
{
|
||||
CheckInitDynamicNekoLoader();
|
||||
char *result = (char *)dyn_alloc_private(inLength+1);
|
||||
memcpy(result,inString,inLength);
|
||||
result[inLength]='\0';
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
neko_value api_alloc_raw_string(int inLength)
|
||||
{
|
||||
CheckInitDynamicNekoLoader();
|
||||
return dyn_alloc_empty_string(inLength);
|
||||
}
|
||||
|
||||
|
||||
#define NEKO_NOT_IMPLEMENTED(func) dyn_fail(api_alloc_string("NOT Implemented:" func),__FILE__,__LINE__)
|
||||
|
||||
void * api_empty() { return 0; }
|
||||
|
||||
bool api_val_bool(neko_value arg1) { return arg1==gNekoTrue; }
|
||||
int api_val_int(neko_value arg1) { return neko_val_int(arg1); }
|
||||
double api_val_float(neko_value arg1) { return *(double *)( ((char *)arg1) + 4 ); }
|
||||
double api_val_number(neko_value arg1) { return neko_val_is_int(arg1) ? neko_val_int(arg1) : api_val_float(arg1); }
|
||||
|
||||
|
||||
neko_value api_alloc_bool(bool arg1) { CheckInitDynamicNekoLoader(); return arg1 ? gNekoTrue : gNekoFalse; }
|
||||
neko_value api_alloc_int(int arg1) { return neko_alloc_int(arg1); }
|
||||
neko_value api_alloc_empty_object()
|
||||
{
|
||||
return dyn_alloc_object(gNekoNull);
|
||||
}
|
||||
|
||||
neko_value api_buffer_to_string(neko_buffer arg1)
|
||||
{
|
||||
neko_value neko_string = dyn_val_buffer(arg1);
|
||||
if (gNeko2HaxeString)
|
||||
return dyn_val_call1(*gNeko2HaxeString,neko_string);
|
||||
return neko_string;
|
||||
}
|
||||
|
||||
|
||||
const char * api_val_string(neko_value arg1)
|
||||
{
|
||||
if (neko_val_is_string(arg1))
|
||||
return neko_val_string(arg1);
|
||||
|
||||
if (neko_val_is_object(arg1))
|
||||
{
|
||||
neko_value s = dyn_val_field(arg1,__s_id);
|
||||
if (neko_val_is_string(s))
|
||||
return neko_val_string(s);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void api_alloc_field_numeric(neko_value arg1,int arg2, double arg3)
|
||||
{
|
||||
dyn_alloc_field(arg1, arg2, dyn_alloc_float(arg3) );
|
||||
}
|
||||
|
||||
double api_val_field_numeric(neko_value arg1,int arg2)
|
||||
{
|
||||
neko_value field = dyn_val_field(arg1, arg2);
|
||||
if (neko_val_is_number(field))
|
||||
return api_val_number(field);
|
||||
if (field==gNekoTrue)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
int api_val_strlen(neko_value arg1)
|
||||
{
|
||||
if (neko_val_is_string(arg1))
|
||||
return neko_val_strlen(arg1);
|
||||
|
||||
if (neko_val_is_object(arg1))
|
||||
{
|
||||
neko_value l = dyn_val_field(arg1,length_id);
|
||||
if (neko_val_is_int(l))
|
||||
return api_val_int(l);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
void api_buffer_set_size(neko_buffer inBuffer,int inLen) {
|
||||
NEKO_NOT_IMPLEMENTED("api_buffer_set_size");
|
||||
}
|
||||
|
||||
|
||||
void api_buffer_append_char(neko_buffer inBuffer,int inChar)
|
||||
{
|
||||
NEKO_NOT_IMPLEMENTED("api_buffer_append_char");
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Byte arrays - use strings
|
||||
neko_buffer api_val_to_buffer(neko_value arg1)
|
||||
{
|
||||
return (neko_buffer)api_val_string(arg1);
|
||||
}
|
||||
bool api_val_is_buffer(neko_value arg1) { return neko_val_is_string(arg1); }
|
||||
int api_buffer_size(neko_buffer inBuffer) { return neko_val_strlen((neko_value)inBuffer); }
|
||||
char * api_buffer_data(neko_buffer inBuffer) { return (char *)api_val_string((neko_value)inBuffer); }
|
||||
|
||||
char * api_val_dup_string(neko_value inVal)
|
||||
{
|
||||
int len = api_val_strlen(inVal);
|
||||
const char *ptr = api_val_string(inVal);
|
||||
char *result = dyn_alloc_private(len+1);
|
||||
memcpy(result,ptr,len);
|
||||
result[len] = '\0';
|
||||
return result;
|
||||
}
|
||||
|
||||
neko_value api_alloc_string_len(const char *inStr,int inLen)
|
||||
{
|
||||
if (gNeko2HaxeString)
|
||||
{
|
||||
if (!inStr)
|
||||
return dyn_val_call1(*gNeko2HaxeString,api_alloc_raw_string(inLen));
|
||||
return dyn_val_call1(*gNeko2HaxeString,dyn_copy_string(inStr,inLen));
|
||||
}
|
||||
if (!inStr)
|
||||
inStr = dyn_alloc_private(inLen);
|
||||
return dyn_copy_string(inStr,inLen);
|
||||
}
|
||||
|
||||
neko_buffer api_alloc_buffer_len(int inLen)
|
||||
{
|
||||
neko_value str=api_alloc_string_len(0,inLen+1);
|
||||
char *s=(char *)api_val_string(str);
|
||||
memset(s,0,inLen+1);
|
||||
return (neko_buffer)str;
|
||||
}
|
||||
|
||||
|
||||
|
||||
neko_value api_alloc_wstring_len(const wchar_t *inStr,int inLen)
|
||||
{
|
||||
int len = 0;
|
||||
const wchar_t *chars = inStr;
|
||||
for(int i=0;i<inLen;i++)
|
||||
{
|
||||
int c = chars[i];
|
||||
if( c <= 0x7F ) len++;
|
||||
else if( c <= 0x7FF ) len+=2;
|
||||
else if( c <= 0xFFFF ) len+=3;
|
||||
else len+= 4;
|
||||
}
|
||||
|
||||
char *result = dyn_alloc_private(len);//+1?
|
||||
unsigned char *data = (unsigned char *) &result[0];
|
||||
for(int i=0;i<inLen;i++)
|
||||
{
|
||||
int c = chars[i];
|
||||
if( c <= 0x7F )
|
||||
*data++ = c;
|
||||
else if( c <= 0x7FF )
|
||||
{
|
||||
*data++ = 0xC0 | (c >> 6);
|
||||
*data++ = 0x80 | (c & 63);
|
||||
}
|
||||
else if( c <= 0xFFFF )
|
||||
{
|
||||
*data++ = 0xE0 | (c >> 12);
|
||||
*data++ = 0x80 | ((c >> 6) & 63);
|
||||
*data++ = 0x80 | (c & 63);
|
||||
}
|
||||
else
|
||||
{
|
||||
*data++ = 0xF0 | (c >> 18);
|
||||
*data++ = 0x80 | ((c >> 12) & 63);
|
||||
*data++ = 0x80 | ((c >> 6) & 63);
|
||||
*data++ = 0x80 | (c & 63);
|
||||
}
|
||||
}
|
||||
//result[len] = 0;
|
||||
|
||||
return api_alloc_string_len(result,len);
|
||||
}
|
||||
|
||||
|
||||
|
||||
const wchar_t *api_val_wstring(neko_value arg1)
|
||||
{
|
||||
int len = api_val_strlen(arg1);
|
||||
|
||||
unsigned char *b = (unsigned char *)api_val_string(arg1);
|
||||
wchar_t *result = (wchar_t *)dyn_alloc_private((len+1)*sizeof(wchar_t));
|
||||
int l = 0;
|
||||
|
||||
for(int i=0;i<len;)
|
||||
{
|
||||
int c = b[i++];
|
||||
if (c==0) break;
|
||||
else if( c < 0x80 )
|
||||
{
|
||||
result[l++] = c;
|
||||
}
|
||||
else if( c < 0xE0 )
|
||||
result[l++] = ( ((c & 0x3F) << 6) | (b[i++] & 0x7F) );
|
||||
else if( c < 0xF0 )
|
||||
{
|
||||
int c2 = b[i++];
|
||||
result[l++] = ( ((c & 0x1F) << 12) | ((c2 & 0x7F) << 6) | ( b[i++] & 0x7F) );
|
||||
}
|
||||
else
|
||||
{
|
||||
int c2 = b[i++];
|
||||
int c3 = b[i++];
|
||||
result[l++] = ( ((c & 0x0F) << 18) | ((c2 & 0x7F) << 12) | ((c3 << 6) & 0x7F) | (b[i++] & 0x7F) );
|
||||
}
|
||||
}
|
||||
result[l] = '\0';
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
wchar_t * api_val_dup_wstring(neko_value inVal)
|
||||
{
|
||||
return (wchar_t *)api_val_wstring(inVal);
|
||||
}
|
||||
|
||||
|
||||
|
||||
int api_val_type(neko_value arg1)
|
||||
{
|
||||
int t=neko_val_type(arg1);
|
||||
|
||||
if (t==VAL_OBJECT)
|
||||
{
|
||||
neko_value __a = dyn_val_field(arg1,__a_id);
|
||||
if (neko_val_is_array(__a))
|
||||
return valtArray;
|
||||
neko_value __s = dyn_val_field(arg1,__s_id);
|
||||
if (neko_val_is_string(__s))
|
||||
return valtString;
|
||||
}
|
||||
if (t<7)
|
||||
return (hxValueType)t;
|
||||
if (t==VAL_ABSTRACT)
|
||||
return valtAbstractBase;
|
||||
|
||||
if (t==VAL_PRIMITIVE || t==VAL_JITFUN)
|
||||
return valtFunction;
|
||||
if (t==VAL_32_BITS || t==VAL_INT)
|
||||
return valtInt;
|
||||
return valtNull;
|
||||
}
|
||||
|
||||
neko_value *api_alloc_root()
|
||||
{
|
||||
return dyn_alloc_root(1);
|
||||
}
|
||||
|
||||
|
||||
void * api_val_to_kind(neko_value arg1,neko_vkind arg2)
|
||||
{
|
||||
neko_vkind k = (neko_vkind)neko_val_kind(arg1);
|
||||
if (k!=arg2)
|
||||
return 0;
|
||||
return neko_val_data(arg1);
|
||||
}
|
||||
|
||||
|
||||
int api_alloc_kind()
|
||||
{
|
||||
static int id = 1;
|
||||
int result = id;
|
||||
id += 4;
|
||||
return result;
|
||||
}
|
||||
neko_value api_alloc_null()
|
||||
{
|
||||
CheckInitDynamicNekoLoader();
|
||||
return gNekoNull;
|
||||
}
|
||||
|
||||
neko_value api_create_abstract(neko_vkind inKind,int inSize,void *inFinalizer)
|
||||
{
|
||||
void *data = dyn_alloc(inSize);
|
||||
neko_value val = dyn_alloc_abstract(inKind, data);
|
||||
dyn_val_gc(val, inFinalizer);
|
||||
return val;
|
||||
}
|
||||
|
||||
void api_free_abstract(neko_value inAbstract)
|
||||
{
|
||||
if (neko_val_is_abstract(inAbstract))
|
||||
{
|
||||
dyn_val_gc(inAbstract,0);
|
||||
neko_val_kind(inAbstract) = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
neko_value api_buffer_val(neko_buffer arg1)
|
||||
{
|
||||
if (neko_val_is_string(arg1))
|
||||
return (neko_value)arg1;
|
||||
|
||||
if (neko_val_is_object(arg1))
|
||||
{
|
||||
neko_value s = dyn_val_field((neko_value)arg1,__s_id);
|
||||
if (neko_val_is_string(s))
|
||||
return (neko_value)(s);
|
||||
}
|
||||
|
||||
|
||||
return api_alloc_null();
|
||||
}
|
||||
|
||||
|
||||
void api_hx_error()
|
||||
{
|
||||
dyn_fail(dyn_alloc_string("An unknown error has occurred."),"",1);
|
||||
}
|
||||
|
||||
void * api_val_data(neko_value arg1) { return neko_val_data(arg1); }
|
||||
|
||||
// Array access - generic
|
||||
int api_val_array_size(neko_value arg1)
|
||||
{
|
||||
if (neko_val_is_array(arg1))
|
||||
return neko_val_array_size(arg1);
|
||||
neko_value l = dyn_val_field(arg1,length_id);
|
||||
return neko_val_int(l);
|
||||
}
|
||||
|
||||
|
||||
neko_value api_val_array_i(neko_value arg1,int arg2)
|
||||
{
|
||||
if (neko_val_is_array(arg1))
|
||||
return neko_val_array_ptr(arg1)[arg2];
|
||||
return neko_val_array_ptr(dyn_val_field(arg1,__a_id))[arg2];
|
||||
}
|
||||
|
||||
void api_val_array_set_i(neko_value arg1,int arg2,neko_value inVal)
|
||||
{
|
||||
if (!neko_val_is_array(arg1))
|
||||
arg1 = dyn_val_field(arg1,__a_id);
|
||||
neko_val_array_ptr(arg1)[arg2] = inVal;
|
||||
}
|
||||
|
||||
void api_val_array_set_size(neko_value arg1,int inLen)
|
||||
{
|
||||
NEKO_NOT_IMPLEMENTED("api_val_array_set_size");
|
||||
}
|
||||
|
||||
void api_val_array_push(neko_value inArray,neko_value inValue)
|
||||
{
|
||||
dyn_val_ocall1(inArray,push_id,inValue);
|
||||
}
|
||||
|
||||
|
||||
neko_value api_alloc_array(int arg1)
|
||||
{
|
||||
if (!gNekoNewArray)
|
||||
return dyn_alloc_array(arg1);
|
||||
return dyn_val_call1(*gNekoNewArray,neko_alloc_int(arg1));
|
||||
}
|
||||
|
||||
|
||||
neko_value * api_val_array_value(neko_value arg1)
|
||||
{
|
||||
if (neko_val_is_array(arg1))
|
||||
return neko_val_array_ptr(arg1);
|
||||
return neko_val_array_ptr(dyn_val_field(arg1,__a_id));
|
||||
}
|
||||
|
||||
neko_value api_val_call0_traceexcept(neko_value arg1)
|
||||
{
|
||||
NEKO_NOT_IMPLEMENTED("api_val_call0_traceexcept");
|
||||
return gNekoNull;
|
||||
}
|
||||
|
||||
|
||||
int api_val_fun_nargs(neko_value arg1)
|
||||
{
|
||||
if (!arg1 || !neko_val_is_function(arg1) )
|
||||
return faNotFunction;
|
||||
return neko_val_fun_nargs(arg1);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void api_val_gc(neko_value obj, void *finalizer)
|
||||
{
|
||||
// Let neko deal with ints or abstracts ...
|
||||
if (neko_val_is_int(obj) || neko_val_is_abstract(obj))
|
||||
{
|
||||
dyn_val_gc(obj,finalizer);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Hack type to abstract for the duration
|
||||
neko_val_type old_tag = neko_val_tag(obj);
|
||||
neko_val_tag(obj) = VAL_ABSTRACT;
|
||||
dyn_val_gc(obj,finalizer);
|
||||
neko_val_tag(obj) = old_tag;
|
||||
}
|
||||
}
|
||||
|
||||
void api_gc_change_managed_memory(int,const char *)
|
||||
{
|
||||
// Nothing to do here
|
||||
}
|
||||
|
||||
bool api_gc_try_blocking() { return false; }
|
||||
bool api_gc_try_unblocking() { return false; }
|
||||
|
||||
#define IMPLEMENT_HERE(x) if (!strcmp(inName,#x)) return (void *)api_##x;
|
||||
#define IGNORE_API(x) if (!strcmp(inName,#x)) return (void *)api_empty;
|
||||
|
||||
|
||||
void *DynamicNekoLoader(const char *inName)
|
||||
{
|
||||
IMPLEMENT_HERE(alloc_kind)
|
||||
IMPLEMENT_HERE(alloc_null)
|
||||
IMPLEMENT_HERE(val_to_kind)
|
||||
if (!strcmp(inName,"hx_fail"))
|
||||
return LoadNekoFunc("_neko_failure");
|
||||
IMPLEMENT_HERE(val_type)
|
||||
IMPLEMENT_HERE(val_bool)
|
||||
IMPLEMENT_HERE(val_int)
|
||||
IMPLEMENT_HERE(val_float)
|
||||
IMPLEMENT_HERE(val_number)
|
||||
IMPLEMENT_HERE(val_field_numeric)
|
||||
IMPLEMENT_HERE(alloc_bool)
|
||||
IMPLEMENT_HERE(alloc_int)
|
||||
IMPLEMENT_HERE(alloc_empty_object)
|
||||
IMPLEMENT_HERE(alloc_root)
|
||||
IMPLEMENT_HERE(val_gc)
|
||||
IMPLEMENT_HERE(gc_try_blocking)
|
||||
IMPLEMENT_HERE(gc_try_unblocking)
|
||||
|
||||
IMPLEMENT_HERE(create_abstract)
|
||||
IMPLEMENT_HERE(free_abstract)
|
||||
|
||||
IGNORE_API(gc_enter_blocking)
|
||||
IGNORE_API(gc_exit_blocking)
|
||||
IGNORE_API(gc_safe_point)
|
||||
IGNORE_API(gc_add_root)
|
||||
IGNORE_API(gc_remove_root)
|
||||
IGNORE_API(gc_set_top_of_stack)
|
||||
IGNORE_API(gc_change_managed_memory)
|
||||
IGNORE_API(create_root)
|
||||
IGNORE_API(query_root)
|
||||
IGNORE_API(destroy_root)
|
||||
IGNORE_API(hx_register_prim)
|
||||
IGNORE_API(val_array_int)
|
||||
IGNORE_API(val_array_double)
|
||||
IGNORE_API(val_array_float)
|
||||
IGNORE_API(val_array_bool)
|
||||
|
||||
if (!strcmp(inName,"hx_alloc"))
|
||||
return LoadNekoFunc("neko_alloc");
|
||||
|
||||
IMPLEMENT_HERE(buffer_to_string)
|
||||
IMPLEMENT_HERE(buffer_val)
|
||||
|
||||
if (!strcmp(inName,"val_iter_field_vals"))
|
||||
return LoadNekoFunc("neko_val_iter_fields");
|
||||
|
||||
IMPLEMENT_HERE(val_strlen)
|
||||
IMPLEMENT_HERE(val_wstring)
|
||||
IMPLEMENT_HERE(val_string)
|
||||
IMPLEMENT_HERE(alloc_string)
|
||||
IMPLEMENT_HERE(alloc_raw_string)
|
||||
IMPLEMENT_HERE(alloc_string_data)
|
||||
IMPLEMENT_HERE(val_dup_wstring)
|
||||
IMPLEMENT_HERE(val_dup_string)
|
||||
IMPLEMENT_HERE(alloc_string_len)
|
||||
IMPLEMENT_HERE(alloc_wstring_len)
|
||||
|
||||
IMPLEMENT_HERE(val_is_buffer)
|
||||
IMPLEMENT_HERE(val_to_buffer)
|
||||
IMPLEMENT_HERE(alloc_buffer_len)
|
||||
IMPLEMENT_HERE(buffer_size)
|
||||
IMPLEMENT_HERE(buffer_set_size)
|
||||
IMPLEMENT_HERE(buffer_append_char)
|
||||
IMPLEMENT_HERE(buffer_data)
|
||||
|
||||
IMPLEMENT_HERE(hx_error)
|
||||
IMPLEMENT_HERE(val_array_i)
|
||||
IMPLEMENT_HERE(val_array_size)
|
||||
IMPLEMENT_HERE(val_data)
|
||||
IMPLEMENT_HERE(val_array_set_i)
|
||||
IMPLEMENT_HERE(val_array_set_size)
|
||||
IMPLEMENT_HERE(val_array_push)
|
||||
IMPLEMENT_HERE(alloc_array)
|
||||
IMPLEMENT_HERE(alloc_field_numeric)
|
||||
IMPLEMENT_HERE(val_array_value)
|
||||
|
||||
IMPLEMENT_HERE(val_fun_nargs)
|
||||
|
||||
IMPLEMENT_HERE(val_call0_traceexcept)
|
||||
|
||||
|
||||
char buffer[100];
|
||||
strcpy(buffer,"neko_");
|
||||
strcat(buffer,inName);
|
||||
void *result = LoadNekoFunc(buffer);
|
||||
if (result)
|
||||
return result;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
ResolveProc InitDynamicNekoLoader()
|
||||
{
|
||||
static bool init = false;
|
||||
if (!init)
|
||||
{
|
||||
dyn_alloc_private = (alloc_private_func)LoadNekoFunc("neko_alloc_private");
|
||||
dyn_alloc = (alloc_private_func)LoadNekoFunc("neko_alloc");
|
||||
dyn_alloc_object = (alloc_object_func)LoadNekoFunc("neko_alloc_object");
|
||||
dyn_alloc_string = (alloc_string_func)LoadNekoFunc("neko_alloc_string");
|
||||
dyn_alloc_abstract = (alloc_abstract_func)LoadNekoFunc("neko_alloc_abstract");
|
||||
dyn_val_call1 = (val_call1_func)LoadNekoFunc("neko_val_call1");
|
||||
dyn_val_field = (val_field_func)LoadNekoFunc("neko_val_field");
|
||||
dyn_alloc_field = (alloc_field_func)LoadNekoFunc("neko_alloc_field");
|
||||
dyn_alloc_float = (alloc_float_func)LoadNekoFunc("neko_alloc_float");
|
||||
dyn_alloc_root = (alloc_root_func)LoadNekoFunc("neko_alloc_root");
|
||||
dyn_copy_string = (copy_string_func)LoadNekoFunc("neko_copy_string");
|
||||
dyn_val_id = (val_id_func)LoadNekoFunc("neko_val_id");
|
||||
dyn_alloc_buffer = (alloc_buffer_func)LoadNekoFunc("neko_alloc_buffer");
|
||||
dyn_val_buffer = (val_buffer_func)LoadNekoFunc("neko_buffer_to_string");
|
||||
dyn_fail = (fail_func)LoadNekoFunc("_neko_failure");
|
||||
dyn_buffer_append_sub = (buffer_append_sub_func)LoadNekoFunc("neko_buffer_append_sub");
|
||||
dyn_alloc_array = (alloc_array_func)LoadNekoFunc("neko_alloc_array");
|
||||
dyn_val_gc = (val_gc_func)LoadNekoFunc("neko_val_gc");
|
||||
dyn_val_ocall1 = (val_ocall1_func)LoadNekoFunc("neko_val_ocall1");
|
||||
dyn_alloc_empty_string = (alloc_empty_string_func)LoadNekoFunc("neko_alloc_empty_string");
|
||||
init = true;
|
||||
}
|
||||
|
||||
if (!dyn_val_id)
|
||||
return 0;
|
||||
|
||||
|
||||
__a_id = dyn_val_id("__a");
|
||||
__s_id = dyn_val_id("__s");
|
||||
b_id = dyn_val_id("b");
|
||||
length_id = dyn_val_id("length");
|
||||
push_id = dyn_val_id("push");
|
||||
|
||||
return DynamicNekoLoader;
|
||||
}
|
||||
|
||||
|
||||
neko_value neko_init(neko_value inNewString,neko_value inNewArray,neko_value inNull, neko_value inTrue, neko_value inFalse)
|
||||
{
|
||||
InitDynamicNekoLoader();
|
||||
|
||||
gNekoNull = inNull;
|
||||
gNekoTrue = inTrue;
|
||||
gNekoFalse = inFalse;
|
||||
|
||||
gNeko2HaxeString = dyn_alloc_root(1);
|
||||
*gNeko2HaxeString = inNewString;
|
||||
gNekoNewArray = dyn_alloc_root(1);
|
||||
*gNekoNewArray = inNewArray;
|
||||
|
||||
return gNekoNull;
|
||||
}
|
||||
|
||||
|
||||
|
||||
} // end anon namespace
|
||||
|
||||
#endif
|
||||
|
||||
1096
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFIPrime.h
Normal file
1096
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFIPrime.h
Normal file
File diff suppressed because it is too large
Load Diff
307
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Class.h
Normal file
307
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Class.h
Normal file
@ -0,0 +1,307 @@
|
||||
#ifndef HX_CLASS_H
|
||||
#define HX_CLASS_H
|
||||
|
||||
|
||||
namespace hx
|
||||
{
|
||||
// --- hxClassOf --------------------------------------------------------------
|
||||
//
|
||||
// Gets the class definition that relates to a specific type.
|
||||
// Most classes have their own class data, but the standard types (non-classes)
|
||||
// use the template traits to get the class
|
||||
|
||||
|
||||
template<typename T>
|
||||
inline hx::Class &ClassOf() { typedef typename T::Obj Obj; return Obj::__SGetClass(); }
|
||||
|
||||
template<>
|
||||
inline hx::Class &ClassOf<int>() { return GetIntClass(); }
|
||||
|
||||
template<>
|
||||
inline hx::Class &ClassOf<double>() { return GetFloatClass(); }
|
||||
|
||||
template<>
|
||||
inline hx::Class &ClassOf<float>() { return GetFloatClass(); }
|
||||
|
||||
template<>
|
||||
inline hx::Class &ClassOf<bool>() { return GetBoolClass(); }
|
||||
|
||||
template<>
|
||||
inline hx::Class &ClassOf<null>() { return GetVoidClass(); }
|
||||
|
||||
template<>
|
||||
inline hx::Class &ClassOf<String>() { return GetStringClass(); }
|
||||
|
||||
template<>
|
||||
inline hx::Class &ClassOf< ::cpp::Int64>() { return GetInt64Class(); }
|
||||
|
||||
|
||||
template<typename T>
|
||||
struct hxBaseType { typedef T type; };
|
||||
template<typename T>
|
||||
struct hxBaseType< hx::ObjectPtr<T> > { typedef T type; };
|
||||
|
||||
template<typename T> inline int ClassSizeOf() { return sizeof( typename hx::hxBaseType<T>::type ); }
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
|
||||
// --- Class_obj --------------------------------------------------------------------
|
||||
//
|
||||
// The Class_obj provides the type information required by the Reflect and type APIs.
|
||||
|
||||
namespace hx
|
||||
{
|
||||
typedef Dynamic (*ConstructEmptyFunc)();
|
||||
typedef Dynamic (*ConstructArgsFunc)(DynamicArray inArgs);
|
||||
typedef Dynamic (*ConstructEnumFunc)(String inName,DynamicArray inArgs);
|
||||
typedef void (*MarkFunc)(hx::MarkContext *__inCtx);
|
||||
typedef bool (*CanCastFunc)(hx::Object *inPtr);
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
typedef void (*VisitFunc)(hx::VisitContext *__inCtx);
|
||||
#endif
|
||||
typedef bool (*GetStaticFieldFunc)(const String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
|
||||
typedef bool (*SetStaticFieldFunc)(const String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
|
||||
}
|
||||
|
||||
inline bool operator!=(hx::ConstructEnumFunc inFunc,const null &inNull) { return inFunc!=0; }
|
||||
|
||||
#ifdef HXCPP_SCRIPTABLE
|
||||
namespace hx
|
||||
{
|
||||
enum FieldStorage
|
||||
{
|
||||
fsUnknown = 0,
|
||||
fsBool,
|
||||
fsInt,
|
||||
fsFloat,
|
||||
fsString,
|
||||
fsByte,
|
||||
fsObject,
|
||||
};
|
||||
struct StorageInfo
|
||||
{
|
||||
FieldStorage type;
|
||||
int offset;
|
||||
String name;
|
||||
};
|
||||
struct StaticInfo
|
||||
{
|
||||
FieldStorage type;
|
||||
void *address;
|
||||
String name;
|
||||
};
|
||||
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
class HXCPP_EXTERN_CLASS_ATTRIBUTES Class_obj : public hx::Object
|
||||
{
|
||||
public:
|
||||
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdClass };
|
||||
|
||||
|
||||
inline void *operator new( size_t inSize )
|
||||
{
|
||||
return hx::InternalCreateConstBuffer(0,(int)inSize);
|
||||
}
|
||||
void operator delete( void *) { }
|
||||
|
||||
|
||||
Class_obj() : mSuper(0) { };
|
||||
Class_obj(const String &inClassName, String inStatics[], String inMembers[],
|
||||
hx::ConstructEmptyFunc inConstructEmpty, hx::ConstructArgsFunc inConstructArgs,
|
||||
hx::Class *inSuperClass, hx::ConstructEnumFunc inConstructEnum,
|
||||
hx::CanCastFunc inCanCast, hx::MarkFunc inMarkFunc
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
, hx::VisitFunc inVisitFunc
|
||||
#endif
|
||||
#ifdef HXCPP_SCRIPTABLE
|
||||
,const hx::StorageInfo *inStorageInfo
|
||||
,const hx::StaticInfo *inStaticInfo
|
||||
#endif
|
||||
);
|
||||
|
||||
String __ToString() const;
|
||||
|
||||
void MarkStatics(hx::MarkContext *__inCtx);
|
||||
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
void VisitStatics(hx::VisitContext *__inCtx);
|
||||
#endif
|
||||
|
||||
static ::Array< ::String > dupFunctions(String inStatics[]);
|
||||
|
||||
// the "Class class"
|
||||
hx::Class __GetClass() const;
|
||||
static hx::Class & __SGetClass();
|
||||
static void __boot();
|
||||
|
||||
hx::Val __Field(const String &inString ,hx::PropertyAccess inCallProp);
|
||||
|
||||
hx::Val __SetField(const String &inString,const hx::Val &inValue ,hx::PropertyAccess inCallProp);
|
||||
|
||||
bool __HasField(const String &inString);
|
||||
|
||||
virtual Dynamic ConstructEmpty();
|
||||
virtual Dynamic ConstructArgs(hx::DynamicArray inArgs);
|
||||
virtual Dynamic ConstructEnum(String inName,hx::DynamicArray inArgs);
|
||||
virtual bool VCanCast(hx::Object *inPtr) { return false; }
|
||||
|
||||
int __GetType() const { return vtObject; }
|
||||
|
||||
virtual bool __IsEnum();
|
||||
|
||||
inline bool CanCast(hx::Object *inPtr) { return mCanCast ? mCanCast(inPtr) : VCanCast(inPtr); }
|
||||
static bool GetNoStaticField(const String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
|
||||
static bool SetNoStaticField(const String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
|
||||
|
||||
void registerScriptable(bool inOverwrite);
|
||||
|
||||
hx::CanCastFunc mCanCast;
|
||||
|
||||
|
||||
|
||||
virtual Array<String> GetInstanceFields();
|
||||
virtual Array<String> GetClassFields();
|
||||
hx::Class GetSuper();
|
||||
#ifdef HXCPP_SCRIPTABLE
|
||||
const hx::StorageInfo* GetMemberStorage(String inName);
|
||||
const hx::StaticInfo* GetStaticStorage(String inName);
|
||||
#endif
|
||||
|
||||
static hx::Class Resolve(String inName);
|
||||
|
||||
|
||||
hx::Class *mSuper;
|
||||
String mName;
|
||||
Dynamic __meta__;
|
||||
String __rtti__;
|
||||
|
||||
hx::ConstructArgsFunc mConstructArgs;
|
||||
hx::ConstructEmptyFunc mConstructEmpty;
|
||||
hx::ConstructEnumFunc mConstructEnum;
|
||||
hx::GetStaticFieldFunc mGetStaticField;
|
||||
hx::SetStaticFieldFunc mSetStaticField;
|
||||
|
||||
hx::MarkFunc mMarkFunc;
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
hx::VisitFunc mVisitFunc;
|
||||
#endif
|
||||
Array<String> mStatics;
|
||||
Array<String> mMembers;
|
||||
|
||||
#ifdef HXCPP_SCRIPTABLE
|
||||
const hx::StorageInfo* mMemberStorageInfo;
|
||||
const hx::StaticInfo* mStaticStorageInfo;
|
||||
#endif
|
||||
};
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
void __hxcpp_boot_std_classes();
|
||||
|
||||
|
||||
// --- All classes should be registered with this function via the "__boot" method
|
||||
#ifdef RegisterClass
|
||||
#undef RegisterClass
|
||||
#endif
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
hx::Class _hx_RegisterClass(const String &inClassName, CanCastFunc inCanCast,
|
||||
String inStatics[], String inMembers[],
|
||||
ConstructEmptyFunc inConstructEmpty, ConstructArgsFunc inConstructArgs,
|
||||
hx::Class *inSuperClass, ConstructEnumFunc inConst=0, MarkFunc inMarkFunc=0
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
, VisitFunc inVisitFunc=0
|
||||
#endif
|
||||
#ifdef HXCPP_SCRIPTABLE
|
||||
,const hx::StorageInfo *inStorageInfo=0
|
||||
,const hx::StaticInfo *inStaticInfo=0
|
||||
#endif
|
||||
);
|
||||
|
||||
// For older versions
|
||||
inline hx::Class RegisterClass(
|
||||
const String &inClassName, CanCastFunc inCanCast,
|
||||
String inStatics[], String inMembers[],
|
||||
ConstructEmptyFunc inConstructEmpty, ConstructArgsFunc inConstructArgs,
|
||||
hx::Class *inSuperClass, ConstructEnumFunc inConst=0, MarkFunc inMarkFunc=0
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
, VisitFunc inVisitFunc=0
|
||||
#endif
|
||||
#ifdef HXCPP_SCRIPTABLE
|
||||
,const hx::StorageInfo *inStorageInfo=0
|
||||
,const hx::StaticInfo *inStaticInfo=0
|
||||
#endif
|
||||
)
|
||||
{
|
||||
return _hx_RegisterClass(inClassName, inCanCast, inStatics, inMembers,
|
||||
inConstructEmpty, inConstructArgs, inSuperClass, inConst, inMarkFunc
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
, inVisitFunc
|
||||
#endif
|
||||
#ifdef HXCPP_SCRIPTABLE
|
||||
,inStorageInfo ,inStaticInfo
|
||||
#endif
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
void _hx_RegisterClass(const String &inClassName, hx::Class inClass);
|
||||
|
||||
inline void RegisterClass(const String &inClassName, hx::Class inClass)
|
||||
{
|
||||
_hx_RegisterClass(inClassName, inClass);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline bool TCanCast(hx::Object *inPtr)
|
||||
{
|
||||
return inPtr && (
|
||||
#if (HXCPP_API_LEVEL >= 332)
|
||||
inPtr->_hx_isInstanceOf(T::_hx_ClassId)
|
||||
#elif (HXCPP_API_LEVEL==331)
|
||||
dynamic_cast<T *>(inPtr)
|
||||
#else
|
||||
dynamic_cast<T *>(inPtr->__GetRealObject())
|
||||
#if (HXCPP_API_LEVEL < 330)
|
||||
|| inPtr->__ToInterface(typeid(T))
|
||||
#endif
|
||||
#endif
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
#if (HXCPP_API_LEVEL >= 330)
|
||||
template<int HASH>
|
||||
inline bool TIsInterface(hx::Object *inPtr)
|
||||
{
|
||||
return inPtr && inPtr->_hx_getInterface(HASH);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void RegisterVTableOffset(int inOffset);
|
||||
|
||||
#define HX_REGISTER_VTABLE_OFFSET( CLASS, INTERFACE ) \
|
||||
{ \
|
||||
CLASS *dummy = (CLASS *)0; \
|
||||
INTERFACE *intf = dummy; \
|
||||
hx::RegisterVTableOffset( (int)( (size_t)((char *)intf - (char *)dummy)) ); \
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
365
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Debug.h
Normal file
365
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Debug.h
Normal file
@ -0,0 +1,365 @@
|
||||
#ifndef HX_DEBUG_H
|
||||
#define HX_DEBUG_H
|
||||
|
||||
#include <hxcpp.h>
|
||||
|
||||
// Some functions used by AdvancedDebug.cpp
|
||||
// Returns the thread number of the calling thread
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
int __hxcpp_GetCurrentThreadNumber();
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
#ifdef HXCPP_DEBUGGER
|
||||
|
||||
template<typename T> struct StackVariableWrapper
|
||||
{
|
||||
typedef T wrapper;
|
||||
};
|
||||
template<> struct StackVariableWrapper<size_t>
|
||||
{
|
||||
#ifdef HXCPP_M64
|
||||
typedef cpp::Int64 wrapper;
|
||||
#else
|
||||
typedef int wrapper;
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
template<typename T> struct StackVariableWrapper<T *>
|
||||
{
|
||||
typedef cpp::Pointer<T> wrapper;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
class StackVariable
|
||||
{
|
||||
public:
|
||||
|
||||
const char *mHaxeName;
|
||||
bool mIsArg;
|
||||
StackVariable *mNext;
|
||||
|
||||
template<typename T>
|
||||
StackVariable(StackVariable *&inHead, bool inIsArg,
|
||||
const char *inHaxeName, T *inCppVar)
|
||||
: mHaxeName(inHaxeName), mIsArg(inIsArg), mHead(inHead),
|
||||
mCppVar((void *) inCppVar)
|
||||
{
|
||||
mGetOrSetFunction = GetOrSetFunction<T>;
|
||||
mNext = mHead;
|
||||
mHead = this;
|
||||
}
|
||||
|
||||
StackVariable(StackVariable *&inHead, bool inIsArg,
|
||||
const char *inHaxeName, hx::Object **inCppVar)
|
||||
: mHaxeName(inHaxeName), mIsArg(inIsArg), mHead(inHead),
|
||||
mCppVar((void *) inCppVar)
|
||||
{
|
||||
mGetOrSetFunction = GetOrSetFunctionHxObject;
|
||||
mNext = mHead;
|
||||
mHead = this;
|
||||
}
|
||||
|
||||
|
||||
// For StackThis
|
||||
template<typename T>
|
||||
StackVariable(StackVariable *&inHead, T *inCppVar)
|
||||
: mHaxeName("this"), mIsArg(true), mHead(inHead),
|
||||
mCppVar((void *) inCppVar)
|
||||
{
|
||||
mNext = mHead;
|
||||
mHead = this;
|
||||
}
|
||||
|
||||
~StackVariable()
|
||||
{
|
||||
// Stack variables are always deleted in the reverse order that they
|
||||
// are created, so a simple pop_front is sufficient; no need to hunt
|
||||
// for and remove the variable, it's always in the front ...
|
||||
mHead = mNext;
|
||||
}
|
||||
|
||||
operator Dynamic()
|
||||
{
|
||||
return mGetOrSetFunction(true, mCppVar, 0);
|
||||
}
|
||||
|
||||
StackVariable &operator =(Dynamic &other)
|
||||
{
|
||||
(void) mGetOrSetFunction(false, mCppVar, &other);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
typedef Dynamic (*GetOrSetFunctionType)(bool, void *, Dynamic *);
|
||||
|
||||
GetOrSetFunctionType mGetOrSetFunction;
|
||||
|
||||
private:
|
||||
|
||||
template<typename T>
|
||||
static Dynamic GetOrSetFunction(bool get, void *ptr, Dynamic *dynamic)
|
||||
{
|
||||
typedef typename StackVariableWrapper<T>::wrapper Wrap;
|
||||
|
||||
if (get) {
|
||||
return Wrap(* (T *) ptr);
|
||||
}
|
||||
else {
|
||||
* (T *) ptr = Wrap(*dynamic);
|
||||
return null();
|
||||
}
|
||||
}
|
||||
|
||||
static Dynamic GetOrSetFunctionHxObject(bool get, void *ptr, Dynamic *dynamic)
|
||||
{
|
||||
if (get) {
|
||||
return * (hx::Object **) ptr;
|
||||
}
|
||||
else {
|
||||
* (hx::Object **)ptr = dynamic->mPtr;
|
||||
return null();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
StackVariable *&mHead;
|
||||
|
||||
void *mCppVar;
|
||||
|
||||
};
|
||||
|
||||
|
||||
class StackThis : public StackVariable
|
||||
{
|
||||
public:
|
||||
|
||||
template<typename T>
|
||||
StackThis(StackVariable *&inHead, T *inThis)
|
||||
: StackVariable(inHead, inThis)
|
||||
{
|
||||
mGetOrSetFunction = GetFunction<T>;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
StackThis(StackVariable *&inHead, hx::ObjectPtr<T> &inThis)
|
||||
: StackVariable(inHead, &inThis.mPtr)
|
||||
{
|
||||
mGetOrSetFunction = GetObjectPtr<T>;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
static Dynamic GetObjectPtr(bool get, void *ptr, Dynamic *val)
|
||||
{
|
||||
if (get) {
|
||||
return *(hx::Object **) ptr;
|
||||
}
|
||||
else {
|
||||
return null();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<typename T>
|
||||
static Dynamic GetFunction(bool get, void *ptr, Dynamic *val)
|
||||
{
|
||||
if (get) {
|
||||
return (T *) ptr;
|
||||
}
|
||||
else {
|
||||
return null();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
class StackCatchable
|
||||
{
|
||||
public:
|
||||
|
||||
StackCatchable *mNext;
|
||||
|
||||
template<typename T>
|
||||
StackCatchable(StackFrame &frame, T * /* dummy required by template*/)
|
||||
: mFrame(frame)
|
||||
{
|
||||
mNext = frame.catchables;
|
||||
frame.catchables = this;
|
||||
mTestFunction = TestFunction<T>;
|
||||
}
|
||||
|
||||
~StackCatchable()
|
||||
{
|
||||
mFrame.catchables = mNext;
|
||||
}
|
||||
|
||||
bool Catches(Dynamic e) const
|
||||
{
|
||||
return mTestFunction(e);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
template<typename T>
|
||||
static bool TestFunction(Dynamic e)
|
||||
{
|
||||
return e.IsClass<T>();
|
||||
}
|
||||
|
||||
StackFrame &mFrame;
|
||||
bool (*mTestFunction)(Dynamic e);
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif // HXCPP_DEBUGGER
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
|
||||
|
||||
void __hxcpp_dbg_getScriptableFiles( Array< ::String> ioPaths );
|
||||
void __hxcpp_dbg_getScriptableFilesFullPath( Array< ::String> ioPaths );
|
||||
void __hxcpp_dbg_getScriptableClasses( Array< ::String> ioClasses );
|
||||
|
||||
|
||||
|
||||
#ifdef HXCPP_DEBUGGER
|
||||
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
// These must match the values present in cpp.vm.Debugger
|
||||
|
||||
enum ThreadEvent
|
||||
{
|
||||
THREAD_CREATED = 1,
|
||||
THREAD_TERMINATED = 2,
|
||||
THREAD_STARTED = 3,
|
||||
THREAD_STOPPED = 4
|
||||
};
|
||||
|
||||
enum StepType
|
||||
{
|
||||
STEP_NONE = 0, // Not present or needed in cpp.vm.Debugger
|
||||
STEP_INTO = 1,
|
||||
STEP_OVER = 2,
|
||||
STEP_OUT = 3
|
||||
};
|
||||
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
|
||||
// The following functions are called directly, and only, by the haxe standard
|
||||
// library's cpp.vm.Debugger.hx class
|
||||
void __hxcpp_dbg_setEventNotificationHandler(Dynamic handler);
|
||||
void __hxcpp_dbg_enableCurrentThreadDebugging(bool enable);
|
||||
int __hxcpp_dbg_getCurrentThreadNumber();
|
||||
Array< ::String> __hxcpp_dbg_getFiles();
|
||||
Array< ::String> __hxcpp_dbg_getFilesFullPath();
|
||||
Array< ::String> __hxcpp_dbg_getClasses();
|
||||
Array<Dynamic> __hxcpp_dbg_getThreadInfos();
|
||||
Dynamic __hxcpp_dbg_getThreadInfo(int threadNumber, bool unsafe);
|
||||
int __hxcpp_dbg_addFileLineBreakpoint(String fileName, int lineNumber);
|
||||
int __hxcpp_dbg_addClassFunctionBreakpoint(String className,
|
||||
String functionName);
|
||||
void __hxcpp_dbg_deleteAllBreakpoints();
|
||||
void __hxcpp_dbg_deleteBreakpoint(int number);
|
||||
void __hxcpp_dbg_breakNow(bool wait);
|
||||
void __hxcpp_dbg_continueThreads(int threadNumber, int count);
|
||||
void __hxcpp_dbg_stepThread(int threadNumber, int stepType, int stepCount);
|
||||
Array<Dynamic> __hxcpp_dbg_getStackVariables(int threadNumber,
|
||||
int stackFrameNumber,
|
||||
bool unsafe,
|
||||
Dynamic markThreadNotStopped);
|
||||
Dynamic __hxcpp_dbg_getStackVariableValue(int threadNumber,
|
||||
int stackFrameNumber,
|
||||
String name,
|
||||
bool unsafe,
|
||||
Dynamic markNonexistent,
|
||||
Dynamic markThreadNotStopped);
|
||||
|
||||
Dynamic __hxcpp_dbg_setStackVariableValue(int threadNumber,
|
||||
int stackFrameNumber,
|
||||
String name, Dynamic value,
|
||||
bool unsafe,
|
||||
Dynamic markNonexistent,
|
||||
Dynamic markThreadNotStopped);
|
||||
void __hxcpp_dbg_setNewParameterFunction(Dynamic function);
|
||||
void __hxcpp_dbg_setNewStackFrameFunction(Dynamic function);
|
||||
void __hxcpp_dbg_setNewThreadInfoFunction(Dynamic function);
|
||||
void __hxcpp_dbg_setAddParameterToStackFrameFunction(Dynamic function);
|
||||
void __hxcpp_dbg_setAddStackFrameToThreadInfoFunction(Dynamic function);
|
||||
|
||||
bool __hxcpp_dbg_fix_critical_error(String inErr);
|
||||
|
||||
// The following functions are called by Thread.cpp to notify of thread
|
||||
// created and terminated
|
||||
void __hxcpp_dbg_threadCreatedOrTerminated(int threadNumber, bool created);
|
||||
|
||||
// The following is called by the stack macros, but only if
|
||||
// HXCPP_DEBUGGER is set
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic __hxcpp_dbg_checkedThrow(Dynamic toThrow);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic __hxcpp_dbg_checkedRethrow(Dynamic toThrow);
|
||||
|
||||
#else // !HXCPP_DEBUGGER
|
||||
|
||||
// If no debugger, provide empty implementations of the debugging functions
|
||||
|
||||
inline void __hxcpp_dbg_setEventNotificationHandler(Dynamic)
|
||||
{ hx::Throw("Debugging is not enabled for this program; try\n"
|
||||
"rebuilding it with the -D HXCPP_DEBUGGER option"); }
|
||||
inline void __hxcpp_dbg_enableCurrentThreadDebugging(bool) { }
|
||||
inline int __hxcpp_dbg_getCurrentThreadNumber() { return -1; }
|
||||
inline Array< ::String> __hxcpp_dbg_getFiles()
|
||||
{ return Array_obj< String>::__new(); }
|
||||
inline Array< ::String> __hxcpp_dbg_getFilesFullPath()
|
||||
{ return Array_obj< String>::__new(); }
|
||||
inline Array< ::String> __hxcpp_dbg_getClasses()
|
||||
{ return Array_obj< String>::__new(); }
|
||||
inline Array<Dynamic> __hxcpp_dbg_getThreadInfos()
|
||||
{ return Array_obj< ::Dynamic>::__new(); }
|
||||
inline Dynamic __hxcpp_dbg_getThreadInfo(int, bool) { return null(); }
|
||||
inline int __hxcpp_dbg_addFileLineBreakpoint(String, int) { return -1; }
|
||||
inline int __hxcpp_dbg_addClassFunctionBreakpoint(String, String)
|
||||
{ return -1; }
|
||||
inline void __hxcpp_dbg_deleteAllBreakpoints() { }
|
||||
inline void __hxcpp_dbg_deleteBreakpoint(int) { }
|
||||
inline void __hxcpp_dbg_breakNow(bool) { }
|
||||
inline void __hxcpp_dbg_continueThreads(int, int) { }
|
||||
inline void __hxcpp_dbg_stepThread(int, int, int) { }
|
||||
inline Array<Dynamic> __hxcpp_dbg_getStackVariables(int, int, bool, Dynamic)
|
||||
{ return Array_obj< String>::__new(); }
|
||||
inline Dynamic __hxcpp_dbg_getStackVariableValue(int, int, String, bool,
|
||||
Dynamic, Dynamic)
|
||||
{ return null(); }
|
||||
inline Dynamic __hxcpp_dbg_setStackVariableValue(int, int, String, Dynamic,
|
||||
bool, Dynamic, Dynamic)
|
||||
{ return null(); }
|
||||
inline void __hxcpp_dbg_setNewParameterFunction(Dynamic) { }
|
||||
inline void __hxcpp_dbg_setNewStackFrameFunction(Dynamic) { }
|
||||
inline void __hxcpp_dbg_setNewThreadInfoFunction(Dynamic) { }
|
||||
inline void __hxcpp_dbg_setAddParameterToStackFrameFunction(Dynamic) { }
|
||||
inline void __hxcpp_dbg_setAddStackFrameToThreadInfoFunction(Dynamic) { }
|
||||
|
||||
// The following functions are called by Thread.cpp to notify of thread
|
||||
// created and terminated
|
||||
inline void __hxcpp_dbg_threadCreatedOrTerminated(int, bool) { }
|
||||
|
||||
inline Dynamic __hxcpp_dbg_checkedThrow(Dynamic toThrow) { return hx::Throw(toThrow); }
|
||||
inline Dynamic __hxcpp_dbg_checkedRethrow(Dynamic toThrow) { return hx::Rethrow(toThrow); }
|
||||
|
||||
#endif // HXCPP_DEBUGGER
|
||||
|
||||
|
||||
#endif // HX_DEBUG_H
|
||||
1095
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/DynamicImpl.h
Normal file
1095
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/DynamicImpl.h
Normal file
File diff suppressed because it is too large
Load Diff
210
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/DynamicImpl.tpl
Normal file
210
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/DynamicImpl.tpl
Normal file
@ -0,0 +1,210 @@
|
||||
|
||||
::foreach PARAMS:: ::if (ARG>=6)::
|
||||
Dynamic Dynamic::NS::operator()(::DYNAMIC_ARG_LIST::)
|
||||
{
|
||||
CheckFPtr();
|
||||
return mPtr->__Run(Array_obj<Dynamic>::NS::__new(::ARG::)::DYNAMIC_ADDS::);
|
||||
}
|
||||
|
||||
namespace cpp
|
||||
{
|
||||
::NS::Dynamic Variant::NS::operator()(::DYNAMIC_ARG_LIST::)
|
||||
{
|
||||
if (isNull()) Dynamic::ThrowBadFunctionError();
|
||||
return valObject->__Run(Array_obj<Dynamic>::NS::__new(::ARG::)::DYNAMIC_ADDS::);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
::else::
|
||||
|
||||
namespace hx {
|
||||
|
||||
struct CMemberFunction::ARG:: : public hx::Object
|
||||
{
|
||||
hx::ObjectPtr<Object> mThis;
|
||||
MemberFunction::ARG:: mFunction;
|
||||
const char *mName;
|
||||
|
||||
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::NS::clsIdCMember::ARG:: };
|
||||
|
||||
|
||||
CMemberFunction::ARG::(const char *inName, hx::Object *inObj, MemberFunction::ARG:: inFunction)
|
||||
{
|
||||
mName = inName;
|
||||
mThis = inObj;
|
||||
mFunction = inFunction;
|
||||
}
|
||||
int __Compare(const hx::Object *inRHS) const
|
||||
{
|
||||
const CMemberFunction::ARG:: *other = dynamic_cast<const CMemberFunction::ARG:: *>(inRHS);
|
||||
if (!other)
|
||||
return -1;
|
||||
return (mName==other->mName && mFunction==other->mFunction && mThis.GetPtr()==other->mThis.GetPtr())? 0 : -1;
|
||||
}
|
||||
|
||||
int __GetType() const { return vtFunction; }
|
||||
int __ArgCount() const { return ::ARG::; }
|
||||
::String __ToString() const{ return String(mName); }
|
||||
void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER_NAME(mThis,"CMemberFunction::ARG::.this"); }
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
void __Visit(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER(mThis); }
|
||||
#endif
|
||||
void *__GetHandle() const { return mThis.GetPtr(); }
|
||||
Dynamic __Run(const Array<Dynamic> &inArgs)
|
||||
{
|
||||
::if (ARG>0)::
|
||||
return mFunction(mThis.GetPtr(), ::ARR_LIST::);
|
||||
::else::
|
||||
return mFunction(mThis.GetPtr());
|
||||
::end::
|
||||
}
|
||||
Dynamic __run(::DYNAMIC_ARG_LIST::)
|
||||
{
|
||||
::if (ARG>0)::
|
||||
return mFunction(mThis.GetPtr(), ::ARG_LIST::);
|
||||
::else::
|
||||
return mFunction(mThis.GetPtr());
|
||||
::end::
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
struct CStaticFunction::ARG:: : public hx::Object
|
||||
{
|
||||
StaticFunction::ARG:: mFunction;
|
||||
const char *mName;
|
||||
|
||||
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::NS::clsIdCStatic::ARG:: };
|
||||
|
||||
|
||||
CStaticFunction::ARG::(const char *inName,StaticFunction::ARG:: inFunction)
|
||||
{
|
||||
mName = inName;
|
||||
mFunction = inFunction;
|
||||
}
|
||||
int __Compare(const hx::Object *inRHS) const
|
||||
{
|
||||
const CStaticFunction::ARG:: *other = dynamic_cast<const CStaticFunction::ARG:: *>(inRHS);
|
||||
if (!other)
|
||||
return -1;
|
||||
return mName==other->mName && mFunction==other->mFunction && mName==other->mName ? 0 : -1;
|
||||
}
|
||||
|
||||
int __GetType() const { return vtFunction; }
|
||||
int __ArgCount() const { return ::ARG::; }
|
||||
::String __ToString() const{ return String(mName); }
|
||||
Dynamic __Run(const Array<Dynamic> &inArgs)
|
||||
{
|
||||
return mFunction(::ARR_LIST::);
|
||||
}
|
||||
Dynamic __run(::DYNAMIC_ARG_LIST::)
|
||||
{
|
||||
return mFunction(::ARG_LIST::);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic CreateMemberFunction::ARG::(const char *inName,hx::Object *inObj, MemberFunction::ARG:: inFunc)
|
||||
{ return new CMemberFunction::ARG::(inName,inObj,inFunc); }
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
Dynamic CreateStaticFunction::ARG::(const char *inName,StaticFunction::ARG:: inFunc)
|
||||
{ return new CStaticFunction::ARG::(inName,inFunc); }
|
||||
|
||||
}
|
||||
|
||||
::end::
|
||||
::end::
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
|
||||
struct CMemberFunctionVar : public hx::Object
|
||||
{
|
||||
hx::ObjectPtr<Object> mThis;
|
||||
MemberFunctionVar mFunction;
|
||||
const char *mName;
|
||||
int N;
|
||||
|
||||
|
||||
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdCMemberVar };
|
||||
|
||||
|
||||
CMemberFunctionVar(const char *inName,hx::Object *inObj, MemberFunctionVar inFunction,int inN)
|
||||
{
|
||||
mThis = inObj;
|
||||
mFunction = inFunction;
|
||||
mName = inName;
|
||||
N = inN;
|
||||
}
|
||||
int __Compare(const hx::Object *inRHS) const
|
||||
{
|
||||
const CMemberFunctionVar *other = dynamic_cast<const CMemberFunctionVar *>(inRHS);
|
||||
if (!other)
|
||||
return -1;
|
||||
return (mFunction==other->mFunction && mName==other->mName && mThis.GetPtr()==other->mThis.GetPtr())? 0 : -1;
|
||||
}
|
||||
|
||||
|
||||
int __GetType() const { return vtFunction; }
|
||||
int __ArgCount() const { return N; }
|
||||
::String __ToString() const{ return String(mName); }
|
||||
void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER_NAME(mThis,"CMemberFunctionVar.this"); }
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
void __Visit(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER(mThis); }
|
||||
#endif
|
||||
void *__GetHandle() const { return mThis.GetPtr(); }
|
||||
Dynamic __Run(const Array<Dynamic> &inArgs)
|
||||
{
|
||||
return mFunction(mThis.GetPtr(), inArgs);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
struct CStaticFunctionVar : public hx::Object
|
||||
{
|
||||
StaticFunctionVar mFunction;
|
||||
const char *mName;
|
||||
int N;
|
||||
|
||||
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdCStaticVar };
|
||||
|
||||
CStaticFunctionVar(const char *inName,StaticFunctionVar inFunction,int inN)
|
||||
{
|
||||
mFunction = inFunction;
|
||||
mName = inName;
|
||||
N = inN;
|
||||
}
|
||||
int __Compare(const hx::Object *inRHS) const
|
||||
{
|
||||
const CStaticFunctionVar *other = dynamic_cast<const CStaticFunctionVar *>(inRHS);
|
||||
if (!other)
|
||||
return -1;
|
||||
return mName==other->mName && mFunction==other->mFunction ? 0 : -1;
|
||||
}
|
||||
|
||||
|
||||
int __GetType() const { return vtFunction; }
|
||||
int __ArgCount() const { return N; }
|
||||
::String __ToString() const { return String(mName); }
|
||||
Dynamic __Run(const Array<Dynamic> &inArgs)
|
||||
{
|
||||
return mFunction(inArgs);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
Dynamic CreateMemberFunctionVar(const char *inName, hx::Object *inObj, MemberFunctionVar inFunc,int inN)
|
||||
{ return new CMemberFunctionVar(inName, inObj,inFunc,inN); }
|
||||
|
||||
Dynamic CreateStaticFunctionVar(const char *inName,StaticFunctionVar inFunc,int inN)
|
||||
{ return new CStaticFunctionVar(inName, inFunc,inN); }
|
||||
|
||||
}
|
||||
|
||||
|
||||
27
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/ErrorCodes.h
Normal file
27
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/ErrorCodes.h
Normal file
@ -0,0 +1,27 @@
|
||||
#ifndef HX_ERROR_CODES
|
||||
#define HX_ERROR_CODES
|
||||
|
||||
// --- Exteral constants, used inline
|
||||
#define HX_INVALID_CAST Dynamic(HX_CSTRING("Invalid Cast"))
|
||||
#define HX_INVALID_INTERFACE Dynamic(HX_CSTRING("Object does not implement interface"))
|
||||
#define HX_INDEX_OUT_OF_BOUNDS Dynamic(HX_CSTRING("Index Out of Bounds"))
|
||||
#define HX_INVALID_CONSTRUCTOR Dynamic(HX_CSTRING("Invalid constructor"))
|
||||
#define HX_INVALID_ENUM_CONSTRUCTOR(_enum_name, _constructor_name) \
|
||||
Dynamic(HX_CSTRING("Invalid enum constructor for ") + \
|
||||
HX_CSTRING(_enum_name) + \
|
||||
HX_CSTRING(": ") + \
|
||||
_constructor_name)
|
||||
#define HX_INVALID_OBJECT Dynamic(HX_CSTRING("Invalid object"))
|
||||
#define HX_INVALID_ARG_COUNT Dynamic(HX_CSTRING("Invalid Arg Count"))
|
||||
#define HX_NULL_FUNCTION_POINTER Dynamic(HX_CSTRING("Null Function Pointer"))
|
||||
#define HX_INVALID_ENUM_ARG_COUNT(_enum_name, _constructor_name, _count, _expected) \
|
||||
Dynamic(HX_CSTRING("Invalid enum arg count for ") + \
|
||||
HX_CSTRING(_enum_name) + \
|
||||
HX_CSTRING(".") + \
|
||||
_constructor_name + \
|
||||
HX_CSTRING(": expected ") + \
|
||||
::String(_expected) + \
|
||||
HX_CSTRING(", got ") + \
|
||||
::String(_count))
|
||||
|
||||
#endif
|
||||
304
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/FieldRef.h
Normal file
304
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/FieldRef.h
Normal file
@ -0,0 +1,304 @@
|
||||
#ifndef HX_FIELD_REF_H
|
||||
#define HX_FIELD_REF_H
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
// --- FieldRef ----------------------------------------------------------
|
||||
//
|
||||
// This is used to provide syntaxe for setting fields by name. This is because
|
||||
// the field can't be returned by reference, because it may not exist as a dynamic.
|
||||
//
|
||||
// eg, consider class 'A' with variable 'x':
|
||||
// class A { int x; }
|
||||
//
|
||||
// And you have a Dynamic pointing to it:
|
||||
// Dynamic d = new A; Then you access x by name:
|
||||
// d->__Field("x") = 1;
|
||||
//
|
||||
// __Field can't return a Dynamic & because x is a int, not Dynamic. So I use this class.
|
||||
// Note that this may change if I fix the generator to create __SetField("x",1) directly.
|
||||
|
||||
|
||||
#define HX_FIELD_REF_MEM_OP(op,ret) \
|
||||
inline ret operator op (const FieldRef &inA) \
|
||||
{ return this->operator Dynamic() op inA.operator Dynamic(); } \
|
||||
inline ret operator op (const IndexRef &inA); \
|
||||
template<typename T> inline ret operator op (const T& inA) \
|
||||
{ return this->operator Dynamic() op inA; }
|
||||
|
||||
#define HX_FIELD_REF_IMPL_MEM_OP(op,ret) \
|
||||
inline ret hx::FieldRef::operator op (const IndexRef &inA) \
|
||||
{ return this->operator Dynamic() op inA.operator Dynamic(); } \
|
||||
|
||||
class FieldRef
|
||||
{
|
||||
public:
|
||||
explicit FieldRef(hx::Object *inObj,const String &inName) : mObject(inObj), mName(inName)
|
||||
{
|
||||
}
|
||||
|
||||
hx::Val operator=(const hx::Val &inRHS)
|
||||
{
|
||||
return mObject->__SetField(mName,inRHS, HX_PROP_DYNAMIC );
|
||||
}
|
||||
#if HXCPP_API_LEVEL >= 330
|
||||
inline operator hx::Val() const { return mObject ? mObject->__Field(mName, HX_PROP_DYNAMIC) : null(); }
|
||||
#endif
|
||||
inline operator Dynamic() const { return mObject ? Dynamic(mObject->__Field(mName, HX_PROP_DYNAMIC)) : null(); }
|
||||
inline operator double() const { return mObject->__Field(mName, HX_PROP_DYNAMIC); }
|
||||
inline operator float() const { return mObject->__Field(mName, HX_PROP_DYNAMIC); }
|
||||
inline operator int() const { return mObject->__Field(mName, HX_PROP_DYNAMIC); }
|
||||
inline operator cpp::UInt64() const { return mObject->__Field(mName, HX_PROP_DYNAMIC); }
|
||||
inline operator cpp::Int64() const { return mObject->__Field(mName, HX_PROP_DYNAMIC); }
|
||||
|
||||
|
||||
// post-increment
|
||||
inline double operator++(int)
|
||||
{
|
||||
double d = mObject->__Field(mName, HX_PROP_DYNAMIC);
|
||||
mObject->__SetField(mName,d+1, HX_PROP_DYNAMIC);
|
||||
return d;
|
||||
}
|
||||
// pre-increment
|
||||
inline double operator++()
|
||||
{
|
||||
double d = ((double)mObject->__Field(mName, HX_PROP_DYNAMIC)) + 1;
|
||||
mObject->__SetField(mName,d, HX_PROP_DYNAMIC);
|
||||
return d;
|
||||
}
|
||||
// post-decrement
|
||||
inline double operator--(int)
|
||||
{
|
||||
double d = mObject->__Field(mName, HX_PROP_DYNAMIC);
|
||||
mObject->__SetField(mName,d-1, HX_PROP_DYNAMIC);
|
||||
return d;
|
||||
}
|
||||
// pre-decrement
|
||||
inline double operator--()
|
||||
{
|
||||
double d = (double)(mObject->__Field(mName, HX_PROP_DYNAMIC)) - 1;
|
||||
mObject->__SetField(mName,d, HX_PROP_DYNAMIC);
|
||||
return d;
|
||||
}
|
||||
bool operator !() { return ! ((int)(mObject->__Field(mName, HX_PROP_DYNAMIC))); }
|
||||
int operator ~() { return ~ ((int)mObject->__Field(mName, HX_PROP_DYNAMIC)); }
|
||||
|
||||
inline bool operator==(const null &) const { return !mObject; }
|
||||
inline bool operator!=(const null &) const { return mObject; }
|
||||
|
||||
double operator -() { return - (double)(mObject->__Field(mName, HX_PROP_DYNAMIC)); }
|
||||
|
||||
bool HasPointer() const { return mObject; }
|
||||
|
||||
|
||||
HX_FIELD_REF_MEM_OP(==,bool)
|
||||
HX_FIELD_REF_MEM_OP(!=,bool)
|
||||
HX_FIELD_REF_MEM_OP(<,bool)
|
||||
HX_FIELD_REF_MEM_OP(<=,bool)
|
||||
HX_FIELD_REF_MEM_OP(>,bool)
|
||||
HX_FIELD_REF_MEM_OP(>=,bool)
|
||||
|
||||
HX_FIELD_REF_MEM_OP(+,Dynamic)
|
||||
HX_FIELD_REF_MEM_OP(*,double)
|
||||
HX_FIELD_REF_MEM_OP(/,double)
|
||||
HX_FIELD_REF_MEM_OP(-,double)
|
||||
HX_FIELD_REF_MEM_OP(%,double)
|
||||
|
||||
|
||||
|
||||
String mName;
|
||||
hx::Object *mObject;
|
||||
};
|
||||
|
||||
// We can define this one now...
|
||||
template<typename T>
|
||||
inline FieldRef ObjectPtr<T>::FieldRef(const String &inString)
|
||||
{
|
||||
return hx::FieldRef(mPtr,inString);
|
||||
}
|
||||
|
||||
#define HX_FIELD_REF_OP(op,ret) \
|
||||
template<typename T> inline ret operator op (T &inT, const FieldRef &inA) \
|
||||
{ return inT op ( inA.operator Dynamic()); }
|
||||
|
||||
HX_FIELD_REF_OP(==,bool)
|
||||
HX_FIELD_REF_OP(!=,bool)
|
||||
HX_FIELD_REF_OP(<,bool)
|
||||
HX_FIELD_REF_OP(<=,bool)
|
||||
HX_FIELD_REF_OP(>,bool)
|
||||
HX_FIELD_REF_OP(>=,bool)
|
||||
|
||||
HX_FIELD_REF_OP(+,Dynamic)
|
||||
HX_FIELD_REF_OP(*,double)
|
||||
HX_FIELD_REF_OP(/,double)
|
||||
HX_FIELD_REF_OP(-,double)
|
||||
HX_FIELD_REF_OP(%,double)
|
||||
|
||||
|
||||
|
||||
// --- IndexRef --------------------------------------------------------------
|
||||
//
|
||||
// Like FieldRef, but for integer array access
|
||||
//
|
||||
|
||||
#define HX_INDEX_REF_MEM_OP(op,ret) \
|
||||
inline ret operator op (const IndexRef &inA) \
|
||||
{ return this->operator Dynamic() op inA.operator Dynamic(); } \
|
||||
inline ret operator op (const FieldRef &inA) \
|
||||
{ return this->operator Dynamic() op inA.operator Dynamic(); } \
|
||||
template<typename T> inline ret operator op (const T& inA) \
|
||||
{ return this->operator Dynamic() op inA; }
|
||||
|
||||
|
||||
class IndexRef
|
||||
{
|
||||
public:
|
||||
explicit IndexRef(hx::Object *inObj,int inIndex) : mObject(inObj), mIndex(inIndex)
|
||||
{
|
||||
}
|
||||
|
||||
Dynamic operator=(const Dynamic &inRHS)
|
||||
{
|
||||
return mObject->__SetItem(mIndex,inRHS);
|
||||
}
|
||||
inline operator Dynamic() const { return mObject->__GetItem(mIndex); }
|
||||
inline operator double() const { return mObject->__GetItem(mIndex); }
|
||||
inline operator int() const { return mObject->__GetItem(mIndex); }
|
||||
|
||||
// post-increment
|
||||
inline double operator++(int)
|
||||
{
|
||||
double d = mObject->__GetItem(mIndex)->__ToDouble();
|
||||
mObject->__SetItem(mIndex,d+1);
|
||||
return d;
|
||||
}
|
||||
// pre-increment
|
||||
inline double operator++()
|
||||
{
|
||||
double d = mObject->__GetItem(mIndex)->__ToDouble() + 1;
|
||||
mObject->__SetItem(mIndex,d);
|
||||
return d;
|
||||
}
|
||||
// post-decrement
|
||||
inline double operator--(int)
|
||||
{
|
||||
double d = mObject->__GetItem(mIndex)->__ToDouble();
|
||||
mObject->__SetItem(mIndex,d-1);
|
||||
return d;
|
||||
}
|
||||
// pre-decrement
|
||||
inline double operator--()
|
||||
{
|
||||
double d = mObject->__GetItem(mIndex)->__ToDouble() - 1;
|
||||
mObject->__SetItem(mIndex,d);
|
||||
return d;
|
||||
}
|
||||
bool operator !() { return ! mObject->__GetItem(mIndex)->__ToInt(); }
|
||||
int operator ~() { return ~ mObject->__GetItem(mIndex)->__ToInt(); }
|
||||
double operator -() { return - mObject->__GetItem(mIndex)->__ToDouble(); }
|
||||
|
||||
inline bool operator==(const null &) const { return !mObject; }
|
||||
inline bool operator!=(const null &) const { return mObject; }
|
||||
|
||||
HX_INDEX_REF_MEM_OP(==,bool)
|
||||
HX_INDEX_REF_MEM_OP(!=,bool)
|
||||
HX_INDEX_REF_MEM_OP(<,bool)
|
||||
HX_INDEX_REF_MEM_OP(<=,bool)
|
||||
HX_INDEX_REF_MEM_OP(>,bool)
|
||||
HX_INDEX_REF_MEM_OP(>=,bool)
|
||||
|
||||
HX_INDEX_REF_MEM_OP(+,Dynamic)
|
||||
HX_INDEX_REF_MEM_OP(*,double)
|
||||
HX_INDEX_REF_MEM_OP(/,double)
|
||||
HX_INDEX_REF_MEM_OP(-,double)
|
||||
HX_INDEX_REF_MEM_OP(%,double)
|
||||
|
||||
bool HasPointer() const { return mObject; }
|
||||
|
||||
int mIndex;
|
||||
hx::Object *mObject;
|
||||
};
|
||||
|
||||
// We can define this one now...
|
||||
template<typename T>
|
||||
inline IndexRef ObjectPtr<T>::IndexRef(int inIndex)
|
||||
{
|
||||
return hx::IndexRef(mPtr,inIndex);
|
||||
}
|
||||
|
||||
#define HX_INDEX_REF_OP(op,ret) \
|
||||
template<typename T> inline ret operator op (T &inT, const IndexRef &inA) \
|
||||
{ return inT op ( inA. operator Dynamic()); }
|
||||
|
||||
HX_INDEX_REF_OP(==,bool)
|
||||
HX_INDEX_REF_OP(!=,bool)
|
||||
HX_INDEX_REF_OP(<,bool)
|
||||
HX_INDEX_REF_OP(<=,bool)
|
||||
HX_INDEX_REF_OP(>,bool)
|
||||
HX_INDEX_REF_OP(>=,bool)
|
||||
|
||||
HX_INDEX_REF_OP(+,Dynamic)
|
||||
HX_INDEX_REF_OP(*,double)
|
||||
HX_INDEX_REF_OP(/,double)
|
||||
HX_INDEX_REF_OP(-,double)
|
||||
HX_INDEX_REF_OP(%,double)
|
||||
|
||||
|
||||
// Implement once IndexRef has been defined.
|
||||
HX_FIELD_REF_IMPL_MEM_OP(==,bool)
|
||||
HX_FIELD_REF_IMPL_MEM_OP(!=,bool)
|
||||
HX_FIELD_REF_IMPL_MEM_OP(<,bool)
|
||||
HX_FIELD_REF_IMPL_MEM_OP(<=,bool)
|
||||
HX_FIELD_REF_IMPL_MEM_OP(>,bool)
|
||||
HX_FIELD_REF_IMPL_MEM_OP(>=,bool)
|
||||
|
||||
HX_FIELD_REF_IMPL_MEM_OP(+,Dynamic)
|
||||
HX_FIELD_REF_IMPL_MEM_OP(*,double)
|
||||
HX_FIELD_REF_IMPL_MEM_OP(/,double)
|
||||
HX_FIELD_REF_IMPL_MEM_OP(-,double)
|
||||
HX_FIELD_REF_IMPL_MEM_OP(%,double)
|
||||
|
||||
// Disambiguate Dynamic operators...
|
||||
|
||||
#define HX_INDEX_REF_OP_DYNAMIC(op,ret) \
|
||||
inline ret operator op (const Dynamic &inT, const IndexRef &inA) \
|
||||
{ return inT op ( inA.operator Dynamic()); }
|
||||
|
||||
HX_INDEX_REF_OP_DYNAMIC(==,bool)
|
||||
HX_INDEX_REF_OP_DYNAMIC(!=,bool)
|
||||
HX_INDEX_REF_OP_DYNAMIC(+,Dynamic)
|
||||
HX_INDEX_REF_OP_DYNAMIC(*,double)
|
||||
|
||||
|
||||
|
||||
template<typename _OBJ>
|
||||
class __TArrayImplRef
|
||||
{
|
||||
public:
|
||||
_OBJ mObject;
|
||||
int mIndex;
|
||||
|
||||
explicit __TArrayImplRef(_OBJ inObj,int inIndex) : mObject(inObj), mIndex(inIndex) { }
|
||||
|
||||
template<typename _DATA>
|
||||
inline operator _DATA() { return mObject->__get(mIndex); }
|
||||
template<typename _DATA>
|
||||
inline void operator=(_DATA inRHS)
|
||||
{
|
||||
mObject->__set(mIndex,inRHS);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename _OBJ>
|
||||
__TArrayImplRef<_OBJ> __ArrayImplRef(_OBJ inObj, int inIndex)
|
||||
{
|
||||
return __TArrayImplRef<_OBJ>(inObj,inIndex);
|
||||
}
|
||||
|
||||
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
|
||||
#endif
|
||||
28
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Functions.h
Normal file
28
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Functions.h
Normal file
@ -0,0 +1,28 @@
|
||||
#ifndef HX_FUNCTIONS_H
|
||||
#define HX_FUNCTIONS_H
|
||||
#include <hxcpp.h>
|
||||
|
||||
namespace hx
|
||||
{
|
||||
struct HXCPP_EXTERN_CLASS_ATTRIBUTES LocalFunc : public hx::Object
|
||||
{
|
||||
int __GetType() const { return vtFunction; }
|
||||
inline void DoMarkThis(hx::MarkContext *__inCtx) { }
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
inline void DoVisitThis(hx::VisitContext *__inCtx) { }
|
||||
#endif
|
||||
};
|
||||
|
||||
struct HXCPP_EXTERN_CLASS_ATTRIBUTES LocalThisFunc : public LocalFunc
|
||||
{
|
||||
Dynamic __this;
|
||||
void __SetThis(Dynamic inThis) { __this = inThis; }
|
||||
inline void DoMarkThis(hx::MarkContext *__inCtx) { HX_MARK_MEMBER(__this); }
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
inline void DoVisitThis(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER(__this); }
|
||||
#endif
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
580
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/GC.h
Normal file
580
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/GC.h
Normal file
@ -0,0 +1,580 @@
|
||||
#ifndef HX_GC_H
|
||||
#define HX_GC_H
|
||||
|
||||
#include <hx/Tls.h>
|
||||
#include <stdio.h>
|
||||
|
||||
// Under the current scheme (as defined by HX_HCSTRING/HX_CSTRING in hxcpp.h)
|
||||
// each constant string data is prepended with a 4-byte header that says the string
|
||||
// is constant (ie, not part of GC) and whether there is(not) a pre-computed hash at
|
||||
// the end of the data.
|
||||
// When HX_SMART_STRINGS is active, a bit says whether it is char16_t encoded.
|
||||
|
||||
#define HX_GC_CONST_ALLOC_BIT 0x80000000
|
||||
#define HX_GC_CONST_ALLOC_MARK_BIT 0x80
|
||||
|
||||
|
||||
|
||||
|
||||
// Tell compiler the extra functions are supported
|
||||
#define HXCPP_GC_FUNCTIONS_1
|
||||
|
||||
// Function called by the haxe code...
|
||||
|
||||
#ifdef HXCPP_TELEMETRY
|
||||
extern void __hxt_gc_new(hx::StackContext *inStack, void* obj, int inSize, const char *inName);
|
||||
#endif
|
||||
|
||||
|
||||
// Helpers for debugging code
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_reachable(hx::Object *inKeep);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_enable(bool inEnable);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_collect(bool inMajor=true);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_gc_compact();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int __hxcpp_gc_trace(hx::Class inClass, bool inPrint);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int __hxcpp_gc_used_bytes();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES double __hxcpp_gc_mem_info(int inWhat);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_enter_gc_free_zone();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_exit_gc_free_zone();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_gc_safe_point();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_spam_collects(int inEveryNCalls);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_set_minimum_working_memory(int inBytes);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_set_minimum_free_space(int inBytes);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_set_target_free_space_percentage(int inPercentage);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __hxcpp_is_const_string(const ::String &inString);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_gc_freeze(Dynamic inObject);
|
||||
|
||||
typedef void (hx::Object::*_hx_member_finalizer)(void);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_add_member_finalizer(hx::Object *inObject, _hx_member_finalizer, bool inPin);
|
||||
|
||||
typedef void (*_hx_alloc_finalizer)(void *inPtr);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_add_alloc_finalizer(void *inAlloc, _hx_alloc_finalizer, bool inPin);
|
||||
|
||||
template<typename T>
|
||||
inline void _hx_add_finalizable( hx::ObjectPtr<T> inObj, bool inPin)
|
||||
{
|
||||
_hx_member_finalizer finalizer = (_hx_member_finalizer)&T::finalize;
|
||||
__hxcpp_add_member_finalizer(inObj.mPtr, finalizer, inPin);
|
||||
}
|
||||
template<typename T>
|
||||
inline void _hx_add_finalizable( T *inObj, bool inPin)
|
||||
{
|
||||
_hx_member_finalizer finalizer = (_hx_member_finalizer)&T::finalize;
|
||||
__hxcpp_add_member_finalizer(inObj, finalizer, inPin);
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<typename T>
|
||||
T _hx_allocate_extended(int inExtra)
|
||||
{
|
||||
typedef typename T::Obj Obj;
|
||||
Obj *obj = new (inExtra) Obj();
|
||||
return obj;
|
||||
}
|
||||
|
||||
/*
|
||||
template<typename T>
|
||||
inline void _hx_allocate_extended( hx::ObjectPtr<T> inObj, bool inPin)
|
||||
*/
|
||||
|
||||
|
||||
// Finalizers from haxe code...
|
||||
void __hxcpp_gc_do_not_kill(Dynamic inObj);
|
||||
|
||||
// This is the correctly typed version - no change of getting function proto wrong
|
||||
void _hx_set_finalizer(Dynamic inObj, void (*inFunc)(Dynamic) );
|
||||
|
||||
void __hxcpp_set_finalizer(Dynamic inObj, void *inFunction);
|
||||
hx::Object *__hxcpp_get_next_zombie();
|
||||
|
||||
#ifdef HXCPP_TELEMETRY
|
||||
void __hxcpp_set_hxt_finalizer(void* inObj, void *inFunc);
|
||||
#endif
|
||||
|
||||
hx::Object *__hxcpp_weak_ref_create(Dynamic inObject);
|
||||
hx::Object *__hxcpp_weak_ref_get(Dynamic inRef);
|
||||
|
||||
|
||||
unsigned int __hxcpp_obj_hash(Dynamic inObj);
|
||||
int __hxcpp_obj_id(Dynamic inObj);
|
||||
hx::Object *__hxcpp_id_obj(int);
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
namespace hx
|
||||
{
|
||||
// Generic allocation routine.
|
||||
// If inSize is small (<4k) it will be allocated from the immix pool.
|
||||
// Larger, and it will be allocated from a separate memory pool
|
||||
// inIsObject specifies whether "__Mark" should be called on the resulting object
|
||||
void *InternalNew(int inSize,bool inIsObject);
|
||||
|
||||
// Used internall - realloc array data
|
||||
void *InternalRealloc(int inFromSize, void *inData,int inSize,bool inAllowExpansion=false);
|
||||
|
||||
void InternalReleaseMem(void *inMem);
|
||||
|
||||
unsigned int ObjectSizeSafe(void *inData);
|
||||
|
||||
// Const buffers are allocated outside the GC system, and do not require marking
|
||||
// String buffers can optionally have a pre-computed hash appended with this method
|
||||
void *InternalCreateConstBuffer(const void *inData,int inSize,bool inAddStringHash=false);
|
||||
|
||||
// Called after collection by an unspecified thread
|
||||
typedef void (*finalizer)(hx::Object *v);
|
||||
|
||||
// Used internally by the runtime.
|
||||
// The constructor will add this object to the internal list of finalizers.
|
||||
// If the parent object is not marked by the end of the collect, the finalizer will trigger.
|
||||
struct InternalFinalizer
|
||||
{
|
||||
InternalFinalizer(hx::Object *inObj, finalizer inFinalizer=0);
|
||||
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
void Visit(VisitContext *__inCtx);
|
||||
#endif
|
||||
void Detach();
|
||||
|
||||
bool mValid;
|
||||
finalizer mFinalizer;
|
||||
hx::Object *mObject;
|
||||
};
|
||||
|
||||
// Attach a finalizer to any object allocation. This can be called from haxe code, but be aware that
|
||||
// you can't make any GC calls from the finalizer.
|
||||
void GCSetFinalizer( hx::Object *, hx::finalizer f );
|
||||
|
||||
// If another thread wants to do a collect, it will signal this variable.
|
||||
// This automatically gets checked when you call "new", but if you are in long-running
|
||||
// loop with no new call, you might starve another thread if you to not check this.
|
||||
// 0xffffffff = pause requested
|
||||
extern int gPauseForCollect;
|
||||
|
||||
|
||||
// Minimum total memory - used + buffer for new objects
|
||||
extern int sgMinimumWorkingMemory;
|
||||
|
||||
// Minimum free memory - not counting used memory
|
||||
extern int sgMinimumFreeSpace;
|
||||
|
||||
// Also ensure that the free memory is larger than this amount of used memory
|
||||
extern int sgTargetFreeSpacePercentage;
|
||||
|
||||
|
||||
extern HXCPP_EXTERN_CLASS_ATTRIBUTES int gByteMarkID;
|
||||
|
||||
// Call in response to a gPauseForCollect. Normally, this is done for you in "new"
|
||||
void PauseForCollect();
|
||||
|
||||
|
||||
// Used by WeakHash to work out if it needs to dispose its keys
|
||||
bool IsWeakRefValid(hx::Object *inPtr);
|
||||
bool IsWeakRefValid(const HX_CHAR *inPtr);
|
||||
|
||||
// Used by CFFI to scan a block of memory for GC Pointers. May picks up random crap
|
||||
// that points to real, active objects.
|
||||
void MarkConservative(int *inBottom, int *inTop,hx::MarkContext *__inCtx);
|
||||
|
||||
|
||||
// Create/Remove a root.
|
||||
// All statics are explicitly registered - this saves adding the whole data segment
|
||||
// to the collection list.
|
||||
// It takes a pointer-pointer so it can move the contents, and the caller can change the contents
|
||||
void GCAddRoot(hx::Object **inRoot);
|
||||
void GCRemoveRoot(hx::Object **inRoot);
|
||||
|
||||
|
||||
// This is used internally in hxcpp
|
||||
// It calls InternalNew, and takes care of null-terminating the result
|
||||
char *NewString(int inLen);
|
||||
|
||||
// The concept of 'private' is from the old conservative Gc method.
|
||||
// Now with explicit marking, these functions do the same thing, which is
|
||||
// to allocate some GC memory and optionally copy the 'inData' into those bytes
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void *NewGCBytes(void *inData,int inSize);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void *NewGCPrivate(void *inData,int inSize);
|
||||
|
||||
// Force a collect from the calling thread
|
||||
// Only one thread should call this at a time
|
||||
int InternalCollect(bool inMajor,bool inCompact);
|
||||
|
||||
|
||||
// Disable the garbage collector. It will try to increase its internal buffers to honour extra requests.
|
||||
// If it runs out of memory, it will actually try to do a collect.
|
||||
void InternalEnableGC(bool inEnable);
|
||||
|
||||
// Record that fact that external memory has been allocated and associated with a haxe object
|
||||
// eg. BitmapData. This will help the collector know when to collect
|
||||
void GCChangeManagedMemory(int inDelta, const char *inWhy=0);
|
||||
|
||||
// Haxe threads can center GC free zones, where they can't make GC allocation calls, and should not mess with GC memory.
|
||||
// This means that they do not need to pause while the GC collections happen, and other threads will not
|
||||
// wait for them to "check in" before collecting. The standard runtime makes these calls around OS calls, such as "Sleep"
|
||||
void EnterGCFreeZone();
|
||||
void ExitGCFreeZone();
|
||||
// retuns true if ExitGCFreeZone should be called
|
||||
bool TryGCFreeZone();
|
||||
// retuns true if ExitGCFreeZone was called
|
||||
bool TryExitGCFreeZone();
|
||||
|
||||
class HXCPP_EXTERN_CLASS_ATTRIBUTES AutoGCFreeZone
|
||||
{
|
||||
public:
|
||||
AutoGCFreeZone() : locked(true) { EnterGCFreeZone(); }
|
||||
~AutoGCFreeZone() { if (locked) ExitGCFreeZone(); }
|
||||
|
||||
void close() { if (locked) ExitGCFreeZone(); locked = false; }
|
||||
|
||||
bool locked;
|
||||
};
|
||||
|
||||
|
||||
// Defined in Class.cpp, these function is called from the Gc to start the marking/visiting
|
||||
void MarkClassStatics(hx::MarkContext *__inCtx);
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
void VisitClassStatics(hx::VisitContext *__inCtx);
|
||||
#endif
|
||||
|
||||
|
||||
// Called by haxe/application code to mark allocations.
|
||||
// "Object" allocs will recursively call __Mark
|
||||
inline void MarkAlloc(void *inPtr ,hx::MarkContext *__inCtx);
|
||||
inline void MarkObjectAlloc(hx::Object *inPtr ,hx::MarkContext *__inCtx);
|
||||
|
||||
// Implemented differently for efficiency
|
||||
void MarkObjectArray(hx::Object **inPtr, int inLength, hx::MarkContext *__inCtx);
|
||||
void MarkStringArray(String *inPtr, int inLength, hx::MarkContext *__inCtx);
|
||||
|
||||
// Provide extra debug info to the marking routines
|
||||
#ifdef HXCPP_DEBUG
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void MarkSetMember(const char *inName ,hx::MarkContext *__inCtx);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void MarkPushClass(const char *inName ,hx::MarkContext *__inCtx);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void MarkPopClass(hx::MarkContext *__inCtx);
|
||||
#endif
|
||||
|
||||
|
||||
// Used by runtime if it is being paranoid about pointers. It checks that the pointer is real and alive at last collect.
|
||||
void GCCheckPointer(void *);
|
||||
void GCOnNewPointer(void *);
|
||||
|
||||
|
||||
// Called internally before and GC operations
|
||||
void CommonInitAlloc();
|
||||
|
||||
|
||||
// Threading ...
|
||||
void RegisterNewThread(void *inTopOfStack);
|
||||
void RegisterCurrentThread(void *inTopOfStack);
|
||||
void UnregisterCurrentThread();
|
||||
void GCPrepareMultiThreaded();
|
||||
|
||||
|
||||
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
|
||||
// Inline code tied to the immix implementation
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
#define HX_USE_INLINE_IMMIX_OPERATOR_NEW
|
||||
|
||||
//#define HX_STACK_CTX ::hx::ImmixAllocator *_hx_stack_ctx = hx::gMultiThreadMode ? hx::tlsImmixAllocator : hx::gMainThreadAlloc;
|
||||
|
||||
|
||||
// Each line ast 128 bytes (2^7)
|
||||
#define IMMIX_LINE_BITS 7
|
||||
#define IMMIX_LINE_LEN (1<<IMMIX_LINE_BITS)
|
||||
|
||||
#define HX_GC_REMEMBERED 0x40
|
||||
|
||||
// The size info is stored in the header 8 bits to the right
|
||||
#define IMMIX_ALLOC_SIZE_SHIFT 6
|
||||
|
||||
// Indicates that __Mark must be called recursively
|
||||
#define IMMIX_ALLOC_IS_CONTAINER 0x00800000
|
||||
// String is char16_t type
|
||||
#define HX_GC_STRING_CHAR16_T 0x00200000
|
||||
// String has hash data at end
|
||||
#define HX_GC_STRING_HASH 0x00100000
|
||||
|
||||
#define HX_GC_STRING_HASH_BIT 0x10
|
||||
|
||||
#ifdef HXCPP_BIG_ENDIAN
|
||||
#define HX_GC_STRING_HASH_OFFSET -3
|
||||
#define HX_GC_CONST_ALLOC_MARK_OFFSET -4
|
||||
#define HX_ENDIAN_MARK_ID_BYTE -4
|
||||
#else
|
||||
#define HX_GC_STRING_HASH_OFFSET -2
|
||||
#define HX_GC_CONST_ALLOC_MARK_OFFSET -1
|
||||
#define HX_ENDIAN_MARK_ID_BYTE -1
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
// The gPauseForCollect bits will turn spaceEnd negative, and so force the slow path
|
||||
#ifndef HXCPP_SINGLE_THREADED_APP
|
||||
#define WITH_PAUSE_FOR_COLLECT_FLAG | hx::gPauseForCollect
|
||||
#else
|
||||
#define WITH_PAUSE_FOR_COLLECT_FLAG
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
struct StackContext;
|
||||
|
||||
EXTERN_FAST_TLS_DATA(StackContext, tlsStackContext);
|
||||
|
||||
extern StackContext *gMainThreadContext;
|
||||
|
||||
extern unsigned int gImmixStartFlag[128];
|
||||
extern int gMarkID;
|
||||
extern int gMarkIDWithContainer;
|
||||
extern void BadImmixAlloc();
|
||||
|
||||
|
||||
class ImmixAllocator
|
||||
{
|
||||
public:
|
||||
virtual ~ImmixAllocator() {}
|
||||
virtual void *CallAlloc(int inSize,unsigned int inObjectFlags) = 0;
|
||||
virtual void SetupStackAndCollect(bool inMajor, bool inForceCompact, bool inLocked=false,bool inFreeIsFragged=false) = 0;
|
||||
|
||||
#ifdef HXCPP_GC_NURSERY
|
||||
unsigned char *spaceFirst;
|
||||
unsigned char *spaceOversize;
|
||||
#else
|
||||
int spaceStart;
|
||||
int spaceEnd;
|
||||
#endif
|
||||
unsigned int *allocStartFlags;
|
||||
unsigned char *allocBase;
|
||||
|
||||
|
||||
|
||||
// These allocate the function using the garbage-colleced malloc
|
||||
inline static void *alloc(ImmixAllocator *alloc, size_t inSize, bool inContainer, const char *inName )
|
||||
{
|
||||
#ifdef HXCPP_GC_NURSERY
|
||||
|
||||
unsigned char *buffer = alloc->spaceFirst;
|
||||
unsigned char *end = buffer + (inSize + 4);
|
||||
|
||||
if ( end > alloc->spaceOversize )
|
||||
{
|
||||
// Fall back to external method
|
||||
buffer = (unsigned char *)alloc->CallAlloc(inSize, inContainer ? IMMIX_ALLOC_IS_CONTAINER : 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
alloc->spaceFirst = end;
|
||||
|
||||
if (inContainer)
|
||||
((unsigned int *)buffer)[-1] = inSize | IMMIX_ALLOC_IS_CONTAINER;
|
||||
else
|
||||
((unsigned int *)buffer)[-1] = inSize;
|
||||
}
|
||||
|
||||
#ifdef HXCPP_TELEMETRY
|
||||
__hxt_gc_new((hx::StackContext *)alloc,buffer, inSize, inName);
|
||||
#endif
|
||||
|
||||
return buffer;
|
||||
|
||||
#else
|
||||
#ifndef HXCPP_ALIGN_ALLOC
|
||||
// Inline the fast-path if we can
|
||||
// We know the object can hold a pointer (vtable) and that the size is int-aligned
|
||||
int start = alloc->spaceStart;
|
||||
int end = start + sizeof(int) + inSize;
|
||||
|
||||
if ( end <= alloc->spaceEnd )
|
||||
{
|
||||
alloc->spaceStart = end;
|
||||
|
||||
unsigned int *buffer = (unsigned int *)(alloc->allocBase + start);
|
||||
|
||||
int startRow = start>>IMMIX_LINE_BITS;
|
||||
|
||||
alloc->allocStartFlags[ startRow ] |= gImmixStartFlag[start&127];
|
||||
|
||||
if (inContainer)
|
||||
*buffer++ = (( (end+(IMMIX_LINE_LEN-1))>>IMMIX_LINE_BITS) -startRow) |
|
||||
(inSize<<IMMIX_ALLOC_SIZE_SHIFT) |
|
||||
hx::gMarkIDWithContainer;
|
||||
else
|
||||
*buffer++ = (( (end+(IMMIX_LINE_LEN-1))>>IMMIX_LINE_BITS) -startRow) |
|
||||
(inSize<<IMMIX_ALLOC_SIZE_SHIFT) |
|
||||
hx::gMarkID;
|
||||
|
||||
#if defined(HXCPP_GC_CHECK_POINTER) && defined(HXCPP_GC_DEBUG_ALWAYS_MOVE)
|
||||
hx::GCOnNewPointer(buffer);
|
||||
#endif
|
||||
|
||||
#ifdef HXCPP_TELEMETRY
|
||||
__hxt_gc_new((hx::StackContext *)alloc,buffer, inSize, inName);
|
||||
#endif
|
||||
return buffer;
|
||||
}
|
||||
#endif // HXCPP_ALIGN_ALLOC
|
||||
|
||||
// Fall back to external method
|
||||
void *result = alloc->CallAlloc(inSize, inContainer ? IMMIX_ALLOC_IS_CONTAINER : 0);
|
||||
|
||||
#ifdef HXCPP_TELEMETRY
|
||||
__hxt_gc_new((hx::StackContext *)alloc,result, inSize, inName);
|
||||
#endif
|
||||
|
||||
return result;
|
||||
#endif // HXCPP_GC_NURSERY
|
||||
}
|
||||
};
|
||||
|
||||
typedef ImmixAllocator GcAllocator;
|
||||
typedef ImmixAllocator Ctx;
|
||||
|
||||
|
||||
#ifdef HXCPP_GC_GENERATIONAL
|
||||
#define HX_OBJ_WB_CTX(obj,value,ctx) { \
|
||||
unsigned char &mark = ((unsigned char *)(obj))[ HX_ENDIAN_MARK_ID_BYTE]; \
|
||||
if (mark == hx::gByteMarkID && value && !((unsigned char *)(value))[ HX_ENDIAN_MARK_ID_BYTE ] ) { \
|
||||
mark|=HX_GC_REMEMBERED; \
|
||||
ctx->pushReferrer(obj); \
|
||||
} }
|
||||
#define HX_OBJ_WB_PESSIMISTIC_CTX(obj,ctx) { \
|
||||
unsigned char &mark = ((unsigned char *)(obj))[ HX_ENDIAN_MARK_ID_BYTE]; \
|
||||
if (mark == hx::gByteMarkID) { \
|
||||
mark|=HX_GC_REMEMBERED; \
|
||||
ctx->pushReferrer(obj); \
|
||||
} }
|
||||
// I'm not sure if this will ever trigger...
|
||||
#define HX_OBJ_WB_NEW_MARKED_OBJECT(obj) { \
|
||||
if (((unsigned char *)(obj))[ HX_ENDIAN_MARK_ID_BYTE]==hx::gByteMarkID) hx::NewMarkedObject(obj); \
|
||||
}
|
||||
#else
|
||||
#define HX_OBJ_WB_CTX(obj,value,ctx)
|
||||
#define HX_OBJ_WB_PESSIMISTIC_CTX(obj,ctx)
|
||||
#define HX_OBJ_WB_NEW_MARKED_OBJECT(obj)
|
||||
#endif
|
||||
|
||||
#define HX_OBJ_WB(obj,value) HX_OBJ_WB_CTX(obj,value,_hx_ctx)
|
||||
#define HX_ARRAY_WB(array,index,value) HX_OBJ_WB(array,value)
|
||||
#define HX_OBJ_WB_PESSIMISTIC(obj) HX_OBJ_WB_PESSIMISTIC_CTX(obj,_hx_ctx)
|
||||
#define HX_OBJ_WB_GET(obj,value) HX_OBJ_WB_CTX(obj,value,HX_CTX_GET)
|
||||
#define HX_OBJ_WB_PESSIMISTIC_GET(obj) HX_OBJ_WB_PESSIMISTIC_CTX(obj,HX_CTX_GET)
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES extern unsigned int gPrevMarkIdMask;
|
||||
|
||||
// Called only once it is determined that a new mark is required
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void MarkAllocUnchecked(void *inPtr ,hx::MarkContext *__inCtx);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void MarkObjectAllocUnchecked(hx::Object *inPtr ,hx::MarkContext *__inCtx);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void NewMarkedObject(hx::Object *inPtr);
|
||||
|
||||
inline void MarkAlloc(void *inPtr ,hx::MarkContext *__inCtx)
|
||||
{
|
||||
#ifdef EMSCRIPTEN
|
||||
// Unaligned must be constants...
|
||||
if ( !( ((size_t)inPtr) & 3) )
|
||||
#endif
|
||||
// This will also skip const regions
|
||||
if ( !(((unsigned int *)inPtr)[-1] & gPrevMarkIdMask) )
|
||||
MarkAllocUnchecked(inPtr,__inCtx);
|
||||
}
|
||||
inline void MarkObjectAlloc(hx::Object *inPtr ,hx::MarkContext *__inCtx)
|
||||
{
|
||||
#ifdef EMSCRIPTEN
|
||||
// Unaligned must be constants...
|
||||
if ( !( ((size_t)inPtr) & 3) )
|
||||
#endif
|
||||
// This will also skip const regions
|
||||
if ( !(((unsigned int *)inPtr)[-1] & gPrevMarkIdMask) )
|
||||
MarkObjectAllocUnchecked(inPtr,__inCtx);
|
||||
}
|
||||
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
|
||||
|
||||
|
||||
// It was theoretically possible to redefine the MarkContext arg type (or skip it)
|
||||
// incase the particular GC scheme did not need it. This may take a bit of extra
|
||||
// work to get going again
|
||||
|
||||
#define HX_MARK_ARG __inCtx
|
||||
//#define HX_MARK_ADD_ARG ,__inCtx
|
||||
#define HX_MARK_PARAMS hx::MarkContext *__inCtx
|
||||
//#define HX_MARK_ADD_PARAMS ,hx::MarkContext *__inCtx
|
||||
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
#define HX_VISIT_ARG __inCtx
|
||||
#define HX_VISIT_PARAMS hx::VisitContext *__inCtx
|
||||
#else
|
||||
#define HX_VISIT_ARG
|
||||
#define HX_VISIT_PARAMS
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// These macros add debug to the mark/visit calls if required
|
||||
// They also perform some inline checking to avoid function calls if possible
|
||||
|
||||
|
||||
#ifdef HXCPP_DEBUG
|
||||
|
||||
#define HX_MARK_MEMBER_NAME(x,name) { hx::MarkSetMember(name, __inCtx); hx::MarkMember(x, __inCtx ); }
|
||||
#define HX_MARK_BEGIN_CLASS(x) hx::MarkPushClass(#x, __inCtx );
|
||||
#define HX_MARK_END_CLASS() hx::MarkPopClass(__inCtx );
|
||||
#define HX_MARK_MEMBER(x) { hx::MarkSetMember(0, __inCtx); hx::MarkMember(x, __inCtx ); }
|
||||
#define HX_MARK_MEMBER_ARRAY(x,len) { hx::MarkSetMember(0, __inCtx); hx::MarkMemberArray(x, len, __inCtx ); }
|
||||
|
||||
#else
|
||||
|
||||
#define HX_MARK_MEMBER_NAME(x,name) hx::MarkMember(x, __inCtx )
|
||||
#define HX_MARK_BEGIN_CLASS(x)
|
||||
#define HX_MARK_END_CLASS()
|
||||
#define HX_MARK_MEMBER(x) hx::MarkMember(x, __inCtx )
|
||||
#define HX_MARK_MEMBER_ARRAY(x,len) hx::MarkMemberArray(x, len, __inCtx )
|
||||
|
||||
#endif
|
||||
|
||||
#define HX_MARK_OBJECT(ioPtr) if (ioPtr) hx::MarkObjectAlloc(ioPtr, __inCtx );
|
||||
|
||||
|
||||
|
||||
|
||||
#define HX_MARK_STRING(ioPtr) \
|
||||
if (ioPtr) hx::MarkAlloc((void *)ioPtr, __inCtx );
|
||||
|
||||
#define HX_MARK_ARRAY(ioPtr) { if (ioPtr) hx::MarkAlloc((void *)ioPtr, __inCtx ); }
|
||||
|
||||
|
||||
|
||||
|
||||
#define HX_VISIT_MEMBER_NAME(x,name) hx::VisitMember(x, __inCtx )
|
||||
#define HX_VISIT_MEMBER(x) hx::VisitMember(x, __inCtx )
|
||||
|
||||
#define HX_VISIT_OBJECT(ioPtr) \
|
||||
{ if (ioPtr && !(((unsigned char *)ioPtr)[HX_GC_CONST_ALLOC_MARK_OFFSET] & HX_GC_CONST_ALLOC_MARK_BIT) ) __inCtx->visitObject( (hx::Object **)&ioPtr); }
|
||||
|
||||
#define HX_VISIT_STRING(ioPtr) \
|
||||
if (ioPtr && !(((unsigned char *)ioPtr)[HX_GC_CONST_ALLOC_MARK_OFFSET] & HX_GC_CONST_ALLOC_MARK_BIT) ) __inCtx->visitAlloc((void **)&ioPtr);
|
||||
|
||||
#define HX_VISIT_ARRAY(ioPtr) { if (ioPtr) __inCtx->visitAlloc((void **)&ioPtr); }
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
161
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/GcTypeInference.h
Normal file
161
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/GcTypeInference.h
Normal file
@ -0,0 +1,161 @@
|
||||
#ifndef HX_GC_TYPE_INFERENCE_H
|
||||
#define HX_GC_TYPE_INFERENCE_H
|
||||
|
||||
|
||||
// These templates allow you to call MarkMember(x) or VisitMember(x) and the
|
||||
// compiler will direct the call to the correct function
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
|
||||
template<typename T> inline void MarkMember(T &outT,hx::MarkContext *__inCtx) { }
|
||||
|
||||
template<typename T> inline void MarkMember(hx::ObjectPtr<T> &outT,hx::MarkContext *__inCtx)
|
||||
{
|
||||
HX_MARK_OBJECT(outT.mPtr);
|
||||
}
|
||||
template<> inline void MarkMember(Dynamic &outT,hx::MarkContext *__inCtx)
|
||||
{
|
||||
HX_MARK_OBJECT(outT.mPtr);
|
||||
}
|
||||
template<typename T> inline void MarkMember(Array<T> &outT,hx::MarkContext *__inCtx)
|
||||
{
|
||||
HX_MARK_OBJECT(outT.mPtr);
|
||||
}
|
||||
template<> inline void MarkMember<hx::Object *>(hx::Object *&outT,hx::MarkContext *__inCtx)
|
||||
{
|
||||
HX_MARK_OBJECT(outT);
|
||||
}
|
||||
template<> inline void MarkMember<cpp::Variant>(cpp::Variant &outT,hx::MarkContext *__inCtx)
|
||||
{
|
||||
outT.mark(__inCtx);
|
||||
}
|
||||
template<typename T> inline void MarkMember(hx::Native<T> &outT,hx::MarkContext *__inCtx)
|
||||
{
|
||||
if (outT.ptr)
|
||||
{
|
||||
hx::Object *ptr = outT.ptr->__GetRealObject();
|
||||
HX_MARK_OBJECT(ptr);
|
||||
}
|
||||
}
|
||||
|
||||
template<> inline void MarkMember<int>(int &outT,hx::MarkContext *__inCtx) { }
|
||||
template<> inline void MarkMember<bool>(bool &outT,hx::MarkContext *__inCtx) { }
|
||||
template<> inline void MarkMember<double>(double &outT,hx::MarkContext *__inCtx) { }
|
||||
template<> inline void MarkMember<float>(float &outT,hx::MarkContext *__inCtx) { }
|
||||
template<> inline void MarkMember<String>(String &outT,hx::MarkContext *__inCtx)
|
||||
{
|
||||
HX_MARK_STRING(outT.raw_ptr());
|
||||
}
|
||||
template<> inline void MarkMember<null>(null &outT,hx::MarkContext *__inCtx) { }
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename T> inline void MarkMemberArray(T *,int, hx::MarkContext *__inCtx)
|
||||
{
|
||||
//*(int *)0=0;
|
||||
}
|
||||
template<> inline void MarkMemberArray<String>(String *ioStrings,int inLen,hx::MarkContext *__inCtx)
|
||||
{
|
||||
hx::MarkStringArray(ioStrings,inLen,__inCtx);
|
||||
}
|
||||
template<typename T> inline void MarkMemberArray(hx::ObjectPtr<T> *inObjects, int inLen, hx::MarkContext *__inCtx)
|
||||
{
|
||||
hx::MarkObjectArray( (hx::Object **)inObjects ,inLen,__inCtx);
|
||||
}
|
||||
template<> inline void MarkMemberArray(Dynamic *outT,int inLen, hx::MarkContext *__inCtx)
|
||||
{
|
||||
hx::MarkObjectArray( (hx::Object **)outT ,inLen,__inCtx);
|
||||
}
|
||||
template<> inline void MarkMemberArray(hx::Object **outT,int inLen, hx::MarkContext *__inCtx)
|
||||
{
|
||||
hx::MarkObjectArray( outT ,inLen,__inCtx);
|
||||
}
|
||||
template<typename T> inline void MarkMemberArray(Array<T> *outT,int inLen,hx::MarkContext *__inCtx)
|
||||
{
|
||||
hx::MarkObjectArray( (hx::Object **)outT ,inLen,__inCtx);
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Locate potential GC pointer inside member
|
||||
inline const void *PointerOf( ::Dynamic &d) { return d.mPtr; }
|
||||
inline const void *PointerOf( ::String &s) { return s.raw_ptr(); }
|
||||
template<typename T> inline const void *PointerOf( ::Array<T> &a) { return a.mPtr; }
|
||||
template<typename T> inline const void *PointerOf( ::hx::ObjectPtr<T> &o) { return o.mPtr; }
|
||||
template<typename T> inline const void *PointerOf( ::hx::Native<T> &o)
|
||||
{
|
||||
if (o.ptr)
|
||||
return o.ptr->__GetRealObject();
|
||||
return 0;
|
||||
}
|
||||
|
||||
inline const void *PointerOf(...) { return 0; }
|
||||
|
||||
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
template<typename T> inline void VisitMember(T &outT,hx::VisitContext *__inCtx) { }
|
||||
|
||||
template<typename T> inline void VisitMember(hx::ObjectPtr<T> &outT,hx::VisitContext *__inCtx)
|
||||
{
|
||||
HX_VISIT_OBJECT(outT.mPtr);
|
||||
}
|
||||
template<> inline void VisitMember(Dynamic &outT,hx::VisitContext *__inCtx)
|
||||
{
|
||||
HX_VISIT_OBJECT(outT.mPtr);
|
||||
}
|
||||
template<> inline void VisitMember<hx::Object *>(hx::Object *&outT,hx::VisitContext *__inCtx)
|
||||
{
|
||||
HX_VISIT_OBJECT(outT);
|
||||
}
|
||||
template<typename T> inline void VisitMember(Array<T> &outT,hx::VisitContext *__inCtx)
|
||||
{
|
||||
HX_VISIT_OBJECT(outT.mPtr);
|
||||
}
|
||||
template<> inline void VisitMember(cpp::Variant &outT,hx::VisitContext *__inCtx)
|
||||
{
|
||||
outT.visit(__inCtx);
|
||||
}
|
||||
template<typename T> inline void VisitMember(hx::Native<T> &outT,hx::VisitContext *__inCtx)
|
||||
{
|
||||
if (outT.ptr)
|
||||
{
|
||||
hx::Object *ptr0 = outT.ptr->__GetRealObject();
|
||||
if (ptr0)
|
||||
{
|
||||
hx::Object *ptr1 = ptr0;
|
||||
HX_VISIT_OBJECT(ptr1);
|
||||
size_t delta = ( (char *)ptr1 - (char *)ptr0 );
|
||||
if (delta)
|
||||
outT.ptr = (T)( (char *)outT.ptr + delta );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<> inline void VisitMember<int>(int &outT,hx::VisitContext *__inCtx) { }
|
||||
template<> inline void VisitMember<bool>(bool &outT,hx::VisitContext *__inCtx) { }
|
||||
template<> inline void VisitMember<double>(double &outT,hx::VisitContext *__inCtx) { }
|
||||
template<> inline void VisitMember<float>(float &outT,hx::VisitContext *__inCtx) { }
|
||||
template<> inline void VisitMember<String>(String &outT,hx::VisitContext *__inCtx)
|
||||
{
|
||||
HX_VISIT_STRING(outT.raw_ref());
|
||||
}
|
||||
template<> inline void VisitMember<null>(null &outT,hx::VisitContext *__inCtx) { }
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
// Template used to register and initialise the statics in the one call.
|
||||
// Do nothing...
|
||||
template<typename T> inline T &Static(T &t) { return t; }
|
||||
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
135
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/GenMacro.hx
Normal file
135
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/GenMacro.hx
Normal file
@ -0,0 +1,135 @@
|
||||
/*
|
||||
This file is used to generate Macros.h and DynamicImpl.h.
|
||||
To change the number of "fast" args, you will also need to change numbers in the tpl files.
|
||||
Usage: haxe -x GenMacro.hx
|
||||
*/
|
||||
|
||||
import haxe.Template;
|
||||
#if haxe3
|
||||
import sys.io.File;
|
||||
import sys.io.FileOutput;
|
||||
#else
|
||||
import neko.io.File;
|
||||
import neko.io.FileOutput;
|
||||
#end
|
||||
|
||||
class GenMacro
|
||||
{
|
||||
static var warning =
|
||||
"// ## ## ## ## #### ## ## ## ## ## #### ##\n" +
|
||||
"// ## ## ## ## ## ## ## ### ## ## ### ## ## ##\n" +
|
||||
"// ## ## ## ###### ###### ###### ## ###### ## ### ##\n" +
|
||||
"// ## ## ## ## ## ## ## ## ### ## ## ### ## ## \n" +
|
||||
"// ## ## ## ## ## ## ## ## ## ## ## #### ##\n\n" +
|
||||
"// DO NOT EDIT\n// This file is generated from the .tpl file\n";
|
||||
|
||||
public function new()
|
||||
{
|
||||
var context = { };
|
||||
var params = new Array<Dynamic>();
|
||||
var arr_list = new Array<String>();
|
||||
var arg_list = new Array<String>();
|
||||
var dynamic_arg_list = new Array<String>();
|
||||
var dynamic_in_args = new Array<String>();
|
||||
var dynamic_var_args = new Array<String>();
|
||||
var dynamic_adds = new Array<String>();
|
||||
|
||||
for(arg in 0...27)
|
||||
{
|
||||
if (arg>0)
|
||||
{
|
||||
arr_list.push( "inArgs[" + (arg-1) + "]");
|
||||
arg_list.push( "inArg" + (arg-1));
|
||||
dynamic_arg_list.push("const Dynamic &inArg" + (arg-1) );
|
||||
dynamic_adds.push( "->init(" + (arg-1) + ",inArg" + (arg-1) + ")" );
|
||||
}
|
||||
|
||||
params.push( {
|
||||
ARG : arg,
|
||||
ARR_LIST : arr_list.join(","),
|
||||
DYNAMIC_ARG_LIST : dynamic_arg_list.join(","),
|
||||
ARG_LIST : arg_list.join(","),
|
||||
DYNAMIC_ADDS : dynamic_adds.join("")
|
||||
} );
|
||||
}
|
||||
|
||||
var locals = new Array<Dynamic>();
|
||||
var jumboLocals = new Array<Dynamic>();
|
||||
var marks = new Array<String>();
|
||||
var visits = new Array<String>();
|
||||
var type_vars = new Array<String>();
|
||||
var type_args = new Array<String>();
|
||||
var construct_args = new Array<String>();
|
||||
var construct_vars = new Array<String>();
|
||||
for(arg in 1...62)
|
||||
{
|
||||
var vid = arg-1;
|
||||
if (vid>=0)
|
||||
{
|
||||
marks.push( "HX_MARK_MEMBER(v" + vid +");" );
|
||||
visits.push( "HX_VISIT_MEMBER(v" + vid +");" );
|
||||
type_args.push( "t" + vid +",v" + vid );
|
||||
type_vars.push( "t" + vid +" v" + vid );
|
||||
construct_args.push( "t" + vid +" __" + vid );
|
||||
construct_vars.push( "v" + vid +"(__" + vid + ")" );
|
||||
}
|
||||
|
||||
var local = {
|
||||
ARG : arg,
|
||||
MARKS : marks.join(" "),
|
||||
VISITS : visits.join(" "),
|
||||
TYPE_VARS : type_vars.join(","),
|
||||
TYPE_ARGS : type_args.join(","),
|
||||
TYPE_DECL : type_vars.join(";"),
|
||||
CONSTRUCT_VARS : construct_vars.join(","),
|
||||
CONSTRUCT_ARGS : construct_args.join(",")
|
||||
};
|
||||
if (arg<20)
|
||||
locals.push(local);
|
||||
else
|
||||
jumboLocals.push(local);
|
||||
}
|
||||
|
||||
Reflect.setField(context, "PARAMS", params);
|
||||
Reflect.setField(context, "LOCALS", locals);
|
||||
Reflect.setField(context, "NS", "::");
|
||||
Reflect.setField(context, "hxNS", " ::hx::");
|
||||
|
||||
var fixed = File.getContent("MacrosFixed.h");
|
||||
fixed = fixed.split("
|
||||
").join("");
|
||||
var fileContents:String = File.getContent("Macros.tpl");
|
||||
fileContents = fileContents.split("
|
||||
").join("");
|
||||
|
||||
var template:Template = new Template(fileContents);
|
||||
var result:String = template.execute(context);
|
||||
var fileOutput:FileOutput = File.write("Macros.h", true);
|
||||
fileOutput.writeString(warning);
|
||||
fileOutput.writeString(fixed);
|
||||
fileOutput.writeString(result);
|
||||
fileOutput.close();
|
||||
|
||||
var fileContents:String = File.getContent("MacrosJumbo.tpl");
|
||||
fileContents = fileContents.split("
|
||||
").join("");
|
||||
var template:Template = new Template(fileContents);
|
||||
Reflect.setField(context, "LOCALS", jumboLocals);
|
||||
var result:String = template.execute(context);
|
||||
var fileOutput:FileOutput = File.write("MacrosJumbo.h", true);
|
||||
fileOutput.writeString(warning);
|
||||
fileOutput.writeString(result);
|
||||
fileOutput.close();
|
||||
|
||||
|
||||
|
||||
var fileContents:String = File.getContent("DynamicImpl.tpl");
|
||||
fileContents = fileContents.split("
|
||||
").join("");
|
||||
var template:Template = new Template(fileContents);
|
||||
var result:String = template.execute(context);
|
||||
var fileOutput:FileOutput = File.write("DynamicImpl.h", true);
|
||||
fileOutput.writeString(warning);
|
||||
fileOutput.writeString(result);
|
||||
fileOutput.close();
|
||||
|
||||
@ -0,0 +1,3 @@
|
||||
#ifndef HXCPP_HEADER_VERSION
|
||||
#define HXCPP_HEADER_VERSION 330
|
||||
#endif
|
||||
114
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/HxcppMain.h
Normal file
114
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/HxcppMain.h
Normal file
@ -0,0 +1,114 @@
|
||||
#ifdef HXCPP_DLL_IMPORT
|
||||
|
||||
extern "C" EXPORT_EXTRA void __main__()
|
||||
{
|
||||
__boot_all();
|
||||
__hxcpp_main();
|
||||
}
|
||||
|
||||
#elif defined(HX_ANDROID) && !defined(HXCPP_EXE_LINK)
|
||||
|
||||
// Java Main....
|
||||
#include <jni.h>
|
||||
#include <hx/Thread.h>
|
||||
#include <android/log.h>
|
||||
|
||||
extern "C" EXPORT_EXTRA void hxcpp_main()
|
||||
{
|
||||
HX_TOP_OF_STACK
|
||||
try
|
||||
{
|
||||
hx::Boot();
|
||||
__boot_all();
|
||||
__hxcpp_main();
|
||||
}
|
||||
catch (Dynamic e)
|
||||
{
|
||||
__hx_dump_stack();
|
||||
__android_log_print(ANDROID_LOG_ERROR, "Exception", "%s", e==null() ? "null" : e->toString().__CStr());
|
||||
}
|
||||
hx::SetTopOfStack((int *)0,true);
|
||||
}
|
||||
|
||||
extern "C" EXPORT_EXTRA JNIEXPORT void JNICALL Java_org_haxe_HXCPP_main(JNIEnv * env)
|
||||
{
|
||||
hxcpp_main();
|
||||
}
|
||||
|
||||
#elif defined(HX_WINRT) && defined(__cplusplus_winrt)
|
||||
|
||||
#include <Roapi.h>
|
||||
[ Platform::MTAThread ]
|
||||
int main(Platform::Array<Platform::String^>^)
|
||||
{
|
||||
HX_TOP_OF_STACK
|
||||
RoInitialize(RO_INIT_MULTITHREADED);
|
||||
hx::Boot();
|
||||
try
|
||||
{
|
||||
__boot_all();
|
||||
__hxcpp_main();
|
||||
}
|
||||
catch (Dynamic e)
|
||||
{
|
||||
__hx_dump_stack();
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
#if defined(HX_WIN_MAIN) && !defined(_WINDOWS_)
|
||||
#ifndef HINSTANCE
|
||||
#define HINSTANCE void*
|
||||
#endif
|
||||
#ifndef LPSTR
|
||||
#define LPSTR char*
|
||||
#endif
|
||||
extern "C" int __stdcall MessageBoxA(void *,const char *,const char *,int);
|
||||
#endif
|
||||
|
||||
|
||||
#if defined(TIZEN)
|
||||
extern "C" EXPORT_EXTRA int OspMain (int argc, char* pArgv[])
|
||||
{
|
||||
#elif defined(HX_WIN_MAIN)
|
||||
int __stdcall WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
|
||||
{
|
||||
#else
|
||||
|
||||
extern int _hxcpp_argc;
|
||||
extern char **_hxcpp_argv;
|
||||
int main(int argc,char **argv)
|
||||
{
|
||||
_hxcpp_argc = argc;
|
||||
_hxcpp_argv = argv;
|
||||
#endif
|
||||
HX_TOP_OF_STACK
|
||||
hx::Boot();
|
||||
try
|
||||
{
|
||||
__boot_all();
|
||||
__hxcpp_main();
|
||||
}
|
||||
catch (Dynamic e)
|
||||
{
|
||||
__hx_dump_stack();
|
||||
#ifdef HX_WIN_MAIN
|
||||
MessageBoxA(0, e==null() ? "null" : e->toString().__CStr(), "Error", 0);
|
||||
#else
|
||||
printf("Error : %s\n",e==null() ? "null" : e->toString().__CStr());
|
||||
#endif
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#if 0
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
9
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/IndexRef.h
Normal file
9
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/IndexRef.h
Normal file
@ -0,0 +1,9 @@
|
||||
#ifndef HX_INDEX_REF_H
|
||||
#define HX_INDEX_REF_H
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
65
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Interface.h
Normal file
65
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Interface.h
Normal file
@ -0,0 +1,65 @@
|
||||
#ifndef HX_INTERFACE_H
|
||||
#define HX_INTERFACE_H
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void InvalidInterface();
|
||||
|
||||
template<typename T>
|
||||
inline T interface_cast(void *ptr)
|
||||
{
|
||||
#if defined(HXCPP_GC_CHECK_POINTER) || defined(HXCPP_DEBUG)
|
||||
if (!ptr) hx::InvalidInterface();
|
||||
#endif
|
||||
return static_cast<T>(ptr);
|
||||
}
|
||||
|
||||
#if (HXCPP_API_LEVEL >= 330)
|
||||
template<typename T>
|
||||
inline T interface_check(T inObj,int interfaceId)
|
||||
{
|
||||
Dynamic d(inObj);
|
||||
if ( !d.mPtr || !d->_hx_getInterface(interfaceId))
|
||||
hx::BadCast();
|
||||
return inObj;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#if (HXCPP_API_LEVEL < 330)
|
||||
class HXCPP_EXTERN_CLASS_ATTRIBUTES Interface : public hx::Object
|
||||
{
|
||||
public:
|
||||
// The following functions make use of : hx::Object *__GetRealObject();
|
||||
|
||||
void __Mark(hx::MarkContext *__inCtx);
|
||||
hx::Object *__ToInterface(const hx::type_info &);
|
||||
int __GetType() const;
|
||||
void *__GetHandle() const;
|
||||
hx::FieldRef __FieldRef(const ::String &);
|
||||
::String __ToString() const;
|
||||
int __ToInt() const;
|
||||
double __ToDouble() const;
|
||||
const char * __CStr() const;
|
||||
::String toString();
|
||||
bool __HasField(const ::String &);
|
||||
hx::Val __Field(const ::String &, hx::PropertyAccess inCallProp);
|
||||
Dynamic __IField(int);
|
||||
hx::Val __SetField(const ::String &,const hx::Val &, hx::PropertyAccess inCallProp);
|
||||
void __SetThis(Dynamic);
|
||||
void __GetFields(Array< ::String> &);
|
||||
hx::Class __GetClass() const;
|
||||
int __Compare(const hx::Object *) const;
|
||||
|
||||
/* No need for enum options - not in interfaces */
|
||||
/* No need for array options - not in interfaces */
|
||||
/* No need for function options - not in interfaces */
|
||||
};
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
475
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/LessThanEq.h
Normal file
475
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/LessThanEq.h
Normal file
@ -0,0 +1,475 @@
|
||||
#ifndef HX_LESS_THAN_EQ_INCLUDED
|
||||
#define HX_LESS_THAN_EQ_INCLUDED
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
enum {
|
||||
CompareAsInt,
|
||||
CompareAsInt64,
|
||||
CompareAsDouble,
|
||||
CompareAsString,
|
||||
CompareAsDynamic,
|
||||
};
|
||||
|
||||
|
||||
template <typename T>
|
||||
struct CompareTraits
|
||||
{
|
||||
enum { type = (int)CompareAsDynamic };
|
||||
|
||||
inline static int toInt(Dynamic inValue) { return inValue; }
|
||||
inline static double toDouble(Dynamic inValue) { return inValue; }
|
||||
inline static cpp::Int64 toInt64(Dynamic inValue) { return inValue; }
|
||||
inline static String toString(Dynamic inValue) { return inValue; }
|
||||
inline static hx::Object *toObject(Dynamic inValue) { return inValue.mPtr; }
|
||||
inline static int getDynamicCompareType(const Dynamic &inValue)
|
||||
{
|
||||
if (!inValue.mPtr)
|
||||
return CompareAsDynamic;
|
||||
switch(inValue->__GetType())
|
||||
{
|
||||
case vtInt: case vtBool: return CompareAsInt;
|
||||
case vtInt64: return CompareAsInt64;
|
||||
case vtFloat: return CompareAsDouble;
|
||||
case vtString: return CompareAsString;
|
||||
default: return CompareAsDynamic;
|
||||
}
|
||||
}
|
||||
inline static bool isNull(const Dynamic &inValue) { return !inValue.mPtr; }
|
||||
};
|
||||
|
||||
|
||||
|
||||
template <>
|
||||
struct CompareTraits<null>
|
||||
{
|
||||
enum { type = (int)CompareAsDynamic };
|
||||
|
||||
inline static int toInt(const null &inValue) { return 0; }
|
||||
inline static double toDouble(const null & inValue) { return 0; }
|
||||
inline static cpp::Int64 toInt64(const null & inValue) { return 0; }
|
||||
inline static String toString(const null & inValue) { return String(); }
|
||||
inline static hx::Object *toObject(const null & inValue) { return 0; }
|
||||
|
||||
inline static int getDynamicCompareType(const null &) { return type; }
|
||||
inline static bool isNull(const null &) { return true; }
|
||||
};
|
||||
|
||||
|
||||
|
||||
template <>
|
||||
struct CompareTraits<signed int>
|
||||
{
|
||||
enum { type = (int)CompareAsInt };
|
||||
|
||||
inline static int toInt(int inValue) { return inValue; }
|
||||
inline static double toDouble(int inValue) { return inValue; }
|
||||
inline static cpp::Int64 toInt64(int inValue) { return inValue; }
|
||||
inline static String toString(int inValue) { return String(); }
|
||||
inline static hx::Object *toObject(int inValue) { return 0; }
|
||||
|
||||
inline static int getDynamicCompareType(int) { return type; }
|
||||
inline static bool isNull(int) { return false; }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct CompareTraits<unsigned int>
|
||||
{
|
||||
enum { type = (int)CompareAsInt };
|
||||
|
||||
// Return value is unsigned ...
|
||||
inline static unsigned int toInt(unsigned int inValue) { return inValue; }
|
||||
inline static double toDouble(unsigned int inValue) { return inValue; }
|
||||
inline static cpp::Int64 toInt64(unsigned int inValue) { return inValue; }
|
||||
inline static String toString(unsigned int inValue) { return String(); }
|
||||
inline static hx::Object *toObject(unsigned int inValue) { return 0; }
|
||||
|
||||
inline static int getDynamicCompareType(int) { return type; }
|
||||
inline static bool isNull(int) { return false; }
|
||||
};
|
||||
|
||||
template <> struct CompareTraits<signed short> : public CompareTraits<int> { };
|
||||
template <> struct CompareTraits<unsigned short> : public CompareTraits<int> { };
|
||||
template <> struct CompareTraits<signed char> : public CompareTraits<int> { };
|
||||
template <> struct CompareTraits<unsigned char> : public CompareTraits<int> { };
|
||||
template <> struct CompareTraits<char> : public CompareTraits<int> { };
|
||||
template <> struct CompareTraits<wchar_t> : public CompareTraits<int> { };
|
||||
#if __cplusplus >= 201103L || defined(KORE_MICROSOFT)
|
||||
template <> struct CompareTraits<char16_t> : public CompareTraits<int> { };
|
||||
#endif
|
||||
|
||||
|
||||
template <>
|
||||
struct CompareTraits<double>
|
||||
{
|
||||
enum { type = (int)CompareAsDouble };
|
||||
|
||||
inline static int toInt(double inValue) { return inValue; }
|
||||
inline static double toDouble(double inValue) { return inValue; }
|
||||
inline static cpp::Int64 toInt64(double inValue) { return inValue; }
|
||||
inline static String toString(double inValue) { return String(); }
|
||||
inline static hx::Object *toObject(double inValue) { return 0; }
|
||||
|
||||
inline static int getDynamicCompareType(const double &) { return type; }
|
||||
inline static bool isNull(const double &) { return false; }
|
||||
};
|
||||
template <> struct CompareTraits<float> : public CompareTraits<double> { };
|
||||
|
||||
|
||||
|
||||
template <>
|
||||
struct CompareTraits<cpp::Int64>
|
||||
{
|
||||
enum { type = (int)CompareAsInt64 };
|
||||
|
||||
inline static int toInt(cpp::Int64 inValue) { return (int)inValue; }
|
||||
inline static double toDouble(cpp::Int64 inValue) { return inValue; }
|
||||
inline static cpp::Int64 toInt64(cpp::Int64 inValue) { return inValue; }
|
||||
inline static String toString(cpp::Int64 inValue) { return String(); }
|
||||
inline static hx::Object *toObject(cpp::Int64 inValue) { return 0; }
|
||||
|
||||
inline static int getDynamicCompareType(cpp::Int64) { return type; }
|
||||
inline static bool isNull(cpp::Int64) { return false; }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct CompareTraits<cpp::UInt64>
|
||||
{
|
||||
enum { type = (int)CompareAsInt64 };
|
||||
|
||||
inline static int toInt(cpp::UInt64 inValue) { return (int)inValue; }
|
||||
inline static double toDouble(cpp::UInt64 inValue) { return inValue; }
|
||||
// Return value is unsigned ...
|
||||
inline static cpp::UInt64 toInt64(cpp::UInt64 inValue) { return inValue; }
|
||||
inline static String toString(cpp::UInt64 inValue) { return String(); }
|
||||
inline static hx::Object *toObject(cpp::UInt64 inValue) { return 0; }
|
||||
|
||||
inline static int getDynamicCompareType(cpp::UInt64) { return type; }
|
||||
inline static bool isNull(cpp::UInt64) { return false; }
|
||||
};
|
||||
|
||||
|
||||
template <>
|
||||
struct CompareTraits< String >
|
||||
{
|
||||
enum { type = (int)CompareAsString };
|
||||
|
||||
inline static int toInt(const String &) { return 0; }
|
||||
inline static double toDouble(const String &) { return 0; }
|
||||
inline static cpp::Int64 toInt64(const String &) { return 0; }
|
||||
inline static String toString(const String &inValue ) { return inValue; }
|
||||
inline static hx::Object *toObject(const String &inValue) { return Dynamic(inValue).mPtr; }
|
||||
|
||||
inline static int getDynamicCompareType(const String &) { return type; }
|
||||
inline static bool isNull(const String &inValue) { return !inValue.raw_ptr(); }
|
||||
};
|
||||
|
||||
|
||||
template <>
|
||||
struct CompareTraits< cpp::Variant >
|
||||
{
|
||||
enum { type = (int)CompareAsDynamic };
|
||||
|
||||
// Might ne a
|
||||
inline static int toInt(const cpp::Variant &inValue) { return inValue; }
|
||||
inline static double toDouble(const cpp::Variant &inValue) { return inValue; }
|
||||
inline static cpp::Int64 toInt64(const cpp::Variant &inValue) { return inValue; }
|
||||
inline static String toString(const cpp::Variant &inValue ) { return inValue; }
|
||||
inline static hx::Object *toObject(const cpp::Variant &inValue) {
|
||||
if (inValue.type==cpp::Variant::typeObject)
|
||||
return inValue.valObject;
|
||||
return 0;
|
||||
}
|
||||
|
||||
inline static int getDynamicCompareType(const cpp::Variant &inValue)
|
||||
{
|
||||
switch(inValue.type)
|
||||
{
|
||||
case cpp::Variant::typeInt: case cpp::Variant::typeBool: return CompareAsInt;
|
||||
case cpp::Variant::typeInt64: return CompareAsInt64;
|
||||
case cpp::Variant::typeDouble: return CompareAsDouble;
|
||||
case cpp::Variant::typeString: return CompareAsString;
|
||||
|
||||
case cpp::Variant::typeObject:
|
||||
{
|
||||
if (!inValue.valObject)
|
||||
return CompareAsDynamic;
|
||||
switch(inValue.valObject->__GetType())
|
||||
{
|
||||
case vtInt: case vtBool: return CompareAsInt;
|
||||
case vtInt64: return CompareAsInt64;
|
||||
case vtFloat: return CompareAsDouble;
|
||||
case vtString: return CompareAsString;
|
||||
default: return CompareAsDynamic;
|
||||
}
|
||||
}
|
||||
default:
|
||||
return CompareAsDynamic;
|
||||
}
|
||||
}
|
||||
inline static bool isNull(const cpp::Variant &inValue) { return inValue.isNull(); }
|
||||
};
|
||||
|
||||
|
||||
|
||||
template <typename T>
|
||||
struct CompareTraits< cpp::Pointer<T> >
|
||||
{
|
||||
enum { type = (int)CompareAsDynamic };
|
||||
|
||||
inline static int toInt(Dynamic inValue) { return inValue; }
|
||||
inline static double toDouble(Dynamic inValue) { return inValue; }
|
||||
inline static cpp::Int64 toInt64(Dynamic inValue) { return inValue; }
|
||||
inline static String toString(Dynamic inValue) { return inValue; }
|
||||
inline static hx::Object *toObject(Dynamic inValue) { return inValue.mPtr; }
|
||||
inline static int getDynamicCompareType(const Dynamic &inValue)
|
||||
{
|
||||
return CompareAsDynamic;
|
||||
}
|
||||
inline static bool isNull(const cpp::Pointer<T> &inValue) { return !inValue.ptr; }
|
||||
};
|
||||
|
||||
|
||||
template <typename T>
|
||||
struct CompareTraits< T * >
|
||||
{
|
||||
enum { type = (int)CompareAsInt64 };
|
||||
|
||||
inline static int toInt(T * inValue) { return 0; }
|
||||
inline static double toDouble(T * inValue) { return 0; }
|
||||
inline static cpp::Int64 toInt64(T * inValue) { return (cpp::Int64)inValue; }
|
||||
inline static String toString(T * inValue) { return String(); }
|
||||
inline static hx::Object *toObject(T * inValue) { return 0; }
|
||||
inline static int getDynamicCompareType(T * inValue)
|
||||
{
|
||||
return CompareAsInt64;
|
||||
}
|
||||
inline static bool isNull(T *inValue) { return !inValue; }
|
||||
};
|
||||
|
||||
|
||||
template<typename T1>
|
||||
hx::Object *GetExistingObject(const T1 &v1)
|
||||
{
|
||||
typedef CompareTraits<T1> traits1;
|
||||
return traits1::toObject(v1);
|
||||
}
|
||||
|
||||
|
||||
template<typename T1>
|
||||
bool IsNull(const T1 &v1)
|
||||
{
|
||||
typedef CompareTraits<T1> traits1;
|
||||
return traits1::isNull(v1);
|
||||
}
|
||||
|
||||
template<typename T1>
|
||||
bool IsNotNull(const T1 &v1)
|
||||
{
|
||||
typedef CompareTraits<T1> traits1;
|
||||
return !traits1::isNull(v1);
|
||||
}
|
||||
|
||||
template<bool LESS, bool EQ, typename T1, typename T2>
|
||||
inline bool TestLessEq(const T1 &v1, const T2 &v2)
|
||||
{
|
||||
typedef CompareTraits<T1> traits1;
|
||||
typedef CompareTraits<T2> traits2;
|
||||
|
||||
if (traits1::type==(int)CompareAsInt && traits2::type==(int)CompareAsInt)
|
||||
{
|
||||
return LESS ? ( EQ ? traits1::toInt(v1) <= traits2::toInt(v2) :
|
||||
traits1::toInt(v1) < traits2::toInt(v2) ) :
|
||||
( EQ ? traits1::toInt(v1) == traits2::toInt(v2) :
|
||||
traits1::toInt(v1) != traits2::toInt(v2) );
|
||||
}
|
||||
else if (traits1::type<=(int)CompareAsInt64 && traits2::type<=(int)CompareAsInt64)
|
||||
{
|
||||
return LESS ? ( EQ ? traits1::toInt64(v1) <= traits2::toInt64(v2) :
|
||||
traits1::toInt64(v1) < traits2::toInt64(v2) ) :
|
||||
( EQ ? traits1::toInt64(v1) == traits2::toInt64(v2) :
|
||||
traits1::toInt64(v1) != traits2::toInt64(v2) );
|
||||
}
|
||||
else if (traits1::type<=(int)CompareAsDouble && traits2::type<=(int)CompareAsDouble)
|
||||
{
|
||||
return LESS ? ( EQ ? traits1::toDouble(v1) <= traits2::toDouble(v2) :
|
||||
traits1::toDouble(v1) < traits2::toDouble(v2) ) :
|
||||
( EQ ? traits1::toDouble(v1) == traits2::toDouble(v2) :
|
||||
traits1::toDouble(v1) != traits2::toDouble(v2) );
|
||||
}
|
||||
else if (traits1::type==(int)CompareAsString && traits2::type==(int)CompareAsString)
|
||||
{
|
||||
return LESS ? ( EQ ? traits1::toString(v1) <= traits2::toString(v2) :
|
||||
traits1::toString(v1) < traits2::toString(v2) ) :
|
||||
( EQ ? traits1::toString(v1) == traits2::toString(v2) :
|
||||
traits1::toString(v1) != traits2::toString(v2) );
|
||||
}
|
||||
else if (traits1::type<=(int)CompareAsString && traits2::type<=(int)CompareAsString)
|
||||
{
|
||||
// String with a number...
|
||||
return false;
|
||||
}
|
||||
else if (traits1::type==(int)CompareAsString || traits2::type==(int)CompareAsString)
|
||||
{
|
||||
// String with a object...
|
||||
return LESS ? ( EQ ? traits1::toString(v1) <= traits2::toString(v2) :
|
||||
traits1::toString(v1) < traits2::toString(v2) ) :
|
||||
( EQ ? traits1::toString(v1) == traits2::toString(v2) :
|
||||
traits1::toString(v1) != traits2::toString(v2) );
|
||||
}
|
||||
else if (traits1::type<=(int)CompareAsDouble || traits2::type<=(int)CompareAsDouble)
|
||||
{
|
||||
// numeric with a object...
|
||||
|
||||
// null can only be equal to null...
|
||||
bool n1 = traits1::isNull(v1);
|
||||
bool n2 = traits2::isNull(v2);
|
||||
if (n1 || n2)
|
||||
return EQ ? n1==n2 : !LESS && n1!=n2/* false,false = not equal*/;
|
||||
|
||||
return LESS ? ( EQ ? traits1::toDouble(v1) <= traits2::toDouble(v2) :
|
||||
traits1::toDouble(v1) < traits2::toDouble(v2) ) :
|
||||
( EQ ? traits1::toDouble(v1) == traits2::toDouble(v2) :
|
||||
traits1::toDouble(v1) != traits2::toDouble(v2) );
|
||||
}
|
||||
else
|
||||
{
|
||||
// Dynamic compare.
|
||||
// This time, one or both types are calculated at run time
|
||||
|
||||
// Check null/not null compare
|
||||
bool n1 = traits1::isNull(v1);
|
||||
bool n2 = traits2::isNull(v2);
|
||||
if (n1 || n2)
|
||||
return EQ ? n1==n2 : !LESS && n1!=n2 /* false,false = not equal*/;
|
||||
|
||||
int t1 = traits1::getDynamicCompareType(v1);
|
||||
int t2 = traits2::getDynamicCompareType(v2);
|
||||
|
||||
if (t1==(int)CompareAsInt && t2==(int)CompareAsInt)
|
||||
{
|
||||
return LESS ? ( EQ ? traits1::toInt(v1) <= traits2::toInt(v2) :
|
||||
traits1::toInt(v1) < traits2::toInt(v2) ) :
|
||||
( EQ ? traits1::toInt(v1) == traits2::toInt(v2) :
|
||||
traits1::toInt(v1) != traits2::toInt(v2) );
|
||||
}
|
||||
else if (t1<=(int)CompareAsInt64 && t2<=(int)CompareAsInt64)
|
||||
{
|
||||
return LESS ? ( EQ ? traits1::toInt64(v1) <= traits2::toInt64(v2) :
|
||||
traits1::toInt64(v1) < traits2::toInt64(v2) ) :
|
||||
( EQ ? traits1::toInt64(v1) == traits2::toInt64(v2) :
|
||||
traits1::toInt64(v1) != traits2::toInt64(v2) );
|
||||
}
|
||||
else if (t1<=(int)CompareAsDouble && t2<=(int)CompareAsDouble)
|
||||
{
|
||||
return LESS ? ( EQ ? traits1::toDouble(v1) <= traits2::toDouble(v2) :
|
||||
traits1::toDouble(v1) < traits2::toDouble(v2) ) :
|
||||
( EQ ? traits1::toDouble(v1) == traits2::toDouble(v2) :
|
||||
traits1::toDouble(v1) != traits2::toDouble(v2) );
|
||||
}
|
||||
else if (t1==(int)CompareAsString && t2==(int)CompareAsString)
|
||||
{
|
||||
return LESS ? ( EQ ? traits1::toString(v1) <= traits2::toString(v2) :
|
||||
traits1::toString(v1) < traits2::toString(v2) ) :
|
||||
( EQ ? traits1::toString(v1) == traits2::toString(v2) :
|
||||
traits1::toString(v1) != traits2::toString(v2) );
|
||||
}
|
||||
else if (t1<=(int)CompareAsString && t2<=(int)CompareAsString)
|
||||
{
|
||||
// String with a number...
|
||||
return false;
|
||||
}
|
||||
else if (t1==(int)CompareAsString || t2==(int)CompareAsString)
|
||||
{
|
||||
// String with a object...
|
||||
return LESS ? ( EQ ? traits1::toString(v1) <= traits2::toString(v2) :
|
||||
traits1::toString(v1) < traits2::toString(v2) ) :
|
||||
( EQ ? traits1::toString(v1) == traits2::toString(v2) :
|
||||
traits1::toString(v1) != traits2::toString(v2) );
|
||||
}
|
||||
else if (t1<=(int)CompareAsDouble || t2<=(int)CompareAsDouble)
|
||||
{
|
||||
// numeric with a object only works for not-equal
|
||||
return !LESS && !EQ;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Object with Object
|
||||
hx::Object *o1 = traits1::toObject(v1);
|
||||
hx::Object *o2 = traits2::toObject(v2);
|
||||
|
||||
int diff = o1->__Compare(o2);
|
||||
return LESS ? ( EQ ? diff <= 0 :
|
||||
diff < 0 ) :
|
||||
( EQ ? diff == 0 :
|
||||
diff != 0 );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<typename T1, typename T2>
|
||||
bool IsEq(const T1 &v1, const T2 &v2) { return TestLessEq<false,true,T1,T2>(v1,v2); }
|
||||
|
||||
template<typename T1, typename T2>
|
||||
bool IsNotEq(const T1 &v1, const T2 &v2) { return TestLessEq<false,false,T1,T2>(v1,v2); }
|
||||
|
||||
template<typename T1, typename T2>
|
||||
bool IsLess(const T1 &v1, const T2 &v2) { return TestLessEq<true,false,T1,T2>(v1,v2); }
|
||||
|
||||
template<typename T1, typename T2>
|
||||
bool IsLessEq(const T1 &v1, const T2 &v2) { return TestLessEq<true,true,T1,T2>(v1,v2); }
|
||||
|
||||
|
||||
template<typename T1, typename T2>
|
||||
bool IsGreater(const T1 &v1, const T2 &v2) { return TestLessEq<true,false,T2,T1>(v2,v1); }
|
||||
|
||||
template<typename T1, typename T2>
|
||||
bool IsGreaterEq(const T1 &v1, const T2 &v2) { return TestLessEq<true,true,T2,T1>(v2,v1); }
|
||||
|
||||
|
||||
|
||||
template<typename T1, typename T2>
|
||||
bool IsPointerEq(const T1 &v1, const T2 &v2)
|
||||
{
|
||||
return GetExistingObject(v1) == GetExistingObject(v2);
|
||||
}
|
||||
|
||||
template<typename T1, typename T2>
|
||||
bool IsPointerNotEq(const T1 &v1, const T2 &v2)
|
||||
{
|
||||
return GetExistingObject(v1) != GetExistingObject(v2);
|
||||
}
|
||||
|
||||
|
||||
template<typename T1, typename T2>
|
||||
bool IsInstanceEq(const T1 &v1, const T2 &v2)
|
||||
{
|
||||
hx::Object *p1 = GetExistingObject(v1);
|
||||
hx::Object *p2 = GetExistingObject(v2);
|
||||
if (p1==p2)
|
||||
return true;
|
||||
if (!p1 || !p2)
|
||||
return false;
|
||||
return !p1->__Compare(p2);
|
||||
}
|
||||
|
||||
template<typename T1, typename T2>
|
||||
bool IsInstanceNotEq(const T1 &v1, const T2 &v2)
|
||||
{
|
||||
hx::Object *p1 = GetExistingObject(v1);
|
||||
hx::Object *p2 = GetExistingObject(v2);
|
||||
if (p1==p2)
|
||||
return false;
|
||||
if (!p1 || !p2)
|
||||
return true;
|
||||
return p1->__Compare(p2);
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
1138
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Macros.h
Normal file
1138
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Macros.h
Normal file
File diff suppressed because it is too large
Load Diff
195
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Macros.tpl
Normal file
195
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Macros.tpl
Normal file
@ -0,0 +1,195 @@
|
||||
#ifndef HX_MACROS_H
|
||||
#define HX_MACROS_H
|
||||
|
||||
// --- Functions and their parameters ----
|
||||
|
||||
::foreach PARAMS::
|
||||
#define HX_ARR_LIST::ARG:: ::ARR_LIST::::end::
|
||||
|
||||
::foreach PARAMS::
|
||||
#define HX_DYNAMIC_ARG_LIST::ARG:: ::DYNAMIC_ARG_LIST::::end::
|
||||
|
||||
::foreach PARAMS::
|
||||
#define HX_ARG_LIST::ARG:: ::ARG_LIST::::end::
|
||||
|
||||
#define HX_DEFINE_DYNAMIC_FUNC0(class,func,ret) \
|
||||
static ::NS::Dynamic __##class##func(::hxNS::Object *inObj) \
|
||||
{ \
|
||||
ret reinterpret_cast<class *>(inObj)->func(); return ::NS::Dynamic(); \
|
||||
}; \
|
||||
::NS::Dynamic class::func##_dyn() \
|
||||
{\
|
||||
return ::hxNS::CreateMemberFunction0(#func,this,__##class##func); \
|
||||
}
|
||||
|
||||
|
||||
#define HX_DEFINE_DYNAMIC_FUNC(class,N,func,ret,array_list,dynamic_arg_list,arg_list) \
|
||||
static ::NS::Dynamic __##class##func(::hxNS::Object *inObj, dynamic_arg_list) \
|
||||
{ \
|
||||
ret reinterpret_cast<class *>(inObj)->func(arg_list); return ::NS::Dynamic(); \
|
||||
}; \
|
||||
::NS::Dynamic class::func##_dyn() \
|
||||
{\
|
||||
return ::hxNS::CreateMemberFunction##N(#func,this,__##class##func); \
|
||||
}
|
||||
|
||||
|
||||
#define HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,N,func,ret,array_list,dynamic_arg_list,arg_list) \
|
||||
static ::NS::Dynamic __##class##func(::hxNS::Object *inObj, const Array< ::NS::Dynamic> &inArgs) \
|
||||
{ \
|
||||
ret reinterpret_cast<class *>(inObj)->func(array_list); return ::NS::Dynamic(); \
|
||||
}; \
|
||||
::NS::Dynamic class::func##_dyn() \
|
||||
{\
|
||||
return ::hxNS::CreateMemberFunctionVar(#func,this,__##class##func,N); \
|
||||
}
|
||||
|
||||
|
||||
#define DELEGATE_0(ret,func) ret func() { return mDelegate->func(); }
|
||||
#define CDELEGATE_0(ret,func) ret func() const { return mDelegate->func(); }
|
||||
#define DELEGATE_1(ret,func,arg1) ret func(arg1 _a1) { return mDelegate->func(_a1); }
|
||||
#define CDELEGATE_1(ret,func,arg1) ret func(arg1 _a1) const { return mDelegate->func(_a1); }
|
||||
#define DELEGATE_2(ret,func,arg1,arg2) ret func(arg1 _a1,arg2 _a2) { return mDelegate->func(_a1,_a2); }
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#define HX_DECLARE_DYNAMIC_FUNC(func,dynamic_arg_list) \
|
||||
::NS::Dynamic func##_dyn(dynamic_arg_list);
|
||||
|
||||
#define STATIC_HX_DECLARE_DYNAMIC_FUNC(func,dynamic_arg_list) \
|
||||
static ::NS::Dynamic func##_dyn(dynamic_arg_list);
|
||||
|
||||
|
||||
::foreach PARAMS::
|
||||
::if (ARG>0)::::if (ARG<6)::
|
||||
#define HX_DEFINE_DYNAMIC_FUNC::ARG::(class,func,ret) \
|
||||
HX_DEFINE_DYNAMIC_FUNC(class,::ARG::,func,ret,HX_ARR_LIST::ARG::,HX_DYNAMIC_ARG_LIST::ARG::,HX_ARG_LIST::ARG::)
|
||||
::else::
|
||||
#define HX_DEFINE_DYNAMIC_FUNC::ARG::(class,func,ret) \
|
||||
HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,::ARG::,func,ret,HX_ARR_LIST::ARG::,HX_DYNAMIC_ARG_LIST::ARG::,HX_ARG_LIST::ARG::)
|
||||
::end::
|
||||
::end::::end::
|
||||
|
||||
|
||||
#define STATIC_HX_DEFINE_DYNAMIC_FUNC0(class,func,ret) \
|
||||
static ::NS::Dynamic __##class##func() \
|
||||
{ \
|
||||
ret class::func(); return ::NS::Dynamic(); \
|
||||
}; \
|
||||
::NS::Dynamic class::func##_dyn() \
|
||||
{\
|
||||
return ::hxNS::CreateStaticFunction0(#func,__##class##func); \
|
||||
}
|
||||
|
||||
|
||||
#define STATIC_HX_DEFINE_DYNAMIC_FUNC(class,N,func,ret,array_list,dynamic_arg_list,arg_list) \
|
||||
static ::NS::Dynamic __##class##func(dynamic_arg_list) \
|
||||
{ \
|
||||
ret class::func(arg_list); return ::NS::Dynamic(); \
|
||||
}; \
|
||||
::NS::Dynamic class::func##_dyn() \
|
||||
{\
|
||||
return ::hxNS::CreateStaticFunction##N(#func,__##class##func); \
|
||||
}
|
||||
|
||||
|
||||
#define STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,N,func,ret,array_list,dynamic_arg_list,arg_list) \
|
||||
static ::NS::Dynamic __##class##func(const Array< ::NS::Dynamic> &inArgs) \
|
||||
{ \
|
||||
ret class::func(array_list); return ::NS::Dynamic(); \
|
||||
}; \
|
||||
::NS::Dynamic class::func##_dyn() \
|
||||
{\
|
||||
return ::hxNS::CreateStaticFunctionVar(#func,__##class##func,N); \
|
||||
}
|
||||
|
||||
|
||||
|
||||
::foreach PARAMS::
|
||||
::if (ARG>0)::::if (ARG<6)::
|
||||
#define STATIC_HX_DEFINE_DYNAMIC_FUNC::ARG::(class,func,ret) \
|
||||
STATIC_HX_DEFINE_DYNAMIC_FUNC(class,::ARG::,func,ret,HX_ARR_LIST::ARG::,HX_DYNAMIC_ARG_LIST::ARG::,HX_ARG_LIST::ARG::)
|
||||
::else::
|
||||
#define STATIC_HX_DEFINE_DYNAMIC_FUNC::ARG::(class,func,ret) \
|
||||
STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,::ARG::,func,ret,HX_ARR_LIST::ARG::,HX_DYNAMIC_ARG_LIST::ARG::,HX_ARG_LIST::ARG::)
|
||||
::end::
|
||||
::end::::end::
|
||||
|
||||
|
||||
#define HX_DYNAMIC_CALL(ret,func,array_args,dyn_arg_list,arg_list) \
|
||||
::NS::Dynamic __Run(const Array< ::NS::Dynamic> &inArgs) { ret func( array_args ); return null();} \
|
||||
::NS::Dynamic __run(dyn_arg_list) { ret func( arg_list ); return null();}
|
||||
|
||||
::foreach PARAMS::
|
||||
#define HX_DYNAMIC_CALL::ARG::(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST::ARG::,HX_DYNAMIC_ARG_LIST::ARG::,HX_ARG_LIST::ARG::)::end::
|
||||
|
||||
#define HX_BEGIN_DEFAULT_FUNC(name,t0) \
|
||||
namespace { \
|
||||
struct name : public ::hxNS::Object { int __GetType() const { return vtFunction; } \
|
||||
HX_IS_INSTANCE_OF enum { _hx_ClassId = ::hxNS::clsIdClosure }; \
|
||||
::hxNS::ObjectPtr<t0> __this; \
|
||||
name(::hxNS::ObjectPtr<t0> __0 = null()) : __this(__0) {} \
|
||||
void __Mark(::hxNS::MarkContext *__inCtx) { HX_MARK_MEMBER(__this); } \
|
||||
void __Visit(::hxNS::VisitContext *__inCtx) { HX_VISIT_MEMBER(__this); }
|
||||
|
||||
|
||||
#define HX_END_DEFAULT_FUNC \
|
||||
}
|
||||
|
||||
#define HXARGC(x) int __ArgCount() const { return x; }
|
||||
|
||||
#define HX_BEGIN_LOCAL_FUNC_S0(SUPER,name) \
|
||||
struct name : public SUPER { \
|
||||
HX_IS_INSTANCE_OF enum { _hx_ClassId = ::hxNS::clsIdClosure }; \
|
||||
void __Mark(::hxNS::MarkContext *__inCtx) { DoMarkThis(__inCtx); } \
|
||||
void __Visit(::hxNS::VisitContext *__inCtx) { DoVisitThis(__inCtx); } \
|
||||
name() {}
|
||||
|
||||
::foreach LOCALS::
|
||||
#define HX_BEGIN_LOCAL_FUNC_S::ARG::(SUPER,name,::TYPE_ARGS::) \
|
||||
struct name : public SUPER { \
|
||||
HX_IS_INSTANCE_OF enum { _hx_ClassId = ::hxNS::clsIdClosure }; \
|
||||
::TYPE_DECL::; \
|
||||
void __Mark(::hxNS::MarkContext *__inCtx) { DoMarkThis(__inCtx); ::MARKS:: } \
|
||||
void __Visit(::hxNS::VisitContext *__inCtx) { DoVisitThis(__inCtx); ::VISITS:: } \
|
||||
name(::CONSTRUCT_ARGS::) : ::CONSTRUCT_VARS:: {}::end::
|
||||
|
||||
#if (HXCPP_API_LEVEL>=330)
|
||||
#define HX_LOCAL_RUN _hx_run
|
||||
#else
|
||||
#define HX_LOCAL_RUN run
|
||||
#endif
|
||||
|
||||
#define HX_END_LOCAL_FUNC0(ret) HX_DYNAMIC_CALL0(ret, HX_LOCAL_RUN ) };
|
||||
::foreach LOCALS::
|
||||
#define HX_END_LOCAL_FUNC::ARG::(ret) HX_DYNAMIC_CALL::ARG::(ret, HX_LOCAL_RUN ) };::end::
|
||||
|
||||
// For compatibility until next version of haxe is released
|
||||
#define HX_BEGIN_LOCAL_FUNC0(name) \
|
||||
HX_BEGIN_LOCAL_FUNC_S0(::hxNS::LocalFunc,name)
|
||||
::foreach LOCALS::
|
||||
#define HX_BEGIN_LOCAL_FUNC::ARG::(name,::TYPE_ARGS::) \
|
||||
HX_BEGIN_LOCAL_FUNC_S::ARG::(::hxNS::LocalFunc,name,::TYPE_ARGS::)::end::
|
||||
|
||||
|
||||
#define HX_DECLARE_DYNAMIC_FUNCTIONS \
|
||||
::foreach PARAMS:: ::if (ARG<6)::::else:: ::NS::Dynamic operator()(::DYNAMIC_ARG_LIST::); \
|
||||
::end:: ::end::
|
||||
|
||||
|
||||
#define HX_DECLARE_VARIANT_FUNCTIONS \
|
||||
::foreach PARAMS:: ::if (ARG<6):: inline ::NS::Dynamic operator()(::DYNAMIC_ARG_LIST::); \
|
||||
::else:: ::NS::Dynamic operator()(::DYNAMIC_ARG_LIST::); \
|
||||
::end:: ::end::
|
||||
|
||||
|
||||
#define HX_IMPLEMENT_INLINE_VARIANT_FUNCTIONS \
|
||||
::foreach PARAMS:: ::if (ARG<6):: ::NS::Dynamic Variant::NS::operator()(::DYNAMIC_ARG_LIST::) { CheckFPtr(); return valObject->__run(::ARG_LIST::); } \
|
||||
::end:: ::end::
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
355
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/MacrosFixed.h
Normal file
355
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/MacrosFixed.h
Normal file
@ -0,0 +1,355 @@
|
||||
#ifndef MACROS_FIXED_H
|
||||
#define MACROS_FIXED_H
|
||||
|
||||
// ---- Forward Declare ---------------
|
||||
|
||||
|
||||
#define HX_DECLARE_CLASS0(klass) \
|
||||
class klass##_obj; \
|
||||
typedef ::hx::ObjectPtr<klass##_obj> klass;
|
||||
#define HX_DECLARE_CLASS1(ns1,klass) namespace ns1 { HX_DECLARE_CLASS0(klass) }
|
||||
#define HX_DECLARE_CLASS2(ns2,ns1,klass) namespace ns2 { HX_DECLARE_CLASS1(ns1,klass) }
|
||||
#define HX_DECLARE_CLASS3(ns3,ns2,ns1,klass) namespace ns3 { HX_DECLARE_CLASS2(ns2,ns1,klass) }
|
||||
#define HX_DECLARE_CLASS4(ns4,ns3,ns2,ns1,klass) namespace ns4 { HX_DECLARE_CLASS3(ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_CLASS5(ns5,ns4,ns3,ns2,ns1,klass) namespace ns5 { HX_DECLARE_CLASS4(ns4,ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_CLASS6(ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns6 { HX_DECLARE_CLASS5(ns5,ns4,ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_CLASS7(ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns7 { HX_DECLARE_CLASS6(ns6,ns5,ns4,ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_CLASS8(ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns8 { HX_DECLARE_CLASS7(ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_CLASS9(ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns9 { HX_DECLARE_CLASS8(ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_CLASS10(ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns10 { HX_DECLARE_CLASS9(ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_CLASS11(ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns11 { HX_DECLARE_CLASS10(ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_CLASS12(ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns12 { HX_DECLARE_CLASS11(ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_CLASS13(ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns13 { HX_DECLARE_CLASS12(ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_CLASS14(ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns14 { HX_DECLARE_CLASS13(ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_CLASS15(ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns15 { HX_DECLARE_CLASS14(ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_CLASS16(ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns16 { HX_DECLARE_CLASS15(ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_CLASS17(ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns17 { HX_DECLARE_CLASS16(ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_CLASS18(ns18,ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns18 { HX_DECLARE_CLASS17(ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_CLASS19(ns19,ns18,ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns19 { HX_DECLARE_CLASS18(ns18,ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_CLASS20(ns20,ns19,ns18,ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns20 { HX_DECLARE_CLASS19(ns19,ns18,ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
|
||||
|
||||
// ---- Enum ----------------------
|
||||
|
||||
#if (HXCPP_API_LEVEL >= 330)
|
||||
|
||||
#define HX_DEFINE_CREATE_ENUM(enum_obj) \
|
||||
static ::Dynamic Create##enum_obj(::String inName,::hx::DynamicArray inArgs) \
|
||||
{ \
|
||||
int count = enum_obj::__FindArgCount(inName); \
|
||||
int args = inArgs.GetPtr() ? inArgs.__length() : 0; \
|
||||
if (args!=count) __hxcpp_dbg_checkedThrow(HX_INVALID_ENUM_ARG_COUNT(#enum_obj, inName, count, args)); \
|
||||
::Dynamic result; \
|
||||
if (!enum_obj::__GetStatic(inName,result,::hx::paccDynamic)) __hxcpp_dbg_checkedThrow(HX_INVALID_ENUM_CONSTRUCTOR(#enum_obj, inName)); \
|
||||
if (args==0) return result; \
|
||||
return result->__Run(inArgs); \
|
||||
}
|
||||
|
||||
|
||||
#else
|
||||
|
||||
#define HX_DEFINE_CREATE_ENUM(enum_obj) \
|
||||
static ::Dynamic Create##enum_obj(::String inName,::hx::DynamicArray inArgs) \
|
||||
{ \
|
||||
int idx = enum_obj::__FindIndex(inName); \
|
||||
if (idx<0) __hxcpp_dbg_checkedThrow(HX_INVALID_ENUM_CONSTRUCTOR(#enum_obj, inName)); \
|
||||
int count = enum_obj::__FindArgCount(inName); \
|
||||
int args = inArgs.GetPtr() ? inArgs.__length() : 0; \
|
||||
if (args!=count) __hxcpp_dbg_checkedThrow(HX_INVALID_ENUM_ARG_COUNT(#enum_obj, inName, count, args)); \
|
||||
::Dynamic result =(new enum_obj())->__Field(inName,HX_PROP_DYNAMIC); \
|
||||
if (args==0 || !result.mPtr) return result; \
|
||||
return result->__Run(inArgs); \
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
// ---- Fields ----------------------
|
||||
|
||||
#if (HXCPP_API_LEVEL<331)
|
||||
#define HX_DO_RTTI_BASE \
|
||||
bool __Is(::hx::Object *inObj) const { return dynamic_cast<OBJ_ *>(inObj)!=0; }
|
||||
#else
|
||||
#define HX_DO_RTTI_BASE
|
||||
#endif
|
||||
|
||||
#if (HXCPP_API_LEVEL>331)
|
||||
#define HX_IS_INSTANCE_OF bool _hx_isInstanceOf(int inClassId) { return inClassId==1 || inClassId==(int)_hx_ClassId; }
|
||||
#else
|
||||
#define HX_IS_INSTANCE_OF
|
||||
#endif
|
||||
|
||||
|
||||
#define HX_DO_RTTI_ALL \
|
||||
HX_DO_RTTI_BASE \
|
||||
static ::hx::ObjectPtr< ::hx::Class_obj> __mClass; \
|
||||
::hx::ObjectPtr< ::hx::Class_obj > __GetClass() const { return __mClass; } \
|
||||
inline static ::hx::ObjectPtr< ::hx::Class_obj> &__SGetClass() { return __mClass; } \
|
||||
inline operator super *() { return this; }
|
||||
|
||||
#define HX_DO_RTTI \
|
||||
HX_DO_RTTI_ALL \
|
||||
::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp); \
|
||||
::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp); \
|
||||
void __GetFields(Array< ::String> &outFields);
|
||||
|
||||
#define HX_DO_INTERFACE_RTTI \
|
||||
static ::hx::ObjectPtr< ::hx::Class_obj> __mClass; \
|
||||
static ::hx::ObjectPtr< ::hx::Class_obj> &__SGetClass() { return __mClass; } \
|
||||
static void __register();
|
||||
|
||||
#define HX_DO_ENUM_RTTI_INTERNAL \
|
||||
HX_DO_RTTI_BASE \
|
||||
::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp); \
|
||||
static int __FindIndex(::String inName); \
|
||||
static int __FindArgCount(::String inName);
|
||||
|
||||
#define HX_DO_ENUM_RTTI \
|
||||
HX_DO_ENUM_RTTI_INTERNAL \
|
||||
static ::hx::ObjectPtr< ::hx::Class_obj> __mClass; \
|
||||
::hx::ObjectPtr< ::hx::Class_obj > __GetClass() const { return __mClass; } \
|
||||
static ::hx::ObjectPtr< ::hx::Class_obj> &__SGetClass() { return __mClass; }
|
||||
|
||||
|
||||
#define HX_DECLARE_IMPLEMENT_DYNAMIC ::Dynamic __mDynamicFields; \
|
||||
::Dynamic *__GetFieldMap() { return &__mDynamicFields; } \
|
||||
bool __HasField(const String &inString) \
|
||||
{ return ::hx::FieldMapHas(&__mDynamicFields,inString) || super::__HasField(inString); }
|
||||
|
||||
|
||||
#define HX_INIT_IMPLEMENT_DYNAMIC
|
||||
|
||||
#define HX_MARK_DYNAMIC HX_MARK_MEMBER(__mDynamicFields)
|
||||
|
||||
|
||||
#ifdef HX_VISIT_ALLOCS
|
||||
|
||||
#define HX_VISIT_DYNAMIC HX_VISIT_MEMBER(__mDynamicFields);
|
||||
|
||||
#else
|
||||
|
||||
#define HX_VISIT_DYNAMIC do { } while (0);
|
||||
|
||||
#endif
|
||||
|
||||
#define HX_CHECK_DYNAMIC_GET_FIELD(inName) \
|
||||
{ ::Dynamic d; if (::hx::FieldMapGet(&__mDynamicFields,inName,d)) return d; }
|
||||
|
||||
#define HX_CHECK_DYNAMIC_GET_INT_FIELD(inID) \
|
||||
{ ::Dynamic d; if (::hx::FieldMapGet(&__mDynamicFields,inID,d)) return d; }
|
||||
|
||||
#ifdef HXCPP_GC_GENERATIONAL
|
||||
#define HX_DYNAMIC_SET_FIELD(inName,inValue) ::hx::FieldMapSet(this,&__mDynamicFields,inName,inValue)
|
||||
#else
|
||||
#define HX_DYNAMIC_SET_FIELD(inName,inValue) ::hx::FieldMapSet(&__mDynamicFields,inName,inValue)
|
||||
#endif
|
||||
|
||||
#define HX_APPEND_DYNAMIC_FIELDS(outFields) ::hx::FieldMapAppendFields(&__mDynamicFields,outFields)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// ---- Main ---------------
|
||||
|
||||
|
||||
namespace hx {
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void SetTopOfStack(int *inTopOfStack,bool);
|
||||
}
|
||||
#define HX_TOP_OF_STACK \
|
||||
int t0 = 99; \
|
||||
::hx::SetTopOfStack(&t0,false);
|
||||
|
||||
|
||||
#ifdef __GNUC__
|
||||
#define EXPORT_EXTRA __attribute__ ((visibility("default")))
|
||||
#else
|
||||
#define EXPORT_EXTRA __declspec(dllexport)
|
||||
#endif
|
||||
|
||||
#ifdef HX_DECLARE_MAIN
|
||||
|
||||
#ifdef HXCPP_DLL_IMPORT
|
||||
|
||||
#define HX_BEGIN_MAIN \
|
||||
extern "C" { \
|
||||
EXPORT_EXTRA void __main__() { \
|
||||
__boot_all();
|
||||
|
||||
#define HX_END_MAIN \
|
||||
} \
|
||||
}
|
||||
|
||||
|
||||
#elif defined(HX_ANDROID)
|
||||
#ifdef HXCPP_EXE_LINK
|
||||
#define HX_BEGIN_MAIN \
|
||||
\
|
||||
int main(int argc,char **argv){ \
|
||||
HX_TOP_OF_STACK \
|
||||
::hx::Boot(); \
|
||||
try{ \
|
||||
__boot_all();
|
||||
|
||||
#define HX_END_MAIN \
|
||||
} \
|
||||
catch ( ::Dynamic e){ \
|
||||
__hx_dump_stack(); \
|
||||
printf("Error : %s\n",e->toString().__CStr()); \
|
||||
return -1; \
|
||||
} \
|
||||
return 0; \
|
||||
}
|
||||
|
||||
#else
|
||||
// Java Main....
|
||||
#include <jni.h>
|
||||
#include <hx/Thread.h>
|
||||
#include <android/log.h>
|
||||
|
||||
#define HX_BEGIN_MAIN \
|
||||
extern "C" EXPORT_EXTRA void hxcpp_main() { \
|
||||
HX_TOP_OF_STACK \
|
||||
try { \
|
||||
::hx::Boot(); \
|
||||
__boot_all();
|
||||
|
||||
|
||||
#define HX_END_MAIN \
|
||||
} catch ( ::Dynamic e) { \
|
||||
__hx_dump_stack(); \
|
||||
__android_log_print(ANDROID_LOG_ERROR, "Exception", "%s", e->toString().__CStr()); \
|
||||
}\
|
||||
::hx::SetTopOfStack((int *)0,true); \
|
||||
} \
|
||||
\
|
||||
extern "C" EXPORT_EXTRA JNIEXPORT void JNICALL Java_org_haxe_HXCPP_main(JNIEnv * env) \
|
||||
{ hxcpp_main(); }
|
||||
#endif
|
||||
|
||||
#elif defined(HX_WINRT)
|
||||
|
||||
#include <Roapi.h>
|
||||
|
||||
#define HX_BEGIN_MAIN \
|
||||
[ Platform::MTAThread ] \
|
||||
int main(Platform::Array<Platform::String^>^) \
|
||||
{ \
|
||||
HX_TOP_OF_STACK \
|
||||
RoInitialize(RO_INIT_MULTITHREADED); \
|
||||
::hx::Boot(); \
|
||||
try{ \
|
||||
__boot_all();
|
||||
|
||||
#define HX_END_MAIN \
|
||||
} \
|
||||
catch ( ::Dynamic e){ \
|
||||
__hx_dump_stack(); \
|
||||
return -1; \
|
||||
} \
|
||||
return 0; \
|
||||
}
|
||||
|
||||
#elif defined(HX_WIN_MAIN)
|
||||
|
||||
|
||||
#ifdef HAVE_WINDOWS_H
|
||||
|
||||
#define HX_BEGIN_MAIN \
|
||||
int __stdcall WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) \
|
||||
{ \
|
||||
HX_TOP_OF_STACK \
|
||||
::hx::Boot(); \
|
||||
try{ \
|
||||
__boot_all();
|
||||
|
||||
#else
|
||||
|
||||
#define HX_BEGIN_MAIN \
|
||||
extern "C" int __stdcall MessageBoxA(void *,const char *,const char *,int); \
|
||||
\
|
||||
int __stdcall WinMain( void * hInstance, void * hPrevInstance, const char *lpCmdLine, int nCmdShow) \
|
||||
{ \
|
||||
HX_TOP_OF_STACK \
|
||||
::hx::Boot(); \
|
||||
try{ \
|
||||
__boot_all();
|
||||
|
||||
#endif
|
||||
|
||||
#define HX_END_MAIN \
|
||||
} \
|
||||
catch ( ::Dynamic e){ \
|
||||
__hx_dump_stack(); \
|
||||
MessageBoxA(0, e->toString().__CStr(), "Error", 0); \
|
||||
return -1; \
|
||||
} \
|
||||
return 0; \
|
||||
}
|
||||
|
||||
|
||||
#elif defined(TIZEN)
|
||||
|
||||
|
||||
#define HX_BEGIN_MAIN \
|
||||
\
|
||||
extern "C" EXPORT_EXTRA int OspMain (int argc, char* pArgv[]){ \
|
||||
HX_TOP_OF_STACK \
|
||||
::hx::Boot(); \
|
||||
try{ \
|
||||
__boot_all();
|
||||
|
||||
#define HX_END_MAIN \
|
||||
} \
|
||||
catch ( ::Dynamic e){ \
|
||||
__hx_dump_stack(); \
|
||||
printf("Error : %s\n",e->toString().__CStr()); \
|
||||
return -1; \
|
||||
} \
|
||||
return 0; \
|
||||
}
|
||||
|
||||
|
||||
#else
|
||||
// Console Main ...
|
||||
|
||||
#define HX_BEGIN_MAIN \
|
||||
\
|
||||
int main(int argc,char **argv){ \
|
||||
HX_TOP_OF_STACK \
|
||||
::hx::Boot(); \
|
||||
try{ \
|
||||
__boot_all();
|
||||
|
||||
#define HX_END_MAIN \
|
||||
} \
|
||||
catch ( ::Dynamic e){ \
|
||||
__hx_dump_stack(); \
|
||||
printf("Error : %s\n",e->toString().__CStr()); \
|
||||
return -1; \
|
||||
} \
|
||||
return 0; \
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#endif // HX_DECLARE_MAIN
|
||||
|
||||
// Run as library
|
||||
#define HX_BEGIN_LIB_MAIN \
|
||||
extern "C" {\
|
||||
\
|
||||
void __hxcpp_lib_main() \
|
||||
{ \
|
||||
HX_TOP_OF_STACK \
|
||||
::hx::Boot(); \
|
||||
__boot_all();
|
||||
|
||||
#define HX_END_LIB_MAIN \
|
||||
} }
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
406
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/MacrosJumbo.h
Normal file
406
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/MacrosJumbo.h
Normal file
@ -0,0 +1,406 @@
|
||||
// ## ## ## ## #### ## ## ## ## ## #### ##
|
||||
// ## ## ## ## ## ## ## ### ## ## ### ## ## ##
|
||||
// ## ## ## ###### ###### ###### ## ###### ## ### ##
|
||||
// ## ## ## ## ## ## ## ## ### ## ## ### ## ##
|
||||
// ## ## ## ## ## ## ## ## ## ## ## #### ##
|
||||
|
||||
// DO NOT EDIT
|
||||
// This file is generated from the .tpl file
|
||||
#ifndef HX_MACROS_JUMBO_H
|
||||
#define HX_MACROS_JUMBO_H
|
||||
|
||||
|
||||
#define HX_BEGIN_LOCAL_FUNC_S20(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S21(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S22(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S23(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S24(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S25(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S26(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S27(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S28(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S29(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S30(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S31(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S32(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S33(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S34(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S35(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S36(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S37(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S38(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S39(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S40(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S41(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S42(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S43(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S44(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S45(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S46(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S47(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S48(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S49(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S50(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S51(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S52(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S53(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S54(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S55(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S56(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54;t55 v55; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); HX_MARK_MEMBER(v55); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); HX_VISIT_MEMBER(v55); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54,t55 __55) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54),v55(__55) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S57(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54;t55 v55;t56 v56; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); HX_MARK_MEMBER(v55); HX_MARK_MEMBER(v56); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); HX_VISIT_MEMBER(v55); HX_VISIT_MEMBER(v56); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54,t55 __55,t56 __56) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54),v55(__55),v56(__56) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S58(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54;t55 v55;t56 v56;t57 v57; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); HX_MARK_MEMBER(v55); HX_MARK_MEMBER(v56); HX_MARK_MEMBER(v57); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); HX_VISIT_MEMBER(v55); HX_VISIT_MEMBER(v56); HX_VISIT_MEMBER(v57); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54,t55 __55,t56 __56,t57 __57) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54),v55(__55),v56(__56),v57(__57) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S59(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54;t55 v55;t56 v56;t57 v57;t58 v58; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); HX_MARK_MEMBER(v55); HX_MARK_MEMBER(v56); HX_MARK_MEMBER(v57); HX_MARK_MEMBER(v58); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); HX_VISIT_MEMBER(v55); HX_VISIT_MEMBER(v56); HX_VISIT_MEMBER(v57); HX_VISIT_MEMBER(v58); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54,t55 __55,t56 __56,t57 __57,t58 __58) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54),v55(__55),v56(__56),v57(__57),v58(__58) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S60(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58,t59,v59) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54;t55 v55;t56 v56;t57 v57;t58 v58;t59 v59; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); HX_MARK_MEMBER(v55); HX_MARK_MEMBER(v56); HX_MARK_MEMBER(v57); HX_MARK_MEMBER(v58); HX_MARK_MEMBER(v59); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); HX_VISIT_MEMBER(v55); HX_VISIT_MEMBER(v56); HX_VISIT_MEMBER(v57); HX_VISIT_MEMBER(v58); HX_VISIT_MEMBER(v59); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54,t55 __55,t56 __56,t57 __57,t58 __58,t59 __59) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54),v55(__55),v56(__56),v57(__57),v58(__58),v59(__59) {}
|
||||
#define HX_BEGIN_LOCAL_FUNC_S61(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58,t59,v59,t60,v60) \
|
||||
struct name : public SUPER { \
|
||||
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54;t55 v55;t56 v56;t57 v57;t58 v58;t59 v59;t60 v60; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); HX_MARK_MEMBER(v55); HX_MARK_MEMBER(v56); HX_MARK_MEMBER(v57); HX_MARK_MEMBER(v58); HX_MARK_MEMBER(v59); HX_MARK_MEMBER(v60); } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); HX_VISIT_MEMBER(v55); HX_VISIT_MEMBER(v56); HX_VISIT_MEMBER(v57); HX_VISIT_MEMBER(v58); HX_VISIT_MEMBER(v59); HX_VISIT_MEMBER(v60); } \
|
||||
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54,t55 __55,t56 __56,t57 __57,t58 __58,t59 __59,t60 __60) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54),v55(__55),v56(__56),v57(__57),v58(__58),v59(__59),v60(__60) {}
|
||||
|
||||
#if (HXCPP_API_LEVEL>=330)
|
||||
#define HX_LOCAL_RUN _hx_run
|
||||
#else
|
||||
#define HX_LOCAL_RUN run
|
||||
#endif
|
||||
|
||||
|
||||
#define HX_END_LOCAL_FUNC20(ret) HX_DYNAMIC_CALL20(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC21(ret) HX_DYNAMIC_CALL21(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC22(ret) HX_DYNAMIC_CALL22(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC23(ret) HX_DYNAMIC_CALL23(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC24(ret) HX_DYNAMIC_CALL24(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC25(ret) HX_DYNAMIC_CALL25(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC26(ret) HX_DYNAMIC_CALL26(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC27(ret) HX_DYNAMIC_CALL27(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC28(ret) HX_DYNAMIC_CALL28(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC29(ret) HX_DYNAMIC_CALL29(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC30(ret) HX_DYNAMIC_CALL30(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC31(ret) HX_DYNAMIC_CALL31(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC32(ret) HX_DYNAMIC_CALL32(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC33(ret) HX_DYNAMIC_CALL33(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC34(ret) HX_DYNAMIC_CALL34(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC35(ret) HX_DYNAMIC_CALL35(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC36(ret) HX_DYNAMIC_CALL36(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC37(ret) HX_DYNAMIC_CALL37(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC38(ret) HX_DYNAMIC_CALL38(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC39(ret) HX_DYNAMIC_CALL39(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC40(ret) HX_DYNAMIC_CALL40(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC41(ret) HX_DYNAMIC_CALL41(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC42(ret) HX_DYNAMIC_CALL42(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC43(ret) HX_DYNAMIC_CALL43(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC44(ret) HX_DYNAMIC_CALL44(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC45(ret) HX_DYNAMIC_CALL45(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC46(ret) HX_DYNAMIC_CALL46(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC47(ret) HX_DYNAMIC_CALL47(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC48(ret) HX_DYNAMIC_CALL48(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC49(ret) HX_DYNAMIC_CALL49(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC50(ret) HX_DYNAMIC_CALL50(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC51(ret) HX_DYNAMIC_CALL51(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC52(ret) HX_DYNAMIC_CALL52(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC53(ret) HX_DYNAMIC_CALL53(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC54(ret) HX_DYNAMIC_CALL54(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC55(ret) HX_DYNAMIC_CALL55(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC56(ret) HX_DYNAMIC_CALL56(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC57(ret) HX_DYNAMIC_CALL57(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC58(ret) HX_DYNAMIC_CALL58(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC59(ret) HX_DYNAMIC_CALL59(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC60(ret) HX_DYNAMIC_CALL60(ret, HX_LOCAL_RUN ) };
|
||||
#define HX_END_LOCAL_FUNC61(ret) HX_DYNAMIC_CALL61(ret, HX_LOCAL_RUN ) };
|
||||
|
||||
// For compatibility until next version of haxe is released
|
||||
|
||||
#define HX_BEGIN_LOCAL_FUNC20(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19) \
|
||||
HX_BEGIN_LOCAL_FUNC_S20(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19)
|
||||
#define HX_BEGIN_LOCAL_FUNC21(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20) \
|
||||
HX_BEGIN_LOCAL_FUNC_S21(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20)
|
||||
#define HX_BEGIN_LOCAL_FUNC22(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21) \
|
||||
HX_BEGIN_LOCAL_FUNC_S22(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21)
|
||||
#define HX_BEGIN_LOCAL_FUNC23(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22) \
|
||||
HX_BEGIN_LOCAL_FUNC_S23(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22)
|
||||
#define HX_BEGIN_LOCAL_FUNC24(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23) \
|
||||
HX_BEGIN_LOCAL_FUNC_S24(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23)
|
||||
#define HX_BEGIN_LOCAL_FUNC25(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24) \
|
||||
HX_BEGIN_LOCAL_FUNC_S25(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24)
|
||||
#define HX_BEGIN_LOCAL_FUNC26(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25) \
|
||||
HX_BEGIN_LOCAL_FUNC_S26(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25)
|
||||
#define HX_BEGIN_LOCAL_FUNC27(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26) \
|
||||
HX_BEGIN_LOCAL_FUNC_S27(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26)
|
||||
#define HX_BEGIN_LOCAL_FUNC28(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27) \
|
||||
HX_BEGIN_LOCAL_FUNC_S28(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27)
|
||||
#define HX_BEGIN_LOCAL_FUNC29(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28) \
|
||||
HX_BEGIN_LOCAL_FUNC_S29(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28)
|
||||
#define HX_BEGIN_LOCAL_FUNC30(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29) \
|
||||
HX_BEGIN_LOCAL_FUNC_S30(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29)
|
||||
#define HX_BEGIN_LOCAL_FUNC31(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30) \
|
||||
HX_BEGIN_LOCAL_FUNC_S31(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30)
|
||||
#define HX_BEGIN_LOCAL_FUNC32(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31) \
|
||||
HX_BEGIN_LOCAL_FUNC_S32(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31)
|
||||
#define HX_BEGIN_LOCAL_FUNC33(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32) \
|
||||
HX_BEGIN_LOCAL_FUNC_S33(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32)
|
||||
#define HX_BEGIN_LOCAL_FUNC34(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33) \
|
||||
HX_BEGIN_LOCAL_FUNC_S34(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33)
|
||||
#define HX_BEGIN_LOCAL_FUNC35(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34) \
|
||||
HX_BEGIN_LOCAL_FUNC_S35(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34)
|
||||
#define HX_BEGIN_LOCAL_FUNC36(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35) \
|
||||
HX_BEGIN_LOCAL_FUNC_S36(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35)
|
||||
#define HX_BEGIN_LOCAL_FUNC37(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36) \
|
||||
HX_BEGIN_LOCAL_FUNC_S37(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36)
|
||||
#define HX_BEGIN_LOCAL_FUNC38(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37) \
|
||||
HX_BEGIN_LOCAL_FUNC_S38(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37)
|
||||
#define HX_BEGIN_LOCAL_FUNC39(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38) \
|
||||
HX_BEGIN_LOCAL_FUNC_S39(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38)
|
||||
#define HX_BEGIN_LOCAL_FUNC40(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39) \
|
||||
HX_BEGIN_LOCAL_FUNC_S40(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39)
|
||||
#define HX_BEGIN_LOCAL_FUNC41(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40) \
|
||||
HX_BEGIN_LOCAL_FUNC_S41(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40)
|
||||
#define HX_BEGIN_LOCAL_FUNC42(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41) \
|
||||
HX_BEGIN_LOCAL_FUNC_S42(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41)
|
||||
#define HX_BEGIN_LOCAL_FUNC43(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42) \
|
||||
HX_BEGIN_LOCAL_FUNC_S43(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42)
|
||||
#define HX_BEGIN_LOCAL_FUNC44(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43) \
|
||||
HX_BEGIN_LOCAL_FUNC_S44(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43)
|
||||
#define HX_BEGIN_LOCAL_FUNC45(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44) \
|
||||
HX_BEGIN_LOCAL_FUNC_S45(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44)
|
||||
#define HX_BEGIN_LOCAL_FUNC46(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45) \
|
||||
HX_BEGIN_LOCAL_FUNC_S46(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45)
|
||||
#define HX_BEGIN_LOCAL_FUNC47(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46) \
|
||||
HX_BEGIN_LOCAL_FUNC_S47(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46)
|
||||
#define HX_BEGIN_LOCAL_FUNC48(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47) \
|
||||
HX_BEGIN_LOCAL_FUNC_S48(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47)
|
||||
#define HX_BEGIN_LOCAL_FUNC49(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48) \
|
||||
HX_BEGIN_LOCAL_FUNC_S49(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48)
|
||||
#define HX_BEGIN_LOCAL_FUNC50(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49) \
|
||||
HX_BEGIN_LOCAL_FUNC_S50(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49)
|
||||
#define HX_BEGIN_LOCAL_FUNC51(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50) \
|
||||
HX_BEGIN_LOCAL_FUNC_S51(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50)
|
||||
#define HX_BEGIN_LOCAL_FUNC52(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51) \
|
||||
HX_BEGIN_LOCAL_FUNC_S52(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51)
|
||||
#define HX_BEGIN_LOCAL_FUNC53(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52) \
|
||||
HX_BEGIN_LOCAL_FUNC_S53(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52)
|
||||
#define HX_BEGIN_LOCAL_FUNC54(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53) \
|
||||
HX_BEGIN_LOCAL_FUNC_S54(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53)
|
||||
#define HX_BEGIN_LOCAL_FUNC55(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54) \
|
||||
HX_BEGIN_LOCAL_FUNC_S55(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54)
|
||||
#define HX_BEGIN_LOCAL_FUNC56(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55) \
|
||||
HX_BEGIN_LOCAL_FUNC_S56(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55)
|
||||
#define HX_BEGIN_LOCAL_FUNC57(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56) \
|
||||
HX_BEGIN_LOCAL_FUNC_S57(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56)
|
||||
#define HX_BEGIN_LOCAL_FUNC58(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57) \
|
||||
HX_BEGIN_LOCAL_FUNC_S58(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57)
|
||||
#define HX_BEGIN_LOCAL_FUNC59(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58) \
|
||||
HX_BEGIN_LOCAL_FUNC_S59(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58)
|
||||
#define HX_BEGIN_LOCAL_FUNC60(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58,t59,v59) \
|
||||
HX_BEGIN_LOCAL_FUNC_S60(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58,t59,v59)
|
||||
#define HX_BEGIN_LOCAL_FUNC61(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58,t59,v59,t60,v60) \
|
||||
HX_BEGIN_LOCAL_FUNC_S61(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58,t59,v59,t60,v60)
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
29
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/MacrosJumbo.tpl
Normal file
29
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/MacrosJumbo.tpl
Normal file
@ -0,0 +1,29 @@
|
||||
#ifndef HX_MACROS_JUMBO_H
|
||||
#define HX_MACROS_JUMBO_H
|
||||
|
||||
::foreach LOCALS::
|
||||
#define HX_BEGIN_LOCAL_FUNC_S::ARG::(SUPER,name,::TYPE_ARGS::) \
|
||||
struct name : public SUPER { \
|
||||
::TYPE_DECL::; \
|
||||
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); ::MARKS:: } \
|
||||
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); ::VISITS:: } \
|
||||
name(::CONSTRUCT_ARGS::) : ::CONSTRUCT_VARS:: {}::end::
|
||||
|
||||
#if (HXCPP_API_LEVEL>=330)
|
||||
#define HX_LOCAL_RUN _hx_run
|
||||
#else
|
||||
#define HX_LOCAL_RUN run
|
||||
#endif
|
||||
|
||||
::foreach LOCALS::
|
||||
#define HX_END_LOCAL_FUNC::ARG::(ret) HX_DYNAMIC_CALL::ARG::(ret, HX_LOCAL_RUN ) };::end::
|
||||
|
||||
// For compatibility until next version of haxe is released
|
||||
::foreach LOCALS::
|
||||
#define HX_BEGIN_LOCAL_FUNC::ARG::(name,::TYPE_ARGS::) \
|
||||
HX_BEGIN_LOCAL_FUNC_S::ARG::(hx::LocalFunc,name,::TYPE_ARGS::)::end::
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
32
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Memory.h
Normal file
32
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Memory.h
Normal file
@ -0,0 +1,32 @@
|
||||
#ifdef HX_MEMORY_H_OVERRIDE
|
||||
// Users can define their own header to use here, but there is no API
|
||||
// compatibility gaurantee for future changes.
|
||||
#include HX_MEMORY_H_OVERRIDE
|
||||
|
||||
// Todo - special version?
|
||||
inline void HxFreeGCBlock(void *p) {
|
||||
HxFree(p);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
#ifndef HX_MEMORY_H
|
||||
#define HX_MEMORY_H
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
inline void *HxAlloc(size_t size) {
|
||||
return malloc(size);
|
||||
}
|
||||
|
||||
inline void HxFree(void *p) {
|
||||
free(p);
|
||||
}
|
||||
|
||||
void *HxAllocGCBlock(size_t size);
|
||||
void HxFreeGCBlock(void *p);
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
183
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Native.h
Normal file
183
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Native.h
Normal file
@ -0,0 +1,183 @@
|
||||
#ifndef HX_NATIVE_INCLUDED_H
|
||||
#define HX_NATIVE_INCLUDED_H
|
||||
/*
|
||||
*
|
||||
This file is in the public domain, and can be freely distributed.
|
||||
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#ifndef HXCPP_H
|
||||
#define HXCPP_H
|
||||
typedef double Float;
|
||||
typedef void Void;
|
||||
|
||||
//typedef int Int;
|
||||
//typedef bool Bool;
|
||||
|
||||
#ifndef HXCPP_CLASS_ATTRIBUTES
|
||||
#define HXCPP_CLASS_ATTRIBUTES
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#define HX_DECLARE_NATIVE0(klass) \
|
||||
class klass;
|
||||
#define HX_DECLARE_NATIVE1(ns1,klass) namespace ns1 { HX_DECLARE_NATIVE0(klass) }
|
||||
#define HX_DECLARE_NATIVE2(ns2,ns1,klass) namespace ns2 { HX_DECLARE_NATIVE1(ns1,klass) }
|
||||
#define HX_DECLARE_NATIVE3(ns3,ns2,ns1,klass) namespace ns3 { HX_DECLARE_NATIVE2(ns2,ns1,klass) }
|
||||
#define HX_DECLARE_NATIVE4(ns4,ns3,ns2,ns1,klass) namespace ns4 { HX_DECLARE_NATIVE3(ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_NATIVE5(ns5,ns4,ns3,ns2,ns1,klass) namespace ns5 { HX_DECLARE_NATIVE4(ns4,ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_NATIVE6(ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns6 { HX_DECLARE_NATIVE5(ns5,ns4,ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_NATIVE7(ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns7 { HX_DECLARE_NATIVE6(ns6,ns5,ns4,ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_NATIVE8(ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns8 { HX_DECLARE_NATIVE7(ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
|
||||
#define HX_DECLARE_NATIVE9(ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns9 { HX_DECLARE_NATIVE8(ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
namespace hx
|
||||
{
|
||||
class Object;
|
||||
|
||||
class HXCPP_CLASS_ATTRIBUTES NativeInterface
|
||||
{
|
||||
public:
|
||||
virtual hx::Object *__GetRealObject() = 0;
|
||||
void _hx_addRef();
|
||||
void _hx_decRef();
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
class Native
|
||||
{
|
||||
public:
|
||||
T ptr;
|
||||
|
||||
Native () : ptr(0) { }
|
||||
Native (T inPtr) : ptr(inPtr) { }
|
||||
Native (const Native<T> &inNative) : ptr(inNative.ptr) { }
|
||||
#ifdef CPP_VARIANT_ONCE_H
|
||||
Native (const cpp::Variant &inVariant) {
|
||||
hx::Object *obj = inVariant.asObject();
|
||||
ptr = obj ? (T)inVariant.valObject->__GetHandle() : 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
inline Native &operator=(T inPtr) { ptr=inPtr; return *this; }
|
||||
inline Native &operator=(const Native<T> &inNative) { ptr=inNative.ptr; return *this; }
|
||||
#ifdef HX_NULL_H
|
||||
inline Native &operator=(const ::null &) { ptr=0; return *this; }
|
||||
#endif
|
||||
inline T operator->() const { return ptr; }
|
||||
|
||||
inline operator T() const { return ptr; }
|
||||
|
||||
template<typename O>
|
||||
inline bool operator==(const Native<O> &inOther) const
|
||||
{ return ptr == inOther.ptr; }
|
||||
template<typename O>
|
||||
inline bool operator!=(const Native<O> &inOther) const
|
||||
{ return ptr != inOther.ptr; }
|
||||
|
||||
};
|
||||
|
||||
HXCPP_CLASS_ATTRIBUTES const char *Init();
|
||||
HXCPP_CLASS_ATTRIBUTES void PushTopOfStack(void *);
|
||||
HXCPP_CLASS_ATTRIBUTES void PopTopOfStack();
|
||||
HXCPP_CLASS_ATTRIBUTES void GcAddOffsetRoot(void *inRoot, int inOffset);
|
||||
HXCPP_CLASS_ATTRIBUTES void GcSetOffsetRoot(void *inRoot, int inOffset);
|
||||
HXCPP_CLASS_ATTRIBUTES void GcRemoveOffsetRoot(void *inRoot);
|
||||
HXCPP_CLASS_ATTRIBUTES int GcGetThreadAttachedCount();
|
||||
|
||||
class HXCPP_CLASS_ATTRIBUTES NativeAttach
|
||||
{
|
||||
bool isAttached;
|
||||
public:
|
||||
NativeAttach(bool inAttach=true)
|
||||
{
|
||||
isAttached = false;
|
||||
if (inAttach)
|
||||
attach();
|
||||
}
|
||||
~NativeAttach()
|
||||
{
|
||||
detach();
|
||||
}
|
||||
void attach()
|
||||
{
|
||||
if (!isAttached)
|
||||
{
|
||||
isAttached = true;
|
||||
hx::PushTopOfStack(this);
|
||||
}
|
||||
}
|
||||
void detach()
|
||||
{
|
||||
if (isAttached)
|
||||
{
|
||||
isAttached = false;
|
||||
hx::PopTopOfStack();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
class Ref
|
||||
{
|
||||
public:
|
||||
T ptr;
|
||||
|
||||
Ref() : ptr(0) { }
|
||||
Ref(const T &inT) : ptr(0) { setPtr(inT); }
|
||||
template<typename O>
|
||||
inline Ref(const Native<O> &inNative) : ptr(0) { setPtr(inNative.ptr); }
|
||||
template<typename O>
|
||||
inline Ref(const Ref<O> &inRef) : ptr(0) { setPtr(inRef.ptr); }
|
||||
|
||||
~Ref() { setPtr(0); }
|
||||
void setPtr(T inPtr)
|
||||
{
|
||||
hx::Object *old = ptr ? ptr->__GetRealObject() : 0;
|
||||
int oldOffset = old ? (int)(size_t)((char *)inPtr - (char *)old) : 0;
|
||||
hx::Object *next = inPtr ? inPtr->__GetRealObject() : 0;
|
||||
int nextOffset = next ? (int)(size_t)((char *)inPtr - (char *)next) : 0;
|
||||
|
||||
ptr = inPtr;
|
||||
if (next)
|
||||
{
|
||||
if (!old)
|
||||
GcAddOffsetRoot(&ptr, nextOffset);
|
||||
else if (oldOffset!=nextOffset)
|
||||
GcSetOffsetRoot(&ptr, nextOffset);
|
||||
}
|
||||
else if (old)
|
||||
GcRemoveOffsetRoot(&ptr);
|
||||
}
|
||||
|
||||
inline Ref &operator=(const T &inPtr) { setPtr(inPtr); return *this; }
|
||||
template<typename O>
|
||||
inline Ref &operator=(const Native<O> &inNative) { setPtr(inNative.ptr); return *this; }
|
||||
template<typename O>
|
||||
inline Ref &operator=(const Ref<O> &inRef) { setPtr(inRef.ptr); return *this; }
|
||||
|
||||
template<typename O>
|
||||
inline bool operator==(const Ref<O> &inOther) const
|
||||
{ return ptr == inOther.ptr; }
|
||||
template<typename O>
|
||||
inline bool operator!=(const Ref<O> &inOther) const
|
||||
{ return ptr != inOther.ptr; }
|
||||
|
||||
T operator->() { return ptr; }
|
||||
};
|
||||
|
||||
#define HX_NATIVE_IMPLEMENTATION hx::Object *__GetRealObject() { return this; }
|
||||
#define HX_EXTERN_NATIVE_IMPLEMENTATION hx::Object *__GetRealObject() { return 0; }
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
118
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/NekoFunc.h
Normal file
118
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/NekoFunc.h
Normal file
@ -0,0 +1,118 @@
|
||||
#ifndef HX_NEKO_FUNC_H
|
||||
#define HX_NEKO_FUNC_H
|
||||
|
||||
#define NEKO_VERSION 180
|
||||
|
||||
typedef intptr_t int_val;
|
||||
|
||||
typedef enum {
|
||||
VAL_INT = 0xFF,
|
||||
VAL_NULL = 0,
|
||||
VAL_FLOAT = 1,
|
||||
VAL_BOOL = 2,
|
||||
VAL_STRING = 3,
|
||||
VAL_OBJECT = 4,
|
||||
VAL_ARRAY = 5,
|
||||
VAL_FUNCTION = 6,
|
||||
VAL_ABSTRACT = 7,
|
||||
VAL_PRIMITIVE = 6 | 8,
|
||||
VAL_JITFUN = 6 | 16,
|
||||
VAL_32_BITS = 0xFFFFFFFF
|
||||
} neko_val_type;
|
||||
|
||||
struct _neko_value {
|
||||
neko_val_type t;
|
||||
};
|
||||
|
||||
struct _neko_objtable;
|
||||
struct _neko_buffer;
|
||||
|
||||
#ifndef HAVE_NEKO_TYPES
|
||||
typedef struct _neko_vkind *neko_vkind;
|
||||
typedef struct _neko_value *neko_value;
|
||||
typedef struct _neko_buffer *neko_buffer;
|
||||
#endif
|
||||
|
||||
typedef struct _neko_objtable* neko_objtable;
|
||||
typedef double tfloat;
|
||||
|
||||
typedef void (*finalizer)(neko_value v);
|
||||
|
||||
#pragma pack(4)
|
||||
typedef struct {
|
||||
neko_val_type t;
|
||||
tfloat f;
|
||||
} vfloat;
|
||||
#pragma pack()
|
||||
|
||||
typedef struct _vobject {
|
||||
neko_val_type t;
|
||||
neko_objtable table;
|
||||
struct _vobject *proto;
|
||||
} vobject;
|
||||
|
||||
typedef struct {
|
||||
neko_val_type t;
|
||||
int nargs;
|
||||
void *addr;
|
||||
neko_value env;
|
||||
void *module;
|
||||
} vfunction;
|
||||
|
||||
typedef struct {
|
||||
neko_val_type t;
|
||||
char c;
|
||||
} vstring;
|
||||
|
||||
typedef struct {
|
||||
neko_val_type t;
|
||||
neko_value ptr;
|
||||
} varray;
|
||||
|
||||
typedef struct {
|
||||
neko_val_type t;
|
||||
neko_vkind kind;
|
||||
void *data;
|
||||
} vabstract;
|
||||
|
||||
|
||||
|
||||
#define neko_val_tag(v) (*(neko_val_type*)(v))
|
||||
#define neko_val_is_null(v) ((v) == val_null)
|
||||
#define neko_val_is_int(v) ((((int)(int_val)(v)) & 1) != 0)
|
||||
#define neko_val_is_number(v) (neko_val_is_int(v) || neko_val_tag(v) == VAL_FLOAT)
|
||||
#define neko_val_is_float(v) (!neko_val_is_int(v) && neko_val_tag(v) == VAL_FLOAT)
|
||||
#define neko_val_is_string(v) (!neko_val_is_int(v) && (neko_val_tag(v)&7) == VAL_STRING)
|
||||
#define neko_val_is_function(v) (!neko_val_is_int(v) && (neko_val_tag(v)&7) == VAL_FUNCTION)
|
||||
#define neko_val_is_object(v) (!neko_val_is_int(v) && neko_val_tag(v) == VAL_OBJECT)
|
||||
#define neko_val_is_array(v) (!neko_val_is_int(v) && (neko_val_tag(v)&7) == VAL_ARRAY)
|
||||
#define neko_val_is_abstract(v) (!neko_val_is_int(v) && neko_val_tag(v) == VAL_ABSTRACT)
|
||||
#define neko_val_is_kind(v,t) (neko_val_is_abstract(v) && neko_val_kind(v) == (t))
|
||||
#define neko_val_check_kind(v,t) if( !neko_val_is_kind(v,t) ) neko_error();
|
||||
#define neko_val_check_function(f,n) if( !neko_val_is_function(f) || (neko_val_fun_nargs(f) != (n) && neko_val_fun_nargs(f) != VAR_ARGS) ) neko_error();
|
||||
#define neko_val_check(v,t) if( !neko_val_is_##t(v) ) neko_error();
|
||||
#define neko_val_data(v) ((vabstract*)(v))->data
|
||||
#define neko_val_kind(v) ((vabstract*)(v))->kind
|
||||
|
||||
#define neko_val_type(v) (neko_val_is_int(v) ? VAL_INT : (neko_val_tag(v)&7))
|
||||
#define neko_val_int(v) (((int)(int_val)(v)) >> 1)
|
||||
#define neko_val_float(v) (CONV_FLOAT ((vfloat*)(v))->f)
|
||||
#define neko_val_bool(v) ((v) == neko_val_true)
|
||||
#define neko_val_number(v) (neko_val_is_int(v)?neko_val_int(v):neko_val_float(v))
|
||||
#define neko_val_hdata(v) ((vhash*)neko_val_data(v))
|
||||
#define neko_val_string(v) (&((vstring*)(v))->c)
|
||||
#define neko_val_strlen(v) (neko_val_tag(v) >> 3)
|
||||
#define neko_val_set_length(v,l) neko_val_tag(v) = (neko_val_tag(v)&7) | ((l) << 3)
|
||||
#define neko_val_set_size neko_val_set_length
|
||||
|
||||
#define neko_val_array_size(v) (neko_val_tag(v) >> 3)
|
||||
#define neko_val_array_ptr(v) (&((varray*)(v))->ptr)
|
||||
#define neko_val_fun_nargs(v) ((vfunction*)(v))->nargs
|
||||
#define neko_alloc_int(v) ((neko_value)(int_val)((((int)(v)) << 1) | 1))
|
||||
#define neko_alloc_bool(b) ((b)?neko_val_true:neko_val_false)
|
||||
|
||||
#define neko_max_array_size ((1 << 29) - 1)
|
||||
#define neko_max_string_size ((1 << 29) - 1)
|
||||
#define neko_invalid_comparison 0xFE
|
||||
|
||||
#endif // HX_NEKO_FUNC_H
|
||||
100
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/OS.h
Normal file
100
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/OS.h
Normal file
@ -0,0 +1,100 @@
|
||||
#ifndef HX_OS_H
|
||||
#define HX_OS_H
|
||||
|
||||
// OS FLAGS
|
||||
#if defined(_WIN32)
|
||||
# define NEKO_WINDOWS
|
||||
#endif
|
||||
|
||||
#if defined(__APPLE__) || defined(__MACH__) || defined(macintosh)
|
||||
# define NEKO_MAC
|
||||
#endif
|
||||
|
||||
#if defined(linux) || defined(__linux__)
|
||||
# define NEKO_LINUX
|
||||
#endif
|
||||
|
||||
#if defined(__FreeBSD_kernel__)
|
||||
# define NEKO_GNUKBSD
|
||||
#endif
|
||||
|
||||
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
|
||||
# define NEKO_BSD
|
||||
#endif
|
||||
|
||||
// COMPILER/PROCESSOR FLAGS
|
||||
#if defined(__GNUC__)
|
||||
# define NEKO_GCC
|
||||
#endif
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
# define NEKO_VCC
|
||||
#endif
|
||||
|
||||
#if defined(__MINGW32__)
|
||||
# define NEKO_MINGW
|
||||
#endif
|
||||
|
||||
#if defined(__i386__) || defined(_WIN32)
|
||||
# define NEKO_X86
|
||||
#endif
|
||||
|
||||
#if defined(__ppc__)
|
||||
# define NEKO_PPC
|
||||
#endif
|
||||
|
||||
#if !defined(_64BITS) && (defined(__LP64__) || defined(_LP64))
|
||||
#define _64BITS
|
||||
#endif
|
||||
|
||||
#if defined(_64BITS)
|
||||
# define NEKO_64BITS
|
||||
#endif
|
||||
|
||||
#if defined(NEKO_LINUX) || defined(NEKO_MAC) || defined(NEKO_BSD) || defined(NEKO_GNUKBSD)
|
||||
# define NEKO_POSIX
|
||||
#endif
|
||||
|
||||
#if defined(NEKO_GCC)
|
||||
# define NEKO_THREADED
|
||||
# define NEKO_DIRECT_THREADED
|
||||
#endif
|
||||
|
||||
#include <stddef.h>
|
||||
#ifndef NEKO_VCC
|
||||
# include <stdint.h>
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#undef EXPORT
|
||||
#undef IMPORT
|
||||
#if defined(NEKO_VCC) || defined(NEKO_MINGW)
|
||||
# define INLINE __inline
|
||||
# define EXPORT __declspec( dllexport )
|
||||
# define IMPORT __declspec( dllimport )
|
||||
#elif defined (HX_LINUX)
|
||||
# define INLINE inline
|
||||
# define EXPORT __attribute__ ((visibility("default")))
|
||||
# define IMPORT
|
||||
#else
|
||||
# define INLINE inline
|
||||
# define EXPORT __attribute__ ((visibility("default")))
|
||||
# define IMPORT
|
||||
#endif
|
||||
|
||||
#ifdef NEKO_POSIX
|
||||
# include <errno.h>
|
||||
# define POSIX_LABEL(name) name:
|
||||
# define HANDLE_EINTR(label) if( errno == EINTR ) goto label
|
||||
# define HANDLE_FINTR(f,label) if( ferror(f) && errno == EINTR ) goto label
|
||||
#else
|
||||
# define POSIX_LABEL(name)
|
||||
# define HANDLE_EINTR(label)
|
||||
# define HANDLE_FINTR(f,label)
|
||||
#endif
|
||||
|
||||
|
||||
#endif
|
||||
222
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/ObjcHelpers.h
Normal file
222
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/ObjcHelpers.h
Normal file
@ -0,0 +1,222 @@
|
||||
#ifndef HX_OBJC_HELPERS_INCLUDED
|
||||
#define HX_OBJC_HELPERS_INCLUDED
|
||||
|
||||
|
||||
|
||||
@interface NSHaxeWrapperClass : NSObject {
|
||||
@public hx::Object *haxeObject;
|
||||
}
|
||||
- (id)init:(hx::Object *) inHaxe;
|
||||
- (void)dealloc;
|
||||
@end
|
||||
|
||||
|
||||
NSDictionary<NSString *, id> *_hx_obj_to_nsdictionary(Dynamic d);
|
||||
|
||||
id _hx_value_to_objc(Dynamic d);
|
||||
|
||||
|
||||
Dynamic _hx_nsdictionary_to_obj(NSDictionary<NSString *, id> *inDictionary);
|
||||
|
||||
Dynamic _hx_objc_to_dynamic(id inValue);
|
||||
|
||||
Array<unsigned char> _hx_objc_to_bytes(id value);
|
||||
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
|
||||
// 0 args
|
||||
struct TObjcBlockVoidVoid
|
||||
{
|
||||
typedef void (^t)();
|
||||
|
||||
static t create(Dynamic func)
|
||||
{
|
||||
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
|
||||
t wrap = ^ {
|
||||
wrapper->haxeObject->__run();
|
||||
};
|
||||
return wrap;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Ret>
|
||||
struct TObjcBlockRetVoid
|
||||
{
|
||||
typedef Ret (^t)();
|
||||
|
||||
static t create(Dynamic func)
|
||||
{
|
||||
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
|
||||
t wrap = ^() {
|
||||
return (Ret) wrapper->haxeObject->__run();
|
||||
};
|
||||
return wrap;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// 1 arg
|
||||
template<typename Arg0>
|
||||
struct TObjcBlockVoidArgs1
|
||||
{
|
||||
typedef void (^t)(Arg0 a);
|
||||
|
||||
static t create(Dynamic func)
|
||||
{
|
||||
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
|
||||
t wrap = ^(Arg0 a0) {
|
||||
wrapper->haxeObject->__run(a0);
|
||||
};
|
||||
return wrap;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Ret, typename Arg0>
|
||||
struct TObjcBlockRetArgs1
|
||||
{
|
||||
typedef Ret (^t)(Arg0 a);
|
||||
inline static t create(Dynamic func)
|
||||
{
|
||||
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
|
||||
t wrap = ^(Arg0 a0) {
|
||||
return (Ret) wrapper->haxeObject->__run(a0);
|
||||
} ;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
// 2 arg
|
||||
template<typename Arg0, typename Arg1>
|
||||
struct TObjcBlockVoidArgs2
|
||||
{
|
||||
typedef void (^t)(Arg0 a0, Arg1 a1);
|
||||
|
||||
static t create(Dynamic func)
|
||||
{
|
||||
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
|
||||
t wrap = ^(Arg0 a0, Arg1 a1) {
|
||||
wrapper->haxeObject->__run(a0,a1);
|
||||
};
|
||||
return wrap;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Ret, typename Arg0, typename Arg1>
|
||||
struct TObjcBlockRetArgs2
|
||||
{
|
||||
typedef Ret (^t)(Arg0 a0, Arg1 a1);
|
||||
inline static t create(Dynamic func)
|
||||
{
|
||||
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
|
||||
t wrap = ^(Arg0 a0, Arg1 a1) {
|
||||
return (Ret) wrapper->haxeObject->__run(a0,a1);
|
||||
} ;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// 3 arg
|
||||
template<typename Arg0, typename Arg1, typename Arg2>
|
||||
struct TObjcBlockVoidArgs3
|
||||
{
|
||||
typedef void (^t)(Arg0 a0, Arg1 a1, Arg2 a2);
|
||||
|
||||
static t create(Dynamic func)
|
||||
{
|
||||
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
|
||||
t wrap = ^(Arg0 a0, Arg1 a1, Arg2 a2) {
|
||||
wrapper->haxeObject->__run(a0,a1,a2);
|
||||
};
|
||||
return wrap;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Ret, typename Arg0, typename Arg1, typename Arg2>
|
||||
struct TObjcBlockRetArgs3
|
||||
{
|
||||
typedef Ret (^t)(Arg0 a0, Arg1 a1, Arg2 a2);
|
||||
inline static t create(Dynamic func)
|
||||
{
|
||||
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
|
||||
t wrap = ^(Arg0 a0, Arg1 a1, Arg2 a2) {
|
||||
return (Ret) wrapper->haxeObject->__run(a0,a1,a2);
|
||||
} ;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// 4 arg
|
||||
template<typename Arg0, typename Arg1, typename Arg2, typename Arg3>
|
||||
struct TObjcBlockVoidArgs4
|
||||
{
|
||||
typedef void (^t)(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3);
|
||||
|
||||
static t create(Dynamic func)
|
||||
{
|
||||
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
|
||||
t wrap = ^(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3) {
|
||||
wrapper->haxeObject->__run(a0,a1,a2,a3);
|
||||
};
|
||||
return wrap;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Ret, typename Arg0, typename Arg1, typename Arg2, typename Arg3>
|
||||
struct TObjcBlockRetArgs4
|
||||
{
|
||||
typedef Ret (^t)(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3);
|
||||
inline static t create(Dynamic func)
|
||||
{
|
||||
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
|
||||
t wrap = ^(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3) {
|
||||
return (Ret) wrapper->haxeObject->__run(a0,a1,a2,a3);
|
||||
} ;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// 5 arg
|
||||
template<typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
|
||||
struct TObjcBlockVoidArgs5
|
||||
{
|
||||
typedef void (^t)(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4);
|
||||
|
||||
static t create(Dynamic func)
|
||||
{
|
||||
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
|
||||
t wrap = ^(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4) {
|
||||
wrapper->haxeObject->__run(a0,a1,a2,a3,a4);
|
||||
};
|
||||
return wrap;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Ret, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
|
||||
struct TObjcBlockRetArgs5
|
||||
{
|
||||
typedef Ret (^t)(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4);
|
||||
inline static t create(Dynamic func)
|
||||
{
|
||||
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
|
||||
t wrap = ^(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4) {
|
||||
return (Ret) wrapper->haxeObject->__run(a0,a1,a2,a3,a4);
|
||||
} ;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
450
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Object.h
Normal file
450
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Object.h
Normal file
@ -0,0 +1,450 @@
|
||||
#ifndef HX_OBJECT_H
|
||||
#define HX_OBJECT_H
|
||||
|
||||
#ifndef HXCPP_H
|
||||
#error "Please include hxcpp.h, not hx/Object.h"
|
||||
#endif
|
||||
|
||||
#if defined(KORE_LINUX) && __cplusplus < 201103L
|
||||
#include <math.h>
|
||||
#endif
|
||||
|
||||
// --- Constants -------------------------------------------------------
|
||||
|
||||
// These values are returned from the "__GetType" function
|
||||
enum hxObjectType
|
||||
{
|
||||
vtUnknown = -1,
|
||||
vtInt = 0xff,
|
||||
vtNull = 0,
|
||||
vtFloat = 1,
|
||||
vtBool = 2,
|
||||
vtString = 3,
|
||||
vtObject = 4,
|
||||
vtArray = 5,
|
||||
vtFunction = 6,
|
||||
vtEnum,
|
||||
vtClass,
|
||||
vtInt64,
|
||||
vtAbstractBase = 0x100,
|
||||
};
|
||||
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
|
||||
|
||||
class FieldRef;
|
||||
class IndexRef;
|
||||
typedef Array<Dynamic> DynamicArray;
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES null BadCast();
|
||||
|
||||
#ifdef HXCPP_SCRIPTABLE
|
||||
|
||||
// CPPIA_CALL = fastcall on x86(32), nothing otherwise
|
||||
#if (HXCPP_API_LEVEL >= 331)
|
||||
#if (defined(_WIN32) && !defined(_M_X64) && !defined(__x86_64__) && !defined(_ARM_) ) || \
|
||||
defined(HXCPP_X86) || defined(__i386__) || defined(__i386) || \
|
||||
(!defined(_WIN32) && !defined(_ARM_) && !defined(__arm__) && !defined(__x86_64__) )
|
||||
|
||||
#if defined(__GNUC__) && !defined(__APPLE__) && !defined(EMSCRIPTEN)
|
||||
#define CPPIA_CALL __attribute__ ((fastcall))
|
||||
#elif defined(_MSC_VER)
|
||||
#define CPPIA_CALL __fastcall
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef CPPIA_CALL
|
||||
#define CPPIA_CALL
|
||||
#endif
|
||||
|
||||
|
||||
typedef void (CPPIA_CALL *StackExecute)(struct StackContext *ctx);
|
||||
struct ScriptFunction
|
||||
{
|
||||
ScriptFunction(StackExecute inExe=0,const char *inSig=0)
|
||||
: execute(inExe), signature(inSig) { }
|
||||
StackExecute execute;
|
||||
const char *signature;
|
||||
};
|
||||
struct ScriptCallable;
|
||||
|
||||
#endif
|
||||
|
||||
enum NewObjectType
|
||||
{
|
||||
NewObjAlloc,
|
||||
NewObjContainer,
|
||||
NewObjConst,
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
clsIdDynamic = 1,
|
||||
clsIdClass,
|
||||
clsIdInt,
|
||||
clsIdInt64,
|
||||
clsIdFloat,
|
||||
clsIdBool,
|
||||
clsIdString,
|
||||
clsIdMath,
|
||||
clsIdEnum,
|
||||
clsIdClosure,
|
||||
clsIdVirtualArray,
|
||||
clsIdArrayIterator,
|
||||
clsIdArrayBase,
|
||||
clsIdArrayByte,
|
||||
clsIdArrayShort,
|
||||
clsIdArrayInt,
|
||||
clsIdArrayBool,
|
||||
clsIdArrayFloat32,
|
||||
clsIdArrayFloat64,
|
||||
clsIdArrayString,
|
||||
clsIdArrayInt64,
|
||||
clsIdArrayObject,
|
||||
clsIdAbstract,
|
||||
clsIdHash,
|
||||
clsIdWeakRef,
|
||||
clsIdExternalPrimitive,
|
||||
clsIdPointer,
|
||||
clsIdStruct,
|
||||
clsIdCMember0,
|
||||
clsIdCMember1,
|
||||
clsIdCMember2,
|
||||
clsIdCMember3,
|
||||
clsIdCMember4,
|
||||
clsIdCMember5,
|
||||
clsIdCMemberVar,
|
||||
clsIdCStatic0,
|
||||
clsIdCStatic1,
|
||||
clsIdCStatic2,
|
||||
clsIdCStatic3,
|
||||
clsIdCStatic4,
|
||||
clsIdCStatic5,
|
||||
clsIdCStatic6,
|
||||
clsIdCStaticVar,
|
||||
clsIdMutex,
|
||||
clsIdSemaphore,
|
||||
clsIdCondition,
|
||||
clsIdLock,
|
||||
clsIdDeque,
|
||||
clsIdThreadInfo,
|
||||
clsIdPcreData,
|
||||
clsIdFio,
|
||||
clsIdProcess,
|
||||
clsIdSocket,
|
||||
clsIdRandom,
|
||||
clsIdPollData,
|
||||
clsIdSqlite,
|
||||
clsIdMysql,
|
||||
clsIdMysqlResult,
|
||||
clsIdSsl,
|
||||
clsIdSslCert,
|
||||
clsIdSslConf,
|
||||
clsIdSslKey,
|
||||
clsIdZLib,
|
||||
|
||||
};
|
||||
|
||||
|
||||
// --- hx::Object ------------------------------------------------------------
|
||||
//
|
||||
// Base for all hxcpp objects.
|
||||
// This contains the virtual functions required by the core to provide
|
||||
// a generic interface to the specific classes.
|
||||
//
|
||||
// Hxcpp classes inherit from this.
|
||||
//
|
||||
class HXCPP_EXTERN_CLASS_ATTRIBUTES Object
|
||||
{
|
||||
public:
|
||||
enum { _hx_ClassId = hx::clsIdDynamic };
|
||||
|
||||
|
||||
inline void *operator new( size_t inSize, bool inContainer=true, const char *inName=0 )
|
||||
{
|
||||
#ifdef HX_USE_INLINE_IMMIX_OPERATOR_NEW
|
||||
ImmixAllocator *alloc = HX_CTX_GET;
|
||||
|
||||
#ifdef HXCPP_DEBUG
|
||||
if (!alloc)
|
||||
BadImmixAlloc();
|
||||
#endif
|
||||
|
||||
return ImmixAllocator::alloc(alloc, inSize, inContainer, inName);
|
||||
|
||||
#else // Not HX_USE_INLINE_IMMIX_OPERATOR_NEW ...
|
||||
|
||||
void *result = hx::InternalNew(inSize,inContainer);
|
||||
|
||||
#ifdef HXCPP_TELEMETRY
|
||||
__hxt_gc_new(result, inSize, inName);
|
||||
#endif
|
||||
return result;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline void *operator new( size_t inSize, hx::NewObjectType inType, const char *inName=0 )
|
||||
{
|
||||
if (inType==NewObjConst)
|
||||
return InternalCreateConstBuffer(0,(int)inSize);
|
||||
return operator new(inSize, inType==NewObjContainer, inName);
|
||||
}
|
||||
|
||||
void operator delete( void *, bool) { }
|
||||
void operator delete( void *, bool, const char * ) { }
|
||||
void operator delete( void *, int ) { }
|
||||
void operator delete( void *, hx::NewObjectType) { }
|
||||
void operator delete( void *, hx::NewObjectType, const char * ) { }
|
||||
|
||||
#if (HXCPP_API_LEVEL>=332)
|
||||
virtual bool _hx_isInstanceOf(int inClassId);
|
||||
#endif
|
||||
|
||||
//virtual void *__root();
|
||||
virtual void __Mark(hx::MarkContext *__inCtx) { }
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
virtual void __Visit(hx::VisitContext *__inCtx) { }
|
||||
#endif
|
||||
|
||||
// helpers...
|
||||
inline bool __IsArray() const { return __GetType()==vtArray; }
|
||||
|
||||
virtual int __GetType() const { return vtClass; }
|
||||
virtual void *__GetHandle() const { return 0; }
|
||||
|
||||
|
||||
virtual hx::FieldRef __FieldRef(const String &inString);
|
||||
|
||||
virtual String __ToString() const;
|
||||
|
||||
virtual int __ToInt() const { return 0; }
|
||||
#if defined(KORE_LINUX) && __cplusplus < 201103L
|
||||
virtual double __ToDouble() const { return NAN; }
|
||||
#else
|
||||
virtual double __ToDouble() const { return std::numeric_limits<double>::quiet_NaN(); }
|
||||
#endif
|
||||
virtual cpp::Int64 __ToInt64() const { return (cpp::Int64)(0); }
|
||||
virtual const char * __CStr() const;
|
||||
virtual String toString();
|
||||
virtual bool __HasField(const String &inString);
|
||||
virtual hx::Val __Field(const String &inString, hx::PropertyAccess inCallProp);
|
||||
|
||||
#if (HXCPP_API_LEVEL <= 330)
|
||||
virtual bool __Is(hx::Object *inClass) const { return true; }
|
||||
virtual hx::Object *__GetRealObject() { return this; }
|
||||
bool __Is(Dynamic inClass ) const;
|
||||
#endif
|
||||
|
||||
#if (HXCPP_API_LEVEL >= 330)
|
||||
// Non-virtual
|
||||
Dynamic __IField(int inFieldID);
|
||||
double __INumField(int inFieldID);
|
||||
virtual void *_hx_getInterface(int inId);
|
||||
#else
|
||||
virtual hx::Object *__ToInterface(const hx::type_info &inInterface) { return 0; }
|
||||
virtual Dynamic __IField(int inFieldID);
|
||||
virtual double __INumField(int inFieldID);
|
||||
|
||||
// These have been moved to EnumBase
|
||||
virtual DynamicArray __EnumParams();
|
||||
virtual String __Tag() const;
|
||||
virtual int __Index() const;
|
||||
virtual void __SetSize(int inLen) { }
|
||||
#endif
|
||||
|
||||
virtual hx::Val __SetField(const String &inField,const hx::Val &inValue, hx::PropertyAccess inCallProp);
|
||||
|
||||
virtual void __SetThis(Dynamic inThis);
|
||||
virtual Dynamic __Run(const Array<Dynamic> &inArgs);
|
||||
virtual Dynamic *__GetFieldMap();
|
||||
virtual void __GetFields(Array<String> &outFields);
|
||||
virtual hx::Class __GetClass() const;
|
||||
|
||||
virtual int __Compare(const hx::Object *inRHS) const;
|
||||
|
||||
virtual int __length() const { return 0; }
|
||||
virtual Dynamic __GetItem(int inIndex) const;
|
||||
virtual Dynamic __SetItem(int inIndex,Dynamic inValue);
|
||||
|
||||
|
||||
typedef const Dynamic &D;
|
||||
virtual Dynamic __run();
|
||||
virtual Dynamic __run(D a);
|
||||
virtual Dynamic __run(D a,D b);
|
||||
virtual Dynamic __run(D a,D b,D c);
|
||||
virtual Dynamic __run(D a,D b,D c,D d);
|
||||
virtual Dynamic __run(D a,D b,D c,D d,D e);
|
||||
|
||||
virtual int __ArgCount() const { return -1; }
|
||||
|
||||
#ifdef HXCPP_SCRIPTABLE
|
||||
virtual void **__GetScriptVTable() { return 0; }
|
||||
virtual hx::ScriptCallable *__GetScriptCallable() { return 0; }
|
||||
static hx::ScriptFunction __script_construct;
|
||||
#endif
|
||||
|
||||
#if (HXCPP_API_LEVEL>=331)
|
||||
inline bool __compare( hx::Object *inRHS ) { return this!=inRHS; }
|
||||
#else
|
||||
inline bool __compare( hx::Object *inRHS )
|
||||
{ return __GetRealObject()!=inRHS->__GetRealObject(); }
|
||||
#endif
|
||||
|
||||
static hx::Class &__SGetClass();
|
||||
static void __boot();
|
||||
};
|
||||
|
||||
// --- hx::ObjectPtr ---------------------------------------------------------------
|
||||
//
|
||||
// This class simply provides syntax so that pointers can be written as objects,
|
||||
// and overloaded operators can be used
|
||||
|
||||
template<typename OBJ_>
|
||||
class ObjectPtr
|
||||
{
|
||||
protected:
|
||||
inline bool SetPtr(OBJ_ *inPtr)
|
||||
{
|
||||
mPtr = inPtr;
|
||||
return true;
|
||||
}
|
||||
inline bool SetPtr(...) { return false; }
|
||||
|
||||
inline void CastPtr(hx::Object *inPtr,bool inThrowOnInvalid)
|
||||
{
|
||||
if (inPtr)
|
||||
{
|
||||
#if (HXCPP_API_LEVEL>=332)
|
||||
mPtr = inPtr->_hx_isInstanceOf(OBJ_::_hx_ClassId) ? reinterpret_cast<OBJ_ *>(inPtr) : 0;
|
||||
#elif (HXCPP_API_LEVEL>=331)
|
||||
mPtr = dynamic_cast<OBJ_ *>(inPtr);
|
||||
#else
|
||||
mPtr = dynamic_cast<OBJ_ *>(inPtr->__GetRealObject());
|
||||
#if (HXCPP_API_LEVEL < 330)
|
||||
if (!mPtr)
|
||||
mPtr = (Ptr)inPtr->__ToInterface(typeid(Obj));
|
||||
#endif
|
||||
#endif
|
||||
if (inThrowOnInvalid && !mPtr)
|
||||
::hx::BadCast();
|
||||
}
|
||||
else
|
||||
mPtr = 0;
|
||||
}
|
||||
|
||||
public:
|
||||
typedef OBJ_ Obj;
|
||||
typedef OBJ_ *Ptr;
|
||||
|
||||
inline ObjectPtr() : mPtr(0) { }
|
||||
inline ObjectPtr(OBJ_ *inObj) : mPtr(inObj) { }
|
||||
inline ObjectPtr(const null &inNull) : mPtr(0) { }
|
||||
inline ObjectPtr(const ObjectPtr<OBJ_> &inOther) : mPtr( inOther.mPtr ) { }
|
||||
template<typename T>
|
||||
inline ObjectPtr(const hx::Native<T> &inNative) : mPtr( dynamic_cast<T>(inNative.ptr) ) { }
|
||||
|
||||
template<typename SOURCE_>
|
||||
inline ObjectPtr(const ObjectPtr<SOURCE_> &inObjectPtr)
|
||||
{
|
||||
if (!SetPtr(inObjectPtr.mPtr))
|
||||
CastPtr(inObjectPtr.mPtr,false);
|
||||
}
|
||||
|
||||
|
||||
inline ObjectPtr(const ::cpp::Variant &inVariant)
|
||||
{
|
||||
hx::Object *object = inVariant.asObject();
|
||||
if (!SetPtr(object))
|
||||
CastPtr(object,false);
|
||||
}
|
||||
|
||||
template<typename SOURCE_>
|
||||
inline ObjectPtr(const SOURCE_ *inPtr,bool inCheckCast=true)
|
||||
{
|
||||
if (!SetPtr(const_cast<SOURCE_ *>(inPtr)))
|
||||
CastPtr(const_cast<SOURCE_ *>(inPtr),inCheckCast);
|
||||
}
|
||||
|
||||
inline ObjectPtr &operator=(const null &inNull) { mPtr = 0; return *this; }
|
||||
inline ObjectPtr &operator=(Ptr inRHS) { mPtr = inRHS; return *this; }
|
||||
inline ObjectPtr &operator=(const ObjectPtr &inRHS) { mPtr = inRHS.mPtr; return *this; }
|
||||
template<typename InterfaceImpl>
|
||||
inline ObjectPtr &operator=(InterfaceImpl *inRHS)
|
||||
{
|
||||
mPtr = inRHS->operator Ptr();
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline OBJ_ *GetPtr() const { return mPtr; }
|
||||
inline OBJ_ *operator->()
|
||||
{
|
||||
#ifdef HXCPP_CHECK_POINTER
|
||||
if (!mPtr) NullReference("Object", true);
|
||||
// The handler might have fixed up the null value
|
||||
if (!mPtr) NullReference("Object", false);
|
||||
#ifdef HXCPP_GC_CHECK_POINTER
|
||||
GCCheckPointer(mPtr);
|
||||
#endif
|
||||
#endif
|
||||
return mPtr;
|
||||
}
|
||||
inline const OBJ_ *operator->() const
|
||||
{
|
||||
#ifdef HXCPP_CHECK_POINTER
|
||||
if (!mPtr) NullReference("Object", true);
|
||||
// The handler might have fixed up the null value
|
||||
if (!mPtr) NullReference("Object", false);
|
||||
#ifdef HXCPP_GC_CHECK_POINTER
|
||||
GCCheckPointer(mPtr);
|
||||
#endif
|
||||
#endif
|
||||
return mPtr;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline bool operator==(const T &inTRHS) const
|
||||
{
|
||||
ObjectPtr inRHS(inTRHS.mPtr,false);
|
||||
if (mPtr==inRHS.mPtr) return true;
|
||||
if (!mPtr || !inRHS.mPtr) return false;
|
||||
return !mPtr->__compare(inRHS.mPtr);
|
||||
}
|
||||
inline bool operator==(const cpp::Variant &inRHS) const;
|
||||
inline bool operator!=(const cpp::Variant &inRHS) const;
|
||||
|
||||
template<typename T>
|
||||
inline bool operator!=(const T &inTRHS) const
|
||||
{
|
||||
ObjectPtr inRHS(inTRHS.mPtr,false);
|
||||
if (mPtr==inRHS.mPtr) return false;
|
||||
if (!mPtr || !inRHS.mPtr) return true;
|
||||
return mPtr->__compare(inRHS.mPtr);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
operator hx::Native<T> () { return hx::Native<T>( mPtr ); }
|
||||
|
||||
inline bool operator==(const null &inRHS) const { return mPtr==0; }
|
||||
inline bool operator!=(const null &inRHS) const { return mPtr!=0; }
|
||||
|
||||
//inline bool operator==(const Dynamic &inRHS) const { return inRHS==*this; }
|
||||
//inline bool operator!=(const Dynamic &inRHS) const { return inRHS!=*this; }
|
||||
|
||||
|
||||
// This is defined in the "FieldRef" class...
|
||||
inline class hx::FieldRef FieldRef(const String &inString);
|
||||
inline class hx::IndexRef IndexRef(int inString);
|
||||
inline static hx::Class &__SGetClass() { return OBJ_::__SGetClass(); }
|
||||
|
||||
OBJ_ *mPtr;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
448
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Operators.h
Normal file
448
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Operators.h
Normal file
@ -0,0 +1,448 @@
|
||||
#ifndef HX_OPERATORS_H
|
||||
#define HX_OPERATORS_H
|
||||
|
||||
|
||||
|
||||
template<typename T> bool null::operator == (const hx::ObjectPtr<T> &O) const { return !O.mPtr; }
|
||||
template<typename T> inline bool null::operator != (const hx::ObjectPtr<T> &O) const { return O.mPtr; }
|
||||
|
||||
template<typename T> inline bool null::operator == (const Array<T> &O) const { return !O.mPtr; }
|
||||
template<typename T> inline bool null::operator != (const Array<T> &O) const { return O.mPtr; }
|
||||
inline bool null::operator == (const hx::FieldRef &O) const { return !O.HasPointer(); }
|
||||
inline bool null::operator != (const hx::FieldRef &O) const { return O.HasPointer(); }
|
||||
inline bool null::operator == (const hx::IndexRef &O) const { return !O.HasPointer(); }
|
||||
inline bool null::operator != (const hx::IndexRef &O) const { return O.HasPointer(); }
|
||||
|
||||
inline bool null::operator == (const Dynamic &O) const { return !O.mPtr; }
|
||||
inline bool null::operator != (const Dynamic &O) const { return O.mPtr; }
|
||||
|
||||
inline bool null::operator == (const String &O) const { return !O.raw_ptr(); }
|
||||
inline bool null::operator != (const String &O) const { return O.raw_ptr(); }
|
||||
|
||||
namespace hx {
|
||||
template<typename T> Null<T>::operator Dynamic() { if (isNull) return Dynamic(); return value; }
|
||||
}
|
||||
|
||||
HX_COMPARE_NULL_MOST_OPS(String)
|
||||
HX_COMPARE_NULL_MOST_OPS(Dynamic)
|
||||
HX_COMPARE_NULL_MOST_OPS(hx::FieldRef)
|
||||
HX_COMPARE_NULL_MOST_OPS(hx::IndexRef)
|
||||
|
||||
//HX_NULL_DEFINE_COMPARE_MOST_OPS(String)
|
||||
//HX_NULL_DEFINE_COMPARE_MOST_OPS(Dynamic)
|
||||
//HX_NULL_DEFINE_COMPARE_MOST_OPS(hx::FieldRef)
|
||||
//HX_NULL_DEFINE_COMPARE_MOST_OPS(hx::IndexRef)
|
||||
|
||||
|
||||
// Operators for mixing various types ....
|
||||
|
||||
|
||||
inline String operator+(const cpp::UInt64 &i,const String &s) { return String(i) + s; }
|
||||
inline String operator+(const cpp::Int64 &i,const String &s) { return String(i) + s; }
|
||||
inline String operator+(const int &i,const String &s) { return String(i) + s; }
|
||||
inline String operator+(const unsigned int &i,const String &s) { return String(i) + s; }
|
||||
inline String operator+(const double &d,const String &s) { return String(d) + s; }
|
||||
inline String operator+(const float &d,const String &s) { return String(d) + s; }
|
||||
inline String operator+(const bool &b,const String &s) { return String(b) + s; }
|
||||
inline String operator+(const unsigned char c,const String &s) { return String(c) + s; }
|
||||
inline String operator+(const signed char c,const String &s) { return String(c) + s; }
|
||||
inline String operator+(const unsigned short c,const String &s) { return String(c) + s; }
|
||||
inline String operator+(const signed short c,const String &s) { return String(c) + s; }
|
||||
inline String operator+(const null &n,const String &s) { return String(n) + s; }
|
||||
inline String operator+(const cpp::CppInt32__ &i,const String &s) { return String(i) + s; }
|
||||
|
||||
template<typename T_>
|
||||
inline String operator+(const hx::ObjectPtr<T_> &inLHS,const String &s)
|
||||
{ return (inLHS.mPtr ? const_cast<hx::ObjectPtr<T_> & >(inLHS)->toString() : HX_CSTRING("null") ) + s; }
|
||||
|
||||
/*
|
||||
template<typename LHS_>
|
||||
inline Dynamic operator+(LHS_ inLHS, const hx::FieldRef &inField)
|
||||
{ return inLHS + inField.operator Dynamic(); }
|
||||
|
||||
template<typename LHS_>
|
||||
inline Dynamic operator+(LHS_ inLHS,const hx::IndexRef &inIndexRef)
|
||||
{ return inLHS + inIndexRef.operator Dynamic(); }
|
||||
*/
|
||||
|
||||
// += -= *= /= %= &= |= ^= <<= >>= >>>=
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
template<typename T> inline double ToDouble(T inT) { return 0; }
|
||||
template<typename T> inline double ToDouble(hx::ObjectPtr<T> inObj)
|
||||
{
|
||||
return inObj.mPtr ? inObj.mPtr->__ToDouble() : 0.0;
|
||||
}
|
||||
template<> inline double ToDouble(String inValue) { return __hxcpp_parse_float(inValue); }
|
||||
template<> inline double ToDouble(double inValue) { return inValue; }
|
||||
template<> inline double ToDouble(int inValue) { return inValue; }
|
||||
template<> inline double ToDouble(bool inValue) { return inValue; }
|
||||
template<> inline double ToDouble(float inValue) { return inValue; }
|
||||
template<> inline double ToDouble(cpp::UInt64 inValue) { return inValue; }
|
||||
template<> inline double ToDouble(cpp::Int64 inValue) { return inValue; }
|
||||
template<> inline double ToDouble(null inValue) { return 0; }
|
||||
|
||||
|
||||
|
||||
inline int UShr(int inData,int inShift)
|
||||
{
|
||||
return ((unsigned int)inData) >> inShift;
|
||||
}
|
||||
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES double DoubleMod(double inLHS,double inRHS);
|
||||
|
||||
template<typename TL,typename TR>
|
||||
double Mod(TL inLHS,TR inRHS) { return hx::DoubleMod(inLHS,inRHS); }
|
||||
|
||||
double DivByZero(double d);
|
||||
|
||||
#if !defined(_MSC_VER) || _MSC_VER > 1399
|
||||
inline int Mod(int inLHS,int inRHS)
|
||||
{
|
||||
if (!inRHS)
|
||||
hx::Throw(HX_CSTRING("Mod by 0 Error."));
|
||||
return inLHS % inRHS;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
template<typename L, typename R>
|
||||
inline L& AddEq(L &inLHS, R inRHS) { inLHS = inLHS + inRHS; return inLHS; }
|
||||
template<typename L, typename R>
|
||||
inline L& MultEq(L &inLHS, R inRHS) { inLHS = inLHS * inRHS; return inLHS; }
|
||||
template<typename L, typename R>
|
||||
inline L& DivEq(L &inLHS, R inRHS) { inLHS = (double)inLHS / (double)inRHS; return inLHS; }
|
||||
template<typename L, typename R>
|
||||
inline L& SubEq(L &inLHS, R inRHS) { inLHS = inLHS - inRHS; return inLHS; }
|
||||
template<typename L, typename R>
|
||||
inline L& AndEq(L &inLHS, R inRHS) { inLHS = (int)inLHS & (int)inRHS; return inLHS; }
|
||||
template<typename L, typename R>
|
||||
inline L& OrEq(L &inLHS, R inRHS) { inLHS = (int)inLHS | (int)inRHS; return inLHS; }
|
||||
template<typename L, typename R>
|
||||
inline L& XorEq(L &inLHS, R inRHS) { inLHS = (int)inLHS ^ (int)inRHS; return inLHS; }
|
||||
template<typename L, typename R>
|
||||
inline L& ShlEq(L &inLHS, R inRHS) { inLHS = (int)inLHS << (int)inRHS; return inLHS; }
|
||||
template<typename L, typename R>
|
||||
inline L& ShrEq(L &inLHS, R inRHS) { inLHS = (int)inLHS >> (int)inRHS; return inLHS; }
|
||||
template<typename L, typename R>
|
||||
inline L& UShrEq(L &inLHS, R inRHS) { inLHS = hx::UShr(inLHS,inRHS); return inLHS; }
|
||||
template<typename L, typename R>
|
||||
inline L& ModEq(L &inLHS, R inRHS) { inLHS = DoubleMod(inLHS,inRHS); return inLHS; }
|
||||
|
||||
#if defined(__GNUC__) || defined(__SNC__)
|
||||
template<typename R>
|
||||
inline hx::FieldRef AddEq(hx::FieldRef inLHS, R inRHS) { inLHS = inLHS + inRHS; return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::FieldRef MultEq(hx::FieldRef inLHS, R inRHS) { inLHS = inLHS * inRHS; return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::FieldRef DivEq(hx::FieldRef inLHS, R inRHS) { inLHS = (double)inLHS / (double)inRHS; return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::FieldRef SubEq(hx::FieldRef inLHS, R inRHS) { inLHS = inLHS - inRHS; return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::FieldRef AndEq(hx::FieldRef inLHS, R inRHS) { inLHS = (int)inLHS & (int)inRHS; return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::FieldRef OrEq(hx::FieldRef inLHS, R inRHS) { inLHS = (int)inLHS | (int)inRHS; return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::FieldRef XorEq(hx::FieldRef inLHS, R inRHS) { inLHS = (int)inLHS ^ (int)inRHS; return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::FieldRef ShlEq(hx::FieldRef inLHS, R inRHS) { inLHS = (int)inLHS << (int)inRHS; return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::FieldRef ShrEq(hx::FieldRef inLHS, R inRHS) { inLHS = (int)inLHS >> (int)inRHS; return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::FieldRef UShrEq(hx::FieldRef inLHS, R inRHS) { inLHS = hx::UShr(inLHS,inRHS); return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::FieldRef ModEq(hx::FieldRef inLHS, R inRHS) { inLHS = DoubleMod(inLHS,inRHS); return inLHS; }
|
||||
|
||||
|
||||
template<typename R>
|
||||
inline hx::IndexRef AddEq(hx::IndexRef inLHS, R inRHS) { inLHS = inLHS + inRHS; return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::IndexRef MultEq(hx::IndexRef inLHS, R inRHS) { inLHS = (double)inLHS * (double)inRHS; return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::IndexRef DivEq(hx::IndexRef inLHS, R inRHS) { inLHS = (double)inLHS / (double)inRHS; return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::IndexRef SubEq(hx::IndexRef inLHS, R inRHS) { inLHS = (double)inLHS - (double)inRHS; return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::IndexRef AndEq(hx::IndexRef inLHS, R inRHS) { inLHS = (int)inLHS & (int)inRHS; return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::IndexRef OrEq(hx::IndexRef inLHS, R inRHS) { inLHS = (int)inLHS | (int)inRHS; return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::IndexRef XorEq(hx::IndexRef inLHS, R inRHS) { inLHS = (int)inLHS ^ (int)inRHS; return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::IndexRef ShlEq(hx::IndexRef inLHS, R inRHS) { inLHS = (int)inLHS << (int)inRHS; return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::IndexRef ShrEq(hx::IndexRef inLHS, R inRHS) { inLHS = (int)inLHS >> (int)inRHS; return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::IndexRef UShrEq(hx::IndexRef inLHS, R inRHS) { inLHS = hx::UShr(inLHS,inRHS); return inLHS; }
|
||||
template<typename R>
|
||||
inline hx::IndexRef ModEq(hx::IndexRef inLHS, R inRHS) { inLHS = DoubleMod(inLHS,inRHS); return inLHS; }
|
||||
|
||||
|
||||
|
||||
#endif // __GNUC__ || __SNC__
|
||||
|
||||
template<typename R,typename T>
|
||||
inline hx::__TArrayImplRef<T> AddEq(hx::__TArrayImplRef<T> ref, R inRHS)
|
||||
{ ref.mObject->__set(ref.mIndex, ref.mObject->__get(ref.mIndex) + inRHS); return ref;}
|
||||
|
||||
template<typename R,typename T>
|
||||
inline hx::__TArrayImplRef<T> MultEq(hx::__TArrayImplRef<T> ref, R inRHS)
|
||||
{ ref.mObject->__set(ref.mIndex, ref.mObject->__get(ref.mIndex) * inRHS); return ref;}
|
||||
|
||||
template<typename R,typename T>
|
||||
inline hx::__TArrayImplRef<T> DivEq(hx::__TArrayImplRef<T> ref, R inRHS)
|
||||
{ ref.mObject->__set(ref.mIndex, ref.mObject->__get(ref.mIndex) / inRHS); return ref;}
|
||||
|
||||
template<typename R,typename T>
|
||||
inline hx::__TArrayImplRef<T> SubEq(hx::__TArrayImplRef<T> ref, R inRHS)
|
||||
{ ref.mObject->__set(ref.mIndex, ref.mObject->__get(ref.mIndex) - inRHS); return ref;}
|
||||
|
||||
template<typename T>
|
||||
inline hx::__TArrayImplRef<T> AndEq(hx::__TArrayImplRef<T> ref, int inRHS)
|
||||
{ ref.mObject->__set(ref.mIndex, (int)ref.mObject->__get(ref.mIndex) & inRHS); return ref;}
|
||||
|
||||
template<typename T>
|
||||
inline hx::__TArrayImplRef<T> OrEq(hx::__TArrayImplRef<T> ref, int inRHS)
|
||||
{ ref.mObject->__set(ref.mIndex, (int)ref.mObject->__get(ref.mIndex) | inRHS); return ref;}
|
||||
|
||||
template<typename T>
|
||||
inline hx::__TArrayImplRef<T> XorEq(hx::__TArrayImplRef<T> ref, int inRHS)
|
||||
{ ref.mObject->__set(ref.mIndex, (int)ref.mObject->__get(ref.mIndex) ^ inRHS); return ref;}
|
||||
|
||||
template<typename T>
|
||||
inline hx::__TArrayImplRef<T> ShlEq(hx::__TArrayImplRef<T> ref, int inRHS)
|
||||
{ ref.mObject->__set(ref.mIndex, (int)ref.mObject->__get(ref.mIndex) << inRHS); return ref;}
|
||||
|
||||
template<typename T>
|
||||
inline hx::__TArrayImplRef<T> ShrEq(hx::__TArrayImplRef<T> ref, int inRHS)
|
||||
{ ref.mObject->__set(ref.mIndex, (int)ref.mObject->__get(ref.mIndex) >> inRHS); return ref;}
|
||||
|
||||
template<typename T>
|
||||
inline hx::__TArrayImplRef<T> UShrEq(hx::__TArrayImplRef<T> ref, int inRHS)
|
||||
{ ref.mObject->__set(ref.mIndex, hx::UShr(ref.mObject->__get(ref.mIndex),inRHS)); return ref;}
|
||||
|
||||
template<typename T>
|
||||
inline hx::__TArrayImplRef<T> UShrEq(hx::__TArrayImplRef<T> ref, double inRHS)
|
||||
{ ref.mObject->__set(ref.mIndex, DoubleMod(ref.mObject->__get(ref.mIndex),inRHS)); return ref;}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename T> inline T TCastObject(hx::Object *inObj) { return hx::BadCast(); }
|
||||
template<> inline bool TCastObject<bool>(hx::Object *inObj)
|
||||
{
|
||||
if (!inObj) return false;
|
||||
if (inObj->__GetType()!=::vtBool) return hx::BadCast();
|
||||
return inObj?inObj->__ToInt():0;
|
||||
}
|
||||
template<> inline int TCastObject<int>(hx::Object *inObj)
|
||||
{
|
||||
if (!inObj) return 0;
|
||||
if (!(inObj->__GetType()==::vtInt ||
|
||||
((inObj->__GetType()==::vtFloat || inObj->__GetType()==::vtInt64) && inObj->__ToDouble()==inObj->__ToInt()) ) ) return hx::BadCast();
|
||||
return inObj->__ToInt();
|
||||
}
|
||||
template<> inline double TCastObject<double>(hx::Object *inObj)
|
||||
{
|
||||
if (!inObj) return 0.0;
|
||||
if ((inObj->__GetType()!=::vtFloat && inObj->__GetType()!=::vtInt64 && inObj->__GetType()!=::vtInt))
|
||||
return hx::BadCast();
|
||||
return inObj->__ToDouble();
|
||||
}
|
||||
template<> inline float TCastObject<float>(hx::Object *inObj)
|
||||
{
|
||||
if (!inObj || (inObj->__GetType()!=::vtFloat && inObj->__GetType()!=::vtInt64 && inObj->__GetType()!=::vtInt))
|
||||
return hx::BadCast();
|
||||
return inObj->__ToDouble();
|
||||
}
|
||||
|
||||
template<> inline String TCastObject<String>(hx::Object *inObj)
|
||||
{
|
||||
if (!inObj) return String();
|
||||
if (inObj->__GetType()!=::vtString)
|
||||
return hx::BadCast();
|
||||
return inObj->__ToString();
|
||||
}
|
||||
|
||||
template<> inline null TCastObject<null>(hx::Object *inObj) { return null(); }
|
||||
|
||||
// Cast to scalar
|
||||
template<typename T> struct TCast
|
||||
{
|
||||
template<typename VAL> static inline T cast(VAL inVal ) {
|
||||
T result = TCastObject<T>(Dynamic(inVal).GetPtr());
|
||||
//null string from null is ok...
|
||||
//if (result==null()) hx::BadCast();
|
||||
return result;
|
||||
}
|
||||
|
||||
template<typename INOBJ>
|
||||
static inline T cast(ObjectPtr<INOBJ> inObj )
|
||||
{
|
||||
T result = TCastObject<T>(inObj.GetPtr());
|
||||
if (result==null()) hx::BadCast();
|
||||
return result;
|
||||
}
|
||||
|
||||
template<typename INOBJ>
|
||||
static inline T cast(Array<INOBJ> inObj ) { return hx::BadCast(); }
|
||||
|
||||
};
|
||||
|
||||
// Cast to object
|
||||
template<typename T> struct TCast< ObjectPtr<T> >
|
||||
{
|
||||
template<typename VAL> static inline ObjectPtr<T> cast(VAL inVal ) {
|
||||
ObjectPtr<T> result = Dynamic(inVal);
|
||||
if (result==null() && inVal!=null()) BadCast();
|
||||
return result;
|
||||
}
|
||||
|
||||
template<typename INOBJ>
|
||||
static inline ObjectPtr<T> cast(ObjectPtr<INOBJ> inObj )
|
||||
{
|
||||
ObjectPtr<T> result = ObjectPtr<T>(inObj);
|
||||
if (result==null() && inObj!=null()) hx::BadCast();
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
#if (HXCPP_API_LEVEL >= 330)
|
||||
template< > struct TCast< cpp::VirtualArray >
|
||||
{
|
||||
template<typename VAL> static inline cpp::VirtualArray cast(VAL inVal ) {
|
||||
return cpp::VirtualArray(inVal);
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
|
||||
// Cast to struct
|
||||
template<typename T,typename H> struct TCast< cpp::Struct<T,H> >
|
||||
{
|
||||
static inline cpp::Struct<T,H> cast( const cpp::Struct<T,H> &inObj ) { return inObj; }
|
||||
};
|
||||
|
||||
|
||||
inline Array<Dynamic> TCastToArray(Dynamic inVal)
|
||||
{
|
||||
Dynamic result = inVal;
|
||||
if (result==null() && inVal!=null()) hx::BadCast();
|
||||
return inVal;
|
||||
}
|
||||
|
||||
template<typename PTRTYPE> struct DynamicConvertType { enum { Convert = aciNotArray }; };
|
||||
|
||||
// Always convert ...
|
||||
template<> struct DynamicConvertType< hx::Interface * > { enum { Convert = aciAlwaysConvert }; };
|
||||
template<> struct DynamicConvertType< Array_obj<Dynamic> * > { enum { Convert = aciObjectArray }; };
|
||||
template<> struct DynamicConvertType< Array_obj< ::String> * > { enum { Convert = aciStringArray }; };
|
||||
template<typename T> struct DynamicConvertType< Array_obj<T> * > { enum { Convert = sizeof(T) }; };
|
||||
#if (HXCPP_API_LEVEL >= 330)
|
||||
template<> struct DynamicConvertType< cpp::VirtualArray_obj * > { enum { Convert = aciVirtualArray }; };
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<typename RESULT>
|
||||
inline RESULT Dynamic::StaticCast() const
|
||||
{
|
||||
typedef typename RESULT::Ptr type;
|
||||
|
||||
const int convertId = (int)hx::DynamicConvertType<type>::Convert;
|
||||
if (convertId!=hx::aciNotArray && mPtr && convertId!=((hx::ArrayCommon *)mPtr)->getArrayConvertId())
|
||||
{
|
||||
// Constructing the result from the Dynamic value will check for a conversion
|
||||
// using something like dynamic_cast
|
||||
return *this;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Simple reinterpret_cast
|
||||
return (typename RESULT::Ptr)mPtr;
|
||||
}
|
||||
}
|
||||
|
||||
namespace hx
|
||||
{
|
||||
inline bool IsInterfacePtr(...) { return false; }
|
||||
inline bool IsInterfacePtr(const hx::Interface *) { return true; }
|
||||
}
|
||||
|
||||
template<typename VALUE>
|
||||
inline void __hxcpp_unsafe_set(hx::ObjectPtr<VALUE> &outForced, const Dynamic &inD)
|
||||
{
|
||||
if (hx::IsInterfacePtr(outForced.mPtr))
|
||||
{
|
||||
hx::Throw(HX_CSTRING("unsafe set of interfaces not supported yet."));
|
||||
outForced.mPtr = (VALUE *)(inD.mPtr);
|
||||
}
|
||||
else
|
||||
{
|
||||
#if (HXCPP_API_LEVEL >= 331)
|
||||
outForced.mPtr = (VALUE *)(inD.mPtr);
|
||||
#else
|
||||
outForced.mPtr = (VALUE *)(inD.mPtr ? inD.mPtr->__GetRealObject() : 0);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
namespace hx
|
||||
{
|
||||
class HXCPP_EXTERN_CLASS_ATTRIBUTES StringValueIterator : public cpp::StringIterator<int>
|
||||
{
|
||||
public:
|
||||
StringValueIterator(const String &inValue) : StringIterator(inValue) { }
|
||||
|
||||
int next() { return value.cca(pos++); }
|
||||
};
|
||||
|
||||
class HXCPP_EXTERN_CLASS_ATTRIBUTES StringKeyValueIterator : public cpp::StringIterator<Dynamic>
|
||||
{
|
||||
public:
|
||||
StringKeyValueIterator(const String &inValue) : StringIterator(inValue) { }
|
||||
|
||||
Dynamic next() {
|
||||
int p = pos;
|
||||
return
|
||||
hx::AnonStruct2_obj< int,int >::Create(HX_("key",9f,89,51,00),p,
|
||||
HX_("value",71,7f,b8,31), value.cca(pos++) );
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
Dynamic String::iterator()
|
||||
{
|
||||
return new hx::StringValueIterator(*this);
|
||||
}
|
||||
|
||||
|
||||
Dynamic String::keyValueIterator()
|
||||
{
|
||||
return new hx::StringKeyValueIterator(*this);
|
||||
}
|
||||
|
||||
namespace hx
|
||||
{
|
||||
template<typename FROM, typename TO> Dynamic hx::ArrayKeyValueIterator<FROM, TO>::next()
|
||||
{
|
||||
int p = mIdx++;
|
||||
return
|
||||
hx::AnonStruct2_obj< int,TO >::Create(HX_("key",9f,89,51,00),p,
|
||||
HX_("value",71,7f,b8,31), toTo(mArray->__get(p)) );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
204
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/QuickVec.h
Normal file
204
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/QuickVec.h
Normal file
@ -0,0 +1,204 @@
|
||||
#ifndef HX_QUICKVEC_INCLUDED
|
||||
#define HX_QUICKVEC_INCLUDED
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <algorithm>
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
template<typename T>
|
||||
struct QuickVec
|
||||
{
|
||||
int mAlloc;
|
||||
int mSize;
|
||||
T *mPtr;
|
||||
|
||||
QuickVec() : mPtr(0), mAlloc(0), mSize(0) { }
|
||||
~QuickVec()
|
||||
{
|
||||
if (mPtr)
|
||||
free(mPtr);
|
||||
}
|
||||
|
||||
inline void push(const T &inT)
|
||||
{
|
||||
if (mSize+1>mAlloc)
|
||||
{
|
||||
mAlloc = 10 + (mSize*3/2);
|
||||
mPtr = (T *)realloc(mPtr,sizeof(T)*mAlloc);
|
||||
}
|
||||
mPtr[mSize]=inT;
|
||||
mSize++;
|
||||
}
|
||||
void swap(QuickVec<T> &inOther)
|
||||
{
|
||||
std::swap(mAlloc, inOther.mAlloc);
|
||||
std::swap(mSize, inOther.mSize);
|
||||
std::swap(mPtr, inOther.mPtr);
|
||||
}
|
||||
T *setSize(int inSize)
|
||||
{
|
||||
if (inSize>mAlloc)
|
||||
{
|
||||
mAlloc = inSize;
|
||||
mPtr = (T *)realloc(mPtr,sizeof(T)*mAlloc);
|
||||
}
|
||||
mSize = inSize;
|
||||
return mPtr;
|
||||
}
|
||||
// Can push this many without realloc
|
||||
bool hasExtraCapacity(int inN)
|
||||
{
|
||||
return mSize+inN<=mAlloc;
|
||||
}
|
||||
|
||||
bool safeReserveExtra(int inN)
|
||||
{
|
||||
int want = mSize + inN;
|
||||
if (want>mAlloc)
|
||||
{
|
||||
int wantAlloc = 10 + (mSize*3/2);
|
||||
if (wantAlloc<want)
|
||||
wantAlloc = want;
|
||||
T *newBuffer = (T *)malloc( sizeof(T)*wantAlloc );
|
||||
if (!newBuffer)
|
||||
return false;
|
||||
mAlloc = wantAlloc;
|
||||
if (mPtr)
|
||||
{
|
||||
memcpy(newBuffer, mPtr, mSize*sizeof(T));
|
||||
free(mPtr);
|
||||
}
|
||||
mPtr = newBuffer;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
inline void pop_back() { --mSize; }
|
||||
inline T &back() { return mPtr[mSize-1]; }
|
||||
inline T pop()
|
||||
{
|
||||
return mPtr[--mSize];
|
||||
}
|
||||
inline void qerase(int inPos)
|
||||
{
|
||||
--mSize;
|
||||
mPtr[inPos] = mPtr[mSize];
|
||||
}
|
||||
inline void erase(int inPos)
|
||||
{
|
||||
--mSize;
|
||||
if (mSize>inPos)
|
||||
memmove(mPtr+inPos, mPtr+inPos+1, (mSize-inPos)*sizeof(T));
|
||||
}
|
||||
void zero() { memset(mPtr,0,mSize*sizeof(T) ); }
|
||||
|
||||
inline bool qerase_val(T inVal)
|
||||
{
|
||||
for(int i=0;i<mSize;i++)
|
||||
if (mPtr[i]==inVal)
|
||||
{
|
||||
--mSize;
|
||||
mPtr[i] = mPtr[mSize];
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool some_left() { return mSize; }
|
||||
inline bool empty() const { return !mSize; }
|
||||
inline void clear() { mSize = 0; }
|
||||
inline int next()
|
||||
{
|
||||
if (mSize+1>=mAlloc)
|
||||
{
|
||||
mAlloc = 10 + (mSize*3/2);
|
||||
mPtr = (T *)realloc(mPtr,sizeof(T)*mAlloc);
|
||||
}
|
||||
return mSize++;
|
||||
}
|
||||
inline int size() const { return mSize; }
|
||||
inline T &operator[](int inIndex) { return mPtr[inIndex]; }
|
||||
inline const T &operator[](int inIndex) const { return mPtr[inIndex]; }
|
||||
|
||||
private:
|
||||
QuickVec(const QuickVec<T> &);
|
||||
void operator =(const QuickVec<T> &);
|
||||
};
|
||||
|
||||
|
||||
template<typename T>
|
||||
class QuickDeque
|
||||
{
|
||||
struct Slab
|
||||
{
|
||||
T mElems[1024];
|
||||
};
|
||||
|
||||
QuickVec<Slab *> mSpare;
|
||||
QuickVec<Slab *> mActive;
|
||||
|
||||
int mHeadPos;
|
||||
int mTailPos;
|
||||
Slab *mHead;
|
||||
Slab *mTail;
|
||||
|
||||
public:
|
||||
|
||||
QuickDeque()
|
||||
{
|
||||
mHead = mTail = 0;
|
||||
mHeadPos = 1024;
|
||||
mTailPos = 1024;
|
||||
}
|
||||
~QuickDeque()
|
||||
{
|
||||
for(int i=0;i<mSpare.size();i++)
|
||||
delete mSpare[i];
|
||||
for(int i=0;i<mActive.size();i++)
|
||||
delete mActive[i];
|
||||
delete mHead;
|
||||
if (mTail!=mHead)
|
||||
delete mTail;
|
||||
}
|
||||
inline void push(T inObj)
|
||||
{
|
||||
if (mHeadPos<1024)
|
||||
{
|
||||
mHead->mElems[mHeadPos++] = inObj;
|
||||
return;
|
||||
}
|
||||
if (mHead != mTail)
|
||||
mActive.push(mHead);
|
||||
mHead = mSpare.empty() ? new Slab : mSpare.pop();
|
||||
mHead->mElems[0] = inObj;
|
||||
mHeadPos = 1;
|
||||
}
|
||||
inline bool some_left() { return mHead!=mTail || mHeadPos!=mTailPos; }
|
||||
inline T pop()
|
||||
{
|
||||
if (mTailPos<1024)
|
||||
return mTail->mElems[mTailPos++];
|
||||
if (mTail)
|
||||
mSpare.push(mTail);
|
||||
if (mActive.empty())
|
||||
{
|
||||
mTail = mHead;
|
||||
}
|
||||
else
|
||||
{
|
||||
mTail = mActive[0];
|
||||
mActive.erase(0);
|
||||
}
|
||||
mTailPos = 1;
|
||||
return mTail->mElems[0];
|
||||
}
|
||||
|
||||
private:
|
||||
QuickDeque(const QuickDeque<T> &);
|
||||
void operator=(const QuickDeque<T> &);
|
||||
};
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
#endif
|
||||
289
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Scriptable.h
Normal file
289
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Scriptable.h
Normal file
@ -0,0 +1,289 @@
|
||||
#ifndef INCLUDED_HX_SCRIPTABLE
|
||||
#define INCLUDED_HX_SCRIPTABLE
|
||||
|
||||
#include <typeinfo>
|
||||
#ifdef __clang__
|
||||
#pragma clang diagnostic ignored "-Winvalid-offsetof"
|
||||
#endif
|
||||
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
extern bool gEnableJit;
|
||||
inline void EnableJit(bool inEnable) { gEnableJit = inEnable; }
|
||||
|
||||
#define HXCPP_CPPIA_SUPER_ARG(x) , (x)
|
||||
|
||||
struct ScriptNamedFunction : public ScriptFunction
|
||||
{
|
||||
ScriptNamedFunction(const ScriptFunction &s) : ScriptFunction(s), name(0), isStatic(false), superExecute(0) { }
|
||||
|
||||
ScriptNamedFunction(const char *inName=0,StackExecute inExe=0,const char *inSig=0, bool inIsStatic=false, StackExecute superExecute=0)
|
||||
: ScriptFunction(inExe, inSig), name(inName), isStatic(inIsStatic), superExecute(superExecute) { }
|
||||
|
||||
const char *name;
|
||||
bool isStatic;
|
||||
StackExecute superExecute;
|
||||
};
|
||||
|
||||
|
||||
inline void SetFloatAligned(void *inPtr, const Float &inValue)
|
||||
{
|
||||
#ifdef HXCPP_ALIGN_FLOAT
|
||||
int *dest = (int *)inPtr;
|
||||
const int *src = (const int *)&inValue;
|
||||
dest[1] = src[1];
|
||||
#else
|
||||
*(Float *)inPtr = inValue;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
inline Float GetFloatAligned(const void *inPtr)
|
||||
{
|
||||
#ifdef HXCPP_ALIGN_FLOAT
|
||||
Float result;
|
||||
int *dest = (int *)&result;
|
||||
const int *src = (const int *)inPtr;
|
||||
dest[0] = src[0];
|
||||
dest[1] = src[1];
|
||||
return result;
|
||||
#else
|
||||
return *(Float *)inPtr;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
inline void StackContext::pushFloat(Float f)
|
||||
{
|
||||
SetFloatAligned(pointer, f);
|
||||
pointer += sizeof(Float);
|
||||
}
|
||||
inline void StackContext::pushString(const String &s)
|
||||
{
|
||||
*(String *)pointer = s;
|
||||
pointer += sizeof(String);
|
||||
}
|
||||
|
||||
inline void StackContext::pushObject(Dynamic d)
|
||||
{
|
||||
*(hx::Object **)pointer = d.mPtr;
|
||||
pointer += sizeof(hx::Object *);
|
||||
}
|
||||
|
||||
inline void StackContext::returnFloat(Float f)
|
||||
{
|
||||
SetFloatAligned(frame, f);
|
||||
}
|
||||
inline void StackContext::returnString(const String &s)
|
||||
{
|
||||
*(String *)frame = s;
|
||||
}
|
||||
inline void StackContext::returnObject(Dynamic d)
|
||||
{
|
||||
*(hx::Object **)frame = d.mPtr;
|
||||
}
|
||||
|
||||
inline hx::Object *StackContext::getThis(bool inCheckPtr)
|
||||
{
|
||||
#ifdef HXCPP_CHECK_POINTER
|
||||
if (inCheckPtr)
|
||||
{
|
||||
if (!*(hx::Object **)frame) NullReference("This", false);
|
||||
#ifdef HXCPP_GC_CHECK_POINTER
|
||||
GCCheckPointer(*(hx::Object **)frame);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
return *(hx::Object **)frame;
|
||||
}
|
||||
|
||||
|
||||
inline Float StackContext::getFloat(int inPos)
|
||||
{
|
||||
return GetFloatAligned(frame+inPos);
|
||||
}
|
||||
inline String StackContext::getString(int inPos)
|
||||
{
|
||||
return *(String *)(frame+inPos);
|
||||
}
|
||||
inline Dynamic StackContext::getObject(int inPos)
|
||||
{
|
||||
return *(hx::Object **)(frame+inPos);
|
||||
}
|
||||
|
||||
|
||||
enum SignatureChar
|
||||
{
|
||||
sigVoid = 'v',
|
||||
sigBool = 'b',
|
||||
sigInt = 'i',
|
||||
sigFloat = 'f',
|
||||
sigString = 's',
|
||||
sigObject = 'o',
|
||||
};
|
||||
|
||||
|
||||
|
||||
struct AutoStack
|
||||
{
|
||||
CppiaCtx *ctx;
|
||||
unsigned char *pointer;
|
||||
unsigned char *frame;
|
||||
|
||||
AutoStack(CppiaCtx *inCtx) : ctx(inCtx)
|
||||
{
|
||||
frame = ctx->frame;
|
||||
pointer = ctx->pointer;
|
||||
ctx->frame = pointer;
|
||||
}
|
||||
AutoStack(CppiaCtx *inCtx,unsigned char *inPointer) : ctx(inCtx)
|
||||
{
|
||||
frame = ctx->frame;
|
||||
pointer = inPointer;
|
||||
ctx->frame = pointer;
|
||||
}
|
||||
|
||||
~AutoStack()
|
||||
{
|
||||
ctx->pointer = pointer;
|
||||
ctx->frame = frame;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
typedef hx::Object * (*ScriptableClassFactory)(void **inVTable,int inDataSize);
|
||||
typedef hx::Object * (*ScriptableInterfaceFactory)(void **inVTable,::hx::Object *);
|
||||
|
||||
void ScriptableRegisterClass( String inName, int inBaseSize, ScriptNamedFunction *inFunctions, ScriptableClassFactory inFactory, ScriptFunction inConstruct);
|
||||
|
||||
|
||||
#if (HXCPP_API_LEVEL >= 330)
|
||||
void ScriptableRegisterInterface( String inName, ScriptNamedFunction *inFunctions, void *inInterfacePointers);
|
||||
void ScriptableRegisterNameSlots(const char *inNames[], int inLength);
|
||||
|
||||
#else
|
||||
void ScriptableRegisterInterface( String inName, ScriptNamedFunction *inFunctions,const hx::type_info *inType, ScriptableInterfaceFactory inFactory);
|
||||
#endif
|
||||
|
||||
::String ScriptableToString(void *);
|
||||
hx::Class ScriptableGetClass(void *);
|
||||
int ScriptableGetType(void *);
|
||||
void ScriptableMark(void *, hx::Object *, HX_MARK_PARAMS);
|
||||
void ScriptableVisit(void *, hx::Object *, HX_VISIT_PARAMS);
|
||||
bool ScriptableField(hx::Object *, const ::String &,hx::PropertyAccess inCallProp,Dynamic &outResult);
|
||||
bool ScriptableField(hx::Object *, int inName,hx::PropertyAccess inCallProp,Float &outResult);
|
||||
bool ScriptableField(hx::Object *, int inName,hx::PropertyAccess inCallProp,Dynamic &outResult);
|
||||
void ScriptableGetFields(hx::Object *inObject, Array< ::String> &outFields);
|
||||
bool ScriptableSetField(hx::Object *, const ::String &, Dynamic inValue,hx::PropertyAccess inCallProp, Dynamic &outValue);
|
||||
|
||||
|
||||
class CppiaLoadedModule_obj : public ::hx::Object
|
||||
{
|
||||
public:
|
||||
virtual void run() = 0;
|
||||
virtual void boot() = 0;
|
||||
virtual ::hx::Class resolveClass( ::String inName) = 0;
|
||||
};
|
||||
typedef ::hx::ObjectPtr<CppiaLoadedModule_obj> CppiaLoadedModule;
|
||||
|
||||
|
||||
|
||||
} // End namespace hx
|
||||
|
||||
void __scriptable_load_neko(String inName);
|
||||
void __scriptable_load_cppia(String inCode);
|
||||
::hx::CppiaLoadedModule __scriptable_cppia_from_string(String inCode);
|
||||
::hx::CppiaLoadedModule __scriptable_cppia_from_data(Array<unsigned char> inBytes);
|
||||
void __scriptable_load_neko_bytes(Array<unsigned char> inBytes);
|
||||
void __scriptable_load_abc(Array<unsigned char> inBytes);
|
||||
|
||||
#if (HXCPP_API_LEVEL >= 330)
|
||||
|
||||
#define HX_SCRIPTABLE_REGISTER_INTERFACE(name,class) \
|
||||
hx::ScriptableRegisterInterface( HX_CSTRING(name), __scriptableFunctions, & class##_scriptable )
|
||||
|
||||
#else
|
||||
|
||||
#define HX_SCRIPTABLE_REGISTER_INTERFACE(name,class) \
|
||||
hx::ScriptableRegisterInterface( HX_CSTRING(name), __scriptableFunctions, &typeid(class), class##__scriptable::__script_create )
|
||||
|
||||
#endif
|
||||
|
||||
#define HX_SCRIPTABLE_REGISTER_CLASS(name,class) \
|
||||
hx::ScriptableRegisterClass( HX_CSTRING(name), (int)offsetof(class##__scriptable,__scriptVTable) + sizeof(void *), __scriptableFunctions, class##__scriptable::__script_create, class##__scriptable::__script_construct )
|
||||
|
||||
|
||||
#ifdef HXCPP_VISIT_ALLOCS
|
||||
#define SCRIPTABLE_VISIT_FUNCTION \
|
||||
void __Visit(HX_VISIT_PARAMS) { super::__Visit(HX_VISIT_ARG); hx::ScriptableVisit(__scriptVTable[-1],this,HX_VISIT_ARG); }
|
||||
#else
|
||||
#define SCRIPTABLE_VISIT_FUNCTION
|
||||
#endif
|
||||
|
||||
|
||||
#define HX_DEFINE_SCRIPTABLE(ARG_LIST) \
|
||||
inline void *operator new( size_t inSize, int inExtraDataSize ) \
|
||||
{ \
|
||||
return hx::InternalNew(inSize + inExtraDataSize,true); \
|
||||
} \
|
||||
inline void operator delete(void *,int) {} \
|
||||
public: \
|
||||
void **__scriptVTable; \
|
||||
static hx::Object *__script_create(void **inVTable, int inExtra) { \
|
||||
__ME *result = new (inExtra) __ME(); \
|
||||
result->__scriptVTable = inVTable; \
|
||||
return result; } \
|
||||
void ** __GetScriptVTable() { return __scriptVTable; } \
|
||||
::String toString() { if (__scriptVTable[0] ) \
|
||||
{ hx::CppiaCtx *ctx = hx::CppiaCtx::getCurrent(); hx::AutoStack a(ctx); ctx->pushObject(this); return ctx->runString(__scriptVTable[0]); } \
|
||||
else return __superString::toString(); } \
|
||||
::String __ToString() const { return hx::ScriptableToString(__scriptVTable[-1]); } \
|
||||
hx::Class __GetClass() const { return hx::ScriptableGetClass(__scriptVTable[-1]); } \
|
||||
int __GetType() const { return hx::ScriptableGetType(__scriptVTable[-1]); } \
|
||||
void __Mark(HX_MARK_PARAMS) { super::__Mark(HX_MARK_ARG); hx::ScriptableMark(__scriptVTable[-1],this,HX_MARK_ARG); } \
|
||||
SCRIPTABLE_VISIT_FUNCTION
|
||||
|
||||
|
||||
|
||||
#define HX_DEFINE_SCRIPTABLE_INTERFACE \
|
||||
void **__scriptVTable; \
|
||||
Dynamic mDelegate; \
|
||||
hx::Object *__GetRealObject() { return mDelegate.mPtr; } \
|
||||
SCRIPTABLE_VISIT_FUNCTION \
|
||||
void ** __GetScriptVTable() { return __scriptVTable; } \
|
||||
public: \
|
||||
static hx::Object *__script_create(void **inVTable,hx::Object *inDelegate) { \
|
||||
__ME *result = new __ME(); \
|
||||
result->__scriptVTable = inVTable; \
|
||||
result->mDelegate = inDelegate; \
|
||||
return result; }
|
||||
|
||||
|
||||
|
||||
#define HX_DEFINE_SCRIPTABLE_DYNAMIC \
|
||||
\
|
||||
hx::Val __Field(const ::String &inName,hx::PropertyAccess inCallProp) \
|
||||
{ Dynamic result; if (hx::ScriptableField(this,inName,inCallProp,result)) return result; return super::__Field(inName,inCallProp); } \
|
||||
Float __INumField(int inFieldID) \
|
||||
{ Float result; if (hx::ScriptableField(this,inFieldID,hx::paccAlways,result)) return result; return super::__INumField(inFieldID); } \
|
||||
Dynamic __IField(int inFieldID) \
|
||||
{ Dynamic result; if (hx::ScriptableField(this,inFieldID,hx::paccAlways,result)) return result; return super::__IField(inFieldID); } \
|
||||
hx::Val __SetField(const ::String &inName,const hx::Val &inValue,hx::PropertyAccess inCallProp) \
|
||||
{ \
|
||||
Dynamic value; \
|
||||
if (hx::ScriptableSetField(this, inName, inValue,inCallProp,value)) \
|
||||
return value; \
|
||||
return super::__SetField(inName,inValue,inCallProp); \
|
||||
} \
|
||||
void __GetFields(Array< ::String> &outFields) \
|
||||
{ super::__GetFields(outFields); hx::ScriptableGetFields(this,outFields); }
|
||||
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
752
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/StackContext.h
Normal file
752
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/StackContext.h
Normal file
@ -0,0 +1,752 @@
|
||||
#ifndef HX_STACK_CONTEXT_H
|
||||
#define HX_STACK_CONTEXT_H
|
||||
|
||||
#include "QuickVec.h"
|
||||
|
||||
#ifdef HXCPP_SINGLE_THREADED_APP
|
||||
#define HX_CTX_GET ::hx::gMainThreadContext
|
||||
#else
|
||||
#define HX_CTX_GET ((::hx::StackContext *)::hx::tlsStackContext)
|
||||
#endif
|
||||
|
||||
// Set:
|
||||
// HXCPP_STACK_LINE if stack line numbers need to be tracked
|
||||
// HXCPP_STACK_TRACE if stack frames need to be tracked
|
||||
|
||||
// Keep track of lines - more accurate stack traces for exceptions, also
|
||||
// needed for the debugger
|
||||
#if (defined(HXCPP_DEBUG) || defined(HXCPP_DEBUGGER)) && !defined(HXCPP_STACK_LINE)
|
||||
#define HXCPP_STACK_LINE
|
||||
#endif
|
||||
|
||||
// Do we need to keep a stack trace - for basic exception handelling, also needed for the debugger
|
||||
// At a minimum, you can track the functions calls and nothing else
|
||||
#if (defined(HXCPP_STACK_LINE) || defined(HXCPP_TELEMETRY) || defined(HXCPP_PROFILER) || defined(HXCPP_DEBUG)) && !defined(HXCPP_STACK_TRACE)
|
||||
#define HXCPP_STACK_TRACE
|
||||
#endif
|
||||
|
||||
#if defined(HXCPP_STACK_TRACE) && defined(HXCPP_SCRIPTABLE)
|
||||
#define HXCPP_STACK_SCRIPTABLE
|
||||
#endif
|
||||
// HXCPP_DEBUG_HASH == HXCPP_DEBUGGER
|
||||
// HXCPP_STACK_VARS == HXCPP_DEBUGGER
|
||||
|
||||
|
||||
// HX_STACKFRAME(pos) - tracks position according to define. May be optimized away.
|
||||
// HX_GC_STACKFRAME(pos) - tracks position according to define, but is never optimized away
|
||||
// HX_JUST_GC_STACKFRAME - never tracks position, never optimized away
|
||||
|
||||
// Setup the _hx_stackframe variable
|
||||
#ifdef HXCPP_STACK_TRACE
|
||||
// Setup the 'HX_DEFINE_STACK_FRAME' 'HX_LOCAL_STACK_FRAME' macro.
|
||||
// This will be empty, just track functions(release), track functions and lines(debug) or track everything (debugger)
|
||||
#define HX_DECLARE_STACK_FRAME(name) extern ::hx::StackPosition name;
|
||||
|
||||
#ifdef HXCPP_STACK_LINE
|
||||
|
||||
#ifdef HXCPP_DEBUGGER
|
||||
#define HX_DEFINE_STACK_FRAME(varName, className, functionName, classFunctionHash, fullName,fileName, \
|
||||
lineNumber, fileHash ) \
|
||||
::hx::StackPosition varName(className, functionName, fullName, fileName, lineNumber, \
|
||||
classFunctionHash, fileHash);
|
||||
#else
|
||||
#define HX_DEFINE_STACK_FRAME(varName, className, functionName, classFunctionHash, fullName,fileName, \
|
||||
lineNumber, fileHash ) \
|
||||
::hx::StackPosition varName(className, functionName, fullName, fileName, lineNumber);
|
||||
#endif
|
||||
#else
|
||||
|
||||
#define HX_DEFINE_STACK_FRAME(varName, className, functionName, classFunctionHash, fullName,fileName, \
|
||||
lineNumber, fileHash ) \
|
||||
::hx::StackPosition varName(className, functionName, fullName, fileName);
|
||||
|
||||
#endif
|
||||
|
||||
#define HX_LOCAL_STACK_FRAME(a,b,c,d,e,f,g,h) static HX_DEFINE_STACK_FRAME(a,b,c,d,e,f,g,h)
|
||||
|
||||
// Haxe < 330 does not create position pointers, and we must use a local one.
|
||||
// This code will hst the 'HX_STACK_FRAME' macro
|
||||
#define HX_STACK_FRAME(className, functionName, classFunctionHash, fullName,fileName, lineNumber, fileHash ) \
|
||||
HX_DEFINE_STACK_FRAME(__stackPosition, className, functionName, classFunctionHash, fullName,fileName, lineNumber, fileHash ) \
|
||||
::hx::StackFrame _hx_stackframe(&__stackPosition);
|
||||
|
||||
// Newer code will use the HX_STACKFRAME macro
|
||||
#define HX_STACKFRAME(pos) ::hx::StackFrame _hx_stackframe(pos);
|
||||
#define HX_GC_STACKFRAME(pos) ::hx::StackFrame _hx_stackframe(pos);
|
||||
|
||||
// Must record the stack state at the catch
|
||||
#define HX_STACK_BEGIN_CATCH __hxcpp_stack_begin_catch();
|
||||
#define HX_JUST_GC_STACKFRAME ::hx::JustGcStackFrame _hx_stackframe;
|
||||
#define HX_CTX _hx_stackframe.ctx
|
||||
#else
|
||||
// No need to track frame
|
||||
#define HX_DECLARE_STACK_FRAME(name)
|
||||
#define HX_STACK_BEGIN_CATCH
|
||||
#define HX_DEFINE_STACK_FRAME(__stackPosition, className, functionName, classFunctionHash, fullName,fileName, lineNumber, fileHash )
|
||||
#define HX_LOCAL_STACK_FRAME(a,b,c,d,e,f,g,h)
|
||||
#define HX_STACK_FRAME(className, functionName, classFunctionHash, fullName,fileName, lineNumber, fileHash )
|
||||
#define HX_STACKFRAME(pos)
|
||||
#define HX_JUST_GC_STACKFRAME ::hx::StackContext *_hx_ctx = HX_CTX_GET;
|
||||
#define HX_GC_STACKFRAME(pos) HX_JUST_GC_STACKFRAME
|
||||
#define HX_CTX _hx_ctx
|
||||
#endif
|
||||
|
||||
#define HX_GC_CTX HX_CTX
|
||||
|
||||
|
||||
// Setup debugger catchable and variable macros...
|
||||
#ifdef HXCPP_DEBUGGER
|
||||
|
||||
// Emitted at the beginning of every instance fuction. ptr is "this".
|
||||
// Only if stack variables are to be tracked
|
||||
#define HX_STACK_THIS(ptr) ::hx::StackThis __stackthis(_hx_stackframe.variables, ptr);
|
||||
|
||||
// Emitted at the beginning of every function that takes arguments.
|
||||
// name is the name of the argument.
|
||||
// For the lifetime of this object, the argument will be in the [arguments]
|
||||
// list of the stack frame in which the arg was declared
|
||||
// Only if stack variables are to be tracked
|
||||
#define HX_STACK_ARG(cpp_var, haxe_name) \
|
||||
::hx::StackVariable __stackargument_##cpp_var(_hx_stackframe.variables, true, haxe_name, &cpp_var);
|
||||
|
||||
// Emitted whenever a Haxe value is pushed on the stack. cpp_var is the local
|
||||
// cpp variable, haxe_name is the name that was used in haxe for it
|
||||
// Only if stack variables are to be tracked
|
||||
#define HX_STACK_VAR(cpp_var, haxe_name) \
|
||||
::hx::StackVariable __stackvariable_##cpp_var(_hx_stackframe.variables, false, haxe_name, &cpp_var);
|
||||
|
||||
#define HX_STACK_CATCHABLE(T, n) \
|
||||
hx::StackCatchable __stackcatchable_##n \
|
||||
(_hx_stackframe, reinterpret_cast<T *>(&_hx_stackframe));
|
||||
|
||||
// If HXCPP_DEBUGGER is enabled, then a throw is checked to see if it
|
||||
// can be caught and if not, the debugger is entered. Otherwise, the
|
||||
// throw proceeds as normal.
|
||||
#define HX_STACK_DO_THROW(e) __hxcpp_dbg_checkedThrow(e)
|
||||
#define HX_STACK_DO_RETHROW(e) __hxcpp_dbg_checkedRethrow(e)
|
||||
|
||||
|
||||
#define HX_VAR(type,name) type name; HX_STACK_VAR(name, #name)
|
||||
#define HX_VARI(type,name) type name; HX_STACK_VAR(name, #name) name
|
||||
#define HX_VAR_NAME(type,name,dbgName) type name; HX_STACK_VAR(name, dbgName)
|
||||
#define HX_VARI_NAME(type,name,dbgName) type name; HX_STACK_VAR(name, dbgName) name
|
||||
|
||||
#else // Non-debugger versions. Just stub-out.
|
||||
|
||||
#define HX_STACK_THIS(ptr)
|
||||
#define HX_STACK_ARG(cpp_var, haxe_name)
|
||||
#define HX_STACK_VAR(cpp_var, haxe_name)
|
||||
#define HX_STACK_CATCHABLE(T, n)
|
||||
|
||||
#define HX_VAR(type,name) type name
|
||||
#define HX_VARI(type,name) type name
|
||||
#define HX_VAR_NAME(type,name,dbgName) type name
|
||||
#define HX_VARI_NAME(type,name,dbgName) type name
|
||||
|
||||
// Just throw - move to hx::Throw function?
|
||||
#define HX_STACK_DO_THROW(e) ::hx::Throw(e)
|
||||
#define HX_STACK_DO_RETHROW(e) ::hx::Rethrow(e)
|
||||
#endif // HXCPP_STACK_VARS
|
||||
|
||||
|
||||
|
||||
|
||||
// Emitted after every Haxe line. number is the original Haxe line number.
|
||||
// Only if stack lines are to be tracked
|
||||
#ifdef HXCPP_STACK_LINE
|
||||
// If the debugger is enabled, must check for a breakpoint at every line.
|
||||
#ifdef HXCPP_DEBUGGER
|
||||
#define HX_STACK_LINE(number) \
|
||||
_hx_stackframe.lineNumber = number; \
|
||||
/* This is incorrect - a read memory barrier is needed here. */ \
|
||||
/* For now, just live with the exceedingly rare cases where */ \
|
||||
/* breakpoints are missed */ \
|
||||
if (::hx::gShouldCallHandleBreakpoints) { \
|
||||
__hxcpp_on_line_changed(_hx_stackframe.ctx); \
|
||||
}
|
||||
#define HX_STACK_LINE_QUICK(number) _hx_stackframe.lineNumber = number;
|
||||
#else
|
||||
// Just set it
|
||||
#define HX_STACK_LINE(number) _hx_stackframe.lineNumber = number;
|
||||
#define HX_STACK_LINE_QUICK(number) _hx_stackframe.lineNumber = number;
|
||||
#endif
|
||||
#else
|
||||
#define HX_STACK_LINE(number)
|
||||
#define HX_STACK_LINE_QUICK(number)
|
||||
#endif
|
||||
|
||||
|
||||
// For tidier generated code
|
||||
#define HXLINE(number) HX_STACK_LINE(number)
|
||||
#define HXDLIN(number)
|
||||
|
||||
|
||||
// To support older versions of the haxe compiler that emit HX_STACK_PUSH
|
||||
// instead of HX_STACK_FRAME. If the old haxe compiler is used with this
|
||||
// new debugger implementation, className.functionName breakpoints will
|
||||
// not work, and stack reporting will be a little weird. If you want to
|
||||
// use debugging, you really should upgrade to a newer haxe compiler.
|
||||
|
||||
#undef HX_STACK_PUSH
|
||||
#define HX_STACK_PUSH(fullName, fileName, lineNumber) \
|
||||
HX_STACK_FRAME("", fullName, 0, fullName, fileName, lineNumber, 0)
|
||||
|
||||
#if defined(HXCPP_STACK_TRACE) || defined(HXCPP_TELEMETRY)
|
||||
#define HXCPP_STACK_IDS
|
||||
#endif
|
||||
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
|
||||
class StackFrame;
|
||||
struct StackContext;
|
||||
|
||||
class Profiler;
|
||||
void profDestroy(Profiler *);
|
||||
void profAttach(Profiler *, StackContext *);
|
||||
void profDetach(Profiler *, StackContext *);
|
||||
void profSample(Profiler *, StackContext *inContext);
|
||||
|
||||
|
||||
class Telemetry;
|
||||
Telemetry *tlmCreate(StackContext *);
|
||||
void tlmDestroy(Telemetry *);
|
||||
void tlmAttach(Telemetry *, StackContext *);
|
||||
void tlmDetach(Telemetry *);
|
||||
void tlmSampleEnter(Telemetry *, StackFrame *inFrame);
|
||||
void tlmSampleExit(Telemetry *);
|
||||
|
||||
|
||||
class DebuggerContext;
|
||||
DebuggerContext *dbgCtxCreate(StackContext *);
|
||||
void dbgCtxDestroy(DebuggerContext *);
|
||||
void dbgCtxAttach(DebuggerContext *, StackContext *);
|
||||
void dbgCtxDetach(DebuggerContext *);
|
||||
void dbgCtxEnable(DebuggerContext *, bool inEnable);
|
||||
|
||||
|
||||
struct scriptCallable;
|
||||
class StackVariable;
|
||||
class StackCatchable;
|
||||
|
||||
template<typename T> struct Hash;
|
||||
struct TWeakStringSet;
|
||||
typedef Hash<TWeakStringSet> WeakStringSet;
|
||||
|
||||
extern const char* EXTERN_CLASS_NAME;
|
||||
|
||||
|
||||
#ifdef HXCPP_DEBUGGER
|
||||
extern volatile bool gShouldCallHandleBreakpoints;
|
||||
|
||||
|
||||
// These must match the values present in cpp.vm.Debugger
|
||||
enum DebugStatus
|
||||
{
|
||||
DBG_STATUS_INVALID = 0, // Not present or needed in cpp.vm.Debugger
|
||||
DBG_STATUS_RUNNING = 1,
|
||||
DBG_STATUS_STOPPED_BREAK_IMMEDIATE = 2,
|
||||
DBG_STATUS_STOPPED_BREAKPOINT = 3,
|
||||
DBG_STATUS_STOPPED_UNCAUGHT_EXCEPTION = 4,
|
||||
DBG_STATUS_STOPPED_CRITICAL_ERROR = 5
|
||||
};
|
||||
|
||||
enum ExecutionTrace
|
||||
{
|
||||
exeTraceOff = 0,
|
||||
exeTraceFuncs = 1,
|
||||
exeTraceLines = 2,
|
||||
};
|
||||
|
||||
extern ExecutionTrace sExecutionTrace;
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class StackPosition
|
||||
{
|
||||
public:
|
||||
// These are constant during the lifetime of the stack frame
|
||||
const char *className;
|
||||
const char *functionName;
|
||||
const char *fullName; // this is className.functionName - used for profiler
|
||||
const char *fileName;
|
||||
int firstLineNumber;
|
||||
|
||||
#if defined(HXCPP_STACK_SCRIPTABLE)
|
||||
// Information about the current cppia function
|
||||
struct ScriptCallable *scriptCallable;
|
||||
#endif
|
||||
|
||||
// These are only used if HXCPP_DEBUGGER is defined
|
||||
#ifdef HXCPP_DEBUGGER
|
||||
int fileHash;
|
||||
int classFuncHash;
|
||||
#else
|
||||
enum { fileHash = 0, classFuncHash=0 };
|
||||
#endif
|
||||
|
||||
inline StackPosition() { }
|
||||
|
||||
// The constructor automatically adds the StackFrame to the list of
|
||||
// stack frames for the current thread
|
||||
inline StackPosition(const char *inClassName, const char *inFunctionName,
|
||||
const char *inFullName, const char *inFileName
|
||||
#ifdef HXCPP_STACK_LINE
|
||||
, int inLineNumber
|
||||
#endif
|
||||
#ifdef HXCPP_DEBUGGER
|
||||
,int inClassFunctionHash, int inFileHash
|
||||
#endif
|
||||
)
|
||||
|
||||
: className(inClassName), functionName(inFunctionName)
|
||||
,fullName(inFullName), fileName(inFileName)
|
||||
#ifdef HXCPP_DEBUGGER
|
||||
,classFuncHash(inClassFunctionHash)
|
||||
,fileHash(inFileHash)
|
||||
#endif
|
||||
#ifdef HXCPP_STACK_LINE
|
||||
,firstLineNumber(inLineNumber)
|
||||
#endif
|
||||
{
|
||||
#if defined(HXCPP_STACK_SCRIPTABLE)
|
||||
// Information about the current cppia function
|
||||
scriptCallable = 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#ifdef HXCPP_STACK_TRACE
|
||||
struct ExceptionStackFrame
|
||||
{
|
||||
#ifdef HXCPP_STACK_LINE
|
||||
int line;
|
||||
#endif
|
||||
|
||||
#if HXCPP_API_LEVEL > 330
|
||||
const hx::StackPosition *position;
|
||||
#else
|
||||
const char *className;
|
||||
const char *functionName;
|
||||
const char *fileName;
|
||||
#endif
|
||||
|
||||
ExceptionStackFrame(const StackFrame &inFrame);
|
||||
::String format(bool inForDisplay);
|
||||
::String toDisplay();
|
||||
::String toString();
|
||||
};
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef HXCPP_SCRIPTABLE
|
||||
enum
|
||||
{
|
||||
bcrBreak = 0x01,
|
||||
bcrContinue = 0x02,
|
||||
bcrReturn = 0x04,
|
||||
|
||||
bcrLoop = (bcrBreak | bcrContinue),
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
struct MarkChunk
|
||||
{
|
||||
enum { SIZE = 62 };
|
||||
enum { OBJ_ARRAY_JOB = -1 };
|
||||
|
||||
inline MarkChunk() : count(0), next(0) { }
|
||||
|
||||
int count;
|
||||
|
||||
union
|
||||
{
|
||||
hx::Object *stack[SIZE];
|
||||
struct
|
||||
{
|
||||
hx::Object **arrayBase;
|
||||
int arrayElements;
|
||||
};
|
||||
};
|
||||
MarkChunk *next;
|
||||
|
||||
inline void push(Object *inObj)
|
||||
{
|
||||
stack[count++] = inObj;
|
||||
}
|
||||
inline hx::Object *pop()
|
||||
{
|
||||
if (count)
|
||||
return stack[--count];
|
||||
return 0;
|
||||
}
|
||||
MarkChunk *swapForNew();
|
||||
};
|
||||
|
||||
|
||||
|
||||
struct StackContext : public hx::ImmixAllocator
|
||||
{
|
||||
#ifdef HXCPP_STACK_IDS
|
||||
int mThreadId;
|
||||
#endif
|
||||
|
||||
#ifdef HXCPP_STACK_TRACE
|
||||
hx::QuickVec<StackFrame *> mStackFrames;
|
||||
hx::QuickVec<hx::ExceptionStackFrame> mExceptionStack;
|
||||
// Updated only when a thrown exception unwinds the stack
|
||||
bool mIsUnwindingException;
|
||||
|
||||
#ifdef HXCPP_STACK_SCRIPTABLE
|
||||
// TODO - combine CppaCtx and StackContext
|
||||
#endif
|
||||
|
||||
#ifdef HXCPP_DEBUGGER
|
||||
DebuggerContext *mDebugger;
|
||||
#endif
|
||||
|
||||
#ifdef HXCPP_PROFILER
|
||||
// Profiling support
|
||||
Profiler *mProfiler;
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef HXCPP_TELEMETRY
|
||||
// Telemetry support
|
||||
Telemetry *mTelemetry;
|
||||
#endif
|
||||
|
||||
#ifdef HXCPP_COMBINE_STRINGS
|
||||
WeakStringSet *stringSet;
|
||||
#endif
|
||||
|
||||
#ifdef HXCPP_GC_GENERATIONAL
|
||||
MarkChunk *mOldReferrers;
|
||||
inline void pushReferrer(hx::Object *inObj)
|
||||
{
|
||||
// If collector is running on non-generational mode, mOldReferrers will be null
|
||||
if (mOldReferrers)
|
||||
{
|
||||
mOldReferrers->push(inObj);
|
||||
if (mOldReferrers->count==MarkChunk::SIZE)
|
||||
mOldReferrers = mOldReferrers->swapForNew();
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef HXCPP_CATCH_SEGV
|
||||
#ifdef _MSC_VER
|
||||
_se_translator_function mOldSignalFunc;
|
||||
#else
|
||||
void (*mOldSignalFunc)(int);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
StackContext();
|
||||
~StackContext();
|
||||
void onThreadAttach();
|
||||
void onThreadDetach();
|
||||
|
||||
|
||||
#ifdef HXCPP_STACK_TRACE // {
|
||||
void tracePosition();
|
||||
|
||||
// Note that the stack frames are manipulated without holding any locks.
|
||||
// This is because the manipulation of stack frames can only be done by
|
||||
// the thread that "owns" that stack frame. The only other contention on
|
||||
// the call stack is from calls to GetThreadInfo() and GetThreadInfos(),
|
||||
// and these should only be called when the thread for which the call
|
||||
// stack is being acquired is stopped in a breakpoint anyway, thus there
|
||||
// can be no contention on the contents of the CallStack in that case
|
||||
// either.
|
||||
|
||||
inline void pushFrame(StackFrame *inFrame)
|
||||
{
|
||||
#ifdef HXCPP_PROFILER
|
||||
if (mProfiler)
|
||||
profSample(mProfiler,this);
|
||||
#endif
|
||||
|
||||
#ifdef HXCPP_TELEMETRY
|
||||
if (mTelemetry)
|
||||
tlmSampleEnter(mTelemetry,inFrame);
|
||||
#endif
|
||||
|
||||
mIsUnwindingException = false;
|
||||
mStackFrames.push(inFrame);
|
||||
|
||||
#ifdef HXCPP_DEBUGGER
|
||||
if (sExecutionTrace!=exeTraceOff)
|
||||
tracePosition();
|
||||
#endif
|
||||
}
|
||||
|
||||
inline void popFrame(StackFrame *inFrame)
|
||||
{
|
||||
#ifdef HXCPP_TELEMETRY
|
||||
if (mTelemetry)
|
||||
tlmSampleExit(mTelemetry);
|
||||
#endif
|
||||
|
||||
if (mIsUnwindingException)
|
||||
{
|
||||
// Use default operator=
|
||||
mExceptionStack.push( *inFrame );
|
||||
}
|
||||
|
||||
mStackFrames.pop_back();
|
||||
}
|
||||
|
||||
void getCurrentCallStackAsStrings(Array<String> result, bool skipLast);
|
||||
void getCurrentExceptionStackAsStrings(Array<String> result);
|
||||
StackFrame *getCurrentStackFrame() { return mStackFrames.back(); }
|
||||
StackFrame *getStackFrame(int inIndex) { return mStackFrames[inIndex]; }
|
||||
int getDepth() const { return mStackFrames.size(); }
|
||||
inline const char *getFullNameAtDepth(int depth) const;
|
||||
void dumpExceptionStack();
|
||||
|
||||
// Called when a throw occurs
|
||||
void setLastException();
|
||||
void pushLastException();
|
||||
// Called when a catch block begins to be executed. hxcpp wants to track
|
||||
// the stack back through the catches so that it can be dumped if
|
||||
// uncaught. If inAll is true, the entire stack is captured immediately.
|
||||
// If inAll is false, only the last stack frame is captured.
|
||||
void beginCatch(bool inAll);
|
||||
|
||||
#endif // } HXCPP_STACK_TRACE
|
||||
|
||||
#ifdef HXCPP_DEBUGGER
|
||||
void enableCurrentThreadDebugging(bool inEnable)
|
||||
{
|
||||
dbgCtxEnable(mDebugger,inEnable);
|
||||
}
|
||||
#endif
|
||||
|
||||
static inline StackContext *getCurrent()
|
||||
{
|
||||
return HX_CTX_GET;
|
||||
}
|
||||
|
||||
#ifdef HXCPP_STACK_IDS
|
||||
static void getAllStackIds( QuickVec<int> &outIds );
|
||||
static StackContext *getStackForId(int id);
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef HXCPP_SCRIPTABLE
|
||||
unsigned char *stack;
|
||||
unsigned char *pointer;
|
||||
unsigned char *frame;
|
||||
class Object *exception;
|
||||
|
||||
unsigned int breakContReturn;
|
||||
int byteMarkId;
|
||||
|
||||
template<typename T>
|
||||
void push(T inValue)
|
||||
{
|
||||
*(T *)pointer = inValue;
|
||||
pointer += sizeof(T);
|
||||
}
|
||||
unsigned char *stackAlloc(int inSize)
|
||||
{
|
||||
unsigned char *p = pointer;
|
||||
pointer += inSize;
|
||||
return p;
|
||||
}
|
||||
void stackFree(int inSize)
|
||||
{
|
||||
pointer -= inSize;
|
||||
}
|
||||
|
||||
int getFrameSize() const { return pointer-frame; }
|
||||
|
||||
int runInt(void *vtable);
|
||||
Float runFloat(void *vtable);
|
||||
String runString(void *vtable);
|
||||
void runVoid(void *vtable);
|
||||
Dynamic runObject(void *vtable);
|
||||
hx::Object *runObjectPtr(void *vtable);
|
||||
|
||||
void push(bool &inValue) { *(int *)pointer = inValue; pointer += sizeof(int); }
|
||||
inline void pushBool(bool b) { *(int *)pointer = b; pointer += sizeof(int); }
|
||||
inline void pushInt(int i) { *(int *)pointer = i; pointer += sizeof(int); }
|
||||
|
||||
inline void pushFloat(Float f);
|
||||
inline void pushString(const String &s);
|
||||
inline void pushObject(Dynamic d);
|
||||
inline void returnFloat(Float f);
|
||||
inline void returnString(const String &s);
|
||||
inline void returnObject(Dynamic d);
|
||||
inline hx::Object *getThis(bool inCheckPtr=true);
|
||||
|
||||
inline void returnBool(bool b) { *(int *)frame = b; }
|
||||
inline void returnInt(int i) { *(int *)frame = i; }
|
||||
inline bool getBool(int inPos=0) { return *(bool *)(frame+inPos); }
|
||||
inline int getInt(int inPos=0) { return *(int *)(frame+inPos); }
|
||||
|
||||
inline Float getFloat(int inPos=0);
|
||||
inline String getString(int inPos=0);
|
||||
inline Dynamic getObject(int inPos=0);
|
||||
inline hx::Object *getObjectPtr(int inPos=0) { return *(hx::Object **)(frame+inPos); }
|
||||
|
||||
|
||||
void breakFlag() { breakContReturn |= bcrBreak; }
|
||||
void continueFlag() { breakContReturn |= bcrContinue; }
|
||||
void returnFlag() { breakContReturn |= bcrReturn; }
|
||||
|
||||
#endif
|
||||
|
||||
};
|
||||
|
||||
|
||||
typedef StackContext CppiaCtx;
|
||||
|
||||
|
||||
|
||||
class StackFrame
|
||||
{
|
||||
public:
|
||||
StackContext *ctx;
|
||||
|
||||
#ifdef HXCPP_STACK_TRACE // {
|
||||
const StackPosition *position;
|
||||
|
||||
#ifdef HXCPP_STACK_LINE
|
||||
// Current line number, changes during the lifetime of the stack frame.
|
||||
// Only updated if HXCPP_STACK_LINE is defined.
|
||||
int lineNumber;
|
||||
|
||||
#ifdef HXCPP_DEBUGGER
|
||||
// Function arguments and local variables in reverse order of their
|
||||
// declaration. If a variable name is in here twice, the first version is
|
||||
// the most recently scoped one and should be used. Only updated if
|
||||
// HXCPP_DEBUGGER is defined.
|
||||
StackVariable *variables;
|
||||
|
||||
// The list of types that can be currently caught in the stack frame.
|
||||
StackCatchable *catchables;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// The constructor automatically adds the StackFrame to the list of
|
||||
// stack frames for the current thread
|
||||
inline StackFrame(const StackPosition *inPosition
|
||||
) : position(inPosition)
|
||||
{
|
||||
#ifdef HXCPP_STACK_LINE
|
||||
lineNumber = inPosition->firstLineNumber;
|
||||
#ifdef HXCPP_DEBUGGER
|
||||
variables = 0;
|
||||
catchables = 0;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
ctx = HX_CTX_GET;
|
||||
ctx->pushFrame(this);
|
||||
}
|
||||
|
||||
|
||||
// The destructor automatically removes the StackFrame from the list of
|
||||
// stack frames for the current thread
|
||||
~StackFrame()
|
||||
{
|
||||
ctx->popFrame(this);
|
||||
}
|
||||
|
||||
::String toString();
|
||||
::String toDisplay();
|
||||
#else // } !HXCPP_STACK_TRACE {
|
||||
|
||||
// Release version only has ctx
|
||||
inline StackFrame()
|
||||
{
|
||||
ctx = HX_CTX_GET;
|
||||
}
|
||||
|
||||
#endif // }
|
||||
|
||||
};
|
||||
|
||||
#ifdef HXCPP_STACK_TRACE
|
||||
const char *StackContext::getFullNameAtDepth(int depth) const
|
||||
{
|
||||
return mStackFrames[depth]->position->fullName;
|
||||
}
|
||||
#endif
|
||||
|
||||
class JustGcStackFrame
|
||||
{
|
||||
public:
|
||||
StackContext *ctx;
|
||||
inline JustGcStackFrame() : ctx(HX_CTX_GET) { }
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
|
||||
|
||||
// Some functions used by AdvancedDebug.cpp
|
||||
// Returns the thread number of the calling thread
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
int __hxcpp_GetCurrentThreadNumber();
|
||||
|
||||
// Called by the main function when an uncaught exception occurs to dump
|
||||
// the stack leading to the exception
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
void __hx_dump_stack();
|
||||
|
||||
// The macro HX_STACK_BEGIN_CATCH, which is emitted at the beginning of every
|
||||
// catch block, calls this in debug mode to let the debugging system know that
|
||||
// a catch block has been entered
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
void __hxcpp_stack_begin_catch();
|
||||
|
||||
// Last chance to throw an exception for null-pointer access
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
void __hxcpp_set_critical_error_handler(Dynamic inHandler);
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
void __hxcpp_execution_trace(int inLevel);
|
||||
|
||||
// Used by debug breakpoints and execution trace
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
void __hxcpp_set_stack_frame_line(int);
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
void __hxcpp_on_line_changed(hx::StackContext *);
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
void __hxcpp_set_debugger_info(const char **inAllClasses, const char **inFullPaths);
|
||||
|
||||
|
||||
void __hxcpp_dbg_getScriptableVariables(hx::StackFrame *stackFrame, ::Array< ::Dynamic> outNames);
|
||||
bool __hxcpp_dbg_getScriptableValue(hx::StackFrame *stackFrame, String inName, ::Dynamic &outValue);
|
||||
bool __hxcpp_dbg_setScriptableValue(hx::StackFrame *StackFrame, String inName, ::Dynamic inValue);
|
||||
|
||||
|
||||
|
||||
|
||||
#endif // HX_STACK_CTX_H
|
||||
932
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/StdLibs.h
Normal file
932
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/StdLibs.h
Normal file
@ -0,0 +1,932 @@
|
||||
#ifndef HX_STDLIBS_H
|
||||
#define HX_STDLIBS_H
|
||||
|
||||
// --- Resource -------------------------------------------------------------
|
||||
|
||||
namespace haxe {
|
||||
namespace ds {
|
||||
class HXCPP_CLASS_ATTRIBUTES StringMap_obj;
|
||||
}
|
||||
}
|
||||
|
||||
namespace hx
|
||||
{
|
||||
struct Resource
|
||||
{
|
||||
String mName;
|
||||
int mDataLength;
|
||||
unsigned char *mData;
|
||||
|
||||
bool operator<(const Resource &inRHS) const { return mName < inRHS.mName; }
|
||||
};
|
||||
|
||||
Resource *GetResources();
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
void RegisterResources(hx::Resource *inResources);
|
||||
|
||||
|
||||
struct AnyCast
|
||||
{
|
||||
template<typename T>
|
||||
explicit AnyCast(T* inPtr) : mPtr((void *)inPtr) { }
|
||||
|
||||
template<typename T>
|
||||
operator T*() const { return (T*)mPtr; }
|
||||
|
||||
void *mPtr;
|
||||
};
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
Array<String> __hxcpp_resource_names();
|
||||
String __hxcpp_resource_string(String inName);
|
||||
Array<unsigned char> __hxcpp_resource_bytes(String inName);
|
||||
|
||||
|
||||
|
||||
|
||||
// System access
|
||||
Array<String> __get_args();
|
||||
double __time_stamp();
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_print_string(const String &inV);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_println_string(const String &inV);
|
||||
|
||||
template<typename T> inline void __hxcpp_println(T inV)
|
||||
{
|
||||
Dynamic d(inV);
|
||||
__hxcpp_println_string(d);
|
||||
}
|
||||
// Specialization that does not need dynamic boxing
|
||||
template<> inline void __hxcpp_println(String inV)
|
||||
{
|
||||
__hxcpp_println_string(inV);
|
||||
}
|
||||
|
||||
template<typename T> inline void __hxcpp_print(T inV)
|
||||
{
|
||||
Dynamic d(inV);
|
||||
__hxcpp_print_string(d);
|
||||
}
|
||||
// Specialization that does not need dynamic boxing
|
||||
template<> inline void __hxcpp_print(String inV)
|
||||
{
|
||||
__hxcpp_print_string(inV);
|
||||
}
|
||||
|
||||
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __trace(Dynamic inPtr, Dynamic inData);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_exit(int inExitCode);
|
||||
void __hxcpp_stdlibs_boot();
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int hxcpp_alloc_kind();
|
||||
|
||||
// --- Maths ---------------------------------------------------------
|
||||
double __hxcpp_drand();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int __hxcpp_irand(int inMax);
|
||||
|
||||
// --- Casting/Converting ---------------------------------------------------------
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __instanceof(const Dynamic &inValue, const Dynamic &inType);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int __int__(double x);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __hxcpp_same_closure(Dynamic &inF1,Dynamic &inF2);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __hxcpp_parse_int(const String &inString);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES double __hxcpp_parse_float(const String &inString);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES double __hxcpp_parse_substr_float(const String &inString, int start, int len);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int __hxcpp_parse_substr_int(const String &inString, int start=0, int len=-1);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __hxcpp_create_var_args(Dynamic &inArrayFunc);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_set_float_format(String inFormat);
|
||||
|
||||
inline int _hx_idiv(int inNum,int inDenom) { return inNum/inDenom; }
|
||||
inline int _hx_imod(int inNum,int inDenom) { return inNum%inDenom; }
|
||||
inline int _hx_cast_int(int inX) { return inX; }
|
||||
inline int _hx_fast_floor(double inX) {
|
||||
union Cast
|
||||
{
|
||||
double d;
|
||||
long l;
|
||||
};
|
||||
Cast c;
|
||||
c.d = (inX-0.5) + 6755399441055744.0;
|
||||
return c.l;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// --- CFFI helpers ------------------------------------------------------------------
|
||||
|
||||
// Used for accessing object fields by integer ID, rather than string ID.
|
||||
// Used mainly for neko ndll interaction.
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int __hxcpp_field_to_id( const char *inField );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES const String &__hxcpp_field_from_id( int f );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int __hxcpp_register_prim(const HX_CHAR *inName,void *inFunc);
|
||||
|
||||
// Get function pointer from dll file
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __loadprim(String inLib, String inPrim,int inArgCount);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void *__hxcpp_get_proc_address(String inLib, String inPrim,bool inNdll, bool inQuietFail=false);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_run_dll(String inLib, String inPrim);
|
||||
// Can assign to function pointer without error
|
||||
inline hx::AnyCast __hxcpp_cast_get_proc_address(String inLib, String inPrim,bool inQuietFail=false)
|
||||
{
|
||||
return hx::AnyCast(__hxcpp_get_proc_address(inLib,inPrim,false,inQuietFail));
|
||||
}
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int __hxcpp_unload_all_libraries();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_push_dll_path(String inPath);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String __hxcpp_get_dll_extension();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String __hxcpp_get_bin_dir();
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String __hxcpp_get_kind(Dynamic inObject);
|
||||
|
||||
|
||||
// Loading functions via name (dummy return value)
|
||||
|
||||
|
||||
|
||||
// --- haxe.io.BytesData ----------------------------------------------------------------
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_bytes_of_string(Array<unsigned char> &outBytes,const String &inString);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_string_of_bytes(Array<unsigned char> &inBytes,String &outString,int pos,int len,bool inCopyPointer=false);
|
||||
// UTF8 processing
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String __hxcpp_char_array_to_utf8_string(Array<int> &inChars,int inFirst=0, int inLen=-1);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<int> __hxcpp_utf8_string_to_char_array(String &inString);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String __hxcpp_char_bytes_to_utf8_string(String &inBytes);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String __hxcpp_utf8_string_to_char_bytes(String &inUTF8);
|
||||
|
||||
|
||||
#ifdef HXCPP_GC_GENERATIONAL
|
||||
#define HX_MAP_THIS this, h
|
||||
#define HX_MAP_THIS_ this,
|
||||
#define HX_MAP_THIS_ARG hx::Object *owner, Dynamic &ioHash
|
||||
#else
|
||||
#define HX_MAP_THIS h
|
||||
#define HX_MAP_THIS_
|
||||
#define HX_MAP_THIS_ARG Dynamic &ioHash
|
||||
#endif
|
||||
|
||||
// --- HashRoot ---------------------------------------------------------------------
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int __root_hash_size(Dynamic *rtHash);
|
||||
|
||||
// --- IntHash ----------------------------------------------------------------------
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES inline hx::Object *__int_hash_create() { return 0; }
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int_hash_set(HX_MAP_THIS_ARG,int inKey,const Dynamic &value);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __int_hash_exists(Dynamic &hash,int inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __int_hash_remove(Dynamic &hash,int inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<int> __int_hash_keys(Dynamic &hash);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __int_hash_values(Dynamic &hash);
|
||||
// Typed IntHash access...
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int_hash_set_int(HX_MAP_THIS_ARG,int inKey,int inValue);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int_hash_set_string(HX_MAP_THIS_ARG,int inKey,::String inValue);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int_hash_set_float(HX_MAP_THIS_ARG,int inKey,Float inValue);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int_hash_set_int64(HX_MAP_THIS_ARG,int inKey,cpp::Int64 inValue);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __int_hash_to_string(Dynamic &hash);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int_hash_clear(Dynamic &hash);
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __int_hash_get(Dynamic inHash,int inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int __int_hash_get_int(Dynamic inHash,int inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __int_hash_get_string(Dynamic inHash,int inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Float __int_hash_get_float(Dynamic inHash,int inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES cpp::Int64 __int_hash_get_int64(Dynamic inHash,int inKey);
|
||||
inline bool __int_hash_get_bool(Dynamic inHash,int inKey) { return __int_hash_get_int(inHash,inKey); }
|
||||
|
||||
// --- Int64Hash -----------------------------------------------------------------------
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES inline hx::Object *__int64_hash_create() { return 0; }
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int64_hash_set(HX_MAP_THIS_ARG,cpp::Int64 inKey,const Dynamic &value);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __int64_hash_exists(Dynamic &hash,cpp::Int64 inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __int64_hash_remove(Dynamic &hash,cpp::Int64 inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<cpp::Int64> __int64_hash_keys(Dynamic &hash);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __int64_hash_values(Dynamic &hash);
|
||||
// Typed IntHash access...
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int64_hash_set_int(HX_MAP_THIS_ARG,cpp::Int64 inKey,int inValue);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int64_hash_set_string(HX_MAP_THIS_ARG,cpp::Int64 inKey,::String inValue);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int64_hash_set_float(HX_MAP_THIS_ARG,cpp::Int64 inKey,Float inValue);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int64_hash_set_int64(HX_MAP_THIS_ARG,cpp::Int64 inKey,cpp::Int64 inValue);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __int64_hash_to_string(Dynamic &hash);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int64_hash_clear(Dynamic &hash);
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __int64_hash_get(Dynamic inHash,cpp::Int64 inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int __int64_hash_get_int(Dynamic inHash,cpp::Int64 inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __int64_hash_get_string(Dynamic inHash,cpp::Int64 inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Float __int64_hash_get_float(Dynamic inHash,cpp::Int64 inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES cpp::Int64 __int64_hash_get_int64(Dynamic inHash,cpp::Int64 inKey);
|
||||
inline bool __int64_hash_get_bool(Dynamic inHash,cpp::Int64 inKey) { return __int64_hash_get_int(inHash,inKey); }
|
||||
|
||||
// --- StringHash ----------------------------------------------------------------------
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __string_hash_set(HX_MAP_THIS_ARG,String inKey,const Dynamic &value,bool inForceDynamic=false);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __string_hash_exists(Dynamic &hash,String inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __string_hash_remove(Dynamic &hash,String inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Array< ::String> __string_hash_keys(Dynamic &hash);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __string_hash_values(Dynamic &hash);
|
||||
// Typed StringHash access...
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __string_hash_set_int(HX_MAP_THIS_ARG,String inKey,int inValue);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __string_hash_set_string(HX_MAP_THIS_ARG,String inKey,::String inValue);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __string_hash_set_float(HX_MAP_THIS_ARG,String inKey,Float inValue);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __string_hash_set_int64(HX_MAP_THIS_ARG,String inKey,cpp::Int64 inValue);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __string_hash_map_substr(HX_MAP_THIS_ARG,String inKey,int inStart, int inLength);
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __string_hash_to_string(Dynamic &hash);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __string_hash_to_string_raw(Dynamic &hash);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __string_hash_clear(Dynamic &hash);
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __string_hash_get(Dynamic inHash,String inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __string_hash_get2(haxe::ds::StringMap_obj* map,String* inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int __string_hash_get_int(Dynamic inHash,String inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __string_hash_get_string(Dynamic inHash,String inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Float __string_hash_get_float(Dynamic inHash,String inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES cpp::Int64 __string_hash_get_int64(Dynamic inHash,String inKey);
|
||||
inline bool __string_hash_get_bool(Dynamic inHash,String inKey) { return __string_hash_get_int(inHash,inKey); }
|
||||
|
||||
// --- ObjectHash ----------------------------------------------------------------------
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __object_hash_set(HX_MAP_THIS_ARG,Dynamic inKey,const Dynamic &value,bool inWeakKey=false);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __object_hash_exists(Dynamic &hash,Dynamic inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __object_hash_remove(Dynamic &hash,Dynamic inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Array< ::Dynamic> __object_hash_keys(Dynamic &hash);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __object_hash_values(Dynamic &hash);
|
||||
// Typed ObjectHash access...
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __object_hash_set_int(HX_MAP_THIS_ARG,Dynamic inKey,int inValue,bool inWeakKey=false);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __object_hash_set_string(HX_MAP_THIS_ARG,Dynamic inKey,::String inValue,bool inWeakKey=false);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __object_hash_set_float(HX_MAP_THIS_ARG,Dynamic inKey,Float inValue,bool inWeakKey=false);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __object_hash_set_int64(HX_MAP_THIS_ARG,Dynamic inKey,cpp::Int64 inValue,bool inWeakKey=false);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __object_hash_to_string(Dynamic &hash);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __object_hash_clear(Dynamic &hash);
|
||||
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __object_hash_get(Dynamic inHash,Dynamic inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int __object_hash_get_int(Dynamic inHash,Dynamic inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __object_hash_get_string(Dynamic inHash,Dynamic inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Float __object_hash_get_float(Dynamic inHash,Dynamic inKey);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES cpp::Int64 __object_hash_get_int64(Dynamic inHash,Dynamic inKey);
|
||||
inline bool __object_hash_get_bool(Dynamic inHash,Dynamic inKey) { return __object_hash_get_int(inHash,inKey); }
|
||||
|
||||
// --- Date --------------------------------------------------------------------------
|
||||
|
||||
// returns Epoch UTC timestamp (in seconds); assumes that input date parts are considered to be in local timezone date/time representation
|
||||
double __hxcpp_new_date(int inYear,int inMonth,int inDay,int inHour, int inMin, int inSeconds,int inMilliseconds = 0);
|
||||
|
||||
double __hxcpp_utc_date(int inYear,int inMonth,int inDay,int inHour, int inMin, int inSeconds);
|
||||
int __hxcpp_get_hours(double inSeconds);
|
||||
int __hxcpp_get_minutes(double inSeconds);
|
||||
int __hxcpp_get_seconds(double inSeconds);
|
||||
int __hxcpp_get_year(double inSeconds);
|
||||
int __hxcpp_get_month(double inSeconds);
|
||||
int __hxcpp_get_date(double inSeconds);
|
||||
int __hxcpp_get_day(double inSeconds);
|
||||
String __hxcpp_to_string(double inSeconds);
|
||||
double __hxcpp_date_now();
|
||||
|
||||
|
||||
int __hxcpp_get_utc_hours(double inSeconds); /* returns hour part of UTC date/time representation of input time (Epoch, in seconds), 0-23 */
|
||||
int __hxcpp_get_utc_minutes(double inSeconds); /* returns minutes part of UTC date/time representation of input time (Epoch, in seconds), 0-59 */
|
||||
int __hxcpp_get_utc_seconds(double inSeconds); /* returns seconds part of UTC date/time representation of input time (Epoch, in seconds), 0-59 */
|
||||
int __hxcpp_get_utc_year(double inSeconds); /* returns year part of UTC date/time representation of input time (Epoch, in seconds) */
|
||||
int __hxcpp_get_utc_month(double inSeconds); /* returns month part of UTC date/time representation of input time (Epoch, in seconds), 0-January...11-December */
|
||||
int __hxcpp_get_utc_date(double inSeconds); /* returns day of the month part of UTC date/time representation of input time (Epoch, in seconds), 1-31 */
|
||||
int __hxcpp_get_utc_day(double inSeconds); /* returns day of the week part of UTC date/time representation of input time (Epoch, in seconds), 0-Sunday...6-Saturday */
|
||||
String __hxcpp_to_utc_string(double inSeconds); /* same as __hxcpp_to_string but in corresponding UTC format */
|
||||
|
||||
int __hxcpp_is_dst(double inSeconds); /* is input time (Epoch UTC timestamp, in seconds)'s local time in DST ? 1 for true, 0 for false */
|
||||
double __hxcpp_timezone_offset(double inSeconds); /* input time (Epoch UTC timestamp, in seconds)'s local time zone offset from UTC, in seconds */
|
||||
double __hxcpp_from_utc(int inYear,int inMonth,int inDay,int inHour, int inMin, int inSeconds, int inMilliSeconds); /* returns Epoch timestamp (in seconds); assumes that input date parts are considered to be in UTC date/time representation */
|
||||
|
||||
|
||||
|
||||
double __hxcpp_time_stamp();
|
||||
|
||||
// --- vm/threading --------------------------------------------------------------------
|
||||
|
||||
Dynamic __hxcpp_thread_create(Dynamic inFunc);
|
||||
Dynamic __hxcpp_thread_current();
|
||||
void __hxcpp_thread_send(Dynamic inThread, Dynamic inMessage);
|
||||
Dynamic __hxcpp_thread_read_message(bool inBlocked);
|
||||
bool __hxcpp_is_current_thread(hx::Object *inThread);
|
||||
|
||||
Dynamic __hxcpp_mutex_create();
|
||||
void __hxcpp_mutex_acquire(Dynamic);
|
||||
bool __hxcpp_mutex_try(Dynamic);
|
||||
void __hxcpp_mutex_release(Dynamic);
|
||||
|
||||
Dynamic __hxcpp_semaphore_create(int);
|
||||
void __hxcpp_semaphore_acquire(Dynamic);
|
||||
bool __hxcpp_semaphore_try_acquire(Dynamic, double timeout);
|
||||
void __hxcpp_semaphore_release(Dynamic);
|
||||
|
||||
Dynamic __hxcpp_condition_create(void);
|
||||
void __hxcpp_condition_acquire(Dynamic);
|
||||
bool __hxcpp_condition_try_acquire(Dynamic);
|
||||
void __hxcpp_condition_release(Dynamic);
|
||||
void __hxcpp_condition_wait(Dynamic);
|
||||
bool __hxcpp_condition_timed_wait(Dynamic,double);
|
||||
void __hxcpp_condition_signal(Dynamic);
|
||||
void __hxcpp_condition_broadcast(Dynamic);
|
||||
|
||||
Dynamic __hxcpp_lock_create();
|
||||
bool __hxcpp_lock_wait(Dynamic inlock,double inTime);
|
||||
void __hxcpp_lock_release(Dynamic inlock);
|
||||
|
||||
Dynamic __hxcpp_deque_create();
|
||||
void __hxcpp_deque_add(Dynamic q,Dynamic inVal);
|
||||
void __hxcpp_deque_push(Dynamic q,Dynamic inVal);
|
||||
Dynamic __hxcpp_deque_pop(Dynamic q,bool block);
|
||||
|
||||
Dynamic __hxcpp_tls_get(int inID);
|
||||
void __hxcpp_tls_set(int inID,Dynamic inVal);
|
||||
|
||||
bool _hx_atomic_exchange_if(::cpp::Pointer<cpp::AtomicInt> inPtr, int test, int newVal );
|
||||
int _hx_atomic_inc(::cpp::Pointer<cpp::AtomicInt> inPtr );
|
||||
int _hx_atomic_dec(::cpp::Pointer<cpp::AtomicInt> inPtr );
|
||||
|
||||
// Assumptions made:
|
||||
// People are not using 8 year old versions of GCC.
|
||||
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
#define HX_GCC_ATOMICS
|
||||
#define HX_HAS_ATOMIC 1
|
||||
#elif defined(_MSC_VER)
|
||||
#define HX_MSVC_ATOMICS
|
||||
#define HX_HAS_ATOMIC 1
|
||||
#include <intrin.h>
|
||||
#else
|
||||
#define HX_HAS_ATOMIC 0
|
||||
#endif
|
||||
|
||||
inline int _hx_atomic_add(volatile int *a, int b) {
|
||||
#if defined(HX_GCC_ATOMICS)
|
||||
return __atomic_fetch_add(a, b, __ATOMIC_SEQ_CST);
|
||||
#elif defined(HX_MSVC_ATOMICS)
|
||||
return _InterlockedExchangeAdd((long volatile *)a, b);
|
||||
#else
|
||||
int old = *a;
|
||||
*a += b;
|
||||
return old;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline int _hx_atomic_sub(volatile int *a, int b) {
|
||||
#if defined(HX_GCC_ATOMICS)
|
||||
return __atomic_fetch_sub(a, b, __ATOMIC_SEQ_CST);
|
||||
#elif defined(HX_MSVC_ATOMICS)
|
||||
return _InterlockedExchangeAdd((long volatile *)a, -b);
|
||||
#else
|
||||
int old = *a;
|
||||
*a -= b;
|
||||
return old;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline int _hx_atomic_and(volatile int *a, int b) {
|
||||
#if defined(HX_GCC_ATOMICS)
|
||||
return __atomic_fetch_and(a, b, __ATOMIC_SEQ_CST);
|
||||
#elif defined(HX_MSVC_ATOMICS)
|
||||
return _InterlockedAnd((long volatile *)a, b);
|
||||
#else
|
||||
int old = *a;
|
||||
*a &= b;
|
||||
return old;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline int _hx_atomic_or(volatile int *a, int b) {
|
||||
#if defined(HX_GCC_ATOMICS)
|
||||
return __atomic_fetch_or(a, b, __ATOMIC_SEQ_CST);
|
||||
#elif defined(HX_MSVC_ATOMICS)
|
||||
return _InterlockedOr((long volatile *)a, b);
|
||||
#else
|
||||
int old = *a;
|
||||
*a |= b;
|
||||
return old;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline int _hx_atomic_xor(int *a, int b) {
|
||||
#if defined(HX_GCC_ATOMICS)
|
||||
return __atomic_fetch_xor(a, b, __ATOMIC_SEQ_CST);
|
||||
#elif defined(HX_MSVC_ATOMICS)
|
||||
return _InterlockedXor((long volatile *)a, b);
|
||||
#else
|
||||
int old = *a;
|
||||
*a ^= b;
|
||||
return old;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline int _hx_atomic_compare_exchange(volatile int *a, int expected,
|
||||
int replacement) {
|
||||
#if defined(HX_GCC_ATOMICS)
|
||||
int _expected = expected;
|
||||
__atomic_compare_exchange(a, &_expected, &replacement, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
|
||||
return _expected;
|
||||
#elif defined(HX_MSVC_ATOMICS)
|
||||
return _InterlockedCompareExchange((long volatile *)a, replacement, expected);
|
||||
#else
|
||||
int old = *a;
|
||||
if(old == expected) {
|
||||
*a = replacement;
|
||||
}
|
||||
return old;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline int _hx_atomic_exchange(volatile int *a, int replacement) {
|
||||
#if defined(HX_GCC_ATOMICS)
|
||||
int ret = 0;
|
||||
__atomic_exchange(a, &replacement, &ret, __ATOMIC_SEQ_CST);
|
||||
return ret;
|
||||
#elif defined(HX_MSVC_ATOMICS)
|
||||
return _InterlockedExchange((long volatile *)a, replacement);
|
||||
#else
|
||||
int old = *a;
|
||||
*a = replacement;
|
||||
return old;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline int _hx_atomic_load(volatile int *a) {
|
||||
#if defined(HX_GCC_ATOMICS)
|
||||
int ret = 0;
|
||||
__atomic_load(a, &ret, __ATOMIC_SEQ_CST);
|
||||
return ret;
|
||||
#elif defined(HX_MSVC_ATOMICS)
|
||||
return _InterlockedXor((long volatile *)a, 0);
|
||||
#else
|
||||
return *a;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline int _hx_atomic_store(volatile int *a, int value) {
|
||||
#if defined(HX_GCC_ATOMICS)
|
||||
__atomic_store(a, &value, __ATOMIC_SEQ_CST);
|
||||
return value;
|
||||
#elif defined(HX_MSVC_ATOMICS)
|
||||
_InterlockedExchange((long volatile *)a, value);
|
||||
return value;
|
||||
#else
|
||||
*a = value;
|
||||
return value;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline void* _hx_atomic_compare_exchange_ptr(volatile void **a, void *expected, void* replacement) {
|
||||
#if defined(HX_GCC_ATOMICS)
|
||||
void* _expected = expected;
|
||||
__atomic_compare_exchange(a, (volatile void **)&_expected, (volatile void**)&replacement, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
|
||||
return _expected;
|
||||
#elif defined(HX_MSVC_ATOMICS)
|
||||
return _InterlockedCompareExchangePointer((void *volatile *)a, replacement, expected);
|
||||
#else
|
||||
void *old = *a;
|
||||
*a = replacement;
|
||||
return old;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline void* _hx_atomic_compare_exchange_cast_ptr(void *a, void *expected, void *replacement) {
|
||||
return _hx_atomic_compare_exchange_ptr((volatile void **)a, expected, replacement);
|
||||
}
|
||||
|
||||
Array<String> __hxcpp_get_call_stack(bool inSkipLast);
|
||||
Array<String> __hxcpp_get_exception_stack();
|
||||
#define HXCPP_HAS_CLASSLIST
|
||||
Array<String> __hxcpp_get_class_list();
|
||||
|
||||
// --- Profile -------------------------------------------------------------------
|
||||
|
||||
void __hxcpp_start_profiler(::String inDumpFile);
|
||||
void __hxcpp_stop_profiler();
|
||||
|
||||
|
||||
// --- Memory --------------------------------------------------------------------------
|
||||
|
||||
inline void __hxcpp_align_set_float32( unsigned char *base, int addr, float v)
|
||||
{
|
||||
#ifdef HXCPP_ALIGN_FLOAT
|
||||
if (addr & 3)
|
||||
{
|
||||
const unsigned char *src = (const unsigned char *)&v;
|
||||
unsigned char *dest = base + addr;
|
||||
dest[0] = src[0];
|
||||
dest[1] = src[1];
|
||||
dest[2] = src[2];
|
||||
dest[3] = src[3];
|
||||
}
|
||||
else
|
||||
#endif
|
||||
*(float *)(base+addr) = v;
|
||||
}
|
||||
|
||||
|
||||
inline float __hxcpp_align_get_float32( unsigned char *base, int addr)
|
||||
{
|
||||
#ifdef HXCPP_ALIGN_FLOAT
|
||||
if (addr & 3)
|
||||
{
|
||||
float buf;
|
||||
unsigned char *dest = (unsigned char *)&buf;
|
||||
const unsigned char *src = base + addr;
|
||||
dest[0] = src[0];
|
||||
dest[1] = src[1];
|
||||
dest[2] = src[2];
|
||||
dest[3] = src[3];
|
||||
return buf;
|
||||
}
|
||||
#endif
|
||||
return *(float *)(base+addr);
|
||||
}
|
||||
|
||||
|
||||
inline void __hxcpp_align_set_float64( unsigned char *base, int addr, double v)
|
||||
{
|
||||
#ifdef HXCPP_ALIGN_FLOAT
|
||||
if (addr & 3)
|
||||
{
|
||||
unsigned char *dest = base + addr;
|
||||
const unsigned char *src = (const unsigned char *)&v;
|
||||
dest[0] = src[0];
|
||||
dest[1] = src[1];
|
||||
dest[2] = src[2];
|
||||
dest[3] = src[3];
|
||||
dest[4] = src[4];
|
||||
dest[5] = src[5];
|
||||
dest[6] = src[6];
|
||||
dest[7] = src[7];
|
||||
}
|
||||
else
|
||||
#endif
|
||||
*(double *)(base + addr) = v;
|
||||
}
|
||||
|
||||
|
||||
inline double __hxcpp_align_get_float64( unsigned char *base, int addr)
|
||||
{
|
||||
#ifdef HXCPP_ALIGN_FLOAT
|
||||
if (addr & 3)
|
||||
{
|
||||
double buf;
|
||||
unsigned char *dest = (unsigned char *)&buf;
|
||||
const unsigned char *src = base + addr;
|
||||
dest[0] = src[0];
|
||||
dest[1] = src[1];
|
||||
dest[2] = src[2];
|
||||
dest[3] = src[3];
|
||||
dest[4] = src[4];
|
||||
dest[5] = src[5];
|
||||
dest[6] = src[6];
|
||||
dest[7] = src[7];
|
||||
return buf;
|
||||
}
|
||||
#endif
|
||||
return *(double *)(base+addr);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
// Threadsafe methods - takes buffer
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_memory_memset(Array<unsigned char> &inBuffer ,int pos, int len, int value);
|
||||
|
||||
inline int __hxcpp_memory_get_byte(Array<unsigned char> inBuffer ,int addr) { return inBuffer->GetBase()[addr]; }
|
||||
inline double __hxcpp_memory_get_double(Array<unsigned char> inBuffer ,int addr) {
|
||||
return __hxcpp_align_get_float64((unsigned char *)inBuffer->GetBase(), addr);
|
||||
}
|
||||
inline float __hxcpp_memory_get_float(Array<unsigned char> inBuffer ,int addr) {
|
||||
return __hxcpp_align_get_float32((unsigned char *)inBuffer->GetBase(), addr);
|
||||
}
|
||||
inline int __hxcpp_memory_get_i16(Array<unsigned char> inBuffer ,int addr) { return *(short *)(inBuffer->GetBase()+addr); }
|
||||
inline int __hxcpp_memory_get_i32(Array<unsigned char> inBuffer ,int addr) { return *(int *)(inBuffer->GetBase()+addr); }
|
||||
inline int __hxcpp_memory_get_ui16(Array<unsigned char> inBuffer ,int addr) { return *(unsigned short *)(inBuffer->GetBase()+addr); }
|
||||
inline int __hxcpp_memory_get_ui32(Array<unsigned char> inBuffer ,int addr) { return *(unsigned int *)(inBuffer->GetBase()+addr); }
|
||||
inline float __hxcpp_memory_get_f32(Array<unsigned char> inBuffer ,int addr) {
|
||||
return __hxcpp_align_get_float32((unsigned char *)inBuffer->GetBase(), addr);
|
||||
}
|
||||
|
||||
inline void __hxcpp_memory_set_byte(Array<unsigned char> inBuffer ,int addr,int v) { inBuffer->GetBase()[addr] = v; }
|
||||
inline void __hxcpp_memory_set_double(Array<unsigned char> inBuffer ,int addr,double v) {
|
||||
return __hxcpp_align_set_float64((unsigned char *)inBuffer->GetBase(), addr,v);
|
||||
}
|
||||
inline void __hxcpp_memory_set_float(Array<unsigned char> inBuffer ,int addr,float v) {
|
||||
return __hxcpp_align_set_float32((unsigned char *)inBuffer->GetBase(), addr,v);
|
||||
}
|
||||
inline void __hxcpp_memory_set_i16(Array<unsigned char> inBuffer ,int addr,int v) { *(short *)(inBuffer->GetBase()+addr) = v; }
|
||||
inline void __hxcpp_memory_set_i32(Array<unsigned char> inBuffer ,int addr,int v) { *(int *)(inBuffer->GetBase()+addr) = v; }
|
||||
inline void __hxcpp_memory_set_ui16(Array<unsigned char> inBuffer ,int addr,int v) { *(unsigned short *)(inBuffer->GetBase()+addr) = v; }
|
||||
inline void __hxcpp_memory_set_ui32(Array<unsigned char> inBuffer ,int addr,int v) { *(unsigned int *)(inBuffer->GetBase()+addr) = v; }
|
||||
inline void __hxcpp_memory_set_f32(Array<unsigned char> inBuffer ,int addr,float v) {
|
||||
return __hxcpp_align_set_float32((unsigned char *)inBuffer->GetBase(), addr, v);
|
||||
}
|
||||
|
||||
|
||||
// Uses global pointer...
|
||||
extern unsigned char *__hxcpp_memory;
|
||||
|
||||
inline void __hxcpp_memory_clear( ) { __hxcpp_memory = 0; }
|
||||
inline void __hxcpp_memory_select( Array<unsigned char> inBuffer )
|
||||
{ __hxcpp_memory= (unsigned char *)inBuffer->GetBase(); }
|
||||
|
||||
inline int __hxcpp_memory_get_byte(int addr) { return __hxcpp_memory[addr]; }
|
||||
inline double __hxcpp_memory_get_double(int addr) { return __hxcpp_align_get_float64(__hxcpp_memory,addr); }
|
||||
inline float __hxcpp_memory_get_float(int addr) { return __hxcpp_align_get_float32(__hxcpp_memory,addr); }
|
||||
inline int __hxcpp_memory_get_i16(int addr) { return *(short *)(__hxcpp_memory+addr); }
|
||||
inline int __hxcpp_memory_get_i32(int addr) { return *(int *)(__hxcpp_memory+addr); }
|
||||
inline int __hxcpp_memory_get_ui16(int addr) { return *(unsigned short *)(__hxcpp_memory+addr); }
|
||||
inline int __hxcpp_memory_get_ui32(int addr) { return *(unsigned int *)(__hxcpp_memory+addr); }
|
||||
inline float __hxcpp_memory_get_f32(int addr) { return __hxcpp_align_get_float32(__hxcpp_memory,addr); }
|
||||
|
||||
inline void __hxcpp_memory_set_byte(int addr,int v) { __hxcpp_memory[addr] = v; }
|
||||
inline void __hxcpp_memory_set_double(int addr,double v) { __hxcpp_align_set_float64(__hxcpp_memory,addr,v); }
|
||||
inline void __hxcpp_memory_set_float(int addr,float v) { __hxcpp_align_set_float32(__hxcpp_memory,addr,v); }
|
||||
inline void __hxcpp_memory_set_i16(int addr,int v) { *(short *)(__hxcpp_memory+addr) = v; }
|
||||
inline void __hxcpp_memory_set_i32(int addr,int v) { *(int *)(__hxcpp_memory+addr) = v; }
|
||||
inline void __hxcpp_memory_set_ui16(int addr,int v) { *(unsigned short *)(__hxcpp_memory+addr) = v; }
|
||||
inline void __hxcpp_memory_set_ui32(int addr,int v) { *(unsigned int *)(__hxcpp_memory+addr) = v; }
|
||||
inline void __hxcpp_memory_set_f32(int addr,float v) { __hxcpp_align_set_float32(__hxcpp_memory,addr,v); }
|
||||
|
||||
// FPHelper conversion
|
||||
|
||||
inline void __hxcpp_reverse_endian(int &ioData)
|
||||
{
|
||||
ioData = (((ioData>>24) & 0xff ) )|
|
||||
(((ioData>>16) & 0xff )<<8 )|
|
||||
(((ioData>>8 ) & 0xff )<<16 )|
|
||||
(((ioData ) & 0xff )<<24 );
|
||||
}
|
||||
|
||||
|
||||
inline float __hxcpp_reinterpret_le_int32_as_float32(int inInt)
|
||||
{
|
||||
#ifdef HXCPP_BIG_ENDIAN
|
||||
__hxcpp_reverse_endian(inInt);
|
||||
#endif
|
||||
return *(float*)(&inInt);
|
||||
}
|
||||
|
||||
|
||||
inline int __hxcpp_reinterpret_float32_as_le_int32(float inFloat)
|
||||
{
|
||||
#ifdef HXCPP_BIG_ENDIAN
|
||||
__hxcpp_reverse_endian(*(int *)&inFloat);
|
||||
#endif
|
||||
return *(int*)(&inFloat);
|
||||
}
|
||||
|
||||
|
||||
inline double __hxcpp_reinterpret_le_int32s_as_float64(int inLow, int inHigh)
|
||||
{
|
||||
int vals[2] = {inLow, inHigh};
|
||||
#ifdef HXCPP_BIG_ENDIAN
|
||||
__hxcpp_reverse_endian(vals[0]);
|
||||
__hxcpp_reverse_endian(vals[1]);
|
||||
#endif
|
||||
return *(double*)(vals);
|
||||
}
|
||||
|
||||
|
||||
inline int __hxcpp_reinterpret_float64_as_le_int32_low(double inValue)
|
||||
{
|
||||
int *asInts = (int *)&inValue;
|
||||
#ifdef HXCPP_BIG_ENDIAN
|
||||
__hxcpp_reverse_endian(asInts[0]);
|
||||
#endif
|
||||
return asInts[0];
|
||||
}
|
||||
|
||||
|
||||
inline int __hxcpp_reinterpret_float64_as_le_int32_high(double inValue)
|
||||
{
|
||||
int *asInts = (int *)&inValue;
|
||||
#ifdef HXCPP_BIG_ENDIAN
|
||||
__hxcpp_reverse_endian(asInts[1]);
|
||||
#endif
|
||||
return asInts[1];
|
||||
}
|
||||
|
||||
#ifdef __OBJC__
|
||||
#ifdef HXCPP_OBJC
|
||||
|
||||
inline NSData *_hx_bytes_to_nsdata( ::Array<unsigned char> inBytes)
|
||||
{
|
||||
if (!inBytes.mPtr)
|
||||
return nil;
|
||||
|
||||
return [NSData dataWithBytes: inBytes->getBase() length:inBytes->length ];
|
||||
|
||||
}
|
||||
|
||||
inline ::Array<unsigned char> _hx_nsdata_to_bytes(NSData *inData)
|
||||
{
|
||||
if (inData==nil)
|
||||
return null();
|
||||
|
||||
return ::Array_obj<unsigned char>::fromData( (const unsigned char *)inData.bytes, inData.length );
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_regexp_new_options(String s, String options);
|
||||
|
||||
// EReg.hx -> src/hx/libs/regexp/RegExp.cpp
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_regexp_new_options(String s, String options);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_regexp_match(Dynamic handle, String string, int pos, int len);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_regexp_matched(Dynamic handle, int pos);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_regexp_matched_pos(Dynamic handle, int match);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_regexp_matched_num(Dynamic handle);
|
||||
|
||||
|
||||
// haxe.zip.(Un)Compress.hx -> src/hx/libs/zlib/ZLib.cpp
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_deflate_init(int level);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_deflate_bound(Dynamic handle,int length);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_deflate_buffer(Dynamic handle, Array<unsigned char> src, int srcPos, Array<unsigned char> dest, int destPos);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_deflate_end(Dynamic handle);
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_inflate_init(Dynamic windowBits);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_inflate_buffer(Dynamic handle, Array<unsigned char> src, int srcPos, Array<unsigned char> dest, int destPos);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_inflate_end(Dynamic handle);
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_zip_set_flush_mode(Dynamic handle, String flushMode);
|
||||
|
||||
// sys.db.Mysql.hx -> src/hx/libs/regexp/RegExp.cpp
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_mysql_connect(Dynamic params);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_mysql_select_db(Dynamic handle,String db);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_mysql_request(Dynamic handle,String req);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_mysql_close(Dynamic handle);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_mysql_escape(Dynamic handle,String str);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_mysql_result_get_length(Dynamic handle);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_mysql_result_get_nfields(Dynamic handle);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_mysql_result_next(Dynamic handle);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_mysql_result_get(Dynamic handle,int i);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_mysql_result_get_int(Dynamic handle,int i);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Float _hx_mysql_result_get_float(Dynamic handle,int i);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<String> _hx_mysql_result_get_fields_names(Dynamic handle);
|
||||
|
||||
namespace cpp { template<typename T> class Function; }
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_mysql_set_conversion(
|
||||
cpp::Function< Dynamic(Dynamic) > inCharsToBytes,
|
||||
cpp::Function< Dynamic(Float) > inTimeToDate );
|
||||
|
||||
// sys.db.Sqlite.hx -> src/hx/libs/sqlite/RegExp.cpp
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_sqlite_connect(String filename);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_sqlite_request(Dynamic handle,String req);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_sqlite_close(Dynamic handle);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_sqlite_last_insert_id(Dynamic handle);
|
||||
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_sqlite_result_get_length(Dynamic handle);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_sqlite_result_get_nfields(Dynamic handle);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_sqlite_result_next(Dynamic handle);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_sqlite_result_get(Dynamic handle,int i);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_sqlite_result_get_int(Dynamic handle,int i);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Float _hx_sqlite_result_get_float(Dynamic handle,int i);
|
||||
|
||||
// src/hx/libs/std ..
|
||||
// File
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_file_open( String fname, String r );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_file_close( Dynamic handle );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_file_write( Dynamic handle, Array<unsigned char> s, int p, int n );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_file_write_char( Dynamic handle, int c );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_file_read( Dynamic handle, Array<unsigned char> buf, int p, int n );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_file_read_char( Dynamic handle );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_file_seek( Dynamic handle, int pos, int kind );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_file_tell( Dynamic handle );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_std_file_eof( Dynamic handle );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_file_flush( Dynamic handle );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_file_contents_string( String name );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<unsigned char> _hx_std_file_contents_bytes( String name );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_file_stdin();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_file_stdout();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_file_stderr();
|
||||
|
||||
// Process
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_process_run( String cmd, Array<String> vargs, int inShow= 1 /* SHOW_NORMAL */ );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_process_stdout_read( Dynamic handle, Array<unsigned char> buf, int pos, int len );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_process_stderr_read( Dynamic handle, Array<unsigned char> buf, int pos, int len );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_process_stdin_write( Dynamic handle, Array<unsigned char> buf, int pos, int len );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_process_stdin_close( Dynamic handle );
|
||||
#if (HXCPP_API_LEVEL > 420)
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_process_exit( Dynamic handle, bool block );
|
||||
#else
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_process_exit( Dynamic handle );
|
||||
#endif
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_process_pid( Dynamic handle );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_process_kill( Dynamic handle );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_process_close( Dynamic handle );
|
||||
|
||||
// Random
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_random_new();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_random_set_seed( Dynamic handle, int v );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_random_int( Dynamic handle, int max );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES double _hx_std_random_float( Dynamic handle );
|
||||
|
||||
// Socket
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_init();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_socket_new( bool udp, bool ipv6 = false );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_bind( Dynamic o, int host, int port );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_bind_ipv6( Dynamic o, Array<unsigned char> host, int port );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_close( Dynamic handle );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_send_char( Dynamic o, int c );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_socket_send( Dynamic o, Array<unsigned char> buf, int p, int l );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_socket_recv( Dynamic o, Array<unsigned char> buf, int p, int l );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_socket_recv_char( Dynamic o );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_write( Dynamic o, Array<unsigned char> buf );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<unsigned char> _hx_std_socket_read( Dynamic o );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_host_resolve( String host );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<unsigned char> _hx_std_host_resolve_ipv6( String host, bool dummy=true );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_host_to_string( int ip );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_host_to_string_ipv6( Array<unsigned char> ip );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_host_reverse( int host );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_host_reverse_ipv6( Array<unsigned char> host );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_host_local();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_connect( Dynamic o, int host, int port );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_connect_ipv6( Dynamic o, Array<unsigned char> host, int port );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_listen( Dynamic o, int n );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<Dynamic> _hx_std_socket_select( Array<Dynamic> rs, Array<Dynamic> ws, Array<Dynamic> es, Dynamic timeout );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_fast_select( Array<Dynamic> rs, Array<Dynamic> ws, Array<Dynamic> es, Dynamic timeout );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_socket_accept( Dynamic o );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<int> _hx_std_socket_peer( Dynamic o );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<int> _hx_std_socket_host( Dynamic o );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_set_timeout( Dynamic o, Dynamic t );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_shutdown( Dynamic o, bool r, bool w );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_set_blocking( Dynamic o, bool b );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_set_fast_send( Dynamic o, bool b );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_set_broadcast( Dynamic o, bool b );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_socket_poll_alloc( int nsocks );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<Dynamic> _hx_std_socket_poll_prepare( Dynamic pdata, Array<Dynamic> rsocks, Array<Dynamic> wsocks );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_poll_events( Dynamic pdata, double timeout );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<Dynamic> _hx_std_socket_poll( Array<Dynamic> socks, Dynamic pdata, double timeout );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_socket_send_to( Dynamic o, Array<unsigned char> buf, int p, int l, Dynamic inAddr );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_socket_recv_from( Dynamic o, Array<unsigned char> buf, int p, int l, Dynamic outAddr);
|
||||
|
||||
// Sys
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_get_env( String v );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_put_env( String e, String v );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_sys_sleep( double f );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_std_set_time_locale( String l );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_get_cwd();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_std_set_cwd( String d );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_sys_string();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_std_sys_is64();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_sys_command( String cmd );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_sys_exit( int code );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_std_sys_exists( String path );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_file_delete( String path );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_sys_rename( String path, String newname );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_sys_stat( String path );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_sys_file_type( String path );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_std_sys_create_dir( String path, int mode );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_sys_remove_dir( String path );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES double _hx_std_sys_time();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES double _hx_std_sys_cpu_time();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<String> _hx_std_sys_read_dir( String p);
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_file_full_path( String path );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_sys_exe_path();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<String> _hx_std_sys_env();
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_sys_getch( bool b );
|
||||
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_sys_get_pid();
|
||||
|
||||
|
||||
// SSL
|
||||
void _hx_ssl_init();
|
||||
Dynamic _hx_ssl_new( Dynamic hconf );
|
||||
void _hx_ssl_close( Dynamic hssl );
|
||||
void _hx_ssl_debug_set (int i);
|
||||
void _hx_ssl_handshake( Dynamic handle );
|
||||
void _hx_ssl_set_socket( Dynamic hssl, Dynamic hsocket );
|
||||
void _hx_ssl_set_hostname( Dynamic hssl, String hostname );
|
||||
Dynamic _hx_ssl_get_peer_certificate( Dynamic hssl );
|
||||
bool _hx_ssl_get_verify_result( Dynamic hssl );
|
||||
void _hx_ssl_send_char( Dynamic hssl, int v );
|
||||
int _hx_ssl_send( Dynamic hssl, Array<unsigned char> buf, int p, int l );
|
||||
void _hx_ssl_write( Dynamic hssl, Array<unsigned char> buf );
|
||||
int _hx_ssl_recv_char( Dynamic hssl );
|
||||
int _hx_ssl_recv( Dynamic hssl, Array<unsigned char> buf, int p, int l );
|
||||
Array<unsigned char> _hx_ssl_read( Dynamic hssl );
|
||||
Dynamic _hx_ssl_conf_new( bool server );
|
||||
void _hx_ssl_conf_close( Dynamic hconf );
|
||||
void _hx_ssl_conf_set_ca( Dynamic hconf, Dynamic hcert );
|
||||
void _hx_ssl_conf_set_verify( Dynamic hconf, int mode );
|
||||
void _hx_ssl_conf_set_cert( Dynamic hconf, Dynamic hcert, Dynamic hpkey );
|
||||
void _hx_ssl_conf_set_servername_callback( Dynamic hconf, Dynamic obj );
|
||||
Dynamic _hx_ssl_cert_load_defaults();
|
||||
Dynamic _hx_ssl_cert_load_file( String file );
|
||||
Dynamic _hx_ssl_cert_load_path( String path );
|
||||
String _hx_ssl_cert_get_subject( Dynamic hcert, String objname );
|
||||
String _hx_ssl_cert_get_issuer( Dynamic hcert, String objname );
|
||||
Array<String> _hx_ssl_cert_get_altnames( Dynamic hcert );
|
||||
Array<int> _hx_ssl_cert_get_notbefore( Dynamic hcert );
|
||||
Array<int> _hx_ssl_cert_get_notafter( Dynamic hcert );
|
||||
Dynamic _hx_ssl_cert_get_next( Dynamic hcert );
|
||||
Dynamic _hx_ssl_cert_add_pem( Dynamic hcert, String data );
|
||||
Dynamic _hx_ssl_cert_add_der( Dynamic hcert, Array<unsigned char> buf );
|
||||
Dynamic _hx_ssl_key_from_der( Array<unsigned char> buf, bool pub );
|
||||
Dynamic _hx_ssl_key_from_pem( String data, bool pub, String pass );
|
||||
Array<unsigned char> _hx_ssl_dgst_make( Array<unsigned char> buf, String alg );
|
||||
Array<unsigned char> _hx_ssl_dgst_sign( Array<unsigned char> buf, Dynamic hpkey, String alg );
|
||||
bool _hx_ssl_dgst_verify( Array<unsigned char> buf, Array<unsigned char> sign, Dynamic hpkey, String alg );
|
||||
|
||||
|
||||
#endif
|
||||
30
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/StdString.h
Normal file
30
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/StdString.h
Normal file
@ -0,0 +1,30 @@
|
||||
#ifndef HX_STD_STRING_INCLUDEDED
|
||||
#define HX_STD_STRING_INCLUDEDED
|
||||
|
||||
#include <string>
|
||||
|
||||
namespace hx
|
||||
{
|
||||
class StdString : public std::string
|
||||
{
|
||||
public:
|
||||
StdString() : std::string() { }
|
||||
StdString(const char *inPtr) : std::string(inPtr) { }
|
||||
StdString(const char *inPtr, int inLen) : std::string(inPtr, inLen) { }
|
||||
StdString(const std::string &inS) : std::string(inS) { }
|
||||
StdString(const StdString &inS) : std::string(inS) { }
|
||||
|
||||
#if (HXCPP_API_LEVEL>1)
|
||||
StdString(const Dynamic &inS) : std::string(inS.mPtr ? inS.mPtr->toString().utf8_str() : "null") { }
|
||||
StdString(const String &inS) : std::string(inS.utf8_str()) { }
|
||||
String toString() const { return String(c_str(),size()).dup(); }
|
||||
String toString() { return String(c_str(),size()).dup(); }
|
||||
operator Dynamic() const { return const_cast<StdString*>(this)->toString(); }
|
||||
#endif
|
||||
|
||||
inline const StdString &toStdString() const { return *this; }
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
53
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/StringAlloc.h
Executable file
53
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/StringAlloc.h
Executable file
@ -0,0 +1,53 @@
|
||||
#ifndef HX_STRING_ALLOC
|
||||
#define HX_STRING_ALLOC
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
class IStringAlloc
|
||||
{
|
||||
public:
|
||||
virtual void *allocBytes(size_t inBytes) = 0;
|
||||
|
||||
protected:
|
||||
~IStringAlloc(){};
|
||||
};
|
||||
|
||||
template<int STACK>
|
||||
class StringAlloc : public IStringAlloc
|
||||
{
|
||||
char buffer[STACK];
|
||||
size_t alloced;
|
||||
char *heap;
|
||||
|
||||
public:
|
||||
inline StringAlloc() : alloced(0), heap(0) { }
|
||||
~StringAlloc()
|
||||
{
|
||||
if (heap)
|
||||
free(heap);
|
||||
}
|
||||
void *allocBytes(size_t inBytes)
|
||||
{
|
||||
if (inBytes<=STACK)
|
||||
return buffer;
|
||||
if (inBytes>alloced)
|
||||
{
|
||||
alloced = inBytes;
|
||||
heap = (char *)realloc(heap, alloced);
|
||||
}
|
||||
return heap;
|
||||
}
|
||||
private:
|
||||
StringAlloc(const StringAlloc &);
|
||||
void operator=(const StringAlloc &);
|
||||
};
|
||||
|
||||
typedef StringAlloc<100> strbuf;
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
#endif
|
||||
35
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Telemetry.h
Normal file
35
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Telemetry.h
Normal file
@ -0,0 +1,35 @@
|
||||
#ifndef HX_TELEMETRY_H
|
||||
#define HX_TELEMETRY_H
|
||||
|
||||
#define HX_TELEMETRY_VERSION 1
|
||||
|
||||
#include <hxcpp.h>
|
||||
#include <vector>
|
||||
|
||||
struct TelemetryFrame
|
||||
{
|
||||
// microseconds, always valid
|
||||
int gctime;
|
||||
int gcoverhead;
|
||||
|
||||
// Valid only if profiler is enabled
|
||||
std::vector<int> *samples;
|
||||
std::vector<const char*> *names;
|
||||
|
||||
// Valid only if allocations (and profiler) are enabled
|
||||
std::vector<int> *allocation_data;
|
||||
std::vector<int> *stacks;
|
||||
};
|
||||
|
||||
// --- Telemetry -----------------------------------------------------------------
|
||||
|
||||
int __hxcpp_hxt_start_telemetry(bool profiler, bool allocations);
|
||||
void __hxcpp_hxt_stash_telemetry();
|
||||
TelemetryFrame* __hxcpp_hxt_dump_telemetry(int thread_num);
|
||||
void __hxcpp_hxt_ignore_allocs(int delta);
|
||||
|
||||
// expose these from GCInternal
|
||||
int __hxcpp_gc_reserved_bytes();
|
||||
int __hxcpp_gc_used_bytes();
|
||||
|
||||
#endif
|
||||
458
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Thread.h
Normal file
458
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Thread.h
Normal file
@ -0,0 +1,458 @@
|
||||
#ifdef HX_THREAD_H_OVERRIDE
|
||||
// Users can define their own header to use here, but there is no API
|
||||
// compatibility gaurantee for future changes.
|
||||
#include HX_THREAD_H_OVERRIDE
|
||||
#else
|
||||
|
||||
#ifndef HX_THREAD_H
|
||||
#define HX_THREAD_H
|
||||
|
||||
#ifndef HXCPP_HEADER_VERSION
|
||||
#include "hx/HeaderVersion.h"
|
||||
#endif
|
||||
|
||||
#if defined(KORE)
|
||||
|
||||
#include <kinc/threads/atomic.h>
|
||||
#include <kinc/threads/event.h>
|
||||
#include <kinc/threads/mutex.h>
|
||||
#include <kinc/threads/thread.h>
|
||||
|
||||
#elif defined(HX_WINRT)
|
||||
|
||||
#include <windows.h>
|
||||
#include <process.h>
|
||||
#include <mutex>
|
||||
|
||||
#elif defined(_WIN32)
|
||||
|
||||
#ifdef HXCPP_WINXP_COMPAT
|
||||
#undef _WIN32_WINNT
|
||||
#define _WIN32_WINNT 0x0400
|
||||
#else
|
||||
#undef _WIN32_WINNT
|
||||
#define _WIN32_WINNT 0x0600
|
||||
#endif
|
||||
|
||||
#include <windows.h>
|
||||
#include <process.h>
|
||||
#else
|
||||
#include <errno.h>
|
||||
#include <pthread.h>
|
||||
#include <sys/time.h>
|
||||
#include <stdio.h>
|
||||
#define HXCPP_PTHREADS
|
||||
#endif
|
||||
|
||||
#ifdef RegisterClass
|
||||
#undef RegisterClass
|
||||
#endif
|
||||
|
||||
#if defined(KORE)
|
||||
|
||||
struct HxMutex {
|
||||
HxMutex() {
|
||||
kinc_mutex_init(&mutex);
|
||||
}
|
||||
|
||||
~HxMutex() {
|
||||
kinc_mutex_destroy(&mutex);
|
||||
}
|
||||
|
||||
void Lock() {
|
||||
kinc_mutex_lock(&mutex);
|
||||
}
|
||||
|
||||
void Unlock() {
|
||||
kinc_mutex_unlock(&mutex);
|
||||
}
|
||||
|
||||
bool TryLock() {
|
||||
return kinc_mutex_try_to_lock(&mutex);
|
||||
}
|
||||
|
||||
void Clean() {
|
||||
kinc_mutex_destroy(&mutex);
|
||||
}
|
||||
private:
|
||||
kinc_mutex_t mutex;
|
||||
};
|
||||
|
||||
#define THREAD_FUNC_TYPE void
|
||||
#define THREAD_FUNC_RET return;
|
||||
|
||||
inline bool HxCreateDetachedThread(void (*func)(void *), void *param)
|
||||
{
|
||||
kinc_thread_t thread;
|
||||
kinc_thread_init(&thread, func, param);
|
||||
return true;
|
||||
}
|
||||
|
||||
#elif defined(HX_WINDOWS)
|
||||
|
||||
|
||||
struct HxMutex
|
||||
{
|
||||
HxMutex()
|
||||
{
|
||||
mValid = true;
|
||||
#ifdef HX_WINRT
|
||||
InitializeCriticalSectionEx(&mCritSec,4000,0);
|
||||
#else
|
||||
InitializeCriticalSection(&mCritSec);
|
||||
#endif
|
||||
}
|
||||
~HxMutex() { if (mValid) DeleteCriticalSection(&mCritSec); }
|
||||
void Lock() { EnterCriticalSection(&mCritSec); }
|
||||
void Unlock() { LeaveCriticalSection(&mCritSec); }
|
||||
bool TryLock() { return TryEnterCriticalSection(&mCritSec); }
|
||||
bool IsValid() { return mValid; }
|
||||
void Clean()
|
||||
{
|
||||
if (mValid)
|
||||
{
|
||||
DeleteCriticalSection(&mCritSec);
|
||||
mValid = false;
|
||||
}
|
||||
}
|
||||
|
||||
bool mValid;
|
||||
CRITICAL_SECTION mCritSec;
|
||||
};
|
||||
|
||||
|
||||
#define THREAD_FUNC_TYPE DWORD WINAPI
|
||||
#define THREAD_FUNC_RET return 0;
|
||||
|
||||
inline bool HxCreateDetachedThread(DWORD (WINAPI *func)(void *), void *param)
|
||||
{
|
||||
return (CreateThread(NULL, 0, func, param, 0, 0) != 0);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
struct HxMutex
|
||||
{
|
||||
HxMutex()
|
||||
{
|
||||
pthread_mutexattr_t mta;
|
||||
pthread_mutexattr_init(&mta);
|
||||
pthread_mutexattr_settype(&mta, PTHREAD_MUTEX_RECURSIVE);
|
||||
mValid = pthread_mutex_init(&mMutex,&mta) ==0;
|
||||
}
|
||||
~HxMutex() { if (mValid) pthread_mutex_destroy(&mMutex); }
|
||||
void Lock() { pthread_mutex_lock(&mMutex); }
|
||||
void Unlock() { pthread_mutex_unlock(&mMutex); }
|
||||
bool TryLock() { return !pthread_mutex_trylock(&mMutex); }
|
||||
bool IsValid() { return mValid; }
|
||||
void Clean()
|
||||
{
|
||||
if (mValid)
|
||||
pthread_mutex_destroy(&mMutex);
|
||||
mValid = 0;
|
||||
}
|
||||
|
||||
bool mValid;
|
||||
pthread_mutex_t mMutex;
|
||||
};
|
||||
|
||||
#define THREAD_FUNC_TYPE void *
|
||||
#define THREAD_FUNC_RET return 0;
|
||||
|
||||
inline bool HxCreateDetachedThread(void *(*func)(void *), void *param)
|
||||
{
|
||||
pthread_t t;
|
||||
pthread_attr_t attr;
|
||||
if (pthread_attr_init(&attr) != 0)
|
||||
return false;
|
||||
#ifdef PTHREAD_CREATE_DETACHED
|
||||
if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0)
|
||||
return false;
|
||||
#endif
|
||||
if (pthread_create(&t, &attr, func, param) != 0 )
|
||||
return false;
|
||||
if (pthread_attr_destroy(&attr) != 0)
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename LOCKABLE>
|
||||
struct TAutoLock
|
||||
{
|
||||
TAutoLock(LOCKABLE &inMutex) : mMutex(inMutex) { mMutex.Lock(); }
|
||||
~TAutoLock() { mMutex.Unlock(); }
|
||||
void Lock() { mMutex.Lock(); }
|
||||
void Unlock() { mMutex.Unlock(); }
|
||||
|
||||
LOCKABLE &mMutex;
|
||||
};
|
||||
|
||||
typedef TAutoLock<HxMutex> AutoLock;
|
||||
|
||||
#if defined(KORE)
|
||||
|
||||
struct HxSemaphore {
|
||||
HxSemaphore() {
|
||||
kinc_event_init(&event, true);
|
||||
}
|
||||
|
||||
~HxSemaphore() {
|
||||
kinc_event_destroy(&event);
|
||||
}
|
||||
|
||||
void Set() {
|
||||
kinc_event_signal(&event);
|
||||
}
|
||||
|
||||
void Wait() {
|
||||
kinc_event_wait(&event);
|
||||
}
|
||||
|
||||
bool WaitSeconds(double inSeconds) {
|
||||
return kinc_event_try_to_wait(&event, inSeconds);
|
||||
}
|
||||
|
||||
void Reset() {
|
||||
kinc_event_reset(&event);
|
||||
}
|
||||
|
||||
void Clean() {
|
||||
kinc_event_destroy(&event);
|
||||
}
|
||||
private:
|
||||
kinc_event_t event;
|
||||
};
|
||||
|
||||
struct ThreadPoolSignal {
|
||||
ThreadPoolSignal() {
|
||||
kinc_event_init(&event, true);
|
||||
}
|
||||
|
||||
~ThreadPoolSignal() {
|
||||
|
||||
}
|
||||
|
||||
void Set() {
|
||||
kinc_event_signal(&event);
|
||||
}
|
||||
|
||||
void Wait() {
|
||||
kinc_event_wait(&event);
|
||||
}
|
||||
|
||||
bool WaitSeconds(double inSeconds) {
|
||||
return kinc_event_try_to_wait(&event, inSeconds);
|
||||
}
|
||||
|
||||
void Reset() {
|
||||
kinc_event_reset(&event);
|
||||
}
|
||||
|
||||
void Clean() {
|
||||
kinc_event_destroy(&event);
|
||||
}
|
||||
private:
|
||||
kinc_event_t event;
|
||||
};
|
||||
|
||||
#elif defined(HX_WINDOWS)
|
||||
|
||||
struct HxSemaphore
|
||||
{
|
||||
HxSemaphore()
|
||||
{
|
||||
#ifdef HX_WINRT
|
||||
mSemaphore = CreateEventEx(nullptr,nullptr,0,EVENT_ALL_ACCESS);
|
||||
#else
|
||||
mSemaphore = CreateEvent(0,0,0,0);
|
||||
#endif
|
||||
}
|
||||
~HxSemaphore() { if (mSemaphore) CloseHandle(mSemaphore); }
|
||||
void Set() { SetEvent(mSemaphore); }
|
||||
void Wait()
|
||||
{
|
||||
#ifdef HX_WINRT
|
||||
WaitForSingleObjectEx(mSemaphore,INFINITE,false);
|
||||
#else
|
||||
WaitForSingleObject(mSemaphore,INFINITE);
|
||||
#endif
|
||||
}
|
||||
// Returns true on success, false on timeout
|
||||
bool WaitSeconds(double inSeconds)
|
||||
{
|
||||
#ifdef HX_WINRT
|
||||
return WaitForSingleObjectEx(mSemaphore,inSeconds*1000.0,false) != WAIT_TIMEOUT;
|
||||
#else
|
||||
return WaitForSingleObject(mSemaphore,inSeconds*1000.0) != WAIT_TIMEOUT;
|
||||
#endif
|
||||
}
|
||||
void Reset() { ResetEvent(mSemaphore); }
|
||||
void Clean() { if (mSemaphore) CloseHandle(mSemaphore); mSemaphore = 0; }
|
||||
|
||||
HANDLE mSemaphore;
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
|
||||
#define HX_THREAD_SEMAPHORE_LOCKABLE
|
||||
|
||||
struct HxSemaphore
|
||||
{
|
||||
HxSemaphore()
|
||||
{
|
||||
mSet = false;
|
||||
mValid = true;
|
||||
pthread_cond_init(&mCondition,0);
|
||||
}
|
||||
~HxSemaphore()
|
||||
{
|
||||
if (mValid)
|
||||
{
|
||||
pthread_cond_destroy(&mCondition);
|
||||
}
|
||||
}
|
||||
// For autolock
|
||||
inline operator HxMutex &() { return mMutex; }
|
||||
void Set()
|
||||
{
|
||||
AutoLock lock(mMutex);
|
||||
if (!mSet)
|
||||
{
|
||||
mSet = true;
|
||||
pthread_cond_signal( &mCondition );
|
||||
}
|
||||
}
|
||||
void QSet()
|
||||
{
|
||||
mSet = true;
|
||||
pthread_cond_signal( &mCondition );
|
||||
}
|
||||
void Reset()
|
||||
{
|
||||
AutoLock lock(mMutex);
|
||||
mSet = false;
|
||||
}
|
||||
void QReset() { mSet = false; }
|
||||
void Wait()
|
||||
{
|
||||
AutoLock lock(mMutex);
|
||||
while( !mSet )
|
||||
pthread_cond_wait( &mCondition, &mMutex.mMutex );
|
||||
mSet = false;
|
||||
}
|
||||
// when we already hold the mMutex lock ...
|
||||
void QWait()
|
||||
{
|
||||
while( !mSet )
|
||||
pthread_cond_wait( &mCondition, &mMutex.mMutex );
|
||||
mSet = false;
|
||||
}
|
||||
// Returns true if the wait was success, false on timeout.
|
||||
bool WaitSeconds(double inSeconds)
|
||||
{
|
||||
struct timeval tv;
|
||||
gettimeofday(&tv, 0);
|
||||
|
||||
int isec = (int)inSeconds;
|
||||
int usec = (int)((inSeconds-isec)*1000000.0);
|
||||
timespec spec;
|
||||
spec.tv_nsec = (tv.tv_usec + usec) * 1000;
|
||||
if (spec.tv_nsec>1000000000)
|
||||
{
|
||||
spec.tv_nsec-=1000000000;
|
||||
isec++;
|
||||
}
|
||||
spec.tv_sec = tv.tv_sec + isec;
|
||||
|
||||
AutoLock lock(mMutex);
|
||||
|
||||
int result = 0;
|
||||
// Wait for set to be true...
|
||||
while( !mSet && (result=pthread_cond_timedwait( &mCondition, &mMutex.mMutex, &spec )) != ETIMEDOUT)
|
||||
{
|
||||
if (result!=0)
|
||||
{
|
||||
// Error - something's gone wrong...
|
||||
/*
|
||||
if (result==EINVAL)
|
||||
printf("ERROR: Condition EINVAL\n");
|
||||
else if (result==EPERM)
|
||||
printf("ERROR: Condition EPERM\n");
|
||||
else
|
||||
printf("ERROR: Condition unknown error\n");
|
||||
*/
|
||||
break;
|
||||
}
|
||||
// Condition signalled - but try mSet again ...
|
||||
}
|
||||
|
||||
bool wasSet = mSet;
|
||||
mSet = false;
|
||||
return wasSet;
|
||||
}
|
||||
void Clean()
|
||||
{
|
||||
mMutex.Clean();
|
||||
if (mValid)
|
||||
{
|
||||
mValid = false;
|
||||
pthread_cond_destroy(&mCondition);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
HxMutex mMutex;
|
||||
pthread_cond_t mCondition;
|
||||
bool mSet;
|
||||
bool mValid;
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#if defined(KORE)
|
||||
|
||||
#include <kinc/threads/thread.h>
|
||||
|
||||
inline void HxSleep(unsigned int ms)
|
||||
{
|
||||
kinc_thread_sleep(ms);
|
||||
}
|
||||
|
||||
#elif defined HX_WINRT
|
||||
|
||||
inline void HxSleep(unsigned int ms)
|
||||
{
|
||||
::Sleep(ms);
|
||||
}
|
||||
|
||||
#elif defined HX_WINDOWS
|
||||
|
||||
inline void HxSleep(unsigned int ms)
|
||||
{
|
||||
::Sleep(ms);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
inline void HxSleep(unsigned int ms)
|
||||
{
|
||||
struct timespec t;
|
||||
struct timespec tmp;
|
||||
t.tv_sec = 0;
|
||||
t.tv_nsec = ms * 1000000;
|
||||
nanosleep(&t, &tmp);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#endif
|
||||
#endif
|
||||
200
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Tls.h
Executable file
200
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Tls.h
Executable file
@ -0,0 +1,200 @@
|
||||
#ifdef HX_TLS_H_OVERRIDE
|
||||
// Users can define their own header to use here, but there is no API
|
||||
// compatibility gaurantee for future changes.
|
||||
#include HX_TLS_H_OVERRIDE
|
||||
#else
|
||||
|
||||
#ifndef HX_TLS_INCLUDED
|
||||
#define HX_TLS_INCLUDED
|
||||
|
||||
#if defined(HX_WINDOWS) || defined(KORE_CONSOLE)
|
||||
|
||||
#if defined(HX_WINRT)
|
||||
// Nothing
|
||||
#elif defined(KORE_CONSOLE)
|
||||
|
||||
#include <kinc/threads/threadlocal.h>
|
||||
|
||||
namespace hx {
|
||||
template<typename DATA, bool FAST = false> struct TLSData {
|
||||
TLSData() {
|
||||
kinc_thread_local_init(&tls);
|
||||
}
|
||||
|
||||
~TLSData() {
|
||||
kinc_thread_local_destroy(&tls);
|
||||
}
|
||||
|
||||
DATA *Get() {
|
||||
return (DATA*)kinc_thread_local_get(&tls);
|
||||
}
|
||||
|
||||
void Set(DATA *inData) {
|
||||
kinc_thread_local_set(&tls, inData);
|
||||
}
|
||||
|
||||
inline DATA *operator=(DATA *inData) {
|
||||
kinc_thread_local_set(&tls, inData);
|
||||
return inData;
|
||||
}
|
||||
|
||||
inline operator DATA*() {
|
||||
return (DATA*)kinc_thread_local_get(&tls);
|
||||
}
|
||||
private:
|
||||
kinc_thread_local_t tls;
|
||||
};
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
#if ! defined(__GNUC__) && !defined(__BORLANDC__)
|
||||
#include <intrin.h>
|
||||
#endif
|
||||
|
||||
extern "C"
|
||||
{
|
||||
__declspec(dllimport)
|
||||
int __stdcall TlsSetValue(unsigned long dwTlsIndex, void *lpTlsValue);
|
||||
|
||||
__declspec(dllimport)
|
||||
void * __stdcall TlsGetValue(unsigned long dwTlsIndex);
|
||||
|
||||
__declspec(dllimport)
|
||||
unsigned long __stdcall TlsAlloc(void);
|
||||
}
|
||||
|
||||
|
||||
namespace hx {
|
||||
|
||||
template<typename DATA,bool FAST=false>
|
||||
struct TLSData
|
||||
{
|
||||
static const size_t kMaxInlineSlots = 64;
|
||||
|
||||
TLSData()
|
||||
{
|
||||
mSlot = TlsAlloc();
|
||||
TlsSetValue(mSlot,0);
|
||||
#ifdef HXCPP_M64
|
||||
mFastOffset = mSlot*sizeof(void *) + 0x1480;
|
||||
#else
|
||||
if (FAST || mSlot < kMaxInlineSlots)
|
||||
mFastOffset = mSlot*sizeof(void *) + 0xE10;
|
||||
else
|
||||
mFastOffset = mSlot - kMaxInlineSlots;
|
||||
#endif
|
||||
}
|
||||
inline DATA *operator=(DATA *inData)
|
||||
{
|
||||
TlsSetValue(mSlot,inData);
|
||||
return inData;
|
||||
}
|
||||
|
||||
inline operator DATA *()
|
||||
{
|
||||
#if !defined(HXCPP_M64) && (_MSC_VER >= 1400)
|
||||
const size_t kTibExtraTlsOffset = 0xF94;
|
||||
|
||||
if (FAST || mSlot < kMaxInlineSlots)
|
||||
return (DATA *)__readfsdword(mFastOffset);
|
||||
|
||||
DATA **extra = (DATA **)(__readfsdword(kTibExtraTlsOffset));
|
||||
return extra[mFastOffset];
|
||||
#elif (_MSC_VER >= 1400) & !defined(HXCPP_DEBUG) && !defined(HXCPP_ARM64)// 64 bit version...
|
||||
if (mSlot < 64)
|
||||
return (DATA *)__readgsqword(mFastOffset);
|
||||
else
|
||||
return (DATA *)TlsGetValue(mSlot);
|
||||
#else
|
||||
return (DATA *)TlsGetValue(mSlot);
|
||||
#endif
|
||||
}
|
||||
|
||||
int mSlot;
|
||||
int mFastOffset;
|
||||
};
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
|
||||
#define DECLARE_TLS_DATA(TYPE,NAME) \
|
||||
hx::TLSData<TYPE> NAME;
|
||||
#define DECLARE_FAST_TLS_DATA(TYPE,NAME) \
|
||||
hx::TLSData<TYPE,true> NAME;
|
||||
#define EXTERN_TLS_DATA(TYPE,NAME) \
|
||||
extern hx::TLSData<TYPE> NAME;
|
||||
#define EXTERN_FAST_TLS_DATA(TYPE,NAME) \
|
||||
extern hx::TLSData<TYPE,true> NAME;
|
||||
|
||||
|
||||
#endif
|
||||
#else // not HX_WINDOWS
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
template<typename DATA,bool FAST=false>
|
||||
struct TLSData
|
||||
{
|
||||
TLSData()
|
||||
{
|
||||
pthread_key_create(&mSlot, 0);
|
||||
}
|
||||
DATA *Get()
|
||||
{
|
||||
return (DATA *)pthread_getspecific(mSlot);
|
||||
}
|
||||
void Set(DATA *inData)
|
||||
{
|
||||
pthread_setspecific(mSlot,inData);
|
||||
}
|
||||
inline DATA *operator=(DATA *inData)
|
||||
{
|
||||
pthread_setspecific(mSlot,inData);
|
||||
return inData;
|
||||
}
|
||||
inline operator DATA *() { return (DATA *)pthread_getspecific(mSlot); }
|
||||
|
||||
pthread_key_t mSlot;
|
||||
};
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#ifdef HX_WINRT
|
||||
|
||||
#define DECLARE_TLS_DATA(TYPE,NAME) \
|
||||
__declspec(thread) TYPE * NAME = nullptr;
|
||||
#define DECLARE_FAST_TLS_DATA(TYPE,NAME) \
|
||||
__declspec(thread) TYPE * NAME = nullptr;
|
||||
#define EXTERN_TLS_DATA(TYPE,NAME) \
|
||||
__declspec(thread) extern TYPE * NAME;
|
||||
#define EXTERN_FAST_TLS_DATA(TYPE,NAME) \
|
||||
__declspec(thread) extern TYPE * NAME;
|
||||
|
||||
#else
|
||||
|
||||
#define DECLARE_TLS_DATA(TYPE,NAME) \
|
||||
hx::TLSData<TYPE> NAME;
|
||||
#define DECLARE_FAST_TLS_DATA(TYPE,NAME) \
|
||||
hx::TLSData<TYPE,true> NAME;
|
||||
#define EXTERN_TLS_DATA(TYPE,NAME) \
|
||||
extern hx::TLSData<TYPE> NAME;
|
||||
#define EXTERN_FAST_TLS_DATA(TYPE,NAME) \
|
||||
extern hx::TLSData<TYPE,true> NAME;
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
44
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Undefine.h
Normal file
44
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Undefine.h
Normal file
@ -0,0 +1,44 @@
|
||||
#ifndef HX_UNDEFINE_H
|
||||
#define HX_UNDEFINE_H
|
||||
|
||||
|
||||
#if (HXCPP_API_LEVEL < 321)
|
||||
#undef INT_MIN
|
||||
#undef INT_MAX
|
||||
#undef INT8_MIN
|
||||
#undef INT8_MAX
|
||||
#undef UINT8_MAX
|
||||
#undef INT16_MIN
|
||||
#undef INT16_MAX
|
||||
#undef UINT16_MAX
|
||||
#undef INT32_MIN
|
||||
#undef INT32_MAX
|
||||
#undef UINT32_MAX
|
||||
#endif
|
||||
|
||||
|
||||
#undef TRUE
|
||||
#undef FALSE
|
||||
#undef BOOLEAN
|
||||
#undef ERROR
|
||||
#undef NO_ERROR
|
||||
#undef DELETE
|
||||
#undef OPTIONS
|
||||
#undef IN
|
||||
#undef OUT
|
||||
#undef ALTERNATE
|
||||
#undef OPTIONAL
|
||||
#undef DOUBLE_CLICK
|
||||
#undef DIFFERENCE
|
||||
#undef POINT
|
||||
#undef RECT
|
||||
#undef OVERFLOW
|
||||
#undef UNDERFLOW
|
||||
#undef DOMAIN
|
||||
#undef TRANSPARENT
|
||||
#undef CONST
|
||||
#undef CopyFile
|
||||
#undef COLOR_HIGHLIGHT
|
||||
#undef __valid
|
||||
|
||||
#endif
|
||||
38
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Unordered.h
Normal file
38
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Unordered.h
Normal file
@ -0,0 +1,38 @@
|
||||
#ifndef HX_UNORDERED_INCLUDED
|
||||
#define HX_UNORDERED_INCLUDED
|
||||
|
||||
#if (defined(_MSC_VER) && (_MSC_VER >= 1800)) || ( defined(__GNUC__) && defined(HXCPP_CPP11) )
|
||||
#include <unordered_set>
|
||||
#include <unordered_map>
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
template<typename T>
|
||||
struct UnorderedSet : public std::unordered_set<T> { };
|
||||
|
||||
template<typename KEY, typename VALUE>
|
||||
struct UnorderedMap : public std::unordered_map<KEY,VALUE> { };
|
||||
|
||||
}
|
||||
|
||||
|
||||
#else
|
||||
|
||||
#include <set>
|
||||
#include <map>
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
template<typename T>
|
||||
struct UnorderedSet : public std::set<T> { };
|
||||
|
||||
template<typename KEY, typename VALUE>
|
||||
struct UnorderedMap : public std::map<KEY,VALUE> { };
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
84
Kha/Backends/Kinc-hxcpp/khacpp/include/hxMath.h
Normal file
84
Kha/Backends/Kinc-hxcpp/khacpp/include/hxMath.h
Normal file
@ -0,0 +1,84 @@
|
||||
#ifndef HX_MATH
|
||||
#define HX_MATH
|
||||
|
||||
#ifndef HXCPP_H
|
||||
#include <hxcpp.h>
|
||||
#endif
|
||||
|
||||
#include <cmath>
|
||||
#include <stdlib.h>
|
||||
|
||||
class HXCPP_EXTERN_CLASS_ATTRIBUTES Math_obj : public hx::Object
|
||||
{
|
||||
public:
|
||||
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdMath };
|
||||
|
||||
typedef hx::Object super;
|
||||
typedef Math_obj OBJ_;
|
||||
HX_DO_RTTI;
|
||||
void __construct();
|
||||
static Dynamic __CreateEmpty();
|
||||
static void __boot();
|
||||
|
||||
inline static int floor(double inX) { return __int__(::std::floor(inX)); }
|
||||
inline static int ceil(double inX) { return __int__(::std::ceil(inX)); }
|
||||
inline static int round(double inX) { return floor(inX+0.5); }
|
||||
inline static double ffloor(double inX) { return ::std::floor(inX); }
|
||||
inline static double fceil(double inX) { return ::std::ceil(inX); }
|
||||
inline static double fround(double inX) { return ::std::floor(inX+0.5); }
|
||||
inline static double random() { return __hxcpp_drand(); }
|
||||
inline static double sqrt(double inX) { return ::std::sqrt(inX); }
|
||||
inline static double cos(double inX) { return ::std::cos(inX); }
|
||||
inline static double sin(double inX) { return ::std::sin(inX); }
|
||||
inline static double tan(double inX) { return ::std::tan(inX); }
|
||||
inline static double atan2(double inY,double inX) { return ::std::atan2(inY,inX); }
|
||||
inline static double abs(double inX) { return ::std::fabs(inX); }
|
||||
inline static double pow(double inA,double inB) { return ::std::pow(inA,inB); }
|
||||
inline static double log(double inA) { return ::std::log(inA); }
|
||||
inline static double max(double inA,double inB) { return inA>inB ? inA:inA==inA?inB:inA; }
|
||||
inline static double min(double inA,double inB) { return inA<inB ? inA:inA==inA?inB:inA; }
|
||||
|
||||
inline static double atan(double inA) { return ::std::atan(inA); }
|
||||
inline static double asin(double inA) { return ::std::asin(inA); }
|
||||
inline static double acos(double inA) { return ::std::acos(inA); }
|
||||
inline static double exp(double inA) { return ::std::exp(inA); }
|
||||
|
||||
|
||||
static bool isNaN(double inX);
|
||||
static bool isFinite(double inX);
|
||||
|
||||
|
||||
static Dynamic floor_dyn();
|
||||
static Dynamic ceil_dyn();
|
||||
static Dynamic round_dyn();
|
||||
static Dynamic ffloor_dyn();
|
||||
static Dynamic fceil_dyn();
|
||||
static Dynamic fround_dyn();
|
||||
static Dynamic random_dyn();
|
||||
static Dynamic sqrt_dyn();
|
||||
static Dynamic cos_dyn();
|
||||
static Dynamic sin_dyn();
|
||||
static Dynamic tan_dyn();
|
||||
static Dynamic atan2_dyn();
|
||||
static Dynamic abs_dyn();
|
||||
static Dynamic pow_dyn();
|
||||
static Dynamic log_dyn();
|
||||
static Dynamic min_dyn();
|
||||
static Dynamic max_dyn();
|
||||
static Dynamic atan_dyn();
|
||||
static Dynamic asin_dyn();
|
||||
static Dynamic acos_dyn();
|
||||
static Dynamic exp_dyn();
|
||||
static Dynamic isNaN_dyn();
|
||||
static Dynamic isFinite_dyn();
|
||||
|
||||
static double NaN;
|
||||
static double PI;
|
||||
static double NEGATIVE_INFINITY;
|
||||
static double POSITIVE_INFINITY;
|
||||
};
|
||||
|
||||
typedef hx::ObjectPtr<Math_obj> Math;
|
||||
|
||||
|
||||
#endif
|
||||
406
Kha/Backends/Kinc-hxcpp/khacpp/include/hxString.h
Normal file
406
Kha/Backends/Kinc-hxcpp/khacpp/include/hxString.h
Normal file
@ -0,0 +1,406 @@
|
||||
#ifndef HX_STRING_H
|
||||
#define HX_STRING_H
|
||||
|
||||
#ifndef HXCPP_H
|
||||
#error "Please include hxcpp.h, not hx/Object.h"
|
||||
#endif
|
||||
|
||||
#include <hx/StringAlloc.h>
|
||||
|
||||
#ifdef __OBJC__
|
||||
#import <Foundation/Foundation.h>
|
||||
#endif
|
||||
|
||||
#if __cplusplus < 201103L && !defined(KORE_MICROSOFT)
|
||||
typedef unsigned short char16_t;
|
||||
#endif
|
||||
|
||||
// --- String --------------------------------------------------------
|
||||
//
|
||||
// Basic String type for hxcpp.
|
||||
// It's based on garbage collection of the wchar_t (or char ) *ptr.
|
||||
// Note: this does not inherit from "hx::Object", so in some ways it acts more
|
||||
// like a standard "int" type than a mode generic class.
|
||||
|
||||
class HXCPP_EXTERN_CLASS_ATTRIBUTES String
|
||||
{
|
||||
friend class StringOffset;
|
||||
|
||||
public:
|
||||
// These allocate the function using the garbage-colleced malloc
|
||||
void *operator new( size_t inSize );
|
||||
inline void* operator new( size_t, void* ptr ) { return ptr; }
|
||||
void operator delete( void * ) { }
|
||||
|
||||
inline String() : length(0), __s(0) { }
|
||||
|
||||
// Uses pointer
|
||||
inline String(const char *inPtr,int inLen) : __s(inPtr), length(inLen) { }
|
||||
#ifdef HX_SMART_STRINGS
|
||||
inline String(const char16_t *inPtr,int inLen) : __w(inPtr), length(inLen) { }
|
||||
#endif
|
||||
|
||||
// Makes copy
|
||||
inline String(const wchar_t *inPtr) { *this = create(inPtr); }
|
||||
inline String(const char16_t *inPtr) { *this = create(inPtr); }
|
||||
inline String(const char *inPtr) { *this = create(inPtr); }
|
||||
|
||||
static String create(const wchar_t *inPtr,int inLen=-1);
|
||||
static String create(const char16_t *inPtr,int inLen=-1);
|
||||
static String create(const char *inPtr,int inLen=-1);
|
||||
|
||||
// Uses non-gc memory and wont ever be collected
|
||||
static ::String createPermanent(const char *inUtf8, int inLen);
|
||||
const ::String &makePermanent() const;
|
||||
hx::Object *makePermanentObject() const;
|
||||
|
||||
// Legacy
|
||||
::String &dup();
|
||||
|
||||
|
||||
#ifdef __OBJC__
|
||||
inline String(NSString *inString)
|
||||
{
|
||||
if (inString)
|
||||
*this = String([inString UTF8String]);
|
||||
else
|
||||
{
|
||||
length = 0;
|
||||
__s = 0;
|
||||
}
|
||||
}
|
||||
inline operator NSString * () const
|
||||
{
|
||||
hx::strbuf buf;
|
||||
return [[NSString alloc] initWithUTF8String:utf8_str(&buf) ];
|
||||
}
|
||||
#endif
|
||||
#if defined(HX_WINRT) && defined(__cplusplus_winrt)
|
||||
inline String(Platform::String^ inString)
|
||||
{
|
||||
*this = String(inString->Data());
|
||||
}
|
||||
inline String(Platform::StringReference inString)
|
||||
{
|
||||
*this = String(inString.Data());
|
||||
}
|
||||
#endif
|
||||
|
||||
inline String(const ::String &inRHS) : __s(inRHS.__s), length(inRHS.length) { }
|
||||
String(const int &inRHS);
|
||||
String(const unsigned int &inRHS);
|
||||
String(const short &inRHS) { fromInt(inRHS); }
|
||||
String(const unsigned short &inRHS) { fromInt(inRHS); }
|
||||
String(const signed char &inRHS) { fromInt(inRHS); }
|
||||
String(const unsigned char &inRHS) { fromInt(inRHS); }
|
||||
String(const cpp::CppInt32__ &inRHS);
|
||||
String(const double &inRHS);
|
||||
String(const float &inRHS);
|
||||
String(const cpp::Int64 &inRHS);
|
||||
String(const cpp::UInt64 &inRHS);
|
||||
explicit String(const bool &inRHS);
|
||||
inline String(const null &inRHS) : __s(0), length(0) { }
|
||||
String(hx::Null< ::String > inRHS) : __s(inRHS.value.__s), length(inRHS.value.length) { }
|
||||
inline String(const ::cpp::Variant &inRHS) { *this = inRHS.asString(); }
|
||||
template<typename T>
|
||||
inline String( const ::cpp::Pointer<T> &inRHS) { fromPointer(inRHS.ptr); }
|
||||
template<typename T>
|
||||
inline String( const hx::Native<T> &n ) { fromPointer(n.ptr); }
|
||||
|
||||
static String emptyString;
|
||||
static void __boot();
|
||||
|
||||
hx::Object *__ToObject() const;
|
||||
|
||||
template<typename T,typename S>
|
||||
explicit inline String(const cpp::Struct<T,S> &inRHS);
|
||||
template<typename OBJ>
|
||||
explicit inline String(const hx::ObjectPtr<OBJ> &inRHS);
|
||||
void fromInt(int inI);
|
||||
void fromPointer(const void *p);
|
||||
|
||||
|
||||
|
||||
/*
|
||||
This causes ambiguous problem with Object==Dynamic (String==Dynamic vs Object==Object)
|
||||
and syntactically, String(Dynamic) should be enough I think.
|
||||
Could perhaps make it explicit
|
||||
|
||||
template<typename T>
|
||||
inline String(const hx::ObjectPtr<T> &inRHS)
|
||||
{
|
||||
if (inRHS.mPtr)
|
||||
{
|
||||
::String s = static_cast<hx::Object *>(inRHS.mPtr)->toString();
|
||||
__s = s.__s;
|
||||
length = s.length;
|
||||
}
|
||||
else { __s = 0; length = 0; }
|
||||
}
|
||||
*/
|
||||
String(const Dynamic &inRHS);
|
||||
|
||||
inline ::String &operator=(const ::String &inRHS)
|
||||
{ length = inRHS.length; __s = inRHS.__s; return *this; }
|
||||
|
||||
::String Default(const ::String &inDef) { return __s ? *this : inDef; }
|
||||
|
||||
|
||||
::String toString() { return *this; }
|
||||
|
||||
::String __URLEncode() const;
|
||||
::String __URLDecode() const;
|
||||
|
||||
|
||||
::String toUpperCase() const;
|
||||
::String toLowerCase() const;
|
||||
::String charAt(int inPos) const;
|
||||
Dynamic charCodeAt(int inPos) const;
|
||||
int indexOf(const ::String &inValue, Dynamic inStart) const;
|
||||
int lastIndexOf(const ::String &inValue, Dynamic inStart) const;
|
||||
Array<String> split(const ::String &inDelimiter) const;
|
||||
::String substr(int inPos,Dynamic inLen) const;
|
||||
::String substring(int inStartIndex, Dynamic inEndIndex) const;
|
||||
|
||||
inline const char *&raw_ref() { return __s; }
|
||||
inline const char *raw_ptr() const { return __s; }
|
||||
const char *utf8_str(hx::IStringAlloc *inBuffer = 0,bool throwInvalid=true, int *byteLength = 0) const;
|
||||
const char *ascii_substr(hx::IStringAlloc *inBuffer,int start, int length) const;
|
||||
inline const char *c_str() const { return utf8_str(); }
|
||||
inline const char *out_str(hx::IStringAlloc *inBuffer = 0) const { return utf8_str(inBuffer,false); }
|
||||
const wchar_t *wchar_str(hx::IStringAlloc *inBuffer = 0) const;
|
||||
const char16_t *wc_str(hx::IStringAlloc *inBuffer = 0, int *outCharLength = 0) const;
|
||||
|
||||
const char *__CStr() const { return utf8_str(); };
|
||||
const wchar_t *__WCStr() const { return wchar_str(0); }
|
||||
inline operator const char *() { return utf8_str(); }
|
||||
|
||||
#ifdef HX_SMART_STRINGS
|
||||
inline const char16_t *raw_wptr() const { return __w; }
|
||||
#endif
|
||||
inline bool isUTF16Encoded() const {
|
||||
#ifdef HX_SMART_STRINGS
|
||||
return __w && ((unsigned int *)__w)[-1] & HX_GC_STRING_CHAR16_T;
|
||||
#else
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline bool isAsciiEncoded() const {
|
||||
#ifdef HX_SMART_STRINGS
|
||||
return !__w || !(((unsigned int *)__w)[-1] & HX_GC_STRING_CHAR16_T);
|
||||
#else
|
||||
return true;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline bool isAsciiEncodedQ() const {
|
||||
#ifdef HX_SMART_STRINGS
|
||||
return !(((unsigned int *)__w)[-1] & HX_GC_STRING_CHAR16_T);
|
||||
#else
|
||||
return true;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
|
||||
static ::String fromCharCode(int inCode);
|
||||
|
||||
inline bool operator==(const null &inRHS) const { return __s==0; }
|
||||
inline bool operator!=(const null &inRHS) const { return __s!=0; }
|
||||
|
||||
inline int getChar( int index ) {
|
||||
if (isUTF16Encoded())
|
||||
return __w[index];
|
||||
return __s[index];
|
||||
}
|
||||
inline unsigned int hash( ) const
|
||||
{
|
||||
if (!__s) return 0;
|
||||
if ( __s[HX_GC_STRING_HASH_OFFSET] & HX_GC_STRING_HASH_BIT)
|
||||
{
|
||||
#ifdef HXCPP_PARANOID
|
||||
unsigned int result = calcHash();
|
||||
|
||||
unsigned int have = (((unsigned int *)__s)[-1] & HX_GC_CONST_ALLOC_BIT) ?
|
||||
((unsigned int *)__s)[-2] : *((unsigned int *)(__s+length+1) );
|
||||
|
||||
if ( have != result )
|
||||
{
|
||||
printf("Bad string hash for %s\n", __s );
|
||||
printf(" Is %08x\n", result );
|
||||
printf(" Baked %08x\n", have );
|
||||
printf(" Mark %08x\n", ((unsigned int *)__s)[-1] );
|
||||
}
|
||||
#endif
|
||||
if (__s[HX_GC_CONST_ALLOC_MARK_OFFSET] & HX_GC_CONST_ALLOC_MARK_BIT)
|
||||
{
|
||||
#ifdef EMSCRIPTEN
|
||||
return ((emscripten_align1_int*)__s)[-2];
|
||||
#else
|
||||
return ((unsigned int *)__s)[-2];
|
||||
#endif
|
||||
}
|
||||
#ifdef EMSCRIPTEN
|
||||
return *((emscripten_align1_int *)(__s+length+1) );
|
||||
#else
|
||||
return *((unsigned int *)(__s+length+1) );
|
||||
#endif
|
||||
}
|
||||
|
||||
// Slow path..
|
||||
return calcHash();
|
||||
}
|
||||
|
||||
unsigned int calcHash() const;
|
||||
unsigned int calcSubHash(int start, int length) const;
|
||||
|
||||
#ifdef HX_SMART_STRINGS
|
||||
int compare(const ::String &inRHS) const;
|
||||
#else
|
||||
inline int compare(const ::String &inRHS) const
|
||||
{
|
||||
const char *r = inRHS.__s;
|
||||
if (__s == r) return inRHS.length-length;
|
||||
if (__s==0) return -1;
|
||||
if (r==0) return 1;
|
||||
|
||||
return strcmp(__s,r);
|
||||
//return memcmp(__s,r,length);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
::String &operator+=(const ::String &inRHS);
|
||||
::String operator+(const ::String &inRHS) const;
|
||||
::String operator+(const int &inRHS) const { return *this + ::String(inRHS); }
|
||||
::String operator+(const bool &inRHS) const { return *this + ::String(inRHS); }
|
||||
::String operator+(const double &inRHS) const { return *this + ::String(inRHS); }
|
||||
::String operator+(const float &inRHS) const { return *this + ::String(inRHS); }
|
||||
::String operator+(const null &inRHS) const{ return *this + HX_CSTRING("null"); }
|
||||
//::String operator+(const char *inRHS) const{ return *this + ::String(inRHS); }
|
||||
::String operator+(const cpp::CppInt32__ &inRHS) const{ return *this + ::String(inRHS); }
|
||||
template<typename T>
|
||||
inline ::String operator+(const hx::ObjectPtr<T> &inRHS) const
|
||||
{ return *this + (inRHS.mPtr ? const_cast<hx::ObjectPtr<T>&>(inRHS)->toString() : HX_CSTRING("null") ); }
|
||||
::String operator+(const cpp::Variant &inRHS) const{ return *this + inRHS.asString(); }
|
||||
|
||||
|
||||
|
||||
#ifdef HX_SMART_STRINGS
|
||||
bool eq(const ::String &inRHS) const;
|
||||
#else
|
||||
inline bool eq(const ::String &inRHS) const
|
||||
{
|
||||
// Strings are known not to be null...
|
||||
return length==inRHS.length && !memcmp(__s,inRHS.__s,length);
|
||||
}
|
||||
#endif
|
||||
|
||||
inline bool operator==(const ::String &inRHS) const
|
||||
{
|
||||
if (!inRHS.__s)
|
||||
return !__s;
|
||||
if (!__s)
|
||||
return false;
|
||||
return eq(inRHS);
|
||||
}
|
||||
inline bool operator!=(const ::String &inRHS) const
|
||||
{
|
||||
if (!inRHS.__s)
|
||||
return __s;
|
||||
if (!__s)
|
||||
return true;
|
||||
return !eq(inRHS);
|
||||
}
|
||||
|
||||
inline bool operator<(const ::String &inRHS) const { return compare(inRHS)<0; }
|
||||
inline bool operator<=(const ::String &inRHS) const { return compare(inRHS)<=0; }
|
||||
inline bool operator>(const ::String &inRHS) const { return compare(inRHS)>0; }
|
||||
inline bool operator>=(const ::String &inRHS) const { return compare(inRHS)>=0; }
|
||||
|
||||
inline bool operator<(const Dynamic &inRHS) const { return compare(inRHS)<0; }
|
||||
inline bool operator<=(const Dynamic &inRHS) const { return compare(inRHS)<=0; }
|
||||
inline bool operator>(const Dynamic &inRHS) const { return compare(inRHS)>0; }
|
||||
inline bool operator>=(const Dynamic &inRHS) const { return compare(inRHS)>=0; }
|
||||
|
||||
inline int cca(int inPos) const
|
||||
{
|
||||
if ((unsigned)inPos>=length) return 0;
|
||||
#ifdef HX_SMART_STRINGS
|
||||
if (isUTF16Encoded())
|
||||
return __w[inPos];
|
||||
#endif
|
||||
return ((unsigned char *)__s)[inPos];
|
||||
}
|
||||
|
||||
inline Dynamic iterator();
|
||||
inline Dynamic keyValueIterator();
|
||||
|
||||
static char16_t *allocChar16Ptr(int len);
|
||||
|
||||
|
||||
static Dynamic fromCharCode_dyn();
|
||||
|
||||
|
||||
Dynamic charAt_dyn();
|
||||
Dynamic charCodeAt_dyn();
|
||||
Dynamic indexOf_dyn();
|
||||
Dynamic lastIndexOf_dyn();
|
||||
Dynamic split_dyn();
|
||||
Dynamic substr_dyn();
|
||||
Dynamic substring_dyn();
|
||||
Dynamic toLowerCase_dyn();
|
||||
Dynamic toString_dyn();
|
||||
Dynamic toUpperCase_dyn();
|
||||
|
||||
// This is used by the string-wrapped-as-dynamic class
|
||||
hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
|
||||
|
||||
// The actual implementation.
|
||||
// Note that "__s" is const - if you want to change it, you should create a new string.
|
||||
// this allows for multiple strings to point to the same data.
|
||||
int length;
|
||||
|
||||
#ifdef HX_SMART_STRINGS
|
||||
// TODO private:
|
||||
// Use c_str, wc_str, raw_str instead
|
||||
#endif
|
||||
|
||||
union {
|
||||
const char *__s;
|
||||
const char16_t *__w;
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
class StringOffset
|
||||
{
|
||||
public:
|
||||
enum { Ptr = offsetof(String,__s) };
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
inline HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_string_create(const char *str, int len)
|
||||
{
|
||||
return String::create(str,len);
|
||||
}
|
||||
|
||||
inline int HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_string_compare(String inString0, String inString1)
|
||||
{
|
||||
return inString0.compare(inString1);
|
||||
}
|
||||
|
||||
String HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_utf8_to_utf16(const unsigned char *ptr, int inUtf8Len, bool addHash);
|
||||
|
||||
int HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_utf8_char_code_at(String inString, int inIndex);
|
||||
int HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_utf8_length(String inString);
|
||||
bool HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_utf8_is_valid(String inString);
|
||||
String HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_utf8_sub(String inString0, int inStart, int inLen);
|
||||
int HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_utf8_decode_advance(char *&ioPtr);
|
||||
|
||||
|
||||
#endif
|
||||
415
Kha/Backends/Kinc-hxcpp/khacpp/include/hxcpp.h
Executable file
415
Kha/Backends/Kinc-hxcpp/khacpp/include/hxcpp.h
Executable file
@ -0,0 +1,415 @@
|
||||
#ifndef HXCPP_H
|
||||
#define HXCPP_H
|
||||
|
||||
#include <kinc/global.h>
|
||||
|
||||
#ifdef __clang__
|
||||
#pragma clang diagnostic ignored "-Wunused-variable"
|
||||
#pragma clang diagnostic ignored "-Wunused-value"
|
||||
#pragma clang diagnostic ignored "-Wunreachable-code"
|
||||
#pragma clang diagnostic ignored "-Wshorten-64-to-32"
|
||||
#pragma clang diagnostic ignored "-Winvalid-offsetof"
|
||||
#pragma clang diagnostic ignored "-Wparentheses-equality"
|
||||
#pragma clang diagnostic ignored "-Wconditional-uninitialized"
|
||||
#pragma clang diagnostic ignored "-Wreorder"
|
||||
#pragma clang diagnostic ignored "-Wself-assign"
|
||||
#pragma clang diagnostic ignored "-Wint-to-void-pointer-cast"
|
||||
#pragma clang diagnostic ignored "-Woverloaded-virtual"
|
||||
#pragma clang diagnostic ignored "-Wsometimes-uninitialized"
|
||||
#else
|
||||
#pragma warning(disable : 4018 4101 4146 4244 4305 4127 4100 4267 4389 4201 4312 4244 4996 4457 4458 4189 4701 4702)
|
||||
#endif
|
||||
|
||||
// Standard headers ....
|
||||
#include <limits>
|
||||
|
||||
// Windows hack
|
||||
#define NOMINMAX
|
||||
|
||||
#ifndef HXCPP_API_LEVEL
|
||||
#define HXCPP_API_LEVEL 0
|
||||
#endif
|
||||
|
||||
#include "hx/HeaderVersion.h"
|
||||
|
||||
#if defined(_MSC_VER) || defined(__BORLANDC__)
|
||||
#if _MSC_VER >= 1423
|
||||
#include <typeinfo>
|
||||
#else
|
||||
#include <typeinfo.h>
|
||||
#endif
|
||||
#if defined(__BORLANDC__)
|
||||
namespace hx { typedef std::type_info type_info; }
|
||||
#else
|
||||
namespace hx { typedef ::type_info type_info; }
|
||||
#endif
|
||||
#else
|
||||
#include <typeinfo>
|
||||
#include <stdint.h>
|
||||
#include <cstddef>
|
||||
namespace hx { typedef std::type_info type_info; }
|
||||
#ifndef EMSCRIPTEN
|
||||
using hx::type_info;
|
||||
#ifdef __MINGW32__
|
||||
#include <stdint.h>
|
||||
#else
|
||||
typedef int64_t __int64;
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(EMSCRIPTEN) || defined(IPHONE) || defined(APPLETV)
|
||||
#include <unistd.h>
|
||||
#include <cstdlib>
|
||||
#endif
|
||||
|
||||
#if defined(EMSCRIPTEN)
|
||||
#include <emscripten.h>
|
||||
#endif
|
||||
|
||||
#ifdef __OBJC__
|
||||
#ifdef HXCPP_OBJC
|
||||
#import <Foundation/Foundation.h>
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include <wchar.h>
|
||||
|
||||
#ifdef HX_LINUX
|
||||
#include <unistd.h>
|
||||
#include <cstdio>
|
||||
#include <stddef.h>
|
||||
#endif
|
||||
|
||||
#if defined(EMSCRIPTEN) || defined(_ARM_) || defined(__arm__) || defined(GCW0)
|
||||
#define HXCPP_ALIGN_FLOAT
|
||||
#endif
|
||||
|
||||
// Must allign allocs to 8 bytes to match floating point requirement?
|
||||
// Ints must br read on 4-byte boundary
|
||||
#if defined(EMSCRIPTEN) || defined(GCW0)
|
||||
#define HXCPP_ALIGN_ALLOC
|
||||
#endif
|
||||
|
||||
#if defined(__LP64__) || defined(_LP64) || defined(_WIN64)
|
||||
#if !defined(HXCPP_M64)
|
||||
#define HXCPP_M64
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
// Some compilers are over-enthusiastic about what they #define ...
|
||||
//#ifdef NULL
|
||||
//#undef NULL
|
||||
//#endif
|
||||
|
||||
#ifdef assert
|
||||
#undef assert
|
||||
#endif
|
||||
|
||||
#define HXCPP_CLASS_ATTRIBUTES
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#if defined(HXCPP_DLL_IMPORT)
|
||||
#define HXCPP_EXTERN_CLASS_ATTRIBUTES __declspec(dllimport)
|
||||
#elif defined (HXCPP_DLL_EXPORT)
|
||||
#define HXCPP_EXTERN_CLASS_ATTRIBUTES __declspec(dllexport)
|
||||
#else
|
||||
#define HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
#endif
|
||||
#else
|
||||
#if defined(HXCPP_DLL_EXPORT)
|
||||
#define HXCPP_EXTERN_CLASS_ATTRIBUTES __attribute__((visibility("default")))
|
||||
#else
|
||||
#define HXCPP_EXTERN_CLASS_ATTRIBUTES
|
||||
#endif
|
||||
#endif
|
||||
|
||||
typedef char HX_CHAR;
|
||||
|
||||
|
||||
|
||||
#if (defined(HXCPP_DEBUG) || defined(HXCPP_DEBUGGER)) && !defined HXCPP_CHECK_POINTER
|
||||
#define HXCPP_CHECK_POINTER
|
||||
#endif
|
||||
|
||||
#ifdef HX_WINRT
|
||||
|
||||
#define WINRT_LOG(fmt, ...) {char buf[1024];sprintf_s(buf,1024,"****LOG: %s(%d): %s \n [" fmt "]\n",__FILE__,__LINE__,__FUNCTION__, __VA_ARGS__);OutputDebugStringA(buf);}
|
||||
#define WINRT_PRINTF(fmt, ...) {char buf[2048];sprintf_s(buf,2048,fmt,__VA_ARGS__);OutputDebugStringA(buf);}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef BIG_ENDIAN
|
||||
#undef BIG_ENDIAN
|
||||
|
||||
#ifndef HXCPP_BIG_ENDIAN
|
||||
#define HXCPP_BIG_ENDIAN
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef __BIG_ENDIAN__
|
||||
#ifndef HXCPP_BIG_ENDIAN
|
||||
#define HXCPP_BIG_ENDIAN
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef LITTLE_ENDIAN
|
||||
#undef LITTLE_ENDIAN
|
||||
|
||||
#ifdef HXCPP_BIG_ENDIAN
|
||||
#undef HXCPP_BIG_ENDIAN
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef __LITTLE_ENDIAN__
|
||||
#ifdef HXCPP_BIG_ENDIAN
|
||||
#undef HXCPP_BIG_ENDIAN
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
// HX_HCSTRING is for constant strings with built-in hashes
|
||||
// HX_GC_CONST_ALLOC_BIT | HX_GC_STRING_HASH
|
||||
// HX_CSTRING is for constant strings without built-in hashes
|
||||
// HX_GC_CONST_ALLOC_BIT
|
||||
// HX_GC_CONST_ALLOC_BIT = 0x80000000
|
||||
// HX_GC_STRING_HASH = 0x00100000
|
||||
// HX_GC_STRING_CHAR16_T = 0x00200000
|
||||
|
||||
// For making generated code easier to read
|
||||
#define HX_HASH_JOIN(A, B) A##B
|
||||
#define HX_JOIN_PARTS(A, B) HX_HASH_JOIN(A, B)
|
||||
#define HX_HASH_OF(A) #A
|
||||
#define HX_HASH_OF_W(A) HX_HASH_JOIN(u,#A)
|
||||
#define HX_STR_QUOTE(A) HX_HASH_OF(A)
|
||||
#define HX_STR_QUOTE_W(A) HX_HASH_OF_W(A)
|
||||
#define HX_HEX_QUOTE(hex) HX_STR_QUOTE(HX_JOIN_PARTS(\x,hex))
|
||||
#define HX_HEX_QUOTE_W(hex) HX_STR_QUOTE_W(HX_JOIN_PARTS(\x,hex))
|
||||
|
||||
#ifdef HXCPP_BIG_ENDIAN
|
||||
|
||||
#define HX_HCSTRING(s,h0,h1,h2,h3) ::String( const_cast<char *>((h3 h2 h1 h0 "\x80\x10\x00\x00" s)) + 8 , sizeof(s)/sizeof(char)-1)
|
||||
#define HX_(s,h0,h1,h2,h3) ::String( const_cast<char *>(( HX_HEX_QUOTE(h3) HX_HEX_QUOTE(h2) HX_HEX_QUOTE(h1) HX_HEX_QUOTE(h0) "\x80\x10\x00\x00" s )) + 8 , sizeof(s)/sizeof(char)-1)
|
||||
#define HX_STRINGI(s,len) ::String( const_cast<char *>(("\x80\x00\x00\x00" s)) + 4 ,len)
|
||||
#define HX_W(s,h0,h1) ::String( const_cast<char16_t *>(( HX_HEX_QUOTE_W(h1) HX_HEX_QUOTE_W(h0) u"\x8030\x0000" s )) + 4, sizeof(s)/2-1)
|
||||
|
||||
#else
|
||||
|
||||
#define HX_HCSTRING(s,h0,h1,h2,h3) ::String( const_cast<char *>((h0 h1 h2 h3 "\x00\x00\x10\x80" s )) + 8 , sizeof(s)/sizeof(char)-1)
|
||||
#define HX_(s,h0,h1,h2,h3) ::String( const_cast<char *>(( HX_HEX_QUOTE(h0) HX_HEX_QUOTE(h1) HX_HEX_QUOTE(h2) HX_HEX_QUOTE(h3) "\x00\x00\x10\x80" s )) + 8 , sizeof(s)/sizeof(char)-1)
|
||||
#define HX_STRINGI(s,len) ::String( const_cast<char *>(("\x00\x00\x0\x80" s)) + 4 ,len)
|
||||
|
||||
#define HX_W(s,h0,h1) ::String( const_cast<char16_t *>(( HX_HEX_QUOTE_W(h0) HX_HEX_QUOTE_W(h1) u"\x0000\x8030" s )) + 4, sizeof(s)/2-1)
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#define HX_STRI(s) HX_STRINGI(s,sizeof(s)/sizeof(char)-1)
|
||||
#define HX_CSTRING(x) HX_STRI(x)
|
||||
#define HX_CSTRING2(wide,len,utf8) HX_STRI(utf8)
|
||||
|
||||
#ifdef HX_SMART_STRINGS
|
||||
#define HX_FIELD_EQ(name,field) (name.isAsciiEncoded() && !::memcmp(name.raw_ptr(), field, sizeof(field)/sizeof(char)))
|
||||
// No null check is performedd...
|
||||
#define HX_QSTR_EQ(name,field) (name.length==field.length && field.isAsciiEncodedQ() && !::memcmp(name.raw_ptr(), field.raw_ptr() , field.length) )
|
||||
// field is known to be isAsciiEncodedQ
|
||||
#define HX_QSTR_EQ_AE(name,field) (name.length==field.length && !::memcmp(name.raw_ptr(), field.raw_ptr() , field.length) )
|
||||
#else
|
||||
#define HX_FIELD_EQ(name,field) !::memcmp(name.__s, field, sizeof(field)/sizeof(char))
|
||||
// No null check is performed....
|
||||
#define HX_QSTR_EQ(name,field) (name.length==field.length && !::memcmp(name.__s, field.__s, field.length))
|
||||
#define HX_QSTR_EQ_AE(name,field) (name.length==field.length && !::memcmp(name.__s, field.__s, field.length))
|
||||
#endif
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
|
||||
|
||||
#pragma warning(disable:4251)
|
||||
#pragma warning(disable:4800)
|
||||
#endif
|
||||
|
||||
#if defined(_MSC_VER) && _MSC_VER < 1201
|
||||
#error MSVC 7.1 does not support template specialization and is not supported by HXCPP
|
||||
#endif
|
||||
|
||||
|
||||
// HXCPP includes...
|
||||
|
||||
// Basic mapping from haxe -> c++
|
||||
#if (HXCPP_API_LEVEL<=330)
|
||||
typedef int Int;
|
||||
typedef bool Bool;
|
||||
#endif
|
||||
|
||||
#ifdef HXCPP_FLOAT32
|
||||
typedef float Float;
|
||||
#else
|
||||
typedef double Float;
|
||||
#endif
|
||||
|
||||
|
||||
// Extended mapping - cpp namespace
|
||||
namespace cpp
|
||||
{
|
||||
typedef signed char Int8;
|
||||
typedef unsigned char UInt8;
|
||||
typedef char Char;
|
||||
typedef signed short Int16;
|
||||
typedef unsigned short UInt16;
|
||||
typedef signed int Int32;
|
||||
typedef unsigned int UInt32;
|
||||
#ifdef _WIN32
|
||||
typedef __int64 Int64;
|
||||
typedef unsigned __int64 UInt64;
|
||||
// TODO - EMSCRIPTEN?
|
||||
#else
|
||||
typedef int64_t Int64;
|
||||
typedef uint64_t UInt64;
|
||||
#endif
|
||||
typedef float Float32;
|
||||
typedef double Float64;
|
||||
typedef volatile int AtomicInt;
|
||||
};
|
||||
// Extended mapping - old way
|
||||
namespace haxe { namespace io { typedef unsigned char Unsigned_char__; } }
|
||||
|
||||
// --- Forward decalarations --------------------------------------------
|
||||
|
||||
class null;
|
||||
namespace hx { class Object; }
|
||||
namespace hx { class FieldRef; }
|
||||
namespace hx { class IndexRef; }
|
||||
namespace hx { class NativeInterface; }
|
||||
namespace hx { struct StackContext; }
|
||||
namespace hx { template<typename T> class Native; }
|
||||
namespace hx { template<typename O> class ObjectPtr; }
|
||||
namespace cpp { template<typename S,typename H> class Struct; }
|
||||
namespace cpp { template<typename T> class Pointer; }
|
||||
namespace cpp { template<typename T> class Function; }
|
||||
template<typename ELEM_> class Array_obj;
|
||||
template<typename ELEM_> class Array;
|
||||
namespace hx {
|
||||
class Class_obj;
|
||||
typedef hx::ObjectPtr<hx::Class_obj> Class;
|
||||
}
|
||||
namespace cpp {
|
||||
struct Variant;
|
||||
class VirtualArray_obj;
|
||||
class VirtualArray;
|
||||
class CppInt32__;
|
||||
}
|
||||
|
||||
|
||||
#if (HXCPP_API_LEVEL < 320) && !defined(__OBJC__)
|
||||
typedef hx::Class Class;
|
||||
typedef hx::Class_obj Class_obj;
|
||||
#endif
|
||||
|
||||
class Dynamic;
|
||||
class String;
|
||||
|
||||
// Use an external routine to throw to avoid sjlj overhead on iphone.
|
||||
namespace hx { HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic Throw(Dynamic inDynamic); }
|
||||
namespace hx { HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic Rethrow(Dynamic inDynamic); }
|
||||
namespace hx { HXCPP_EXTERN_CLASS_ATTRIBUTES void CriticalError(const String &inError, bool inAllowFixup=false); }
|
||||
namespace hx { HXCPP_EXTERN_CLASS_ATTRIBUTES void NullReference(const char *type, bool allowFixup); }
|
||||
namespace hx { extern String sNone[]; }
|
||||
void __hxcpp_check_overflow(int inVal);
|
||||
|
||||
namespace hx
|
||||
{
|
||||
class MarkContext;
|
||||
|
||||
|
||||
class VisitContext
|
||||
{
|
||||
public:
|
||||
virtual void visitObject(hx::Object **ioPtr)=0;
|
||||
virtual void visitAlloc(void **ioPtr)=0;
|
||||
};
|
||||
|
||||
#if (HXCPP_API_LEVEL >= 330)
|
||||
typedef ::cpp::Variant Val;
|
||||
#else
|
||||
typedef ::Dynamic Val;
|
||||
#endif
|
||||
|
||||
#ifdef HXCPP_GC_GENERATIONAL
|
||||
#define HXCPP_GC_NURSERY
|
||||
#endif
|
||||
|
||||
|
||||
//#define HXCPP_COMBINE_STRINGS
|
||||
|
||||
#if (HXCPP_API_LEVEL >= 313)
|
||||
enum PropertyAccessMode
|
||||
{
|
||||
paccNever = 0,
|
||||
paccDynamic = 1,
|
||||
paccAlways = 2,
|
||||
};
|
||||
typedef PropertyAccessMode PropertyAccess;
|
||||
#define HX_PROP_NEVER hx::paccNever
|
||||
#define HX_PROP_DYNAMIC hx::paccDynamic
|
||||
#define HX_PROP_ALWAYS hx::paccAlways
|
||||
#else
|
||||
typedef bool PropertyAccess;
|
||||
#define HX_PROP_NEVER false
|
||||
#define HX_PROP_DYNAMIC true
|
||||
#define HX_PROP_ALWAYS true
|
||||
#endif
|
||||
|
||||
} // end namespace hx
|
||||
|
||||
#define HX_COMMA ,
|
||||
|
||||
|
||||
// The order of these includes has been chosen to minimize forward declarations.
|
||||
// You should not include the individual files, just this one.
|
||||
|
||||
// First time ...
|
||||
#include <hx/Macros.h>
|
||||
#include <cpp/Variant.h>
|
||||
#include <hx/ErrorCodes.h>
|
||||
#include <hx/GC.h>
|
||||
#include <hx/StackContext.h>
|
||||
#include "null.h"
|
||||
#include <hx/Object.h>
|
||||
#include "hxString.h"
|
||||
#include "Dynamic.h"
|
||||
#include <cpp/CppInt32__.h>
|
||||
// This needs to "see" other declarations ...
|
||||
#include <hx/GcTypeInference.h>
|
||||
#include <hx/FieldRef.h>
|
||||
#include "Array.h"
|
||||
#include <hx/Anon.h>
|
||||
#include <hx/Class.h>
|
||||
#include "Enum.h"
|
||||
#include <hx/Interface.h>
|
||||
#include <hx/Telemetry.h>
|
||||
#if defined(__OBJC__) && defined(HXCPP_OBJC)
|
||||
#include <hx/ObjcHelpers.h>
|
||||
#endif
|
||||
#include <hx/StdLibs.h>
|
||||
#include <cpp/Pointer.h>
|
||||
#include <hx/Native.h>
|
||||
#include <hx/Operators.h>
|
||||
#include <hx/Functions.h>
|
||||
// second time ...
|
||||
#include <cpp/Variant.h>
|
||||
#include <hx/Debug.h>
|
||||
#include <hx/Boot.h>
|
||||
#include <hx/Undefine.h>
|
||||
#if (HXCPP_API_LEVEL>=330)
|
||||
#include <hx/LessThanEq.h>
|
||||
#else
|
||||
#include <cpp/Int64.h>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
235
Kha/Backends/Kinc-hxcpp/khacpp/include/null.h
Normal file
235
Kha/Backends/Kinc-hxcpp/khacpp/include/null.h
Normal file
@ -0,0 +1,235 @@
|
||||
#ifndef HX_NULL_H
|
||||
#define HX_NULL_H
|
||||
|
||||
|
||||
|
||||
// --- null value ---------------------------------------------------------
|
||||
//
|
||||
// This is used by external operatator and return statments - Most will
|
||||
// use operator overloading to convert to the null pointer
|
||||
|
||||
|
||||
// Forward declare ...
|
||||
class String;
|
||||
class null;
|
||||
namespace hx { template<typename O> class ObjectPtr; }
|
||||
|
||||
namespace hx { null NullArithmetic(const char *inText); }
|
||||
|
||||
#define HX_NULL_COMPARE_OP(op,type,value) \
|
||||
bool operator op (const type &inRHS) const { return value; }
|
||||
|
||||
#define HX_NULL_COMPARE_OPS(type) \
|
||||
HX_NULL_COMPARE_OP(<,type,false) \
|
||||
HX_NULL_COMPARE_OP(<=,type,false) \
|
||||
HX_NULL_COMPARE_OP(>,type,false) \
|
||||
HX_NULL_COMPARE_OP(>=,type,false) \
|
||||
HX_NULL_COMPARE_OP(==,type,false) \
|
||||
HX_NULL_COMPARE_OP(!=,type,true)
|
||||
|
||||
#define HX_NULL_COMPARE_MOST_OPS(type) \
|
||||
HX_NULL_COMPARE_OP(<,type,false) \
|
||||
HX_NULL_COMPARE_OP(<=,type,false) \
|
||||
HX_NULL_COMPARE_OP(>,type,false) \
|
||||
HX_NULL_COMPARE_OP(>=,type,false)
|
||||
|
||||
#define HX_COMPARE_NULL_OP(op,type,value) \
|
||||
inline bool operator op (type inLHS, const null &) { return value; }
|
||||
|
||||
#define HX_COMPARE_NULL_OPS(type) \
|
||||
HX_COMPARE_NULL_OP(<,type,false) \
|
||||
HX_COMPARE_NULL_OP(<=,type,false) \
|
||||
HX_COMPARE_NULL_OP(>,type,false) \
|
||||
HX_COMPARE_NULL_OP(>=,type,false) \
|
||||
HX_COMPARE_NULL_OP(==,type,false) \
|
||||
HX_COMPARE_NULL_OP(!=,type,true)
|
||||
|
||||
#define HX_COMPARE_NULL_MOST_OPS(type) \
|
||||
HX_COMPARE_NULL_OP(<,type,false) \
|
||||
HX_COMPARE_NULL_OP(<=,type,false) \
|
||||
HX_COMPARE_NULL_OP(>,type,false) \
|
||||
HX_COMPARE_NULL_OP(>=,type,false)
|
||||
|
||||
|
||||
#define HX_NULL_ARITHMETIC_OP(op) \
|
||||
template<typename T> inline null operator op (T t) const \
|
||||
{ return hx::NullArithmetic(#op); } \
|
||||
inline null operator op (const null &) const \
|
||||
{ return hx::NullArithmetic(#op); }
|
||||
|
||||
#define HX_ARITHMETIC_NULL_OP(op) \
|
||||
template<typename T> inline null operator op (const T &, const null &) \
|
||||
{ return hx::NullArithmetic(#op); }
|
||||
|
||||
|
||||
class null
|
||||
{
|
||||
struct AnyArg
|
||||
{
|
||||
template<typename T>
|
||||
inline AnyArg(const T&) { }
|
||||
};
|
||||
public:
|
||||
inline null(){ }
|
||||
|
||||
template<typename T> explicit inline null(const hx::ObjectPtr<T> &){ }
|
||||
template<typename T> explicit inline null(const String &){ }
|
||||
explicit inline null(double){ }
|
||||
explicit inline null(float){ }
|
||||
explicit inline null(int){ }
|
||||
explicit inline null(bool){ }
|
||||
|
||||
template<typename T>
|
||||
T StaticCast() { return null(); }
|
||||
|
||||
operator bool () { return false; }
|
||||
operator int () { return 0; }
|
||||
operator unsigned int () { return 0; }
|
||||
operator double () { return 0; }
|
||||
operator float () { return 0; }
|
||||
operator char () { return 0; }
|
||||
operator unsigned char () { return 0; }
|
||||
operator signed char () { return 0; }
|
||||
operator short () { return 0; }
|
||||
operator unsigned short () { return 0; }
|
||||
operator cpp::UInt64 () { return 0; }
|
||||
operator cpp::Int64 () { return 0; }
|
||||
template<typename T>
|
||||
inline operator typename hx::Native<T *> () const { return 0; }
|
||||
|
||||
|
||||
// Any pointer!
|
||||
//operator char * () { return 0; }
|
||||
//operator wchar_t * () { return 0; }
|
||||
template<typename T> operator T *() { return 0; }
|
||||
|
||||
bool operator == (null inRHS) const { return true; }
|
||||
bool operator != (null inRHS) const { return false; }
|
||||
bool operator == (null inRHS) { return true; }
|
||||
bool operator != (null inRHS) { return false; }
|
||||
|
||||
template<typename T> inline bool operator == (const hx::ObjectPtr<T> &) const;
|
||||
template<typename T> inline bool operator != (const hx::ObjectPtr<T> &) const;
|
||||
template<typename T> inline bool operator == (const Array<T> &) const;
|
||||
template<typename T> inline bool operator != (const Array<T> &) const;
|
||||
inline bool operator == (const hx::FieldRef &) const;
|
||||
inline bool operator != (const hx::FieldRef &) const;
|
||||
inline bool operator == (const hx::IndexRef &) const;
|
||||
inline bool operator != (const hx::IndexRef &) const;
|
||||
inline bool operator == (const Dynamic &) const;
|
||||
inline bool operator != (const Dynamic &) const;
|
||||
inline bool operator == (const String &) const;
|
||||
inline bool operator != (const String &) const;
|
||||
inline bool operator == (const cpp::Variant &v) const { return v.isNull(); }
|
||||
inline bool operator != (const cpp::Variant &v) const{ return !v.isNull(); }
|
||||
|
||||
inline null operator - () const { return hx::NullArithmetic("-"); }
|
||||
inline null operator ! () const { return hx::NullArithmetic("!"); }
|
||||
|
||||
template<class T> T operator()(const AnyArg &a0=0, const AnyArg &a1=0, const AnyArg &a2=0,
|
||||
const AnyArg &a4=0, const AnyArg &a5=0, const AnyArg &a6=0,
|
||||
const AnyArg &a7=0, const AnyArg &a8=0, const AnyArg &a9=0 )
|
||||
{
|
||||
hx::NullReference("Function Call", false);
|
||||
T nullDynamic;
|
||||
return nullDynamic;
|
||||
}
|
||||
|
||||
HX_NULL_COMPARE_OPS(bool)
|
||||
HX_NULL_COMPARE_OPS(double)
|
||||
HX_NULL_COMPARE_OPS(float)
|
||||
HX_NULL_COMPARE_OPS(int)
|
||||
HX_NULL_COMPARE_OPS(unsigned int)
|
||||
HX_NULL_COMPARE_OPS(short)
|
||||
HX_NULL_COMPARE_OPS(unsigned short)
|
||||
HX_NULL_COMPARE_OPS(signed char)
|
||||
HX_NULL_COMPARE_OPS(unsigned char)
|
||||
HX_NULL_COMPARE_OPS(cpp::Int64)
|
||||
HX_NULL_COMPARE_OPS(cpp::UInt64)
|
||||
HX_NULL_COMPARE_MOST_OPS(String)
|
||||
HX_NULL_COMPARE_MOST_OPS(Dynamic)
|
||||
HX_NULL_COMPARE_MOST_OPS(hx::FieldRef)
|
||||
HX_NULL_COMPARE_MOST_OPS(hx::IndexRef)
|
||||
|
||||
HX_NULL_COMPARE_OP(<,null,false)
|
||||
HX_NULL_COMPARE_OP(<=,null,true)
|
||||
HX_NULL_COMPARE_OP(>,null,false)
|
||||
HX_NULL_COMPARE_OP(>=,null,true)
|
||||
|
||||
|
||||
HX_NULL_ARITHMETIC_OP(+);
|
||||
HX_NULL_ARITHMETIC_OP(*);
|
||||
HX_NULL_ARITHMETIC_OP(-);
|
||||
HX_NULL_ARITHMETIC_OP(/);
|
||||
HX_NULL_ARITHMETIC_OP(%);
|
||||
HX_NULL_ARITHMETIC_OP(&);
|
||||
HX_NULL_ARITHMETIC_OP(|);
|
||||
HX_NULL_ARITHMETIC_OP(^);
|
||||
HX_NULL_ARITHMETIC_OP(>>);
|
||||
HX_NULL_ARITHMETIC_OP(<<);
|
||||
};
|
||||
|
||||
namespace hx
|
||||
{
|
||||
|
||||
template<typename T>
|
||||
struct Null
|
||||
{
|
||||
inline Null() : isNull(true) { }
|
||||
inline Null(const Null<T> &inOther) : isNull(inOther.isNull), value(inOther.value) { }
|
||||
inline Null(const T& inVal) : isNull(false), value(inVal) { }
|
||||
inline Null(const null &) : isNull(true) { }
|
||||
inline Null(const Dynamic &inVal)
|
||||
{
|
||||
isNull = null() == inVal;
|
||||
if (!isNull)
|
||||
value = inVal;
|
||||
}
|
||||
inline Null(const cpp::Variant &inVal)
|
||||
{
|
||||
isNull = inVal.isNull();
|
||||
if (!isNull)
|
||||
value = inVal;
|
||||
}
|
||||
|
||||
inline operator Dynamic();
|
||||
inline T Default(T inDefault) { return isNull ? inDefault : value; }
|
||||
|
||||
bool isNull;
|
||||
T value;
|
||||
};
|
||||
|
||||
} // end namesapce hx
|
||||
|
||||
typedef null Void;
|
||||
|
||||
HX_COMPARE_NULL_OPS(bool)
|
||||
HX_COMPARE_NULL_OPS(double)
|
||||
HX_COMPARE_NULL_OPS(float)
|
||||
HX_COMPARE_NULL_OPS(int)
|
||||
HX_COMPARE_NULL_OPS(unsigned int)
|
||||
HX_COMPARE_NULL_OPS(short)
|
||||
HX_COMPARE_NULL_OPS(unsigned short)
|
||||
HX_COMPARE_NULL_OPS(signed char)
|
||||
HX_COMPARE_NULL_OPS(unsigned char)
|
||||
HX_COMPARE_NULL_OPS(cpp::UInt64)
|
||||
HX_COMPARE_NULL_OPS(cpp::Int64)
|
||||
|
||||
HX_ARITHMETIC_NULL_OP(+)
|
||||
HX_ARITHMETIC_NULL_OP(*)
|
||||
HX_ARITHMETIC_NULL_OP(-)
|
||||
HX_ARITHMETIC_NULL_OP(/)
|
||||
HX_ARITHMETIC_NULL_OP(%)
|
||||
HX_ARITHMETIC_NULL_OP(&)
|
||||
HX_ARITHMETIC_NULL_OP(|)
|
||||
HX_ARITHMETIC_NULL_OP(^)
|
||||
HX_ARITHMETIC_NULL_OP(>>)
|
||||
HX_ARITHMETIC_NULL_OP(<<)
|
||||
|
||||
// Other ops in Operator.h
|
||||
|
||||
inline void *_hx_nullptr() { return 0; }
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user