public void AddNode(Node node) { if (AllNodes.Contains(node)) return; AllNodes.Add(node); if (!DirectContingents.ContainsKey(node)) DirectContingents.Add(node, new List<Node>()); if (!DirectDependents.ContainsKey(node)) DirectDependents.Add(node, new List<Node>()); }
void functiondecl(out Node node, ProtoCore.DSASM.AccessModifier access = ProtoCore.DSASM.AccessModifier.kPublic) { FunctionDefinitionNode f = new FunctionDefinitionNode(); string methodName; Node argumentSignature; ProtoCore.Type returnType; Node pattern; string externLibName = ""; bool isExternLib = false; bool isDNI = false; if (la.kind == 26) { Get(); isExternLib = true; if (la.kind == 22) { Get(); isDNI = true; } ExternalLibraryReference(out externLibName); } Expect(25); MethodSignature(out methodName, out argumentSignature, out pattern, out returnType); f = new FunctionDefinitionNode(); f.IsExternLib = isExternLib; f.IsDNI = isDNI; f.ExternLibName = externLibName; f.Name = methodName; f.Name = methodName; f.Pattern = pattern; f.ReturnType = returnType; f.access = access; f.Singnature = argumentSignature as ArgumentSignatureNode; Node functionBody = null; if (la.kind == 20) { Get(); } else if (la.kind == 32) { FunctionalMethodBodyMultiLine(out functionBody); } else SynErr(62); f.FunctionBody = functionBody as CodeBlockNode; node = f; }
public override void ConsolidateNames(ref Dictionary<string, List<Node>> names) { IdentifierNode rightTerminalNode = RightNode as IdentifierNode; if (rightTerminalNode != null) { if (Optr != ProtoCore.DSASM.Operator.dot) { //replace RHS Consolidate(ref(names), ref(rightTerminalNode)); RightNode = rightTerminalNode; } } else { RightNode.ConsolidateNames(ref(names)); } //left has to be done 2nd, because in case of modifiers, we dont want to //replace the node on RHS by a node on LHS. So a modifier stack name is not unique. IdentifierNode leftTerminalNode = LeftNode as IdentifierNode; if (leftTerminalNode != null) { if (Optr != ProtoCore.DSASM.Operator.assign) { //replace LHS Consolidate(ref(names), ref(leftTerminalNode)); LeftNode = leftTerminalNode; } else { if (leftTerminalNode.Name != null) { if (names.ContainsKey(leftTerminalNode.Name)) { List<Node> candidates = names[leftTerminalNode.Name]; candidates.Add(leftTerminalNode); } else { //append LHS List<Node> candidates = new List<Node>(); candidates.Add(leftTerminalNode); names.Add(leftTerminalNode.Name, candidates); } } } } else { LeftNode.ConsolidateNames(ref(names)); } }
public void RemoveDirectContingents(Node node) { DirectContingents[node].Clear(); }
public void AddDirectDependent(Node node, Node dependent) { if (!DirectDependents[node].Contains(dependent)) DirectDependents[node].Add(dependent); }
public static void GenerateDependencyGraph(this DependencyTracker tracker, Node t) { t.GenerateDependencyGraph(tracker); }
void ComparisonExpression(out Node node) { RangeExpr(out node); while (StartOf(9)) { Operator op; ComparisonOp(out op); Node expr2; RangeExpr(out expr2); BinaryExpressionNode binaryNode = new BinaryExpressionNode(); binaryNode.LeftNode = node; binaryNode.RightNode = expr2; binaryNode.Optr = op; node = binaryNode; } }
void LogicalExpression(out Node node) { ComparisonExpression(out node); while (la.kind == 55 || la.kind == 56) { Operator op; LogicalOp(out op); Node expr2; Expression(out expr2); BinaryExpressionNode binaryNode = new BinaryExpressionNode(); binaryNode.LeftNode = node; binaryNode.RightNode = expr2; binaryNode.Optr = op; node = binaryNode; } }
void BaseConstructorCall(out Node bnode) { FunctionCallNode f = new FunctionCallNode(); NodeList args = null; Expect(37); if (la.kind == 1) { Ident(out bnode); f.Function = bnode; } Arguments(out args); f.FormalArguments = args; bnode = f; }
void MethodSignature(out string methodName, out Node argumentSign, out Node pattern, out ProtoCore.Type returnType) { Expect(1); methodName = t.val; Node argumentSignature = null; returnType = new ProtoCore.Type(); returnType.Name = "var"; returnType.UID = 0; // TODO Jun: Luke made changes to array representation, handle this //returnType.IsArray = false; if (la.kind == 36) { TypeRestriction(out returnType); } ArgumentSignatureDefinition(out argumentSignature); pattern = null; if (la.kind == 15) { PatternExpression(out pattern); } argumentSign = argumentSignature; }
void constructordecl(out Node constrNode, ProtoCore.DSASM.AccessModifier access) { ConstructorDefinitionNode constr = null; string methodName; Node argumentSignature; ProtoCore.Type returnType; Node pattern; Expect(24); MethodSignature(out methodName, out argumentSignature, out pattern, out returnType); constr = new ConstructorDefinitionNode(); constr.Name = methodName; constr.Pattern = pattern; constr.ReturnType = returnType; constr.Signature = argumentSignature as ArgumentSignatureNode; constr.access = access; Node functionBody = null; if (la.kind == 36) { Get(); Node bnode; BaseConstructorCall(out bnode); constr.baseConstr = bnode as FunctionCallNode; } FunctionalMethodBodyMultiLine(out functionBody); constr.FunctionBody = functionBody as CodeBlockNode; constrNode = constr; }
void ForLoop(out Node forLoop) { Node node; ForLoopNode loop = new ForLoopNode(); NodeList forBody = null; Expect(48); Expect(18); IdentifierList(out node); loop.id = node; Expect(49); Expression(out node); loop.expression = node; Expect(19); Expect(32); StatementList(out forBody); loop.body = forBody; Expect(33); forLoop = loop; }
void FunctionalStatement(out Node node) { while (!(la.kind == 0 || la.kind == 1)) {SynErr(64); Get();} node = null; Node leftNode; IdentifierList(out leftNode); Expect(35); Node rightNode = null; if (la.kind == 11) { LanguageBlock(out rightNode); BinaryExpressionNode expressionNode = new BinaryExpressionNode(); expressionNode.LeftNode = leftNode; expressionNode.RightNode = rightNode; expressionNode.Optr = Operator.assign; node = expressionNode; } else if (StartOf(4)) { Expression(out rightNode); BinaryExpressionNode expressionNode = new BinaryExpressionNode(); expressionNode.LeftNode = leftNode; expressionNode.RightNode = rightNode; expressionNode.Optr = Operator.assign; node = expressionNode; while (!(la.kind == 0 || la.kind == 20)) {SynErr(65); Get();} Expect(20); } else if (la.kind == 41) { Get(); ModifierStackNode mstack = new ModifierStackNode(); string name = ""; Expression(out rightNode); if (la.kind == 42) { Get(); Expect(1); name = t.val; } BinaryExpressionNode expressionNode = new BinaryExpressionNode(); expressionNode.RightNode = rightNode; expressionNode.LeftNode = leftNode; expressionNode.Optr = Operator.assign; mstack.AddElementNode(expressionNode, name); while (!(la.kind == 0 || la.kind == 20)) {SynErr(66); Get();} Expect(20); while (StartOf(5)) { name = ""; bool bHasOperator = false; Operator op = Operator.add; if (StartOf(6)) { bHasOperator = true; BinaryOps(out op); } Expression(out rightNode); if (la.kind == 42) { Get(); Expect(1); name = t.val; } if(!bHasOperator) { expressionNode = new BinaryExpressionNode(); expressionNode.RightNode = rightNode; expressionNode.LeftNode = leftNode; expressionNode.Optr = Operator.assign; mstack.AddElementNode(expressionNode, name); } else { BinaryExpressionNode expressionNode2 = new BinaryExpressionNode(); expressionNode2.LeftNode = leftNode; expressionNode2.RightNode = rightNode; expressionNode2.Optr = op; expressionNode = new BinaryExpressionNode(); expressionNode.RightNode = expressionNode2; expressionNode.LeftNode = leftNode; expressionNode.Optr = Operator.assign; mstack.AddElementNode(expressionNode, name); } while (!(la.kind == 0 || la.kind == 20)) {SynErr(67); Get();} Expect(20); } node = mstack; Expect(33); } else SynErr(68); }
void LanguageBlock(out Node node) { node = null; LanguageBlockNode langblock = new LanguageBlockNode(); Expect(11); Expect(1); if( 0 == t.val.CompareTo("Imperative")) { langblock.codeblock.language = ProtoCore.Language.kImperative; } else if( 0 == t.val.CompareTo("Associative")) { langblock.codeblock.language = ProtoCore.Language.kAssociative; } while (la.kind == 34) { Get(); string key; Expect(1); key = t.val; Expect(35); Expect(4); if ("fingerprint" == key) { langblock.codeblock.fingerprint = t.val; langblock.codeblock.fingerprint = langblock.codeblock.fingerprint.Remove(0,1); langblock.codeblock.fingerprint = langblock.codeblock.fingerprint.Remove(langblock.codeblock.fingerprint.Length-1,1); } else if ("version" == key) { langblock.codeblock.version = t.val; langblock.codeblock.version = langblock.codeblock.version.Remove(0,1); langblock.codeblock.version = langblock.codeblock.version.Remove(langblock.codeblock.version.Length-1,1); } } Expect(12); Expect(31); langblock.codeblock.body = t.val.Substring(2,t.val.Length-4); node = langblock; ParseLanguageBlockNode(langblock); }
void classdecl(out Node node) { ClassDeclNode classnode = new ClassDeclNode(); Expect(23); Expect(1); classnode.name = t.val; if (la.kind == 27) { Get(); Expect(1); classnode.superClass = new List<string>(); classnode.superClass.Add(t.val); while (la.kind == 1) { Get(); classnode.superClass.Add(t.val); } } Expect(32); while (StartOf(3)) { ProtoCore.DSASM.AccessModifier access = ProtoCore.DSASM.AccessModifier.kPublic; if (la.kind == 38 || la.kind == 39 || la.kind == 40) { AccessModifier(out access); } if (la.kind == 24) { Node constr = null; constructordecl(out constr, access); classnode.funclist.Add(constr); } else if (la.kind == 25 || la.kind == 26) { Node funcnode; functiondecl(out funcnode, access); classnode.funclist.Add(funcnode); } else if (la.kind == 1) { Node varnode = null; vardecl(out varnode, access); classnode.varlist.Add(varnode); Expect(20); } else SynErr(63); } Expect(33); node = classnode; }
void IdentifierList(out Node node) { node = null; NameReference(out node); while (la.kind == 5) { Get(); Node rnode = null; NameReference(out rnode); IdentifierListNode bnode = new IdentifierListNode(); bnode.LeftNode = node; bnode.Optr = Operator.dot; bnode.RightNode = rnode; node = bnode; } }
void UnaryExpression(out Node node) { node = null; UnaryOperator op; Node exprNode; unaryop(out op); Expression(out exprNode); UnaryExpressionNode unary = new UnaryExpressionNode(); unary.Operator = op; unary.Expression = exprNode; node = unary; }
void FunctionalMethodBodyMultiLine(out Node funcBody) { CodeBlockNode functionBody = new CodeBlockNode(); NodeList body = new NodeList(); Expect(32); StatementList(out body); functionBody = new CodeBlockNode(); functionBody.Body =body; Expect(33); funcBody = functionBody; }
void TernaryOp(ref Node node) { InlineConditionalNode inlineConNode = new InlineConditionalNode(); Expect(43); inlineConNode.ConditionExpression = node; node = null; Expression(out node); inlineConNode.TrueExpression = node; Expect(36); node = null; Expression(out node); inlineConNode.FalseExpression = node; node = inlineConNode; }
void Ident(out Node node) { Expect(1); int ltype = (0 == String.Compare(t.val, "return")) ? (int)ProtoCore.PrimitiveType.kTypeReturn : (int)ProtoCore.PrimitiveType.kTypeVar; IdentifierNode var = new IdentifierNode() { // TODO Jun: Move the primitive types into a class table Value = t.val, Name = t.val, type = ltype, datatype = (ProtoCore.PrimitiveType)ltype }; node = var; }
void RangeExpr(out Node node) { ArithmeticExpression(out node); if (la.kind == 21) { RangeExprNode rnode = new RangeExprNode(); rnode.FromNode = node; Get(); ArithmeticExpression(out node); rnode.ToNode = node; if (la.kind == 21) { RangeStepOperator op; Get(); rangeStepOperator(out op); rnode.stepoperator = op; ArithmeticExpression(out node); rnode.StepNode = node; } node = rnode; } }
void ArgumentSignatureDefinition(out Node argumentSign) { ArgumentSignatureNode argumentSignature = new ArgumentSignatureNode(); Expect(18); if (la.kind == 1) { Node arg; ArgDecl(out arg); argumentSignature.AddArgument(arg as VarDeclNode); while (la.kind == 34) { Get(); ArgDecl(out arg); argumentSignature.AddArgument(arg as VarDeclNode); } } Expect(19); argumentSign = argumentSignature; }
public void AddDirectContingent(Node node, Node contingent) { if(!DirectContingents[node].Contains(contingent)) DirectContingents[node].Add(contingent); }
void PatternExpression(out Node pattern) { Node p = null; Expect(15); Expression(out p); pattern = p; }
void ArgDecl(out Node node, ProtoCore.DSASM.AccessModifier access = ProtoCore.DSASM.AccessModifier.kPublic) { IdentifierNode tNode = null; VarDeclNode varDeclNode = new VarDeclNode(); varDeclNode.memregion = ProtoCore.DSASM.MemoryRegion.kMemStack; varDeclNode.access = access; if (IsArrayAccess()) { arrayIdent(out node); tNode = node as IdentifierNode; varDeclNode.NameNode = tNode; } else if (la.kind == 1) { Get(); tNode = new IdentifierNode() { Value = t.val, Name = t.val, type = (int)ProtoCore.PrimitiveType.kTypeVar, datatype = ProtoCore.PrimitiveType.kTypeVar }; varDeclNode.NameNode = tNode; } else SynErr(71); ProtoCore.Type argtype = new ProtoCore.Type(); argtype.Name = "var"; argtype.rank = 0; argtype.UID = 0; if (la.kind == 36) { Get(); Expect(1); argtype.Name = t.val; if (la.kind == 11) { argtype.IsIndexable = true; Get(); Expect(12); argtype.rank = 1; if (la.kind == 11 || la.kind == 21 || la.kind == 35) { if (la.kind == 21) { Get(); Expect(11); Expect(12); argtype.rank = ProtoCore.DSASM.Constants.nDimensionArrayRank; } else { while (la.kind == 11) { Get(); Expect(12); argtype.rank++; } } } } } varDeclNode.ArgumentType = argtype; if (la.kind == 35) { Get(); Node rhsNode; Expression(out rhsNode); BinaryExpressionNode bNode = new BinaryExpressionNode(); bNode.LeftNode = tNode; bNode.RightNode = rhsNode; bNode.Optr = Operator.assign; varDeclNode.NameNode = bNode; } node = varDeclNode; }
void arrayIdent(out Node node) { Ident(out node); IdentifierNode var = node as IdentifierNode; if (la.kind == 11) { ArrayNode array = null; arrayIndices(out array); var.ArrayDimensions = array; } }
public void RemoveDirectDependents(Node node) { DirectDependents[node].Clear(); }
void Expression(out Node node) { node = null; if (la.kind == 13 || la.kind == 57) { UnaryExpression(out node); } else if (StartOf(8)) { LogicalExpression(out node); } else SynErr(72); while (la.kind == 43) { TernaryOp(ref node); } }
public void AddElementNode(Node n, string name) { ElementNodes.Add(n); if ("" != name) { AtNames.Add(name, n); BinaryExpressionNode o = n as BinaryExpressionNode; IdentifierNode t = o.LeftNode as IdentifierNode; BinaryExpressionNode e = new BinaryExpressionNode(); e.LeftNode = new IdentifierNode() { Value = name, Name = name, type = t.type, datatype = t.datatype }; e.RightNode = t; e.Optr = ProtoCore.DSASM.Operator.assign; ElementNodes.Add(e); } }
void Statement(out Node node) { while (!(StartOf(2))) {SynErr(60); Get();} node = null; if (la.kind == 1) { FunctionalStatement(out node); } else if (la.kind == 48) { ForLoop(out node); } else if (la.kind == 20) { Get(); } else SynErr(61); }