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);
}
protected void EmitExprListNode(Node node, ref ProtoCore.Type inferedType, ProtoCore.AssociativeGraph.GraphNode graphNode = null, ProtoCore.DSASM.AssociativeSubCompilePass subPass = ProtoCore.DSASM.AssociativeSubCompilePass.kNone)
{
int firstType = (int)PrimitiveType.kTypeVoid;
dynamic exprlist = node;
int rank = 0;
if (subPass != ProtoCore.DSASM.AssociativeSubCompilePass.kUnboundIdentifier)
{
//get the rank
dynamic ltNode = exprlist;
while ((ltNode is ProtoCore.AST.ImperativeAST.ExprListNode || ltNode is ProtoCore.AST.AssociativeAST.ExprListNode) && ltNode.list.Count > 0)
{
rank++;
ltNode = ltNode.list[0];
}
}
foreach (Node listNode in exprlist.list)
{
// The infered type is the type of the first element
DfsTraverse(listNode, ref inferedType, false, graphNode, subPass);
if ((listNode is ProtoCore.AST.AssociativeAST.ExprListNode) == false)
{
// If 'listNode' was another sub-array, then don't bother adding
// it here, as it has added itself in the call to 'DfsTraverse'.
if (null != this.arrayElementType)
{
this.arrayElementType.AppendChildType(inferedType);
}
}
if ((int)PrimitiveType.kTypeVoid == firstType)
{
firstType = inferedType.UID;
}
}
inferedType.UID = firstType;
inferedType.IsIndexable = true;
inferedType.rank = rank;
}
private void handleCycle(ProtoCore.AssociativeGraph.GraphNode graphNode)
{
ProtoCore.AssociativeGraph.GraphNode[] CycleStartNodeAndEndNode = new ProtoCore.AssociativeGraph.GraphNode[2];
List<AssociativeGraph.GraphNode> nodeIterations = Properties.nodeIterations;// core.InterpreterProps.Peek().nodeIterations;
CycleStartNodeAndEndNode = FindCycleStartNodeAndEndNode(nodeIterations);
foreach (ProtoCore.AssociativeGraph.GraphNode node in nodeIterations)
{
Console.WriteLine("nodes " + node.updateNodeRefList[0].nodeList[0].symbol.name);
}
string message = String.Format(ProtoCore.RuntimeData.WarningMessage.kCyclicDependency, CycleStartNodeAndEndNode[0].updateNodeRefList[0].nodeList[0].symbol.name, CycleStartNodeAndEndNode[1].updateNodeRefList[0].nodeList[0].symbol.name);
core.RuntimeStatus.LogWarning(RuntimeData.WarningID.kCyclicDependency, message);
//BreakDependency(NodeExecutedSameTimes);
foreach (ProtoCore.AssociativeGraph.GraphNode node in nodeIterations)
{
node.isCyclic = true;
SetGraphNodeStackValueNull(node);
node.dependentList.Clear();
}
Properties.nodeIterations = new List<AssociativeGraph.GraphNode>();
}
protected void BuildRealDependencyForIdentList(AssociativeGraph.GraphNode graphNode)
{
if (ssaPointerStack.Count == 0)
{
return;
}
// Push all dependent pointers
ProtoCore.AST.AssociativeAST.IdentifierListNode identList = BuildIdentifierList(ssaPointerStack.Peek());
// Comment Jun: perhaps this can be an assert?
if (null != identList)
{
ProtoCore.Type type = new ProtoCore.Type();
type.UID = globalClassIndex;
ProtoCore.AssociativeGraph.UpdateNodeRef nodeRef = new AssociativeGraph.UpdateNodeRef();
int functionIndex = globalProcIndex;
DFSGetSymbolList_Simple(identList, ref type, ref functionIndex, nodeRef);
if (null != graphNode && nodeRef.nodeList.Count > 0)
{
ProtoCore.AssociativeGraph.GraphNode dependentNode = new ProtoCore.AssociativeGraph.GraphNode();
dependentNode.updateNodeRefList.Add(nodeRef);
graphNode.PushDependent(dependentNode);
// If the pointerList is a setter, then it should also be in the lhs of a graphNode
// Given:
// a.x = 1
// Which was converted to:
// tvar = a.set_x(1)
// Set a.x as lhs of the graphnode.
// This means that statement that depends on a.x can re-execute, such as:
// p = a.x;
//
List<ProtoCore.AST.AssociativeAST.AssociativeNode> topList = ssaPointerStack.Peek();
string propertyName = topList[topList.Count - 1].Name;
bool isSetter = propertyName.StartsWith(Constants.kSetterPrefix);
if (isSetter)
{
graphNode.updateNodeRefList.Add(nodeRef);
graphNode.IsLHSIdentList = true;
AutoGenerateUpdateArgumentReference(nodeRef, graphNode);
}
}
}
}
private void BuildSSADependency(Node node, AssociativeGraph.GraphNode graphNode)
{
// Jun Comment: set the graphNode dependent as this identifier list
ProtoCore.Type type = new ProtoCore.Type();
type.UID = globalClassIndex;
ProtoCore.AssociativeGraph.UpdateNodeRef nodeRef = new AssociativeGraph.UpdateNodeRef();
DFSGetSymbolList(node, ref type, nodeRef);
if (null != graphNode && nodeRef.nodeList.Count > 0)
{
ProtoCore.AssociativeGraph.GraphNode dependentNode = new ProtoCore.AssociativeGraph.GraphNode();
dependentNode.updateNodeRefList.Add(nodeRef);
graphNode.PushDependent(dependentNode);
}
}
protected abstract void DfsTraverse(Node node, ref ProtoCore.Type inferedType, bool isBooleanOp = false, ProtoCore.AssociativeGraph.GraphNode graphNode = null, ProtoCore.DSASM.AssociativeSubCompilePass subPass = ProtoCore.DSASM.AssociativeSubCompilePass.kNone);
protected void EmitIdentifierListNode(Node node, ref ProtoCore.Type inferedType, bool isBooleanOp = false, ProtoCore.AssociativeGraph.GraphNode graphNode = null, ProtoCore.DSASM.AssociativeSubCompilePass subPass = ProtoCore.DSASM.AssociativeSubCompilePass.kNone)
{
if (subPass == ProtoCore.DSASM.AssociativeSubCompilePass.kUnboundIdentifier)
{
//to process all unbounded parameters if any
dynamic iNode = node;
while (iNode is ProtoCore.AST.AssociativeAST.IdentifierListNode || iNode is ProtoCore.AST.ImperativeAST.IdentifierListNode)
{
dynamic rightNode = iNode.RightNode;
if (rightNode is ProtoCore.AST.AssociativeAST.FunctionCallNode || rightNode is ProtoCore.AST.ImperativeAST.FunctionCallNode)
{
foreach (dynamic paramNode in rightNode.FormalArguments)
{
ProtoCore.Type paramType = new ProtoCore.Type();
paramType.UID = (int)ProtoCore.PrimitiveType.kTypeVoid;
paramType.IsIndexable = false;
DfsTraverse(paramNode, ref paramType, false, graphNode, ProtoCore.DSASM.AssociativeSubCompilePass.kUnboundIdentifier);
}
}
iNode = iNode.LeftNode;
}
return;
}
int depth = 0;
ProtoCore.Type leftType = new ProtoCore.Type();
leftType.UID = (int)PrimitiveType.kInvalidType;
leftType.IsIndexable = false;
bool isFirstIdent = true;
bool isIdentReference = DfsEmitIdentList(node, null, globalClassIndex, ref leftType, ref depth, ref inferedType, false, ref isFirstIdent, graphNode, subPass);
inferedType.UID = isBooleanOp ? (int)PrimitiveType.kTypeBool : inferedType.UID;
}
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 isLanguageSignValid = isLanguageSignValid = compileState.Langverify.Verify(langBlock);
if (isLanguageSignValid)
{
try
{
ProtoImperative.CodeGen codegen = new ProtoImperative.CodeGen(compileState, parentBlock);
codegen.context = callContext;
codegen.codeBlock.EventSink = sink;
blockId = codegen.Emit(codeBlockNode as ProtoCore.AST.ImperativeAST.CodeBlockNode, graphNode);
}
catch (ProtoCore.BuildHaltException e)
{
#if DEBUG
//core.BuildStatus.LogSemanticError(e.errorMsg);
#endif
}
int errors = 0;
int warnings = 0;
buildSucceeded = compileState.BuildStatus.GetBuildResult(out errors, out warnings);
}
return(buildSucceeded);
}
private void EmitIdentifierNode(ImperativeNode node, ref ProtoCore.Type inferedType, bool isBooleanOp = false, ProtoCore.AssociativeGraph.GraphNode graphNode = null)
{
IdentifierNode t = node as IdentifierNode;
if (t.Name.Equals(ProtoCore.DSDefinitions.Kw.kw_this))
{
if (localProcedure != null)
{
if (localProcedure.isStatic)
{
string message = ProtoCore.BuildData.WarningMessage.kUsingThisInStaticFunction;
compileStateTracker.BuildStatus.LogWarning(ProtoCore.BuildData.WarningID.kInvalidThis, message, compileStateTracker.CurrentDSFileName, t.line, t.col);
EmitPushNull();
return;
}
else if (localProcedure.classScope == Constants.kGlobalScope)
{
string message = ProtoCore.BuildData.WarningMessage.kInvalidThis;
compileStateTracker.BuildStatus.LogWarning(ProtoCore.BuildData.WarningID.kInvalidThis, message, compileStateTracker.CurrentDSFileName, t.line, t.col);
EmitPushNull();
return;
}
else
{
EmitThisPointerNode();
return;
}
}
else
{
string message = ProtoCore.BuildData.WarningMessage.kInvalidThis;
compileStateTracker.BuildStatus.LogWarning(ProtoCore.BuildData.WarningID.kInvalidThis, message, compileStateTracker.CurrentDSFileName, t.line, t.col);
EmitPushNull();
return;
}
}
int dimensions = 0;
int runtimeIndex = codeBlock.symbolTable.runtimeIndex;
ProtoCore.Type type = new ProtoCore.Type();
type.UID = (int)ProtoCore.PrimitiveType.kTypeVoid;
type.IsIndexable = false;
ProtoCore.DSASM.SymbolNode symbolnode = null;
//bool isAllocated = VerifyAllocation(t.Value, out blockId, out localAllocBlock, out symindex, ref type);
//bool allocatedLocally = isAllocated && core.runtimeTableIndex == localAllocBlock;
//bool allocatedExternally = isAllocated && core.runtimeTableIndex > localAllocBlock;
//bool isVisible = isAllocated && core.runtimeTableIndex >= localAllocBlock;
bool isAccessible = false;
if (null == t.ArrayDimensions)
{
//check if it is a function instance
ProtoCore.DSASM.ProcedureNode procNode = null;
procNode = compileStateTracker.GetFirstVisibleProcedure(t.Name, null, codeBlock);
if (null != procNode)
{
if (ProtoCore.DSASM.Constants.kInvalidIndex != procNode.procId)
{
// A global function
inferedType.IsIndexable = false;
inferedType.UID = (int)PrimitiveType.kTypeFunctionPointer;
int fptr = compileStateTracker.FunctionPointerTable.functionPointerDictionary.Count;
ProtoCore.DSASM.FunctionPointerNode fptrNode = new ProtoCore.DSASM.FunctionPointerNode(procNode.procId, procNode.runtimeIndex);
compileStateTracker.FunctionPointerTable.functionPointerDictionary.TryAdd(fptr, fptrNode);
compileStateTracker.FunctionPointerTable.functionPointerDictionary.TryGetBySecond(fptrNode, out fptr);
EmitPushVarData(runtimeIndex, 0);
EmitInstrConsole(ProtoCore.DSASM.kw.push, t.Name);
ProtoCore.DSASM.StackValue opFunctionPointer = new ProtoCore.DSASM.StackValue();
opFunctionPointer.optype = ProtoCore.DSASM.AddressType.FunctionPointer;
opFunctionPointer.opdata = fptr;
opFunctionPointer.opdata_d = fptr;
EmitPush(opFunctionPointer, t.line, t.col);
return;
}
}
}
bool isAllocated = VerifyAllocation(t.Value, globalClassIndex, globalProcIndex, out symbolnode, out isAccessible);
if (!isAllocated || !isAccessible)
{
if (isAllocated)
{
if (!isAccessible)
{
string message = String.Format(ProtoCore.BuildData.WarningMessage.kPropertyIsInaccessible, t.Value);
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kAccessViolation, message, compileStateTracker.CurrentDSFileName, t.line, t.col);
}
}
else
{
string message = String.Format(ProtoCore.BuildData.WarningMessage.kUnboundIdentifierMsg, t.Value);
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kIdUnboundIdentifier, message, compileStateTracker.CurrentDSFileName, t.line, t.col);
}
inferedType.UID = (int)ProtoCore.PrimitiveType.kTypeNull;
// Jun Comment: Specification excerpt
// If resolution fails at this point a com.Design-Script.Imperative.Core.UnboundIdentifier
// warning is emitted during pre-execute phase, and at the ID is bound to null. (R1 - Feb)
EmitPushNull();
EmitPushVarData(runtimeIndex, dimensions);
ProtoCore.Type varType = compileStateTracker.TypeSystem.BuildTypeObject((int)PrimitiveType.kTypeVar, false, 0);
symbolnode = Allocate(t.Value, globalProcIndex, varType);
EmitInstrConsole(ProtoCore.DSASM.kw.pop, t.Value);
EmitPopForSymbol(symbolnode);
}
else
{
type = symbolnode.datatype;
runtimeIndex = symbolnode.runtimeTableIndex;
if (compileStateTracker.Options.AssociativeToImperativePropagation)
{
// Comment Jun: If this symbol belongs to an outer block, then append it to this language blocks dependent
if (symbolnode.codeBlockId != codeBlock.codeBlockId)
{
// A parent codeblock owns this symbol
if (null != graphNode)
{
ProtoCore.AssociativeGraph.GraphNode dependentNode = new ProtoCore.AssociativeGraph.GraphNode();
dependentNode.PushSymbolReference(symbolnode);
graphNode.PushDependent(dependentNode);
}
}
}
}
if (null != t.ArrayDimensions)
{
dimensions = DfsEmitArrayIndexHeap(t.ArrayDimensions);
}
//fix type's rank
//fix type's rank
if (type.rank >= 0)
{
type.rank -= dimensions;
if (type.rank < 0)
{
//throw new Exception("Exceed maximum rank!");
type.rank = 0;
}
}
//check whether the value is an array
if (type.rank == 0)
{
type.IsIndexable = false;
}
EmitPushVarData(runtimeIndex, dimensions);
EmitInstrConsole(ProtoCore.DSASM.kw.push, t.Value);
EmitPushForSymbol(symbolnode, t);
if (compileStateTracker.TypeSystem.IsHigherRank(type.UID, inferedType.UID))
{
inferedType = type;
}
// We need to get inferedType for boolean variable so that we can perform type check
inferedType.UID = (isBooleanOp || (type.UID == (int)PrimitiveType.kTypeBool)) ? (int)PrimitiveType.kTypeBool : type.UID;
}
protected bool DfsEmitIdentList(Node pNode, Node parentNode, int contextClassScope, ref ProtoCore.Type lefttype, ref int depth, ref ProtoCore.Type finalType, bool isLeftidentList, ref bool isFirstIdent, ProtoCore.AssociativeGraph.GraphNode graphNode = null, ProtoCore.DSASM.AssociativeSubCompilePass subPass = ProtoCore.DSASM.AssociativeSubCompilePass.kNone)
{
bool isRefFromIdentifier = false;
dynamic node = pNode;
if (node is ProtoCore.AST.ImperativeAST.IdentifierListNode || node is ProtoCore.AST.AssociativeAST.IdentifierListNode)
{
dynamic bnode = node;
if (ProtoCore.DSASM.Operator.dot != bnode.Optr)
{
throw new BuildHaltException();
}
isRefFromIdentifier = DfsEmitIdentList(bnode.LeftNode, bnode, contextClassScope, ref lefttype, ref depth, ref finalType, isLeftidentList, ref isFirstIdent, graphNode, subPass);
if (lefttype.rank > 0)
{
lefttype.UID = finalType.UID = (int)PrimitiveType.kTypeNull;
return(false);
}
node = bnode.RightNode;
}
if (node is ProtoCore.AST.ImperativeAST.IdentifierNode || node is ProtoCore.AST.AssociativeAST.IdentifierNode)
{
dynamic identnode = node;
int ci = core.ClassTable.IndexOf(identnode.Value);
if (ProtoCore.DSASM.Constants.kInvalidIndex != ci)
{
finalType.UID = lefttype.UID = ci;
}
else if (identnode.Value == ProtoCore.DSDefinitions.Kw.kw_this)
{
finalType.UID = lefttype.UID = contextClassScope;
depth++;
return(true);
}
else
{
ProtoCore.DSASM.SymbolNode symbolnode = null;
bool isAllocated = false;
bool isAccessible = false;
if (lefttype.UID != -1)
{
isAllocated = VerifyAllocation(identnode.Value, lefttype.UID, out symbolnode, out isAccessible);
}
else
{
isAllocated = VerifyAllocation(identnode.Value, contextClassScope, out symbolnode, out isAccessible);
}
bool callOnClass = false;
if (pNode is ProtoCore.AST.ImperativeAST.IdentifierListNode ||
pNode is ProtoCore.AST.AssociativeAST.IdentifierListNode)
{
dynamic leftnode = ((dynamic)pNode).LeftNode;
if (leftnode != null &&
(leftnode is ProtoCore.AST.ImperativeAST.IdentifierNode ||
leftnode is ProtoCore.AST.AssociativeAST.IdentifierNode))
{
string leftClassName = leftnode.Name;
int leftci = core.ClassTable.IndexOf(leftClassName);
if (leftci != ProtoCore.DSASM.Constants.kInvalidIndex)
{
callOnClass = true;
depth = depth + 1;
}
}
}
if (null == symbolnode) //unbound identifier
{
if (isAllocated && !isAccessible)
{
lefttype.UID = finalType.UID = (int)PrimitiveType.kTypeNull;
return(false);
}
if (depth == 0)
{
lefttype.UID = finalType.UID = (int)PrimitiveType.kTypeNull;
return(false);
}
else
{
ProtoCore.DSASM.DyanmicVariableNode dynamicVariableNode = new ProtoCore.DSASM.DyanmicVariableNode(identnode.Value, globalProcIndex, globalClassIndex);
core.DynamicVariableTable.variableTable.Add(dynamicVariableNode);
int dim = 0;
if (null != identnode.ArrayDimensions)
{
dim = DfsEmitArrayIndexHeap(identnode.ArrayDimensions);
}
lefttype.UID = finalType.UID = (int)PrimitiveType.kTypeVar;
depth++;
return(true);
}
}
else
{
if (callOnClass && !symbolnode.isStatic)
{
lefttype.UID = finalType.UID = (int)PrimitiveType.kTypeNull;
return(false);
}
}
lefttype = symbolnode.datatype;
int dimensions = 0;
// Get the symbols' table index
int runtimeIndex = symbolnode.runtimeTableIndex;
ProtoCore.DSASM.AddressType operandType = ProtoCore.DSASM.AddressType.Pointer;
if (null != identnode.ArrayDimensions)
{
/* Remove static type checking
* if (lefttype.UID != (int)PrimitiveType.kTypeArray && !lefttype.IsIndexable)
* buildStatus.LogWarning(BuildData.WarningID.kWarnMax, string.Format("'{0}' is not indexable at compile time", identnode.Name));
*/
dimensions = DfsEmitArrayIndexHeap(identnode.ArrayDimensions);
operandType = ProtoCore.DSASM.AddressType.ArrayPointer;
}
//update the rank
if (lefttype.rank >= 0)
{
lefttype.rank -= dimensions;
if (lefttype.rank < 0)
{
//throw new Exception("Exceed maximum rank!");
lefttype.rank = 0;
}
}
if (0 == depth || (symbolnode != null && symbolnode.isStatic))
{
if (ProtoCore.DSASM.Constants.kGlobalScope == symbolnode.functionIndex &&
ProtoCore.DSASM.Constants.kInvalidIndex != symbolnode.classScope)
{
// member var
operandType = symbolnode.isStatic ? ProtoCore.DSASM.AddressType.StaticMemVarIndex : ProtoCore.DSASM.AddressType.MemVarIndex;
}
else
{
operandType = ProtoCore.DSASM.AddressType.VarIndex;
}
}
depth = depth + 1;
finalType = lefttype;
}
return(true);
}
else if (node is ProtoCore.AST.ImperativeAST.FunctionCallNode || node is ProtoCore.AST.AssociativeAST.FunctionCallNode)
{
TraverseFunctionCall(node, pNode, lefttype.UID, depth, ref finalType, graphNode, subPass);
//finalType.UID = isBooleanOp ? (int)PrimitiveType.kTypeBool : finalType.UID;
lefttype = finalType;
depth = 1;
}
//else
//{
// throw new BuildHaltException();
//}
return(false);
}
public abstract bool Compile(out int blockId, ProtoCore.DSASM.CodeBlock parentBlock, ProtoCore.LanguageCodeBlock codeblock, ProtoCore.CompileTime.Context callContext, ProtoCore.DebugServices.EventSink sink = null, ProtoCore.AST.Node codeBlockNode = null, ProtoCore.AssociativeGraph.GraphNode graphNode = null);
protected void BuildRealDependencyForIdentList(AssociativeGraph.GraphNode graphNode)
{
// Push all dependent pointers
ProtoCore.AST.AssociativeAST.IdentifierListNode identList = BuildIdentifierList(ssaPointerList);
// Comment Jun: perhaps this can be an assert?
if (null != identList)
{
ProtoCore.Type type = new ProtoCore.Type();
type.UID = globalClassIndex;
ProtoCore.AssociativeGraph.UpdateNodeRef nodeRef = new AssociativeGraph.UpdateNodeRef();
int functionIndex = globalProcIndex;
DFSGetSymbolList_Simple(identList, ref type, ref functionIndex, nodeRef);
if (null != graphNode && nodeRef.nodeList.Count > 0)
{
ProtoCore.AssociativeGraph.GraphNode dependentNode = new ProtoCore.AssociativeGraph.GraphNode();
dependentNode.updateNodeRefList.Add(nodeRef);
graphNode.PushDependent(dependentNode);
}
}
}
public override bool Compile(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 isLanguageSignValid = isLanguageSignValid = core.Langverify.Verify(langBlock);
if (isLanguageSignValid)
{
try
{
ProtoImperative.CodeGen codegen = new ProtoImperative.CodeGen(core, parentBlock);
//(Fuqiang, Ayush) : The below code is to parse an Imperative code block. An imoerative code block should
// never need to be parsed at this stage, as it would be parsed by the Assoc parser.
//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);
//System.IO.StringWriter parseErrors = new System.IO.StringWriter();
//p.errors.errorStream = parseErrors;
//p.Parse();
//if (parseErrors.ToString() != String.Empty)
//{
// core.BuildStatus.LogSyntaxError(parseErrors.ToString());
//}
//core.BuildStatus.errorCount += p.errors.count;
codegen.context = callContext;
codegen.codeBlock.EventSink = sink;
blockId = codegen.Emit(codeBlockNode as ProtoCore.AST.ImperativeAST.CodeBlockNode, graphNode);
}
catch (ProtoCore.BuildHaltException e)
{
#if DEBUG
//core.BuildStatus.LogSemanticError(e.errorMsg);
#endif
}
int errors = 0;
int warnings = 0;
buildSucceeded = core.BuildStatus.GetBuildResult(out errors, out warnings);
}
return(buildSucceeded);
}
public override bool Compile(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)
{
Validity.Assert(langBlock != null);
blockId = ProtoCore.DSASM.Constants.kInvalidIndex;
bool buildSucceeded = false;
try
{
ProtoImperative.CodeGen codegen = new ProtoImperative.CodeGen(core, callContext, parentBlock);
codegen.context = callContext;
codegen.codeBlock.EventSink = sink;
blockId = codegen.Emit(codeBlockNode as ProtoCore.AST.ImperativeAST.CodeBlockNode, graphNode);
}
catch (ProtoCore.BuildHaltException)
{
}
buildSucceeded = core.BuildStatus.BuildSucceeded;
return(buildSucceeded);
}
private ProtoCore.AssociativeGraph.GraphNode[] FindCycleStartNodeAndEndNode(List<ProtoCore.AssociativeGraph.GraphNode> nodesExecutedSameTime)
{
ProtoCore.AssociativeGraph.GraphNode cyclicSymbolStart = null;
ProtoCore.AssociativeGraph.GraphNode cyclicSymbolEnd = null;
cyclicSymbolStart = nodesExecutedSameTime[0];
cyclicSymbolEnd = nodesExecutedSameTime.Last();
ProtoCore.AssociativeGraph.GraphNode[] StartAndEnd = new ProtoCore.AssociativeGraph.GraphNode[] { cyclicSymbolStart, cyclicSymbolEnd };
//reset counter
foreach (ProtoCore.AssociativeGraph.GraphNode node in nodesExecutedSameTime)
{
node.counter = 0;
}
return StartAndEnd;
}
public override ProtoCore.DSASM.ProcedureNode TraverseFunctionCall(ProtoCore.AST.Node node, ProtoCore.AST.Node parentNode, int lefttype, int depth, ref ProtoCore.Type inferedType,
ProtoCore.AssociativeGraph.GraphNode graphNode = null, ProtoCore.DSASM.AssociativeSubCompilePass subPass = ProtoCore.DSASM.AssociativeSubCompilePass.kNone,
ProtoCore.AST.Node bnode = null)
{
if (!IsParsingGlobal() && !IsParsingGlobalFunctionBody())
{
return null;
}
//Debug.Assert(null == graphNode);
FunctionCallNode funcCall = node as FunctionCallNode;
string procName = funcCall.Function.Name;
List<ProtoCore.Type> arglist = new List<ProtoCore.Type>();
foreach (ImperativeNode paramNode in funcCall.FormalArguments)
{
ProtoCore.Type paramType = new ProtoCore.Type();
paramType.UID = (int)ProtoCore.PrimitiveType.kTypeVoid;
paramType.IsIndexable = false;
// If it's a binary node then continue type check, otherwise disable type check and just take the type of paramNode itself
// f(1+2.0) -> type check enabled - param is typed as double
// f(2) -> type check disabled - param is typed as int
enforceTypeCheck = !(paramNode is BinaryExpressionNode);
DfsTraverse(paramNode, ref paramType, false, graphNode, AssociativeSubCompilePass.kNone, bnode);
enforceTypeCheck = true;
arglist.Add(paramType);
}
ProtoCore.DSASM.ProcedureNode procNode = null;
int type = ProtoCore.DSASM.Constants.kInvalidIndex;
bool isConstructor = false;
bool isStatic = false;
bool hasLogError = false;
int refClassIndex = ProtoCore.DSASM.Constants.kInvalidIndex;
if (parentNode != null && parentNode is ProtoCore.AST.ImperativeAST.IdentifierListNode)
{
ProtoCore.AST.Node leftnode = (parentNode as ProtoCore.AST.ImperativeAST.IdentifierListNode).LeftNode;
if (leftnode != null && leftnode is ProtoCore.AST.ImperativeAST.IdentifierNode)
{
refClassIndex = compileStateTracker.ClassTable.IndexOf(leftnode.Name);
}
}
// If lefttype is a valid class then check if calling a constructor
if ((int)ProtoCore.PrimitiveType.kInvalidType != inferedType.UID && (int)ProtoCore.PrimitiveType.kTypeVoid != inferedType.UID)
{
bool isAccessible;
int realType;
if (procName != ProtoCore.DSASM.Constants.kFunctionPointerCall)
{
bool isStaticOrConstructor = refClassIndex != ProtoCore.DSASM.Constants.kInvalidIndex;
procNode = compileStateTracker.ClassTable.ClassNodes[inferedType.UID].GetMemberFunction(procName, arglist, globalClassIndex, out isAccessible, out realType, isStaticOrConstructor);
if (procNode != null)
{
Debug.Assert(realType != ProtoCore.DSASM.Constants.kInvalidIndex);
isConstructor = procNode.isConstructor;
isStatic = procNode.isStatic;
type = lefttype = realType;
if (!isAccessible)
{
type = lefttype = realType;
string message = String.Format(ProtoCore.BuildData.WarningMessage.kMethodIsInaccessible, procName);
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kAccessViolation, message, compileStateTracker.CurrentDSFileName, funcCall.line, funcCall.col);
hasLogError = true;
}
}
// To support unamed constructor, x = A();
else if (refClassIndex != Constants.kInvalidIndex)
{
string message = String.Format(ProtoCore.BuildData.WarningMessage.kCallingNonStaticMethod, compileStateTracker.ClassTable.ClassNodes[refClassIndex].name, procName);
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kCallingNonStaticMethodOnClass, message, compileStateTracker.CurrentDSFileName, funcCall.line, funcCall.col);
inferedType.UID = (int)PrimitiveType.kTypeNull;
EmitPushNull();
return null;
}
else
{
int classIndex = compileStateTracker.ClassTable.IndexOf(procName);
int dummy;
if (classIndex != Constants.kInvalidIndex)
{
procNode = compileStateTracker.ClassTable.ClassNodes[classIndex].GetMemberFunction(procName, arglist, globalClassIndex, out isAccessible, out dummy, true);
if (procNode != null && procNode.isConstructor)
{
type = classIndex;
}
else
{
procNode = null;
}
}
}
}
}
// Try function pointer firstly
if ((procNode == null) && (procName != ProtoCore.DSASM.Constants.kFunctionPointerCall))
{
bool isAccessibleFp;
ProtoCore.DSASM.SymbolNode symbolnode = null;
bool isAllocated = VerifyAllocation(procName, globalClassIndex, globalProcIndex, out symbolnode, out isAccessibleFp);
if (isAllocated) // not checking the type against function pointer, as the type could be var
{
procName = ProtoCore.DSASM.Constants.kFunctionPointerCall;
// The graph node always depends on this function pointer
if (null != graphNode)
{
ProtoCore.AssociativeGraph.GraphNode dependentNode = new ProtoCore.AssociativeGraph.GraphNode();
dependentNode.PushSymbolReference(symbolnode);
graphNode.PushDependent(dependentNode);
}
}
}
// Always try global function firstly. Because we dont have syntax
// support for calling global function (say, ::foo()), if we try
// member function firstly, there is no way to call a global function
// For member function, we can use this.foo() to distinguish it from
// global function.
if ((procNode == null) && (procName != ProtoCore.DSASM.Constants.kFunctionPointerCall))
{
procNode = compileStateTracker.GetFirstVisibleProcedure(procName, arglist, codeBlock);
if (null != procNode)
{
type = ProtoCore.DSASM.Constants.kGlobalScope;
if (compileStateTracker.TypeSystem.IsHigherRank(procNode.returntype.UID, inferedType.UID))
{
inferedType = procNode.returntype;
}
}
}
// Try member functions in global class scope
if ((procNode == null) && (procName != ProtoCore.DSASM.Constants.kFunctionPointerCall) && (parentNode == null))
{
if (globalClassIndex != ProtoCore.DSASM.Constants.kInvalidIndex)
{
int realType;
bool isAccessible;
bool isStaticOrConstructor = refClassIndex != ProtoCore.DSASM.Constants.kInvalidIndex;
ProtoCore.DSASM.ProcedureNode memProcNode = compileStateTracker.ClassTable.ClassNodes[globalClassIndex].GetMemberFunction(procName, arglist, globalClassIndex, out isAccessible, out realType, isStaticOrConstructor);
if (memProcNode != null)
{
Debug.Assert(realType != ProtoCore.DSASM.Constants.kInvalidIndex);
procNode = memProcNode;
inferedType = procNode.returntype;
type = realType;
if (!isAccessible)
{
string message = String.Format(ProtoCore.BuildData.WarningMessage.kMethodIsInaccessible, procName);
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kAccessViolation, message, compileStateTracker.CurrentDSFileName, funcCall.line, funcCall.col);
inferedType.UID = (int)PrimitiveType.kTypeNull;
EmitPushNull();
return null;
}
}
}
}
if (null != procNode)
{
inferedType = procNode.returntype;
//if call is replication call
if (procNode.isThisCallReplication)
{
inferedType.IsIndexable = true;
inferedType.rank++;
}
if (ProtoCore.DSASM.Constants.kInvalidIndex != procNode.procId)
{
// The function is at block 0 if its a constructor, member or at the globals scope.
// Its at block 1 if its inside a language block.
// Its limited to block 1 as of R1 since we dont support nested function declarations yet
int blockId = procNode.runtimeIndex;
//push value-not-provided default argument
for (int i = arglist.Count; i < procNode.argInfoList.Count; i++)
{
EmitDefaultArgNode();
}
// Push the function declaration block
// Jun TODO: Implementeation of indexing into a function call:
// x = f()[0][1]
int dimensions = 0;
EmitPushVarData(blockId, dimensions);
// The function call
EmitInstrConsole(ProtoCore.DSASM.kw.callr, procNode.name);
DebugProperties.BreakpointOptions oldOptions = compileStateTracker.DebugProps.breakOptions;
if(procNode.name.StartsWith(Constants.kSetterPrefix))
{
EmitCall(procNode.procId, type, depth, parentNode.line, parentNode.col, parentNode.endLine, parentNode.endCol);
}
/*else if(procNode.isExternal)
{
EmitCall(procNode.procId, type, depth);
}*/
else if (bnode != null)
{
EmitCall(procNode.procId, type, depth, bnode.line, bnode.col, bnode.endLine, bnode.endCol);
}
else if (!procNode.name.Equals(Constants.kFunctionRangeExpression) ||
oldOptions.HasFlag(DebugProperties.BreakpointOptions.EmitCallrForTempBreakpoint))
{
EmitCall(procNode.procId, type, depth, node.line, node.col, node.endLine, node.endCol);
}
else
{
EmitCall(procNode.procId, type, depth);
}
EmitInstrConsole(ProtoCore.DSASM.kw.push, ProtoCore.DSASM.kw.regRX);
ProtoCore.DSASM.StackValue opReturn = new ProtoCore.DSASM.StackValue();
opReturn.optype = ProtoCore.DSASM.AddressType.Register;
opReturn.opdata = (int)ProtoCore.DSASM.Registers.RX;
EmitPush(opReturn);
}
}
else
{
if (depth <= 0 && procName != ProtoCore.DSASM.Constants.kFunctionPointerCall)
{
if (!hasLogError)
{
if (!compileStateTracker.Options.SuppressFunctionResolutionWarning || parentNode == null)
{
string property;
if (CoreUtils.TryGetPropertyName(procName, out property))
{
string message = String.Format(ProtoCore.BuildData.WarningMessage.kPropertyNotFound, property);
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kPropertyNotFound, message, compileStateTracker.CurrentDSFileName, funcCall.line, funcCall.col);
}
else
{
string message = String.Format(ProtoCore.BuildData.WarningMessage.kMethodNotFound, procName);
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kFunctionNotFound, message, compileStateTracker.CurrentDSFileName, funcCall.line, funcCall.col);
}
}
inferedType.UID = (int)PrimitiveType.kTypeNull;
EmitPushNull();
}
}
else
{
if (procName == ProtoCore.DSASM.Constants.kFunctionPointerCall && depth == 0)
{
ProtoCore.DSASM.DynamicFunctionNode dynamicFunctionNode = new ProtoCore.DSASM.DynamicFunctionNode(procName, arglist, lefttype);
compileStateTracker.DynamicFunctionTable.functionTable.Add(dynamicFunctionNode);
var iNode = nodeBuilder.BuildIdentfier(funcCall.Function.Name);
EmitIdentifierNode(iNode, ref inferedType);
}
else
{
ProtoCore.DSASM.DynamicFunctionNode dynamicFunctionNode = new ProtoCore.DSASM.DynamicFunctionNode(funcCall.Function.Name, arglist, lefttype);
compileStateTracker.DynamicFunctionTable.functionTable.Add(dynamicFunctionNode);
}
// The function call
EmitInstrConsole(ProtoCore.DSASM.kw.callr, funcCall.Function.Name + "[dynamic]");
EmitDynamicCall(compileStateTracker.DynamicFunctionTable.functionTable.Count - 1, globalClassIndex, depth, funcCall.line, funcCall.col, funcCall.endLine, funcCall.endCol);
// The function return value
EmitInstrConsole(ProtoCore.DSASM.kw.push, ProtoCore.DSASM.kw.regRX);
ProtoCore.DSASM.StackValue opReturn = new ProtoCore.DSASM.StackValue();
opReturn.optype = ProtoCore.DSASM.AddressType.Register;
opReturn.opdata = (int)ProtoCore.DSASM.Registers.RX;
EmitPush(opReturn);
//assign inferedType to var
inferedType.UID = (int)PrimitiveType.kTypeVar;
}
}
return procNode;
}
public abstract void TraverseFunctionCall(Node node, Node parentNode, int lefttype, int depth, ref ProtoCore.Type inferedType, ProtoCore.AssociativeGraph.GraphNode graphNode = null, ProtoCore.DSASM.AssociativeSubCompilePass subPass = ProtoCore.DSASM.AssociativeSubCompilePass.kNone);
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);
blockId = ProtoCore.DSASM.Constants.kInvalidIndex;
bool buildSucceeded = false;
bool isLangSignValid = core.Langverify.Verify(langBlock);
if (isLangSignValid)
{
try
{
ProtoCore.CodeGen oldCodegen = core.assocCodegen;
if (ProtoCore.DSASM.InterpreterMode.kNormal == core.ExecMode)
{
if ((core.IsParsingPreloadedAssembly || core.IsParsingCodeBlockNode) && parentBlock == null)
{
if (core.CodeBlockList.Count == 0)
{
core.assocCodegen = new ProtoAssociative.CodeGen(core, callContext, parentBlock);
}
else
{
// We reuse the existing toplevel CodeBlockList's for the procedureTable's
// by calling this overloaded constructor - pratapa
core.assocCodegen = new ProtoAssociative.CodeGen(core);
}
}
else
{
core.assocCodegen = new ProtoAssociative.CodeGen(core, callContext, parentBlock);
}
}
if (null != core.AssocNode)
{
ProtoCore.AST.AssociativeAST.CodeBlockNode cnode = new ProtoCore.AST.AssociativeAST.CodeBlockNode();
cnode.Body.Add(core.AssocNode as ProtoCore.AST.AssociativeAST.AssociativeNode);
core.assocCodegen.context = callContext;
blockId = core.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)
{
var p = ParserUtils.CreateParser(langBlock.body, core);
p.Parse();
// TODO Jun: Set this flag inside a persistent object
core.builtInsLoaded = true;
codeBlockNode = p.root;
//core.AstNodeList = p.GetParsedASTList(codeBlockNode as ProtoCore.AST.AssociativeAST.CodeBlockNode);
List <ProtoCore.AST.Node> astNodes = ProtoCore.Utils.ParserUtils.GetAstNodes(codeBlockNode);
core.AstNodeList = astNodes;
}
else
{
if (!core.builtInsLoaded)
{
// Load the built-in methods manually
ProtoCore.Utils.CoreUtils.InsertPredefinedAndBuiltinMethods(core, codeBlockNode, false);
core.builtInsLoaded = true;
}
}
core.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 = core.assocCodegen.codeBlock;
if (core.ExecMode == ProtoCore.DSASM.InterpreterMode.kExpressionInterpreter)
{
int tempBlockId = core.GetCurrentBlockId();
ProtoCore.DSASM.CodeBlock tempCodeBlock = core.GetCodeBlock(core.CodeBlockList, tempBlockId);
while (null != tempCodeBlock && tempCodeBlock.blockType != ProtoCore.DSASM.CodeBlockType.kLanguage)
{
tempCodeBlock = tempCodeBlock.parent;
}
core.assocCodegen.codeBlock = tempCodeBlock;
}
core.assocCodegen.codeBlock.EventSink = sink;
if (core.BuildStatus.ErrorCount == 0) //if there is syntax error, no build needed
{
blockId = core.assocCodegen.Emit((codeBlockNode as ProtoCore.AST.AssociativeAST.CodeBlockNode), graphNode);
}
if (core.ExecMode == ProtoCore.DSASM.InterpreterMode.kExpressionInterpreter)
{
blockId = core.assocCodegen.codeBlock.codeBlockId;
//Restore the code block.
core.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 && core.assocCodegen != oldCodegen)
{
core.assocCodegen = oldCodegen;
}
}
catch (ProtoCore.BuildHaltException)
{
#if DEBUG
//core.BuildStatus.LogSemanticError(e.errorMsg);
#endif
}
buildSucceeded = core.BuildStatus.BuildSucceeded;
}
return(buildSucceeded);
}
private void EmitIdentifierNode(ImperativeNode node, ref ProtoCore.Type inferedType, bool isBooleanOp = false, ProtoCore.AssociativeGraph.GraphNode graphNode = null)
{
IdentifierNode t = node as IdentifierNode;
if (t.Name.Equals(ProtoCore.DSDefinitions.Keyword.This))
{
if (localProcedure != null)
{
if (localProcedure.IsStatic)
{
string message = ProtoCore.Properties.Resources.kUsingThisInStaticFunction;
core.BuildStatus.LogWarning(WarningID.InvalidThis, message, core.CurrentDSFileName, t.line, t.col, graphNode);
EmitPushNull();
return;
}
else if (localProcedure.ClassID == Constants.kGlobalScope)
{
string message = ProtoCore.Properties.Resources.kInvalidThis;
core.BuildStatus.LogWarning(WarningID.InvalidThis, message, core.CurrentDSFileName, t.line, t.col, graphNode);
EmitPushNull();
return;
}
else
{
EmitThisPointerNode();
return;
}
}
else
{
string message = ProtoCore.Properties.Resources.kInvalidThis;
core.BuildStatus.LogWarning(WarningID.InvalidThis, message, core.CurrentDSFileName, t.line, t.col, graphNode);
EmitPushNull();
return;
}
}
int dimensions = 0;
int runtimeIndex = codeBlock.symbolTable.RuntimeIndex;
ProtoCore.Type type = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.Var, 0);
ProtoCore.DSASM.SymbolNode symbolnode = null;
bool isAccessible = false;
bool isAllocated = VerifyAllocation(t.Value, globalClassIndex, globalProcIndex, out symbolnode, out isAccessible);
if (!isAllocated && null == t.ArrayDimensions)
{
//check if it is a function instance
ProtoCore.DSASM.ProcedureNode procNode = null;
procNode = CoreUtils.GetFunctionBySignature(t.Name, null, codeBlock);
if (null != procNode)
{
if (ProtoCore.DSASM.Constants.kInvalidIndex != procNode.ID)
{
// A global function
inferedType.UID = (int)PrimitiveType.FunctionPointer;
int fptr = core.FunctionPointerTable.functionPointerDictionary.Count;
var fptrNode = new ProtoCore.DSASM.FunctionPointerNode(procNode);
core.FunctionPointerTable.functionPointerDictionary.TryAdd(fptr, fptrNode);
core.FunctionPointerTable.functionPointerDictionary.TryGetBySecond(fptrNode, out fptr);
EmitInstrConsole(ProtoCore.DSASM.kw.push, t.Name);
StackValue opFunctionPointer = StackValue.BuildFunctionPointer(fptr);
EmitPush(opFunctionPointer, runtimeIndex, t.line, t.col);
return;
}
}
}
if (!isAllocated || !isAccessible)
{
if (isAllocated)
{
if (!isAccessible)
{
string message = String.Format(ProtoCore.Properties.Resources.kPropertyIsInaccessible, t.Value);
buildStatus.LogWarning(WarningID.AccessViolation, message, core.CurrentDSFileName, t.line, t.col, graphNode);
}
}
else
{
string message = String.Format(ProtoCore.Properties.Resources.kUnboundIdentifierMsg, t.Value);
var unboundSymbol = new SymbolNode
{
name = t.Value
};
buildStatus.LogUnboundVariableWarning(unboundSymbol, message, core.CurrentDSFileName, t.line, t.col, graphNode);
}
inferedType.UID = (int)ProtoCore.PrimitiveType.Null;
// Jun Comment: Specification excerpt
// If resolution fails at this point a com.Design-Script.Imperative.Core.UnboundIdentifier
// warning is emitted during pre-execute phase, and at the ID is bound to null. (R1 - Feb)
EmitPushNull();
ProtoCore.Type varType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.Var, 0);
symbolnode = Allocate(t.Value, globalProcIndex, varType);
EmitInstrConsole(kw.pop, t.Value);
EmitPopForSymbol(symbolnode, runtimeIndex);
}
else
{
type = symbolnode.datatype;
runtimeIndex = symbolnode.runtimeTableIndex;
if (core.Options.AssociativeToImperativePropagation)
{
// Comment Jun: If this symbol belongs to an outer block, then append it to this language blocks dependent
if (symbolnode.codeBlockId != codeBlock.codeBlockId)
{
// A parent codeblock owns this symbol
if (null != graphNode)
{
ProtoCore.AssociativeGraph.GraphNode dependentNode = new ProtoCore.AssociativeGraph.GraphNode();
dependentNode.PushSymbolReference(symbolnode);
graphNode.PushDependent(dependentNode);
}
}
}
}
EmitInstrConsole(kw.push, t.Value);
EmitPushForSymbol(symbolnode, runtimeIndex, t);
if (null != t.ArrayDimensions)
{
dimensions = DfsEmitArrayIndexHeap(t.ArrayDimensions);
}
//fix type's rank
//fix type's rank
if (type.rank >= 0)
{
type.rank -= dimensions;
if (type.rank < 0)
{
//throw new Exception("Exceed maximum rank!");
type.rank = 0;
}
}
if (dimensions > 0)
{
EmitPushDimensions(dimensions);
EmitLoadElement(symbolnode, runtimeIndex);
}
if (core.TypeSystem.IsHigherRank(type.UID, inferedType.UID))
{
inferedType = type;
}
// We need to get inferedType for boolean variable so that we can perform type check
inferedType.UID = (isBooleanOp || (type.UID == (int)PrimitiveType.Bool)) ? (int)PrimitiveType.Bool : type.UID;
}
