Update Files

Kha/Backends/Kinc-hxcpp/khacpp/hxcpp/Builder.hx

@@ -0,0 +1,343 @@
+package hxcpp;
+
+import haxe.io.Path;
+import sys.FileSystem;
+
+class Builder
+{
+   public var debug:Bool;
+   public var verbose:Bool;
+
+   public function new(inArgs:Array<String>)
+   {
+      debug = false;
+      verbose = false;
+      var targets = new Map<String, Array<String>>();
+      var buildArgs = new Array<String>();
+
+      try
+      {
+         var clean = false;
+         var defaultTarget = true;
+         for(arg in inArgs)
+         {
+            if (arg=="-debug")
+            {
+               debug = true;
+               continue;
+            }
+            else if (arg=="-v" || arg=="-verbose")
+            {
+               verbose = true;
+               Sys.putEnv("HXCPP_VERBOSE", "1");
+               continue;
+            }
+            if (arg=="clean")
+            {
+               clean = true;
+               continue;
+            }
+
+
+            var parts = arg.split("-");
+            var linkStatic = allowStatic();
+            var linkNdll = allowNdll();
+            var explicitNdll = false;
+            if (parts[0]=="static")
+            {
+               linkNdll = false;
+               parts.shift();
+            }
+            else if (parts[0]=="ndll")
+            {
+               linkStatic = false;
+               explicitNdll = true;
+               parts.shift();
+            }
+
+            var target = parts.shift();
+            if (target=="default")
+               target = getDefault();
+
+            switch(target)
+            {
+               case "ios", "android", "blackberry", "tizen", "emscripten", "webos", "windows", "msvc", "linux", "mac", "mingw", "tvos":
+                  defaultTarget = false;
+                  if (linkStatic)
+                  {
+                     var stat = "static-" + target;
+                     targets.set(stat, parts);
+
+                     if (target=="ios" && wantLegacyIosBuild())
+                     {
+                        var stat = "static-" + "ioslegacy";
+                        targets.set(stat, parts);
+                     }
+                  }
+                  if (linkNdll && target!="ios" && target!="emscripten" && target!="tvos" /*&& (target!="mingw" || explicitNdll)*/ )
+                     targets.set(target, parts);
+
+               default:
+                  if (arg.substr(0,2)=="-D")
+                     buildArgs.push(arg);
+                  else
+                     throw "Unknown arg '" + arg + "'";
+            }
+         }
+
+         if (clean)
+         {
+            if (!cleanAll(buildArgs))
+               return;
+
+            if (defaultTarget) // Just clean
+               return;
+         }
+
+         if (defaultTarget)
+         {
+            var target = getDefault();
+            if (target!="mingw")
+               targets.set(target,[]);
+            targets.set("static-" +target,[]);
+            onEmptyTarget();
+            Sys.println("\nUsing default = " + target);
+         }
+
+         for(target in targets.keys())
+         {
+            var archs = targets.get(target);
+            var validArchs = new Map<String, Array<String>>();
+            var isStatic = false;
+            if (target.substr(0,7)=="static-")
+            {
+               isStatic = true;
+               target = target.substr(7);
+            }
+            var staticFlags = isStatic ? ["-Dstatic_link"] : [];
+            if (target=="ios" || target=="tvos")
+               staticFlags = ["-DHXCPP_CPP11"];
+
+            switch(target)
+            {
+               case "linux":
+                  if (wantLinux32())
+                     validArchs.set("m32", ["-D"+target, "-DHXCPP_M32"].concat(staticFlags) );
+                  validArchs.set("m64", ["-D"+target, "-DHXCPP_M64"].concat(staticFlags) );
+
+               case "mac":
+                  if (wantMac32())
+                     validArchs.set("m32", ["-D"+target, "-DHXCPP_M32"].concat(staticFlags) );
+                  validArchs.set("m64", ["-D"+target, "-DHXCPP_M64"].concat(staticFlags) );
+
+               case "windows":
+                  validArchs.set("m32", ["-D"+target, "-DHXCPP_M32"].concat(staticFlags) );
+                  if (wantWindows64())
+                     validArchs.set("m64", ["-D"+target, "-DHXCPP_M64"].concat(staticFlags) );
+                  if (wantWindowsArm64())
+                     validArchs.set("arm64", ["-D"+target, "-DHXCPP_ARM64"].concat(staticFlags) );
+
+               case "msvc":
+                  if (isStatic)
+                  {
+                     validArchs.set("2013m32", ["-D"+target, "-DHXCPP_M32", "HXCPP_MSVC_VER=120"].concat(staticFlags) );
+                     validArchs.set("2015m32", ["-D"+target, "-DHXCPP_M32", "HXCPP_MSVC_VER=140"].concat(staticFlags) );
+                     if (wantWindows64())
+                     {
+                        validArchs.set("2013m64", ["-D"+target, "-DHXCPP_M64", "HXCPP_MSVC_VER=120"].concat(staticFlags) );
+                        validArchs.set("2015m64", ["-D"+target, "-DHXCPP_M64", "HXCPP_MSVC_VER=140"].concat(staticFlags) );
+                     }
+                  }
+                  else
+                  {
+                     validArchs.set("m32", ["-D"+target, "-DHXCPP_M32"] );
+                     if (wantWindows64())
+                        validArchs.set("m64", ["-D"+target, "-DHXCPP_M64"] );
+                  }
+
+               case "mingw":
+                  validArchs.set("m32", ["-Dwindows", "-DHXCPP_MINGW", "-DHXCPP_M32"].concat(staticFlags) );
+
+               case "ios", "ioslegacy":
+                  validArchs.set("armv6", ["-Diphoneos"].concat(staticFlags) );
+                  validArchs.set("armv7", ["-Diphoneos", "-DHXCPP_ARMV7"].concat(staticFlags) );
+                  validArchs.set("armv7s", ["-Diphoneos", "-DHXCPP_ARMV7S"].concat(staticFlags) );
+                  validArchs.set("arm64", ["-Diphoneos", "-DHXCPP_ARM64", "-DHXCPP_M64"].concat(staticFlags) );
+                  //validArchs.push("armv64");
+                  validArchs.set("x86", ["-Diphonesim"].concat(staticFlags) );
+                  validArchs.set("x86_64", ["-Diphonesim", "-DHXCPP_M64"].concat(staticFlags) );
+
+               case "android":
+
+                  if( archs.length == 0 )
+                     throw("You must specify the archs you want for android");
+               
+                  validArchs.set("armv5", ["-Dandroid"].concat(staticFlags) );
+                  validArchs.set("armv7", ["-Dandroid", "-DHXCPP_ARMV7"].concat(staticFlags) );
+                  validArchs.set("arm64", ["-Dandroid", "-DHXCPP_ARM64"].concat(staticFlags) );
+                  validArchs.set("x86", ["-Dandroid", "-DHXCPP_X86"].concat(staticFlags) );
+                  validArchs.set("x86_64", ["-Dandroid", "-DHXCPP_X86_64"].concat(staticFlags) );
+               
+               case "blackberry":
+                  validArchs.set("armv7", ["-Dblackberry"].concat(staticFlags) );
+                  validArchs.set("x86", ["-Dblackberry", "-Dsimulator"].concat(staticFlags) );
+               
+               case "tizen":
+                  validArchs.set("armv7", ["-Dtizen"].concat(staticFlags) );
+                  validArchs.set("x86", ["-Dtizen", "-Dsimulator"].concat(staticFlags) );
+               
+               case "emscripten":
+                  validArchs.set("x86", ["-Demscripten"].concat(staticFlags) );
+               
+               case "webos":
+                  validArchs.set("armv7", ["-Dwebos"].concat(staticFlags) );
+               
+               case "tvos":
+                  validArchs.set("arm64", ["-Dappletvos", "-DHXCPP_ARM64", "-DHXCPP_M64", "-DENABLE_BITCODE"].concat(staticFlags) );
+                  // NOTE: removed as there's no 32bit support for the AppleTV simulator
+                  //validArchs.set("x86", ["-Dappletvsim", "-DENABLE_BITCODE"].concat(staticFlags) );
+                  validArchs.set("x86_64", ["-Dappletvsim", "-DHXCPP_M64", "-DENABLE_BITCODE"].concat(staticFlags) );
+
+            }
+
+
+            var valid = new Array<String>();
+            for(key in validArchs.keys())
+               valid.push(key);
+            var buildArchs = archs.length==0 ? valid : archs;
+            for(arch in buildArchs)
+            {
+               if (validArchs.exists(arch))
+               {
+                  var flags = validArchs.get(arch);
+                  if (debug)
+                     flags.push("-Ddebug");
+
+                  flags = flags.concat(buildArgs);
+
+                  runBuild(target, isStatic, arch, flags);
+               }
+            }
+         }
+      }
+      catch( e:Dynamic )
+      {
+         if (e!="")
+            Sys.println(e);
+         showUsage(false);
+      }
+   }
+
+   public function allowNdll() { return true; }
+   public function allowStatic() { return true; }
+   public function wantLegacyIosBuild() { return false; }
+   public function wantWindows64() { return false; }
+   public function wantMac32() { return false; }
+   public function wantLinux32() { return false; }
+   public function wantWindowsArm64() { return false; }
+
+   public function runBuild(target:String, isStatic:Bool, arch:String, buildFlags:Array<String>)
+   {
+      var args = ["run", "hxcpp", getBuildFile() ].concat(buildFlags);
+
+      Sys.println('\nBuild $target, link=' + (isStatic?"lib":"ndll")+' arch=$arch');
+      Sys.println("haxelib " + args.join(" ")); 
+      if (Sys.command("haxelib",args)!=0)
+      {
+         Sys.println("#### Error building " + arch);
+         Sys.exit(-1);
+      }
+   }
+
+   public function getBuildFile()
+   {
+      return "Build.xml";
+   }
+
+   public function getCleanDir()
+   {
+      return "obj";
+   }
+
+   public function cleanAll(inBuildFlags:Array<String>) : Bool
+   {
+      var args = ["run", "hxcpp", getBuildFile(), "clean", "-DHXCPP_CLEAN_ONLY"].concat(inBuildFlags);
+
+      Sys.println("haxelib " + args.join(" ")); 
+      if (Sys.command("haxelib",args)!=0)
+      {
+         Sys.println("#### Error cleaning");
+         Sys.exit(-1);
+      }
+      return true;
+   }
+
+
+
+   public function onEmptyTarget() : Void
+   {
+      showUsage(true);
+   }
+
+   static public function deleteRecurse(inDir:String) : Void
+   {
+      if (FileSystem.exists(inDir))
+      {
+         var contents = FileSystem.readDirectory(inDir);
+         for(item in contents)
+         {
+            if (item!="." && item!="..")
+            {
+               var name = inDir + "/" + item;
+               if (FileSystem.isDirectory(name))
+                  deleteRecurse(name);
+               else
+                  FileSystem.deleteFile(name);
+            }
+         }
+         FileSystem.deleteDirectory(inDir);
+      }
+   }
+
+
+   public function showUsage(inShowSpecifyMessage:Bool) : Void
+   {
+      var link = allowStatic() && allowNdll() ? "[link-]" : "";
+      Sys.println("Usage : neko build.n [clean] " + link +
+                  "target[-arch][-arch] ...] [-debug] [-verbose] [-D...]");
+      Sys.println("  target  : ios, android, windows, linux, mac, mingw, tvos");
+      Sys.println("            default (=current system)");
+      if (link!="")
+      {
+         Sys.println("  link    : ndll- or static-");
+         Sys.println("            (none specified = both link types, mingw static only");
+      }
+      Sys.println("  arch    : -armv5 -armv6 -armv7 -arm64 -x86 -x86_64 -m32 -m64");
+      Sys.println("            (none specified = all valid architectures");
+      Sys.println("  -D...   : defines passed to hxcpp build system");
+      if (link!="")
+         Sys.println(" eg: neko build.n clean ndll-mac-m32-m64 = rebuild both mac ndlls");
+      if (inShowSpecifyMessage)
+         Sys.println(" Specify target or 'default' to remove this message");
+   }
+
+   public function getDefault() : String
+   {
+      var sys = Sys.systemName();
+      if (new EReg("window", "i").match(sys))
+         return "windows";
+      else if (new EReg("linux", "i").match(sys))
+         return "linux";
+      else if (new EReg("mac", "i").match(sys))
+         return "mac";
+      else
+         throw "Unknown host system: " + sys;
+      return "";
+   }
+
+   public static function main()
+   {
+      new Builder( Sys.args() );
+   }
+}
+

Kha/Backends/Kinc-hxcpp/khacpp/hxcpp/NekoInit.hx

@@ -0,0 +1,21 @@
+package hxcpp;
+
+class NekoInit
+{
+   public static function nekoInit(inModuleName:String) : Bool
+   {
+      var init = neko.Lib.load(inModuleName, "neko_init", 5);
+
+      if (init != null) 
+      {
+         init( function(s) return new String(s),
+               function(len:Int) { var r = []; if (len > 0) r[len - 1] = null; return r; },
+               null,
+               true,
+               false);
+         return true;
+
+      }
+      return false;
+   }
+}

Kha/Backends/Kinc-hxcpp/khacpp/hxcpp/StaticMysql.hx

@@ -0,0 +1,24 @@
+package hxcpp;
+
+#if (hxcpp_api_level>=330)
+
+class StaticMysql { }
+
+#else
+
+@:cppFileCode( 'extern "C" int mysql_register_prims();')
+@:buildXml("
+<target id='haxe'>
+  <lib name='${HXCPP}/lib/${BINDIR}/libmysql5${LIBEXTRA}${LIBEXT}'/>
+  <lib name='ws2_32.lib' if='windows'/>
+</target>
+")
+@:keep class StaticMysql
+{
+   static function __init__()
+   {
+     untyped __cpp__("mysql_register_prims();");
+   }
+}
+
+#end

Kha/Backends/Kinc-hxcpp/khacpp/hxcpp/StaticRegexp.hx

@@ -0,0 +1,23 @@
+package hxcpp;
+
+#if (hxcpp_api_level>=330)
+
+class StaticRegexp { }
+
+#else
+
+@:cppFileCode( 'extern "C" int regexp_register_prims();')
+@:buildXml("
+<target id='haxe'>
+  <lib name='${HXCPP}/lib/${BINDIR}/libregexp${LIBEXTRA}${LIBEXT}'/>
+</target>
+")
+@:keep class StaticRegexp
+{
+   static function __init__()
+   {
+     untyped __cpp__("regexp_register_prims();");
+   }
+}
+
+#end

Kha/Backends/Kinc-hxcpp/khacpp/hxcpp/StaticSqlite.hx

@@ -0,0 +1,24 @@
+package hxcpp;
+
+#if (hxcpp_api_level>=330)
+
+class StaticSqlite { }
+
+#else
+
+@:cppFileCode( 'extern "C" int sqlite_register_prims();')
+@:buildXml("
+<target id='haxe'>
+  <lib name='${HXCPP}/lib/${BINDIR}/libsqlite${LIBEXTRA}${LIBEXT}'/>
+  <lib name='-lpthread' if='linux'/>
+</target>
+")
+@:keep class StaticSqlite
+{
+   static function __init__()
+   {
+     untyped __cpp__("sqlite_register_prims();");
+   }
+}
+
+#end

Kha/Backends/Kinc-hxcpp/khacpp/hxcpp/StaticStd.hx

@@ -0,0 +1,25 @@
+package hxcpp;
+
+#if (hxcpp_api_level>=330)
+
+class StaticStd { }
+
+#else
+
+@:cppFileCode( 'extern "C" int std_register_prims();')
+@:buildXml("
+<target id='haxe'>
+  <lib name='${HXCPP}/lib/${BINDIR}/libstd${LIBEXTRA}${LIBEXT}'/>
+   <lib name='ws2_32.lib' if='windows' unless='static_link' />
+</target>
+")
+@:keep class StaticStd
+{
+   static function __init__()
+   {
+     untyped __cpp__("std_register_prims();");
+   }
+}
+
+
+#end

Kha/Backends/Kinc-hxcpp/khacpp/hxcpp/StaticZlib.hx

@@ -0,0 +1,29 @@
+package hxcpp;
+
+#if (hxcpp_api_level>=330)
+
+class StaticZlib { }
+
+#else
+
+@:cppFileCode( 'extern "C" int zlib_register_prims();')
+#if HXCPP_LINK_NO_ZLIB
+@:buildXml("
+<import name='${HXCPP}/project/libs/zlib/Build.xml'/>
+")
+#else
+@:buildXml("
+<target id='haxe'>
+  <lib name='${HXCPP}/lib/${BINDIR}/libzlib${LIBEXTRA}${LIBEXT}'/>
+</target>
+")
+#end
+@:keep class StaticZlib
+{
+   static function __init__()
+   {
+     untyped __cpp__("zlib_register_prims();");
+   }
+}
+
+#end