public FieldDefinition(PastelContext context, PType type, Token name, ClassDefinition classDef) { this.Context = context; this.FieldType = type; this.NameToken = name; this.ClassDef = classDef; }
public ClassDefinition(PastelContext context, Token classToken, Token nameToken) { this.Context = context; this.FirstToken = classToken; this.NameToken = nameToken; this.ParentClass = null; }
public ConstructorDefinition(PastelContext context, Token constructorToken, IList <PType> argTypes, IList <Token> argNames, ClassDefinition classDef) { this.Context = context; this.FirstToken = constructorToken; this.ArgTypes = argTypes.ToArray(); this.ArgNames = argNames.ToArray(); this.ClassDef = classDef; }
public VariableDeclaration( PType type, Token variableNameToken, Token equalsToken, Expression assignmentValue, PastelContext context) : base(type.FirstToken) { this.Context = context; this.Type = type; this.VariableNameToken = variableNameToken; this.EqualsToken = equalsToken; this.Value = assignmentValue; }
public FunctionDefinition( Token nameToken, PType returnType, IList <PType> argTypes, IList <Token> argNames, PastelContext context, ClassDefinition nullableClassOwner) // null if not associated with a class { this.Context = context; this.FirstToken = returnType.FirstToken; this.NameToken = nameToken; this.ReturnType = returnType; this.ArgTypes = argTypes.ToArray(); this.ArgNames = argNames.ToArray(); this.ClassDef = nullableClassOwner; }
private PastelContext GenerateCoreVmParseTree( Platform.AbstractPlatform platform, IInlineImportCodeLoader codeLoader, Dictionary <string, object> constantFlags) { using (new PerformanceSection("VmGenerator.GenerateCoreVmParseTree")) { PastelContext context = new PastelContext(platform.Language, codeLoader); foreach (string key in constantFlags.Keys) { context.SetConstant(key, constantFlags[key]); } foreach (string file in INTERPRETER_BASE_FILES) { context.CompileFile(file); } context.FinalizeCompilation(); return(context); } }
private Platform.LibraryForExport CreateLibraryForExport( string libraryName, string libraryVersion, PastelContext nullableLibaryPastelContext, LibraryResourceDatabase libResDb) { using (new PerformanceSection("VmGenerator.CreateLibraryForExport")) { Multimap <string, Platform.ExportEntity> exportEntities = libResDb.ExportEntities; string[] dotNetLibs = libResDb.DotNetLibs.OrderBy(s => s.ToLower()).ToArray(); return(new Platform.LibraryForExport() { Name = libraryName, Version = libraryVersion, PastelContext = nullableLibaryPastelContext, ExportEntities = exportEntities, DotNetLibs = dotNetLibs, LibProjectNamesAndGuids = libResDb.ProjectReferenceToGuid, }); } }
public EnumDefinition(Token enumToken, Token nameToken, PastelContext context) { this.FirstToken = enumToken; this.NameToken = nameToken; this.Context = context; }
public static void GenerateTemplatesForVmExport( TemplateStorage templates, PastelContext vmContext) { if (vmContext.UsesStringTable) { vmContext.GetTranspilerContext().StringTableBuilder = new Pastel.Transpilers.StringTableBuilder("VM"); } string vmGlobalsCode = vmContext.GetCodeForGlobals(); templates.AddPastelTemplate("vm:globals", vmGlobalsCode); if (vmContext.UsesFunctionDeclarations) { string functionDeclarationCode = vmContext.GetCodeForFunctionDeclarations(); templates.AddPastelTemplate("vm:functionsdecl", functionDeclarationCode); } string functionCode = vmContext.GetCodeForFunctions(); templates.AddPastelTemplate("vm:functions", functionCode); if (vmContext.UsesStructDefinitions) { Dictionary <string, string> structLookup = vmContext.GetCodeForStructs(); foreach (string structName in structLookup.Keys) { templates.AddPastelTemplate("vm:struct:" + structName, structName, structLookup[structName]); } if (vmContext.UsesStructDeclarations) { StringBuilder sb = new StringBuilder(); foreach (string structKey in templates.GetTemplateKeysWithPrefix("vm:struct:")) { string structName = templates.GetName(structKey); sb.Append(vmContext.GetCodeForStructDeclaration(structName)); } templates.AddPastelTemplate("vm:structsdecl", sb.ToString().Trim()); } } if (vmContext.Language == Language.C) { templates.AddPastelTemplate("vm:struct:Value", "Value", string.Join("\n", new string[] { "struct Value {", "\tint type;", "\tunion {", "\t\tint null_internalValue; // not used", "\t\tint bool_internalValue;", "\t\tint int_internalValue;", "\t\tdouble double_internalValue;", "\t\tint* str_internalValue;", "\t\tList* list_internalValue;", "\t\tDictImpl* dict_internalValue;", "\t\tObjectInstance* obj_internalValue;", "\t\tClassValue* class_internalValue;", "\t\tFunctionPointer* func_internalValue;", "\t};", "};", })); } if (vmContext.UsesStringTable) { templates.AddPastelTemplate( "vm:stringtable", vmContext.GetStringConstantTable()); } }
public static void GenerateTemplatesForLibraryExport( TemplateStorage templates, LibraryForExport library) { string libraryName = library.Name; PastelContext libContext = library.PastelContext; libContext.GetTranspilerContext().UniquePrefixForNonCollisions = libraryName.ToLower(); if (libContext.Language == Language.PYTHON || libContext.Language == Language.JAVASCRIPT || libContext.Language == Language.JAVA) { bool changeManifestFuncName = libContext.Language == Language.JAVASCRIPT; string newManifestFunctionNameIfAny = changeManifestFuncName ? "lib_" + libraryName.ToLower() + "_manifest" : null; string manifestFunction = library.PastelContext.GetFunctionCodeForSpecificFunctionAndPopItFromFutureSerialization( "lib_manifest_RegisterFunctions", newManifestFunctionNameIfAny); templates.AddPastelTemplate("library:" + libraryName + ":manifestfunc", manifestFunction); } if (libContext.Language == Language.JAVA) { Dictionary <string, string> lookup = libContext.GetCodeForFunctionsLookup(); StringBuilder sb = new StringBuilder(); string reflectionCalledPrefix = "lib_" + library.Name.ToLower() + "_function_"; libContext.GetTranspilerContext().TabDepth = 1; foreach (string functionName in lookup.Keys.OrderBy(k => k)) { string functionCode = lookup[functionName]; bool isFunctionPointerObject = functionName.StartsWith(reflectionCalledPrefix); if (isFunctionPointerObject) { // This is kind of hacky, BUT... // If the generated function needs to be used as a function pointer, (i.e. it's one // of the library's VM-native bridge methods) change the name to "invoke" and then // wrap it in a dummy class that extends LibraryFunctionPointer. The manifest // function will simply instantiate this in lieu of a performant way to do // function pointers in Java. functionCode = functionCode.Replace( "public static Value v_" + functionName + "(Value[] ", "public Value invoke(Value[] "); functionCode = " public static class FP_" + functionName + " extends LibraryFunctionPointer {\n" + " " + functionCode.Replace("\n", "\n ").TrimEnd() + "\n" + " }"; } sb.Append(functionCode); sb.Append("\n"); } libContext.GetTranspilerContext().TabDepth = 0; templates.AddPastelTemplate("library:" + library.Name + ":functions", sb.ToString().Trim()); } else { string allFunctionCode = libContext.GetCodeForFunctions(); templates.AddPastelTemplate("library:" + library.Name + ":functions", allFunctionCode); } if (libContext.UsesStructDefinitions) { Dictionary <string, string> libStructLookup = libContext.GetCodeForStructs(); foreach (string structName in libStructLookup.Keys) { templates.AddPastelTemplate( "library:" + library.Name + ":struct:" + structName, structName, libStructLookup[structName]); } } }
public void ExportProjectImpl( Dictionary <string, FileOutput> output, TemplateStorage templates, IList <LibraryForExport> libraries, ResourceDatabase resourceDatabase, Options options) { List <string> jsExtraHead = new List <string>() { options.GetStringOrEmpty(ExportOptionKey.JS_HEAD_EXTRAS) }; bool fullPage = options.GetBool(ExportOptionKey.JS_FULL_PAGE); // There's a double-check here so that you can || them together and then have multiple options added here. if (fullPage) { jsExtraHead.Add( "<script type=\"text/javascript\">" + (fullPage ? "C$common$globalOptions['fullscreen'] = true;" : "") + "</script>"); } options.SetOption(ExportOptionKey.JS_HEAD_EXTRAS, string.Join("\n", jsExtraHead)); Dictionary <string, string> replacements = this.GenerateReplacementDictionary(options, resourceDatabase); output["vm.js"] = new FileOutput() { Type = FileOutputType.Text, TextContent = templates.GetCode("vm:globals") + this.NL + this.NL + templates.GetCode("vm:functions"), }; List <LibraryForExport> librariesWithCode = new List <LibraryForExport>(); foreach (LibraryForExport library in libraries) { if (library.HasPastelCode) { string libraryName = library.Name; PastelContext libContext = library.PastelContext; List <string> libraryLines = new List <string>(); libraryLines.Add(templates.GetCode("library:" + libraryName + ":manifestfunc")); libraryLines.Add(""); libraryLines.Add(templates.GetCode("library:" + libraryName + ":functions")); libraryLines.Add(""); libraryLines.Add("C$common$scrapeLibFuncNames('" + libraryName.ToLower() + "');"); libraryLines.Add(""); // add helper functions after the scrape. foreach (ExportEntity embedCode in library.ExportEntities["EMBED_CODE"]) { libraryLines.Add(embedCode.StringValue); } output["libs/lib_" + libraryName.ToLower() + ".js"] = new FileOutput() { Type = FileOutputType.Text, TextContent = string.Join("\n", libraryLines), }; librariesWithCode.Add(library); } } Dictionary <string, string> htmlReplacements = new Dictionary <string, string>(replacements); replacements["JS_LIB_INCLUSIONS"] = GenerateJsLibInclusionHtml(output.Keys); this.CopyResourceAsText(output, "index.html", "Resources/HostHtml.txt", replacements); this.CopyResourceAsText(output, "common.js", "Resources/Common.txt", replacements); TODO.JavaScriptDeGamification(); output["lib_supplemental.js"] = new FileOutput() { Type = FileOutputType.Text, TextContent = this.LoadTextResource("Resources/ImageResource.txt", replacements), }; StringBuilder resourcesJs = new StringBuilder(); foreach (FileOutput textResource in resourceDatabase.TextResources) { resourcesJs.Append("C$common$addTextRes("); resourcesJs.Append(Util.ConvertStringValueToCode(textResource.CanonicalFileName)); resourcesJs.Append(", "); resourcesJs.Append(Util.ConvertStringValueToCode(textResource.TextContent)); resourcesJs.Append(");\n"); } foreach (FileOutput fontResource in resourceDatabase.FontResources) { resourcesJs.Append("C$common$addBinaryRes("); resourcesJs.Append(Util.ConvertStringValueToCode(fontResource.CanonicalFileName)); resourcesJs.Append(", '"); resourcesJs.Append(Util.ConvertByteArrayToBase64(fontResource.GetFinalBinaryContent())); resourcesJs.Append("');\n"); } FileOutput imageSheetManifest = resourceDatabase.ImageSheetManifestFile; resourcesJs.Append("C$common$addTextRes('image_sheets.txt', "); resourcesJs.Append(imageSheetManifest == null ? "''" : Util.ConvertStringValueToCode(imageSheetManifest.TextContent)); resourcesJs.Append(");\n"); resourcesJs.Append("C$common$resourceManifest = "); resourcesJs.Append(Util.ConvertStringValueToCode(resourceDatabase.ResourceManifestFile.TextContent)); resourcesJs.Append(";\n"); string filePrefix = options.GetStringOrNull(ExportOptionKey.JS_FILE_PREFIX); if (filePrefix != null) { resourcesJs.Append("C$common$jsFilePrefix = "); resourcesJs.Append(Util.ConvertStringValueToCode(filePrefix)); resourcesJs.Append(";\n"); } output["resources.js"] = new FileOutput() { Type = FileOutputType.Text, TextContent = resourcesJs.ToString(), }; output["bytecode.js"] = new FileOutput() { Type = FileOutputType.Text, TextContent = "C$bytecode = " + Util.ConvertStringValueToCode(resourceDatabase.ByteCodeFile.TextContent) + ";", }; foreach (string imageResourceFile in resourceDatabase.ImageSheetFiles.Keys) { FileOutput file = resourceDatabase.ImageSheetFiles[imageResourceFile]; output["resources/images/" + imageResourceFile] = file; } foreach (FileOutput audioResourceFile in resourceDatabase.AudioResources) { output["resources/audio/" + audioResourceFile.CanonicalFileName] = audioResourceFile; } // TODO: minify JavaScript across all of output dictionary }
public StructDefinition(Token structToken, Token name, IList <PType> argTypes, IList <Token> argNames, Token parentName, PastelContext context) { this.Context = context; this.FirstToken = structToken; this.NameToken = name; this.ParentName = parentName; this.LocalFieldTypes = argTypes.ToArray(); this.LocalFieldNames = argNames.ToArray(); this.LocalFieldIndexByName = new Dictionary <string, int>(); for (int i = this.LocalFieldNames.Length - 1; i >= 0; --i) { string argName = this.LocalFieldNames[i].Value; this.LocalFieldIndexByName[argName] = i; } }
public void TranslateExpression(TranspilerContext sb, Expression expression) { string typeName = expression.GetType().Name; switch (typeName) { case "CastExpression": this.TranslateCast(sb, ((CastExpression)expression).Type, ((CastExpression)expression).Expression); break; case "FunctionReference": this.TranslateFunctionReference(sb, (FunctionReference)expression); break; case "FunctionPointerInvocation": this.TranslateFunctionPointerInvocation(sb, (FunctionPointerInvocation)expression); break; case "CoreFunctionInvocation": this.TranslateCoreFunctionInvocation(sb, (CoreFunctionInvocation)expression); break; case "OpChain": OpChain oc = (OpChain)expression; if (oc.IsStringConcatenation) { this.TranslateStringConcatenation(sb, oc.Expressions); } else { this.TranslateOpChain(sb, oc); } break; case "ExtensibleFunctionInvocation": this.TranslateExtensibleFunctionInvocation( sb, (ExtensibleFunctionInvocation)expression); break; case "InlineIncrement": InlineIncrement ii = (InlineIncrement)expression; this.TranslateInlineIncrement(sb, ii.Expression, ii.IsPrefix, ii.IncrementToken.Value == "++"); break; case "FunctionInvocation": FunctionInvocation funcInvocation = (FunctionInvocation)expression; string prefix = null; FunctionDefinition funcDef = ((FunctionReference)funcInvocation.Root).Function; PastelContext targetContext = funcDef.Context; PastelContext callerContext = funcInvocation.Owner.Context; if (targetContext != callerContext) { prefix = callerContext.GetDependencyExportPrefix(targetContext); } if (prefix != null) { this.TranslateFunctionInvocationWithPrefix(sb, prefix, (FunctionReference)funcInvocation.Root, funcInvocation.Args); } else { this.TranslateFunctionInvocation(sb, (FunctionReference)funcInvocation.Root, funcInvocation.Args); } break; case "Variable": Variable v = (Variable)expression; this.TranslateVariable(sb, v); break; case "ConstructorInvocation": ConstructorInvocation constructor = (ConstructorInvocation)expression; string rootType = constructor.Type.RootValue; switch (rootType) { case "Array": if (constructor.Type.Generics.Length != 1) { throw new Pastel.ParserException(constructor.Type.FirstToken, "Array constructor requires exactly 1 generic type."); } this.TranslateArrayNew(sb, constructor.Type.Generics[0], constructor.Args[0]); break; case "List": if (constructor.Type.Generics.Length != 1) { throw new Pastel.ParserException(constructor.Type.FirstToken, "List constructor requires exactly 1 generic type."); } this.TranslateListNew(sb, constructor.Type.Generics[0]); break; case "Dictionary": if (constructor.Type.Generics.Length != 2) { throw new Pastel.ParserException(constructor.Type.FirstToken, "Dictionary constructor requires exactly 2 generic types."); } PType dictionaryKeyType = constructor.Type.Generics[0]; PType dictionaryValueType = constructor.Type.Generics[1]; this.TranslateDictionaryNew(sb, dictionaryKeyType, dictionaryValueType); break; case "StringBuilder": if (constructor.Type.Generics.Length != 0) { throw new ParserException(constructor.Type.FirstToken, "StringBuilder constructor does not have any generics."); } this.TranslateStringBuilderNew(sb); break; default: // TODO: throw an exception (in the parser) if generics exist. this.TranslateConstructorInvocation(sb, constructor); break; } break; case "DotField": DotField df = (DotField)expression; StructDefinition structDef = df.StructType; ClassDefinition classDef = df.ClassType; string fieldName = df.FieldName.Value; if (classDef != null) { this.TranslateInstanceFieldDereference(sb, df.Root, classDef, fieldName); } else if (structDef != null) { int fieldIndex = structDef.FlatFieldIndexByName[fieldName]; this.TranslateStructFieldDereference(sb, df.Root, structDef, fieldName, fieldIndex); } else { throw new InvalidOperationException(); // should have been thrown by the compiler } break; case "InlineConstant": InlineConstant ic = (InlineConstant)expression; switch (ic.ResolvedType.RootValue) { case "bool": this.TranslateBooleanConstant(sb, (bool)ic.Value); break; case "char": this.TranslateCharConstant(sb, ((string)ic.Value)[0]); break; case "double": this.TranslateFloatConstant(sb, (double)ic.Value); break; case "int": this.TranslateIntegerConstant(sb, (int)ic.Value); break; case "null": this.TranslateNullConstant(sb); break; case "string": this.TranslateStringConstant(sb, (string)ic.Value); break; default: throw new NotImplementedException(); } break; case "ThisExpression": this.TranslateThis(sb, (ThisExpression)expression); break; case "UnaryOp": UnaryOp uo = (UnaryOp)expression; if (uo.OpToken.Value == "-") { this.TranslateNegative(sb, uo); } else { this.TranslateBooleanNot(sb, uo); } break; case "ForcedParenthesis": sb.Append('('); this.TranslateExpression(sb, ((ForcedParenthesis)expression).Expression); sb.Append(')'); break; default: throw new NotImplementedException(typeName); } }
private List <Platform.LibraryForExport> GetLibrariesForExport( Platform.AbstractPlatform platform, Dictionary <string, LibraryMetadata> librariesById, Dictionary <string, object> constantFlags, IInlineImportCodeLoader codeLoader, PastelContext vm) { using (new PerformanceSection("VmGenerator.GetLibrariesForExport")) { Dictionary <string, PastelContext> libraryCompilation = this.GenerateLibraryParseTree( platform, constantFlags, codeLoader, librariesById.Values, vm); List <Platform.LibraryForExport> libraries = new List <Platform.LibraryForExport>(); Dictionary <string, LibraryExporter> libraryByName = new Dictionary <string, LibraryExporter>(); foreach (string libraryId in libraryCompilation.Keys.OrderBy(s => s)) { LibraryExporter library = LibraryExporter.Get(librariesById[libraryId], platform); libraryByName[library.Metadata.ID] = library; PastelContext libraryPastelContext = libraryCompilation.ContainsKey(library.Metadata.ID) ? libraryCompilation[library.Metadata.ID] : null; Platform.LibraryForExport libraryForExport = this.CreateLibraryForExport( library.Metadata.ID, library.Metadata.Version, libraryPastelContext, library.Resources); libraries.Add(libraryForExport); } // Now that all libraries are read and initialized, go through and resolve all deferred DLL's that required all libraries to be loaded. foreach (Platform.LibraryForExport lfe in libraries) { foreach (Platform.ExportEntity ee in lfe.ExportEntities.GetValueEnumerator()) { if (ee.DeferredFileOutputBytesLibraryName != null) { LibraryExporter sourceLibrary; if (!libraryByName.TryGetValue(ee.DeferredFileOutputBytesLibraryName, out sourceLibrary)) { throw new InvalidOperationException("The library '" + lfe.Name + "' makes reference to another library '" + ee.DeferredFileOutputBytesLibraryName + "' which could not be found."); } string resourcePath = "resources/" + ee.DeferredFileOutputBytesLibraryPath; byte[] dllFile = sourceLibrary.Metadata.ReadFileBytes(resourcePath); if (dllFile == null) { throw new InvalidOperationException("Could not find file: '" + resourcePath + "' in library '" + sourceLibrary.Metadata.ID + "'"); } ee.FileOutput = new FileOutput() { Type = FileOutputType.Binary, BinaryContent = dllFile }; } } } return(libraries); } }
private Dictionary <string, PastelContext> GenerateLibraryParseTree( Platform.AbstractPlatform platform, Dictionary <string, object> constantFlags, IInlineImportCodeLoader codeLoader, ICollection <LibraryMetadata> relevantLibraries, PastelContext sharedScope) { using (new PerformanceSection("VmGenerator.GenerateLibraryParseTree")) { Dictionary <string, PastelContext> libraries = new Dictionary <string, PastelContext>(); foreach (LibraryMetadata libraryMetadata in relevantLibraries) { LibraryExporter library = LibraryExporter.Get(libraryMetadata, platform); Dictionary <string, object> constantsLookup = Util.MergeDictionaries <string, object>(constantFlags, library.CompileTimeConstants); List <ExtensibleFunction> libraryFunctions = library.GetPastelExtensibleFunctions(); if (!libraryMetadata.IsMoreThanJustEmbedCode) { continue; } PastelContext context = new PastelContext(platform.Language, codeLoader); Dictionary <string, string> exFnTranslations = library.GetExtensibleFunctionTranslations(platform); foreach (ExtensibleFunction exFn in libraryFunctions) { string exFnTranslation = null; if (exFnTranslations.ContainsKey(exFn.Name)) { exFnTranslation = exFnTranslations[exFn.Name]; } else if (exFnTranslations.ContainsKey("$" + exFn.Name)) { exFnTranslation = exFnTranslations["$" + exFn.Name]; } context.AddExtensibleFunction(exFn, exFnTranslation); } context.AddDependency(sharedScope); foreach (string constKey in constantsLookup.Keys) { context.SetConstant(constKey, constantsLookup[constKey]); } libraries[library.Metadata.ID] = context; Dictionary <string, string> supplementalCode = library.Metadata.GetSupplementalTranslatedCode(); Dictionary <string, string> translatedCode = library.GetNativeCode(); Dictionary <string, string> structCode = library.Metadata.GetStructFilesCode(); // need to load from the actual Library instance, which could have come from either CRAYON_HOME or source string registryCode = library.Metadata.GetRegistryCode(); if (registryCode == null) { if (supplementalCode.Count > 0 || translatedCode.Count > 0) { throw new InvalidOperationException("The library '" + library.Metadata.ID + "' has translated code but no function_registry.pst file."); } } else { string filename = "LIB:" + library.Metadata.ID + "/function_registry.pst"; context.CompileCode(filename, registryCode); foreach (string structFile in structCode.Keys) { filename = "LIB:" + library.Metadata.ID + "/structs/" + structFile; context.CompileCode(filename, structCode[structFile]); } foreach (string supplementalFile in supplementalCode.Keys) { filename = "LIB:" + library.Metadata.ID + "/supplemental/" + supplementalFile; context.CompileCode(filename, supplementalCode[supplementalFile]); } foreach (string translatedFile in translatedCode.Keys) { filename = "LIB:" + library.Metadata.ID + "/translate/" + translatedFile; context.CompileCode(filename, translatedCode[translatedFile]); } context.FinalizeCompilation(); } } return(libraries); } }
public void GenerateVmSourceCodeForPlatform( Dictionary <string, FileOutput> output, Platform.AbstractPlatform platform, CompilationBundle nullableCompilationBundle, ResourceDatabase resourceDatabase, ICollection <LibraryMetadata> relevantLibraries, string verifiedAbsoluteOutputPath, IInlineImportCodeLoader codeLoader, VmGenerationMode mode) { using (new PerformanceSection("VmGenerator.GenerateVmSourceCodeForPlatform")) { Options options = new Options(); Dictionary <string, object> constantFlags = platform.GetFlattenedConstantFlags() ?? new Dictionary <string, object>(); this.AddTypeEnumsToConstants(constantFlags); PastelContext vmPastelContext = this.GenerateCoreVmParseTree(platform, codeLoader, constantFlags); Dictionary <string, LibraryMetadata> librariesByID = relevantLibraries.ToDictionary(lib => lib.ID); List <Platform.LibraryForExport> libraries = this.GetLibrariesForExport(platform, librariesByID, constantFlags, codeLoader, vmPastelContext); Platform.TemplateStorage templates = new Platform.TemplateStorage(); Platform.TemplateGenerator.GenerateTemplatesForVmExport(templates, vmPastelContext); foreach (Platform.LibraryForExport library in libraries.Where(lib => lib.HasPastelCode)) { Platform.TemplateGenerator.GenerateTemplatesForLibraryExport(templates, library); } if (mode == VmGenerationMode.EXPORT_SELF_CONTAINED_PROJECT_SOURCE) { options .SetOption(ExportOptionKey.PROJECT_ID, nullableCompilationBundle.ProjectID) .SetOption(ExportOptionKey.DESCRIPTION, nullableCompilationBundle.Description) .SetOption(ExportOptionKey.VERSION, nullableCompilationBundle.Version) .SetOption(ExportOptionKey.EMBED_BYTE_CODE, nullableCompilationBundle.GuidSeed) .SetOption(ExportOptionKey.EMBED_BYTE_CODE, true) .SetOption(ExportOptionKey.DEFAULT_TITLE, nullableCompilationBundle.DefaultTitle) .SetOption(ExportOptionKey.LIBRARIES_USED, libraries.Cast <object>().ToArray()) .SetOption(ExportOptionKey.HAS_ICON, nullableCompilationBundle.IconPath != null) .SetOption(ExportOptionKey.HAS_LAUNCHSCREEN, nullableCompilationBundle.LaunchScreenPath != null) .SetOption(ExportOptionKey.IOS_BUNDLE_PREFIX, nullableCompilationBundle.IosBundlePrefix) .SetOption(ExportOptionKey.JAVA_PACKAGE, nullableCompilationBundle.JavaPackage) .SetOption(ExportOptionKey.JS_FILE_PREFIX, nullableCompilationBundle.JsFilePrefix) .SetOption(ExportOptionKey.JS_FULL_PAGE, nullableCompilationBundle.JsFullPage) .SetOption(ExportOptionKey.SUPPORTED_ORIENTATION, nullableCompilationBundle.Orientations); if (options.GetBool(ExportOptionKey.HAS_ICON)) { options.SetOption(ExportOptionKey.ICON_PATH, nullableCompilationBundle.IconPath); } if (options.GetBool(ExportOptionKey.HAS_LAUNCHSCREEN)) { options.SetOption(ExportOptionKey.LAUNCHSCREEN_PATH, nullableCompilationBundle.LaunchScreenPath); } platform.GleanInformationFromPreviouslyExportedProject(options, verifiedAbsoluteOutputPath); platform.ExportProject( output, templates, libraries, resourceDatabase, options); } else { platform.ExportStandaloneVm( output, templates, libraries); } } }