private ProtoCore.AST.AssociativeAST.CodeBlockNode ImportDesignScriptFile(string designScriptFile, string typeName, string alias)
{
string curDirectory = Directory.GetCurrentDirectory();
Directory.SetCurrentDirectory(Path.GetDirectoryName(designScriptFile));
ProtoCore.AST.AssociativeAST.CodeBlockNode importCodeblockNode = null;
try
{
ProtoCore.DesignScriptParser.Scanner scanner = new ProtoCore.DesignScriptParser.Scanner(designScriptFile);
ProtoCore.DesignScriptParser.Parser parser = new ProtoCore.DesignScriptParser.Parser(scanner, _coreObj, true);
parser.ImportModuleHandler = this;
//System.IO.StringWriter parseErrors = new System.IO.StringWriter();
//parser.errors.errorStream = parseErrors;
parser.Parse();
//if (parseErrors.ToString() != String.Empty)
//_coreObj.BuildStatus.LogSyntaxError(parseErrors.ToString());
//_coreObj.BuildStatus.errorCount += parser.errors.count;
importCodeblockNode = (ProtoCore.AST.AssociativeAST.CodeBlockNode)parser.root;
}
finally
{
Directory.SetCurrentDirectory(curDirectory);
}
return(importCodeblockNode);
}
public override bool Compile(
out int blockId,
ProtoCore.DSASM.CodeBlock parentBlock,
ProtoCore.LanguageCodeBlock langBlock,
ProtoCore.CompileTime.Context callContext,
ProtoCore.DebugServices.EventSink sink = null,
ProtoCore.AST.Node codeBlockNode = null,
ProtoCore.AssociativeGraph.GraphNode graphNode = null)
{
Validity.Assert(langBlock != null);
bool buildSucceeded = true;
blockId = 0;
core.assocCodegen = new ProtoVHDL.CodeGen(core, callContext, parentBlock);
System.IO.MemoryStream memstream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(langBlock.body));
ProtoCore.DesignScriptParser.Scanner s = new ProtoCore.DesignScriptParser.Scanner(memstream);
ProtoCore.DesignScriptParser.Parser p = new ProtoCore.DesignScriptParser.Parser(s, core, core.builtInsLoaded);
p.Parse();
core.builtInsLoaded = true;
codeBlockNode = p.root;
List <ProtoCore.AST.Node> astNodes = ProtoCore.Utils.ParserUtils.GetAstNodes(codeBlockNode);
core.AstNodeList = astNodes;
core.assocCodegen.Emit(codeBlockNode as ProtoCore.AST.AssociativeAST.CodeBlockNode);
buildSucceeded = core.BuildStatus.BuildSucceeded;
return(buildSucceeded);
}
/// Checks if the string in code block node is a literal or an identifier or has multiple lines of code.
/// </summary>
/// <param name="code"></param>
/// <returns></returns>
public static SnapshotNodeType AnalyzeString(string code)
{
SnapshotNodeType type = SnapshotNodeType.None;
if (!code.EndsWith(";"))
{
code += ";";
}
List <ProtoCore.AST.Node> n = new List <ProtoCore.AST.Node>();
try
{
ProtoCore.Options options = new ProtoCore.Options();
options.RootModulePathName = string.Empty;
ProtoCore.Core core = new ProtoCore.Core(options);
core.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(core));
core.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(core));
core.IsParsingPreloadedAssembly = false;
core.IsParsingCodeBlockNode = true;
core.ParsingMode = ProtoCore.ParseMode.AllowNonAssignment;
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, core);
p.Parse();
ProtoCore.AST.AssociativeAST.CodeBlockNode codeBlockNode = p.root as ProtoCore.AST.AssociativeAST.CodeBlockNode;
n = p.GetParsedASTList(codeBlockNode);
}
catch (Exception)
{
//if syntax return SnapshotNodeType as None
return(SnapshotNodeType.CodeBlock);
}
if (n.Count > 1 || n.Count == 0)
{
type = SnapshotNodeType.CodeBlock;
}
else if (n[0] is ProtoCore.AST.AssociativeAST.BinaryExpressionNode)
{
type = SnapshotNodeType.CodeBlock;
}
else if (n[0] is ProtoCore.AST.AssociativeAST.IdentifierNode)
{
type = SnapshotNodeType.Identifier;
}
else if (n[0] is ProtoCore.AST.AssociativeAST.IntNode || n[0] is ProtoCore.AST.AssociativeAST.DoubleNode || n[0] is ProtoCore.AST.AssociativeAST.StringNode || n[0] is ProtoCore.AST.AssociativeAST.FunctionCallNode || n[0] is ProtoCore.AST.AssociativeAST.RangeExprNode)
{
type = SnapshotNodeType.Literal;
}
else
{
type = SnapshotNodeType.CodeBlock;
}
return(type);
}
/// <summary>
/// Parses designscript code and outputs comment nodes and returns CodeBlockNode
/// </summary>
/// <param name="core"></param>
/// <param name="code"> Source code to parse </param>
/// <param name="commentNode"> Comments in the code are preserved and stored in commentNode</param>
public static ProtoCore.AST.Node Parse(Core core, string code, out ProtoCore.AST.AssociativeAST.CodeBlockNode commentNode)
{
commentNode = null;
ProtoCore.DesignScriptParser.Parser p = ProtoCore.Utils.ParserUtils.ParseInternal(core, code);
Validity.Assert(null != p);
commentNode = p.commentNode;
return(p.root);
}
/// <summary>
/// Parses designscript code and returns a ProtoAST CodeBlockNode
/// </summary>
/// <param name="code"> Source code to parse </param>
public static ProtoCore.AST.Node Parse(Core core, string code)
{
Validity.Assert(core != null);
Validity.Assert(code != null);
ProtoCore.DesignScriptParser.Parser p = ProtoCore.Utils.ParserUtils.ParseInternal(core, code);
Validity.Assert(null != p);
return(p.root);
}
/// <summary>
/// Parses desginscript code with specified core and returns a
/// ProtoAST CodeBlockNode
/// </summary>
/// <param name="code"></param>
/// <param name="core"></param>
/// <returns></returns>
public static ProtoCore.AST.Node ParseWithCore(string code, ProtoCore.Core core)
{
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, core);
Validity.Assert(null != p);
p.Parse();
return(p.root);
}
/// <summary>
/// Parses designscript sourcecode and ouputs a Parser instance
/// Used internally by ParserUtils
/// </summary>
/// <param name="statement"></param>
private static ProtoCore.DesignScriptParser.Parser ParseInternal(Core core, string statement)
{
Validity.Assert(core != null);
Validity.Assert(statement != 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, core);
p.Parse();
return(p);
}
private ProtoCore.Core CompileCodeSnapshot(AutoCompleteWorkData workData)
{
if (null != this.scopeIdentifiers)
{
this.scopeIdentifiers.Clear();
this.scopeIdentifiers = null;
}
ProtoCore.Options options = new ProtoCore.Options();
options.RootModulePathName = workData.ScriptPath;
ProtoCore.Core core = new ProtoCore.Core(options);
core.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)
{
core.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, core);
try
{
p.Parse();
CoreCodeGen.arrayTypeTable = new ArrayTypeTable();
AssociativeCodeGen codegen = new AssociativeCodeGen(core);
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);
core = null;
}
finally
{
// Do necessary clean-up here.
}
return(core);
}
public static bool Compare(string s1, string s2, ProtoLanguage.CompileStateTracker compileState)
{
System.IO.MemoryStream memstream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(s1));
ProtoCore.DesignScriptParser.Scanner s = new ProtoCore.DesignScriptParser.Scanner(memstream);
ProtoCore.DesignScriptParser.Parser p = new ProtoCore.DesignScriptParser.Parser(s, compileState);
p.Parse();
ProtoCore.AST.Node s1Root = p.root;
memstream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(s2));
s = new ProtoCore.DesignScriptParser.Scanner(s2);
p = new ProtoCore.DesignScriptParser.Parser(s, compileState);
p.Parse();
ProtoCore.AST.Node s2Root = p.root;
bool areEqual = s1Root.Compare(s2Root);
return areEqual;
}
public static bool Compare(string s1, string s2, Core core)
{
System.IO.MemoryStream memstream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(s1));
ProtoCore.DesignScriptParser.Scanner s = new ProtoCore.DesignScriptParser.Scanner(memstream);
ProtoCore.DesignScriptParser.Parser p = new ProtoCore.DesignScriptParser.Parser(s, core);
p.Parse();
ProtoCore.AST.Node s1Root = p.root;
memstream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(s2));
s = new ProtoCore.DesignScriptParser.Scanner(s2);
p = new ProtoCore.DesignScriptParser.Parser(s, core);
p.Parse();
ProtoCore.AST.Node s2Root = p.root;
bool areEqual = s1Root.Equals(s2Root);
return(areEqual);
}
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);
}
/// Checks if the string in code block node is a literal or an identifier or has multiple lines of code.
/// </summary>
/// <param name="code"></param>
/// <returns></returns>
public static SnapshotNodeType AnalyzeString(string code)
{
SnapshotNodeType type = SnapshotNodeType.None;
if (!code.EndsWith(";")) code += ";";
List<ProtoCore.AST.Node> n = new List<ProtoCore.AST.Node>();
try
{
ProtoCore.Options options = new ProtoCore.Options();
options.RootModulePathName = string.Empty;
ProtoCore.Core core = new ProtoCore.Core(options);
core.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(core));
core.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(core));
core.IsParsingPreloadedAssembly = false;
core.IsParsingCodeBlockNode = true;
core.ParsingMode = ProtoCore.ParseMode.AllowNonAssignment;
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, core);
p.Parse();
ProtoCore.AST.AssociativeAST.CodeBlockNode codeBlockNode = p.root as ProtoCore.AST.AssociativeAST.CodeBlockNode;
n = p.GetParsedASTList(codeBlockNode);
}
catch (Exception)
{
//if syntax return SnapshotNodeType as None
return SnapshotNodeType.CodeBlock;
}
if (n.Count > 1 || n.Count == 0)
type = SnapshotNodeType.CodeBlock;
else if (n[0] is ProtoCore.AST.AssociativeAST.BinaryExpressionNode)
type = SnapshotNodeType.CodeBlock;
else if (n[0] is ProtoCore.AST.AssociativeAST.IdentifierNode)
type = SnapshotNodeType.Identifier;
else if (n[0] is ProtoCore.AST.AssociativeAST.IntNode || n[0] is ProtoCore.AST.AssociativeAST.DoubleNode || n[0] is ProtoCore.AST.AssociativeAST.StringNode || n[0] is ProtoCore.AST.AssociativeAST.FunctionCallNode || n[0] is ProtoCore.AST.AssociativeAST.RangeExprNode)
type = SnapshotNodeType.Literal;
else type = SnapshotNodeType.CodeBlock;
return type;
}
private static void GetOutputLines(string code, ProtoCore.Core core, Dictionary<int, string> outputLines)
{
Validity.Assert(code != null);
if (!String.IsNullOrEmpty(code))
{
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, core);
p.Parse();
foreach (var astNode in core.AstNodeList)
{
var binaryExpr = astNode as ProtoCore.AST.AssociativeAST.BinaryExpressionNode;
while (binaryExpr != null)
{
var lhsVariable = binaryExpr.LeftNode as ProtoCore.AST.AssociativeAST.IdentifierNode;
if (lhsVariable != null)
{
outputLines[lhsVariable.line] = lhsVariable.Name;
}
// deal with the case of continuous assingment
binaryExpr = binaryExpr.RightNode as ProtoCore.AST.AssociativeAST.BinaryExpressionNode;
}
}
}
}
public override bool Compile(ProtoLanguage.CompileStateTracker compileState, out int blockId, ProtoCore.DSASM.CodeBlock parentBlock, ProtoCore.LanguageCodeBlock langBlock, ProtoCore.CompileTime.Context callContext, ProtoCore.DebugServices.EventSink sink, ProtoCore.AST.Node codeBlockNode, ProtoCore.AssociativeGraph.GraphNode graphNode = null)
{
Debug.Assert(langBlock != null);
blockId = ProtoCore.DSASM.Constants.kInvalidIndex;
bool buildSucceeded = false;
bool isLangSignValid = compileState.Langverify.Verify(langBlock);
if (isLangSignValid)
{
try
{
ProtoCore.CodeGen oldCodegen = compileState.assocCodegen;
if (ProtoCore.DSASM.InterpreterMode.kNormal == compileState.ExecMode)
{
if ((compileState.IsParsingPreloadedAssembly || compileState.IsParsingCodeBlockNode) && parentBlock == null)
{
if (compileState.CodeBlockList.Count == 0)
{
compileState.assocCodegen = new ProtoAssociative.CodeGen(compileState, parentBlock);
}
else
{
// We reuse the existing toplevel CodeBlockList's for the procedureTable's
// by calling this overloaded constructor - pratapa
compileState.assocCodegen = new ProtoAssociative.CodeGen(compileState);
}
}
else
compileState.assocCodegen = new ProtoAssociative.CodeGen(compileState, parentBlock);
}
if (null != compileState.AssocNode)
{
ProtoCore.AST.AssociativeAST.CodeBlockNode cnode = new ProtoCore.AST.AssociativeAST.CodeBlockNode();
cnode.Body.Add(compileState.AssocNode as ProtoCore.AST.AssociativeAST.AssociativeNode);
compileState.assocCodegen.context = callContext;
blockId = compileState.assocCodegen.Emit((cnode as ProtoCore.AST.AssociativeAST.CodeBlockNode), graphNode);
}
else
{
//if not null, Compile has been called from DfsTraverse. No parsing is needed.
if (codeBlockNode == null)
{
System.IO.MemoryStream memstream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(langBlock.body));
ProtoCore.DesignScriptParser.Scanner s = new ProtoCore.DesignScriptParser.Scanner(memstream);
ProtoCore.DesignScriptParser.Parser p = new ProtoCore.DesignScriptParser.Parser(s, compileState, compileState.builtInsLoaded);
p.Parse();
// TODO Jun: Set this flag inside a persistent object
compileState.builtInsLoaded = true;
codeBlockNode = p.root;
//compileState.AstNodeList = p.GetParsedASTList(codeBlockNode as ProtoCore.AST.AssociativeAST.CodeBlockNode);
List<ProtoCore.AST.Node> astNodes = ProtoCore.Utils.ParserUtils.GetAstNodes(codeBlockNode);
compileState.AstNodeList = astNodes;
}
else
{
if (!compileState.builtInsLoaded)
{
// Load the built-in methods manually
ProtoCore.Utils.CoreUtils.InsertPredefinedAndBuiltinMethods(compileState, codeBlockNode, false);
compileState.builtInsLoaded = true;
}
}
compileState.assocCodegen.context = callContext;
//Temporarily change the code block for code gen to the current block, in the case it is an imperative block
//CodeGen for ProtoImperative is modified to passing in the core object.
ProtoCore.DSASM.CodeBlock oldCodeBlock = compileState.assocCodegen.codeBlock;
if (compileState.ExecMode == ProtoCore.DSASM.InterpreterMode.kExpressionInterpreter)
{
int tempBlockId = compileState.GetCurrentBlockId();
ProtoCore.DSASM.CodeBlock tempCodeBlock = compileState.GetCodeBlock(compileState.CodeBlockList, tempBlockId);
while (null != tempCodeBlock && tempCodeBlock.blockType != ProtoCore.DSASM.CodeBlockType.kLanguage)
{
tempCodeBlock = tempCodeBlock.parent;
}
compileState.assocCodegen.codeBlock = tempCodeBlock;
}
compileState.assocCodegen.codeBlock.EventSink = sink;
if (compileState.BuildStatus.Errors.Count == 0) //if there is syntax error, no build needed
{
blockId = compileState.assocCodegen.Emit((codeBlockNode as ProtoCore.AST.AssociativeAST.CodeBlockNode), graphNode);
}
if (compileState.ExecMode == ProtoCore.DSASM.InterpreterMode.kExpressionInterpreter)
{
blockId = compileState.assocCodegen.codeBlock.codeBlockId;
//Restore the code block.
compileState.assocCodegen.codeBlock = oldCodeBlock;
}
}
// @keyu: we have to restore asscoCodegen here. It may be
// reused later on. Suppose for an inline expression
// "x = 1 == 2 ? 3 : 4", we dynamically create assocCodegen
// to compile true and false expression in this inline
// expression, and if we don't restore assocCodegen, the pc
// is totally messed up.
//
// But if directly replace with old assocCodegen, will it
// replace some other useful information? Need to revisit it.
//
// Also refer to defect IDE-2120.
if (oldCodegen != null && compileState.assocCodegen != oldCodegen)
{
compileState.assocCodegen = oldCodegen;
}
}
catch (ProtoCore.BuildHaltException e)
{
#if DEBUG
//compileState.BuildStatus.LogSemanticError(e.errorMsg);
#endif
}
int errors = 0;
int warnings = 0;
buildSucceeded = compileState.BuildStatus.GetBuildResult(out errors, out warnings);
}
return buildSucceeded;
}
private ProtoCore.AST.AssociativeAST.CodeBlockNode ImportDesignScriptFile(string designScriptFile, string typeName, string alias)
{
string curDirectory = Directory.GetCurrentDirectory();
Directory.SetCurrentDirectory(Path.GetDirectoryName(designScriptFile));
ProtoCore.AST.AssociativeAST.CodeBlockNode importCodeblockNode = null;
try
{
ProtoCore.DesignScriptParser.Scanner scanner = new ProtoCore.DesignScriptParser.Scanner(designScriptFile);
ProtoCore.DesignScriptParser.Parser parser = new ProtoCore.DesignScriptParser.Parser(scanner, _coreObj, true);
parser.ImportModuleHandler = this;
//System.IO.StringWriter parseErrors = new System.IO.StringWriter();
//parser.errors.errorStream = parseErrors;
parser.Parse();
//if (parseErrors.ToString() != String.Empty)
//_coreObj.BuildStatus.LogSyntaxError(parseErrors.ToString());
//_coreObj.BuildStatus.errorCount += parser.errors.count;
importCodeblockNode = (ProtoCore.AST.AssociativeAST.CodeBlockNode)parser.root;
}
finally
{
Directory.SetCurrentDirectory(curDirectory);
}
return importCodeblockNode;
}
/// <summary>
/// Parses designscript sourcecode and ouputs a Parser instance
/// Used internally by ParserUtils
/// </summary>
/// <param name="statement"></param>
private static ProtoCore.DesignScriptParser.Parser ParseInternal(Core core, string statement)
{
Validity.Assert(core != null);
Validity.Assert(statement != 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, core);
p.Parse();
return p;
}
private ProtoCore.Core CompileCodeSnapshot(AutoCompleteWorkData workData)
{
if (null != this.scopeIdentifiers)
{
this.scopeIdentifiers.Clear();
this.scopeIdentifiers = null;
}
ProtoCore.Options options = new ProtoCore.Options();
options.RootModulePathName = workData.ScriptPath;
ProtoCore.Core core = new ProtoCore.Core(options);
core.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)
core.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, core);
try
{
p.Parse();
CoreCodeGen.arrayTypeTable = new ArrayTypeTable();
AssociativeCodeGen codegen = new AssociativeCodeGen(core);
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);
core = null;
}
finally
{
// Do necessary clean-up here.
}
return core;
}
/// <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 override bool Compile(ProtoLanguage.CompileStateTracker compileState, out int blockId, ProtoCore.DSASM.CodeBlock parentBlock, ProtoCore.LanguageCodeBlock langBlock, ProtoCore.CompileTime.Context callContext, ProtoCore.DebugServices.EventSink sink, ProtoCore.AST.Node codeBlockNode, ProtoCore.AssociativeGraph.GraphNode graphNode = null)
{
Debug.Assert(langBlock != null);
blockId = ProtoCore.DSASM.Constants.kInvalidIndex;
bool buildSucceeded = false;
bool isLangSignValid = compileState.Langverify.Verify(langBlock);
if (isLangSignValid)
{
try
{
ProtoCore.CodeGen oldCodegen = compileState.assocCodegen;
if (ProtoCore.DSASM.InterpreterMode.kNormal == compileState.ExecMode)
{
if ((compileState.IsParsingPreloadedAssembly || compileState.IsParsingCodeBlockNode) && parentBlock == null)
{
if (compileState.CodeBlockList.Count == 0)
{
compileState.assocCodegen = new ProtoAssociative.CodeGen(compileState, parentBlock);
}
else
{
// We reuse the existing toplevel CodeBlockList's for the procedureTable's
// by calling this overloaded constructor - pratapa
compileState.assocCodegen = new ProtoAssociative.CodeGen(compileState);
}
}
else
{
compileState.assocCodegen = new ProtoAssociative.CodeGen(compileState, parentBlock);
}
}
if (null != compileState.AssocNode)
{
ProtoCore.AST.AssociativeAST.CodeBlockNode cnode = new ProtoCore.AST.AssociativeAST.CodeBlockNode();
cnode.Body.Add(compileState.AssocNode as ProtoCore.AST.AssociativeAST.AssociativeNode);
compileState.assocCodegen.context = callContext;
blockId = compileState.assocCodegen.Emit((cnode as ProtoCore.AST.AssociativeAST.CodeBlockNode), graphNode);
}
else
{
//if not null, Compile has been called from DfsTraverse. No parsing is needed.
if (codeBlockNode == null)
{
System.IO.MemoryStream memstream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(langBlock.body));
ProtoCore.DesignScriptParser.Scanner s = new ProtoCore.DesignScriptParser.Scanner(memstream);
ProtoCore.DesignScriptParser.Parser p = new ProtoCore.DesignScriptParser.Parser(s, compileState, compileState.builtInsLoaded);
p.Parse();
// TODO Jun: Set this flag inside a persistent object
compileState.builtInsLoaded = true;
codeBlockNode = p.root;
//compileState.AstNodeList = p.GetParsedASTList(codeBlockNode as ProtoCore.AST.AssociativeAST.CodeBlockNode);
List <ProtoCore.AST.Node> astNodes = ProtoCore.Utils.ParserUtils.GetAstNodes(codeBlockNode);
compileState.AstNodeList = astNodes;
}
else
{
if (!compileState.builtInsLoaded)
{
// Load the built-in methods manually
ProtoCore.Utils.CoreUtils.InsertPredefinedAndBuiltinMethods(compileState, codeBlockNode, false);
compileState.builtInsLoaded = true;
}
}
compileState.assocCodegen.context = callContext;
//Temporarily change the code block for code gen to the current block, in the case it is an imperative block
//CodeGen for ProtoImperative is modified to passing in the core object.
ProtoCore.DSASM.CodeBlock oldCodeBlock = compileState.assocCodegen.codeBlock;
if (compileState.ExecMode == ProtoCore.DSASM.InterpreterMode.kExpressionInterpreter)
{
int tempBlockId = compileState.GetCurrentBlockId();
ProtoCore.DSASM.CodeBlock tempCodeBlock = compileState.GetCodeBlock(compileState.CodeBlockList, tempBlockId);
while (null != tempCodeBlock && tempCodeBlock.blockType != ProtoCore.DSASM.CodeBlockType.kLanguage)
{
tempCodeBlock = tempCodeBlock.parent;
}
compileState.assocCodegen.codeBlock = tempCodeBlock;
}
compileState.assocCodegen.codeBlock.EventSink = sink;
if (compileState.BuildStatus.Errors.Count == 0) //if there is syntax error, no build needed
{
blockId = compileState.assocCodegen.Emit((codeBlockNode as ProtoCore.AST.AssociativeAST.CodeBlockNode), graphNode);
}
if (compileState.ExecMode == ProtoCore.DSASM.InterpreterMode.kExpressionInterpreter)
{
blockId = compileState.assocCodegen.codeBlock.codeBlockId;
//Restore the code block.
compileState.assocCodegen.codeBlock = oldCodeBlock;
}
}
// @keyu: we have to restore asscoCodegen here. It may be
// reused later on. Suppose for an inline expression
// "x = 1 == 2 ? 3 : 4", we dynamically create assocCodegen
// to compile true and false expression in this inline
// expression, and if we don't restore assocCodegen, the pc
// is totally messed up.
//
// But if directly replace with old assocCodegen, will it
// replace some other useful information? Need to revisit it.
//
// Also refer to defect IDE-2120.
if (oldCodegen != null && compileState.assocCodegen != oldCodegen)
{
compileState.assocCodegen = oldCodegen;
}
}
catch (ProtoCore.BuildHaltException e)
{
#if DEBUG
//compileState.BuildStatus.LogSemanticError(e.errorMsg);
#endif
}
int errors = 0;
int warnings = 0;
buildSucceeded = compileState.BuildStatus.GetBuildResult(out errors, out warnings);
}
return(buildSucceeded);
}
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);
}
public static List<SnapshotNode> NodeToCodeBlocks(List<SnapshotNode> inputs, GraphToDSCompiler.GraphCompiler originalGC)
{
List<SnapshotNode> codeBlocks = new List<SnapshotNode>();
GraphToDSCompiler.GraphCompiler newGC = GraphCompiler.CreateInstance();
newGC.SetCore(core);
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;
BuildCore(true);
Validity.Assert(core != 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, core);
p.Parse();
commentNode = p.commentNode;
return p.root;
}
public static bool Parse(Guid nodeGUID, ref string code,
out List<ProtoCore.AST.Node> parsedNodes,
out IEnumerable<ProtoCore.BuildData.ErrorEntry> errors,
out IEnumerable<ProtoCore.BuildData.WarningEntry> warnings,
List<String> unboundIdentifiers,
out List<String> tempIdentifiers)
{
tempIdentifiers = new List<string>();
List<String> compiledCode = new List<String>();
parsedNodes = null;
//-----------------------------------------------------------------------------------
//--------------------------------Correct the code-----------------------------------
//-----------------------------------------------------------------------------------
// Use the compile expression to format the code by adding the required %t temp vars
// needed for non assignment statements
CompileExpression(code, out compiledCode);
string codeToParse = "";
for (int i = 0; i < compiledCode.Count; i++)
{
string tempVariableName = string.Format("temp_{0}_", i) + nodeGUID.ToString().Replace("-", "_");
tempIdentifiers.Add(tempVariableName);
string singleExpression = compiledCode[i];
singleExpression = singleExpression.Replace("%t", tempVariableName);
codeToParse += singleExpression;
}
code = codeToParse;
//Catch the errors thrown by compile expression, namely function modiferstack and class decl found
if (core.BuildStatus.ErrorCount > 0)
{
errors = core.BuildStatus.Errors;
warnings = core.BuildStatus.Warnings;
parsedNodes = null;
return false;
}
// Parse and compile the code to get the result AST nodes as well as
// any errors or warnings that were caught by the comiler
ProtoCore.BuildStatus buildStatus;
var tempUnboundIdentifiers = new Dictionary<int, List<VariableLine>>();
List<ProtoCore.AST.Node> nodeList = new List<ProtoCore.AST.Node>();
ParseCodeBlockNodeStatements(codeToParse, out tempUnboundIdentifiers, out nodeList, out buildStatus);
errors = buildStatus.Errors;
warnings = buildStatus.Warnings;
//Get the unboundIdentifiers from the warnings
foreach (KeyValuePair<int, List<VariableLine>> kvp in tempUnboundIdentifiers)
{
foreach (VariableLine vl in kvp.Value)
{
if (!unboundIdentifiers.Contains(vl.variable))
{
unboundIdentifiers.Add(vl.variable);
}
}
}
// Assign the 'out' variables
// Use the parse function to get the parsed nodes to return to the
// user
if (nodeList != null)
{
parsedNodes = new List<ProtoCore.AST.Node>();
ProtoCore.AST.AssociativeAST.CodeBlockNode cNode;
parsedNodes = ParserUtils.GetAstNodes(Parse(codeToParse, out cNode));
}
else
{
parsedNodes = null;
}
return true;
}
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] + ";";
}*/
ProtoCore.Options options = new ProtoCore.Options();
ProtoCore.Core core = new ProtoCore.Core(options);
core.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(core));
core.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(core));
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, core);
p.Parse();
ProtoCore.AST.AssociativeAST.CodeBlockNode cbn = p.root as ProtoCore.AST.AssociativeAST.CodeBlockNode;
Validity.Assert(cbn != null);
return p.GetParsedASTList(cbn);
}
/// <summary>
/// Checks if the string in code block node is a literal or an identifier or has multiple lines of code.
/// </summary>
/// <param name="code"></param>
/// <returns></returns>
public static SnapshotNodeType AnalyzeString(string code)
{
SnapshotNodeType type = SnapshotNodeType.None;
if (!code.EndsWith(";")) code += ";";
List<ProtoCore.AST.Node> n = new List<ProtoCore.AST.Node>();
try
{
BuildCore(true);
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, core);
p.Parse();
ProtoCore.AST.AssociativeAST.CodeBlockNode codeBlockNode = p.root as ProtoCore.AST.AssociativeAST.CodeBlockNode;
n = p.GetParsedASTList(codeBlockNode);
}
catch (Exception exception)
{
//if syntax return SnapshotNodeType as None
return SnapshotNodeType.CodeBlock;
}
/*
string LiteralPatternInt = @"^\s*-?\d+\s*$";
string LiteralPatternDouble = @"^\d+([\.]\d+)?$";
string LiteralPatternString = "^\"([^\"\\\\]|\\\\.)*\"$";
string IdentifierPattern = @"^\s*[_a-zA-Z][_a-z0-9A-Z@]*\s*$";
Match matchInt = Regex.Match(code, LiteralPatternInt);
Match matchDouble = Regex.Match(code, LiteralPatternDouble);
Match matchString = Regex.Match(code, LiteralPatternString);
Match matchIdentifier = Regex.Match(code, IdentifierPattern);
if (matchInt.Success || matchString.Success || matchDouble.Success)
type = StringExpressionType.Literal;
else if (matchIdentifier.Success)
type = StringExpressionType.Identifier;
else
type = StringExpressionType.CodeBlock;*/
if (n.Count > 1 || n.Count == 0)
type = SnapshotNodeType.CodeBlock;
else if (n[0] is ProtoCore.AST.AssociativeAST.BinaryExpressionNode)
type = SnapshotNodeType.CodeBlock;
else if (n[0] is ProtoCore.AST.AssociativeAST.IdentifierNode)
type = SnapshotNodeType.Identifier;
else if (n[0] is ProtoCore.AST.AssociativeAST.IntNode || n[0] is ProtoCore.AST.AssociativeAST.DoubleNode || n[0] is ProtoCore.AST.AssociativeAST.StringNode || n[0] is ProtoCore.AST.AssociativeAST.FunctionCallNode || n[0] is ProtoCore.AST.AssociativeAST.RangeExprNode)
type = SnapshotNodeType.Literal;
else type = SnapshotNodeType.CodeBlock;
return type;
}
/*
proc RewriteCodeBlock(Node codeblock)
// Create new codeblocks for every line of code in the current codeblock CodeBlock[] newBlockList = new CodeBlock[node.lines.length]
for n = 0 to node.lines.length
newBlockList[n].code = node.lines[n]
newBlockList[n].uid = generateUID(codeblock.uid)
end
// At this point, determine which parents of the current codeblock node need to be connected to each splitted node
// Iterate through each parent of the current code block
foreach parentNode in codeblock.parents
// Iterate through each child of the parent
for n = 0 to parentNode.children.length
// Check if the child is this codeblock
if parentNode.children[n] is equal to codeblock
// index ‘n’ is the current output slot of the codeblock
newBlockList[n].parent.push(parentNode)
// Rewire the parent’s child to this new codeblock
parentNode.children[n] = newBlockList[n]
end
n++;
end
end
end
*/
/*private List<Block> RewriteCodeBlock(Block codeblock)
{
Validity.Assert(codeblock != null);
if (codeblock.Name == null || codeblock.Name.Length <= 0)
{
return null;
}
// Comment Jun: Im just trying to find the number of times ';' occurs
// Make this more efficient by turning this into a function in a utils class
string dummy = codeblock.Name.Replace(";", "");
if ((codeblock.Name.Length - dummy.Length) <= 1)
{
// Single line codeblocks need not be split
return null;
}
string[] token = new string[1];
token[0] = ProtoCore.DSASM.Constants.termline;
StringSplitOptions opt = new StringSplitOptions();
string[] contents = codeblock.Name.Split(token, opt);
int length = contents.Length;
// The map of the new uid and its associated connecting slot
Dictionary<int, uint> slotIndexToUIDMap = new Dictionary<int, uint>();
// Create new codeblocks for every line of code in the current codeblock CodeBlock[] newBlockList = new CodeBlock[node.lines.length]
List<Block> newBlockList = new List<Block>();
for (int n = 0; n < length; n++)
{
// TODO Jun: Check with IDE why the semicolon is inconsitent
string code = contents[n];
if (code.Length > 0 && code[0] != ';')
{
uint newGuid = GraphUtilities.GenerateUID();
List<AssignmentStatement> assignmentData = new List<AssignmentStatement>();
if (codeblock.assignmentData.Count > 0)
{
// This assignemnt data list must contain only 1 element
// This element is associated witht he current line in the codeblock
assignmentData.Add(codeblock.assignmentData[n]);
}
Block newBlock = new Block(code, newGuid, assignmentData);
newBlock.splitFomUint = codeblock.Guid;
newBlockList.Add(newBlock);
slotIndexToUIDMap.Add(n, newGuid);
}
}
// At this point, determine which parents of the current codeblock node need to be connected to each splitted node
// Iterate through each parent of the current code block
List<Node> parents = codeblock.GetParents();
foreach (Node parentNode in parents)
{
// Iterate through each child of the parent
for (int childIndex = 0; childIndex < parentNode.children.Count; childIndex++)
{
Node child = null;
bool foundIndex = parentNode.children.TryGetValue(childIndex, out child);
if (foundIndex)
{
// Check if the child is this codeblock
if (child.Guid == codeblock.Guid)
{
int fromIndex = parentNode.childConnections[childIndex].from;
// Set the new codeblock's parent
newBlockList[fromIndex].AddParent(parentNode);
// Rewire the parent’s child to this new codeblock
parentNode.RemoveChild(childIndex);
parentNode.AddChild(newBlockList[fromIndex], childIndex, fromIndex);
}
}
}
}
if (codeBlockUIDMap.ContainsKey(codeblock.Guid))
{
codeBlockUIDMap[codeblock.Guid] = slotIndexToUIDMap;
}
else
{
codeBlockUIDMap.Add(codeblock.Guid, slotIndexToUIDMap);
}
return newBlockList;
}*/
private List<ProtoCore.AST.Node> ParseCodeBlock(string code)
{
Validity.Assert(code != null);
if (string.IsNullOrEmpty(code))
return null;
ProtoCore.Options options = new ProtoCore.Options();
ProtoCore.Core core = new ProtoCore.Core(options);
core.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(core));
core.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(core));
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, core);
p.Parse();
ProtoCore.AST.AssociativeAST.CodeBlockNode cbn = p.root as ProtoCore.AST.AssociativeAST.CodeBlockNode;
Validity.Assert(cbn != null);
return p.GetParsedASTList(cbn);
}
/// <summary>
/// Parses desginscript code with specified core and returns a
/// ProtoAST CodeBlockNode
/// </summary>
/// <param name="code"></param>
/// <param name="core"></param>
/// <returns></returns>
public static ProtoCore.AST.Node ParseWithCore(string code, ProtoCore.Core core)
{
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, core);
Validity.Assert(null != p);
p.Parse();
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] + ";";
}*/
ProtoCore.Options options = new ProtoCore.Options();
ProtoCore.Core core = new ProtoCore.Core(options);
core.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(core));
core.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(core));
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, core);
p.Parse();
ProtoCore.AST.AssociativeAST.CodeBlockNode cbn = p.root as ProtoCore.AST.AssociativeAST.CodeBlockNode;
Validity.Assert(cbn != null);
return p.GetParsedASTList(cbn);
}
