private void EmitImportNode(ImportNode node, out AssociativeNode outnode) { Validity.Assert(node != null); ProtoCore.AST.AssociativeAST.ImportNode importNode = null; importNode = new ProtoCore.AST.AssociativeAST.ImportNode(); importNode.ModuleName = node.ModuleName; //(AstRootNode as CodeBlockNode).Body.Add(importNode); outnode = importNode; }
private bool TryGetImportNode(string moduleName, string typeName, out ProtoCore.AST.AssociativeAST.ImportNode node) { if (mModuleTable.TryGetValue(moduleName, out node)) { if (typeName.Length == 0) //All types { return(true); } ProtoCore.AST.AssociativeAST.ClassDeclNode classNode; if (TryGetClassNode(node.CodeNode, typeName, out classNode) && !IsEmptyClassNode(classNode)) { return(true); } } return(false); }
private ProtoCore.AST.AssociativeAST.CodeBlockNode MergeCodeBlockNode(ref ProtoCore.AST.AssociativeAST.ImportNode importedNode, ProtoCore.AST.AssociativeAST.CodeBlockNode codeBlockNode) { if (codeBlockNode == null || codeBlockNode.Body == null || importedNode == null) { return(codeBlockNode); } ProtoCore.AST.AssociativeAST.CodeBlockNode importedCodeBlock = importedNode.CodeNode; if (importedCodeBlock == null) { importedNode.CodeNode = codeBlockNode; return(codeBlockNode); } foreach (var item in codeBlockNode.Body) { ProtoCore.AST.AssociativeAST.ClassDeclNode classNode = item as ProtoCore.AST.AssociativeAST.ClassDeclNode; if (classNode != null) { ProtoCore.AST.AssociativeAST.ClassDeclNode importedClass = null; if (TryGetClassNode(importedCodeBlock, classNode.className, out importedClass)) { bool dummyClassNode = IsEmptyClassNode(classNode); bool dummyImportClass = IsEmptyClassNode(importedClass); Validity.Assert(dummyImportClass || dummyClassNode, string.Format("{0} is imported more than once!!", classNode.className)); if (dummyImportClass && !dummyClassNode) { importedNode.CodeNode.Body.Remove(importedClass); importedNode.CodeNode.Body.Add(classNode); } } else { importedNode.CodeNode.Body.Add(classNode); } } else { importedNode.CodeNode.Body.Add(item); //TODO other conflict resolution needs to be done here. } } return(importedNode.CodeNode); }
/// <summary> /// Resets the VM whenever a new library is imported and re-imports them /// Returns the list of new Library Mirrors for reflection /// TODO: It should not be needed once we have language support to insert import statements arbitrarily /// </summary> /// <param name="libraries"></param> /// <returns></returns> public List<LibraryMirror> ResetVMAndImportLibrary(List<string> libraries) { List<LibraryMirror> libs = new List<LibraryMirror>(); // Reset VM ReInitializeLiveRunner(); // generate import node for each library in input list List<AssociativeNode> importNodes = null; foreach (string lib in libraries) { importNodes = new List<AssociativeNode>(); ProtoCore.AST.AssociativeAST.ImportNode importNode = new ProtoCore.AST.AssociativeAST.ImportNode(); importNode.ModuleName = lib; importNodes.Add(importNode); ProtoCore.CodeGenDS codeGen = new ProtoCore.CodeGenDS(importNodes); string code = codeGen.GenerateCode(); int currentCI = runnerCore.ClassTable.ClassNodes.Count; UpdateCmdLineInterpreter(code); int postCI = runnerCore.ClassTable.ClassNodes.Count; IList<ProtoCore.DSASM.ClassNode> classNodes = new List<ProtoCore.DSASM.ClassNode>(); for (int i = currentCI; i < postCI; ++i) { classNodes.Add(runnerCore.ClassTable.ClassNodes[i]); } ProtoCore.Mirror.LibraryMirror libraryMirror = ProtoCore.Mirror.Reflection.Reflect(lib, classNodes, runnerCore); libs.Add(libraryMirror); } return libs; }
/// <summary> /// This is called temporarily to reset the VM and recompile the entire graph with new import /// statements whenever a node from a new library is added to the graph. /// TODO: It should not be needed once we have language support to insert import statements arbitrarily /// </summary> /// <param name="libraries"></param> /// <param name="syncData"></param> public void ResetVMAndResyncGraph(IEnumerable<string> libraries) { // Reset VM ReInitializeLiveRunner(); if (!libraries.Any()) { return; } // generate import node for each library in input list List<AssociativeNode> importNodes = new List<AssociativeNode>(); foreach (string lib in libraries) { ProtoCore.AST.AssociativeAST.ImportNode importNode = new ProtoCore.AST.AssociativeAST.ImportNode(); importNode.ModuleName = lib; importNodes.Add(importNode); } ProtoCore.CodeGenDS codeGen = new ProtoCore.CodeGenDS(importNodes); string code = codeGen.GenerateCode(); UpdateCmdLineInterpreter(code); }
internal ImportNode Compile(ImportModuleHandler importer) { ImportNode impNode = null; ProtoCore.AST.AssociativeAST.CodeBlockNode code = new ProtoCore.AST.AssociativeAST.CodeBlockNode(); foreach (var item in mData) { SortedSet<Type> types = GetTypesForImport(item.Value.Data); foreach (var type in types) { if (CLRObjectMarshler.IsMarshaledAsNativeType(type)) continue; ImportNode node = importer.Import(type.Assembly.Location, type.FullName, ""); if (impNode != null && node != null) impNode.CodeNode.Body.AddRange(node.CodeNode.Body); else impNode = node; } if (impNode == null) impNode = new ImportNode() { ModuleName="ExternalContext", CodeNode = new ProtoCore.AST.AssociativeAST.CodeBlockNode() }; impNode.CodeNode.Body.Add(ContextDataMethodCallNode(item.Value)); } return impNode; }
public ProtoCore.AST.AssociativeAST.ImportNode Import(string moduleName, string typeName, string alias, int line = -1, int col = -1) { curLine = line; curCol = col; moduleName = moduleName.Replace("\"", String.Empty); ProtoCore.AST.AssociativeAST.ImportNode node = new ProtoCore.AST.AssociativeAST.ImportNode(); node.ModuleName = moduleName; string modulePathFileName = FileUtils.GetDSFullPathName(moduleName, _coreObj.Options); // Tracking directory paths for all imported DS files during preload assembly stage so that they can be accessed by Graph compiler before execution - pratapa if (_coreObj.IsParsingPreloadedAssembly) { string dirName = Path.GetDirectoryName(modulePathFileName); if (!string.IsNullOrEmpty(dirName) && !_coreObj.Options.IncludeDirectories.Contains(dirName)) _coreObj.Options.IncludeDirectories.Add(dirName); } if (string.IsNullOrEmpty(typeName)) { //Check if moduleName is a type name with namespace. Type type = Type.GetType(moduleName); if (type != null) { typeName = type.FullName; modulePathFileName = type.Assembly.Location; } } if (modulePathFileName == null || !File.Exists(modulePathFileName)) { System.Diagnostics.Debug.Write(@"Cannot import file: '" + modulePathFileName); _coreObj.LogWarning(ProtoCore.BuildData.WarningID.FileNotFound, string.Format(Resources.kFileNotFound, modulePathFileName)); return null; } node.ModulePathFileName = modulePathFileName; node.CodeNode = null; if (typeName.Length > 0) node.Identifiers.Add(typeName); ProtoCore.AST.AssociativeAST.ImportNode importedNode = null; if (TryGetImportNode(modulePathFileName, typeName, out importedNode)) { node.HasBeenImported = true; return node; } ProtoCore.AST.AssociativeAST.CodeBlockNode codeNode = null; if (importedNode == null) codeNode = new ProtoCore.AST.AssociativeAST.CodeBlockNode(); else codeNode = importedNode.CodeNode; try { codeNode = ImportCodeBlock(modulePathFileName, typeName, alias, codeNode); } catch (System.Exception ex) { if (ex.InnerException != null) _coreObj.BuildStatus.LogSemanticError(ex.InnerException.Message); _coreObj.BuildStatus.LogSemanticError(ex.Message); } //Cache the codeblock of root import node. CodeBlockNode rootImportCodeBlock = mRootImportNode.CodeNode; mRootImportNode.CodeNode = new CodeBlockNode(); //reset with the new one. //Remove all empty nodes and add to root import node. codeNode.Body.RemoveAll(AddToRootImportNodeIfEmpty); if (mRootImportNode.CodeNode.Body.Count == 0) //empty mRootImportNode.CodeNode = rootImportCodeBlock; //reset the old one. if (importedNode != null) { //module has import node, but type is not imported yet. //MergeCodeBlockNode(ref importedNode, codeBlockNode); //update existing import node and return null. importedNode.CodeNode = codeNode; return null; } node.CodeNode = codeNode; mModuleTable.Add(modulePathFileName, node); return node; }
private void EmitImportNode(ImportNode node, out AssociativeNode outnode) { Validity.Assert(node != null); ProtoCore.AST.AssociativeAST.ImportNode importNode = null; importNode = new ProtoCore.AST.AssociativeAST.ImportNode(); importNode.ModuleName = node.ModuleName; //(AstRootNode as CodeBlockNode).Body.Add(importNode); outnode = importNode; }
public ProtoCore.AST.AssociativeAST.ImportNode Import(string moduleName, string typeName, string alias, int line = -1, int col = -1) { curLine = line; curCol = col; moduleName = moduleName.Replace("\"", String.Empty); ProtoCore.AST.AssociativeAST.ImportNode node = new ProtoCore.AST.AssociativeAST.ImportNode(); node.ModuleName = moduleName; string modulePathFileName = FileUtils.GetDSFullPathName(moduleName, _coreObj.Options); // Tracking directory paths for all imported DS files during preload assembly stage so that they can be accessed by Graph compiler before execution - pratapa if (_coreObj.IsParsingPreloadedAssembly) { string dirName = Path.GetDirectoryName(modulePathFileName); if (!string.IsNullOrEmpty(dirName) && !_coreObj.Options.IncludeDirectories.Contains(dirName)) { _coreObj.Options.IncludeDirectories.Add(dirName); } } if (string.IsNullOrEmpty(typeName)) { //Check if moduleName is a type name with namespace. Type type = Type.GetType(moduleName); if (type != null) { typeName = type.FullName; modulePathFileName = type.Assembly.Location; } } if (modulePathFileName == null || !File.Exists(modulePathFileName)) { System.Diagnostics.Debug.Write(@"Cannot import file: '" + modulePathFileName); _coreObj.LogWarning(ProtoCore.BuildData.WarningID.kFileNotFound, string.Format(Resources.kFileNotFound, modulePathFileName)); return(null); } node.ModulePathFileName = modulePathFileName; node.CodeNode = null; if (typeName.Length > 0) { node.Identifiers.Add(typeName); } ProtoCore.AST.AssociativeAST.ImportNode importedNode = null; if (TryGetImportNode(modulePathFileName, typeName, out importedNode)) { node.HasBeenImported = true; return(node); } ProtoCore.AST.AssociativeAST.CodeBlockNode codeNode = null; if (importedNode == null) { codeNode = new ProtoCore.AST.AssociativeAST.CodeBlockNode(); } else { codeNode = importedNode.CodeNode; } try { codeNode = ImportCodeBlock(modulePathFileName, typeName, alias, codeNode); } catch (System.Exception ex) { if (ex.InnerException != null) { _coreObj.BuildStatus.LogSemanticError(ex.InnerException.Message); } _coreObj.BuildStatus.LogSemanticError(ex.Message); } //Cache the codeblock of root import node. CodeBlockNode rootImportCodeBlock = mRootImportNode.CodeNode; mRootImportNode.CodeNode = new CodeBlockNode(); //reset with the new one. //Remove all empty nodes and add to root import node. codeNode.Body.RemoveAll(AddToRootImportNodeIfEmpty); if (mRootImportNode.CodeNode.Body.Count == 0) //empty { mRootImportNode.CodeNode = rootImportCodeBlock; //reset the old one. } if (importedNode != null) { //module has import node, but type is not imported yet. //MergeCodeBlockNode(ref importedNode, codeBlockNode); //update existing import node and return null. importedNode.CodeNode = codeNode; return(null); } node.CodeNode = codeNode; mModuleTable.Add(modulePathFileName, node); return(node); }