private static ProtoLanguage.CompileStateTracker BuildCompilerState(ProtoLanguage.CompileOptions options) { ProtoLanguage.CompileStateTracker compileState = new ProtoLanguage.CompileStateTracker(options); compileState.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive()); compileState.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive()); return(compileState); }
/// <summary> /// TODO Jun : Remove me after the tracker + core swap-out /// </summary> /// <param name="fileName"></param> /// <param name="options"></param> /// <returns></returns> public static string GetDSFullPathName(string fileName, ProtoLanguage.CompileOptions options = null) { //1. First search at .exe module directory, in case files of the same name exists in the following directories. // The .exe module directory is of highest priority. // CodeBase is used here because Assembly.Location does not work quite well when the module is shallow-copied in nunit test. if (Path.IsPathRooted(fileName)) { if (File.Exists(fileName)) { return(Path.GetFullPath(fileName)); } fileName = Path.GetFileName(fileName); } string fullPathName; if (GetFullPath(fileName, GetInstallLocation(), out fullPathName)) { return(fullPathName); } //2. Search relative to the .ds file directory string rootModulePath = "."; if (null != options && !string.IsNullOrEmpty(options.RootModulePathName)) { rootModulePath = options.RootModulePathName; } if (GetFullPath(fileName, rootModulePath, out fullPathName)) { return(fullPathName); } if (null != options) { //3. Search at include directories. // This will include the import path. foreach (string directory in options.IncludeDirectories) { fullPathName = Path.Combine(directory, fileName); if (null != fullPathName && File.Exists(fullPathName)) { return(fullPathName); } } } //4. Search the absolute path or relative to the current directory if (File.Exists(fileName)) { return(Path.GetFullPath(fileName)); } return(fileName); }
public static ProtoLanguage.CompileStateTracker BuildDebuggertCompilerState(Dictionary <string, Object> context = null) { ProtoLanguage.CompileOptions options = new ProtoLanguage.CompileOptions(); options.IDEDebugMode = true; ProtoLanguage.CompileStateTracker compileState = BuildCompilerState(options); if (null != context) { compileState.AddContextData(context); } return(compileState); }
public static ProtoLanguage.CompileStateTracker BuildLiveRunnerCompilerState(Dictionary <string, Object> context = null) { ProtoLanguage.CompileOptions options = new ProtoLanguage.CompileOptions(); options.IsDeltaExecution = true; ProtoLanguage.CompileStateTracker compileState = BuildCompilerState(options); if (null != context) { compileState.AddContextData(context); } return(compileState); }
public static ProtoLanguage.CompileStateTracker BuildDefaultCompilerState(bool isDeltaExecution = false, Dictionary <string, Object> context = null) { if (isDeltaExecution) { return(BuildLiveRunnerCompilerState(context)); } ProtoLanguage.CompileOptions options = new ProtoLanguage.CompileOptions(); ProtoLanguage.CompileStateTracker compileState = BuildCompilerState(options); if (null != context) { compileState.AddContextData(context); } return(compileState); }
public static ProtoLanguage.CompileStateTracker BuildDefaultCompilerState(Dictionary<string, Object> context = null) { ProtoLanguage.CompileOptions options = new ProtoLanguage.CompileOptions(); ProtoLanguage.CompileStateTracker compileState = new ProtoLanguage.CompileStateTracker(options); compileState.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive()); compileState.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive()); if (null != context) { compileState.AddContextData(context); } return compileState; }
public static ProtoLanguage.CompileStateTracker BuildDefaultCompilerState(Dictionary <string, Object> context = null) { ProtoLanguage.CompileOptions options = new ProtoLanguage.CompileOptions(); ProtoLanguage.CompileStateTracker compileState = new ProtoLanguage.CompileStateTracker(options); compileState.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive()); compileState.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive()); if (null != context) { compileState.AddContextData(context); } return(compileState); }
private ProtoLanguage.CompileStateTracker CompileCodeSnapshot(AutoCompleteWorkData workData) { if (null != this.scopeIdentifiers) { this.scopeIdentifiers.Clear(); this.scopeIdentifiers = null; } ProtoLanguage.CompileOptions options = new ProtoLanguage.CompileOptions(); options.RootModulePathName = workData.ScriptPath; ProtoLanguage.CompileStateTracker compileState = new ProtoLanguage.CompileStateTracker(options); compileState.CurrentDSFileName = workData.ScriptPath; ProtoFFI.DLLFFIHandler.Register(ProtoFFI.FFILanguage.CSharp, new ProtoFFI.CSModuleHelper()); // Register a message stream if we do have one. if (null != this.MessageHandler) { compileState.BuildStatus.MessageHandler = this.MessageHandler; } MemoryStream stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(workData.CodeSnapshot)); ProtoCore.DesignScriptParser.Scanner s = new ProtoCore.DesignScriptParser.Scanner(stream); ProtoCore.DesignScriptParser.Parser p = new ProtoCore.DesignScriptParser.Parser(s, compileState); try { p.Parse(); CoreCodeGen.arrayTypeTable = new ArrayTypeTable(); AssociativeCodeGen codegen = new AssociativeCodeGen(compileState); codegen.Emit(p.root as ProtoCore.AST.AssociativeAST.CodeBlockNode); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine("Exception Caught in CodeGen"); System.Diagnostics.Debug.WriteLine(ex.Message); compileState = null; } finally { // Do necessary clean-up here. } return(compileState); }
public static bool Compile(string src, string entryFile) { ProtoLanguage.CompileOptions ops = new ProtoLanguage.CompileOptions(); ops.RootModulePathName = entryFile; if (null != AutoCompletionHelper.searchPaths) { ops.IncludeDirectories.AddRange(AutoCompletionHelper.searchPaths); } compileState = new ProtoLanguage.CompileStateTracker(ops); compileState.CurrentDSFileName = entryFile; CoreCodeGen.ResetInternalStates(); ProtoFFI.DLLFFIHandler.Register(ProtoFFI.FFILanguage.CSharp, new ProtoFFI.CSModuleHelper()); // Register a message stream if we do have one. if (null != AutoCompletionHelper.MessageHandler) { compileState.BuildStatus.MessageHandler = MessageHandler; } MemoryStream ms = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(src)); ProtoCore.DesignScriptParser.Scanner s = new ProtoCore.DesignScriptParser.Scanner(ms); ProtoCore.DesignScriptParser.Parser p = new ProtoCore.DesignScriptParser.Parser(s, compileState); try { p.Parse(); CoreCodeGen.arrayTypeTable = new ArrayTypeTable(); AssociativeCodeGen codegen = new AssociativeCodeGen(compileState); codegen.Emit(p.root as ProtoCore.AST.AssociativeAST.CodeBlockNode); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine("Exception Caught in CodeGen"); System.Diagnostics.Debug.WriteLine(ex.Message); return(false); } return(true); }
public static List<SnapshotNode> NodeToCodeBlocks(List<SnapshotNode> inputs, GraphToDSCompiler.GraphCompiler originalGC) { List<SnapshotNode> codeBlocks = new List<SnapshotNode>(); GraphToDSCompiler.GraphCompiler newGC = GraphCompiler.CreateInstance(); newGC.SetCore(compileState); GraphToDSCompiler.SynchronizeData newSyncData = new SynchronizeData(); newSyncData.AddedNodes = inputs; newSyncData.ModifiedNodes = new List<SnapshotNode>(); newSyncData.RemovedNodes = new List<uint>(); GraphToDSCompiler.GraphBuilder GB = new GraphBuilder(newSyncData, newGC); #region fix connection for multi-line CBN /*for multi-line code blocks*/ List<Node> completeList = originalGC.Graph.nodeList; List<uint> originalNodeUIDList = new List<uint>(); foreach (Node oriGcNode in completeList) { originalNodeUIDList.Add(oriGcNode.Guid); } GB.AddNodesToAST(); //List<SnapshotNode> inputsCopy = new List<SnapshotNode>(inputs); for (int i = 0; i < inputs.Count; i++) { SnapshotNode inputSnapshotNode = inputs[i]; for (int j = 0; j < inputSnapshotNode.InputList.Count; j++) { Connection inputConnection = inputSnapshotNode.InputList[j]; if (!originalNodeUIDList.Contains(inputConnection.OtherNode)) { Connection correctedInputConnection = new Connection(); correctedInputConnection.LocalName = inputConnection.LocalName; correctedInputConnection.LocalIndex = inputConnection.LocalIndex; correctedInputConnection.IsImplicit = inputConnection.IsImplicit; correctedInputConnection.OtherIndex = inputConnection.OtherIndex; if (newGC.codeBlockUIDMap.ContainsKey(inputConnection.OtherNode)) { correctedInputConnection.OtherNode = newGC.codeBlockUIDMap[inputConnection.OtherNode][inputConnection.OtherIndex]; } else { correctedInputConnection.OtherNode = originalGC.codeBlockUIDMap[inputConnection.OtherNode][inputConnection.OtherIndex]; } inputSnapshotNode.InputList.Remove(inputConnection); inputSnapshotNode.InputList.Insert(j, correctedInputConnection); } } for (int j = 0; j < inputSnapshotNode.OutputList.Count; j++) { Connection outputConnection = inputSnapshotNode.OutputList[j]; if (!originalNodeUIDList.Contains(outputConnection.OtherNode)) // if the other node is split { Connection correctedInputConnection = new Connection(); correctedInputConnection.LocalName = outputConnection.LocalName; correctedInputConnection.LocalIndex = outputConnection.LocalIndex; correctedInputConnection.IsImplicit = outputConnection.IsImplicit; correctedInputConnection.OtherIndex = outputConnection.OtherIndex; if (newGC.codeBlockUIDMap.ContainsKey(outputConnection.OtherNode)) { correctedInputConnection.OtherNode = newGC.GetUidOfRHSIdentifierInCodeBlock( outputConnection.OtherNode, outputConnection.OtherIndex, outputConnection.LocalName); //correctedInputConnection.OtherNode = newGC.codeBlockUIDMap[outputConnection.OtherNode][outputConnection.OtherIndex]; } else { correctedInputConnection.OtherNode = originalGC.codeBlockUIDMap[outputConnection.OtherNode][outputConnection.OtherIndex]; } inputSnapshotNode.OutputList.Remove(outputConnection); inputSnapshotNode.OutputList.Insert(j, correctedInputConnection); } } } GB.nodesToAdd = inputs; GB.MakeConnectionsForAddedNodes_NodeToCode(GB.nodesToAdd); newGC.PrintGraph(); #endregion //GB.BuildGraphForCodeBlock(); List<uint> nodesToBeAdded = new List<uint>(); List<Node> nodesToBeReplaced = new List<Node>(); //adding children node from the originalGC to the newGC needed for the newGC to generate code foreach (Node n in completeList) { foreach (Node child in n.GetChildren()) { if (newGC.Graph.GetNode(child.Guid) != null) { if (child.Name != newGC.Graph.GetNode(child.Guid).Name) { nodesToBeReplaced.Add(child); } } } } foreach (uint n in nodesToBeAdded) { Node n1 = completeList.FirstOrDefault(q => q.Guid == n); //n1.children.Clear(); nodesToBeReplaced.Add(n1); //newSyncData.RemovedNodes.Add(n); } List<uint> nodeToCodeUIDs = new List<uint>(); foreach (SnapshotNode ssn in inputs) nodeToCodeUIDs.Add(ssn.Id); newGC.nodeToCodeUIDs = nodeToCodeUIDs; /*create output snapshot nodes*/ List<Connection> inputNodeInputConnections = new List<Connection>(); List<Connection> inputNodeOutputConnections = new List<Connection>(); foreach (SnapshotNode ssn in inputs) { foreach (Connection inputConnection in ssn.InputList) { if (!nodeToCodeUIDs.Contains(inputConnection.OtherNode)) inputNodeInputConnections.Add(inputConnection); } foreach (Connection outputConnection in ssn.OutputList) { if (!nodeToCodeUIDs.Contains(outputConnection.OtherNode)) inputNodeOutputConnections.Add(outputConnection); } } newGC.ReplaceNodesFromAList(nodesToBeReplaced); newSyncData.AddedNodes = new List<SnapshotNode>(); newSyncData.ModifiedNodes = new List<SnapshotNode>(); newSyncData.RemovedNodes = new List<uint>(); GB = new GraphBuilder(newSyncData, newGC); //string result = GB.BuildGraphDAG(); List<SnapshotNode> nodeToCodeBlocks = GB.PrintCodeForSelectedNodes(originalGC, inputs); /*for now, only connected nodes are supported: return all connections that are not internal connections (connections between the selected nodes)*/ //uint id = 0; //foreach (string content in toCode) //{ // SnapshotNode ssn = new SnapshotNode(); // ssn.Type = SnapshotNodeType.CodeBlock; // ssn.Content = content; // ssn.Id = id++; // ssn.InputList = new List<Connection>(); // //stupid stub // foreach (Connection inputConnection in inputNodeInputConnections) // { // Connection newInputConnection = new Connection(); // newInputConnection.OtherNode = inputConnection.OtherNode; // newInputConnection.OtherIndex = inputConnection.OtherIndex; // newInputConnection.IsImplicit = inputConnection.IsImplicit; // string[] tokens = newGC.Graph.GetNode(inputConnection.OtherNode).Name.Split('='); // newInputConnection.LocalName = tokens[0]; // ssn.InputList.Add(newInputConnection); // } // //ssn.InputList = inputNodeInputConnections; // ssn.OutputList = new List<Connection>(); // foreach (Connection outputConnection in inputNodeOutputConnections) // { // Connection newOutputConnection = new Connection(); // newOutputConnection.OtherNode = outputConnection.OtherNode; // newOutputConnection.OtherIndex = outputConnection.OtherIndex; // newOutputConnection.IsImplicit = outputConnection.IsImplicit; // //string[] tokens = originalGC.Graph.GetNode(outputConnection.OtherNode).Name.Split('='); // newOutputConnection.LocalName = outputConnection.LocalName; // ssn.OutputList.Add(newOutputConnection); // } // //ssn.OutputList = inputNodeOutputConnections; // codeBlocks.Add(ssn); //} /*update the original GC*/ foreach (SnapshotNode inputNode in inputs) { if (originalNodeUIDList.Contains(inputNode.Id)) originalGC.RemoveNodes(inputNode.Id, false); else { foreach (KeyValuePair<uint, Dictionary<int, uint>> kvp in originalGC.codeBlockUIDMap) { if (kvp.Value.ContainsValue(inputNode.Id)) { originalGC.RemoveNodes(kvp.Key, false); } } } } foreach (Node node in newGC.Graph.nodeList) { node.Name = node.Name.TrimEnd(';') + ";"; } originalGC.Graph.nodeList.Union<Node>(newGC.Graph.nodeList); //originalGC = newGC; /**/ return nodeToCodeBlocks; //return codeBlocks; } /// <summary> /// This is called to Parse individual assignment statements in Codeblock nodes in GraphUI /// and return the resulting ProtoAST node /// </summary> /// <param name="statement"></param> public static ProtoCore.AST.Node Parse(string statement, out ProtoCore.AST.AssociativeAST.CodeBlockNode commentNode) { commentNode = null; BuildCompileState(true); Validity.Assert(compileState != null); Validity.Assert(statement != null); if (string.IsNullOrEmpty(statement)) return null; System.IO.MemoryStream memstream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(statement)); ProtoCore.DesignScriptParser.Scanner s = new ProtoCore.DesignScriptParser.Scanner(memstream); ProtoCore.DesignScriptParser.Parser p = new ProtoCore.DesignScriptParser.Parser(s, compileState); p.Parse(); commentNode = p.commentNode; return p.root; } public static List<ProtoCore.AST.Node> ParseCodeBlock(string code) { Validity.Assert(code != null); if (string.IsNullOrEmpty(code)) return null; // TODO: Change the logic to ignore Import statements in this case using parser - pratapa // Check if this will work with modifier blocks as well /*string[] stmts = code.Split(';'); string source = ""; for (int i=0; i < stmts.Length; ++i) { if (!stmts[i].Contains("import")) source += stmts[i] + ";"; }*/ ProtoLanguage.CompileOptions options = new ProtoLanguage.CompileOptions(); ProtoLanguage.CompileStateTracker compileState = new ProtoLanguage.CompileStateTracker(options); //compileState.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(compileState)); //compileState.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(compileState)); System.IO.MemoryStream memstream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(code)); ProtoCore.DesignScriptParser.Scanner s = new ProtoCore.DesignScriptParser.Scanner(memstream); ProtoCore.DesignScriptParser.Parser p = new ProtoCore.DesignScriptParser.Parser(s, compileState); p.Parse(); ProtoCore.AST.AssociativeAST.CodeBlockNode cbn = p.root as ProtoCore.AST.AssociativeAST.CodeBlockNode; Validity.Assert(cbn != null); return p.GetParsedASTList(cbn); }
private static bool LocateAssembly(string assembly, out string assemblyPath) { ProtoLanguage.CompileOptions options = null; if (null == compileState) options = new ProtoLanguage.CompileOptions() { RootModulePathName = GraphUtilities.rootModulePath }; else options = compileState.Options; assemblyPath = FileUtils.GetDSFullPathName(assembly, options); string dirName = Path.GetDirectoryName(assemblyPath); if (!string.IsNullOrEmpty(dirName) && !compileState.Options.IncludeDirectories.Contains(dirName)) { compileState.Options.IncludeDirectories.Add(dirName); } return File.Exists(assemblyPath); }
private static void BuildCompileState(bool isCodeBlockNode = false, bool isPreloadedAssembly = false) { if (compileState == null) { ProtoLanguage.CompileOptions options = new ProtoLanguage.CompileOptions(); options.RootModulePathName = rootModulePath; compileState = new ProtoLanguage.CompileStateTracker(options); compileState.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive()); compileState.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive()); } else { compileState.ResetForPrecompilation(); } compileState.IsParsingPreloadedAssembly = isPreloadedAssembly; compileState.IsParsingCodeBlockNode = isCodeBlockNode; compileState.ParsingMode = ProtoCore.ParseMode.AllowNonAssignment; }
public static List<ProtoCore.AST.Node> ParseCodeBlock(string code) { Validity.Assert(code != null); if (string.IsNullOrEmpty(code)) return null; // TODO: Change the logic to ignore Import statements in this case using parser - pratapa // Check if this will work with modifier blocks as well /*string[] stmts = code.Split(';'); string source = ""; for (int i=0; i < stmts.Length; ++i) { if (!stmts[i].Contains("import")) source += stmts[i] + ";"; }*/ ProtoLanguage.CompileOptions options = new ProtoLanguage.CompileOptions(); ProtoLanguage.CompileStateTracker compileState = new ProtoLanguage.CompileStateTracker(options); //compileState.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(compileState)); //compileState.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(compileState)); System.IO.MemoryStream memstream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(code)); ProtoCore.DesignScriptParser.Scanner s = new ProtoCore.DesignScriptParser.Scanner(memstream); ProtoCore.DesignScriptParser.Parser p = new ProtoCore.DesignScriptParser.Parser(s, compileState); p.Parse(); ProtoCore.AST.AssociativeAST.CodeBlockNode cbn = p.root as ProtoCore.AST.AssociativeAST.CodeBlockNode; Validity.Assert(cbn != null); return p.GetParsedASTList(cbn); }
private ProtoLanguage.CompileStateTracker CompileCodeSnapshot(AutoCompleteWorkData workData) { if (null != this.scopeIdentifiers) { this.scopeIdentifiers.Clear(); this.scopeIdentifiers = null; } ProtoLanguage.CompileOptions options = new ProtoLanguage.CompileOptions(); options.RootModulePathName = workData.ScriptPath; ProtoLanguage.CompileStateTracker compileState = new ProtoLanguage.CompileStateTracker(options); compileState.CurrentDSFileName = workData.ScriptPath; ProtoFFI.DLLFFIHandler.Register(ProtoFFI.FFILanguage.CSharp, new ProtoFFI.CSModuleHelper()); // Register a message stream if we do have one. if (null != this.MessageHandler) compileState.BuildStatus.MessageHandler = this.MessageHandler; MemoryStream stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(workData.CodeSnapshot)); ProtoCore.DesignScriptParser.Scanner s = new ProtoCore.DesignScriptParser.Scanner(stream); ProtoCore.DesignScriptParser.Parser p = new ProtoCore.DesignScriptParser.Parser(s, compileState); try { p.Parse(); CoreCodeGen.arrayTypeTable = new ArrayTypeTable(); AssociativeCodeGen codegen = new AssociativeCodeGen(compileState); codegen.Emit(p.root as ProtoCore.AST.AssociativeAST.CodeBlockNode); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine("Exception Caught in CodeGen"); System.Diagnostics.Debug.WriteLine(ex.Message); compileState = null; } finally { // Do necessary clean-up here. } return compileState; }