BuildTool.hx

import CopyFile.Overwrite;
import haxe.io.Path;
import haxe.Json;
import sys.io.Process;
import sys.FileSystem;

#if haxe4
import sys.thread.Thread;
import sys.thread.Mutex;
import sys.thread.Tls;
#elseif neko
import neko.vm.Thread;
import neko.vm.Mutex;
import neko.vm.Tls;
#else
import cpp.vm.Thread;
import cpp.vm.Mutex;
import cpp.vm.Tls;
#end

import haxe.crypto.Md5;

import Log.NORMAL;
import Log.BOLD;
import Log.ITALIC;
import Log.YELLOW;
import Log.WHITE;

using StringTools;

#if (haxe_ver>=4)
typedef XmlAccess = haxe.xml.Access;
#else
typedef XmlAccess = haxe.xml.Fast;
#end

#if haxe3
typedef Hash<T> = haxe.ds.StringMap<T>;
#end
typedef FileGroups = Hash<FileGroup>;
typedef Targets = Hash<Target>;
typedef Prelinkers = Hash<Prelinker>;
typedef Linkers = Hash<Linker>;


class BuildTool
{
   public inline static var SupportedVersion = 500;

   var mDefines:Hash<String>;
   var mCurrentIncludeFile:String;
   var mIncludePath:Array<String>;
   var mCompiler:Compiler;
   var mStripper:Stripper;
   var mManifester:Manifester;
   var mPrelinkers:Prelinkers;
   var mLinkers:Linkers;
   var mCopyFiles:Array<CopyFile>;
   var mFileGroups:FileGroups;
   var mTargets:Targets;
   var mFileStack:Array<String>;
   var mMakefile:String;
   var mMagicLibs:Array<{name:String, replace:String}>;
   var mPragmaOnce:Map<String,Bool>;
   var mNvccFlags:Array<String>;
   var mNvccLinkFlags:Array<String>;
   var mDirtyList:Array<String>;
   var arm64:Bool;
   var m64:Bool;
   var m32:Bool;
   var defaultCStandard:Null<Int>;
   var defaultCxxStandard:Null<Int>;
   var defaultObjCStandard:Null<Int>;
   var defaultObjCxxStandard:Null<Int>;

   public static var os="";
   public static var sAllowNumProcs = true;
   public static var sCompileThreadCount = 1;
   public static var sThreadPool:ThreadPool;
   public static var sReportedThreads = -1;
   public static var HXCPP = "";
   public static var is64 = false;
   public static var isWindows = false;
   public static var isWindowsArm = false;
   public static var isLinux = false;
   public static var isRPi = false;
   public static var isMac = false;
   public static var targetKey:String;
   public static var instance:BuildTool;
   public static var helperThread = new Tls<Thread>();
   public static var destination:String;
   public static var outputs = new Array<String>();
   public static var groupMutex = new Mutex();
   static var mVarMatch = new EReg("\\${(.*?)}","");
   static var mNoDollarMatch = new EReg("{(.*?)}","");

   public static var exitOnThreadError = false;
   public static var threadExitCode = 0;
   public static var startDir:String;



   public function new(inJob:String,inDefines:Hash<String>,inTargets:Array<String>,
        inIncludePath:Array<String>, inDirtyList:Array<String> )
   {
      mDefines = inDefines;
      mFileGroups = new FileGroups();
      mCompiler = null;
      mStripper = null;
      mTargets = new Targets();
      mPrelinkers = new Prelinkers();
      mLinkers = new Linkers();
      mCurrentIncludeFile = "";
      mFileStack = [];
      mCopyFiles = [];
      mIncludePath = inIncludePath;
      mPragmaOnce = new Map<String,Bool>();
      mMagicLibs = [];
      mNvccFlags = [];
      mNvccLinkFlags = [];
      mMakefile = "";
      mDirtyList = inDirtyList;

      if (inJob=="cache")
      {
      }
      else
      {
         mMakefile = inJob;
         if (!PathManager.isAbsolute(mMakefile) && sys.FileSystem.exists(mMakefile))
            mMakefile = sys.FileSystem.fullPath(mMakefile);
         mDefines.set("HXCPP_BUILD_DIR", Path.addTrailingSlash(Path.directory(mMakefile)) );
      }


      instance = this;

      m64 = mDefines.exists("HXCPP_M64");
      m32 = mDefines.exists("HXCPP_M32") || mDefines.exists("HXCPP_X86");
      arm64 = mDefines.exists("HXCPP_ARM64");
      var otherArmArchitecture = mDefines.exists("HXCPP_ARMV6") || mDefines.exists("HXCPP_ARMV7") || mDefines.exists("HXCPP_ARMV7S");
      if (m64==m32 && !arm64 && !otherArmArchitecture)
      {
         var arch = mDefines.get("HXCPP_ARCH");
         if (arch!=null)
         {
            m64 = arch=="x86_64";
            m32 = arch=="x86";
            arm64 = arch=="arm64";
         }
         else
         {
            var hostArch = getArch();

            // Default to the current OS version.  windowsArm runs m32 code too
            m64 = hostArch=="m64";
            m32 = hostArch=="m32";
            arm64 = hostArch=="arm64";
         }

         mDefines.remove(m32 ? "HXCPP_M64" : "HXCPP_M32");
         set64(mDefines,m64,arm64);
      }

      Profile.setEntry("parse xml");

      include("toolchain/setup.xml");

      if (mDefines.exists("toolchain"))
      {
         if (!mDefines.exists("BINDIR"))
         {
            mDefines.set("BINDIR", Path.withoutDirectory(Path.withoutExtension(mDefines.get("toolchain"))));
         }
         if ( (new EReg("window","i")).match(os) )
            mDefines.set("windows_host","1");
      }
      else
         setDefaultToolchain(mDefines);


      if (mDefines.exists("dll_import"))
      {
         var path = new Path(mDefines.get("dll_import"));
         if (!mDefines.exists("dll_import_include"))
            mDefines.set("dll_import_include", path.dir + "/include" );
         if (!mDefines.exists("dll_import_link"))
            mDefines.set("dll_import_link", mDefines.get("dll_import") );
      }

      setupAppleDirectories(mDefines);

      if (isMsvc())
      {
         mDefines.set("isMsvc","1");
         if (Std.parseInt(mDefines.get("MSVC_VER"))>=18)
            mDefines.set("MSVC18+","1");
      }

      include("toolchain/finish-setup.xml", false);


      if (mMakefile!="")
      {
         pushFile(mMakefile,"makefile");
         var make_contents = "";
         try {
            make_contents = sys.io.File.getContent(mMakefile);
         } catch (e:Dynamic) {
            Log.error("Could not open build file \"" + mMakefile + "\"");
            //println("Could not open build file '" + mMakefile + "'");
            //Sys.exit(1);
         }


         var xml_slow = Xml.parse(make_contents);
         var xml = new XmlAccess(xml_slow.firstElement());

         parseXML(xml,"",false);
         popFile();

         include("toolchain/" + mDefines.get("toolchain") + "-toolchain.xml", false);


         if (mDefines.exists("HXCPP_CONFIG"))
            include(mDefines.get("HXCPP_CONFIG"),"exes",true);
      }

      for(group in mFileGroups)
         group.filter(mDefines);

      if (Log.verbose) Log.println ("");

      // MSVC needs this before the toolchain file, Emscripten wants to set HXCPP_COMPILE_THREADS
      // If not already calculated in "setup"
      getThreadCount();

      var cached = CompileCache.init(mDefines);

      Profile.setEntry("setup cache");

      if (inJob=="cache")
      {
         if (!cached)
         {
            Log.error("HXCPP_COMPILE_CACHE is not set");
         }
         switch(inTargets[0])
         {
            case "days" :
               var days = inTargets[1]==null ? null : Std.parseInt(inTargets[1]);
               if (days==null)
               {
                  Log.error("cache days - expected day count");
                  Tools.exit(1);
               }
               CompileCache.clear(days,0,true,null);
            case "resize" :
               var mb = inTargets[1]==null ? null : Std.parseInt(inTargets[1]);
               if (mb==null)
               {
                  Log.error("cache resize - expected megabyte count");
                  Tools.exit(1);
               }
               CompileCache.clear(0,mb,true,inTargets[2]);

            case "clear" : CompileCache.clear(0,0,true,inTargets[1]);
            case "list" : CompileCache.list(false,inTargets[1]);
            case "details" : CompileCache.list(true,inTargets[1]);
            default:
              printUsage();
              Tools.exit(1);
         }
         return;
      }

      if (cached)
      {
         var cacheSize = mDefines.exists("HXCPP_CACHE_MB") ? Std.parseInt( mDefines.get("HXCPP_CACHE_MB") ) : 1000;
         if (cacheSize!=null && cacheSize>0)
            CompileCache.clear(0,cacheSize,false,null);
      }

      if (Log.verbose) Log.println ("");

      if (inTargets.remove("clear"))
      {
         Profile.setEntry("clear");
         for(target in mTargets.keys())
            cleanTarget(target,false);
       }

      if (inTargets.remove("clean"))
      {
         Profile.setEntry("clean");
         for(target in mTargets.keys())
            cleanTarget(target,true);
      }

      if (destination!=null && inTargets.length!=1)
      {
         Log.warn("Exactly one target must be specified with 'destination'.  Specified:" + inTargets );
         destination = null;
      }

      Profile.setEntry("build");
      for(target in inTargets)
         buildTarget(target,destination);

      var linkOutputs = mDefines.get("HXCPP_LINK_OUTPUTS");
      if (linkOutputs!=null)
         sys.io.File.saveContent(linkOutputs,outputs.join("\n")+"\n");
      if (Log.verbose)
      {
         for(out in outputs)
            Log.v(" generated " + out);
      }

      if (threadExitCode != 0)
         Tools.exit(threadExitCode);
   }

   public static function isDefault64()
   {
   }

   public function pushFile(inFilename:String, inWhy:String, inSection:String="")
   {
      Log.info("", " - \x1b[1mParsing " + inWhy + ":\x1b[0m " + inFilename + (inSection == "" ? "" : " \x1b[3m(section \"" + inSection + "\")\x1b[0m"));
      mFileStack.push(inFilename);
   }

   public function popFile()
   {
      mFileStack.pop();
   }

   public static function addOutput(inWhat:String, inWhere:String)
   {
      outputs.push(inWhat + "=" + inWhere);
   }

   public static function getThreadCount() : Int
   {
      if (instance!=null)
      {
         var defs = instance.mDefines;
         if (sAllowNumProcs)
         {
            var thread_var = defs.exists("HXCPP_COMPILE_THREADS") ?
               defs.get("HXCPP_COMPILE_THREADS") : Sys.getEnv("HXCPP_COMPILE_THREADS");

            if (thread_var == null)
            {
               sCompileThreadCount = getNumberOfProcesses();
            }
            else
            {
               sCompileThreadCount = (Std.parseInt(thread_var)<2) ? 1 : Std.parseInt(thread_var);
            }
         }
         if (sCompileThreadCount>1 && sThreadPool==null)
            sThreadPool = new ThreadPool(sCompileThreadCount);
      }

      if (sCompileThreadCount!=sReportedThreads)
      {
         sReportedThreads = sCompileThreadCount;
         Log.setup('${Log.YELLOW}Using compile threads: $sCompileThreadCount${Log.NORMAL}' );
      }

      return sCompileThreadCount;
   }

   public static function setThreadError(inCode:Int)
   {
      threadExitCode = inCode;
      if (exitOnThreadError)
         Tools.exit(inCode);
   }

   public function buildTarget(inTarget:String, inDestination:String)
   {
      //var dependDebug = function(s:String) Log.error(s);
      var dependDebug = null;

      // Sys.println("Build : " + inTarget );
      if (!mTargets.exists(inTarget))
      {
         Log.error ("Could not find build target \"" + inTarget + "\"");
         //throw "Could not find target '" + inTarget + "' to build.";
      }
      if (mCompiler==null)
      {
         Log.error("No compiler defined for the current build target");
         //throw "No compiler defined";
      }

      var target:Target = mTargets.get(inTarget);
      target.checkError();

      for(sub in target.mSubTargets)
         buildTarget(sub,null);

      var threadPool = BuildTool.sThreadPool;


      PathManager.resetDirectoryCache();
      var restoreDir = "";
      if (target.mBuildDir!="")
      {
         restoreDir = Sys.getCwd();
         Log.info("", " - \x1b[1mChanging directory:\x1b[0m " + target.mBuildDir);
         Sys.setCwd(target.mBuildDir);
      }

      targetKey = inTarget + target.getKey();

      var objs = new Array<String>();

      mCompiler.objToAbsolute();

      if (target.mFileGroups.length > 0)
         PathManager.mkdir(mCompiler.mObjDir);

      var baseDir = Sys.getCwd();
      for(group in target.mFileGroups)
      {
         var useCache = CompileCache.hasCache && group.mUseCache;
         if (!useCache && group.mUseCache)
            Log.v("Ignoring compiler cache because HXCPP_COMPILE_CACHE is not valid.");

         var groupObjs = new Array<String>();

         if (group.mDir!="." && group.mSetImportDir)
            Sys.setCwd( PathManager.combine(baseDir, group.mDir ) );
         group.checkOptions(mCompiler.mObjDir);

         group.checkDependsExist();

         if (!mCompiler.initPrecompile(mDefines.get("USE_PRECOMPILED_HEADERS") ))
            group.dontPrecompile();

         group.preBuild();

         var to_be_compiled = new Array<File>();

         var cached = useCache && mCompiler.createCompilerVersion();

         var inList = new Array<Bool>();
         var groupIsOutOfDate = mDirtyList.indexOf(group.mId)>=0 || mDirtyList.indexOf("all")>=0;

         if (useCache)
         {
            Profile.push("compute hash");
            if (useCache && group.hasFiles() && threadPool!=null)
            {
               Log.initMultiThreaded();
               var names:Array<String> = Lambda.array(Lambda.map(group.mFiles, function(file:File) {return file.mName; }));
               threadPool.setArrayCount( names.length );
               threadPool.runJob( function(tid) {
                  var localCache = new Map<String,String>();

                  while(threadExitCode==0)
                  {
                     var id = sThreadPool.getNextIndex();
                     if (id<0)
                        break;

                     group.mFiles.get(names[id]).computeDependHash(localCache);
                  }
               } );
            }
            else
            {
               for(file in group.mFiles)
                  file.computeDependHash(null);
            }
            Profile.pop();
         }


         for(file in group.mFiles)
         {
            var obj_name = mCompiler.getCachedObjName(file);
            groupObjs.push(obj_name);
            var outOfDate = groupIsOutOfDate || file.isOutOfDate(obj_name, dependDebug);
            if (outOfDate)
            {
               if (dependDebug!=null)
                  dependDebug(mCompiler.getCacheString(file));
               to_be_compiled.push(file);
            }
            inList.push(outOfDate);
         }
         var someCompiled = to_be_compiled.length > 0;

         var pchStamp:Null<Float> = null;
         if (group.mPrecompiledHeader!="")
         {
            Profile.push("pch");

            var obj = mCompiler.precompile(group,cached || to_be_compiled.length==0);
            if (obj!=null)
            {
               pchStamp = FileSystem.stat(obj).mtime.getTime();
               groupObjs.push(obj);

               /*
               for(i in 0...group.mFiles.length)
               {
                  var obj_name = groupObjs[i];
                  if (!inList[i])
                  {
                     if (FileSystem.stat(obj_name).mtime.getTime() < pchStamp)
                     {
                        groupObjs.push(obj_name);
                        trace(' Add $obj_name');
                     }
                     else
                        trace(' Ok $obj_name');
                  }
                  else
                  {
                        trace(' Listed $obj_name  ' + group.mFiles[i].mName);
                  }
               }
               */
            }
            Profile.pop();
         }

         if (group.mConfig!="")
         {
            var lines = ["#ifndef HXCPP_CONFIG_INCLUDED","#define HXCPP_CONFIG_INCLUDED"];

            var flags = group.mCompilerFlags.concat(mCompiler.getCompilerDefines("haxe"));
            var define = ~/^-D([^=]*)=?(.*)/;
            for(flag in flags)
            {
                if (define.match(flag))
                {
                   var name = define.matched(1);
                   var val = define.matched(2);
                   lines.push("");
                   lines.push( '#if !defined($name) && !defined(NO_$name)' );
                   lines.push( '#define $name $val' );
                   lines.push( '#endif' );
                }
            }

            lines.push("");
            lines.push("#include <hxcpp.h>");
            lines.push("");
            lines.push("#endif");
            lines.push("");

            var filename = mDefines.exists("HXCPP_OUTPUT_CONFIG_NAME") ?
                           mDefines.get("HXCPP_OUTPUT_CONFIG_NAME") :
                           PathManager.combine( target.mOutputDir, group.mConfig );
            if (!PathManager.isAbsolute(filename))
               filename = PathManager.combine( Sys.getCwd(), filename);

            var content = lines.join("\n");
            if (!FileSystem.exists(filename) || sys.io.File.getContent(filename)!=content)
               sys.io.File.saveContent(filename, content);
            addOutput("config",filename);
         }


         var nvcc = group.mNvcc;
         var first = true;
         var groupHeader = (!Log.quiet && !Log.verbose) ? function()
         {
            if (first)
            {
               groupMutex.acquire();
               if (first)
               {
                  first = false;
                  Log.lock();
                  Log.println("");
                  Log.info("\x1b[33;1mCompiling group: " + group.mId + "\x1b[0m");
                  var message = "\x1b[1m" + (nvcc ? getNvcc() : mCompiler.mExe) + "\x1b[0m";
                  var flags = group.mCompilerFlags;
                  if (!nvcc)
                     flags = flags.concat(mCompiler.getFlagStrings());
                  else
                     flags = flags.concat( BuildTool.getNvccFlags() );

                  for (compilerFlag in flags)
                  {
                     if (StringTools.startsWith(compilerFlag, "-D"))
                     {
                        var index = compilerFlag.indexOf("(");
                        if (index > -1)
                        {
                           message += " \x1b[1m" + compilerFlag.substr(0, index) + "\x1b[0m\x1b[2m" + compilerFlag.substr(index) + "\x1b[0m";
                        }
                        else
                        {
                           message += " \x1b[1m" + compilerFlag + "\x1b[0m";
                        }
                     }
                     else
                     {
                        message += " \x1b[0m" + compilerFlag + "\x1b[0m";
                     }
                  }
                  message += " \x1b[2m...\x1b[0m \x1b[2mtags=" + group.mTags.split(",") + "\x1b[0m";
                  Log.info(message);
                  Log.unlock();
               }
               groupMutex.release();
            }
         } : null;

         Profile.push("compile");
         if (threadPool==null)
         {
            for(file in to_be_compiled)
               mCompiler.compile(file,-1,groupHeader,pchStamp);
         }
         else
         {
            Log.initMultiThreaded();
            var mutex = threadPool.mutex;
            var compiler = mCompiler;
            threadPool.setArrayCount(to_be_compiled.length);
            threadPool.runJob( function(threadId:Int) {
                  while(threadExitCode==0)
                  {
                     var index = threadPool.getNextIndex();
                     if (index<0)
                        break;
                     var file = to_be_compiled[index];

                     compiler.compile(file,threadId,groupHeader,pchStamp);
                  }
            });
         }
         Profile.pop();

         if (CompileCache.hasCache && group.mAsLibrary && mLinkers.exists("static_link"))
         {
            Profile.push("link libs");
            var linker = mLinkers.get("static_link");
            var targetDir = mCompiler.mObjDir;
            if (useCache)
            {
               targetDir = CompileCache.compileCache + "/" + group.getCacheProject() + "/lib";
               PathManager.mkdir(targetDir);
            }
            var libName = targetDir + "/" + mCompiler.getTargetPrefix() + "_" + group.getCacheProject();

            var libTarget = new Target(libName, "linker", "static_link" );
            linker.link(libTarget,groupObjs, mCompiler, [] );
            target.mAutoLibs.push(linker.mLastOutName);
            // Linux the libraries must be added again if the references were not resolved the firs time
            if (group.mAddTwice)
               target.mLibs.push(linker.mLastOutName);
            Profile.pop();
         }
         else if (nvcc)
         {
            var objDir = mCompiler.mObjDir;
            if (group.isCached())
               objDir = CompileCache.compileCache;
            var extraObj = linkNvccFiles(objDir, someCompiled, groupObjs, group.mId, mCompiler.mExt);
            groupObjs.push(extraObj);
            objs = objs.concat(groupObjs);
         }
         else
         {
            objs = objs.concat(groupObjs);
         }

         if (group.mDir!="." && group.mSetImportDir)
            Sys.setCwd( baseDir );
      }

      switch(target.mTool)
      {
         case "linker":
            Profile.push("linker");
            if (mPrelinkers.exists(target.mToolID))
            {
               var result = mPrelinkers.get(target.mToolID).prelink(target,objs, mCompiler);
               if (result != "")
                  objs.push(result);
               //throw "Missing linker :\"" + target.mToolID + "\"";
            }

            if (!mLinkers.exists(target.mToolID))
            {
               Log.error ("Could not find linker for \"" + target.mToolID + "\"");
               //throw "Missing linker :\"" + target.mToolID + "\"";
            }
            var extraDeps = [];
            var manifest = mDefines.get("manifestFile");
            if (manifest!=null)
               extraDeps.push(manifest);

            var linker = mLinkers.get(target.mToolID);
            var output = linker.link(target,objs, mCompiler, extraDeps);

            if (output!="")
            {
               if (mStripper!=null)
               {
                  if (target.mToolID=="exe" || target.mToolID=="dll")
                  {
                     if ( mDefines.exists("HXCPP_DEBUG_LINK_AND_STRIP") )
                     {
                        var unstripped = linker.getUnstrippedFilename(mCompiler.mObjDir,target);
                        //var unstripped = mCompiler.mObjDir + "/" + linker.getSimpleFilename(target);
                        Log.v("Save unstripped to " + unstripped);

                        var chmod = isWindows ? false : target.mToolID=="exe";
                        CopyFile.copyFile(output, unstripped, false, Overwrite.ALWAYS, chmod);
                     }

                     mStripper.strip(output);
                  }
               }

               if (manifest!=null && (target.mToolID=="exe" || target.mToolID=="dll") )
               {
                  if (mManifester==null)
                  {
                     Log.v('Could not find manifest tool for "$manifest" - ignoring');
                  }
                  else
                  {
                     //if (!PathManager.isAbsolute(manifest))
                        //manifest = PathManager.combine(startDir,manifest);
                     Log.v('Adding manifest "$manifest"');
                     mManifester.add(output, manifest,target.mToolID=="exe");
                  }
               }
            }


            var outFile = linker.mLastOutName;
            if (outFile!="" && !PathManager.isAbsolute(outFile) && sys.FileSystem.exists(mMakefile))
            {
               var baseFile = PathManager.standardize(mMakefile);
               var parts = baseFile.split("/");
               parts[ parts.length-1 ] = outFile;
               outFile = parts.join("/");
            }
            if (outFile!="")
               addOutput(target.mToolID, outFile);

            if (output!="" && inDestination!=null)
            {
               inDestination = substitute(inDestination,false);
               if (inDestination!="")
               {
                  if (!PathManager.isAbsolute(inDestination) && sys.FileSystem.exists(mMakefile))
                  {
                     var baseFile = PathManager.standardize(mMakefile);
                     var parts = baseFile.split("/");
                     parts[ parts.length-1 ] = inDestination;
                     inDestination = parts.join("/");
                  }

                  inDestination = PathManager.clean(inDestination);
                  var fileParts = inDestination.split("/");
                  fileParts.pop();
                  PathManager.mkdir(fileParts.join("/"));

                  var chmod = isWindows ? false : target.mToolID=="exe";
                  CopyFile.copyFile(output, inDestination, false, Overwrite.ALWAYS, chmod);
               }
            }
            Profile.pop();
         case _ if (inDestination != null):
            Log.warn('Target \'${inTarget}\' does not output a file, so \'destination\' has been ignored');
      }

      if (mCopyFiles.length>0)
      {
         Profile.push("copy files");
         for(copyFile in mCopyFiles)
            if (copyFile.toolId==null || copyFile.toolId==target.mToolID)
               copyFile.copy(target.mOutputDir);
         Profile.pop();
      }

      if (restoreDir!="")
         Sys.setCwd(restoreDir);
   }

   function linkNvccFiles(objDir:String, hasChanged:Bool, nvObjs:Array<String>, inGroupName:String, objExt:String)
   {
      // nvcc -arch=sm_30 -dlink test1.o test2.o -o link.o
      // Sadly, nvcc has no 'fromFile' options, so we must do it from objDir
      var objDirLen = objDir.length;
      var last = objDir.substr(objDirLen-1);
      if (last!="/" && last!="\\")
         objDirLen++;
      var outFile = "nvcc_" + inGroupName + mCompiler.mExt;
      var fullFile = objDir + "/" + outFile;

      if (hasChanged || !sys.FileSystem.exists(fullFile) )
      {
         var maxObjs = 25;
         var shortObjs = nvObjs.map( function(f) return f.substr(objDirLen) );
         if (shortObjs.length>maxObjs)
         {
            var partObjs = new Array<String>();
            var p0 = 0;
            var n =shortObjs.length;
            var groupIdx = 0;
            while(p0<n)
            {
               var subName = "nvcc_" + inGroupName + "_" + (groupIdx++) + mCompiler.mExt;
               var remain = n-p0;
               var use = remain<maxObjs ? remain : remain<maxObjs*2 ? (remain>>1) : maxObjs;
               var files = shortObjs.slice(p0,p0+use);

               var flags = getNvccLinkFlags().concat(files).concat(["-o",subName]);
               var dbgFlags = getNvccLinkFlags().concat(["[.", "x"+subName.length,".]"]).concat(["-o",subName]);
               Log.v("Linking nvcc in " + objDir + ":" + getNvcc() + dbgFlags.join(" ") );
               ProcessManager.runCommand(objDir ,getNvcc(),  flags );
               partObjs.push(subName);
               p0 += use;
            }
            shortObjs = partObjs;
         }

         var flags = getNvccLinkFlags().concat(shortObjs).concat(["-o",outFile]);
         var dbgFlags = getNvccLinkFlags().concat(["[.", "x"+shortObjs.length,".]"]).concat(["-o",outFile]);
         Log.v("Linking nvcc in " + objDir + ":" + getNvcc() + dbgFlags.join(" ") );
         ProcessManager.runCommand(objDir ,getNvcc(),  flags );
      }
      return fullFile;
   }


   public function cleanTarget(inTarget:String,allObj:Bool)
   {
      // Sys.println("Build : " + inTarget );
      if (!mTargets.exists(inTarget))
      {
         Log.error("Could not find build target \"" + inTarget + "\"");
         //throw "Could not find target '" + inTarget + "' to build.";
      }
      if (mCompiler==null)
      {
         Log.error("No compiler defined");
         //throw "No compiler defined";
      }

      var target = mTargets.get(inTarget);
      target.checkError();

      for(sub in target.mSubTargets)
         cleanTarget(sub,allObj);

      var restoreDir = "";
      if (target.mBuildDir!="")
      {
         restoreDir = Sys.getCwd();
         Log.info("", " - \x1b[1mChanging directory:\x1b[0m " + target.mBuildDir);
         Sys.setCwd(target.mBuildDir);
      }

      PathManager.removeDirectory(mCompiler.mObjDir);
      PathManager.removeFile("all_objs");
      PathManager.removeFilesWithExtension(".pdb");
      if (allObj)
         PathManager.removeDirectory("obj");

      if (restoreDir!="")
         Sys.setCwd(restoreDir);
   }

   public function createCompiler(inXML:XmlAccess,inBase:Compiler) : Compiler
   {
      var c = inBase;
      var id = inXML.has.id ? substitute(inXML.att.id) : null;
      var exe = inXML.has.exe ? substitute(inXML.att.exe) : null;
      if (inBase==null || inXML.has.replace)
      {
         c = new Compiler(id,exe);
      }
      else
      {
         if (id!=null)
            c.mID = id;
         if (exe!=null)
            c.mExe = exe;
      }
      c.mAddGCCIdentity = mDefines.exists("USE_GCC_FILETYPES");

      for(el in inXML.elements)
      {
         if (valid(el,""))
            switch(el.name)
            {
               case "flag" :
                     var tag =  el.has.tag?substitute(el.att.tag):"";
                     if (el.has.name)
                        c.addFlag(substitute(el.att.name), tag);
                     c.addFlag(substitute(el.att.value), tag);
               case "cflag" : c.mCFlags.push(substitute(el.att.value));
               case "cppflag" : c.mCPPFlags.push(substitute(el.att.value));
               case "objcflag" : c.mOBJCFlags.push(substitute(el.att.value));
               case "rcflag" : c.mRcFlags.push( substitute((el.att.value)) );
               case "mmflag" : c.mMMFlags.push(substitute(el.att.value));
               case "asmflag" : c.mAsmFlags.push(substitute(el.att.value));
               case "pchflag" : c.mPCHFlags.push(substitute(el.att.value));
               case "objdir" : c.mObjDir = substitute((el.att.value));
               case "outflag" : c.mOutFlag = substitute((el.att.value));
               case "exe" : c.mExe = substitute((el.att.name));
               case "rcexe" : c.mRcExe = substitute((el.att.name));
               case "rcext" : c.mRcExt = substitute((el.att.value));
               case "ext" : c.mExt = substitute((el.att.value));
               case "asmExe" : c.mAsmExe = substitute((el.att.value));
               case "pch" : c.setPCH( substitute((el.att.value)) );
               case "getversion" : c.mGetCompilerVersion = substitute((el.att.value));
               case "section" : createCompiler(el,c);
               case "include" :
                  var name = substitute(el.att.name);
                  var full_name = findIncludeFile(name);
                  if (full_name!="")
                  {
                     pushFile(full_name,"compiler");
                     var make_contents = sys.io.File.getContent(full_name);
                     var xml_slow = Xml.parse(make_contents);
                     createCompiler(new XmlAccess(xml_slow.firstElement()),c);
                     popFile();
                  }
                  else if (!el.has.noerror)
                  {
                     Log.error("Could not find include file \"" + name + "\"");
                     //throw "Could not find include file " + name;
                  }
               default:
                  Log.error("Unknown compiler option \"" + el.name + "\"");
                  //throw "Unknown compiler option: '" + el.name + "'";
            }
      }

      return c;
   }

   public function loadNvccXml()
   {
      var incName = findIncludeFile("nvcc-setup.xml");
      if (incName=="")
         incName = findIncludeFile('$HXCPP/toolchain/nvcc-setup.xml');
      if (incName=="")
        Log.error("Could not setup nvcc - missing nvcc-setup.xml");
      else if (!mPragmaOnce.get(incName))
      {
         pushFile(incName, "Nvcc");
         var make_contents = sys.io.File.getContent(incName);
         mPragmaOnce.set(incName,true);
         var xml = Xml.parse(make_contents);
         parseXML(new XmlAccess(xml.firstElement()),"", false);
         popFile();
      }
   }

   public static function setupNvcc()
   {
      instance.loadNvccXml();
   }


   public function createFileGroup(inXML:XmlAccess,inFiles:FileGroup,inName:String, inForceRelative:Bool, inTags:String):FileGroup
   {
      var dir = inXML.has.dir ? substitute(inXML.att.dir) : ".";
      if (inForceRelative)
         dir = PathManager.combine( Path.directory(mCurrentIncludeFile), dir );

      var group:FileGroup = inFiles==null ? new FileGroup(dir,inName, inForceRelative) :
                                  inXML.has.replace ? inFiles.replace(dir, inForceRelative) :
                                  inFiles;

      if (inTags!=null)
         group.mTags = inTags;

      if (mDefines.exists("HXCPP_C_STANDARD")) {
         defaultCStandard = Std.parseInt(mDefines.get("HXCPP_C_STANDARD"));
      }

      // Hxcpp requires C++11, so the default standard cannot be less than that
      if (mDefines.exists("HXCPP_CXX_STANDARD")) {
         defaultCxxStandard = Std.parseInt(mDefines.get("HXCPP_CXX_STANDARD"));
         if (defaultCxxStandard < 11) {
            Log.warn('Increasing default C++ standard to C++11 instead of C++${defaultCxxStandard}');
            defaultCxxStandard = 11;
         }
      } else if(mDefines.exists("HXCPP_CPP17")) {
         defaultCxxStandard = 17;
      } else if (mDefines.exists("HXCPP_CPP14")) {
         defaultCxxStandard = 14;
      } else {
         defaultCxxStandard = 11;
      }

      if (mDefines.exists("HXCPP_OBJC_STANDARD")) {
         defaultObjCStandard = Std.parseInt(mDefines.get("HXCPP_OBJC_STANDARD"));
      }

      if (mDefines.exists("HXCPP_OBJCXX_STANDARD")) {
         defaultObjCxxStandard = Std.parseInt(mDefines.get("HXCPP_OBJCXX_STANDARD"));
         if (defaultObjCxxStandard < 11) {
            Log.warn('Increasing default Obj-C++ standard to Obj-C++11 instead of Obj-C++${defaultObjCxxStandard}');
            defaultObjCxxStandard = 11;
         }
      } else {
         defaultObjCxxStandard = 11;
      }

      if (inXML.has.c_standard)
         group.mCStandard = Std.parseInt(substitute(inXML.att.c_standard));
      else if (group.mCStandard == null)
         group.mCStandard = defaultCStandard;

      if (inXML.has.objc_standard)
         group.mObjCStandard = Std.parseInt(substitute(inXML.att.objc_standard));
      else if (group.mObjCStandard == null)
         group.mObjCStandard = defaultObjCStandard != null ? defaultObjCStandard : group.mCStandard;

      if (inXML.has.cxx_standard)
         group.mCxxStandard = Std.parseInt(substitute(inXML.att.cxx_standard));
      else if (group.mCxxStandard == null)
         group.mCxxStandard = defaultCxxStandard;

      if (inXML.has.objcxx_standard)
         group.mObjCxxStandard = Std.parseInt(substitute(inXML.att.objcxx_standard));
      else if (group.mObjCxxStandard == null)
         group.mObjCxxStandard = defaultObjCxxStandard != null ? defaultObjCxxStandard : group.mCxxStandard;

      for(el in inXML.elements)
      {
         if (valid(el,""))
            switch(el.name)
            {
               case "file" :
                  var name = substitute(el.att.name);
                  var file:File = group.find(name);
                  if (file==null)
                  {
                     file = new File(name,group);
                     group.addFile( file );
                  }

                  file.mCStandard = el.has.c_standard ? Std.parseInt(substitute(el.att.c_standard)) : group.mCStandard;
                  file.mObjCStandard = el.has.objc_standard ? Std.parseInt(substitute(el.att.objc_standard)) : group.mObjCStandard;
                  file.mCxxStandard = el.has.cxx_standard ? Std.parseInt(substitute(el.att.cxx_standard)) : group.mCxxStandard;
                  file.mObjCxxStandard = el.has.objcxx_standard ? Std.parseInt(substitute(el.att.objcxx_standard)) : group.mObjCxxStandard;

                  if (el.has.tag)
                  {
                     var extra = substitute(el.att.tag);
                     file.setTags(group.mTags==null || group.mTags=="" ? extra : group.mTags+","+extra);
                  }
                  if (el.has.tags)
                     file.setTags( substitute(el.att.tags) );
                  if (el.has.filterout)
                     file.mFilterOut = substitute(el.att.filterout);
                  if (el.has.embedName)
                     file.mEmbedName = substitute(el.att.embedName);
                  if (el.has.scramble)
                     file.mScramble = substitute(el.att.scramble);
                  for(f in el.elements)
                     if (valid(f,"") && f.name=="depend")
                        file.mDepends.push( substitute(f.att.name) );
               case "section" : createFileGroup(el,group,inName,inForceRelative,null);
               case "cache" :
                  group.mUseCache = parseBool( substitute(el.att.value) );
                  if (el.has.project)
                     group.mCacheProject = substitute(el.att.project);
                  if (el.has.asLibrary)
                     group.mAsLibrary = true;
                  if (el.has.respectTimestamp)
                     group.mRespectTimestamp = true;
               case "tag" :
                   group.addTag( substitute(el.att.value) );
               case "addTwice" :
                  group.mAddTwice = true;
               case "depend" :
                  if (el.has.name)
                  {
                     var dateOnly = el.has.dateOnly && parseBool( substitute(el.att.dateOnly) );
                     group.addDepend( substitute(el.att.name), dateOnly );
                  }
                  else if (el.has.files)
                  {
                     var name = substitute(el.att.files);
                     if (!mFileGroups.exists(name))
                         Log.error( "Could not find filegroup for depend node:" + name );
                     group.addDependFiles(mFileGroups.get(name));
                  }
                  else
                     Log.error("depend node must have 'name' or 'files' attribute");
               case "hlsl" :
                  group.addHLSL( substitute(el.att.name), substitute(el.att.profile),
                  substitute(el.att.variable), substitute(el.att.target)  );
               case "options" : group.addOptions( substitute(el.att.name) );
               case "config" : group.mConfig = substitute(el.att.name);
               case "assembler" : group.mAssembler = substitute(el.att.name);
               case "compilerflag" :
                  if (el.has.name)
                     group.addCompilerFlag( substitute(el.att.name) );
                  group.addCompilerFlag( substitute(el.att.value) );
               case "nvcc" :
                  setupNvcc();
                  group.mNvcc = true;
                  if (group.mTags=="haxe,static")
                     group.mTags=="nvcc";
               case "objprefix" :
                  group.mObjPrefix = substitute(el.att.value);
               case "compilervalue" :
                  group.addCompilerFlag( substitute(el.att.name) );
                  group.addCompilerFlag( substitute(el.att.value) );
               case "precompiledheader" :
                  group.setPrecompiled( substitute(el.att.name), substitute(el.att.dir) );
               case "include" :
                  var subbed_name = substitute(el.att.name);
                  var full_name = findIncludeFile(subbed_name);
                  if (full_name!="")
                  {
                     if (!mPragmaOnce.get(full_name))
                     {
                        pushFile(full_name, "FileGroup");
                        var make_contents = sys.io.File.getContent(full_name);
                        var xml_slow = Xml.parse(make_contents);
                        createFileGroup(new XmlAccess(xml_slow.firstElement()), group, inName, false,null);
                        popFile();
                     }
                  }
                  else
                  {
                     Log.error("Could not find include file \"" + subbed_name + "\"");

                  }
            }
      }

      return group;
   }

   public function createLinker(inXML:XmlAccess,inBase:Linker):Linker
   {
      var exe:String = inXML.has.exe ? substitute(inXML.att.exe) : null;
      if (inBase!=null && !inXML.has.replace && inBase.mExe==null)
         inBase.mExe = exe;
      var l = (inBase!=null && !inXML.has.replace) ? inBase : new Linker(exe);
      for(el in inXML.elements)
      {
         if (valid(el,""))
            switch(el.name)
            {
               case "flag" :
                   if (el.has.name)
                      l.mFlags.push(substitute(el.att.name));
                   l.mFlags.push(substitute(el.att.value));
               case "ext" : l.mExt = (substitute(el.att.value));
               case "outflag" : l.mOutFlag = (substitute(el.att.value));
               case "libdir" : l.mLibDir = (substitute(el.att.name));
               case "lib" :
                  if (el.has.hxbase)
                     l.mLibs.push( substitute(el.att.hxbase) + mDefines.get("LIBEXTRA") + mDefines.get("LIBEXT") );
                  else if (el.has.base)
                     l.mLibs.push( substitute(el.att.base) + mDefines.get("LIBEXT") );
                  else
                     l.mLibs.push( substitute(el.att.name) );

               case "prefix" : l.mNamePrefix = substitute(el.att.value);
               case "ranlib" : l.mRanLib = (substitute(el.att.name));
               case "libpathflag" : l.mAddLibPath = (substitute(el.att.value));
               case "recreate" : l.mRecreate = (substitute(el.att.value)) != "";
               case "expandAr" : l.mExpandArchives = substitute(el.att.value) != "";
               case "fromfile" :
                  if (el.has.value)
                     l.mFromFile = substitute(el.att.value);
                  if (el.has.needsQuotes)
                     l.mFromFileNeedsQuotes = parseBool(substitute(el.att.needsQuotes));
               case "exe" : l.mExe = (substitute(el.att.name));
               case "section" : createLinker(el,l);
            }
      }

      return l;
   }

   public function createPrelinker(inXML:XmlAccess,inBase:Prelinker):Prelinker
   {
      var l = (inBase!=null && !inXML.has.replace) ? inBase : new Prelinker(substitute(inXML.att.exe));
      for(el in inXML.elements)
      {
         if (valid(el,""))
            switch(el.name)
            {
               case "flag" : l.mFlags.push(substitute(el.att.value));
               //case "ext" : l.mExt = (substitute(el.att.value));
               case "outflag" : l.mOutFlag = (substitute(el.att.value));
               case "expandAr" : l.mExpandArchives = substitute(el.att.value) != "";
               case "fromfile" : l.mFromFile = (substitute(el.att.value));
               case "exe" : l.mExe = (substitute(el.att.name));
               case "section" : createPrelinker(el,l);
            }
      }

      return l;
   }

   public function createManifester(inXML:XmlAccess,inBase:Manifester):Manifester
   {
      var s = (inBase!=null && !inXML.has.replace) ? inBase :
                 new Manifester(substitute(inXML.att.exe));
      for(el in inXML.elements)
      {
         if (valid(el,""))
            switch(el.name)
            {
                case "flag" :
                    if (el.has.name)
                       s.mFlags.push(substitute(el.att.name));
                    s.mFlags.push(substitute(el.att.value));
                case "exe" : s.mExe = substitute((el.att.name));
            }
      }

      return s;
   }

   public function createStripper(inXML:XmlAccess,inBase:Stripper):Stripper
   {
      var s = (inBase!=null && !inXML.has.replace) ? inBase :
                 new Stripper(substitute(inXML.att.exe));
      for(el in inXML.elements)
      {
         if (valid(el,""))
            switch(el.name)
            {
                case "flag" :
                    if (el.has.name)
                       s.mFlags.push(substitute(el.att.name));
                    s.mFlags.push(substitute(el.att.value));
                case "exe" : s.mExe = substitute((el.att.name));
            }
      }

      return s;
   }

   public function createTarget(inXML:XmlAccess,?inTarget:Target, inForceRelative) : Target
   {
      var target:Target = inTarget;
      var output = inXML.has.output ? substitute(inXML.att.output) : "";
      var tool = inXML.has.tool ? substitute(inXML.att.tool) : "";
      var toolid = inXML.has.toolid ? substitute(inXML.att.toolid) : "";

      if (target==null)
      {
         target = new Target(output,tool,toolid);
         if (inForceRelative)
            target.mBuildDir = Path.directory(mCurrentIncludeFile);
      }
      else
      {
         if (output!="")
            target.mOutput = output;
         if (tool!="")
            target.mTool = tool;
         if (toolid!="")
            target.mToolID = toolid;
      }

      for(el in inXML.elements)
      {
         if (valid(el,""))
            switch(el.name)
            {
               case "target" : target.mSubTargets.push( substitute(el.att.id) );
               case "merge" :
                  var name = substitute(el.att.id);
                  if (!mTargets.exists(name))
                     Log.error("Could not find target " + name + " to merge.");
                  target.merge( mTargets.get(name) );

               case "lib" :
                  if (el.has.hxbase)
                     target.mLibs.push( substitute(el.att.hxbase) + mDefines.get("LIBEXTRA") + mDefines.get("LIBEXT") );
                  else if (el.has.base)
                     target.mLibs.push( substitute(el.att.base) + mDefines.get("LIBEXT") );
                  else
                  {
                      var lib = substitute(el.att.name);
                      var found = false;
                      for(magicLib in mMagicLibs)
                      {
                         if (lib.endsWith(magicLib.name))
                         {
                            var replace = lib.substr(0, lib.length-magicLib.name.length) +
                                              magicLib.replace;
                            Log.v('Using $replace instead of $lib');
                            found = true;
                            include(replace, "", false, true );
                            break;
                         }
                      }
                      if (!found)
                         target.mLibs.push(lib);
                  }

               case "flag" :
                   if (el.has.name)
                      target.mFlags.push( substitute(el.att.name) );
                   target.mFlags.push( substitute(el.att.value) );
               case "depend" : target.mDepends.push( substitute(el.att.name) );
               case "vflag" :
                  target.mFlags.push( substitute(el.att.name) );
                  target.mFlags.push( substitute(el.att.value) );
               case "dir" : target.mDirs.push( substitute(el.att.name) );
               case "outdir" : target.mOutputDir = substitute(el.att.name)+"/";
               case "ext" : target.setExt( (substitute(el.att.value)) );
               case "builddir" : target.mBuildDir = substitute(el.att.name);
               case "libpath" : target.mLibPaths.push( substitute(el.att.name) );
               case "fulloutput" : target.mFullOutputName = substitute(el.att.name);
               case "fullunstripped" : target.mFullUnstrippedName = substitute(el.att.name);
               case "files" :
                  var id = el.att.id;
                  if (!mFileGroups.exists(id))
                     target.addError( "Could not find filegroup " + id );
                  else
                     target.addFiles( mFileGroups.get(id), el.has.asLibrary );
               case "section" : createTarget(el,target,false);
            }
      }

      return target;
   }

   public function defined(inString:String):Bool
   {
      if (inString=="this_dir")
         return true;
      return mDefines.exists(inString);
   }

   public function parseBool(inValue:String):Bool
   {
      return inValue=="1" || inValue=="t" || inValue=="true";
   }

   function findLocalIncludeFile(inBase:String):String
   {
      if (inBase == null || inBase=="") return "";
      var c0 = inBase.substr(0,1);
      if (c0!="/" && c0!="\\")
      {
         var c1 = inBase.substr(1,1);
         if (c1!=":")
         {
            if (mCurrentIncludeFile!="")
            {
               var relative = Path.directory(mCurrentIncludeFile);
               var name = PathManager.combine(relative, inBase);
               if (FileSystem.exists(name))
                  return name;
            }

            for(p in mIncludePath)
            {
               var name = PathManager.combine(p, inBase);
               if (FileSystem.exists(name))
               {
                  return name;
               }
            }
            return "";
         }
      }
      if (FileSystem.exists(inBase))
         return inBase;
      return "";
   }

   function findIncludeFile(inBase:String):String
   {
      var result = findLocalIncludeFile(inBase);
      if (result!="" && !Path.isAbsolute(result))
         result =  Path.normalize( PathManager.combine( mCurrentIncludeFile=="" ? Sys.getCwd() : Path.directory(mCurrentIncludeFile), result ) );
      return result;
   }

   private static function getArch():String
   {
      if (isWindows)
      {
         if (isWindowsArm)
            return "arm64";
         var architecture = Sys.getEnv("PROCESSOR_ARCHITECTURE");
         var wow64Architecture = Sys.getEnv("PROCESSOR_ARCHITEW6432");
         if (architecture.indexOf("64") > -1 || wow64Architecture != null && wow64Architecture.indexOf("64") > -1)
         {
            return "m64";
         }
         else
         {
            return "m32";
         }
      }
      else
      {
         var process = new Process("uname", [ "-m" ]);
         var output = process.stdout.readAll().toString();
         var error = process.stderr.readAll().toString();
         process.exitCode();
         process.close();

         if ( (output.indexOf("aarch64") > -1) ||  (output.indexOf("arm64") > -1) )
         {
            return "arm64";
         }
         else if (output.indexOf("64") > -1)
         {
            return "m64";
         }
         else
         {
            return "m32";
         }
      }
   }

   static public function getMsvcVer()
   {
      return instance.mDefines.get("MSVC_VER");
   }

   static public function keepTemp()
   {
      return instance.mDefines.exists("HXCPP_KEEP_TEMP");
   }


   // Setting HXCPP_COMPILE_THREADS to 2x number or cores can help with hyperthreading
   public static function getNumberOfProcesses():Int
   {
      var cache = Log.verbose;
      Log.verbose = false;

      var result = null;
      if (isWindows)
      {
         var env = Sys.getEnv("NUMBER_OF_PROCESSORS");
         if (env != null)
         {
            result = env;
         }
      }
      else if (isLinux)
      {
         result = ProcessManager.runProcessLine("", "nproc", [], true, false, true, true);
         if (result == null)
         {
            var cpuinfo = ProcessManager.runProcess("", "cat", [ "/proc/cpuinfo" ], true, false, true, true);
            if (cpuinfo != null)
            {
               var split = cpuinfo.split("processor");
               result = Std.string(split.length - 1);
            }
         }
      }
      else if (isMac)
      {
         var cores = ~/Total Number of Cores: (\d+)/;
         var output = ProcessManager.runProcess("", "/usr/sbin/system_profiler", [ "-detailLevel", "full", "SPHardwareDataType" ], true, false, true, true);
         if (output != null && cores.match(output))
         {
            result = cores.matched(1);
         }
      }

      Log.verbose = cache;

      if (result == null || Std.parseInt(result) < 1)
      {
         return 1;
      }
      else
      {
         return Std.parseInt(result);
      }
   }

   private static function getVersion():String
   {
      try
      {
         var json = Json.parse (sys.io.File.getContent (PathManager.getHaxelib ("hxcpp") + "/haxelib.json"));
         return json.version;
      }
      catch (e:Dynamic)
      {
         return "0.0.0";
      }
   }

   public static function isMsvc()
   {
      return instance.mDefines.get("toolchain")=="msvc";
   }

   public static function isMingw()
   {
      return instance.mDefines.get("toolchain")=="mingw";
   }

   public static function getNvcc()
   {
      return instance.mDefines.get("NVCC");
   }

   public static function getNvccLinkFlags() : Array<String>
   {
      return instance.mNvccLinkFlags;
   }

   public static function getNvccFlags() : Array<String>
   {
      return instance.mNvccFlags;
   }

   public static function copy(from:String, to:String)
   {
      Log.v('copy $from $to');

      try {
         if (FileSystem.isDirectory(to))
            to += "/" + Path.withoutDirectory(from);
         var bytes = sys.io.File.getBytes(from);
         sys.io.File.saveBytes(to,bytes);
      } catch(e:Dynamic)
      {
         Log.error('Could not copy file $from $to');
      }
   }


   static public function main()
   {
     try {
       runMain();
     }
     catch(e:Dynamic) {
       Log.error('Uncaught exception on main thread: $e\n${haxe.CallStack.toString(haxe.CallStack.exceptionStack())}');
       Tools.exit(1);
     }
     Tools.exit(0);
   }

   // Process args and environment.
   static function runMain()
   {
      var targets = new Array<String>();
      var defines = new Hash<String>();
      var include_path = new Array<String>();
      var makefile:String="";
      var optionsTxt = "Options.txt";

      Profile.start();

      include_path.push(".");

      var args = Sys.args();
      var env = Sys.environment();

      for(e in env.keys())
         defines.set(e, Sys.getEnv(e) );


      // Check for calling from haxelib ...
      if (args.length>0)
      {
         var last:String = (new Path(args[args.length-1])).toString();
         var isRootDir = last=="/";
         if (!isRootDir)
         {
            var slash = last.substr(-1);
            if (slash=="/"|| slash=="\\")
               last = last.substr(0,last.length-1);
         }
         if (isRootDir || (FileSystem.exists(last) && FileSystem.isDirectory(last)))
         {
            // When called from haxelib, the last arg is the original directory, and
            //  the current direcory is the library directory.
            HXCPP = PathManager.standardize(Sys.getCwd());
            defines.set("HXCPP",HXCPP);
            args.pop();
            Sys.setCwd(last);
         }
      }


      if (defines.exists("HXCPP_NO_COLOUR") || defines.exists("HXCPP_NO_COLOR"))
         Log.colorSupported = false;
      Log.verbose = defines.exists("HXCPP_VERBOSE");
      Log.showSetup = defines.exists("HXCPP_LOG_SETUP");
      exitOnThreadError = defines.exists("HXCPP_EXIT_ON_ERROR");


      os = Sys.systemName();

      startDir = Sys.getCwd();

      isWindows = (new EReg("window","i")).match(os);
      if (isWindows)
      {
         var proc = Sys.getEnv("PROCESSOR_IDENTIFIER");
         isWindowsArm = proc!=null && (new EReg("\\barm","i")).match(proc);
         if (isWindowsArm)
            defines.set("windows_arm_host", "1");
      }
      isMac = (new EReg("mac","i")).match(os);
      if (isMac)
         defines.set("mac_host", "1");
      isLinux = (new EReg("linux","i")).match(os);
      if (isLinux)
         defines.set("linux_host", "1");


      if (args.length>0 && args[0].endsWith(".cppia"))
      {
         var hostName = isWindows ? "Windows" : isMac ? "Mac" : isLinux ? "Linux" : null;
         if (hostName==null)
            Log.error("Cppia is not supported on this host.");
         var archSuffix = switch getArch() {
            case 'arm64': 'Arm64';
            case 'm64': '64';
            case 'm32': '';
            case _: return Log.error("Unsupported host architecture");
         };
         var exe = '$HXCPP/bin/$hostName$archSuffix/Cppia' + (isWindows ? ".exe" : "");
         if (!isWindows)
         {
            var phase = "find";
            try
            {
               var stat = FileSystem.stat(exe);
               if (stat==null)
                  throw "Could not find exe:" + exe;
               var mode = stat.mode;
               var exeFlags = (1<<0) | (1<<3) | (1<<6);
               if ( (mode&exeFlags) != exeFlags )
               {
                  var phase = "add exe permissions to";
                  if (Sys.command( "chmod", ["755", exe])!=0)
                     Log.error('Please use root access to add execute permissions to $exe');
               }
            }
            catch(e:Dynamic)
            {
               Log.error('Could not $phase Cppia host $exe ($e)');
            }
         }

         #if (haxe_ver < 3.3)
         // avoid issue of path with spaces
         // https://github.com/HaxeFoundation/haxe/issues/3603
         if (isWindows)
            exe = '"$exe"';
         #end

         Tools.exit( Sys.command( exe, args ) );
      }
      else if (args.length>0 && args[0].endsWith(".js"))
      {
         Setup.initHXCPPConfig(defines);
         Setup.setupEmscripten(defines);
         var node = defines.get("EMSDK_NODE");
         Log.v( node==null ? "EMSDK_NODE undefined, using 'node'" : 'Using $node from EMSDK_NODE');
         if (node=="" || node==null)
            node = "node";

         Log.v(  node + " " + args.join(" ") );
         Tools.exit( Sys.command( node, args ) );
      }
      else if (args.length==1 && args[0]=="defines")
      {
         var dir = '$HXCPP/tools/hxcpp';
         try
         {
            var defineMatch = ~/m*defines\.\w+\("(\w+)"/i;
            var allDefines = new Map<String,Bool>();
            for(file in FileSystem.readDirectory(dir))
               if (file.endsWith(".hx"))
                  for(line in sys.io.File.getContent(file).split("\n"))
                     if (defineMatch.match(line))
                        allDefines.set(defineMatch.matched(1),true);
            for(key in allDefines.keys())
               Sys.println(key);
         }
         catch(e:Dynamic)
         {
            Log.error('Could not read $dir : $e');
         }
         return;
      }


      isRPi = isLinux && Setup.isRaspberryPi();

      is64 = getArch()!="m32";
      var dirtyList = new Array<String>();

      var a = 0;
      while(a < args.length)
      {
         var arg = args[a];
         if (arg.substr(0,2)=="-D" || (~/^[a-zA-Z0-9_][a-zA-Z0-9_-]*=/).match(arg) )
         {
            var define = arg.substr(0,2)=="-D" ? arg.substr(2) : arg;
            var equals = define.indexOf("=");
            if (equals>0)
            {
               var value = define.substr(equals+1);
               define = define.substr(0,equals);
               if (define=="destination")
               {
                  destination = value;
               }
               else
                  defines.set(define,value);
            }
            else
               defines.set(define,"");
            if (define=="verbose")
               Log.verbose = true;
         }
         else if (arg=="-debug")
               defines.set("debug","1");
         else if (arg=="-no-options")
            optionsTxt = "";
         else if (arg=="-options")
         {
            a++;
            optionsTxt = args[a];
            if (optionsTxt==null)
               optionsTxt = "";
         }
         else if (arg=="-dirty")
         {
            a++;
            dirtyList.push(args[a]);
         }
         else if (arg=="-v" || arg=="-verbose")
            Log.verbose = true;
         else if (arg=="-nocolor")
            Log.colorSupported = false;
         else if (arg.substr(0,2)=="-I")
            include_path.push(PathManager.standardize(arg.substr(2)));
         else if (makefile.length==0)
            makefile = arg;
         else
            targets.push(arg);

         a++;
      }

      if (defines.exists("HXCPP_TIMES"))
         Profile.enable();

      if (defines.exists("HXCPP_NO_COLOUR") || defines.exists("HXCPP_NO_COLOR"))
         Log.colorSupported = false;
      Log.verbose = Log.verbose || defines.exists("HXCPP_VERBOSE");
      Log.quiet = defines.exists("HXCPP_QUIET") && !Log.verbose;
      Log.mute = defines.exists("HXCPP_SILENT") && !Log.quiet && !Log.verbose;

      if ( optionsTxt!="" && makefile!="")
      {
         var path = PathManager.combine(haxe.io.Path.directory(makefile), optionsTxt);
         if (FileSystem.exists(path))
            try
            {
               var contents = sys.io.File.getContent(path);
               if (contents.substr(0,1)!=" ") // Is it New-style?
                  for(def in contents.split("\r").join("").split("\n"))
                  {
                     var equals = def.indexOf("=");
                     if (equals>0)
                     {
                        var name = def.substr(0,equals);
                        var value = def.substr(equals+1);
                        if (name=="hxcpp")
                        {
                           // Ignore
                        }
                        else if (name=="destination")
                            destination = value;
                        else
                           defines.set(name,value);
                     }
                  }
           }
           catch(e:Dynamic)
           {
              Log.error('Could not parse options file $path ($e)');
           }
      }

      Profile.setEntry("setup");
      Setup.initHXCPPConfig(defines);

      if (HXCPP=="" && env.exists("HXCPP"))
      {
         HXCPP = PathManager.standardize(env.get("HXCPP"));
         defines.set("HXCPP",HXCPP);
      }

      if (HXCPP=="")
      {
         if (!defines.exists("HXCPP"))
         {
            Log.error("Please run hxcpp using haxelib");
            //throw "HXCPP not set, and not run from haxelib";
         }
         HXCPP = PathManager.standardize(defines.get("HXCPP"));
         defines.set("HXCPP",HXCPP);
      }

      //Log.info("", "HXCPP : " + HXCPP);

      include_path.push(".");
      if (env.exists("HOME"))
        include_path.push(env.get("HOME"));
      if (env.exists("USERPROFILE"))
        include_path.push(env.get("USERPROFILE"));
      include_path.push(HXCPP);



      //trace(include_path);

      //var msvc = false;

      // Create alias...
      if (defines.exists("ios"))
      {
         if (defines.exists("simulator"))
            defines.set("iphonesim", "iphonesim");
         else if (!defines.exists ("iphonesim"))
            defines.set("iphoneos", "iphoneos");
         defines.set("iphone", "iphone");
      }

      if (defines.exists("tvos"))
      {
         if (defines.exists("simulator"))
            defines.set("appletvsim", "appletvsim");
         else if (!defines.exists ("appletvsim"))
            defines.set("appletvos", "appletvos");
         defines.set("appletv", "appletv");
      }



      if (makefile=="" || Log.verbose)
      {
         printBanner();
      }

      if (makefile=="")
      {
         printUsage();
      }
      else
      {
         Log.v('${BOLD}${YELLOW}Using makefile: $makefile${NORMAL}');
         Log.v('${BOLD}${YELLOW}Reading HXCPP config: ' + defines.get("HXCPP_CONFIG") + NORMAL);
         if (defines.exists("toolchain"))
            Log.v('${BOLD}{$YELLOW}Using target toolchain: ' + defines.get("toolchain") + NORMAL);
         else
            Log.v('${BOLD}${YELLOW}No specified toolchain${NORMAL}');
         if (Log.verbose) Log.println("");


         if (targets.length==0)
            targets.push("default");


         new BuildTool(makefile,defines,targets,include_path,dirtyList);
      }
   }


   static function printUsage()
   {
      Log.println('${YELLOW}Usage:${NORMAL}');
      Log.println(' ${BOLD}haxelib run hxcpp${NORMAL} file.xml ${ITALIC}${WHITE}[options]${NORMAL}');
      Log.println('   Build project from "file.xml".  options:');
      Log.println('    ${BOLD}-D${NORMAL}${ITALIC}value${NORMAL} -- Specify a define to use when processing other commands');
      Log.println('    ${BOLD}-verbose${NORMAL} -- Print additional information (when available)');
      Log.println('    ${BOLD}-dirty [groudId|all]${NORMAL} -- always rebuild files in given group');
      Log.println(' ${BOLD}haxelib run hxcpp${NORMAL} ${ITALIC}${WHITE}file.cppia${NORMAL}');
      Log.println('   Run cppia script using default Cppia host');
      Log.println(' ${BOLD}haxelib run hxcpp${NORMAL} ${ITALIC}${WHITE}file.js${NORMAL}');
      Log.println('    Run emscripten compiled scipt "file.js"');
      Log.println(' ${BOLD}haxelib run hxcpp${NORMAL} ${ITALIC}${WHITE}cache [command] [project]${NORMAL}');
      Log.println('   Perform command on cache, either on specific project or all. commands:');
      Log.println('    ${BOLD}clear${NORMAL} -- remove all files from cache');
      Log.println('    ${BOLD}days${NORMAL} #days -- remove files older than "days"');
      Log.println('    ${BOLD}resize${NORMAL} #megabytes -- Only keep #megabytes MB');
      Log.println('    ${BOLD}list${NORMAL} -- list cache usage');
      Log.println('    ${BOLD}details${NORMAL} -- list cache usage, per file');
      Log.println('');
   }


   static function printBanner()
   {
      Log.println("\x1b[33;1m __                          ");
      Log.println("/\\ \\                                      ");
      Log.println("\\ \\ \\___    __  _   ___   _____   _____   ");
      Log.println(" \\ \\  _ `\\ /\\ \\/'\\ /'___\\/\\ '__`\\/\\ '__`\\ ");
      Log.println("  \\ \\ \\ \\ \\\\/>  <//\\ \\__/\\ \\ \\L\\ \\ \\ \\L\\ \\");
      Log.println("   \\ \\_\\ \\_\\/\\_/\\_\\ \\____\\\\ \\ ,__/\\ \\ ,__/");
      Log.println("    \\/_/\\/_/\\//\\/_/\\/____/ \\ \\ \\/  \\ \\ \\/ ");
      Log.println("                            \\ \\_\\   \\ \\_\\ ");
      Log.println("                             \\/_/    \\/_/ \x1b[0m");
      Log.println("");
      Log.println("\x1b[1mhxcpp \x1b[0m\x1b[3;37m(Haxe C++ Runtime Support)\x1b[0m \x1b[1m(" + getVersion() + ")\x1b[0m");
      Log.println("");
   }

   function setDefaultToolchain(defines:Hash<String>)
   {
      if ( (new EReg("window","i")).match(os) )
         defines.set("windows_host","1");

      if (defines.exists("iphoneos"))
      {
         defines.set("toolchain","iphoneos");
         defines.set("iphone","iphone");
         defines.set("apple","apple");
         defines.set("BINDIR","iPhone");
      }
      else if (defines.exists("iphonesim"))
      {
         defines.set("toolchain","iphonesim");
         defines.set("iphone","iphone");
         defines.set("apple","apple");
         defines.set("BINDIR","iPhone");
      }
      else if (defines.exists("appletvos"))
      {
         defines.set("toolchain","appletvos");
         defines.set("appletv","appletv");
         defines.set("apple","apple");
         defines.set("BINDIR","AppleTV");
      }
      else if (defines.exists("appletvsim"))
      {
         defines.set("toolchain","appletvsim");
         defines.set("appletv","appletv");
         defines.set("apple","apple");
         defines.set("BINDIR","AppleTV");
      }
      else if (defines.exists("watchos"))
      {
         defines.set("toolchain","watchos");
         defines.set("apple","apple");
         defines.set("applewatch","applewatch");
         defines.set("BINDIR","watchos");
      }
      else if (defines.exists("watchsimulator"))
      {
         defines.set("toolchain","watchsimulator");
         defines.set("applewatch","applewatch");
         defines.set("apple","apple");
         defines.set("BINDIR","watchsimulator");
      }

      else if (defines.exists("android"))
      {
         defines.set("toolchain","android");
         defines.set("android","android");
         defines.set("BINDIR","Android");

         if (!defines.exists("ANDROID_HOST"))
         {
            if ( (new EReg("mac","i")).match(os) )
               defines.set("ANDROID_HOST","darwin-x86_64");
            else if ( (new EReg("window","i")).match(os) )
            {
               defines.set("windows_host","1");
               defines.set("ANDROID_HOST","windows");
            }
            else if ( (new EReg("linux","i")).match(os) )
               defines.set("ANDROID_HOST","linux-x86_64");
            else
            {
               Log.error ("Unknown android host \"" + os + "\"");
               //throw "Unknown android host:" + os;
            }
         }
      }
      else if (defines.exists("webos"))
      {
         defines.set("toolchain","webos");
         defines.set("webos","webos");
         defines.set("BINDIR","webOS");
      }
      else if (defines.exists("tizen"))
      {
         defines.set("toolchain","tizen");
         defines.set("tizen","tizen");
         defines.set("BINDIR","Tizen");
      }
      else if (defines.exists("blackberry"))
      {
         defines.set("toolchain", "blackberry");
         defines.set("blackberry","blackberry");
         defines.set("BINDIR","BlackBerry");
      }
      else if (defines.exists("emcc") || defines.exists("emscripten"))
      {
         defines.set("toolchain","emscripten");
         defines.set("emcc","emcc");
         defines.set("emscripten","emscripten");
         defines.set("BINDIR","Emscripten");
      }
      else if (defines.exists("gph"))
      {
         defines.set("toolchain","gph");
         defines.set("gph","gph");
         defines.set("BINDIR","GPH");
      }
      else if (defines.exists ("gcw0"))
      {
         defines.set ("toolchain", "gcw0");
         defines.set ("gcw0", "gcw0");
         defines.set ("BINDIR", "GCW0");
      }
      else if (defines.exists("cygwin") || defines.exists("HXCPP_CYGWIN"))
      {
         set64(defines,m64);
         defines.set("toolchain","cygwin");
         defines.set("cygwin","cygwin");
         defines.set("linux","linux");
         defines.set("BINDIR",m64 ? "Cygwin64":"Cygwin");
      }
      else if ( (new EReg("window","i")).match(os) )
      {
         defines.set("windows_host","1");
         // Cross-compile?
         if (defines.exists("rpi"))
         {
            defines.set("toolchain","linux");
            defines.set("xcompile","1");
            defines.set("linux","linux");
            defines.set("rpi","1");
            defines.set("hardfp","1");
            defines.set("BINDIR", "RPi");
         }
         else
         {
            set64(defines,m64,arm64);
            defines.set("windows","windows");
            defines.set("BINDIR",arm64 ? "WindowsArm64" : m64 ? "Windows64":"Windows");

            // Choose between MSVC and MINGW
            var useMsvc = true;

            if (defines.exists("mingw") || defines.exists("HXCPP_MINGW") || defines.exists("minimingw"))
               useMsvc = false;
            else if ( defines.exists("winrt") || defines.exists("HXCPP_MSVC_VER"))
               useMsvc = true;
            else
            {
                for(i in 8...24)
                {
                   if (Sys.getEnv("VS" + i + "0COMNTOOLS")!=null)
                   {
                      useMsvc = true;
                      break;
                   }
                }

                Log.v("Using Windows compiler: " + (useMsvc ? "MSVC" : "MinGW") );
            }

            if (useMsvc)
            {
               defines.set("toolchain","msvc");
               if ( defines.exists("winrt") )
                  defines.set("BINDIR",m64 ? "WinRT64":"WinRT");
            }
            else
            {
               defines.set("toolchain","mingw");
               defines.set("mingw","mingw");
            }
         }
      }
      else if ( isRPi )
      {
         defines.set("toolchain","linux");
         defines.set("linux","linux");
         defines.set("rpi","1");
         defines.set("hardfp","1");
         defines.set("BINDIR", "RPi");
      }
      else if ( (new EReg("linux","i")).match(os) )
      {
         set64(defines,m64,arm64);
         // Cross-compile?
         if(defines.exists("windows"))
         {
            defines.set("toolchain","mingw");
            defines.set("mingw", "mingw");
            defines.set("xcompile","1");
            defines.set("BINDIR", arm64 ? "WindowsArm64" : m64 ? "Windows64":"Windows");
         }
         else
         {
            defines.set("toolchain","linux");
            defines.set("linux","linux");

            if (defines.exists("HXCPP_LINUX_ARMV7"))
            {
               defines.set("noM32","1");
               defines.set("noM64","1");
               defines.set("HXCPP_ARMV7","1");
               m64 = false;
            }
            else if (arm64 || defines.exists("HXCPP_LINUX_ARM64"))
            {
               defines.set("noM32","1");
               defines.set("noM64","1");
               defines.set("HXCPP_ARM64","1");
               m64 = true;
            }
            defines.set("BINDIR", arm64 ? "LinuxArm64" : m64 ? "Linux64":"Linux");
         }
      }
      else if ( (new EReg("mac","i")).match(os) )
      {
         set64(defines,m64, arm64);
         // Cross-compile?
         if (defines.exists("linux"))
         {
            defines.set("mac_host","1");
            defines.set("linux","linux");
            defines.set("toolchain","linux");
            defines.set("xcompile","1");
            defines.set("BINDIR", arm64 ? "LinuxArm64" : m64 ? "Linux64":"Linux");
         }
         else
         {
            defines.set("toolchain","mac");
            defines.set("macos","macos");
            defines.set("apple","apple");
            defines.set("BINDIR", arm64 ? "MacArm64" : m64 ? "Mac64":"Mac");
         }
      }
   }



   function setupAppleDirectories(defines:Hash<String>)
   {
      if (defines.exists("HXCPP_CLEAN_ONLY"))
         return;

      if (defines.exists("apple") && !defines.exists("DEVELOPER_DIR"))
      {
         var developer_dir = ProcessManager.runProcessLine("", "xcode-select", ["--print-path"], true, false);
         if (developer_dir == null || developer_dir == "" || developer_dir.indexOf ("Run xcode-select") > -1)
            developer_dir = "/Applications/Xcode.app/Contents/Developer";
         if (developer_dir == "/Developer")
            defines.set("LEGACY_XCODE_LOCATION","1");
         defines.set("DEVELOPER_DIR",developer_dir);
      }

      if (defines.exists("iphone") && !defines.exists("IPHONE_VER"))
      {
         var dev_path = defines.get("DEVELOPER_DIR") + "/Platforms/iPhoneOS.platform/Developer/SDKs/";
         if (FileSystem.exists(dev_path))
         {
            var best="0.0";
            var files = FileSystem.readDirectory(dev_path);
            var extract_version = ~/^iPhoneOS(.*).sdk$/;
            for(file in files)
            {
               if (extract_version.match(file))
               {
                  var ver = extract_version.matched(1);
                  if (Std.parseFloat (ver)>Std.parseFloat (best))
                     best = ver;
               }
            }
            if (best!="0.0")
               defines.set("IPHONE_VER",best);
         }
      }

      if (defines.exists("appletv") && !defines.exists("TVOS_VER"))
      {
         var dev_path = defines.get("DEVELOPER_DIR") + "/Platforms/AppleTVOS.platform/Developer/SDKs/";
         if (FileSystem.exists(dev_path))
         {
            var best="0.0";
            var files = FileSystem.readDirectory(dev_path);
            var extract_version = ~/^AppleTVOS(.*).sdk$/;
            for(file in files)
            {
               if (extract_version.match(file))
               {
                  var ver = extract_version.matched(1);
                  if (Std.parseFloat (ver)>Std.parseFloat (best))
                     best = ver;
               }
            }
            if (best!="0.0")
               defines.set("TVOS_VER",best);
         }
      }


      if (defines.exists("applewatch") && !defines.exists("WATCHOS_VER"))
      {
         var dev_path = defines.get("DEVELOPER_DIR") + "/Platforms/WatchOS.platform/Developer/SDKs/";
         if (FileSystem.exists(dev_path))
         {
            var best="0.0";
            var files = FileSystem.readDirectory(dev_path);
            var extract_version = ~/^WatchOS(.*).sdk$/;
            for(file in files)
            {
               if (extract_version.match(file))
               {
                  var ver = extract_version.matched(1);
                  if (Std.parseFloat (ver)>Std.parseFloat (best))
                     best = ver;
               }
            }
            if (best!="0.0")
               defines.set("WATCHOS_VER",best);
         }
      }


      if (defines.exists("macos") && !defines.exists("MACOSX_VER"))
      {
         var dev_path = defines.get("DEVELOPER_DIR") + "/Platforms/MacOSX.platform/Developer/SDKs/";
         if (FileSystem.exists(dev_path))
         {
            var best="0.0";
            var files = FileSystem.readDirectory(dev_path);
            var extract_version = ~/^MacOSX(.*).sdk$/;
            for(file in files)
            {
               if (extract_version.match(file))
               {
                  var ver = extract_version.matched(1);
                  var split_ver = ver.split(".");
                  var major_ver = Std.parseFloat(split_ver[0]);
                  var minor_ver = Std.parseFloat(split_ver[1]);
                  if (Math.isNaN(major_ver) || Math.isNaN(minor_ver))
                  {
                     // if version is the wrong format, skip it
                     continue;
                  }
                  var split_best = best.split(".");
                  var major_best = Std.parseFloat(split_best[0]);
                  var minor_best = Std.parseFloat(split_best[1]);
                  if (Math.isNaN(major_best) || Math.isNaN(minor_best))
                  {
                     // shouldn't happen, but just to be safe
                     best = ver;
                  }
                  else if (major_ver > major_best)
                  {
                     // prefer higher major version
                     best = ver;
                  }
                  else if (major_ver == major_best && minor_ver > minor_best)
                  {
                     // if major versions are equal, prefer higher minor version
                     best = ver;
                  }
               }
            }
            if (best!="0.0")
               defines.set("MACOSX_VER",best);
            else
               Log.v("Could not find MACOSX_VER!");
         }
      }

      if (!FileSystem.exists(defines.get("DEVELOPER_DIR") + "/Platforms/MacOSX.platform/Developer/SDKs/"))
      {
         defines.set("LEGACY_MACOSX_SDK","1");
      }
   }

   function dumpDefs()
   {
      Sys.println("Defines:");
      for(k in mDefines.keys())
         Sys.println('  $k=${mDefines.get(k)}');
   }

   function parseXML(inXML:XmlAccess,inSection:String, forceRelative:Bool)
   {
      for(el in inXML.elements)
      {
         if (valid(el,inSection))
         {
            switch(el.name)
            {
               case "set" :
                  if (el.has.name)
                  {
                     var name = substitute(el.att.name);
                     var value = substitute(el.att.value);
                     mDefines.set(name,value);
                  }
                  else
                     dumpDefs();
               case "unset" :
                  var name = substitute(el.att.name);
                  mDefines.remove(name);
               case "setup" :
                  var name = substitute(el.att.name);
                  Setup.setup(name,mDefines);
               case "echo" :
                  Log.info(substitute(el.att.value));
               case "setenv" :
                  var name = substitute(el.att.name);
                  var value = substitute(el.att.value);
                  mDefines.set(name,value);
                  Sys.putEnv(name,value);
               case "error" :
                  var error = substitute(el.att.value);
                  Log.error(error);
               case "path" :
                  var path = substitute(el.att.name);
                  Log.info("", " - \x1b[1mAdding path:\x1b[0m " + path);
                  var sep = mDefines.exists("windows_host") ? ";" : ":";
                  var add = path + sep + Sys.getEnv("PATH");
                  Sys.putEnv("PATH", add);
                  //trace(Sys.getEnv("PATH"));
               case "compiler" :
                  mCompiler = createCompiler(el,mCompiler);

               case "stripper" :
                  mStripper = createStripper(el,mStripper);
               case "manifest" :
                  mManifester = createManifester(el,mManifester);
               case "prelinker" :
                  var name = substitute(el.att.id);
                  if (mPrelinkers.exists(name))
                     createPrelinker(el,mPrelinkers.get(name));
                  else
                     mPrelinkers.set(name, createPrelinker(el,null) );
               case "linker" :
                  var name = substitute(el.att.id);
                  if (mLinkers.exists(name))
                     createLinker(el,mLinkers.get(name));
                  else
                     mLinkers.set(name, createLinker(el,null) );
               case "files" :
                  var name = substitute(el.att.id);
                  var tags = el.has.tags ? substitute(el.att.tags) : null;
                  if (mFileGroups.exists(name) )
                     createFileGroup(el, mFileGroups.get(name), name, false, tags);
                  else
                     mFileGroups.set(name,createFileGroup(el,null,name, forceRelative,tags));
               case "include", "import" :
                  var name = substitute(el.att.name);
                  var section = el.has.section ? substitute(el.att.section) : "";
                  include(name, section, el.has.noerror, el.name=="import" );
               case "target" :
                  var name = substitute(el.att.id);
                  var overwrite = name=="default";
                  if (el.has.overwrite)
                     overwrite = true;
                  if (el.has.append)
                     overwrite = false;
                  if (mTargets.exists(name) && !overwrite)
                     createTarget(el,mTargets.get(name), forceRelative);
                  else
                     mTargets.set( name, createTarget(el,null, forceRelative) );

               case "mkdir" :
                  var name = substitute(el.att.name);
                  try {
                     PathManager.mkdir(name);
                  } catch(e:Dynamic)
                  {
                     Log.error("Could not create directory " + name );
                  }


               case "copy" :
                   var from = substitute(el.att.from);
                   from = PathManager.combine( Path.directory(mCurrentIncludeFile), from );
                   var to = substitute(el.att.to);
                   to = PathManager.combine( Path.directory(mCurrentIncludeFile), to );
                   copy(from,to);

               case "copyFile" :
                  mCopyFiles.push(
                      new CopyFile(substitute(el.att.name),
                                   substitute(el.att.from),
                                   el.has.allowMissing ?  subBool(el.att.allowMissing) : false,
                                   el.has.overwrite ? substitute(el.att.overwrite) : Overwrite.ALWAYS,
                                   el.has.toolId ?  substitute(el.att.toolId) : null ) );
               case "section" :
                  parseXML(el,"",forceRelative);

               case "pleaseUpdateHxcppTool" :
                  checkToolVersion( substitute(el.att.version) );

               case "magiclib" :
                  mMagicLibs.push( {name: substitute(el.att.name),
                                    replace:substitute(el.att.replace) } );
               case "nvccflag" :
                  if (el.has.name)
                     mNvccFlags.push( substitute(el.att.name) );
                  mNvccFlags.push( substitute(el.att.value) );

               case "nvcclinkflag" :
                  if (el.has.name)
                     mNvccLinkFlags.push( substitute(el.att.name) );
                  mNvccLinkFlags.push( substitute(el.att.value) );

               case "pragma" :
                  if (el.has.once)
                     mPragmaOnce.set(mCurrentIncludeFile, parseBool(substitute(el.att.once)));
            }
         }
      }
   }

   public function checkToolVersion(inVersion:String)
   {
      var ver = Std.parseInt(inVersion);
      if (ver>7)
         Log.error("Your version of hxcpp.n is out-of-date.  Please update by compiling 'haxe compile.hxml' in hxcpp/tools/hxcpp.");
   }

   public function resolvePath(inPath:String)
   {
      return PathManager.combine( mCurrentIncludeFile=="" ? Sys.getCwd() : Path.directory(mCurrentIncludeFile),
           inPath);
   }

   public function include(inName:String, inSection:String="", inAllowMissing:Bool = false, forceRelative=false)
   {
      var full_name = findIncludeFile(inName);
      if (full_name!="")
      {
         if (mPragmaOnce.get(full_name))
            return;

         pushFile(full_name, "include", inSection);
         // TODO - use mFileStack?
         var oldInclude = mCurrentIncludeFile;
         mCurrentIncludeFile = full_name;

         var make_contents = sys.io.File.getContent(full_name);
         var xml_slow = Xml.parse(make_contents);

         Profile.push( haxe.io.Path.withoutDirectory(inName) );
         parseXML(new XmlAccess(xml_slow.firstElement()),inSection, forceRelative);
         Profile.pop();

         mCurrentIncludeFile = oldInclude;
         popFile();
      }
      else if (!inAllowMissing)
      {
         Log.error("Could not find include file \"" + inName + "\"");
         //throw "Could not find include file " + name;
      }
   }



   static function set64(outDefines:Hash<String>, in64:Bool,isArm64=false)
   {
      if (isArm64)
      {
         outDefines.set("HXCPP_ARM64","1");
         outDefines.set("HXCPP_M64","1");
         outDefines.remove("HXCPP_32");
      }
      else if (in64)
      {
         outDefines.set("HXCPP_M64","1");
         outDefines.remove("HXCPP_32");
         outDefines.remove("HXCPP_ARM64");
      }
      else
      {
         outDefines.set("HXCPP_M32","1");
         outDefines.remove("HXCPP_M64");
         outDefines.remove("HXCPP_ARM64");
      }
   }

   public function dospath(path:String) : String
   {
      if (mDefines.exists("windows_host"))
      {
         path = path.split("\\").join("/");
         var filename = "";
         var parts = path.split("/");
         if (!FileSystem.exists(path))
            Log.error("File does not exist:" + path);
         if (!FileSystem.isDirectory(path))
            filename = parts.pop();

         var oldDir = Sys.getCwd();
         var output = "";
         var err = "";
         Sys.setCwd(parts.join("\\"));
         try {
            var bat = '$HXCPP/toolchain/dospath.bat'.split("/").join("\\");
            var process = new Process("cmd",["/c",bat]);
            output = process.stdout.readAll().toString();
            output = output.split("\r")[0].split("\n")[0];
            err  = process.stderr.readAll().toString();
            process.close();
         } catch (e:Dynamic) { Log.error(e); }
         Sys.setCwd(oldDir);

         if (output=="")
            Log.error("Could not find dos path for " + path + " " + err);
         return output + "\\" + filename;
      }

      return path;
   }

   public function substitute(str:String,needDollar=true):String
   {
      var match = needDollar ? mVarMatch : mNoDollarMatch;
      while( match.match(str) )
      {
         var sub = match.matched(1);
         if (sub.startsWith("haxelib:"))
         {
            sub = PathManager.getHaxelib(sub.substr(8));
            sub = PathManager.standardize(sub);
         }
         else if (sub.startsWith("removeQuotes:"))
         {
            sub = mDefines.get(sub.substr(13));
            var len = sub.length;
            if (len>1 && sub.substr(0,1)=="\"" && sub.substr(len-1)=="\"")
               sub = sub.substr(1,len-2);
         }
         else if (sub.startsWith("dospath:") )
         {
            sub = dospath( mDefines.get(sub.substr(8)) );
         }
         else if (sub.startsWith("dir:") )
         {
            sub = dospath( mDefines.get(sub.substr(4)) );
            if (!FileSystem.isDirectory(sub))
            {
               sub = haxe.io.Path.directory(sub);
            }
         }
         else if (sub=="this_dir")
         {
            sub = Path.normalize(mCurrentIncludeFile=="" ? Sys.getCwd() :  Path.directory(mCurrentIncludeFile));
         }
         else
            sub = mDefines.get(sub);

         if (sub==null) sub="";
         str = match.matchedLeft() + sub + match.matchedRight();
      }

      return str;
   }

   public function subBool(str:String):Bool
   {
      var result = substitute(str);
      return result=="t" || result=="true" || result=="1";
   }

   public function valid(inEl:XmlAccess,inSection:String):Bool
   {
      if (inEl.x.get("if") != null)
      {
         var value = inEl.x.get("if");
         var optionalDefines = value.split("||");
         var matchOptional = false;
         for (optional in optionalDefines)
         {
            var requiredDefines = optional.split(" ");
            var matchRequired = true;
            for (required in requiredDefines)
            {
               var check = StringTools.trim(required);
               if (check != "" && !defined(check))
               {
                  matchRequired = false;
               }
            }
            if (matchRequired)
            {
               matchOptional = true;
            }
         }
         if (optionalDefines.length > 0 && !matchOptional)
         {
            return false;
         }
      }

      if (inEl.has.unless)
      {
         var value = substitute(inEl.att.unless);
         var optionalDefines = value.split("||");
         var matchOptional = false;
         for (optional in optionalDefines)
         {
            var requiredDefines = optional.split(" ");
            var matchRequired = true;
            for (required in requiredDefines)
            {
               var check = StringTools.trim(required);
               if (check != "" && !defined(check))
               {
                  matchRequired = false;
               }
            }
            if (matchRequired)
            {
               matchOptional = true;
            }
         }
         if (optionalDefines.length > 0 && matchOptional)
         {
            return false;
         }
      }

      if (inEl.has.unlessApi)
      {
         var value = substitute(inEl.att.unlessApi);
         try {
            var val = Std.parseInt(value);
            if (val<=SupportedVersion)
               return false;
         } catch(e:Dynamic) { }
      }


      if (inEl.has.ifExists)
         if (!FileSystem.exists( substitute(inEl.att.ifExists) )) return false;

      if (inSection!="")
      {
         if (inEl.name!="section")
            return false;
         if (!inEl.has.id)
            return false;
         if (inEl.att.id!=inSection)
            return false;
      }

      return true;
   }
}