1228 lines
26 KiB
Haxe
1228 lines
26 KiB
Haxe
package project;
|
|
|
|
|
|
import haxe.io.Path;
|
|
import haxe.Json;
|
|
import haxe.Serializer;
|
|
import haxe.Unserializer;
|
|
import helpers.ArrayHelper;
|
|
import helpers.CompatibilityHelper;
|
|
import helpers.LogHelper;
|
|
import helpers.ObjectHelper;
|
|
import helpers.PathHelper;
|
|
import helpers.PlatformHelper;
|
|
import helpers.StringHelper;
|
|
import helpers.StringMapHelper;
|
|
import project.AssetType;
|
|
import sys.FileSystem;
|
|
import sys.io.File;
|
|
|
|
#if (lime && !lime_legacy)
|
|
import helpers.FileHelper;
|
|
import helpers.ProcessHelper;
|
|
import lime.graphics.Font;
|
|
import sys.io.Process;
|
|
@:access(lime.graphics.Font)
|
|
#end
|
|
|
|
|
|
class HXProject {
|
|
|
|
|
|
public var app:ApplicationData;
|
|
public var architectures:Array <Architecture>;
|
|
public var assets:Array <Asset>;
|
|
public var certificate:Keystore;
|
|
public var command:String;
|
|
public var config:ConfigData;
|
|
public var debug:Bool;
|
|
public var defines:Map <String, Dynamic>;
|
|
public var dependencies:Array <Dependency>;
|
|
public var environment:Map <String, String>;
|
|
public var haxedefs:Map <String, Dynamic>;
|
|
public var haxeflags:Array <String>;
|
|
public var haxelibs:Array <Haxelib>;
|
|
public var host (get_host, null):Platform;
|
|
public var icons:Array <Icon>;
|
|
public var javaPaths:Array <String>;
|
|
public var libraries:Array <Library>;
|
|
public var libraryHandlers:Map <String, String>;
|
|
public var meta:MetaData;
|
|
public var ndlls:Array <NDLL>;
|
|
public var platformType:PlatformType;
|
|
public var samplePaths:Array <String>;
|
|
public var sources:Array <String>;
|
|
public var splashScreens:Array <SplashScreen>;
|
|
public var target:Platform;
|
|
public var targetFlags:Map <String, String>;
|
|
public var targetHandlers:Map <String, String>;
|
|
public var templateContext (get_templateContext, null):Dynamic;
|
|
public var templatePaths:Array <String>;
|
|
@:isVar public var window (get, set):Window;
|
|
public var windows:Array <Window>;
|
|
|
|
private var defaultApp:ApplicationData;
|
|
private var defaultMeta:MetaData;
|
|
private var defaultWindow:Window;
|
|
|
|
public static var _command:String;
|
|
public static var _debug:Bool;
|
|
public static var _target:Platform;
|
|
public static var _targetFlags:Map <String, String>;
|
|
public static var _templatePaths:Array <String>;
|
|
|
|
private static var initialized:Bool;
|
|
|
|
|
|
public static function main () {
|
|
|
|
var args = Sys.args ();
|
|
|
|
if (args.length < 7) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
HXProject._command = args[0];
|
|
HXProject._target = cast args[2];
|
|
HXProject._debug = (args[3] == "true");
|
|
HXProject._targetFlags = Unserializer.run (args[4]);
|
|
HXProject._templatePaths = Unserializer.run (args[5]);
|
|
|
|
initialize ();
|
|
|
|
var classRef = Type.resolveClass (args[1]);
|
|
var instance = Type.createInstance (classRef, []);
|
|
|
|
var serializer = new Serializer ();
|
|
serializer.useCache = true;
|
|
serializer.serialize (instance);
|
|
|
|
File.saveContent (args[6], serializer.toString ());
|
|
|
|
}
|
|
|
|
|
|
public function new () {
|
|
|
|
initialize ();
|
|
|
|
command = _command;
|
|
config = new ConfigData ();
|
|
debug = _debug;
|
|
target = _target;
|
|
targetFlags = StringMapHelper.copy (_targetFlags);
|
|
templatePaths = _templatePaths.copy ();
|
|
|
|
defaultMeta = { title: "MyApplication", description: "", packageName: "com.example.myapp", version: "1.0.0", company: "Example, Inc.", companyUrl: "", buildNumber: "1", companyId: "" }
|
|
defaultApp = { main: "Main", file: "MyApplication", path: "bin", preloader: "", swfVersion: 11.2, url: "", init: null }
|
|
defaultWindow = { width: 800, height: 600, parameters: "{}", background: 0xFFFFFF, fps: 30, hardware: true, display: 0, resizable: true, borderless: false, orientation: Orientation.AUTO, vsync: false, fullscreen: false, antialiasing: 0, allowShaders: true, requireShaders: false, depthBuffer: false, stencilBuffer: false }
|
|
|
|
platformType = PlatformType.DESKTOP;
|
|
architectures = [];
|
|
|
|
switch (target) {
|
|
|
|
case FLASH:
|
|
|
|
platformType = PlatformType.WEB;
|
|
architectures = [];
|
|
|
|
case HTML5, FIREFOX, EMSCRIPTEN:
|
|
|
|
platformType = PlatformType.WEB;
|
|
architectures = [];
|
|
|
|
defaultWindow.width = 0;
|
|
defaultWindow.height = 0;
|
|
defaultWindow.fps = 0;
|
|
|
|
case ANDROID, BLACKBERRY, IOS, TIZEN, WEBOS:
|
|
|
|
platformType = PlatformType.MOBILE;
|
|
|
|
if (target == Platform.IOS) {
|
|
|
|
architectures = [ Architecture.ARMV7, Architecture.ARM64 ];
|
|
|
|
} else if (target == Platform.ANDROID) {
|
|
|
|
architectures = [ Architecture.ARMV7 ];
|
|
|
|
} else {
|
|
|
|
architectures = [ Architecture.ARMV6 ];
|
|
|
|
}
|
|
|
|
defaultWindow.width = 0;
|
|
defaultWindow.height = 0;
|
|
defaultWindow.fullscreen = true;
|
|
defaultWindow.requireShaders = true;
|
|
|
|
case WINDOWS, MAC, LINUX:
|
|
|
|
platformType = PlatformType.DESKTOP;
|
|
|
|
if (target == Platform.LINUX || target == Platform.MAC) {
|
|
|
|
architectures = [ PlatformHelper.hostArchitecture ];
|
|
|
|
} else {
|
|
|
|
architectures = [ Architecture.X86 ];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
meta = ObjectHelper.copyFields (defaultMeta, {});
|
|
app = ObjectHelper.copyFields (defaultApp, {});
|
|
window = ObjectHelper.copyFields (defaultWindow, {});
|
|
windows = [ window ];
|
|
assets = new Array <Asset> ();
|
|
defines = new Map <String, Dynamic> ();
|
|
dependencies = new Array <Dependency> ();
|
|
environment = Sys.environment ();
|
|
haxedefs = new Map <String, Dynamic> ();
|
|
haxeflags = new Array <String> ();
|
|
haxelibs = new Array <Haxelib> ();
|
|
icons = new Array <Icon> ();
|
|
javaPaths = new Array <String> ();
|
|
libraries = new Array <Library> ();
|
|
libraryHandlers = new Map <String, String> ();
|
|
ndlls = new Array <NDLL> ();
|
|
sources = new Array <String> ();
|
|
samplePaths = new Array <String> ();
|
|
splashScreens = new Array <SplashScreen> ();
|
|
targetHandlers = new Map <String, String> ();
|
|
|
|
}
|
|
|
|
|
|
public function clone ():HXProject {
|
|
|
|
var project = new HXProject ();
|
|
|
|
ObjectHelper.copyFields (app, project.app);
|
|
project.architectures = architectures.copy ();
|
|
project.assets = assets.copy ();
|
|
|
|
for (i in 0...assets.length) {
|
|
|
|
project.assets[i] = assets[i].clone ();
|
|
|
|
}
|
|
|
|
if (certificate != null) {
|
|
|
|
project.certificate = certificate.clone ();
|
|
|
|
}
|
|
|
|
project.command = command;
|
|
project.config = config.clone ();
|
|
project.debug = debug;
|
|
|
|
for (key in defines.keys ()) {
|
|
|
|
project.defines.set (key, defines.get (key));
|
|
|
|
}
|
|
|
|
for (dependency in dependencies) {
|
|
|
|
project.dependencies.push (dependency.clone ());
|
|
|
|
}
|
|
|
|
for (key in environment.keys ()) {
|
|
|
|
project.environment.set (key, environment.get (key));
|
|
|
|
}
|
|
|
|
for (key in haxedefs.keys ()) {
|
|
|
|
project.haxedefs.set (key, haxedefs.get (key));
|
|
|
|
}
|
|
|
|
project.haxeflags = haxeflags.copy ();
|
|
|
|
for (haxelib in haxelibs) {
|
|
|
|
project.haxelibs.push (haxelib.clone ());
|
|
|
|
}
|
|
|
|
for (icon in icons) {
|
|
|
|
project.icons.push (icon.clone ());
|
|
|
|
}
|
|
|
|
project.javaPaths = javaPaths.copy ();
|
|
|
|
for (library in libraries) {
|
|
|
|
project.libraries.push (library.clone ());
|
|
|
|
}
|
|
|
|
for (key in libraryHandlers.keys ()) {
|
|
|
|
project.libraryHandlers.set (key, libraryHandlers.get (key));
|
|
|
|
}
|
|
|
|
ObjectHelper.copyFields (meta, project.meta);
|
|
|
|
for (ndll in ndlls) {
|
|
|
|
project.ndlls.push (ndll.clone ());
|
|
|
|
}
|
|
|
|
project.platformType = platformType;
|
|
project.samplePaths = samplePaths.copy ();
|
|
project.sources = sources.copy ();
|
|
|
|
for (splashScreen in splashScreens) {
|
|
|
|
project.splashScreens.push (splashScreen.clone ());
|
|
|
|
}
|
|
|
|
project.target = target;
|
|
|
|
for (key in targetFlags.keys ()) {
|
|
|
|
project.targetFlags.set (key, targetFlags.get (key));
|
|
|
|
}
|
|
|
|
for (key in targetHandlers.keys ()) {
|
|
|
|
project.targetHandlers.set (key, targetHandlers.get (key));
|
|
|
|
}
|
|
|
|
project.templatePaths = templatePaths.copy ();
|
|
|
|
for (i in 0...windows.length) {
|
|
|
|
project.windows[i] = (ObjectHelper.copyFields (windows[i], {}));
|
|
|
|
}
|
|
|
|
return project;
|
|
|
|
}
|
|
|
|
|
|
private function filter (text:String, include:Array <String> = null, exclude:Array <String> = null):Bool {
|
|
|
|
if (include == null) {
|
|
|
|
include = [ "*" ];
|
|
|
|
}
|
|
|
|
if (exclude == null) {
|
|
|
|
exclude = [];
|
|
|
|
}
|
|
|
|
for (filter in exclude) {
|
|
|
|
if (filter != "") {
|
|
|
|
filter = StringTools.replace (filter, ".", "\\.");
|
|
filter = StringTools.replace (filter, "*", ".*");
|
|
|
|
var regexp = new EReg ("^" + filter, "i");
|
|
|
|
if (regexp.match (text)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (filter in include) {
|
|
|
|
if (filter != "") {
|
|
|
|
filter = StringTools.replace (filter, ".", "\\.");
|
|
filter = StringTools.replace (filter, "*", ".*");
|
|
|
|
var regexp = new EReg ("^" + filter, "i");
|
|
|
|
if (regexp.match (text)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
#if (lime && !lime_legacy)
|
|
|
|
public static function fromFile (projectFile:String, userDefines:Map <String, Dynamic> = null, includePaths:Array <String> = null):HXProject {
|
|
|
|
var project:HXProject = null;
|
|
|
|
var path = FileSystem.fullPath (Path.withoutDirectory (projectFile));
|
|
var name = Path.withoutDirectory (Path.withoutExtension (projectFile));
|
|
name = name.substr (0, 1).toUpperCase () + name.substr (1);
|
|
|
|
var tempDirectory = PathHelper.getTemporaryDirectory ();
|
|
var classFile = PathHelper.combine (tempDirectory, name + ".hx");
|
|
var nekoOutput = PathHelper.combine (tempDirectory, name + ".n");
|
|
var temporaryFile = PathHelper.combine (tempDirectory, "output.dat");
|
|
|
|
FileHelper.copyFile (path, classFile);
|
|
|
|
ProcessHelper.runCommand ("", "haxe", [ name, "-main", "project.HXProject", "-cp", tempDirectory, "-neko", nekoOutput, "-cp", PathHelper.combine (PathHelper.getHaxelib (new Haxelib ("lime")), "tools"), "-lib", "lime" ]);
|
|
ProcessHelper.runCommand ("", "neko", [ FileSystem.fullPath (nekoOutput), HXProject._command, name, Std.string (HXProject._target), Std.string (HXProject._debug), Serializer.run (HXProject._targetFlags), Serializer.run (HXProject._templatePaths), temporaryFile ]);
|
|
|
|
try {
|
|
|
|
var outputPath = PathHelper.combine (tempDirectory, "output.dat");
|
|
|
|
if (FileSystem.exists (outputPath)) {
|
|
|
|
var output = File.getContent (outputPath);
|
|
var unserializer = new Unserializer (output);
|
|
unserializer.setResolver (cast { resolveEnum: Type.resolveEnum, resolveClass: resolveClass });
|
|
project = unserializer.unserialize ();
|
|
|
|
}
|
|
|
|
} catch (e:Dynamic) {}
|
|
|
|
PathHelper.removeDirectory (tempDirectory);
|
|
|
|
if (project != null) {
|
|
|
|
var defines = StringMapHelper.copy (userDefines);
|
|
StringMapHelper.copyKeys (project.defines, defines);
|
|
|
|
processHaxelibs (project, defines);
|
|
|
|
}
|
|
|
|
return project;
|
|
|
|
}
|
|
|
|
|
|
public static function fromHaxelib (haxelib:Haxelib, userDefines:Map <String, Dynamic> = null, clearCache:Bool = false):HXProject {
|
|
|
|
if (haxelib.name == null || haxelib.name == "") {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
var path = PathHelper.getHaxelib (haxelib, false, clearCache);
|
|
|
|
if (path == null || path == "") {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
return HXProject.fromPath (path, userDefines);
|
|
|
|
}
|
|
|
|
|
|
public static function fromPath (path:String, userDefines:Map <String, Dynamic> = null):HXProject {
|
|
|
|
if (!FileSystem.exists (path) || !FileSystem.isDirectory (path)) {
|
|
|
|
Sys.println (":(");
|
|
return null;
|
|
|
|
}
|
|
|
|
var files = [ "include.lime", "include.nmml", "include.xml" ];
|
|
var projectFile = null;
|
|
|
|
for (file in files) {
|
|
|
|
if (projectFile == null && FileSystem.exists (PathHelper.combine (path, file))) {
|
|
|
|
projectFile = PathHelper.combine (path, file);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (projectFile != null) {
|
|
|
|
var project = new ProjectXMLParser (projectFile, userDefines);
|
|
|
|
if (project.config.get ("project.rebuild.path") == null) {
|
|
|
|
project.config.set ("project.rebuild.path", PathHelper.combine (path, "project"));
|
|
|
|
}
|
|
|
|
return project;
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
#end
|
|
|
|
|
|
private function getHaxelibVersion (haxelib:Haxelib):String {
|
|
|
|
var version = haxelib.version;
|
|
|
|
if (version == "" || version == null) {
|
|
|
|
var haxelibPath = PathHelper.getHaxelib (haxelib);
|
|
var jsonPath = PathHelper.combine (haxelibPath, "haxelib.json");
|
|
|
|
try {
|
|
|
|
if (FileSystem.exists (jsonPath)) {
|
|
|
|
var json = Json.parse (File.getContent (jsonPath));
|
|
version = json.version;
|
|
|
|
}
|
|
|
|
} catch (e:Dynamic) {}
|
|
|
|
}
|
|
|
|
return version;
|
|
|
|
}
|
|
|
|
|
|
public function include (path:String):Void {
|
|
|
|
// extend project file somehow?
|
|
|
|
}
|
|
|
|
|
|
public function includeAssets (path:String, rename:String = null, include:Array <String> = null, exclude:Array <String> = null):Void {
|
|
|
|
if (include == null) {
|
|
|
|
include = [ "*" ];
|
|
|
|
}
|
|
|
|
if (exclude == null) {
|
|
|
|
exclude = [];
|
|
|
|
}
|
|
|
|
exclude = exclude.concat ([ ".*", "cvs", "thumbs.db", "desktop.ini", "*.hash" ]);
|
|
|
|
if (path == "") {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
var targetPath = "";
|
|
|
|
if (rename != null) {
|
|
|
|
targetPath = rename;
|
|
|
|
} else {
|
|
|
|
targetPath = path;
|
|
|
|
}
|
|
|
|
if (!FileSystem.exists (path)) {
|
|
|
|
LogHelper.error ("Could not find asset path \"" + path + "\"");
|
|
return;
|
|
|
|
}
|
|
|
|
var files = FileSystem.readDirectory (path);
|
|
|
|
if (targetPath != "") {
|
|
|
|
targetPath += "/";
|
|
|
|
}
|
|
|
|
for (file in files) {
|
|
|
|
if (FileSystem.isDirectory (path + "/" + file)) {
|
|
|
|
if (filter (file, [ "*" ], exclude)) {
|
|
|
|
includeAssets (path + "/" + file, targetPath + file, include, exclude);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (filter (file, include, exclude)) {
|
|
|
|
assets.push (new Asset (path + "/" + file, targetPath + file));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
private static function initialize ():Void {
|
|
|
|
if (!initialized) {
|
|
|
|
if (_target == null) {
|
|
|
|
_target = PlatformHelper.hostPlatform;
|
|
|
|
}
|
|
|
|
if (_targetFlags == null) {
|
|
|
|
_targetFlags = new Map <String, String> ();
|
|
|
|
}
|
|
|
|
if (_templatePaths == null) {
|
|
|
|
_templatePaths = new Array <String> ();
|
|
|
|
}
|
|
|
|
initialized = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
public function merge (project:HXProject):Void {
|
|
|
|
if (project != null) {
|
|
|
|
ObjectHelper.copyUniqueFields (project.meta, meta, project.defaultMeta);
|
|
ObjectHelper.copyUniqueFields (project.app, app, project.defaultApp);
|
|
|
|
for (i in 0...project.windows.length) {
|
|
|
|
if (i < windows.length) {
|
|
|
|
ObjectHelper.copyUniqueFields (project.windows[i], windows[i], project.defaultWindow);
|
|
|
|
} else {
|
|
|
|
windows.push (ObjectHelper.copyFields (project.windows[i], {}));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
StringMapHelper.copyUniqueKeys (project.defines, defines);
|
|
StringMapHelper.copyUniqueKeys (project.environment, environment);
|
|
StringMapHelper.copyUniqueKeys (project.haxedefs, haxedefs);
|
|
StringMapHelper.copyUniqueKeys (project.libraryHandlers, libraryHandlers);
|
|
StringMapHelper.copyUniqueKeys (project.targetHandlers, targetHandlers);
|
|
|
|
if (certificate == null) {
|
|
|
|
certificate = project.certificate;
|
|
|
|
} else {
|
|
|
|
certificate.merge (project.certificate);
|
|
|
|
}
|
|
|
|
config.merge (project.config);
|
|
|
|
assets = ArrayHelper.concatUnique (assets, project.assets);
|
|
dependencies = ArrayHelper.concatUnique (dependencies, project.dependencies, true);
|
|
haxeflags = ArrayHelper.concatUnique (haxeflags, project.haxeflags);
|
|
haxelibs = ArrayHelper.concatUnique (haxelibs, project.haxelibs, true, "name");
|
|
icons = ArrayHelper.concatUnique (icons, project.icons);
|
|
javaPaths = ArrayHelper.concatUnique (javaPaths, project.javaPaths, true);
|
|
libraries = ArrayHelper.concatUnique (libraries, project.libraries, true);
|
|
ndlls = ArrayHelper.concatUnique (ndlls, project.ndlls);
|
|
samplePaths = ArrayHelper.concatUnique (samplePaths, project.samplePaths, true);
|
|
sources = ArrayHelper.concatUnique (sources, project.sources, true);
|
|
splashScreens = ArrayHelper.concatUnique (splashScreens, project.splashScreens);
|
|
templatePaths = ArrayHelper.concatUnique (templatePaths, project.templatePaths, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
public function path (value:String):Void {
|
|
|
|
if (host == Platform.WINDOWS) {
|
|
|
|
setenv ("PATH", value + ";" + Sys.getEnv ("PATH"));
|
|
|
|
} else {
|
|
|
|
setenv ("PATH", value + ":" + Sys.getEnv ("PATH"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
#if (lime && !lime_legacy)
|
|
|
|
@:noCompletion private static function processHaxelibs (project:HXProject, userDefines:Map <String, Dynamic>):Void {
|
|
|
|
var haxelibs = project.haxelibs.copy ();
|
|
project.haxelibs = [];
|
|
|
|
for (haxelib in haxelibs) {
|
|
|
|
/*if (haxelib.name == "nme" && userDefines.exists ("openfl")) {
|
|
|
|
haxelib.name = "openfl-nme-compatibility";
|
|
haxelib.version = "";
|
|
|
|
}*/
|
|
|
|
project.haxelibs.push (haxelib);
|
|
|
|
var includeProject = HXProject.fromHaxelib (haxelib, userDefines);
|
|
|
|
if (includeProject != null) {
|
|
|
|
for (ndll in includeProject.ndlls) {
|
|
|
|
if (ndll.haxelib == null) {
|
|
|
|
ndll.haxelib = haxelib;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
project.merge (includeProject);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
@:noCompletion private static function resolveClass (name:String):Class <Dynamic> {
|
|
|
|
var type = Type.resolveClass (name);
|
|
|
|
if (type == null) {
|
|
|
|
return HXProject;
|
|
|
|
} else {
|
|
|
|
return type;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#end
|
|
|
|
|
|
public function setenv (name:String, value:String):Void {
|
|
|
|
Sys.putEnv (name, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Getters & Setters
|
|
|
|
|
|
|
|
|
|
private function get_host ():Platform {
|
|
|
|
return PlatformHelper.hostPlatform;
|
|
|
|
}
|
|
|
|
|
|
private function get_templateContext ():Dynamic {
|
|
|
|
var context:Dynamic = {};
|
|
|
|
if (app == null) app = { };
|
|
if (meta == null) meta = { };
|
|
|
|
if (window == null) {
|
|
|
|
window = { };
|
|
windows = [ window ];
|
|
|
|
}
|
|
|
|
ObjectHelper.copyMissingFields (defaultApp, app);
|
|
ObjectHelper.copyMissingFields (defaultMeta, meta);
|
|
|
|
for (item in windows) {
|
|
|
|
ObjectHelper.copyMissingFields (defaultWindow, item);
|
|
|
|
}
|
|
|
|
//config.populate ();
|
|
|
|
for (field in Reflect.fields (app)) {
|
|
|
|
Reflect.setField (context, "APP_" + StringHelper.formatUppercaseVariable (field), Reflect.field (app, field));
|
|
|
|
}
|
|
|
|
context.BUILD_DIR = app.path;
|
|
|
|
for (key in environment.keys ()) {
|
|
|
|
Reflect.setField (context, "ENV_" + key, environment.get (key));
|
|
|
|
}
|
|
|
|
for (field in Reflect.fields (meta)) {
|
|
|
|
Reflect.setField (context, "APP_" + StringHelper.formatUppercaseVariable (field), Reflect.field (meta, field));
|
|
Reflect.setField (context, "META_" + StringHelper.formatUppercaseVariable (field), Reflect.field (meta, field));
|
|
|
|
}
|
|
|
|
context.APP_PACKAGE = context.META_PACKAGE = meta.packageName;
|
|
|
|
for (field in Reflect.fields (windows[0])) {
|
|
|
|
Reflect.setField (context, "WIN_" + StringHelper.formatUppercaseVariable (field), Reflect.field (windows[0], field));
|
|
Reflect.setField (context, "WINDOW_" + StringHelper.formatUppercaseVariable (field), Reflect.field (windows[0], field));
|
|
|
|
}
|
|
|
|
if (windows[0].orientation == Orientation.LANDSCAPE || windows[0].orientation == Orientation.PORTRAIT) {
|
|
|
|
context.WIN_ORIENTATION = Std.string (windows[0].orientation).toLowerCase ();
|
|
context.WINDOW_ORIENTATION = Std.string (windows[0].orientation).toLowerCase ();
|
|
|
|
} else {
|
|
|
|
context.WIN_ORIENTATION = "";
|
|
context.WINDOW_ORIENTATION = "";
|
|
|
|
}
|
|
|
|
for (i in 0...windows.length) {
|
|
|
|
for (field in Reflect.fields (windows[i])) {
|
|
|
|
Reflect.setField (context, "WINDOW_" + StringHelper.formatUppercaseVariable (field) + "_" + i, Reflect.field (windows[i], field));
|
|
|
|
}
|
|
|
|
if (windows[i].orientation == Orientation.LANDSCAPE || windows[i].orientation == Orientation.PORTRAIT) {
|
|
|
|
Reflect.setField (context, "WINDOW_ORIENTATION_" + i, Std.string (windows[i].orientation).toLowerCase ());
|
|
|
|
} else {
|
|
|
|
Reflect.setField (context, "WINDOW_ORIENTATION_" + i, "");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (haxeflag in haxeflags) {
|
|
|
|
if (StringTools.startsWith (haxeflag, "-lib")) {
|
|
|
|
Reflect.setField (context, "LIB_" + haxeflag.substr (5).toUpperCase (), "true");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
context.assets = new Array <Dynamic> ();
|
|
|
|
for (asset in assets) {
|
|
|
|
if (asset.type != AssetType.TEMPLATE) {
|
|
|
|
var embeddedAsset:Dynamic = { };
|
|
ObjectHelper.copyFields (asset, embeddedAsset);
|
|
|
|
if (asset.embed == null) {
|
|
|
|
embeddedAsset.embed = (platformType == PlatformType.WEB);
|
|
|
|
}
|
|
|
|
embeddedAsset.type = Std.string (asset.type).toLowerCase ();
|
|
|
|
#if (lime && !lime_legacy)
|
|
if (asset.type == FONT) {
|
|
|
|
try {
|
|
|
|
var font = Font.fromFile (asset.sourcePath);
|
|
embeddedAsset.fontName = font.fontName;
|
|
|
|
} catch (e:Dynamic) {}
|
|
|
|
}
|
|
#end
|
|
|
|
context.assets.push (embeddedAsset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
context.libraries = new Array <Dynamic> ();
|
|
|
|
for (library in libraries) {
|
|
|
|
var embeddedLibrary:Dynamic = { };
|
|
ObjectHelper.copyFields (library, embeddedLibrary);
|
|
context.libraries.push (embeddedLibrary);
|
|
|
|
}
|
|
|
|
Reflect.setField (context, "ndlls", ndlls);
|
|
//Reflect.setField (context, "sslCaCert", sslCaCert);
|
|
context.sslCaCert = "";
|
|
|
|
var compilerFlags = [];
|
|
|
|
for (haxelib in haxelibs) {
|
|
|
|
var name = haxelib.name;
|
|
|
|
if (haxelib.version != "") {
|
|
|
|
name += ":" + haxelib.version;
|
|
|
|
}
|
|
|
|
#if (lime && !lime_legacy)
|
|
|
|
var cache = LogHelper.verbose;
|
|
LogHelper.verbose = false;
|
|
var output = "";
|
|
|
|
try {
|
|
|
|
output = ProcessHelper.runProcess ("", "haxelib", [ "path", name ], true, true, true);
|
|
|
|
} catch (e:Dynamic) { }
|
|
|
|
LogHelper.verbose = cache;
|
|
|
|
var split = output.split ("\n");
|
|
var haxelibName = null;
|
|
|
|
for (arg in split) {
|
|
|
|
arg = StringTools.trim (arg);
|
|
|
|
if (arg != "") {
|
|
|
|
if (!StringTools.startsWith (arg, "-")) {
|
|
|
|
var path = PathHelper.standardize (arg);
|
|
var param = "-cp " + path;
|
|
compilerFlags.remove (param);
|
|
compilerFlags.push (param);
|
|
|
|
var version = "0.0.0";
|
|
var jsonPath = PathHelper.combine (path, "haxelib.json");
|
|
|
|
try {
|
|
|
|
if (FileSystem.exists (jsonPath)) {
|
|
|
|
var json = Json.parse (File.getContent (jsonPath));
|
|
haxelibName = json.name;
|
|
compilerFlags = ArrayHelper.concatUnique (compilerFlags, [ "-D " + haxelibName + "=" + json.version ], true);
|
|
|
|
}
|
|
|
|
} catch (e:Dynamic) {}
|
|
|
|
} else {
|
|
|
|
if (StringTools.startsWith (arg, "-D ") && arg.indexOf ("=") == -1) {
|
|
|
|
var name = arg.substr (3);
|
|
|
|
if (name != haxelibName) {
|
|
|
|
compilerFlags = ArrayHelper.concatUnique (compilerFlags, [ "-D " + name ], true);
|
|
|
|
}
|
|
|
|
/*var haxelib = new Haxelib (arg.substr (3));
|
|
var path = PathHelper.getHaxelib (haxelib);
|
|
var version = getHaxelibVersion (haxelib);
|
|
|
|
if (path != null) {
|
|
|
|
CompatibilityHelper.patchProject (this, haxelib, version);
|
|
compilerFlags = ArrayHelper.concatUnique (compilerFlags, [ "-D " + haxelib.name + "=" + version ], true);
|
|
|
|
}*/
|
|
|
|
} else if (!StringTools.startsWith (arg, "-L")) {
|
|
|
|
compilerFlags = ArrayHelper.concatUnique (compilerFlags, [ arg ], true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
compilerFlags.push ("-lib " + name);
|
|
|
|
#end
|
|
|
|
Reflect.setField (context, "LIB_" + haxelib.name.toUpperCase (), true);
|
|
|
|
if (name == "nme") {
|
|
|
|
context.EMBED_ASSETS = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (source in sources) {
|
|
|
|
compilerFlags.push ("-cp " + source);
|
|
|
|
}
|
|
|
|
for (key in defines.keys ()) {
|
|
|
|
var value = defines.get (key);
|
|
|
|
if (value == null || value == "") {
|
|
|
|
Reflect.setField (context, "SET_" + key.toUpperCase (), true);
|
|
|
|
} else {
|
|
|
|
Reflect.setField (context, "SET_" + key.toUpperCase (), value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (key in haxedefs.keys ()) {
|
|
|
|
var value = haxedefs.get (key);
|
|
|
|
if (value == null || value == "") {
|
|
|
|
compilerFlags.push ("-D " + key);
|
|
|
|
Reflect.setField (context, "DEFINE_" + key.toUpperCase (), true);
|
|
|
|
} else {
|
|
|
|
compilerFlags.push ("-D " + key + "=" + value);
|
|
|
|
Reflect.setField (context, "DEFINE_" + key.toUpperCase (), value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (target != Platform.FLASH) {
|
|
|
|
compilerFlags.push ("-D " + Std.string (target).toLowerCase ());
|
|
|
|
}
|
|
|
|
compilerFlags.push ("-D " + Std.string (platformType).toLowerCase ());
|
|
compilerFlags = compilerFlags.concat (haxeflags);
|
|
|
|
if (compilerFlags.length == 0) {
|
|
|
|
context.HAXE_FLAGS = "";
|
|
|
|
} else {
|
|
|
|
context.HAXE_FLAGS = "\n" + compilerFlags.join ("\n");
|
|
|
|
}
|
|
|
|
var main = app.main;
|
|
|
|
if (main == null) {
|
|
|
|
main = defaultApp.main;
|
|
|
|
}
|
|
|
|
var indexOfPeriod = main.lastIndexOf (".");
|
|
|
|
context.APP_MAIN_PACKAGE = main.substr (0, indexOfPeriod + 1);
|
|
context.APP_MAIN_CLASS = main.substr (indexOfPeriod + 1);
|
|
|
|
var type = "release";
|
|
|
|
if (debug) {
|
|
|
|
type = "debug";
|
|
|
|
} else if (targetFlags.exists ("final")) {
|
|
|
|
type = "final";
|
|
|
|
}
|
|
|
|
var hxml = Std.string (target).toLowerCase () + "/hxml/" + type + ".hxml";
|
|
|
|
for (templatePath in templatePaths) {
|
|
|
|
var path = PathHelper.combine (templatePath, hxml);
|
|
|
|
if (FileSystem.exists (path)) {
|
|
|
|
context.HXML_PATH = path;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (field in Reflect.fields (context)) {
|
|
|
|
//Sys.println ("context." + field + " = " + Reflect.field (context, field));
|
|
|
|
}
|
|
|
|
context.DEBUG = debug;
|
|
context.SWF_VERSION = app.swfVersion;
|
|
context.PRELOADER_NAME = app.preloader;
|
|
|
|
if (certificate != null) {
|
|
|
|
context.KEY_STORE = PathHelper.tryFullPath (certificate.path);
|
|
|
|
if (certificate.password != null) {
|
|
|
|
context.KEY_STORE_PASSWORD = certificate.password;
|
|
|
|
}
|
|
|
|
if (certificate.alias != null) {
|
|
|
|
context.KEY_STORE_ALIAS = certificate.alias;
|
|
|
|
} else if (certificate.path != null) {
|
|
|
|
context.KEY_STORE_ALIAS = Path.withoutExtension (Path.withoutDirectory (certificate.path));
|
|
|
|
}
|
|
|
|
if (certificate.aliasPassword != null) {
|
|
|
|
context.KEY_STORE_ALIAS_PASSWORD = certificate.aliasPassword;
|
|
|
|
} else if (certificate.password != null) {
|
|
|
|
context.KEY_STORE_ALIAS_PASSWORD = certificate.password;
|
|
|
|
}
|
|
|
|
if (certificate.identity != null) {
|
|
|
|
context.KEY_STORE_IDENTITY = certificate.identity;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
context.config = config;
|
|
|
|
return context;
|
|
|
|
}
|
|
|
|
|
|
private function get_window ():Window {
|
|
|
|
if (windows != null) {
|
|
|
|
return windows[0];
|
|
|
|
} else {
|
|
|
|
return window;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
private function set_window (value:Window):Window {
|
|
|
|
if (windows != null) {
|
|
|
|
return windows[0] = window = value;
|
|
|
|
} else {
|
|
|
|
return window = value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|