Update Files

Kha/Backends/Kinc-hxcpp/khacpp/include/Enum.h

@@ -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