RVList <LNode> ApplyMacrosToList(RVList <LNode> list, int maxExpansions) { RVList <LNode> results = list; LNode result = null; int i, c; // Share as much of the original RVList as is left unchanged for (i = 0, c = list.Count; i < c; i++) { if ((result = ApplyMacros(list[i], maxExpansions)) != null || (result = list[i]).Calls(S.Splice)) { results = list.WithoutLast(c - i); Add(ref results, result); break; } } // Prepare a modified list from now on for (i++; i < c; i++) { LNode input = list[i]; if ((result = ApplyMacros(input, maxExpansions)) != null) { Add(ref results, result); } else { results.Add(input); } } return(results); }
public RVList<LNode> ExprList(ref TokenType endMarker, RVList<LNode> list = default(RVList<LNode>)) { TT la0; LNode e = default(LNode); Token end = default(Token); // line 57 if ((LT0.Value is string)) { endMarker = TT.EOF; } // Line 1: ( / TopExpr) switch ((TT) LA0) { case EOF: case TT.Comma: case TT.Dedent: case TT.RBrace: case TT.RBrack: case TT.RParen: case TT.Semicolon: { } break; default: e = TopExpr(); break; } // Line 59: ((TT.Comma|TT.Semicolon) ( / TopExpr))* for (;;) { la0 = (TT) LA0; if (la0 == TT.Comma || la0 == TT.Semicolon) { end = MatchAny(); list.Add(e ?? MissingExpr()); CheckEndMarker(ref endMarker, ref end); // Line 62: ( / TopExpr) switch ((TT) LA0) { case EOF: case TT.Comma: case TT.Dedent: case TT.RBrace: case TT.RBrack: case TT.RParen: case TT.Semicolon: // line 62 e = null; break; default: e = TopExpr(); break; } } else break; } if ((e != null || end.Type() == TT.Comma)) { list.Add(e ?? MissingExpr()); } return list; }
/// <summary>Converts this list of <see cref="Token"/> to a list of <see cref="LNode"/>.</summary> /// <remarks>See <see cref="Token.ToLNode(ISourceFile)"/> for more information.</remarks> public RVList <LNode> ToLNodes() { RVList <LNode> list = RVList <LNode> .Empty; foreach (var item in (DList <Token>) this) { list.Add(item.ToLNode(File)); } return(list); }
public void GenerateOutput(ref RVList <LNode> list) { bool isAbstract = _typeAttrs.Any(a => a.IsIdNamed(S.Abstract)); var baseParts = new List <AdtParam>(); for (var type = ParentType; type != null; type = type.ParentType) { baseParts.InsertRange(0, type.Parts); } var allParts = baseParts.Concat(Parts); var initialization = Parts.Select(p => LNode.Call(CodeSymbols.Assign, LNode.List(LNode.Call(CodeSymbols.Dot, LNode.List(LNode.Id(CodeSymbols.This), p.NameId)), p.NameId)).SetStyle(NodeStyle.Operator)).ToList(); if (baseParts.Count > 0) { initialization.Insert(0, F.Call(S.Base, baseParts.Select(p => p.NameId))); } var args = new RVList <LNode>(allParts.Select(p => p.OriginalDecl)); if (!_constructorAttrs.Any(a => a.IsIdNamed(S.Public))) { _constructorAttrs.Add(F.Id(S.Public)); } LNode constructor = LNode.Call(new RVList <LNode>(_constructorAttrs), CodeSymbols.Cons, LNode.List(LNode.Missing, _typeNameStem, LNode.Call(CodeSymbols.AltList, new RVList <LNode>(args)), LNode.Call(CodeSymbols.Braces, new RVList <LNode>().AddRange(initialization).AddRange(_extraConstrLogic)).SetStyle(NodeStyle.Statement))); var outBody = new RVList <LNode>(); outBody.Add(constructor); outBody.AddRange(Parts.Select(p => p.GetFieldDecl())); outBody.AddRange(baseParts.Select(p => GetWithFn(p, isAbstract, S.Override, allParts))); outBody.AddRange(Parts.Select(p => GetWithFn(p, isAbstract, _children.Count > 0 ? S.Virtual : null, allParts))); outBody.AddRange(Parts.WithIndexes().Where(kvp => kvp.Value.NameId.Name.Name != "Item" + (baseParts.Count + kvp.Key + 1)).Select(kvp => kvp.Value.GetItemDecl(baseParts.Count + kvp.Key + 1))); outBody.AddRange(_classBody); list.Add(LNode.Call(new RVList <LNode>(_typeAttrs), CodeSymbols.Class, LNode.List(TypeName, LNode.Call(CodeSymbols.AltList, new RVList <LNode>(BaseTypes)), LNode.Call(CodeSymbols.Braces, new RVList <LNode>(outBody)).SetStyle(NodeStyle.Statement)))); if (_genericArgs.Count > 0 && Parts.Count > 0) { var argNames = allParts.Select(p => p.NameId); list.Add(LNode.Call(new RVList <LNode>().AddRange(_typeAttrs).Add(LNode.Id(CodeSymbols.Static)).Add(LNode.Id(LNode.List(LNode.Id(CodeSymbols.TriviaWordAttribute)), CodeSymbols.Partial)), CodeSymbols.Class, LNode.List(_typeNameStem, LNode.Call(CodeSymbols.AltList), LNode.Call(CodeSymbols.Braces, LNode.List(LNode.Call(LNode.List(LNode.Id(CodeSymbols.Public), LNode.Id(CodeSymbols.Static)), CodeSymbols.Fn, LNode.List(TypeName, LNode.Call(CodeSymbols.Of, new RVList <LNode>().Add(LNode.Id((Symbol)"New")).AddRange(_genericArgs)), LNode.Call(CodeSymbols.AltList, new RVList <LNode>(args)), LNode.Call(CodeSymbols.Braces, LNode.List(LNode.Call(CodeSymbols.Return, LNode.List(LNode.Call(CodeSymbols.New, LNode.List(LNode.Call(TypeName, new RVList <LNode>(argNames)))))))).SetStyle(NodeStyle.Statement))))).SetStyle(NodeStyle.Statement)))); } foreach (var child in _children) { child.GenerateOutput(ref list); } }
public LNode GetWithFn(AdtParam part, bool isAbstract, Symbol virtualOverride, IEnumerable <AdtParam> allParts) { LNode genericClassName = this.TypeName; int totalParts = allParts.Count(); var withField = F.Id("With" + part.NameId.Name); var args = LNode.List(); foreach (AdtParam otherPart in allParts) { if (part == otherPart) { args.Add(F.Id("newValue")); } else { args.Add(otherPart.NameId); } } var attrs = new RVList <LNode>(F.Id(S.Public)); if (isAbstract) { attrs.Add(F.Id(S.Abstract)); } if (virtualOverride != null && (!isAbstract || virtualOverride == S.Override)) { attrs.Add(F.Id(virtualOverride)); } LNode method; LNode type = part.Type; LNode retType = part.ContainingType.TypeName; if (isAbstract) { method = LNode.Call(new RVList <LNode>(attrs), CodeSymbols.Fn, LNode.List(retType, withField, LNode.Call(CodeSymbols.AltList, LNode.List(LNode.Call(new RVList <LNode>(part.OriginalDecl.Attrs), CodeSymbols.Var, LNode.List(type, LNode.Id((Symbol)"newValue"))))))); } else { method = LNode.Call(new RVList <LNode>(attrs), CodeSymbols.Fn, LNode.List(retType, withField, LNode.Call(CodeSymbols.AltList, LNode.List(LNode.Call(new RVList <LNode>(part.OriginalDecl.Attrs), CodeSymbols.Var, LNode.List(type, LNode.Id((Symbol)"newValue"))))), LNode.Call(CodeSymbols.Braces, LNode.List(LNode.Call(CodeSymbols.Return, LNode.List(LNode.Call(CodeSymbols.New, LNode.List(LNode.Call(genericClassName, new RVList <LNode>(args)))))))).SetStyle(NodeStyle.Statement))); } return(method); }
private void Add(ref RVList <LNode> results, LNode result) { if (result.Calls(S.Splice)) { results.AddRange(result.Args); } else { results.Add(result); } }
public static RVList <LNode> WithSpliced(this RVList <LNode> list, LNode node, Symbol listName) { if (node.Calls(listName)) { return(list.AddRange(node.Args)); } else { return(list.Add(node)); } }
/// <summary>Creates the default method definition to wrap around the body /// of the rule, which has already been generated. Returns <see cref="Basis"/> /// with the specified new method body. If Basis is null, a simple default /// method signature is used, e.g. <c>public void R() {...}</c> where R is /// the rule name.</summary> /// <param name="methodBody">The parsing code that was generated for this rule.</param> /// <returns>A method.</returns> public LNode CreateMethod(RVList <LNode> methodBody) { LNode method = GetMethodSignature(); var parts = method.Args.ToRWList(); if (parts[0].IsIdNamed(S.Missing)) { parts[0] = F.Id(Name); } Debug.Assert(parts.Count == 3); if (IsRecognizer) { methodBody.Add(F.Call(S.Return, F.True)); } parts.Add(F.Braces(methodBody)); return(method.WithArgs(parts.ToRVList())); }
public AltType(RVList<LNode> typeAttrs, LNode typeName, RVList<LNode> baseTypes, AltType parentType) { _typeAttrs = typeAttrs; TypeName = typeName; BaseTypes = baseTypes; ParentType = parentType; if (ParentType != null) BaseTypes.Add(ParentType.TypeName); { LNode stem; RVList<LNode> a = default(RVList<LNode>); if (TypeName.CallsMin(CodeSymbols.Of, 1) && (stem = TypeName.Args[0]) != null && (a = new RVList<LNode>(TypeName.Args.Slice(1))).IsEmpty | true || (stem = TypeName) != null) { _typeNameStem = stem; _genericArgs = a; } } }
public AltType(RVList <LNode> typeAttrs, LNode typeName, RVList <LNode> baseTypes, AltType parentType) { _typeAttrs = typeAttrs; TypeName = typeName; BaseTypes = baseTypes; ParentType = parentType; if (ParentType != null) { BaseTypes.Add(ParentType.TypeName); } { LNode stem; RVList <LNode> a = default(RVList <LNode>); if (TypeName.CallsMin(CodeSymbols.Of, 1) && (stem = TypeName.Args[0]) != null && (a = new RVList <LNode>(TypeName.Args.Slice(1))).IsEmpty | true || (stem = TypeName) != null) { _typeNameStem = stem; _genericArgs = a; } } }
public void ScanClassBody(RVList <LNode> body) { foreach (var stmt in body) { int i; { LNode altName; RVList <LNode> attrs, childBody = default(RVList <LNode>), parts, rest; if ((attrs = stmt.Attrs).IsEmpty | true && stmt.Calls(CodeSymbols.Fn, 3) && stmt.Args[0].IsIdNamed((Symbol)"alt") && (altName = stmt.Args[1]) != null && stmt.Args[2].Calls(CodeSymbols.AltList) && (parts = stmt.Args[2].Args).IsEmpty | true || (attrs = stmt.Attrs).IsEmpty | true && stmt.Calls(CodeSymbols.Fn, 4) && stmt.Args[0].IsIdNamed((Symbol)"alt") && (altName = stmt.Args[1]) != null && stmt.Args[2].Calls(CodeSymbols.AltList) && (parts = stmt.Args[2].Args).IsEmpty | true && stmt.Args[3].Calls(CodeSymbols.Braces) && (childBody = stmt.Args[3].Args).IsEmpty | true) { LNode genericAltName = altName; if (altName.CallsMin(CodeSymbols.Of, 1)) { } else if (_genericArgs.Count > 0) { genericAltName = LNode.Call(CodeSymbols.Of, new RVList <LNode>().Add(altName).AddRange(_genericArgs)); } var child = new AltType(attrs, genericAltName, LNode.List(), this); child.AddParts(parts); child.ScanClassBody(childBody); _children.Add(child); } else if ((attrs = stmt.Attrs).IsEmpty | true && (i = attrs.IndexWhere(a => a.IsIdNamed(__alt))) > -1 && stmt.CallsMin(CodeSymbols.Cons, 3) && stmt.Args[1].IsIdNamed((Symbol)"#this") && stmt.Args[2].Calls(CodeSymbols.AltList) && (rest = new RVList <LNode>(stmt.Args.Slice(3))).IsEmpty | true && rest.Count <= 1) { parts = stmt.Args[2].Args; attrs.RemoveAt(i); _constructorAttrs.AddRange(attrs); if (rest.Count > 0 && rest[0].Calls(S.Braces)) { _extraConstrLogic.AddRange(rest[0].Args); } AddParts(parts); } else { _classBody.Add(stmt); } } } }
public static LNode ForwardMethod(LNode fn, IMessageSink sink) { LNode args, fwd, body; if (fn.ArgCount != 4 || !(fwd = fn.Args[3]).Calls(S.Forward, 1) || !(args = fn.Args[2]).Calls(S.List)) { return(null); } RVList <LNode> formalArgs = args.Args; RVList <LNode> argList = RVList <LNode> .Empty; foreach (var formalArg in formalArgs) { if (!formalArg.Calls(S.Var, 2)) { return(Reject(sink, formalArg, "'==>' expected a variable declaration here")); } LNode argName = formalArg.Args[1]; if (argName.Calls(S.Assign, 2)) { argName = argName.Args[0]; } LNode @ref = formalArg.AttrNamed(S.Ref) ?? formalArg.AttrNamed(S.Out); if (@ref != null) { argName = argName.PlusAttr(@ref); } argList.Add(argName); } LNode target = GetForwardingTarget(fwd, fn.Args[1]); LNode call = F.Call(target, argList); bool isVoidFn = fn.Args[0].IsIdNamed(S.Void); body = F.Braces(isVoidFn ? call : F.Call(S.Return, call)); return(fn.WithArgChanged(3, body)); }
RVList <LNode> ApplyMacrosToList(RVList <LNode> list, int maxExpansions, bool areAttributes) { RVList <LNode> results = list; LNode result = null; int i, count; // Share as much of the original RVList as is left unchanged for (i = 0, count = list.Count; i < count; i++) { _s.StartNextListItem(list, i, areAttributes); LNode input = list[i]; result = ApplyMacros(input, maxExpansions, false); if (result != null || (result = input).Calls(S.Splice)) { results = list.WithoutLast(count - i); Add(ref results, result); break; } } // Prepare a modified list from now on for (i++; i < count && !_s.DropRemainingNodes; i++) { _s.StartNextListItem(list, i, areAttributes); LNode input = list[i]; result = ApplyMacros(input, maxExpansions, false); if (result != null || (result = input).Calls(S.Splice)) { Add(ref results, result); } else { results.Add(input); } } _s.DropRemainingNodes = false; _s.IsAttribute = false; return(results); }
public static LNode QuoteOne(LNode node, bool substitutions) { if (node.Equals(LNode.InParensTrivia)) { return(LNode_InParensTrivia); } if (node.Equals(LNode.Missing)) { return(LNode_Missing); } RVList <LNode> creationArgs = new RVList <LNode>(); // Translate attributes (if any) var attrList = MaybeQuoteList(node.Attrs, substitutions); if (attrList != null) { creationArgs.Add(attrList); } LNode result; switch (node.Kind) { case LNodeKind.Literal: // => F.Literal(value) creationArgs.Add(node.WithoutAttrs()); result = F.Call(LNode_Literal, creationArgs); break; case LNodeKind.Id: // => F.Id(string), F.Id(CodeSymbols.Name) creationArgs.Add(QuoteSymbol(node.Name)); result = F.Call(LNode_Id, creationArgs); break; default: // NodeKind.Call => F.Dot(...), F.Of(...), F.Call(...), F.Braces(...) if (substitutions && node.Calls(S.Substitute, 1)) { result = node.Args[0]; if (attrList != null) { if (result.IsCall) { result = LNode.InParens(result); } result = F.Call(F.Dot(result, Id_PlusAttrs), attrList); } } /*else if (node.Calls(S.Braces)) // F.Braces(...) * result = F.Call(LNode_Braces, node.Args.SmartSelect(arg => QuoteOne(arg, substitutions))); * else if (node.Calls(S.Dot) && node.ArgCount.IsInRange(1, 2)) * result = F.Call(LNode_Dot, node.Args.SmartSelect(arg => QuoteOne(arg, substitutions))); * else if (node.Calls(S.Of)) * result = F.Call(LNode_Of, node.Args.SmartSelect(arg => QuoteOne(arg, substitutions)));*/ else // General case: F.Call(<Target>, <Args>) { if (node.Target.IsId) { creationArgs.Add(QuoteSymbol(node.Name)); } else { creationArgs.Add(QuoteOne(node.Target, substitutions)); } var argList = MaybeQuoteList(node.Args, substitutions); if (argList != null) { creationArgs.Add(argList); } result = F.Call(LNode_Call, creationArgs); } // Note: don't preserve prefix notation because if $op is +, // we want $op(x, y) to generate code for x + y (there is no // way to express this with infix notation.) if (node.BaseStyle != NodeStyle.Default && node.BaseStyle != NodeStyle.PrefixNotation) { result = F.Call(F.Dot(result, F.Id("SetStyle")), F.Dot(F.Id("NodeStyle"), F.Id(node.BaseStyle.ToString()))); } break; } return(result); }
public static LNode QuoteOne(LNode node, bool substitutions = true) { LNode result; switch (node.Kind) { case LNodeKind.Literal: // => F.Literal(value) result = F.Call(F_Literal, node.WithoutAttrs()); break; case LNodeKind.Id: // => F.Id(string), F.Id(CodeSymbols.Name) result = F.Call(F_Id, QuoteIdHelper(node.Name)); break; default: // NodeKind.Call => F.Dot(...), F.Of(...), F.Call(...), F.Braces(...) if (substitutions && node.Calls(S.Substitute, 1)) { result = node.Args[0]; } else if (node.Calls(S.Braces)) // F.Braces(...) { result = F.Call(F_Braces, node.Args.SmartSelect(arg => QuoteOne(arg))); } else if (node.Calls(S.Dot) && node.ArgCount.IsInRange(1, 2)) { result = F.Call(F_Dot, node.Args.SmartSelect(arg => QuoteOne(arg))); } else if (node.Calls(S.Of)) { result = F.Call(F_Of, node.Args.SmartSelect(arg => QuoteOne(arg))); } else // General case: F.Call(<Target>, <Args>) { LNode outTarget; if (node.Target.IsId) { outTarget = QuoteIdHelper(node.Name); } else { outTarget = QuoteOne(node.Target); } RVList <LNode> outArgs = new RVList <LNode>(outTarget); foreach (LNode arg in node.Args) { outArgs.Add(QuoteOne(arg)); } result = F.Call(F_Call, outArgs); } break; } // Translate attributes too (if any) RWList <LNode> outAttrs = null; foreach (LNode attr in node.Attrs) { if (!attr.IsTrivia) { outAttrs = outAttrs ?? new RWList <LNode>(); outAttrs.Add(QuoteOne(attr)); } } if (outAttrs != null) { result = F.Call(F.Dot(result, Id_WithAttrs), outAttrs.ToRVList()); } return(result); }
LNode TryStmt(int startIndex) { TokenType la0, la1; Skip(); var header = Stmt(); #line 1641 "EcsParserGrammar.les" var parts = new RVList<LNode> { header }; LNode expr; #line 1642 "EcsParserGrammar.les" LNode handler; #line default // Line 1644: greedy(TT.@catch (TT.LParen TT.RParen Stmt / Stmt))* for (;;) { la0 = LA0; if (la0 == TT.@catch) { la1 = LA(1); if (IfStmt_set0.Contains((int) la1)) { var kw = MatchAny(); // Line 1645: (TT.LParen TT.RParen Stmt / Stmt) la0 = LA0; if (la0 == TT.LParen) { var p = MatchAny(); Match((int) TT.RParen); handler = Stmt(); #line 1645 "EcsParserGrammar.les" expr = SingleExprInside(p, "catch (...)", null, true); #line default } else { handler = Stmt(); #line 1646 "EcsParserGrammar.les" expr = F.Id(S.Missing, kw.EndIndex, kw.EndIndex); #line default } #line 1648 "EcsParserGrammar.les" parts.Add(F.Call(S.Catch, expr, handler, kw.StartIndex, handler.Range.EndIndex)); #line default } else break; } else break; } // Line 1651: greedy(TT.@finally Stmt)* for (;;) { la0 = LA0; if (la0 == TT.@finally) { la1 = LA(1); if (IfStmt_set0.Contains((int) la1)) { var kw = MatchAny(); handler = Stmt(); #line 1652 "EcsParserGrammar.les" parts.Add(F.Call(S.Finally, handler, kw.StartIndex, handler.Range.EndIndex)); #line default } else break; } else break; } #line 1655 "EcsParserGrammar.les" var result = F.Call(S.Try, parts, startIndex, parts.Last.Range.EndIndex); if (parts.Count == 1) { Error(result, "'try': At least one 'catch' or 'finally' clause is required"); } #line 1659 "EcsParserGrammar.les" return result; #line default }
LNode EventDecl(int startIndex, RVList<LNode> attrs) { TokenType la0; #line 1413 "EcsParserGrammar.les" LNode r; #line default Skip(); var type = DataType(); var name = ComplexNameDecl(); // Line 1415: (default (TT.Comma ComplexNameDecl)* TT.Semicolon | BracedBlock) do { la0 = LA0; if (la0 == TT.Comma || la0 == TT.Semicolon) goto match1; else if (la0 == TT.LBrace) { var body = BracedBlock(S.Fn); #line 1421 "EcsParserGrammar.les" r = F.Call(S.Event, type, name, body, startIndex, body.Range.EndIndex); #line default } else goto match1; break; match1: { #line 1416 "EcsParserGrammar.les" var parts = new RVList<LNode>(type, name); #line default // Line 1417: (TT.Comma ComplexNameDecl)* for (;;) { la0 = LA0; if (la0 == TT.Comma) { Skip(); parts.Add(ComplexNameDecl()); } else break; } var end = Match((int) TT.Semicolon); #line 1419 "EcsParserGrammar.les" r = F.Call(S.Event, parts, startIndex, end.EndIndex); #line default } } while (false); #line 1423 "EcsParserGrammar.les" return r.WithAttrs(attrs); #line default }
LNode MethodOrPropertyOrVar(int startIndex, RVList<LNode> attrs) { TokenType la0; #line 1243 "EcsParserGrammar.les" LNode r; #line default var type = DataType(); // Line 1247: (&(IdAtom (TT.Comma|TT.Semicolon|TT.Set)) NameAndMaybeInit (TT.Comma NameAndMaybeInit)* TT.Semicolon / ComplexNameDecl (MethodArgListAndBody | WhereClausesOpt MethodBodyOrForward)) if (Try_MethodOrPropertyOrVar_Test0(0)) { MaybeRecognizeVarAsKeyword(ref type); var parts = new RVList<LNode> { type }; parts.Add(NameAndMaybeInit(IsArrayType(type))); // Line 1251: (TT.Comma NameAndMaybeInit)* for (;;) { la0 = LA0; if (la0 == TT.Comma) { Skip(); parts.Add(NameAndMaybeInit(IsArrayType(type))); } else break; } var end = Match((int) TT.Semicolon); #line 1252 "EcsParserGrammar.les" r = F.Call(S.Var, parts, type.Range.StartIndex, end.EndIndex).PlusAttrs(attrs); #line default } else { var name = ComplexNameDecl(); // Line 1255: (MethodArgListAndBody | WhereClausesOpt MethodBodyOrForward) switch (LA0) { case TT.LParen: r = MethodArgListAndBody(startIndex, attrs, S.Fn, type, name); break; case TT.At: case TT.ContextualKeyword: case TT.Forward: case TT.LambdaArrow: case TT.LBrace: { WhereClausesOpt(ref name); var body = MethodBodyOrForward(); #line 1259 "EcsParserGrammar.les" r = F.Call(S.Property, type, name, body, type.Range.StartIndex, body.Range.EndIndex).PlusAttrs(attrs); #line default } break; default: { ScanToEndOfStmt(); Error("Syntax error in method, property, or variable declaration"); r = F._Missing.PlusAttrs(attrs); } break; } } #line 1265 "EcsParserGrammar.les" return r; #line default }
LNode BaseListOpt() { TokenType la0; // Line 1137: (TT.Colon DataType (TT.Comma DataType)* | ) la0 = LA0; if (la0 == TT.Colon) { #line 1137 "EcsParserGrammar.les" var bases = new RVList<LNode>(); #line default Skip(); bases.Add(DataType()); // Line 1139: (TT.Comma DataType)* for (;;) { la0 = LA0; if (la0 == TT.Comma) { Skip(); bases.Add(DataType()); } else break; } #line 1140 "EcsParserGrammar.les" return F.List(bases); #line default } else { #line 1141 "EcsParserGrammar.les" return F.List(); #line default } }
LNode InParens_ExprOrTuple(bool allowUnassignedVarDecl, int startIndex, int endIndex) { TokenType la0, la1; // Line 773: (ExprStart (TT.Comma (~(EOF))* => (TT.Comma ExprStart | TT.Comma)*)? | ) la0 = LA0; if (InParens_ExprOrTuple_set0.Contains((int) la0)) { var e = ExprStart(allowUnassignedVarDecl); // Line 774: (TT.Comma (~(EOF))* => (TT.Comma ExprStart | TT.Comma)*)? la0 = LA0; if (la0 == TT.Comma) { #line 775 "EcsParserGrammar.les" var list = new RVList<LNode> { e }; #line default // Line 776: (TT.Comma ExprStart | TT.Comma)* for (;;) { la0 = LA0; if (la0 == TT.Comma) { la1 = LA(1); if (InParens_ExprOrTuple_set0.Contains((int) la1)) { Skip(); list.Add(ExprStart(allowUnassignedVarDecl)); } else Skip(); } else break; } #line 779 "EcsParserGrammar.les" return F.Tuple(list, startIndex, endIndex); #line default } #line 781 "EcsParserGrammar.les" return F.InParens(e, startIndex, endIndex); #line default } else { #line 783 "EcsParserGrammar.les" return F.Tuple(RVList<LNode>.Empty, startIndex, endIndex); #line default } Match((int) EOF); }
LNode FinishPrimaryExpr(LNode e) { TT la0; RVList<LNode> list = default(RVList<LNode>); // Line 145: ( TT.LParen ExprList TT.RParen | TT.Not (TT.LParen ExprList TT.RParen / Expr) | TT.LBrack ExprList TT.RBrack ) la0 = (TT) LA0; if (la0 == TT.LParen) { // line 145 var endMarker = default(TokenType); Skip(); list = ExprList(ref endMarker); var c = Match((int) TT.RParen); // line 148 e = MarkCall(F.Call(e, list, e.Range.StartIndex, c.EndIndex)); if ((endMarker == TT.Semicolon)) { e.Style = NodeStyle.Statement | NodeStyle.Alternate; } } else if (la0 == TT.Not) { Skip(); // line 153 var args = new RVList<LNode> { e }; int endIndex; // Line 154: (TT.LParen ExprList TT.RParen / Expr) la0 = (TT) LA0; if (la0 == TT.LParen) { Skip(); args = ExprList(args); var c = Match((int) TT.RParen); // line 154 endIndex = c.EndIndex; } else { var T = Expr(P.Primary); // line 155 args.Add(T); endIndex = T.Range.EndIndex; } // line 157 e = F.Call(S.Of, args, e.Range.StartIndex, endIndex).SetStyle(NodeStyle.Operator); } else { // line 159 var args = new RVList<LNode> { e }; Match((int) TT.LBrack); args = ExprList(args); var c = Match((int) TT.RBrack); // line 161 e = F.Call(S.Bracks, args, e.Range.StartIndex, c.EndIndex).SetStyle(NodeStyle.Operator); } // line 163 return e; }
public LNode GetWithFn(AdtParam part, bool isAbstract, Symbol virtualOverride, IEnumerable<AdtParam> allParts) { LNode genericClassName = this.TypeName; int totalParts = allParts.Count(); var withField = F.Id("With" + part.NameId.Name); var args = LNode.List(); foreach (AdtParam otherPart in allParts) { if (part == otherPart) args.Add(F.Id("newValue")); else args.Add(otherPart.NameId); } var attrs = new RVList<LNode>(F.Id(S.Public)); if (isAbstract) attrs.Add(F.Id(S.Abstract)); if (virtualOverride != null && (!isAbstract || virtualOverride == S.Override)) attrs.Add(F.Id(virtualOverride)); LNode method; LNode type = part.Type; LNode retType = part.ContainingType.TypeName; if (isAbstract) { method = LNode.Call(new RVList<LNode>(attrs), CodeSymbols.Fn, LNode.List(retType, withField, LNode.Call(CodeSymbols.AltList, LNode.List(LNode.Call(new RVList<LNode>(part.OriginalDecl.Attrs), CodeSymbols.Var, LNode.List(type, LNode.Id((Symbol) "newValue"))))))); } else { method = LNode.Call(new RVList<LNode>(attrs), CodeSymbols.Fn, LNode.List(retType, withField, LNode.Call(CodeSymbols.AltList, LNode.List(LNode.Call(new RVList<LNode>(part.OriginalDecl.Attrs), CodeSymbols.Var, LNode.List(type, LNode.Id((Symbol) "newValue"))))), LNode.Call(CodeSymbols.Braces, LNode.List(LNode.Call(CodeSymbols.Return, LNode.List(LNode.Call(CodeSymbols.New, LNode.List(LNode.Call(genericClassName, new RVList<LNode>(args)))))))).SetStyle(NodeStyle.Statement))); } return method; }
public void GenerateOutput(ref RVList<LNode> list) { bool isAbstract = _typeAttrs.Any(a => a.IsIdNamed(S.Abstract)); var baseParts = new List<AdtParam>(); for (var type = ParentType; type != null; type = type.ParentType) baseParts.InsertRange(0, type.Parts); var allParts = baseParts.Concat(Parts); var initialization = Parts.Select(p => LNode.Call(CodeSymbols.Assign, LNode.List(LNode.Call(CodeSymbols.Dot, LNode.List(LNode.Id(CodeSymbols.This), p.NameId)), p.NameId)).SetStyle(NodeStyle.Operator)).ToList(); if (baseParts.Count > 0) initialization.Insert(0, F.Call(S.Base, baseParts.Select(p => p.NameId))); var args = new RVList<LNode>(allParts.Select(p => p.OriginalDecl)); if (!_constructorAttrs.Any(a => a.IsIdNamed(S.Public))) _constructorAttrs.Add(F.Id(S.Public)); LNode constructor = LNode.Call(new RVList<LNode>(_constructorAttrs), CodeSymbols.Cons, LNode.List(LNode.Missing, _typeNameStem, LNode.Call(CodeSymbols.AltList, new RVList<LNode>(args)), LNode.Call(CodeSymbols.Braces, new RVList<LNode>().AddRange(initialization).AddRange(_extraConstrLogic)).SetStyle(NodeStyle.Statement))); var outBody = new RVList<LNode>(); outBody.Add(constructor); outBody.AddRange(Parts.Select(p => p.GetFieldDecl())); outBody.AddRange(baseParts.Select(p => GetWithFn(p, isAbstract, S.Override, allParts))); outBody.AddRange(Parts.Select(p => GetWithFn(p, isAbstract, _children.Count > 0 ? S.Virtual : null, allParts))); outBody.AddRange(Parts.WithIndexes().Where(kvp => kvp.Value.NameId.Name.Name != "Item" + (baseParts.Count + kvp.Key + 1)).Select(kvp => kvp.Value.GetItemDecl(baseParts.Count + kvp.Key + 1))); outBody.AddRange(_classBody); list.Add(LNode.Call(new RVList<LNode>(_typeAttrs), CodeSymbols.Class, LNode.List(TypeName, LNode.Call(CodeSymbols.AltList, new RVList<LNode>(BaseTypes)), LNode.Call(CodeSymbols.Braces, new RVList<LNode>(outBody)).SetStyle(NodeStyle.Statement)))); if (_genericArgs.Count > 0 && Parts.Count > 0) { var argNames = allParts.Select(p => p.NameId); list.Add(LNode.Call(new RVList<LNode>().AddRange(_typeAttrs).Add(LNode.Id(CodeSymbols.Static)).Add(LNode.Id(LNode.List(LNode.Id(CodeSymbols.TriviaWordAttribute)), CodeSymbols.Partial)), CodeSymbols.Class, LNode.List(_typeNameStem, LNode.Call(CodeSymbols.AltList), LNode.Call(CodeSymbols.Braces, LNode.List(LNode.Call(LNode.List(LNode.Id(CodeSymbols.Public), LNode.Id(CodeSymbols.Static)), CodeSymbols.Fn, LNode.List(TypeName, LNode.Call(CodeSymbols.Of, new RVList<LNode>().Add(LNode.Id((Symbol) "New")).AddRange(_genericArgs)), LNode.Call(CodeSymbols.AltList, new RVList<LNode>(args)), LNode.Call(CodeSymbols.Braces, LNode.List(LNode.Call(CodeSymbols.Return, LNode.List(LNode.Call(CodeSymbols.New, LNode.List(LNode.Call(TypeName, new RVList<LNode>(argNames)))))))).SetStyle(NodeStyle.Statement))))).SetStyle(NodeStyle.Statement)))); } foreach (var child in _children) child.GenerateOutput(ref list); }
/// <summary>Creates the default method definition to wrap around the body /// of the rule, which has already been generated. Returns <see cref="Basis"/> /// with the specified new method body. If Basis is null, a simple default /// method signature is used, e.g. <c>public void R() {...}</c> where R is /// the rule name.</summary> /// <param name="methodBody">The parsing code that was generated for this rule.</param> /// <returns>A method.</returns> public LNode CreateMethod(RVList<LNode> methodBody) { LNode method = GetMethodSignature(); var parts = method.Args.ToRWList(); if (parts[0].IsIdNamed(S.Missing)) parts[0] = F.Id(Name); Debug.Assert(parts.Count == 3); if (IsRecognizer) methodBody.Add(F.Call(S.Return, F.True)); parts.Add(F.Braces(methodBody)); return method.WithArgs(parts.ToRVList()); }
public static LNode SetOrCreateMember(LNode fn, IMessageSink sink) { // Expecting #fn(Type, Name, #(args), {body}) if (fn.ArgCount < 3 || !fn.Args[2].Calls(S.List)) { return(null); } var args = fn.Args[2].Args; LNode body = null; RVList <LNode> createStmts = RVList <LNode> .Empty; RVList <LNode> setStmts = RVList <LNode> .Empty; for (int i = 0; i < args.Count; i++) { var arg = args[i]; Symbol a = S.Property; Symbol fieldName = null; Symbol paramName = null; LNode plainArg = null; LNode createStmt = null; if (arg.Calls(S.Property)) { // #property(Type, Name<T>, {...}) var name = arg.Args[1]; fieldName = Ecs.EcsNodePrinter.KeyNameComponentOf(name); paramName = ChooseArgName(fieldName); plainArg = F.Var(arg.Args[0], paramName); createStmt = arg; } else { LNode type, defaultValue; if (IsVar(arg, out type, out paramName, out defaultValue)) { int a_i = 0; foreach (var attr in arg.Attrs) { if (attr.IsId) { a = attr.Name; if (a == _set || a == S.Public || a == S.Internal || a == S.Protected || a == S.Private || a == S.ProtectedIn || a == S.Static || a == S.Partial) { fieldName = paramName; paramName = ChooseArgName(fieldName); if (a == _set) { plainArg = F.Var(type, paramName, defaultValue).WithAttrs(arg.Attrs.RemoveAt(a_i)); } else { plainArg = F.Var(type, paramName, defaultValue); createStmt = arg; // in case of something like "public T arg = value", assume that // "= value" represents a default value, not a field initializer. if (arg.Args[1].Calls(S.Assign, 2)) { createStmt = arg.WithArgChanged(1, arg.Args[1].Args[0]); } } break; } } a_i++; } } } if (plainArg != null) { if (body == null) { if (fn.ArgCount < 4 || !fn.Args[3].Calls(S.Braces)) { return(Reject(sink, arg, Localize.From("'{0}': to set or create a field or property, the method must have a body in braces {{}}.", a))); } body = fn.Args[3]; } args[i] = plainArg; LNode assignment; if (fieldName == paramName) { assignment = F.Call(S.Assign, F.Dot(F.@this, F.Id(fieldName)), F.Id(paramName)); } else { assignment = F.Call(S.Assign, F.Id(fieldName), F.Id(paramName)); } setStmts.Add(assignment); if (createStmt != null) { createStmts.Add(createStmt); } } } if (body != null) // if this macro has been used... { var parts = fn.Args; parts[2] = parts[2].WithArgs(args); parts[3] = body.WithArgs(body.Args.InsertRange(0, setStmts)); fn = fn.WithArgs(parts); if (createStmts.IsEmpty) { return(fn); } else { createStmts.Add(fn); return(F.Call(S.Splice, createStmts)); } } return(null); }
private void MakeArgListTests(RVList <LNode> patternArgs, ref LNode candidate) { Symbol varArgSym = null; LNode varArgCond = null; int i; for (i = 0; i < patternArgs.Count; i++) { MakeTestExpr(patternArgs[i], LNode.Call(CodeSymbols.IndexBracks, LNode.List(LNode.Call(CodeSymbols.Dot, LNode.List(candidate, LNode.Id((Symbol)"Args"))), F.Literal(i))), out varArgSym, out varArgCond); if (varArgSym != null) { break; } } int i2 = i + 1; for (int left = patternArgs.Count - i2; i2 < patternArgs.Count; i2++) { Symbol varArgSym2 = null; LNode varArgCond2 = null; MakeTestExpr(patternArgs[i2], LNode.Call(CodeSymbols.IndexBracks, LNode.List(LNode.Call(CodeSymbols.Dot, LNode.List(candidate, LNode.Id((Symbol)"Args"))), LNode.Call(CodeSymbols.Sub, LNode.List(LNode.Call(CodeSymbols.Dot, LNode.List(LNode.Call(CodeSymbols.Dot, LNode.List(candidate, LNode.Id((Symbol)"Args"))), LNode.Id((Symbol)"Count"))), F.Literal(left))).SetStyle(NodeStyle.Operator))), out varArgSym2, out varArgCond2); if (varArgSym2 != null) { Context.Sink.Write(Severity.Error, patternArgs[i2], "More than a single $(..varargs) variable is not supported in a single argument list."); break; } left--; } if (varArgSym != null && (varArgSym != __ || varArgCond != null)) { LNode varArgSymId = F.Id(varArgSym); LNode grabVarArgs; if (i == 0 && patternArgs.Count == 1) { grabVarArgs = LNode.Call(CodeSymbols.Assign, LNode.List(varArgSymId, LNode.Call(CodeSymbols.Dot, LNode.List(candidate, LNode.Id((Symbol)"Args"))))).SetStyle(NodeStyle.Operator); } else if (i == 0 && patternArgs.Count > 1) { var fixedArgsLit = F.Literal(patternArgs.Count - 1); grabVarArgs = LNode.Call(CodeSymbols.Assign, LNode.List(varArgSymId, LNode.Call(LNode.Call(CodeSymbols.Dot, LNode.List(LNode.Call(CodeSymbols.Dot, LNode.List(candidate, LNode.Id((Symbol)"Args"))), LNode.Id((Symbol)"WithoutLast"))), LNode.List(fixedArgsLit)))).SetStyle(NodeStyle.Operator); } else { var varArgStartLit = F.Literal(i); var fixedArgsLit = F.Literal(patternArgs.Count - 1); if (i + 1 == patternArgs.Count) { grabVarArgs = LNode.Call(CodeSymbols.Assign, LNode.List(varArgSymId, LNode.Call(CodeSymbols.New, LNode.List(LNode.Call(LNode.Call(CodeSymbols.Of, LNode.List(LNode.Id((Symbol)"RVList"), LNode.Id((Symbol)"LNode"))), LNode.List(LNode.Call(LNode.Call(CodeSymbols.Dot, LNode.List(LNode.Call(CodeSymbols.Dot, LNode.List(candidate, LNode.Id((Symbol)"Args"))), LNode.Id((Symbol)"Slice"))), LNode.List(varArgStartLit)))))))).SetStyle(NodeStyle.Operator); } else { grabVarArgs = LNode.Call(CodeSymbols.Assign, LNode.List(varArgSymId, LNode.Call(CodeSymbols.New, LNode.List(LNode.Call(LNode.Call(CodeSymbols.Of, LNode.List(LNode.Id((Symbol)"RVList"), LNode.Id((Symbol)"LNode"))), LNode.List(LNode.Call(LNode.Call(CodeSymbols.Dot, LNode.List(LNode.Call(CodeSymbols.Dot, LNode.List(candidate, LNode.Id((Symbol)"Args"))), LNode.Id((Symbol)"Slice"))), LNode.List(varArgStartLit, LNode.Call(CodeSymbols.Sub, LNode.List(LNode.Call(CodeSymbols.Dot, LNode.List(LNode.Call(CodeSymbols.Dot, LNode.List(candidate, LNode.Id((Symbol)"Args"))), LNode.Id((Symbol)"Count"))), fixedArgsLit)).SetStyle(NodeStyle.Operator))))))))).SetStyle(NodeStyle.Operator); } } if (varArgCond != null || IsMultiCase) { Tests.Add(LNode.Call(CodeSymbols.OrBits, LNode.List(LNode.Call(CodeSymbols.Dot, LNode.List(grabVarArgs.PlusAttrs(LNode.List(LNode.InParensTrivia)), LNode.Id((Symbol)"IsEmpty"))), LNode.Literal(true))).SetStyle(NodeStyle.Operator)); Tests.Add(varArgCond); } else { ThenClause.Add(grabVarArgs); } } }
LNode FinishPrimaryExpr(LNode e) { TT la0; RVList <LNode> list = default(RVList <LNode>); // Line 149: ( TT.LParen ExprList TT.RParen | TT.Not (TT.LParen ExprList TT.RParen / Expr) | TT.LBrack ExprList TT.RBrack ) la0 = (TT)LA0; if (la0 == TT.LParen) { // line 149 var endMarker = default(TokenType); Skip(); list = ExprList(ref endMarker); var c = Match((int)TT.RParen); // line 152 e = MarkCall(F.Call(e, list, e.Range.StartIndex, c.EndIndex)); if ((endMarker == TT.Semicolon)) { e.Style = NodeStyle.Statement | NodeStyle.Alternate; } } else if (la0 == TT.Not) { Skip(); // line 157 var args = new RVList <LNode> { e }; int endIndex; // Line 158: (TT.LParen ExprList TT.RParen / Expr) la0 = (TT)LA0; if (la0 == TT.LParen) { Skip(); args = ExprList(args); var c = Match((int)TT.RParen); // line 158 endIndex = c.EndIndex; } else { var T = Expr(P.Primary); // line 159 args.Add(T); endIndex = T.Range.EndIndex; } // line 161 e = F.Call(S.Of, args, e.Range.StartIndex, endIndex).SetStyle(NodeStyle.Operator); } else { // line 163 var args = new RVList <LNode> { e }; Match((int)TT.LBrack); args = ExprList(args); var c = Match((int)TT.RBrack); // line 165 e = F.Call(S.IndexBracks, args, e.Range.StartIndex, c.EndIndex).SetStyle(NodeStyle.Operator); } // line 167 return(e); }
public RVList <LNode> ExprList(ref TokenType endMarker, RVList <LNode> list = default(RVList <LNode>)) { TT la0; LNode e = default(LNode); Token end = default(Token); // line 57 if ((LT0.Value is string)) { endMarker = TT.EOF; } // Line 1: ( / TopExpr) switch ((TT)LA0) { case EOF: case TT.Comma: case TT.Dedent: case TT.RBrace: case TT.RBrack: case TT.RParen: case TT.Semicolon: { } break; default: e = TopExpr(); break; } // Line 59: ((TT.Comma|TT.Semicolon) ( / TopExpr))* for (;;) { la0 = (TT)LA0; if (la0 == TT.Comma || la0 == TT.Semicolon) { end = MatchAny(); list.Add(e ?? MissingExpr()); CheckEndMarker(ref endMarker, ref end); // Line 62: ( / TopExpr) switch ((TT)LA0) { case EOF: case TT.Comma: case TT.Dedent: case TT.RBrace: case TT.RBrack: case TT.RParen: case TT.Semicolon: // line 62 e = null; break; default: e = TopExpr(); break; } } else { break; } } if ((e != null || end.Type() == TT.Comma)) { list.Add(e ?? MissingExpr()); } return(list); }