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);
}