本文整理汇总了C#中ProtoCore.AssociativeGraph.UpdateNode类的典型用法代码示例。如果您正苦于以下问题：C# UpdateNode类的具体用法？C# UpdateNode怎么用？C# UpdateNode使用的例子？那么, 这里精选的类代码示例或许可以为您提供帮助。
UpdateNode类属于ProtoCore.AssociativeGraph命名空间，在下文中一共展示了UpdateNode类的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: EmitStringNode
protected void EmitStringNode(
Node node,
ref Type inferedType,
AssociativeGraph.GraphNode graphNode = null,
ProtoCore.CompilerDefinitions.Associative.SubCompilePass subPass = ProtoCore.CompilerDefinitions.Associative.SubCompilePass.kNone)
{
if (subPass == ProtoCore.CompilerDefinitions.Associative.SubCompilePass.kUnboundIdentifier)
{
return;
}
dynamic sNode = node;
if (!enforceTypeCheck || core.TypeSystem.IsHigherRank((int)PrimitiveType.kTypeString, inferedType.UID))
{
inferedType.UID = (int)PrimitiveType.kTypeString;
}
if (core.Options.TempReplicationGuideEmptyFlag && emitReplicationGuide)
{
EmitInstrConsole(ProtoCore.DSASM.kw.push, 0 + "[guide]");
StackValue opNumGuides = StackValue.BuildReplicationGuide(0);
EmitPush(opNumGuides);
}
string value = (string)sNode.Value;
StackValue svString = core.Heap.AllocateFixedString(value);
if (core.Options.TempReplicationGuideEmptyFlag && emitReplicationGuide)
{
EmitInstrConsole(kw.pushg, "\"" + value + "\"");
EmitPushG(svString, node.line, node.col);
}
else
{
EmitInstrConsole(kw.push, "\"" + value + "\"");
EmitPush(svString, node.line, node.col);
}
if (IsAssociativeArrayIndexing && graphNode != null && graphNode.isIndexingLHS)
{
SymbolNode literalSymbol = new SymbolNode();
literalSymbol.name = value;
var dimNode = new AssociativeGraph.UpdateNode();
dimNode.symbol = literalSymbol;
dimNode.nodeType = AssociativeGraph.UpdateNodeType.kLiteral;
graphNode.dimensionNodeList.Add(dimNode);
}
}示例2: EmitDoubleNode
protected void EmitDoubleNode(Node node, ref ProtoCore.Type inferedType, bool isBooleanOp = false, ProtoCore.AssociativeGraph.GraphNode graphNode = null, ProtoCore.CompilerDefinitions.Associative.SubCompilePass subPass = ProtoCore.CompilerDefinitions.Associative.SubCompilePass.kNone)
{
if (subPass == ProtoCore.CompilerDefinitions.Associative.SubCompilePass.kUnboundIdentifier)
{
return;
}
double value;
if (node is AST.ImperativeAST.DoubleNode)
{
value = (node as AST.ImperativeAST.DoubleNode).Value;
}
else if (node is AST.AssociativeAST.DoubleNode)
{
value = (node as AST.AssociativeAST.DoubleNode).Value;
}
else
{
throw new InvalidDataException("The input node is not DoubleNode");
}
if (!enforceTypeCheck || core.TypeSystem.IsHigherRank((int)PrimitiveType.kTypeDouble, inferedType.UID))
{
inferedType.UID = (int)PrimitiveType.kTypeDouble;
}
inferedType.UID = isBooleanOp ? (int)PrimitiveType.kTypeBool : inferedType.UID;
if (core.Options.TempReplicationGuideEmptyFlag)
{
if (emitReplicationGuide)
{
int replicationGuides = 0;
// Push the number of guides
EmitInstrConsole(ProtoCore.DSASM.kw.push, replicationGuides + "[guide]");
StackValue opNumGuides = StackValue.BuildReplicationGuide(replicationGuides);
EmitPush(opNumGuides);
}
}
StackValue op = StackValue.BuildDouble(value);
if (core.Options.TempReplicationGuideEmptyFlag && emitReplicationGuide)
{
EmitInstrConsole(ProtoCore.DSASM.kw.pushg, value.ToString());
EmitPushG(op, node.line, node.col);
}
else
{
EmitInstrConsole(ProtoCore.DSASM.kw.push, value.ToString());
EmitPush(op, node.line, node.col);
}
if (IsAssociativeArrayIndexing)
{
if (null != graphNode)
{
// Get the last dependent which is the current identifier being indexed into
SymbolNode literalSymbol = new SymbolNode();
literalSymbol.name = value.ToString();
AssociativeGraph.UpdateNode intNode = new AssociativeGraph.UpdateNode();
intNode.symbol = literalSymbol;
intNode.nodeType = AssociativeGraph.UpdateNodeType.kLiteral;
if (graphNode.isIndexingLHS)
{
graphNode.dimensionNodeList.Add(intNode);
}
else
{
int lastDependentIndex = graphNode.dependentList.Count - 1;
ProtoCore.AssociativeGraph.UpdateNode currentDependentNode = graphNode.dependentList[lastDependentIndex].updateNodeRefList[0].nodeList[0];
currentDependentNode.dimensionNodeList.Add(intNode);
if (core.Options.GenerateSSA)
{
if (null != firstSSAGraphNode)
{
lastDependentIndex = firstSSAGraphNode.dependentList.Count - 1;
ProtoCore.AssociativeGraph.UpdateNode firstSSAUpdateNode = firstSSAGraphNode.dependentList[lastDependentIndex].updateNodeRefList[0].nodeList[0];
firstSSAUpdateNode.dimensionNodeList.Add(intNode);
}
}
}
}
}
}示例3: IsEqual
public bool IsEqual(UpdateNode rhs)
{
if (nodeType == rhs.nodeType)
{
if (nodeType == UpdateNodeType.kSymbol || nodeType == UpdateNodeType.kLiteral)
{
return symbol.IsEqualAtScope(rhs.symbol);
}
else if (nodeType == UpdateNodeType.kMethod)
{
return procNode.IsEqual(rhs.procNode);
}
}
return false;
}示例4: PushUpdateNode
public void PushUpdateNode(UpdateNode node)
{
Validity.Assert(null != nodeList);
nodeList.Add(node);
}示例5: EmitIdentifierNode
//.........这里部分代码省略.........
graphNode);
}
else
{
string message = String.Format(ProtoCore.Properties.Resources.kUnboundIdentifierMsg, t.Value);
buildStatus.LogUnboundVariableWarning(unboundVariable, message, core.CurrentDSFileName, t.line, t.col, graphNode);
}
}
if (null != t.ArrayDimensions)
{
dimensions = DfsEmitArrayIndexHeap(t.ArrayDimensions, graphNode, parentNode, subPass);
}
}
else
{
if (core.Options.RunMode == ProtoCore.DSASM.InterpreterMode.kExpressionInterpreter &&
!isAllocated)
{
// It happens when the debugger try to watch a variable
// which has been out of scope (as watch is done through
// execute an expression "t = v;" where v is the variable
// to be watched.
EmitPushNull();
return;
}
Validity.Assert(isAllocated);
if (graphNode != null
&& IsAssociativeArrayIndexing
&& !CoreUtils.IsAutoGeneratedVar(symbolnode.name))
{
UpdateNode updateNode = new UpdateNode();
updateNode.symbol = symbolnode;
updateNode.nodeType = UpdateNodeType.kSymbol;
if (graphNode.isIndexingLHS)
{
graphNode.dimensionNodeList.Add(updateNode);
}
else
{
int curDepIndex = graphNode.dependentList.Count - 1;
if (curDepIndex >= 0)
{
var curDep = graphNode.dependentList[curDepIndex].updateNodeRefList[0].nodeList[0];
curDep.dimensionNodeList.Add(updateNode);
if (core.Options.GenerateSSA)
{
if (null != firstSSAGraphNode)
{
curDepIndex = firstSSAGraphNode.dependentList.Count - 1;
if (curDepIndex >= 0)
{
ProtoCore.AssociativeGraph.UpdateNode firstSSAUpdateNode = firstSSAGraphNode.dependentList[curDepIndex].updateNodeRefList[0].nodeList[0];
firstSSAUpdateNode.dimensionNodeList.Add(updateNode);
}
}
}
}
}
}
// If it is a property, replaced it with getter: %get_prop()示例6: PushUpdateNode
public void PushUpdateNode(UpdateNode node)
{
nodeList.Add(node);
}示例7: TraverseDotCallArguments
private void TraverseDotCallArguments(FunctionCallNode funcCall,
FunctionDotCallNode dotCall,
ProcedureNode procCallNode,
List<ProtoCore.Type> arglist,
string procName,
int classIndex,
string className,
bool isStaticCall,
bool isConstructor,
GraphNode graphNode,
AssociativeSubCompilePass subPass,
BinaryExpressionNode bnode)
{
// Update graph dependencies
if (subPass != AssociativeSubCompilePass.kUnboundIdentifier && graphNode != null)
{
if (isStaticCall)
{
Validity.Assert(classIndex != Constants.kInvalidIndex);
Validity.Assert(!string.IsNullOrEmpty(className));
SymbolNode classSymbol = new SymbolNode();
classSymbol.name = className;
classSymbol.classScope = classIndex;
GraphNode dependentNode = new GraphNode();
dependentNode.PushSymbolReference(classSymbol, UpdateNodeType.kSymbol);
graphNode.PushDependent(dependentNode);
}
if (!isConstructor && graphNode.dependentList.Count > 0)
{
UpdateNode updateNode = new UpdateNode();
string propertyName;
if (CoreUtils.TryGetPropertyName(procName, out propertyName))
{
var dummySymbol = new SymbolNode();
dummySymbol.name = propertyName;
updateNode.nodeType = UpdateNodeType.kSymbol;
updateNode.symbol = dummySymbol;
}
else
{
var dummyProcNode = new ProcedureNode();
dummyProcNode.name = procName;
updateNode.nodeType = UpdateNodeType.kMethod;
updateNode.procNode = dummyProcNode;
}
graphNode.dependentList[0].updateNodeRefList[0].nodeList.Add(updateNode);
}
}
int funtionArgCount = 0;
for (int n = 0; n < funcCall.FormalArguments.Count; ++n)
{
if (isStaticCall || isConstructor)
{
if (n != Constants.kDotArgIndexArrayArgs)
{
continue;
}
}
AssociativeNode paramNode = funcCall.FormalArguments[n];
ProtoCore.Type paramType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.kTypeVar, 0);
emitReplicationGuide = false;
// If it's a binary node then continue type check, otherwise
// disable type check and just take the type of paramNode itself
enforceTypeCheck = !(paramNode is BinaryExpressionNode);
if (ProtoCore.DSASM.Constants.kDotArgIndexPtr == n)
{
// Traversing the first arg (the LHS pointer/Static instanct/Constructor
// Replication guides only allowed on method, e.g.,
//
// x = p<1>.f({1,2}<2>);
//
// But not on getter, e.g.,
//
// c = a<1>.x<2>;
if (!CoreUtils.IsGetterSetter(procName) && !isConstructor)
{
emitReplicationGuide = true;
}
DfsTraverse(paramNode, ref paramType, false, graphNode, subPass, bnode);
}
else if (ProtoCore.DSASM.Constants.kDotArgIndexArrayArgs == n)
{
// Traversing the actual arguments passed into the function
// (not the dot function)
int defaultArgNumber = 0;
//.........这里部分代码省略.........
示例8: TraverseDotFunctionCall
//.........这里部分代码省略.........
// Its an accceptable method at this point
if (!isUnresolvedMethod)
{
int funtionArgCount = 0;
//foreach (AssociativeNode paramNode in funcCall.FormalArguments)
for (int n = 0; n < funcCall.FormalArguments.Count; ++n)
{
AssociativeNode paramNode = funcCall.FormalArguments[n];
ProtoCore.Type paramType = new ProtoCore.Type();
paramType.UID = (int)ProtoCore.PrimitiveType.kTypeVoid;
paramType.IsIndexable = false;
emitReplicationGuide = 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);
// TODO Jun: Cleansify me
// What im doing is just taking the second parameter of the dot op (The method call)
// ...and adding it to the graph node dependencies
if (ProtoCore.DSASM.Constants.kDotArgIndexDynTableIndex == n)
{
if (subPass != ProtoCore.DSASM.AssociativeSubCompilePass.kUnboundIdentifier)
{
if (!isConstructor)
{
if (null != procCallNode)
{
if (graphNode.dependentList.Count > 0)
{
ProtoCore.AssociativeGraph.UpdateNodeRef nodeRef = new ProtoCore.AssociativeGraph.UpdateNodeRef();
ProtoCore.AssociativeGraph.UpdateNode updateNode = new ProtoCore.AssociativeGraph.UpdateNode();
ProtoCore.DSASM.ProcedureNode procNodeDummy = new ProtoCore.DSASM.ProcedureNode();
if (procCallNode.isAutoGenerated)
{
ProtoCore.DSASM.SymbolNode sym = new ProtoCore.DSASM.SymbolNode();
sym.name = procName.Remove(0, ProtoCore.DSASM.Constants.kSetterPrefix.Length);
updateNode.nodeType = ProtoCore.AssociativeGraph.UpdateNodeType.kSymbol;
updateNode.symbol = sym;
}
else
{
procNodeDummy.name = procName;
updateNode.nodeType = ProtoCore.AssociativeGraph.UpdateNodeType.kMethod;
updateNode.procNode = procNodeDummy;
}
graphNode.dependentList[0].updateNodeRefList[0].nodeList.Add(updateNode);
}
}
else
{
// comment Jun:
// This is dotarg whos first argument is also a dotarg
// dotarg(dorarg...)...)
if (graphNode.dependentList.Count > 0)
{
if (ProtoCore.Utils.CoreUtils.IsGetterSetter(procName))
{
ProtoCore.AssociativeGraph.UpdateNode updateNode = new ProtoCore.AssociativeGraph.UpdateNode();
ProtoCore.DSASM.SymbolNode sym = new ProtoCore.DSASM.SymbolNode();
sym.name = procName.Remove(0, ProtoCore.DSASM.Constants.kSetterPrefix.Length);
updateNode.nodeType = ProtoCore.AssociativeGraph.UpdateNodeType.kSymbol;
updateNode.symbol = sym;示例9: EmitStringNode
protected void EmitStringNode(
Node node,
ref Type inferedType,
AssociativeGraph.GraphNode graphNode = null,
AssociativeSubCompilePass subPass = AssociativeSubCompilePass.kNone)
{
if (subPass == AssociativeSubCompilePass.kUnboundIdentifier)
{
return;
}
dynamic sNode = node;
if (!enforceTypeCheck || core.TypeSystem.IsHigherRank((int)PrimitiveType.kTypeString, inferedType.UID))
{
inferedType.UID = (int)PrimitiveType.kTypeString;
}
Byte[] utf8bytes = EncodingUtils.UTF8StringToUTF8Bytes((String)sNode.value);
String value = Encoding.UTF8.GetString(utf8bytes);
foreach (char ch in value)
{
String strValue = "'" + ch + "'";
EmitInstrConsole(kw.push, strValue);
StackValue op = StackValue.BuildChar(ch);
EmitPush(op, node.line, node.col);
}
if (IsAssociativeArrayIndexing && graphNode != null && graphNode.isIndexingLHS)
{
SymbolNode literalSymbol = new SymbolNode();
literalSymbol.name = value;
var dimNode = new AssociativeGraph.UpdateNode();
dimNode.symbol = literalSymbol;
dimNode.nodeType = AssociativeGraph.UpdateNodeType.kLiteral;
graphNode.dimensionNodeList.Add(dimNode);
}
EmitInstrConsole(kw.alloca, value.Length.ToString());
EmitPopString(value.Length);
}示例10: EmitDoubleNode
protected void EmitDoubleNode(Node node, ref ProtoCore.Type inferedType, bool isBooleanOp = false, ProtoCore.AssociativeGraph.GraphNode graphNode = null, ProtoCore.DSASM.AssociativeSubCompilePass subPass = ProtoCore.DSASM.AssociativeSubCompilePass.kNone)
{
if (subPass == DSASM.AssociativeSubCompilePass.kUnboundIdentifier)
{
return;
}
dynamic dNode = node;
if (!enforceTypeCheck || core.TypeSystem.IsHigherRank((int)PrimitiveType.kTypeDouble, inferedType.UID))
{
inferedType.UID = (int)PrimitiveType.kTypeDouble;
}
inferedType.UID = isBooleanOp ? (int)PrimitiveType.kTypeBool : inferedType.UID;
if (core.Options.TempReplicationGuideEmptyFlag)
{
if (emitReplicationGuide)
{
int replicationGuides = 0;
// Push the number of guides
EmitInstrConsole(ProtoCore.DSASM.kw.push, replicationGuides + "[guide]");
ProtoCore.DSASM.StackValue opNumGuides = new ProtoCore.DSASM.StackValue();
opNumGuides.optype = ProtoCore.DSASM.AddressType.ReplicationGuide;
opNumGuides.opdata = replicationGuides;
EmitPush(opNumGuides);
}
}
ProtoCore.DSASM.StackValue op = new ProtoCore.DSASM.StackValue();
op.optype = ProtoCore.DSASM.AddressType.Double;
op.opdata = (Int64)System.Convert.ToDouble(dNode.value);
op.opdata_d = System.Convert.ToDouble(dNode.value, cultureInfo);
if (core.Options.TempReplicationGuideEmptyFlag && emitReplicationGuide)
{
EmitInstrConsole(ProtoCore.DSASM.kw.pushg, dNode.value);
EmitPushG(op, dNode.line, dNode.col);
}
else
{
EmitInstrConsole(ProtoCore.DSASM.kw.push, dNode.value);
EmitPush(op, dNode.line, dNode.col);
}
if (IsAssociativeArrayIndexing)
{
if (null != graphNode)
{
// Get the last dependent which is the current identifier being indexed into
SymbolNode literalSymbol = new SymbolNode();
literalSymbol.name = dNode.value;
AssociativeGraph.UpdateNode intNode = new AssociativeGraph.UpdateNode();
intNode.symbol = literalSymbol;
intNode.nodeType = AssociativeGraph.UpdateNodeType.kLiteral;
if (graphNode.isIndexingLHS)
{
graphNode.dimensionNodeList.Add(intNode);
}
else
{
int lastDependentIndex = graphNode.dependentList.Count - 1;
ProtoCore.AssociativeGraph.UpdateNode currentDependentNode = graphNode.dependentList[lastDependentIndex].updateNodeRefList[0].nodeList[0];
currentDependentNode.dimensionNodeList.Add(intNode);
if (core.Options.FullSSA)
{
if (null != firstSSAGraphNode)
{
lastDependentIndex = firstSSAGraphNode.dependentList.Count - 1;
ProtoCore.AssociativeGraph.UpdateNode firstSSAUpdateNode = firstSSAGraphNode.dependentList[lastDependentIndex].updateNodeRefList[0].nodeList[0];
firstSSAUpdateNode.dimensionNodeList.Add(intNode);
}
}
}
}
}
}示例11: EmitIntNode
protected void EmitIntNode(Node node, ref ProtoCore.Type inferedType, bool isBooleanOp = false, ProtoCore.AssociativeGraph.GraphNode graphNode = null, ProtoCore.DSASM.AssociativeSubCompilePass subPass = ProtoCore.DSASM.AssociativeSubCompilePass.kNone)
{
if (subPass == DSASM.AssociativeSubCompilePass.kUnboundIdentifier)
{
return;
}
dynamic iNode = node;
if (!enforceTypeCheck || compileStateTracker.TypeSystem.IsHigherRank((int)PrimitiveType.kTypeInt, inferedType.UID))
{
inferedType.UID = (int)PrimitiveType.kTypeInt;
}
inferedType.UID = isBooleanOp ? (int)PrimitiveType.kTypeBool : inferedType.UID;
if (compileStateTracker.Options.TempReplicationGuideEmptyFlag)
{
if (emitReplicationGuide)
{
int replicationGuides = 0;
// Push the number of guides
EmitInstrConsole(ProtoCore.DSASM.kw.push, replicationGuides + "[guide]");
ProtoCore.DSASM.StackValue opNumGuides = new ProtoCore.DSASM.StackValue();
opNumGuides.optype = ProtoCore.DSASM.AddressType.ReplicationGuide;
opNumGuides.opdata = replicationGuides;
EmitPush(opNumGuides);
}
}
ProtoCore.DSASM.StackValue op = new ProtoCore.DSASM.StackValue();
op.optype = ProtoCore.DSASM.AddressType.Int;
try
{
op.opdata = System.Convert.ToInt64(iNode.value);
op.opdata_d = System.Convert.ToDouble(iNode.value, cultureInfo);
}
catch (System.OverflowException)
{
buildStatus.LogSemanticError("The value is too big or too small to be converted to an integer", compileStateTracker.CurrentDSFileName, node.line, node.col);
}
if (compileStateTracker.Options.TempReplicationGuideEmptyFlag && emitReplicationGuide)
{
EmitInstrConsole(ProtoCore.DSASM.kw.pushg, iNode.value);
EmitPushG(op, iNode.line, iNode.col);
}
else
{
EmitInstrConsole(ProtoCore.DSASM.kw.push, iNode.value);
EmitPush(op, iNode.line, iNode.col);
}
if (IsAssociativeArrayIndexing)
{
if (null != graphNode)
{
// Get the last dependent which is the current identifier being indexed into
SymbolNode literalSymbol = new SymbolNode();
literalSymbol.name = iNode.value;
AssociativeGraph.UpdateNode intNode = new AssociativeGraph.UpdateNode();
intNode.symbol = literalSymbol;
intNode.nodeType = AssociativeGraph.UpdateNodeType.kLiteral;
if (graphNode.isIndexingLHS)
{
graphNode.dimensionNodeList.Add(intNode);
}
else
{
int lastDependentIndex = graphNode.dependentList.Count - 1;
if (lastDependentIndex >= 0)
{
ProtoCore.AssociativeGraph.UpdateNode currentDependentNode = graphNode.dependentList[lastDependentIndex].updateNodeRefList[0].nodeList[0];
currentDependentNode.dimensionNodeList.Add(intNode);
if (null != firstSSAGraphNode)
{
lastDependentIndex = firstSSAGraphNode.dependentList.Count - 1;
if (lastDependentIndex >= 0)
{
ProtoCore.AssociativeGraph.UpdateNode firstSSAUpdateNode = firstSSAGraphNode.dependentList[lastDependentIndex].updateNodeRefList[0].nodeList[0];
firstSSAUpdateNode.dimensionNodeList.Add(intNode);
}
}
}
}
}
}
}示例12: EmitStringNode
protected void EmitStringNode(
Node node,
ref Type inferedType,
AssociativeGraph.GraphNode graphNode = null,
ProtoCore.CompilerDefinitions.Associative.SubCompilePass subPass = ProtoCore.CompilerDefinitions.Associative.SubCompilePass.kNone)
{
if (subPass == ProtoCore.CompilerDefinitions.Associative.SubCompilePass.kUnboundIdentifier)
{
return;
}
dynamic sNode = node;
if (!enforceTypeCheck || core.TypeSystem.IsHigherRank((int)PrimitiveType.kTypeString, inferedType.UID))
{
inferedType.UID = (int)PrimitiveType.kTypeString;
}
string value = (string)sNode.Value;
StackValue svString = core.Heap.AllocateFixedString(value);
EmitOpWithEmptyReplicationGuide(emitReplicationGuide, svString, "\"" + value + "\"", node);
if (IsAssociativeArrayIndexing && graphNode != null && graphNode.isIndexingLHS)
{
SymbolNode literalSymbol = new SymbolNode();
literalSymbol.name = value;
var dimNode = new AssociativeGraph.UpdateNode();
dimNode.symbol = literalSymbol;
dimNode.nodeType = AssociativeGraph.UpdateNodeType.kLiteral;
graphNode.dimensionNodeList.Add(dimNode);
}
}示例13: EmitIntNode
protected void EmitIntNode(Node node, ref ProtoCore.Type inferedType, bool isBooleanOp = false, ProtoCore.AssociativeGraph.GraphNode graphNode = null, ProtoCore.CompilerDefinitions.Associative.SubCompilePass subPass = ProtoCore.CompilerDefinitions.Associative.SubCompilePass.kNone)
{
if (subPass == ProtoCore.CompilerDefinitions.Associative.SubCompilePass.kUnboundIdentifier)
{
return;
}
Int64 value;
if (node is AST.ImperativeAST.IntNode)
{
value = (node as AST.ImperativeAST.IntNode).Value;
}
else if (node is AST.AssociativeAST.IntNode)
{
value = (node as AST.AssociativeAST.IntNode).Value;
}
else
{
throw new InvalidDataException("The input node is not a IntNode");
}
if (!enforceTypeCheck || core.TypeSystem.IsHigherRank((int)PrimitiveType.kTypeInt, inferedType.UID))
{
inferedType.UID = (int)PrimitiveType.kTypeInt;
}
inferedType.UID = isBooleanOp ? (int)PrimitiveType.kTypeBool : inferedType.UID;
EmitOpWithEmptyReplicationGuide(emitReplicationGuide, StackValue.BuildInt(value), value.ToString(), node);
if (IsAssociativeArrayIndexing)
{
if (null != graphNode)
{
// Get the last dependent which is the current identifier being indexed into
SymbolNode literalSymbol = new SymbolNode();
literalSymbol.name = value.ToString();
AssociativeGraph.UpdateNode intNode = new AssociativeGraph.UpdateNode();
intNode.symbol = literalSymbol;
intNode.nodeType = AssociativeGraph.UpdateNodeType.kLiteral;
if (graphNode.isIndexingLHS)
{
graphNode.dimensionNodeList.Add(intNode);
}
else
{
int lastDependentIndex = graphNode.dependentList.Count - 1;
if (lastDependentIndex >= 0)
{
ProtoCore.AssociativeGraph.UpdateNode currentDependentNode = graphNode.dependentList[lastDependentIndex].updateNodeRefList[0].nodeList[0];
currentDependentNode.dimensionNodeList.Add(intNode);
if (core.Options.GenerateSSA)
{
if (null != firstSSAGraphNode)
{
lastDependentIndex = firstSSAGraphNode.dependentList.Count - 1;
if (lastDependentIndex >= 0)
{
ProtoCore.AssociativeGraph.UpdateNode firstSSAUpdateNode = firstSSAGraphNode.dependentList[lastDependentIndex].updateNodeRefList[0].nodeList[0];
firstSSAUpdateNode.dimensionNodeList.Add(intNode);
}
}
}
}
}
}
}
}示例14: DFSGetSymbolList_Simple
// Deperecate this function after further regression testing and just use DFSGetSymbolList
public void DFSGetSymbolList_Simple(Node pNode, ref ProtoCore.Type lefttype, ref int functionindex, ProtoCore.AssociativeGraph.UpdateNodeRef nodeRef)
{
dynamic node = pNode;
if (node is ProtoCore.AST.ImperativeAST.IdentifierListNode || node is ProtoCore.AST.AssociativeAST.IdentifierListNode)
{
dynamic bnode = node;
DFSGetSymbolList_Simple(bnode.LeftNode, ref lefttype, ref functionindex, nodeRef);
node = bnode.RightNode;
}
if (node is ProtoCore.AST.ImperativeAST.IdentifierNode || node is ProtoCore.AST.AssociativeAST.IdentifierNode)
{
dynamic identnode = node;
ProtoCore.DSASM.SymbolNode symbolnode = null;
bool isAccessible = false;
bool isAllocated = VerifyAllocation(identnode.Value, lefttype.UID, functionindex, out symbolnode, out isAccessible);
if (isAllocated)
{
if (null == symbolnode)
{
// It is inaccessible from here due to access modifier.
// Just attempt to retrieve the symbol
int symindex = core.ClassTable.ClassNodes[lefttype.UID].GetFirstVisibleSymbolNoAccessCheck(identnode.Value);
if (ProtoCore.DSASM.Constants.kInvalidIndex != symindex)
{
symbolnode = core.ClassTable.ClassNodes[lefttype.UID].Symbols.symbolList[symindex];
}
}
// Since the variable was found, all succeeding nodes in the ident list are class members
// Class members have a function scope of kGlobalScope as they are only local to the class, not with any member function
functionindex = ProtoCore.DSASM.Constants.kGlobalScope;
lefttype = symbolnode.datatype;
ProtoCore.AssociativeGraph.UpdateNode updateNode = new AssociativeGraph.UpdateNode();
updateNode.symbol = symbolnode;
updateNode.nodeType = ProtoCore.AssociativeGraph.UpdateNodeType.kSymbol;
nodeRef.PushUpdateNode(updateNode);
}
else
{
// Is it a class?
int ci = core.ClassTable.IndexOf(identnode.Value);
if (ProtoCore.DSASM.Constants.kInvalidIndex != ci)
{
lefttype.UID = ci;
// Comment Jun:
// Create a symbol node that contains information about the class type that contains static properties
ProtoCore.DSASM.SymbolNode classSymbol = new DSASM.SymbolNode();
classSymbol.memregion = DSASM.MemoryRegion.kMemStatic;
classSymbol.name = identnode.Value;
classSymbol.classScope = ci;
ProtoCore.AssociativeGraph.UpdateNode updateNode = new AssociativeGraph.UpdateNode();
updateNode.symbol = classSymbol;
updateNode.nodeType = ProtoCore.AssociativeGraph.UpdateNodeType.kSymbol;
nodeRef.PushUpdateNode(updateNode);
}
else
{
// In this case, the lhs type is undefined
// Just attempt to create a symbol node
string ident = identnode.Value;
if (0 != ident.CompareTo(ProtoCore.DSDefinitions.Keyword.This))
{
symbolnode = new SymbolNode();
symbolnode.name = identnode.Value;
ProtoCore.AssociativeGraph.UpdateNode updateNode = new AssociativeGraph.UpdateNode();
updateNode.symbol = symbolnode;
updateNode.nodeType = AssociativeGraph.UpdateNodeType.kSymbol;
nodeRef.PushUpdateNode(updateNode);
}
}
}
}
else if (node is ProtoCore.AST.ImperativeAST.FunctionCallNode || node is ProtoCore.AST.AssociativeAST.FunctionCallNode)
{
string functionName = node.Function.Value;
if (ProtoCore.Utils.CoreUtils.IsGetterSetter(functionName))
{
string property;
if (CoreUtils.TryGetPropertyName(functionName, out property))
{
functionName = property;
}
ProtoCore.DSASM.SymbolNode symbolnode = null;
bool isAccessible = false;
bool isAllocated = VerifyAllocation(functionName, lefttype.UID, globalProcIndex, out symbolnode, out isAccessible);
if (isAllocated)
{
if (null == symbolnode)
//.........这里部分代码省略.........
示例15: PushSymbolReference
public void PushSymbolReference(ProtoCore.DSASM.SymbolNode symbol, ProtoCore.AssociativeGraph.UpdateNodeType type = UpdateNodeType.kSymbol)
{
Validity.Assert(null != symbol);
Validity.Assert(null != updateNodeRefList);
UpdateNode updateNode = new UpdateNode();
updateNode.symbol = symbol;
updateNode.nodeType = type;
UpdateNodeRef nodeRef = new UpdateNodeRef();
nodeRef.PushUpdateNode(updateNode);
updateNodeRefList.Add(nodeRef);
}