public PastelContext AddDependency(PastelContext context, string pastelNamespace, string referencePrefix) { this.dependencyReferenceNamespacesToDependencyIndex[pastelNamespace] = this.dependencies.Count; this.dependencies.Add(context.GetCompiler()); this.dependencyReferenceExportPrefixes.Add(referencePrefix); return(this); }
public PastelCompiler( PastelContext context, Language language, IList <PastelCompiler> includedScopes, Dictionary <string, int> namespaceToScopeIndex, IDictionary <string, object> constants, IInlineImportCodeLoader inlineImportCodeLoader, ICollection <ExtensibleFunction> extensibleFunctions) { this.Context = context; Dictionary <string, object> langConstants = LanguageUtil.GetLanguageConstants(language); Dictionary <string, object> flattenedConstants = new Dictionary <string, object>(langConstants); foreach (string key in constants.Keys) { flattenedConstants[key] = constants[key]; } this.CodeLoader = inlineImportCodeLoader; this.Transpiler = LanguageUtil.GetTranspiler(language); this.IncludedScopes = includedScopes.ToArray(); this.IncludedScopeNamespacesToIndex = new Dictionary <string, int>(namespaceToScopeIndex); this.ExtensibleFunctions = extensibleFunctions == null ? new Dictionary <string, ExtensibleFunction>() : extensibleFunctions.ToDictionary(ef => ef.Name); this.StructDefinitions = new Dictionary <string, StructDefinition>(); this.EnumDefinitions = new Dictionary <string, EnumDefinition>(); this.ConstantDefinitions = new Dictionary <string, VariableDeclaration>(); this.FunctionDefinitions = new Dictionary <string, FunctionDefinition>(); this.ClassDefinitions = new Dictionary <string, ClassDefinition>(); this.interpreterParser = new PastelParser(context, flattenedConstants, inlineImportCodeLoader); }
public PastelParser( PastelContext context, IDictionary <string, object> constants, IInlineImportCodeLoader importCodeLoader) { this.context = context; this.constants = constants; this.importCodeLoader = importCodeLoader; }
private static void BuildProject(string projectPath) { ProjectConfig config = ProjectConfig.Parse(projectPath); if (config.Language == Language.NONE) { throw new InvalidOperationException("Language not defined in " + projectPath); } PastelContext context = CompilePastelContexts(config); GenerateFiles(config, context); }
private static PastelContext CompilePastelContexts(ProjectConfig rootConfig) { Dictionary <string, ProjectConfig> configsLookup = new Dictionary <string, ProjectConfig>(); string[] contextPaths = GetContextsInDependencyOrder(rootConfig, configsLookup); Dictionary <string, PastelContext> contexts = new Dictionary <string, PastelContext>(); foreach (string contextPath in contextPaths) { ProjectConfig config = configsLookup[contextPath]; PastelContext context = GetContextForConfigImpl(config, contexts, new HashSet <string>()); context.CompileCode(config.Source, System.IO.File.ReadAllText(config.Source)); context.FinalizeCompilation(); } return(contexts[rootConfig.Path]); }
public string GetDependencyExportPrefix(PastelContext context) { if (context == this) { return(null); } for (int i = 0; i < this.dependencies.Count; ++i) { if (this.dependencies[i].Context == context) { return(this.dependencyReferenceExportPrefixes[i]); } } // This is a hard crash, not a ParserException, as this is currently only accessible when // you have a resolved function definition, and so it would be impossible to get that // reference if you didn't already list it as a dependency. throw new System.Exception("This is not a dependency of this context."); }
private static Dictionary <string, string> GenerateFiles(ProjectConfig config, PastelContext context) { Dictionary <string, string> output = new Dictionary <string, string>(); if (context.UsesClassDefinitions) { Dictionary <string, string> classDefinitions = context.GetCodeForClasses(); foreach (string className in classDefinitions.Keys.OrderBy(k => k)) { string classCode = classDefinitions[className]; if (context.ClassDefinitionsInSeparateFiles) { GenerateClassImplementation(config, className, classCode); } else { output["class_def:" + className] = classCode; } } if (!context.ClassDefinitionsInSeparateFiles) { System.Text.StringBuilder sb = new System.Text.StringBuilder(); foreach (string key in output.Keys.Where(k => k.StartsWith("class_def:")).OrderBy(k => k)) { sb.Append(output[key]); sb.Append("\n\n"); } string code = sb.ToString().Trim(); if (code.Length > 0) { string classOutputDir = System.IO.Path.GetDirectoryName(config.OutputFileFunctions); string path = System.IO.Path.Combine(classOutputDir, "Classes" + LanguageUtil.GetFileExtension(config.Language)); System.IO.File.WriteAllText(path, code + "\n"); } } } if (context.UsesStructDefinitions) { Dictionary <string, string> structDefinitions = context.GetCodeForStructs(); string[] structOrder = structDefinitions.Keys.OrderBy(k => k.ToLower()).ToArray(); if (context.HasStructsInSeparateFiles) { foreach (string structName in structOrder) { GenerateStructImplementation(config, structName, structDefinitions[structName]); } } else { GenerateStructBundleImplementation(config, structOrder, structDefinitions); } if (context.UsesStructDeclarations) { Dictionary <string, string> structDeclarations = structOrder.ToDictionary(k => context.GetCodeForStructDeclaration(k)); foreach (string structName in structOrder) { output["struct_decl:" + structName] = structDeclarations[structName]; } } } if (context.UsesFunctionDeclarations) { string funcDeclarations = context.GetCodeForFunctionDeclarations(); throw new NotImplementedException(); } GenerateFunctionImplementation(config, context.GetCodeForFunctions()); return(output); }
private static PastelContext GetContextForConfigImpl( ProjectConfig config, Dictionary <string, PastelContext> contexts, HashSet <string> recursionCheck) { if (contexts.ContainsKey(config.Path)) { return(contexts[config.Path]); } if (recursionCheck.Contains(config.Path)) { throw new InvalidOperationException("Project config dependencies have a cycle involving: " + config.Path); } recursionCheck.Add(config.Path); ProjectConfig[] requiredScopes = config.DependenciesByPrefix.Values.ToArray(); for (int i = 0; i < requiredScopes.Length; ++i) { string path = requiredScopes[i].Path; if (!contexts.ContainsKey(path)) { throw new Exception(); // This shouldn't happen. These are run in dependency order. } } string sourceRootDir = System.IO.Path.GetDirectoryName(config.Source); PastelContext context = new PastelContext(sourceRootDir, config.Language, new CodeLoader(sourceRootDir)); foreach (string prefix in config.DependenciesByPrefix.Keys) { ProjectConfig depConfig = config.DependenciesByPrefix[prefix]; // TODO: make this a little more generic for other possible languages string funcNs = depConfig.NamespaceForFunctions; string classWrapper = depConfig.WrappingClassNameForFunctions; string outputPrefix = ""; if (funcNs != null) { outputPrefix = funcNs + "."; } if (classWrapper != null) { outputPrefix += classWrapper + "."; } context.AddDependency(contexts[depConfig.Path], prefix, outputPrefix); } context.MarkDependenciesAsFinalized(); foreach (string constantName in config.Flags.Keys) { context.SetConstant(constantName, config.Flags[constantName]); } foreach (ExtensibleFunction exFn in config.GetExtensibleFunctions()) { // TODO(pastel-split): Translation is already set on the extensible function in the // new codepath, so the 2nd parameter here ought to be removed. context.AddExtensibleFunction(exFn, exFn.Translation); } contexts[config.Path] = context; recursionCheck.Remove(config.Path); return(context); }
public PastelContext AddDependency(PastelContext context) { this.dependencies.Add(context.compiler); return(this); }