Update

Kha/Backends/Kore-hxcpp/khacpp/src/hx/gc/GcCommon.cpp

@@ -0,0 +1,182 @@
+#include <hxcpp.h>
+
+#include <map>
+#include <vector>
+#include <set>
+#include <stdlib.h>
+
+#if defined(HXCPP_CAPTURE_x64) && !defined(__GNUC__)
+#include <windows.h>
+#endif
+
+
+#ifdef _WIN32
+
+#define GC_WIN32_THREADS
+#include <time.h>
+
+#endif
+
+#ifdef HXCPP_TELEMETRY
+extern void __hxt_new_string(void* result, int size);
+#endif
+
+
+
+
+namespace hx
+{
+#if defined(HX_MACOS) || defined(HX_WINDOWS) || defined(HX_LINUX) || defined(KINC_CONSOLE)
+int sgMinimumWorkingMemory       = 20*1024*1024;
+int sgMinimumFreeSpace           = 10*1024*1024;
+#else
+int sgMinimumWorkingMemory       = 8*1024*1024;
+int sgMinimumFreeSpace           = 4*1024*1024;
+#endif
+// Once you use more than the minimum, this kicks in...
+int sgTargetFreeSpacePercentage  = 100;
+
+
+
+
+
+
+// Called internally before and GC operations
+void CommonInitAlloc()
+{
+   #if !defined(HX_WINRT) && !defined(__SNC__) && !defined(__ORBIS__) && !defined(KINC_CONSOLE)
+   const char *minimumWorking = getenv("HXCPP_MINIMUM_WORKING_MEMORY");
+   if (minimumWorking)
+   {
+      int mem =  atoi(minimumWorking);
+      if (mem>0)
+         sgMinimumWorkingMemory = mem;
+   }
+
+   const char *minimumFreeSpace = getenv("HXCPP_MINIMUM_FREE_SPACE");
+   if (minimumFreeSpace)
+   {
+      int mem =  atoi(minimumFreeSpace);
+      if (mem>0)
+         sgMinimumFreeSpace = mem;
+   }
+
+
+   const char *targetFree = getenv("HXCPP_TARGET_FREE_SPACE");
+   if (targetFree)
+   {
+      int percent =  atoi(targetFree);
+      if (percent>0)
+         sgTargetFreeSpacePercentage = percent;
+   }
+   #endif
+}
+
+} // end namespace hx
+
+
+
+void *String::operator new( size_t inSize )
+{
+   return hx::InternalNew(inSize,false);
+}
+
+
+void __hxcpp_collect(bool inMajor)
+{
+   hx::InternalCollect(inMajor,inMajor);
+}
+
+
+void __hxcpp_gc_compact()
+{
+   int mem = hx::InternalCollect(true,true);
+   while(true)
+   {
+      int compact = hx::InternalCollect(true,true);
+      if (compact>=mem-16384)
+         break;
+      mem = compact;
+   }
+}
+
+namespace hx
+{
+
+void GCAddFinalizer(hx::Object *v, finalizer f)
+{
+   if (v)
+   {
+      throw Dynamic(HX_CSTRING("Add finalizer error"));
+   }
+}
+
+HX_CHAR *NewString(int inLen)
+{
+   char *result =  (char *)hx::InternalNew( (inLen+1)*sizeof(char), false );
+   result[inLen] = '\0';
+#ifdef HXCPP_TELEMETRY
+   __hxt_new_string(result, inLen+1);
+#endif
+   return result;
+
+}
+
+void *NewGCBytes(void *inData,int inSize)
+{
+   void *result =  hx::InternalNew(inSize,false);
+   if (inData)
+   {
+      memcpy(result,inData,inSize);
+   }
+   return result;
+}
+
+
+void *NewGCPrivate(void *inData,int inSize)
+{
+   void *result =  InternalNew(inSize,false);
+   if (inData)
+   {
+      memcpy(result,inData,inSize);
+   }
+   return result;
+}
+
+
+
+} // end namespace hx
+
+
+
+
+void __hxcpp_enable(bool inEnable)
+{
+   hx::InternalEnableGC(inEnable);
+}
+
+void  __hxcpp_set_minimum_working_memory(int inBytes)
+{
+   hx::sgMinimumWorkingMemory = inBytes;
+}
+
+void  __hxcpp_set_minimum_free_space(int inBytes)
+{
+   hx::sgMinimumFreeSpace = inBytes;
+}
+
+void  __hxcpp_set_target_free_space_percentage(int inPercentage)
+{
+   hx::sgTargetFreeSpacePercentage = inPercentage;
+}
+
+bool __hxcpp_is_const_string(const ::String &inString)
+{
+   #ifdef HXCPP_ALIGN_ALLOC
+   // Unaligned must be native const
+   if ( ((size_t)inString.__s) & 0x3 )
+      return true;
+   #endif
+   return ((unsigned int *)inString.raw_ptr())[-1] & HX_GC_CONST_ALLOC_BIT;
+}
+