public ScriptFuncContract(AstNodeArgs args) : base(args) { pre = ChildNodes[0] as ScriptFuncContractPre; post = ChildNodes[1] as ScriptFuncContractPost; inv = ChildNodes[2] as ScriptFuncContractInv; }
public ScriptTypeConvertExpr(AstNodeArgs args) : base(args) { if (ChildNodes.Count == 2) { if (args.ChildNodes[0] is ScriptExpr && !(args.ChildNodes[1] is ScriptExpr)) { // ( Expr ) expr = args.ChildNodes[0] as ScriptExpr; } else { //(Type) Expr typeExpr = args.ChildNodes[0] as ScriptExpr; expr = args.ChildNodes[1] as ScriptExpr; } } else { throw new ScriptException("Grammar error!"); } @operator = RuntimeHost.GetBinaryOperator("+"); if (@operator == null) throw new ScriptException("RuntimeHost did not initialize property. Can't find binary operators."); }
public ScriptFunctionDefinition(AstNodeArgs args) : base(args) { Token funcName = ChildNodes[1] as Token; int index = 0; if (funcName != null) { Name = funcName.Text; } else //Function expression { Name = null; index = 1; } if (ChildNodes.Count == 5-index) { Contract = ChildNodes[3 - index] as ScriptFuncContract; Parameters = ChildNodes[3 - index] as ScriptFuncParameters; } if (ChildNodes.Count == 6 - index) { Parameters = ChildNodes[2 - index] as ScriptFuncParameters; GlobalList = ChildNodes[3 - index] as ScriptGlobalList; Contract = ChildNodes[4 - index] as ScriptFuncContract; } Body = (ScriptAst)ChildNodes[ChildNodes.Count - 1]; }
public ScriptForEachStatement(AstNodeArgs args) : base(args) { name = (Token)ChildNodes[1]; expr = (ScriptExpr)ChildNodes[3]; statement = (ScriptStatement)ChildNodes[4]; }
public ScriptFuncParameters(AstNodeArgs args) : base(args) { if (ChildNodes.Count == 1) { for (int index = 0; index < ChildNodes[0].ChildNodes.Count; index++) { AstNode astNode = ChildNodes[0].ChildNodes[index]; Identifiers.Add((astNode as Token).Text); } } //if (ChildNodes[0] is Token) //{ // Identifiers.Add((ChildNodes[0] as Token).Text); //} //else //{ // for (int index = 0; index < ChildNodes[0].ChildNodes.Count; index++) // { // AstNode astNode = ChildNodes[0].ChildNodes[index]; // Identifiers.Add((astNode as Token).Text); // } //} }
public ScriptForStatement(AstNodeArgs args) : base(args) { init = (ScriptAst)args.ChildNodes[1]; cond = (ScriptAst)args.ChildNodes[2]; next = (ScriptAst)args.ChildNodes[3]; statement = (ScriptStatement)args.ChildNodes[4]; }
protected internal AstNode InvokeNodeCreator(AstNodeArgs args) { if (NodeCreator == null) { return(null); } return(NodeCreator(args)); }
public ScriptTryCatchFinallyStatement(AstNodeArgs args) : base(args) { tryBlock = ChildNodes[1] as ScriptStatement; expName = (ChildNodes[3] as Token).Text; catchBlock = ChildNodes[4] as ScriptStatement; finallyBlock = ChildNodes[6] as ScriptStatement; }
public static Token CreateMultiToken(Terminal term, CompilerContext context, TokenList tokens) { SourceSpan span = new SourceSpan(); AstNodeArgs args = new AstNodeArgs(term, context, span, null); Token token = new Token(args); token.ChildNodes.AddRange(tokens.ToArray()); return(token); }
public ScriptFlowControlStatement(AstNodeArgs args) : base(args) { Token oper = ChildNodes[0] as Token; operation = oper.Text; Debug.Assert(oper.Text == "return" || oper.Text == "break" || oper.Text == "continue" || oper.Text == "throw"); if (operation == "return" || operation == "throw") expression = (ScriptExpr)ChildNodes[1]; }
public ScriptConstExpr(AstNodeArgs args) : base(args) { Token cons = (Token)ChildNodes[0]; Value = cons.Value; if (Value.Equals("true")) Value = true; if (Value.Equals("false")) Value = false; if (Value.Equals("null")) Value = null; }
public static Token Create(Terminal term, CompilerContext context, SourceLocation location, string text, object value) { int textLen = text == null ? 0 : text.Length; SourceSpan span = new SourceSpan(location, textLen); AstNodeArgs args = new AstNodeArgs(term, context, span, null); Token token = new Token(args); token.Text = text; token.Value = value; return(token); }
public ScriptBinExpr(AstNodeArgs args) : base(args) { left = (ScriptExpr)ChildNodes[0]; oper = ((Token)ChildNodes[1]).Text; right = (ScriptExpr)ChildNodes[2]; operatorFunction = RuntimeHost.GetBinaryOperator(oper); if (operatorFunction == null) throw new ScriptException("RuntimeHost did not initialize property. Can't find binary operators."); }
public GlobalFunctionExpr(AstNodeArgs args) : base(args) { this.FunctionName = (Token)args.ChildNodes[0].DepthFirstTraversal().OfType<Token>().Single(); AstNodeList funcArgs = args.ChildNodes[2].ChildNodes; this.InputParameter1 = (ExpressionNode)funcArgs[0]; if (funcArgs.Count > 1) this.InputParameter2 = (ExpressionNode)funcArgs[1]; if (funcArgs.Count > 2) this.InputParameter3 = (ExpressionNode)funcArgs[2]; }
public ScriptIfStatement(AstNodeArgs args) : base(args) { condition = (ScriptCondition) ChildNodes[1]; statement = (ScriptStatement)ChildNodes[2]; //Else exists if (ChildNodes.Count == 4 && ChildNodes[3].ChildNodes.Count == 2 && ChildNodes[3].ChildNodes[1] is ScriptStatement) { elseStatement = (ScriptStatement)ChildNodes[3].ChildNodes[1]; } }
public ScriptSwitchStatement(AstNodeArgs args) : base(args) { cases = new List<ScriptSwitchCaseStatement>(); foreach (ScriptSwitchCaseStatement caseStatement in ChildNodes[0].ChildNodes) { cases.Add(caseStatement); } if (ChildNodes.Count == 2) defaultCase = ChildNodes[1] as ScriptSwitchDefaultStatement; }
public IfElseStmtNode(AstNodeArgs args) : base(args) { _condition = (IJSBasicNode)args.ChildNodes[1]; _thenExpression = (IJSBasicNode)args.ChildNodes[3]; //Child #4 is ELSE_CLAUSE AstNode elseClause = args.ChildNodes[4]; if (elseClause.ChildNodes.Count > 0) { _elseExpression = (IJSBasicNode)elseClause.ChildNodes[1]; } }
public ScriptMetaExpr(AstNodeArgs args) : base(args) { AstNodeArgs progArgs = new AstNodeArgs(); progArgs.ChildNodes = new AstNodeList(); progArgs.ChildNodes.Add(ChildNodes[1]); progArgs.Span = args.Span; progArgs.Term = args.Term; metaProg = new ScriptProg(progArgs); metaProg.Parent = this; }
public ScriptQualifiedName(AstNodeArgs args) : base(args) { if (ChildNodes.Count == 2 && ChildNodes[1].ChildNodes.Count == 0) { Identifier = ((Token)ChildNodes[0]).Text; evaluation = EvaluateIdentifier; assignment = AssignIdentifier; } else if (ChildNodes[0] is Token && ChildNodes[1].ChildNodes.Count != 0) { Identifier = (ChildNodes[0] as Token).Text; //NOTE: There might be two cases: // 1) a()[]...() // 2) a<>.(NamePart) Modifiers = new List<ScriptAst>(); foreach (ScriptAst node in ChildNodes[1].ChildNodes) Modifiers.Add(node); ScriptGenericsPostfix generic = Modifiers.FirstOrDefault() as ScriptGenericsPostfix; if (generic != null && Modifiers.Count == 1) { //Case 2 evaluation = EvaluateGenericType; assignment = null; } else { //Case 1 evaluation = EvaluateFunctionCall; assignment = AssignArray; } } else { NamePart = ChildNodes[0] as ScriptQualifiedName; Identifier = ((Token)ChildNodes[2]).Text; if (ChildNodes.Count == 4 && ChildNodes[3].ChildNodes.Count != 0) { Modifiers = new List<ScriptAst>(); foreach (ScriptAst node in ChildNodes[3].ChildNodes) { Modifiers.Add(node); } } evaluation = EvaluateNamePart; assignment = AssignNamePart; } }
public LineNode(AstNodeArgs args) : base(args) { LineTypes = LineTypes.InternalLine; // overwritten later by JavaScriptGenerator LineNumber = (int)((Token)args.ChildNodes[0]).Value; if (args.ChildNodes.Count > 2) { StatementList = (GenericJsBasicNode)args.ChildNodes[1]; } else { StatementList = new GenericJsBasicNode(args); //empty node } }
public ScriptUnaryExpr(AstNodeArgs args) : base(args) { if (ChildNodes[0] is ScriptExpr) { expr = (ScriptExpr)ChildNodes[0]; oper = ((Token)ChildNodes[1]).Text; } else { expr = (ScriptExpr)ChildNodes[1]; oper = ((Token)ChildNodes[0]).Text; } }
public ForStmtNode(AstNodeArgs args) : base(args) { _assignment = (AssignStmtNode)args.ChildNodes[1]; _upperBound = (ExpressionNode)args.ChildNodes[3]; if (args.ChildNodes.Count == 6) { _step = int.Parse(((Token)args.ChildNodes[5]).Text, CultureInfo.InvariantCulture); } else { _step = 1; } }
public RemStmtNode(AstNodeArgs args) : base(args) { Token token = (Token)args.ChildNodes[0]; string text = token.Text; if (text.Length < 5) { _comment = "no comment"; } else { _comment = text.Substring(4); } }
public AstNode(AstNodeArgs args) { Term = args.Term; Span = args.Span; if (args.ChildNodes == null || args.ChildNodes.Count == 0) { return; } //add child nodes, skipping nulls and punctuation symbols foreach (AstNode child in args.ChildNodes) { if (child != null && !child.Term.IsSet(TermOptions.IsPunctuation)) { AddChild(child); } }//foreach }
public BranchStmtNode(AstNodeArgs args) : base(args) { Token command = (Token)args.ChildNodes[0]; if (args.ChildNodes.Count == 1) { BranchType = BranchType.Return; } else { Token line = (Token)args.ChildNodes[1]; BranchType = (command.Text.ToLowerInvariant().Equals("goto") ? BranchType.Goto : BranchType.Gosub); DestinationLine = int.Parse(line.Text, CultureInfo.InvariantCulture); } }
public ScriptMObject(AstNodeArgs args) : base(args) { objectParts = new List<ScriptMObjectPart>(); if (args.ChildNodes[0] is ScriptMObjectPart) { ScriptMObjectPart part = (ScriptMObjectPart)args.ChildNodes[0]; objectParts.Add(part); } else { foreach (ScriptMObjectPart part in args.ChildNodes[0].ChildNodes) { objectParts.Add(part); } } }
public ScriptTypeExpr(AstNodeArgs args) : base(args) { if (ChildNodes.Count == 2 && ChildNodes[1].ChildNodes.Count == 0) { Identifier = ((Token)ChildNodes[0]).Text; } else if (ChildNodes[0] is ScriptTypeExpr) { TypeExpr = ChildNodes[0] as ScriptTypeExpr; Identifier = (ChildNodes[2].ChildNodes[0] as Token).Text; GenericsPostfix = ChildNodes[2].ChildNodes[1] as ScriptGenericsPostfix; } else { GenericsPostfix = (ScriptGenericsPostfix)ChildNodes[1]; Identifier = GenericsPostfix.GetGenericTypeName(((Token)ChildNodes[0]).Text); } }
public ScriptAssignExpr(AstNodeArgs args) : base(args) { nameExpr = (ScriptQualifiedName)args.ChildNodes[0]; oper = ((Token)args.ChildNodes[1]).Text; if (args.ChildNodes.Count == 3) rightExpr = (ScriptExpr)args.ChildNodes[2]; Debug.Assert(oper == "=" || oper == ":=" || oper == "+=" || oper == "-=" || oper == "++" || oper == "--" || oper == ":="); switch (oper) { case "=": assignOperation = Assign; break; case ":=": assignOperation = AssignEx; break; case "++": assignOperation = PlusPlus; break; case "--": assignOperation = MinusMinus; break; case "+=": assignOperation = PlusEqual; break; case "-=": assignOperation = MinusEqual; break; default: throw new ScriptException("Assignment operator:" + oper + " is not supported"); } minus = RuntimeHost.GetBinaryOperator("-"); plus = RuntimeHost.GetBinaryOperator("+"); if (plus == null || minus == null) throw new ScriptException("RuntimeHost did not initialize property. Can't find binary operators."); }
protected Token(AstNodeArgs args) : base(args) { }
public ScriptCompoundStatement(AstNodeArgs args) : base(args) { }
}//method private AstNode CreateNode(ActionRecord reduceAction, SourceSpan sourceSpan, AstNodeList childNodes) { NonTerminal nt = reduceAction.NonTerminal; AstNode result; AstNodeArgs args = new AstNodeArgs(nt, _context, sourceSpan, childNodes); result = nt.InvokeNodeCreator(args); if (result != null) { return(result); } Type defaultNodeType = _context.Compiler.Grammar.DefaultNodeType; Type ntNodeType = nt.NodeType ?? defaultNodeType ?? typeof(AstNode); // Check if NonTerminal is a list // List nodes are produced by .Plus() or .Star() methods of BnfElement // In this case, we have a left-recursive list formation production: // ntList -> ntList + delim? + ntElem // We check if we have already created the list node for ntList (in the first child); // if yes, we use this child as a result directly, without creating new list node. // The other incoming child - the last one - is a new list member; // we simply add it to child list of the result ntList node. Optional "delim" node is simply thrown away. bool isList = nt.IsSet(TermOptions.IsList); if (isList && childNodes.Count > 1 && childNodes[0].Term == nt) { result = childNodes[0]; AstNode newChild = childNodes[childNodes.Count - 1]; newChild.Parent = result; result.ChildNodes.Add(newChild); return(result); } //Check for StarList produced by MakeStarList; in this case the production is: ntList -> Empty | Elem+ // where Elem+ is non-empty list of elements. The child list we are actually interested in is one-level lower if (nt.IsSet(TermOptions.IsStarList) && childNodes.Count == 1) { childNodes = childNodes[0].ChildNodes; } // Check for "node-bubbling" case. For identity productions like // A -> B // the child node B is usually a subclass of node A, // so child node B can be used directly in place of the A. So we simply return child node as a result. // TODO: probably need a grammar option to enable/disable this behavior explicitly if (!isList && !nt.IsSet(TermOptions.IsPunctuation) && childNodes.Count == 1) { Type childNodeType = childNodes[0].Term.NodeType ?? defaultNodeType ?? typeof(AstNode); if (childNodeType == ntNodeType || childNodeType.IsSubclassOf(ntNodeType)) { return(childNodes[0]); } } // Try using Grammar's CreateNode method result = Data.Grammar.CreateNode(_context, reduceAction, sourceSpan, childNodes); if (result == null) { //Finally create node directly. For perf reasons we try using "new" for AstNode type (faster), and // activator for all custom types (slower) if (ntNodeType == typeof(AstNode)) { result = new AstNode(args); } else #if PocketPC || SILVERLIGHT { ConstructorInfo ctor = ntNodeType.GetConstructor(new Type[] { typeof(AstNodeArgs) }); if (ctor == null) { throw new Exception("Failed to located constructor: " + ntNodeType.ToString() + "(AstNodeArgs args)"); } result = (AstNode)ctor.Invoke(new object[] { args }); } #else { result = (AstNode)Activator.CreateInstance(ntNodeType, args); } #endif } if (result != null) { nt.OnNodeCreated(result); } return(result); }
public ScriptNewArrStmt(AstNodeArgs args) : base(args) { constrExpr = ChildNodes[1] as ScriptTypeExpr; arrRank = ChildNodes[2] as ScriptArrayResolution; }
public ScriptStatement(AstNodeArgs args) : base(args) { }
public ScriptFuncContractPost(AstNodeArgs args) : base(args) { list = ChildNodes[1] as ScriptExprList; }
public ScriptExprList(AstNodeArgs args) : base(args) { exprList = (ChildNodes[0] is ScriptExpr) ? ChildNodes : ChildNodes[0].ChildNodes; }
private AstNode CreateNode(ActionRecord reduceAction, SourceSpan sourceSpan, AstNodeList childNodes) { NonTerminal nt = reduceAction.NonTerminal; AstNode result; AstNodeArgs args = new AstNodeArgs(nt, _context, sourceSpan, childNodes); result = nt.InvokeNodeCreator(args); if (result != null) return result; Type defaultNodeType = _context.Compiler.Grammar.DefaultNodeType; Type ntNodeType = nt.NodeType ?? defaultNodeType ?? typeof(AstNode); // Check if NonTerminal is a list // List nodes are produced by .Plus() or .Star() methods of BnfElement // In this case, we have a left-recursive list formation production: // ntList -> ntList + delim? + ntElem // We check if we have already created the list node for ntList (in the first child); // if yes, we use this child as a result directly, without creating new list node. // The other incoming child - the last one - is a new list member; // we simply add it to child list of the result ntList node. Optional "delim" node is simply thrown away. bool isList = nt.IsSet(TermOptions.IsList); if (isList && childNodes.Count > 1 && childNodes[0].Term == nt) { result = childNodes[0]; AstNode newChild = childNodes[childNodes.Count - 1]; newChild.Parent = result; result.ChildNodes.Add(newChild); return result; } //Check for StarList produced by MakeStarList; in this case the production is: ntList -> Empty | Elem+ // where Elem+ is non-empty list of elements. The child list we are actually interested in is one-level lower if (nt.IsSet(TermOptions.IsStarList) && childNodes.Count == 1) { childNodes = childNodes[0].ChildNodes; } // Check for "node-bubbling" case. For identity productions like // A -> B // the child node B is usually a subclass of node A, // so child node B can be used directly in place of the A. So we simply return child node as a result. // TODO: probably need a grammar option to enable/disable this behavior explicitly if (!isList && !nt.IsSet(TermOptions.IsPunctuation) && childNodes.Count == 1) { Type childNodeType = childNodes[0].Term.NodeType ?? defaultNodeType ?? typeof(AstNode); if (childNodeType == ntNodeType || childNodeType.IsSubclassOf(ntNodeType)) return childNodes[0]; } // Try using Grammar's CreateNode method result = Data.Grammar.CreateNode(_context, reduceAction, sourceSpan, childNodes); if (result == null) { //Finally create node directly. For perf reasons we try using "new" for AstNode type (faster), and // activator for all custom types (slower) if (ntNodeType == typeof(AstNode)) result = new AstNode(args); else #if PocketPC || SILVERLIGHT { ConstructorInfo ctor = ntNodeType.GetConstructor(new Type[] { typeof(AstNodeArgs) }); if (ctor == null) throw new Exception("Failed to located constructor: " + ntNodeType.ToString() + "(AstNodeArgs args)"); result = (AstNode)ctor.Invoke(new object[] { args }); } #else { result = (AstNode)Activator.CreateInstance(ntNodeType, args); } #endif } if (result != null) nt.OnNodeCreated(result); return result; }