internal void AddLabel(SimpleName label) {
this.labelIndex[label.Name.UniqueKey] = this.cases.Count;
GotoStatement gotoStatement = new GotoStatement(label, SourceDummy.SourceLocation);
List<Statement> statements = new List<Statement>(1);
statements.Add(gotoStatement);
this.cases.Add(new SwitchCase(new CompileTimeConstant(this.cases.Count, label.SourceLocation), statements, SourceDummy.SourceLocation));
}
private GotoStatement CreateCaseGoto(GotoStatement node, SwitchCase targetedCase)
{
CaseGotoStatement result = new CaseGotoStatement(node, (SwitchCase)targetedCase.CloneStatementOnly());
return(result);
}
public override object Visit (GotoDefault gotoDefault)
{
var result = new GotoStatement (GotoType.CaseDefault);
result.AddChild (new CSharpTokenNode (Convert (gotoDefault.loc), "goto".Length), GotoStatement.Roles.Keyword);
var location = LocationsBag.GetLocations (gotoDefault);
if (location != null) {
result.AddChild (new CSharpTokenNode (Convert (location[0]), "default".Length), GotoStatement.DefaultKeywordRole);
result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), GotoStatement.Roles.Semicolon);
}
return result;
}
// IMPORTANT NOTE:
// The grammar consists of a few LALR(1) conflicts. These issues are, however, correctly handled, due to the fact that the grammar
// is defined in a specific order making the already added parser actions have precedence over the other.
//
// Known conflicts that are correctly handled:
//
// - ELSE: Shift/Reduce conflict Dangling ELSE problem. Lots of articles are around on the internet.
// The shift action is taken here.
//
// - CLOSE_PARENS: Shift/Reduce conflict. This is due to the fact that the explicit cast expression is like the parenthesized
// expression. The shift action is taken here.
//
// - STAR: Reduce/Reduce conflict, between VariableType -> TypeNameExpression and PrimaryExpression -> TypeNameExpression,
// due to the fact variable types can have '*', and look therefore like a binary operator expression.
// The first reduce action is taken here.
public CSharpGrammar()
{
// Please let me know if there is a better way of tidying this :s
TokenMapping.Add((int)ERROR, Error);
#region Definitions to use later
var statementList = new GrammarDefinition("StatementList");
var statementListOptional = new GrammarDefinition("StatementListOptional",
rule: null
| statementList);
var blockStatement = new GrammarDefinition("BlockStatement");
var variableDeclarator = new GrammarDefinition("VariableDeclarator");
var variableDeclaratorList = new GrammarDefinition("VariableDeclaratorList");
variableDeclaratorList.Rule = variableDeclarator
| variableDeclaratorList
+ ToElement(COMMA)
+ variableDeclarator;
var variableDeclaration = new GrammarDefinition("VariableDeclaration");
var variableInitializer = new GrammarDefinition("VariableInitializer");
var arrayInitializer = new GrammarDefinition("ArrayInitializer");
var arrayInitializerOptional = new GrammarDefinition("ArrayInitializerOptional",
rule: null | arrayInitializer);
var identifierInsideBody = new GrammarDefinition("IdentifierInsideBody",
rule: ToElement(IDENTIFIER),
createNode: node => ToIdentifier(node.Children[0].Result));
var identifierInsideBodyOptional = new GrammarDefinition("IdentifierInsideBodyOptional",
rule: null | identifierInsideBody);
variableDeclarator.Rule = identifierInsideBody
| identifierInsideBody
+ ToElement(EQUALS)
+ variableInitializer;
variableDeclarator.ComputeResult = node =>
{
var result = new VariableDeclarator((Identifier) node.Children[0].Result);
if (node.Children.Count > 1)
{
result.OperatorToken = (AstToken) node.Children[1].Result;
result.Value = (Expression) node.Children[2].Result;
}
return result;
};
var typeReference = new GrammarDefinition("TypeReference");
var identifierExpression = new GrammarDefinition("IdentifierExpression",
rule: identifierInsideBody,
createNode: node => new IdentifierExpression((Identifier) node.Children[0].Result));
var usingDirectiveListOptional = new GrammarDefinition("UsingDirectiveListOptional");
#endregion
#region Type References
var namespaceOrTypeExpression = new GrammarDefinition("NamespaceOrTypeExpression");
namespaceOrTypeExpression.Rule = identifierExpression |
namespaceOrTypeExpression
+ ToElement(DOT)
+ ToElement(IDENTIFIER);
namespaceOrTypeExpression.ComputeResult = node =>
{
if (node.Children.Count == 1)
return ToTypeReference((IConvertibleToType) node.Children[0].Result);
var result = new MemberTypeReference();
result.Target = (TypeReference) node.Children[0].Result;
result.AddChild(AstNodeTitles.Accessor, node.Children[1].Result);
result.Identifier = ToIdentifier(node.Children[2].Result);
return result;
};
ComputeResultDelegate createPrimitiveTypeExpression = node =>
{
if (node.Children[0].Result is PrimitiveTypeReference)
return node.Children[0].Result;
return new PrimitiveTypeReference
{
Identifier = ToIdentifier(node.Children[0].Result),
PrimitiveType = CSharpLanguage.PrimitiveTypeFromString(((AstToken) node.Children[0].Result).Value)
};
};
var integralType = new GrammarDefinition("IntegralType",
rule: ToElement(SBYTE)
| ToElement(BYTE)
| ToElement(SHORT)
| ToElement(USHORT)
| ToElement(INT)
| ToElement(UINT)
| ToElement(LONG)
| ToElement(ULONG)
| ToElement(CHAR),
createNode: createPrimitiveTypeExpression);
var primitiveType = new GrammarDefinition("PrimitiveTypeExpression",
rule: ToElement(OBJECT)
| ToElement(STRING)
| ToElement(BOOL)
| ToElement(DECIMAL)
| ToElement(FLOAT)
| ToElement(DOUBLE)
| ToElement(VOID)
| integralType,
createNode: createPrimitiveTypeExpression);
var dimensionSeparators = new GrammarDefinition("DimensionSeparators");
dimensionSeparators.Rule = ToElement(COMMA)
| dimensionSeparators + ToElement(COMMA);
var rankSpecifier = new GrammarDefinition("RankSpecifier",
rule: ToElement(OPEN_BRACKET) + ToElement(CLOSE_BRACKET)
| ToElement(OPEN_BRACKET) + dimensionSeparators
+ ToElement(CLOSE_BRACKET),
createNode: node =>
{
var result = new ArrayTypeRankSpecifier();
result.LeftBracket = (AstToken) node.Children[0].Result;
if (node.Children.Count == 3)
{
foreach (var dimensionSeparator in node.Children[1].GetAllNodesFromListDefinition()
.Select(x => x.Result))
{
result.Dimensions++;
result.AddChild(AstNodeTitles.ElementSeparator, dimensionSeparator);
}
}
result.RightBracket = (AstToken) node.Children[node.Children.Count - 1].Result;
return result;
});
var arrayType = new GrammarDefinition("ArrayType",
rule: typeReference
+ rankSpecifier,
createNode: node => new ArrayTypeReference()
{
BaseType = (TypeReference) node.Children[0].Result,
RankSpecifier = (ArrayTypeRankSpecifier) node.Children[1].Result
});
var pointerType = new GrammarDefinition("PointerType",
rule: typeReference
+ ToElement(STAR),
createNode: node => new PointerTypeReference()
{
BaseType = (TypeReference) node.Children[0].Result,
PointerToken = (AstToken) node.Children[1].Result
});
var typeExpression = new GrammarDefinition("TypeExpression",
rule: namespaceOrTypeExpression
| primitiveType);
typeReference.Rule = typeExpression
| arrayType
| pointerType
;
#endregion
#region Expressions
ComputeResultDelegate createBinaryOperatorExpression = node =>
{
if (node.Children.Count == 1)
return node.Children[0].Result;
var result = new BinaryOperatorExpression();
result.Left = (Expression) node.Children[0].Result;
var operatorToken = (AstToken) (node.Children[1].Result ?? node.Children[1].Children[0].Result);
result.Operator = CSharpLanguage.BinaryOperatorFromString(operatorToken.Value);
result.OperatorToken = (AstToken) operatorToken;
result.Right = (Expression) node.Children[2].Result;
return result;
};
var expression = new GrammarDefinition("Expression");
var expressionOptional = new GrammarDefinition("ExpressionOptional",
rule: null
| expression);
var primaryExpression = new GrammarDefinition("PrimaryExpression");
var primitiveExpression = new GrammarDefinition("PrimitiveExpression",
rule: ToElement(LITERAL)
| ToElement(TRUE)
| ToElement(FALSE)
| ToElement(NULL),
createNode: node =>
{
object interpretedValue;
node.Children[0].Result.UserData.TryGetValue("InterpretedValue", out interpretedValue);
var result = new PrimitiveExpression(interpretedValue, ((AstToken) node.Children[0].Result).Value, node.Children[0].Range);
return result;
});
var parenthesizedExpression = new GrammarDefinition("ParenthesizedExpression",
rule: ToElement(OPEN_PARENS)
+ expression
+ ToElement(CLOSE_PARENS)
| ToElement(OPEN_PARENS)
+ Error
+ ToElement(CLOSE_PARENS),
createNode: node => new ParenthesizedExpression
{
LeftParenthese = (AstToken) node.Children[0].Result,
Expression = (Expression) node.Children[1].Result,
RightParenthese = (AstToken) node.Children[2].Result,
});
var memberAccessorOperator = new GrammarDefinition("MemberAccessorOperator",
rule: ToElement(DOT)
| ToElement(OP_PTR)
| ToElement(INTERR_OPERATOR));
var memberReferenceExpression = new GrammarDefinition("MemberReferenceExpression",
rule: primaryExpression + memberAccessorOperator + identifierInsideBody
| primaryExpression + memberAccessorOperator + Error,
createNode: node => new MemberReferenceExpression
{
Target =
(Expression)
((IConvertibleToExpression) node.Children[0].Result).ToExpression().Remove(),
Accessor = CSharpLanguage.AccessorFromString(((AstToken) node.Children[1].Children[0].Result).Value),
AccessorToken = (AstToken) node.Children[1].Children[0].Result,
Identifier = (Identifier) node.Children[2].Result
});
var argument = new GrammarDefinition("Argument",
rule: expression
| ToElement(REF) + expression
| ToElement(OUT) + expression,
createNode: node =>
{
if (node.Children.Count > 1)
{
return new DirectionExpression()
{
DirectionToken = (AstToken) node.Children[0].Result,
Direction = CSharpLanguage.DirectionFromString(((AstToken) node.Children[0].Result).Value),
Expression = (Expression) node.Children[1].Result
};
}
return node.Children[0].Result;
});
var argumentList = new GrammarDefinition("ArgumentList");
argumentList.Rule = argument
| argumentList + ToElement(COMMA) + argument;
var argumentListOptional = new GrammarDefinition("ArgumentListOptional",
rule: null | argumentList);
var invocationExpression = new GrammarDefinition("InvocationExpression",
rule: primaryExpression
+ ToElement(OPEN_PARENS)
+ argumentListOptional
+ ToElement(CLOSE_PARENS),
createNode: node =>
{
var result = new InvocationExpression()
{
Target = (Expression) node.Children[0].Result,
LeftParenthese = (AstToken) node.Children[1].Result,
};
if (node.Children[2].HasChildren)
{
foreach (var subNode in node.Children[2].Children[0].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Arguments.Add((Expression) subNode);
}
}
result.RightParenthese = (AstToken) node.Children[3].Result;
return result;
});
var indexerExpression = new GrammarDefinition("IndexerExpression",
rule: primaryExpression
+ ToElement(OPEN_BRACKET_EXPR)
+ argumentList
+ ToElement(CLOSE_BRACKET),
createNode: node =>
{
var result = new IndexerExpression()
{
Target = (Expression) node.Children[0].Result,
LeftBracket = (AstToken) node.Children[1].Result,
};
foreach (var subNode in node.Children[2].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Indices.Add((Expression) subNode);
}
result.RightBracket = (AstToken) node.Children[3].Result;
return result;
});
var createObjectExpression = new GrammarDefinition("CreateObjectExpression",
rule: ToElement(NEW)
+ typeReference
+ ToElement(OPEN_PARENS)
+ argumentListOptional
+ ToElement(CLOSE_PARENS)
+ arrayInitializerOptional
| ToElement(NEW)
+ namespaceOrTypeExpression
+ arrayInitializer,
createNode: node =>
{
var result = new CreateObjectExpression();
result.NewKeyword = (AstToken) node.Children[0].Result;
result.Type = (TypeReference) node.Children[1].Result;
if (node.Children.Count == 6)
{
result.LeftParenthese = (AstToken) node.Children[2].Result;
if (node.Children[3].HasChildren)
{
foreach (var subNode in node.Children[3].Children[0].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Arguments.Add((Expression) subNode);
}
}
result.RightParenthese = (AstToken) node.Children[4].Result;
}
var initializerNode = node.Children[node.Children.Count - 1];
if (initializerNode.HasChildren)
result.Initializer = (ArrayInitializer) initializerNode.Result;
return result;
});
var createArrayExpression = new GrammarDefinition("CreateArrayExpression",
rule: ToElement(NEW)
+ rankSpecifier
+ arrayInitializer
| ToElement(NEW)
+ typeReference
+ rankSpecifier
+ arrayInitializer
| ToElement(NEW)
+ typeReference
+ ToElement(OPEN_BRACKET_EXPR)
+ argumentList
+ ToElement(CLOSE_BRACKET)
+ arrayInitializerOptional
,
createNode: node =>
{
var result = new CreateArrayExpression();
result.NewKeyword = (AstToken) node.Children[0].Result;
switch (node.Children.Count)
{
case 3:
{
var rankSpecifierNode = (ArrayTypeRankSpecifier) node.Children[1].Result;
result.LeftBracket = (AstToken) rankSpecifierNode.LeftBracket.Remove();
result.RightBracket = (AstToken) rankSpecifierNode.RightBracket.Remove();
break;
}
case 4:
{
result.Type = (TypeReference) node.Children[1].Result;
var rankSpecifierNode = (ArrayTypeRankSpecifier) node.Children[2].Result;
result.LeftBracket = (AstToken) rankSpecifierNode.LeftBracket.Remove();
result.RightBracket = (AstToken) rankSpecifierNode.RightBracket.Remove();
break;
}
case 6:
{
result.Type = (TypeReference) node.Children[1].Result;
result.LeftBracket = (AstToken) node.Children[2].Result;
if (node.Children[3].HasChildren)
{
foreach (var subNode in node.Children[3].Children[0].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Arguments.Add((Expression) subNode);
}
}
result.RightBracket = (AstToken) node.Children[4].Result;
break;
}
}
var initializerNode = node.Children[node.Children.Count - 1];
if (initializerNode.HasChildren)
result.Initializer = (ArrayInitializer) initializerNode.Result;
return result;
});
var primitiveTypeExpression = new GrammarDefinition("PrimitiveTypeExpression",
rule: primitiveType,
createNode: node => ((IConvertibleToExpression) node.Children[0].Result).ToExpression());
var typeNameExpression = new GrammarDefinition("TypeNameExpression",
rule: identifierExpression
| memberReferenceExpression
| primitiveTypeExpression);
var thisExpression = new GrammarDefinition("ThisExpression",
rule: ToElement(THIS),
createNode: node => new ThisReferenceExpression()
{
ThisKeywordToken = (AstToken) node.Children[0].Result,
});
var baseExpression = new GrammarDefinition("BaseExpression",
rule: ToElement(BASE),
createNode: node => new BaseReferenceExpression()
{
BaseKeywordToken = (AstToken) node.Children[0].Result,
});
var typeofExpression = new GrammarDefinition("TypeOfExpression",
rule: ToElement(TYPEOF) + ToElement(OPEN_PARENS) + typeReference
+ ToElement(CLOSE_PARENS),
createNode: node => new GetTypeExpression()
{
GetTypeKeywordToken = (AstToken) node.Children[0].Result,
LeftParenthese = (AstToken) node.Children[1].Result,
TargetType = (TypeReference) node.Children[2].Result,
RightParenthese = (AstToken) node.Children[3].Result,
});
var defaultExpression = new GrammarDefinition("DefaultExpression",
rule: ToElement(DEFAULT)
+ ToElement(OPEN_PARENS)
+ typeReference
+ ToElement(CLOSE_PARENS),
createNode: node => new DefaultExpression()
{
KeywordToken = (AstToken) node.Children[0].Result,
LeftParenthese = (AstToken) node.Children[1].Result,
TargetType = (TypeReference) node.Children[2].Result,
RightParenthese = (AstToken) node.Children[3].Result,
});
var sizeofExpression = new GrammarDefinition("SizeOfExpression",
rule: ToElement(SIZEOF) + ToElement(OPEN_PARENS) + typeReference
+ ToElement(CLOSE_PARENS),
createNode: node => new SizeOfExpression()
{
SizeofKeyword = (AstToken) node.Children[0].Result,
LeftParenthese = (AstToken) node.Children[1].Result,
TargetType = (TypeReference) node.Children[2].Result,
RightParenthese = (AstToken) node.Children[3].Result,
});
var checkedExpression = new GrammarDefinition("CheckedExpression",
rule:
ToElement(CHECKED) + ToElement(OPEN_PARENS) + expression +
ToElement(CLOSE_PARENS),
createNode: node => new CheckedExpression()
{
CheckedKeyword = (AstToken) node.Children[0].Result,
LeftParenthese = (AstToken) node.Children[1].Result,
TargetExpression = (Expression) node.Children[2].Result,
RightParenthese = (AstToken) node.Children[3].Result,
});
var uncheckedExpression = new GrammarDefinition("UncheckedExpression",
rule:
ToElement(UNCHECKED) + ToElement(OPEN_PARENS) + expression +
ToElement(CLOSE_PARENS),
createNode: node => new UncheckedExpression()
{
UncheckedKeyword = (AstToken) node.Children[0].Result,
LeftParenthese = (AstToken) node.Children[1].Result,
TargetExpression = (Expression) node.Children[2].Result,
RightParenthese = (AstToken) node.Children[3].Result,
});
var stackAllocExpression = new GrammarDefinition("StackAllocExpression",
rule:
ToElement(STACKALLOC)
+ typeReference
+ ToElement(OPEN_BRACKET_EXPR)
+ expression
+ ToElement(CLOSE_BRACKET),
createNode: node => new StackAllocExpression()
{
StackAllocKeyword = (AstToken) node.Children[0].Result,
Type = (TypeReference) node.Children[1].Result,
LeftBracket = (AstToken) node.Children[2].Result,
Counter = (Expression) node.Children[3].Result,
RightBracket = (AstToken) node.Children[4].Result,
});
var explicitAnonymousMethodParameter = new GrammarDefinition("ExplicitAnonymousMethodParameter",
rule: typeReference + ToElement(IDENTIFIER),
createNode: node => new ParameterDeclaration
{
ParameterType = (TypeReference)node.Children[0].Result,
Declarator = new VariableDeclarator(ToIdentifier(node.Children[1].Result))
});
var explicitAnonymousMethodParameterList = new GrammarDefinition("ExplicitAnonymousMethodParameterList");
explicitAnonymousMethodParameterList.Rule = explicitAnonymousMethodParameter
| explicitAnonymousMethodParameterList
+ ToElement(COMMA)
+ explicitAnonymousMethodParameter;
var explicitAnonymousMethodParameterListOptional = new GrammarDefinition("ExplicitAnonymousMethodParameterListOptional",
rule: null | explicitAnonymousMethodParameterList);
var explicitAnonymousMethodSignature = new GrammarDefinition("ExplicitAnonymousMethodSignature",
rule: ToElement(OPEN_PARENS) + explicitAnonymousMethodParameterListOptional + ToElement(CLOSE_PARENS));
var explicitAnonymousMethodSignatureOptional =
new GrammarDefinition("ExplicitAnonymousMethodSignatureOptional",
rule: null | explicitAnonymousMethodSignature);
var anonymousMethodExpression = new GrammarDefinition("AnonymousMethodExpression",
rule: ToElement(DELEGATE) + explicitAnonymousMethodSignatureOptional + blockStatement,
createNode: node =>
{
var result = new AnonymousMethodExpression();
result.DelegateKeyword = (AstToken) node.Children[0].Result;
if (node.Children[1].HasChildren)
{
var signature = node.Children[1].Children[0];
result.LeftParenthese = (AstToken) signature.Children[0].Result;
if (signature.Children[1].HasChildren)
{
foreach (var child in signature.Children[1].Children[0].GetAllListAstNodes())
{
if (child is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, child);
else
result.Parameters.Add((ParameterDeclaration) child);
}
}
result.RightParenthese = (AstToken)signature.Children[2].Result;
}
result.Body = (BlockStatement) node.Children[2].Result;
return result;
});
var implicitAnonymousMethodParameter = new GrammarDefinition("ImplicitAnonymousMethodParameter",
rule: ToElement(IDENTIFIER),
createNode: node => new ParameterDeclaration
{
Declarator = new VariableDeclarator(ToIdentifier(node.Children[0].Result))
});
var implicitAnonymousMethodParameterList = new GrammarDefinition("ImplicitAnonymousMethodParameterList");
implicitAnonymousMethodParameterList.Rule = implicitAnonymousMethodParameter
| implicitAnonymousMethodParameterList
+ ToElement(COMMA)
+ implicitAnonymousMethodParameter;
var implicitAnonymousMethodParameterListOptional = new GrammarDefinition("ImplicitAnonymousMethodParameterListOptional",
rule: null | implicitAnonymousMethodParameterList);
var implicitAnonymousMethodSignature = new GrammarDefinition("implicitAnonymousMethodSignature",
rule: implicitAnonymousMethodParameter | ToElement(OPEN_PARENS_LAMBDA) + implicitAnonymousMethodParameterList + ToElement(CLOSE_PARENS));
var anonymousMethodSignature = new GrammarDefinition("AnonymousMethodSignature",
rule: implicitAnonymousMethodSignature);
var anonymousFunctionBody = new GrammarDefinition("AnonymousFunctionBody",
rule: expression | blockStatement);
var lambdaExpression = new GrammarDefinition("LambdaExpression",
rule: anonymousMethodSignature + ToElement(ARROW) + anonymousFunctionBody,
createNode: node =>
{
var result = new LambdaExpression();
result.Arrow = (AstToken)node.Children[1].Result;
result.Body = node.Children[2].Result;
return result;
});
primaryExpression.Rule =
typeNameExpression
| primitiveExpression
| parenthesizedExpression
| invocationExpression
| indexerExpression
| thisExpression
| baseExpression
| createObjectExpression
| createArrayExpression
| typeofExpression
| defaultExpression
| sizeofExpression
| checkedExpression
| uncheckedExpression
| stackAllocExpression
| anonymousMethodExpression
;
var preFixUnaryOperator = new GrammarDefinition("PreFixUnaryOperator",
rule: ToElement(PLUS)
| ToElement(MINUS)
| ToElement(STAR)
| ToElement(BANG)
| ToElement(OP_INC)
| ToElement(OP_DEC)
| ToElement(BITWISE_AND)
| ToElement(TILDE)
| ToElement(AWAIT));
var postFixUnaryOperator = new GrammarDefinition("PostFixUnaryOperator",
rule: ToElement(OP_INC)
| ToElement(OP_DEC));
var castExpression = new GrammarDefinition("CastExpression");
var unaryOperatorExpression = new GrammarDefinition("UnaryOperatorExpression",
rule: primaryExpression
| castExpression
| (preFixUnaryOperator + primaryExpression)
| (primaryExpression + postFixUnaryOperator),
createNode: node =>
{
if (node.Children.Count == 1)
return node.Children[0].Result;
var result = new UnaryOperatorExpression();
var isPrefix = node.Children[0].GrammarElement == preFixUnaryOperator;
if (isPrefix)
{
var operatorToken = ((AstToken) node.Children[0].Children[0].Result);
result.Operator = CSharpLanguage.UnaryOperatorFromString(operatorToken.Value);
result.OperatorToken = operatorToken;
}
result.Expression = (Expression) node.Children[isPrefix ? 1 : 0].Result;
if (!isPrefix)
{
var operatorToken = (AstToken) node.Children[1].Children[0].Result;
result.Operator = CSharpLanguage.UnaryOperatorFromString(operatorToken.Value, false);
result.OperatorToken = operatorToken;
}
return result;
});
castExpression.Rule = ToElement(OPEN_PARENS)
+ typeNameExpression
+ ToElement(CLOSE_PARENS)
+ unaryOperatorExpression;
castExpression.ComputeResult = node => new ExplicitCastExpression
{
LeftParenthese = (AstToken) node.Children[0].Result,
TargetType = ToTypeReference((IConvertibleToType) node.Children[1].Result),
RightParenthese = (AstToken) node.Children[2].Result,
TargetExpression = (Expression) node.Children[3].Result
};
var multiplicativeOperator = new GrammarDefinition("MultiplicativeOperator",
rule: ToElement(STAR)
| ToElement(DIV)
| ToElement(PERCENT));
var multiplicativeExpression = new GrammarDefinition("MultiplicativeExpression");
multiplicativeExpression.Rule = unaryOperatorExpression
| multiplicativeExpression
+ multiplicativeOperator
+ unaryOperatorExpression;
multiplicativeExpression.ComputeResult = createBinaryOperatorExpression;
var additiveOperator = new GrammarDefinition("AdditiveOperator",
rule: ToElement(PLUS)
| ToElement(MINUS));
var additiveExpression = new GrammarDefinition("AdditiveExpression");
additiveExpression.Rule = multiplicativeExpression
| additiveExpression
+ additiveOperator
+ multiplicativeExpression;
additiveExpression.ComputeResult = createBinaryOperatorExpression;
var shiftOperator = new GrammarDefinition("ShiftOperator",
rule: ToElement(OP_SHIFT_LEFT)
| ToElement(OP_SHIFT_RIGHT));
var shiftExpression = new GrammarDefinition("ShiftExpression");
shiftExpression.Rule = additiveExpression
| shiftExpression
+ shiftOperator
+ additiveExpression;
shiftExpression.ComputeResult = createBinaryOperatorExpression;
var relationalOperator = new GrammarDefinition("RelationalOperator",
rule: ToElement(OP_GT)
| ToElement(OP_GE)
| ToElement(OP_LT)
| ToElement(OP_LE)
| ToElement(IS)
| ToElement(AS));
var relationalExpression = new GrammarDefinition("RelationalExpression");
relationalExpression.Rule = shiftExpression
| relationalExpression
+ relationalOperator
+ shiftExpression;
relationalExpression.ComputeResult = node =>
{
if (node.Children.Count == 1)
return node.Children[0].Result;
var operatorToken = (CSharpAstToken) node.Children[1].Children[0].Result;
switch (operatorToken.Code)
{
case IS:
return new TypeCheckExpression()
{
TargetExpression = (Expression) node.Children[0].Result,
IsKeyword = operatorToken,
TargetType = ToTypeReference((IConvertibleToType) node.Children[2].Result)
};
case AS:
return new SafeCastExpression()
{
TargetExpression = (Expression) node.Children[0].Result,
CastKeyword = operatorToken,
TargetType = ToTypeReference((IConvertibleToType) node.Children[2].Result)
};
default:
return createBinaryOperatorExpression(node);
}
};
var equalityOperator = new GrammarDefinition("equalityOperator",
rule: ToElement(OP_EQUALS)
| ToElement(OP_NOTEQUALS));
var equalityExpression = new GrammarDefinition("EqualityExpression");
equalityExpression.Rule = relationalExpression
| equalityExpression
+ equalityOperator
+ relationalExpression;
equalityExpression.ComputeResult = createBinaryOperatorExpression;
var logicalAndExpression = new GrammarDefinition("LogicalAndExpression");
logicalAndExpression.Rule = equalityExpression
| logicalAndExpression
+ ToElement(BITWISE_AND)
+ equalityExpression;
logicalAndExpression.ComputeResult = createBinaryOperatorExpression;
var logicalXorExpression = new GrammarDefinition("LogicalOrExpression");
logicalXorExpression.Rule = logicalAndExpression
| logicalXorExpression
+ ToElement(CARRET)
+ logicalAndExpression;
logicalXorExpression.ComputeResult = createBinaryOperatorExpression;
var logicalOrExpression = new GrammarDefinition("LogicalOrExpression");
logicalOrExpression.Rule = logicalXorExpression
| logicalOrExpression
+ ToElement(BITWISE_OR)
+ logicalXorExpression;
logicalOrExpression.ComputeResult = createBinaryOperatorExpression;
var conditionalAndExpression = new GrammarDefinition("ConditionalAndExpression");
conditionalAndExpression.Rule = logicalOrExpression
| conditionalAndExpression
+ ToElement(OP_AND)
+ logicalOrExpression;
conditionalAndExpression.ComputeResult = createBinaryOperatorExpression;
var conditionalOrExpression = new GrammarDefinition("ConditionalOrExpression");
conditionalOrExpression.Rule = conditionalAndExpression
| conditionalOrExpression
+ ToElement(OP_OR)
+ conditionalAndExpression;
conditionalOrExpression.ComputeResult = createBinaryOperatorExpression;
var nullCoalescingExpression = new GrammarDefinition("NullCoalescingExpression");
nullCoalescingExpression.Rule = conditionalOrExpression
| nullCoalescingExpression
+ ToElement(OP_COALESCING)
+ conditionalOrExpression;
nullCoalescingExpression.ComputeResult = createBinaryOperatorExpression;
var conditionalExpression = new GrammarDefinition("ConditionalExpression",
rule: nullCoalescingExpression
| nullCoalescingExpression
+ ToElement(INTERR)
+ expression + ToElement(COLON) + expression,
createNode: node => node.Children.Count == 1
? node.Children[0].Result
: new ConditionalExpression
{
Condition = (Expression) node.Children[0].Result,
OperatorToken = (AstToken) node.Children[1].Result,
TrueExpression = (Expression) node.Children[2].Result,
ColonToken = (AstToken) node.Children[3].Result,
FalseExpression = (Expression) node.Children[4].Result
});
var assignmentOperator = new GrammarDefinition("AssignmentOperator",
rule: ToElement(EQUALS)
| ToElement(OP_ADD_ASSIGN)
| ToElement(OP_SUB_ASSIGN)
| ToElement(OP_MULT_ASSIGN)
| ToElement(OP_DIV_ASSIGN)
| ToElement(OP_AND_ASSIGN)
| ToElement(OP_OR_ASSIGN)
| ToElement(OP_XOR_ASSIGN)
| ToElement(OP_SHIFT_LEFT_ASSIGN)
| ToElement(OP_SHIFT_RIGHT_ASSIGN));
var assignmentExpression = new GrammarDefinition("AssignmentExpression",
rule: unaryOperatorExpression
+ assignmentOperator
+ expression,
createNode: node => new AssignmentExpression
{
Target = (Expression) node.Children[0].Result,
Operator = CSharpLanguage.AssignmentOperatorFromString(((AstToken) node.Children[1].Children[0].Result).Value),
OperatorToken = (AstToken) node.Children[1].Children[0].Result,
Value = (Expression) node.Children[2].Result,
});
var fromClause = new GrammarDefinition("FromClause",
rule: ToElement(FROM) + identifierInsideBody + ToElement(IN) + expression,
createNode: node => new LinqFromClause
{
FromKeyword = (AstToken) node.Children[0].Result,
VariableName = (Identifier) node.Children[1].Result,
InKeyword = (AstToken) node.Children[2].Result,
DataSource = (Expression) node.Children[3].Result
});
var letClause = new GrammarDefinition("LetClause",
rule: ToElement(LET) + variableDeclarator,
createNode: node => new LinqLetClause()
{
LetKeyword = (AstToken) node.Children[0].Result,
Variable = (VariableDeclarator) node.Children[1].Result
});
var whereClause = new GrammarDefinition("WhereClause",
rule: ToElement(WHERE) + expression,
createNode: node => new LinqWhereClause()
{
WhereKeyword = (AstToken) node.Children[0].Result,
Condition = (Expression) node.Children[1].Result
});
var orderingDirection = new GrammarDefinition("OrderingDirection",
rule: null | ToElement(ASCENDING) | ToElement(DESCENDING));
var ordering = new GrammarDefinition("Ordering",
rule: expression + orderingDirection,
createNode: node =>
{
var result = new LinqOrdering();
result.Expression = (Expression) node.Children[0].Result;
if (node.Children[1].HasChildren)
{
var directionNode = node.Children[1].Children[0];
result.DirectionKeyword = (AstToken) directionNode.Result;
result.Direction = directionNode.Result != null
? CSharpLanguage.OrderningDirectionFromString(result.DirectionKeyword.Value)
: LinqOrderingDirection.None;
}
return result;
});
var orderings = new GrammarDefinition("Orderings");
orderings.Rule = ordering | orderings + ToElement(COMMA) + ordering;
var orderByClause = new GrammarDefinition("OrderByClause",
rule: ToElement(ORDERBY) + orderings,
createNode: node =>
{
var result = new LinqOrderByClause();
result.OrderByKeyword = (AstToken) node.Children[0].Result;
foreach (var subNode in node.Children[1].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Ordernings.Add((LinqOrdering) subNode);
}
return result;
});
var groupByClause = new GrammarDefinition("GroupByClause",
rule: ToElement(GROUP) + expression + ToElement(BY) + expression,
createNode: node => new LinqGroupByClause()
{
GroupKeyword = (AstToken) node.Children[0].Result,
Expression = (Expression) node.Children[1].Result,
ByKeyword = (AstToken) node.Children[2].Result,
KeyExpression = (Expression) node.Children[3].Result
});
var selectClause = new GrammarDefinition("SelectClause",
rule: ToElement(SELECT) + expression,
createNode: node => new LinqSelectClause()
{
SelectKeyword = (AstToken) node.Children[0].Result,
Target = (Expression) node.Children[1].Result
});
var queryBodyClause = new GrammarDefinition("QueryBodyClause",
rule:
fromClause
| letClause
| groupByClause
| whereClause
| orderByClause
);
var queryBodyClauses = new GrammarDefinition("QueryBodyClauses");
queryBodyClauses.Rule = queryBodyClause | queryBodyClauses + queryBodyClause;
var queryBodyClausesOptional = new GrammarDefinition("QueryBodyClausesOptional",
rule: null | queryBodyClauses);
var linqExpression = new GrammarDefinition("LinqExpression",
rule: fromClause + queryBodyClausesOptional + selectClause,
createNode: node =>
{
var result = new LinqExpression();
result.Clauses.Add((LinqClause) node.Children[0].Result);
if (node.Children[1].HasChildren)
{
result.Clauses.AddRange(node.Children[1].Children[0].GetAllListAstNodes().Cast<LinqClause>());
}
result.Clauses.Add((LinqClause) node.Children[2].Result);
return result;
});
expression.Rule = conditionalExpression
| linqExpression
| lambdaExpression
| assignmentExpression;
#endregion
#region Statements
var statement = new GrammarDefinition("Statement");
var embeddedStatement = new GrammarDefinition("EmbeddedStatement");
var emptyStatement = new GrammarDefinition("EmptyStatement",
rule: ToElement(SEMICOLON),
createNode: node =>
{
var result = new EmptyStatement();
result.AddChild(AstNodeTitles.Semicolon, node.Children[0].Result);
return result;
});
var labelStatement = new GrammarDefinition("LabelStatement",
rule: identifierInsideBody + ToElement(COLON),
createNode: node => new LabelStatement((Identifier) node.Children[0].Result)
{
Colon = (AstToken) node.Children[1].Result
});
var expressionStatement = new GrammarDefinition("ExpressionStatement",
rule: expression + ToElement(SEMICOLON)
| Error + ToElement(SEMICOLON)
| Error + ToElement(CLOSE_BRACE)
| expression + ToElement(CLOSE_BRACE), // Common mistake in C# is to forget the semicolon at the end of a statement.
createNode: node =>
{
var result = new ExpressionStatement(node.Children[0].Result as Expression);
var endingToken = (AstToken) node.Children[1].Result;
if (endingToken.GetTokenCode() == (int) SEMICOLON)
{
result.AddChild(AstNodeTitles.Semicolon, node.Children[1].Result);
}
else
{
node.Context.SyntaxErrors.Add(new SyntaxError(
node.Children[1].Range.End,
"';' expected.",
MessageSeverity.Error));
node.Context.Lexer.PutBack((AstToken) endingToken);
}
return result;
});
blockStatement.Rule = ToElement(OPEN_BRACE)
+ statementListOptional
+ ToElement(CLOSE_BRACE);
blockStatement.ComputeResult = node =>
{
var result = new BlockStatement();
result.StartScope = node.Children[0].Result;
if (node.Children[1].HasChildren)
{
result.Statements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<Statement>());
}
result.EndScope = node.Children[2].Result;
return result;
};
var variableDeclarationStatement = new GrammarDefinition("VariableDeclarationStatement",
rule: variableDeclaration
+ ToElement(SEMICOLON),
createNode: node =>
{
var result = node.Children[0].Result;
result.AddChild(AstNodeTitles.Semicolon, node.Children[1].Result);
return result;
});
var ifElseStatement = new GrammarDefinition("IfElseStatement",
rule: ToElement(IF) + parenthesizedExpression + embeddedStatement
| ToElement(IF) + parenthesizedExpression + embeddedStatement + ToElement(ELSE) + embeddedStatement
,
createNode: node =>
{
var result = new IfElseStatement();
result.IfKeyword = (AstToken) node.Children[0].Result;
var parenthesized = (ParenthesizedExpression) node.Children[1].Result;
result.LeftParenthese = (AstToken) parenthesized.LeftParenthese.Remove();
result.Condition = (Expression) parenthesized.Expression?.Remove();
result.RightParenthese = (AstToken) parenthesized.RightParenthese.Remove();
result.TrueBlock = (Statement) node.Children[2].Result;
if (node.Children.Count > 3)
{
result.ElseKeyword = (AstToken) node.Children[3].Result;
result.FalseBlock = (Statement) node.Children[4].Result;
CheckForPossibleMistakenEmptyStatement(node.Children[4]);
}
else
{
CheckForPossibleMistakenEmptyStatement(node.Children[2]);
}
return result;
});
var switchLabel = new GrammarDefinition("SwitchLabel",
rule: ToElement(CASE) + expression + ToElement(COLON)
| ToElement(DEFAULT_COLON) + ToElement(COLON),
createNode: node =>
{
var result = new SwitchCaseLabel();
result.CaseKeyword = (AstToken) node.Children[0].Result;
if (node.Children.Count > 2)
result.Condition = (Expression) node.Children[1].Result;
result.Colon = (AstToken) node.Children[node.Children.Count - 1].Result;
return result;
});
var switchLabels = new GrammarDefinition("SwitchLabels");
switchLabels.Rule = switchLabel | switchLabels + switchLabel;
var switchSection = new GrammarDefinition("SwitchSection",
rule: switchLabels + statementList,
createNode: node =>
{
var result = new SwitchSection();
result.Labels.AddRange(node.Children[0].GetAllListAstNodes<SwitchCaseLabel>());
result.Statements.AddRange(node.Children[1].GetAllListAstNodes<Statement>());
return result;
});
var switchSections = new GrammarDefinition("SwitchSections");
switchSections.Rule = switchSection
| switchSections + switchSection;
var switchBlock = new GrammarDefinition("SwitchBlock",
rule: ToElement(OPEN_BRACE)
+ switchSections
+ ToElement(CLOSE_BRACE));
var switchStatement = new GrammarDefinition("SwitchStatement",
rule: ToElement(SWITCH)
+ ToElement(OPEN_PARENS)
+ expression
+ ToElement(CLOSE_PARENS)
+ switchBlock,
createNode: node =>
{
var result = new SwitchStatement();
result.SwitchKeyword = (AstToken) node.Children[0].Result;
result.LeftParenthese = (AstToken) node.Children[1].Result;
result.Condition = (Expression) node.Children[2].Result;
result.RightParenthese = (AstToken) node.Children[3].Result;
var switchBlockNode = node.Children[4];
result.StartScope = switchBlockNode.Children[0].Result;
result.Sections.AddRange(switchBlockNode.Children[1].GetAllListAstNodes<SwitchSection>());
result.EndScope = switchBlockNode.Children[2].Result;
return result;
});
var selectionStatement = new GrammarDefinition("SelectionStatement",
rule: ifElseStatement
| switchStatement);
var whileLoopStatement = new GrammarDefinition("WhileLoopStatement",
rule: ToElement(WHILE)
+ parenthesizedExpression
+ embeddedStatement,
createNode: node =>
{
var bodyNode = node.Children[2];
CheckForPossibleMistakenEmptyStatement(bodyNode);
var conditionExpr = (ParenthesizedExpression) node.Children[1].Result;
return new WhileLoopStatement
{
WhileKeyword = (AstToken) node.Children[0].Result,
LeftParenthese = (AstToken) conditionExpr.LeftParenthese.Remove(),
Condition = (Expression) conditionExpr.Expression.Remove(),
RightParenthese = (AstToken) conditionExpr.RightParenthese.Remove(),
Body = (Statement) bodyNode.Result
};
});
var doLoopStatement = new GrammarDefinition("DoLoopStatement",
rule: ToElement(DO)
+ embeddedStatement
+ ToElement(WHILE)
+ parenthesizedExpression
+ ToElement(SEMICOLON),
createNode: node =>
{
var conditionExpr = (ParenthesizedExpression) node.Children[3].Result;
return new DoLoopStatement
{
DoKeyword = (AstToken) node.Children[0].Result,
Body = (Statement) node.Children[1].Result,
WhileKeyword = (AstToken) node.Children[2].Result,
LeftParenthese = (AstToken) conditionExpr.LeftParenthese.Remove(),
Condition = (Expression) conditionExpr.Expression.Remove(),
RightParenthese = (AstToken) conditionExpr.RightParenthese.Remove(),
Semicolon = (AstToken) node.Children[4].Result
};
});
var forLoopInitializer = new GrammarDefinition("ForLoopInitializer",
rule: variableDeclaration
| null
// TODO: statement-expression-list
);
var forLoopCondition = new GrammarDefinition("ForLoopCondition",
rule: expression
| null);
var forLoopStatement = new GrammarDefinition("ForLoopStatement",
rule: ToElement(FOR)
+ ToElement(OPEN_PARENS)
+ forLoopInitializer
+ ToElement(SEMICOLON)
+ expressionOptional
+ ToElement(SEMICOLON)
+ expressionOptional // TODO: statement-expression-list
+ ToElement(CLOSE_PARENS)
+ embeddedStatement,
createNode: node =>
{
var result = new ForLoopStatement();
result.ForKeyword = (AstToken) node.Children[0].Result;
result.LeftParenthese = (AstToken) node.Children[1].Result;
if (node.Children[2].HasChildren)
{
var declaration = node.Children[2].Children[0].Result as VariableDeclarationStatement;
if (declaration != null)
{
result.Initializers.Add(declaration);
}
else
{
result.Initializers.AddRange(node.Children[2].GetAllListAstNodes<Expression>()
.Select(x => new ExpressionStatement(x)));
}
}
result.AddChild(AstNodeTitles.Semicolon, node.Children[3].Result);
if (node.Children[4].HasChildren)
result.Condition = (Expression) node.Children[4].Result;
result.AddChild(AstNodeTitles.Semicolon, node.Children[5].Result);
if (node.Children[6].HasChildren)
{
result.Iterators.AddRange(node.Children[6].Children[0].GetAllListAstNodes<Expression>()
.Select(x => new ExpressionStatement(x)));
}
result.RightParenthese = (AstToken) node.Children[7].Result;
var bodyNode = node.Children[8];
CheckForPossibleMistakenEmptyStatement(bodyNode);
result.Body = (Statement) bodyNode.Result;
return result;
});
var foreachLoopStatement = new GrammarDefinition("ForEachLoopStatement",
rule: ToElement(FOREACH)
+ ToElement(OPEN_PARENS)
+ typeReference
+ identifierInsideBody
+ ToElement(IN)
+ expression
+ ToElement(CLOSE_PARENS)
+ embeddedStatement,
createNode: node =>
{
var bodyNode = node.Children[7];
CheckForPossibleMistakenEmptyStatement(bodyNode);
return new ForeachLoopStatement
{
ForeachKeyword = (AstToken) node.Children[0].Result,
LeftParenthese = (AstToken) node.Children[1].Result,
Type = (TypeReference) node.Children[2].Result,
Identifier = (Identifier) node.Children[3].Result,
InKeyword = (AstToken) node.Children[4].Result,
Target = (Expression) node.Children[5].Result,
RightParenthese = (AstToken) node.Children[6].Result,
Body = (Statement) bodyNode.Result
};
});
var loopStatement = new GrammarDefinition("LoopStatement",
rule: whileLoopStatement
| doLoopStatement
| forLoopStatement
| foreachLoopStatement);
var lockStatement = new GrammarDefinition("LockStatement",
rule: ToElement(LOCK)
+ ToElement(OPEN_PARENS)
+ expression
+ ToElement(CLOSE_PARENS)
+ statement,
createNode: node =>
{
var bodyNode = node.Children[4];
CheckForPossibleMistakenEmptyStatement(bodyNode);
return new LockStatement
{
LockKeyword = (AstToken) node.Children[0].Result,
LeftParenthese = (AstToken) node.Children[1].Result,
LockObject = (Expression) node.Children[2].Result,
RightParenthese = (AstToken) node.Children[3].Result,
Body = (Statement) bodyNode.Result
};
});
var resourceAcquisition = new GrammarDefinition("ResourceAcquisition",
rule: variableDeclaration | expression);
var usingStatement = new GrammarDefinition("UsingStatement",
rule: ToElement(USING)
+ ToElement(OPEN_PARENS)
+ resourceAcquisition
+ ToElement(CLOSE_PARENS)
+ statement,
createNode: node =>
{
var bodyNode = node.Children[4];
CheckForPossibleMistakenEmptyStatement(bodyNode);
return new UsingStatement()
{
UsingKeyword = (AstToken) node.Children[0].Result,
LeftParenthese = (AstToken) node.Children[1].Result,
DisposableObject = node.Children[2].Result,
RightParenthese = (AstToken) node.Children[3].Result,
Body = (Statement) bodyNode.Result
};
});
var breakStatement = new GrammarDefinition("BreakStatement",
rule: ToElement(BREAK)
+ ToElement(SEMICOLON),
createNode: node => new BreakStatement()
{
Keyword = (AstToken) node.Children[0].Result,
Semicolon = (AstToken) node.Children[1].Result
});
var continueStatement = new GrammarDefinition("ContinueStatement",
rule: ToElement(CONTINUE)
+ ToElement(SEMICOLON),
createNode: node => new BreakStatement()
{
Keyword = (AstToken) node.Children[0].Result,
Semicolon = (AstToken) node.Children[1].Result
});
var returnStatement = new GrammarDefinition("ReturnStatement",
rule: ToElement(RETURN)
+ expressionOptional
+ ToElement(SEMICOLON),
createNode: node =>
{
var result = new ReturnStatement();
result.ReturnKeyword = (AstToken) node.Children[0].Result;
if (node.Children[1].HasChildren)
result.Value = (Expression) node.Children[1].Result;
result.AddChild(AstNodeTitles.Semicolon, node.Children[2].Result);
return result;
});
var throwStatement = new GrammarDefinition("ThrowStatement",
rule: ToElement(THROW)
+ expressionOptional
+ ToElement(SEMICOLON),
createNode: node =>
{
var result = new ThrowStatement();
result.ThrowKeyword = (AstToken) node.Children[0].Result;
if (node.Children[1].HasChildren)
result.Expression = (Expression) node.Children[1].Result;
result.AddChild(AstNodeTitles.Semicolon, node.Children[2].Result);
return result;
});
var gotoStatement = new GrammarDefinition("GotoStatement",
rule: ToElement(GOTO)
+ identifierInsideBody
+ ToElement(SEMICOLON),
// TODO: goto case and goto default statements.
createNode: node =>
{
var result = new GotoStatement();
result.GotoKeyword = (AstToken) node.Children[0].Result;
result.LabelIdentifier = (Identifier) node.Children[1].Result;
result.AddChild(AstNodeTitles.Semicolon, node.Children[2].Result);
return result;
});
var jumpStatement = new GrammarDefinition("JumpStatement",
rule: breakStatement
| continueStatement
| gotoStatement
| returnStatement
| throwStatement);
var yieldStatement = new GrammarDefinition("YieldStatement",
rule: ToElement(YIELD)
+ ToElement(RETURN)
+ expression
+ ToElement(SEMICOLON),
createNode: node => new YieldStatement()
{
YieldKeyword = (AstToken) node.Children[0].Result,
ReturnKeyword = (AstToken) node.Children[1].Result,
Value = (Expression) node.Children[2].Result
});
var yieldBreakStatement = new GrammarDefinition("YieldBreakStatement",
rule: ToElement(YIELD)
+ ToElement(BREAK)
+ ToElement(SEMICOLON),
createNode: node => new YieldBreakStatement()
{
Keyword = (AstToken) node.Children[0].Result,
BreakKeyword = (AstToken) node.Children[1].Result
});
var specificCatchClause = new GrammarDefinition("SpecificCatchClause",
rule: ToElement(CATCH) + ToElement(OPEN_PARENS)
+ namespaceOrTypeExpression + identifierInsideBodyOptional + ToElement(CLOSE_PARENS)
+ blockStatement,
createNode: node =>
{
var result = new CatchClause();
result.CatchKeyword = (AstToken) node.Children[0].Result;
result.LeftParenthese = (AstToken) node.Children[1].Result;
result.ExceptionType = (TypeReference) node.Children[2].Result;
if (node.Children[3].HasChildren)
result.ExceptionIdentifier = (Identifier) node.Children[3].Result;
result.RightParenthese = (AstToken) node.Children[4].Result;
result.Body = (BlockStatement) node.Children[5].Result;
return result;
});
var generalCatchClause = new GrammarDefinition("GeneralCatchClause",
rule: ToElement(CATCH) + blockStatement,
createNode: node => new CatchClause
{
CatchKeyword = (AstToken) node.Children[0].Result,
Body = (BlockStatement) node.Children[1].Result
});
var catchClause = new GrammarDefinition("CatchClause",
rule: specificCatchClause | generalCatchClause);
var catchClauses = new GrammarDefinition("CatchClauses");
catchClauses.Rule = catchClause | catchClauses + catchClause;
var finallyClause = new GrammarDefinition("FinallyClause",
rule: ToElement(FINALLY) + blockStatement);
var tryCatchStatement = new GrammarDefinition("TryCatchStatement",
rule: ToElement(TRY) + blockStatement + catchClauses
| ToElement(TRY) + blockStatement + finallyClause
| ToElement(TRY) + blockStatement + catchClauses + finallyClause,
createNode: node =>
{
var result = new TryCatchStatement();
result.TryKeyword = (AstToken) node.Children[0].Result;
result.TryBlock = (BlockStatement) node.Children[1].Result;
ParserNode finallyClauseNode = null;
if (node.Children[2].GrammarElement == finallyClause)
{
finallyClauseNode = node.Children[2];
}
else
{
result.CatchClauses.AddRange(node.Children[2].GetAllListAstNodes<CatchClause>());
}
if (node.Children.Count == 4)
finallyClauseNode = node.Children[3];
if (finallyClauseNode != null)
{
result.FinallyKeyword = (AstToken) finallyClauseNode.Children[0].Result;
result.FinallyBlock = (BlockStatement) finallyClauseNode.Children[1].Result;
}
return result;
});
var unsafeStatement = new GrammarDefinition("UnsafeStatement",
rule: ToElement(UNSAFE) + blockStatement,
createNode: node => new UnsafeStatement()
{
Keyword = (AstToken) node.Children[0].Result,
Body = (BlockStatement) node.Children[1].Result
});
var fixedStatement = new GrammarDefinition("FixedStatement",
rule: ToElement(FIXED) + ToElement(OPEN_PARENS)
+ variableDeclaration + ToElement(CLOSE_PARENS) + embeddedStatement,
createNode: node =>
{
var result = new FixedStatement();
result.Keyword = (AstToken) node.Children[0].Result;
result.LeftParenthese = (AstToken) node.Children[1].Result;
result.VariableDeclaration = (VariableDeclarationStatement) node.Children[2].Result;
result.RightParenthese = (AstToken) node.Children[3].Result;
var bodyNode = node.Children[4];
result.Body = (Statement) bodyNode.Result;
CheckForPossibleMistakenEmptyStatement(bodyNode);
return result;
});
embeddedStatement.Rule = emptyStatement
| expressionStatement
| blockStatement
| selectionStatement
| loopStatement
| jumpStatement
| lockStatement
| usingStatement
| yieldStatement
| yieldBreakStatement
| tryCatchStatement
| unsafeStatement
| fixedStatement
;
statement.Rule = variableDeclarationStatement
| labelStatement
| embeddedStatement;
;
#endregion
#region Members
var customAttribute = new GrammarDefinition("CustomAttribute",
rule: namespaceOrTypeExpression
| namespaceOrTypeExpression + ToElement(OPEN_PARENS) + argumentListOptional + ToElement(CLOSE_PARENS),
createNode: node =>
{
var result = new CustomAttribute();
result.Type = ((IConvertibleToType) node.Children[0].Result).ToTypeReference();
if (node.Children.Count > 1)
{
result.LeftParenthese = (AstToken) node.Children[1].Result;
if (node.Children[2].HasChildren)
{
foreach (var child in node.Children[2].Children[0].GetAllListAstNodes())
{
if (child is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, child);
else
result.Arguments.Add((Expression) child);
}
}
result.RightParenthese = (AstToken) node.Children[3].Result;
}
return result;
});
var customAttributeList = new GrammarDefinition("CustomAttributeList");
customAttributeList.Rule = customAttribute | customAttributeList + ToElement(COMMA) + customAttribute;
var customAttributePrefix = new GrammarDefinition("CustomAttributePrefix",
rule: ToElement(ASSEMBLY) | ToElement(MODULE));
var customAttributePrefixOptional = new GrammarDefinition("CustomAttributePrefixOptional",
rule: null | customAttributePrefix + ToElement(COLON));
var customAttributeSection = new GrammarDefinition("CustomAttributeSection",
rule: ToElement(OPEN_BRACKET_EXPR) // HACK: use expression brackets instead to avoid conflicts.
+ customAttributePrefixOptional
+ customAttributeList
+ ToElement(CLOSE_BRACKET),
createNode: node =>
{
var result = new CustomAttributeSection();
result.LeftBracket = (AstToken) node.Children[0].Result;
if (node.Children[1].Result != null)
{
result.VariantKeyword = (AstToken) node.Children[1].Result;
result.Variant = CSharpLanguage.SectionVariantFromString(result.VariantKeyword.Value);
}
foreach (var child in node.Children[2].GetAllListAstNodes())
{
if (child is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, child);
else
result.Attributes.Add((CustomAttribute) child);
}
result.RightBracket = (AstToken) node.Children[3].Result;
return result;
});
var customAttributeSectionList = new GrammarDefinition("CustomAttributeSectionList");
customAttributeSectionList.Rule = customAttributeSection | customAttributeSectionList + customAttributeSection;
var customAttributeSectionListOptional = new GrammarDefinition("CustomAttributeSectionListOptional",
rule: null | customAttributeSectionList);
var modifier = new GrammarDefinition("Modifier",
rule: ToElement(PRIVATE)
| ToElement(PROTECTED)
| ToElement(INTERNAL)
| ToElement(PUBLIC)
| ToElement(STATIC)
| ToElement(ABSTRACT)
| ToElement(OVERRIDE)
| ToElement(PARTIAL)
| ToElement(CONST)
| ToElement(READONLY)
| ToElement(VIRTUAL)
| ToElement(SEALED)
| ToElement(UNSAFE)
| ToElement(FIXED)
| ToElement(ASYNC)
| ToElement(EXTERN),
createNode: node => new ModifierElement(((AstToken) node.Children[0].Result).Value, node.Children[0].Range)
{
Modifier = CSharpLanguage.ModifierFromString(((AstToken) node.Children[0].Result).Value)
});
var modifierList = new GrammarDefinition("ModifierList");
modifierList.Rule = modifier | modifierList + modifier;
var modifierListOptional = new GrammarDefinition("ModifierListOptional",
rule: null | modifierList);
var fieldDeclaration = new GrammarDefinition("FieldDeclaration",
rule: customAttributeSectionListOptional
+ modifierListOptional
+ typeReference
+ variableDeclaratorList
+ ToElement(SEMICOLON),
createNode: node =>
{
var result = new FieldDeclaration();
if (node.Children[0].HasChildren)
result.CustomAttributeSections.AddRange(node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
if (node.Children[1].HasChildren)
result.ModifierElements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<ModifierElement>());
result.FieldType = (TypeReference) node.Children[2].Result;
foreach (var subNode in node.Children[3].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Declarators.Add((VariableDeclarator) subNode);
}
result.AddChild(AstNodeTitles.Semicolon, node.Children[4].Result);
return result;
});
var parameterModifier = new GrammarDefinition("ParameterModifier",
rule: null
| ToElement(THIS)
| ToElement(REF)
| ToElement(OUT)
| ToElement(PARAMS));
var parameterDeclaration = new GrammarDefinition("ParameterDeclaration",
rule: customAttributeSectionListOptional
+ parameterModifier
+ typeReference
+ variableDeclarator,
createNode: node =>
{
var result = new ParameterDeclaration();
if (node.Children[0].HasChildren)
{
result.CustomAttributeSections.AddRange(
node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
}
result.ParameterModifierToken = (AstToken) (node.Children[1].HasChildren ? node.Children[1].Children[0].Result : null);
result.ParameterType = (TypeReference) node.Children[2].Result;
result.Declarator = (VariableDeclarator) node.Children[3].Result;
return result;
});
var parameterDeclarationList = new GrammarDefinition("ParameterDeclarationList");
parameterDeclarationList.Rule = parameterDeclaration | parameterDeclarationList + ToElement(COMMA) + parameterDeclaration;
var optionalParameterDeclarationList = new GrammarDefinition("OptionalParameterDeclarationList",
rule: null | parameterDeclarationList);
var constructorInitializerVariant = new GrammarDefinition("ConstructorInitializerVariant",
rule: ToElement(THIS) | ToElement(BASE));
var constructorInitializer = new GrammarDefinition("ConstructorInitializer",
rule: constructorInitializerVariant
+ ToElement(OPEN_PARENS)
+ argumentListOptional
+ ToElement(CLOSE_PARENS),
createNode: node =>
{
var result = new Members.ConstructorInitializer();
result.VariantToken = (AstToken) node.Children[0].Children[0].Result;
result.LeftParenthese = (AstToken) node.Children[1].Result;
if (node.Children[2].HasChildren)
{
foreach (var subNode in node.Children[2].Children[0].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Arguments.Add((Expression) subNode);
}
}
result.RightParenthese = (AstToken) node.Children[3].Result;
return result;
});
var optionalConstructorInitializerList = new GrammarDefinition("OptionalConstructorInitializer",
rule: null | ToElement(COLON) + constructorInitializer);
var constructorDeclaration = new GrammarDefinition("ConstructorDeclaration",
rule: customAttributeSectionListOptional
+ modifierListOptional
+ ToElement(IDENTIFIER)
+ ToElement(OPEN_PARENS)
+ optionalParameterDeclarationList
+ ToElement(CLOSE_PARENS)
+ optionalConstructorInitializerList
+ blockStatement,
createNode: node =>
{
var result = new Members.ConstructorDeclaration();
if (node.Children[0].HasChildren)
result.CustomAttributeSections.AddRange(node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
if (node.Children[1].HasChildren)
result.ModifierElements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<ModifierElement>());
result.Identifier = ToIdentifier(node.Children[2].Result);
result.LeftParenthese = (AstToken) node.Children[3].Result;
if (node.Children[4].HasChildren)
{
foreach (var subNode in node.Children[4].Children[0].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Parameters.Add((ParameterDeclaration) subNode);
}
}
result.RightParenthese = (AstToken) node.Children[5].Result;
if (node.Children[6].HasChildren)
{
result.Colon = (AstToken) node.Children[6].Children[0].Result;
result.Initializer = (Members.ConstructorInitializer) node.Children[6].Children[1].Result;
}
result.Body = (BlockStatement) node.Children[7].Result;
return result;
});
var conversionOperator = new GrammarDefinition("ConversionOperator",
rule: ToElement(IMPLICIT)
| ToElement(EXPLICIT));
var conversionOperatorDeclaration = new GrammarDefinition("ConversionOperatorDeclaration",
rule: customAttributeSectionListOptional
+ modifierListOptional
+ conversionOperator
+ ToElement(OPERATOR)
+ ToElement(IDENTIFIER)
+ ToElement(OPEN_PARENS)
+ optionalParameterDeclarationList
+ ToElement(CLOSE_PARENS)
+ blockStatement,
createNode: node =>
{
var result = new OperatorDeclaration();
if (node.Children[0].HasChildren)
result.CustomAttributeSections.AddRange(node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
if (node.Children[1].HasChildren)
result.ModifierElements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<ModifierElement>());
result.Identifier = ToIdentifier(node.Children[2].Result);
result.OperatorType = CSharpLanguage.OperatorDeclarationTypeFromString(result.Identifier.Name);
result.OperatorKeyword = (AstToken) node.Children[3].Result;
result.ReturnType = ToTypeReference(ToIdentifier(node.Children[4].Result));
result.LeftParenthese = (AstToken)node.Children[5].Result;
if (node.Children[6].HasChildren)
{
foreach (var subNode in node.Children[6].Children[0].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Parameters.Add((ParameterDeclaration)subNode);
}
}
result.RightParenthese = (AstToken) node.Children[7].Result;
result.Body = (BlockStatement) node.Children[8].Result;
return result;
});
var overloadableOperator = new GrammarDefinition("OverloadableOperator",
rule: ToElement(PLUS)
| ToElement(MINUS)
| ToElement(STAR)
| ToElement(DIV)
| ToElement(PERCENT)
| ToElement(BITWISE_AND)
| ToElement(BITWISE_OR)
| ToElement(CARRET)
| ToElement(OP_EQUALS)
| ToElement(OP_NOTEQUALS)
| ToElement(OP_GT)
| ToElement(OP_GE)
| ToElement(OP_LT)
| ToElement(OP_LE)
| ToElement(OP_SHIFT_LEFT)
| ToElement(OP_SHIFT_RIGHT)
| ToElement(TRUE)
| ToElement(FALSE)
| ToElement(BANG)
| ToElement(TILDE)
| ToElement(OP_INC)
| ToElement(OP_DEC));
var arithmeticOperatorDeclaration = new GrammarDefinition("ArithmeticOperatorDeclaration",
rule: customAttributeSectionListOptional
+ modifierListOptional
+ typeReference
+ ToElement(OPERATOR)
+ overloadableOperator
+ ToElement(OPEN_PARENS)
+ optionalParameterDeclarationList
+ ToElement(CLOSE_PARENS)
+ blockStatement,
createNode: node =>
{
var result = new OperatorDeclaration();
if (node.Children[0].HasChildren)
result.CustomAttributeSections.AddRange(node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
if (node.Children[1].HasChildren)
result.ModifierElements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<ModifierElement>());
result.ReturnType = (TypeReference) node.Children[2].Result;
result.OperatorKeyword = (AstToken)node.Children[3].Result;
result.Identifier = ToIdentifier(node.Children[4].Result);
result.LeftParenthese = (AstToken)node.Children[5].Result;
if (node.Children[6].HasChildren)
{
foreach (var subNode in node.Children[6].Children[0].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Parameters.Add((ParameterDeclaration)subNode);
}
}
result.RightParenthese = (AstToken)node.Children[7].Result;
result.OperatorType = CSharpLanguage.OperatorDeclarationTypeFromString(result.Identifier.Name);
if (result.Parameters.Count == 2)
{
if (result.OperatorType == OperatorDeclarationType.Positive)
result.OperatorType = OperatorDeclarationType.Add;
else if (result.OperatorType == OperatorDeclarationType.Negative)
result.OperatorType = OperatorDeclarationType.Subtract;
}
result.Body = (BlockStatement)node.Children[8].Result;
return result;
});
var operatorDeclaration = new GrammarDefinition("OperatorDeclaration",
rule: conversionOperatorDeclaration | arithmeticOperatorDeclaration);
var methodDeclarationBody = new GrammarDefinition("MethodDeclarationBody",
rule: ToElement(SEMICOLON) | blockStatement);
var methodDeclaration = new GrammarDefinition("MethodDeclaration",
rule: customAttributeSectionListOptional
+ modifierListOptional
+ typeReference
+ ToElement(IDENTIFIER)
+ ToElement(OPEN_PARENS)
+ optionalParameterDeclarationList
+ ToElement(CLOSE_PARENS)
+ methodDeclarationBody,
createNode: node =>
{
var result = new MethodDeclaration();
if (node.Children[0].HasChildren)
result.CustomAttributeSections.AddRange(node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
if (node.Children[1].HasChildren)
result.ModifierElements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<ModifierElement>());
result.ReturnType = (TypeReference) node.Children[2].Result;
result.Identifier = ToIdentifier(node.Children[3].Result);
result.LeftParenthese = (AstToken) node.Children[4].Result;
if (node.Children[5].HasChildren)
{
foreach (var subNode in node.Children[5].Children[0].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Parameters.Add((ParameterDeclaration) subNode);
}
}
result.RightParenthese = (AstToken) node.Children[6].Result;
var body = node.Children[7].Result;
if (body is AstToken)
result.AddChild(AstNodeTitles.Semicolon, (AstToken) body);
else
result.Body = (BlockStatement) body;
return result;
});
var eventDeclaration = new GrammarDefinition("EventDeclaration",
rule: customAttributeSectionListOptional
+ modifierListOptional
+ ToElement(EVENT)
+ typeReference
+ variableDeclaratorList
+ ToElement(SEMICOLON),
createNode: node =>
{
var result = new EventDeclaration();
if (node.Children[0].HasChildren)
result.CustomAttributeSections.AddRange(node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
if (node.Children[1].HasChildren)
result.ModifierElements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<ModifierElement>());
result.EventKeyword = (AstToken) node.Children[2].Result;
result.EventType = (TypeReference) node.Children[3].Result;
foreach (var subNode in node.Children[4].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Declarators.Add((VariableDeclarator) subNode);
}
result.AddChild(AstNodeTitles.Semicolon, node.Children[5].Result);
return result;
});
var accessorKeyword = new GrammarDefinition("AccessorKeyword",
rule: ToElement(GET)
| ToElement(SET));
var accessorBody = new GrammarDefinition("AccessorBody",
rule: ToElement(SEMICOLON)
| blockStatement);
var accessorDeclaration = new GrammarDefinition("AccessorDeclaration",
rule: customAttributeSectionListOptional
+ modifierListOptional
+ accessorKeyword
+ accessorBody,
createNode: node =>
{
var result = new AccessorDeclaration();
if (node.Children[0].HasChildren)
result.CustomAttributeSections.AddRange(node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
if (node.Children[1].HasChildren)
result.ModifierElements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<ModifierElement>());
result.AccessorKeyword = (AstToken) node.Children[2].Children[0].Result;
var bodyNode = node.Children[3].Children[0].Result;
if (bodyNode is AstToken)
result.AddChild(AstNodeTitles.Semicolon, bodyNode);
else
result.Body = (BlockStatement) bodyNode;
return result;
});
var accessorDeclarationList = new GrammarDefinition("AccessorDeclarationList");
accessorDeclarationList.Rule = accessorDeclaration | accessorDeclaration + accessorDeclaration;
var propertyDeclaration = new GrammarDefinition("PropertyDeclaration",
rule: customAttributeSectionListOptional
+ modifierListOptional
+ typeReference
+ ToElement(IDENTIFIER)
+ ToElement(OPEN_BRACE)
+ accessorDeclarationList
+ ToElement(CLOSE_BRACE),
createNode: node =>
{
var result = new PropertyDeclaration();
if (node.Children[0].HasChildren)
result.CustomAttributeSections.AddRange(node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
if (node.Children[1].HasChildren)
result.ModifierElements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<ModifierElement>());
result.PropertyType = (TypeReference) node.Children[2].Result;
result.Identifier = ToIdentifier(node.Children[3].Result);
result.StartScope = node.Children[4].Result;
foreach (var accessor in node.Children[5].Children)
{
var declaration = (AccessorDeclaration) accessor.Result;
// TODO: detect duplicate accessor declarations.
switch (declaration.AccessorKeyword.Value)
{
case "get":
result.Getter = declaration;
break;
case "set":
result.Setter = declaration;
break;
}
}
result.EndScope = node.Children[6].Result;
return result;
});
var memberDeclaration = new GrammarDefinition("MemberDeclaration");
var memberDeclarationList = new GrammarDefinition("MemberDeclarationList");
memberDeclarationList.Rule = memberDeclaration | memberDeclarationList + memberDeclaration;
var memberDeclarationListOptional = new GrammarDefinition("MemberDeclarationListOptional");
memberDeclarationListOptional.Rule = null | memberDeclarationList;
var baseTypeList = new GrammarDefinition("BaseTypeList");
baseTypeList.Rule = typeReference | baseTypeList + ToElement(COMMA) + typeReference;
var optionalBaseTypeList = new GrammarDefinition("OptionalBaseTypeList");
optionalBaseTypeList.Rule = null | ToElement(COLON) + baseTypeList;
var typeVariantKeyword = new GrammarDefinition("TypeVariantKeyword",
rule: ToElement(CLASS)
| ToElement(STRUCT)
| ToElement(INTERFACE)
| ToElement(ENUM));
var typeDeclaration = new GrammarDefinition("TypeDeclaration",
rule: customAttributeSectionListOptional
+ modifierListOptional
+ typeVariantKeyword
+ ToElement(IDENTIFIER)
+ optionalBaseTypeList
+ ToElement(OPEN_BRACE)
+ memberDeclarationListOptional
+ ToElement(CLOSE_BRACE),
createNode: node =>
{
var result = new TypeDeclaration();
if (node.Children[0].HasChildren)
result.CustomAttributeSections.AddRange(node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
if (node.Children[1].HasChildren)
result.ModifierElements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<ModifierElement>());
var variantToken = (AstToken) node.Children[2].Children[0].Result;
result.TypeVariant = CSharpLanguage.TypeVariantFromString(variantToken.Value);
result.TypeVariantToken = variantToken;
result.Identifier = ToIdentifier(node.Children[3].Result);
if (node.Children[4].HasChildren)
{
result.AddChild(AstNodeTitles.Colon, node.Children[4].Children[0].Result);
foreach (var child in node.Children[4].Children[1].GetAllListAstNodes())
{
if (child is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, child);
else
result.BaseTypes.Add((TypeReference) child);
}
}
result.StartScope = node.Children[5].Result;
if (node.Children[6].HasChildren)
{
result.Members.AddRange(node.Children[6].Children[0].GetAllListAstNodes<MemberDeclaration>());
}
result.EndScope = node.Children[7].Result;
return result;
});
memberDeclaration.Rule = methodDeclaration
| constructorDeclaration
| operatorDeclaration
| propertyDeclaration
| eventDeclaration
| fieldDeclaration
| typeDeclaration
;
var typeOrNamespaceDeclarationList = new GrammarDefinition("TypeOrNamespaceDeclarationList");
var typeOrNamespaceDeclarationListOptional = new GrammarDefinition("TypeOrNamespaceDeclarationListOptional",
rule: null | typeOrNamespaceDeclarationList);
var namespaceDeclaration = new GrammarDefinition("NamespaceDeclaration",
rule: ToElement(NAMESPACE)
+ typeNameExpression
+ ToElement(OPEN_BRACE)
+ usingDirectiveListOptional
+ typeOrNamespaceDeclarationListOptional
+ ToElement(CLOSE_BRACE),
createNode: node =>
{
var result = new NamespaceDeclaration();
result.Keyword = (AstToken) node.Children[0].Result;
result.Identifier = ((IConvertibleToIdentifier) node.Children[1].Result).ToIdentifier();
result.StartScope = node.Children[2].Result;
if (node.Children[3].HasChildren)
{
result.UsingDirectives.AddRange(node.Children[3].Children[0].GetAllListAstNodes<UsingDirective>());
}
if (node.Children[4].HasChildren)
{
foreach (var subNode in node.Children[4].Children[0].GetAllListAstNodes())
{
var type = subNode as TypeDeclaration;
if (type != null)
result.Types.Add(type);
else
result.Namespaces.Add((NamespaceDeclaration) subNode);
}
}
result.EndScope = node.Children[5].Result;
return result;
});
var typeOrNamespaceDeclaration = new GrammarDefinition("TypeOrNamespaceDeclaration",
rule: namespaceDeclaration
| typeDeclaration);
typeOrNamespaceDeclarationList.Rule = typeOrNamespaceDeclaration
| typeOrNamespaceDeclarationList
+ typeOrNamespaceDeclaration;
#endregion
#region Initialize definitions
var variableInitializerList = new GrammarDefinition("VariableInitializerList");
variableInitializerList.Rule = variableInitializer
| variableInitializerList
+ ToElement(COMMA)
+ variableInitializer;
var variableInitializerListOptional = new GrammarDefinition("VariableInitializerListOptional",
rule: null | variableInitializerList);
arrayInitializer.Rule = ToElement(OPEN_BRACE)
+ variableInitializerListOptional
+ ToElement(CLOSE_BRACE)
| ToElement(OPEN_BRACE)
+ variableInitializerList
+ ToElement(COMMA)
+ ToElement(CLOSE_BRACE);
arrayInitializer.ComputeResult = node =>
{
var result = new ArrayInitializer();
result.OpeningBrace = node.Children[0].Result;
ParserNode initializersNode = null;
if (node.Children.Count == 4)
{
initializersNode = node.Children[1];
}
else
{
if (node.Children[1].HasChildren)
initializersNode = node.Children[1].Children[0];
}
if (initializersNode != null)
{
foreach (var element in initializersNode.GetAllListAstNodes())
{
if (element is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, element);
else
result.Elements.Add((Expression) element);
}
}
if (node.Children.Count == 4)
result.AddChild(AstNodeTitles.ElementSeparator, node.Children[2].Result);
result.ClosingBrace = node.Children[node.Children.Count - 1].Result;
return result;
};
variableInitializer.Rule = expression
| arrayInitializer
;
var variableType = new GrammarDefinition("VariableType");
variableType.Rule = typeNameExpression | variableType + rankSpecifier | variableType + ToElement(STAR);
variableType.ComputeResult = node =>
{
var type = ToTypeReference((IConvertibleToType) node.Children[0].Result);
if (node.Children.Count > 1)
{
var specifier = node.Children[1].Result as ArrayTypeRankSpecifier;
if (specifier != null)
{
type = new ArrayTypeReference(type, specifier);
}
else
{
type = new PointerTypeReference(type)
{
PointerToken = (AstToken) node.Children[1].Result
};
}
}
return type;
};
// Types are recognized as expressions to prevent a conflict in the grammar.
// TODO: also support array and pointer types.
variableDeclaration.Rule =
variableType
+ variableDeclaratorList;
variableDeclaration.ComputeResult = node =>
{
var result = new VariableDeclarationStatement();
result.VariableType = ToTypeReference((IConvertibleToType)node.Children[0].Result);
foreach (var subNode in node.Children[1].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Declarators.Add((VariableDeclarator) subNode);
}
return result;
};
statementList.Rule = statement | statementList + statement;
#endregion
#region Root compilation unit
var usingNamespaceDirective = new GrammarDefinition("UsingNamespaceDirective",
rule: ToElement(USING)
+ namespaceOrTypeExpression
+ ToElement(SEMICOLON),
createNode: node =>
{
var result = new UsingNamespaceDirective();
result.UsingKeyword = (AstToken) node.Children[0].Result;
result.NamespaceIdentifier = ((IConvertibleToIdentifier) node.Children[1].Result).ToIdentifier();
result.AddChild(AstNodeTitles.Semicolon, node.Children[2].Result);
return result;
});
var usingAliasDirective = new GrammarDefinition("UsingAliasDirective",
rule: ToElement(USING)
+ ToElement(IDENTIFIER)
+ ToElement(EQUALS)
+ typeReference
+ ToElement(SEMICOLON),
createNode: node =>
{
var result = new UsingAliasDirective
{
UsingKeyword = (AstToken) node.Children[0].Result,
AliasIdentifier = ToIdentifier(node.Children[1].Result),
OperatorToken = (AstToken) node.Children[2].Result,
TypeImport = (TypeReference) node.Children[3].Result
};
result.AddChild(AstNodeTitles.Semicolon, node.Children[4].Result);
return result;
});
var usingDirective = new GrammarDefinition("UsingNamespaceDirective",
rule: usingNamespaceDirective | usingAliasDirective);
var usingDirectiveList = new GrammarDefinition("UsingDirectiveList");
usingDirectiveList.Rule = usingDirective | usingDirectiveList + usingDirective;
usingDirectiveListOptional.Rule = null | usingDirectiveList;
var compilationUnit = new GrammarDefinition("CompilationUnit",
rule: usingDirectiveListOptional
+ typeOrNamespaceDeclarationListOptional,
createNode: node =>
{
var result = new CompilationUnit();
if (node.Children[0].HasChildren)
{
result.UsingDirectives.AddRange(node.Children[0].Children[0].GetAllListAstNodes<UsingDirective>());
}
if (node.Children[1].HasChildren)
{
foreach (var subNode in node.Children[1].Children[0].GetAllListAstNodes())
{
var typeDecl = subNode as TypeDeclaration;
if (typeDecl == null)
result.Namespaces.Add((NamespaceDeclaration) subNode);
else
result.Types.Add(typeDecl);
}
}
return result;
});
#endregion
RootDefinitions.Add(DefaultRoot = compilationUnit);
RootDefinitions.Add(MemberDeclarationRule = memberDeclaration);
RootDefinitions.Add(StatementRule = statement);
}
public override object Visit (Goto gotoStatement)
{
var result = new GotoStatement ();
var location = LocationsBag.GetLocations (gotoStatement);
result.AddChild (new CSharpTokenNode (Convert (gotoStatement.loc), "goto".Length), GotoStatement.Roles.Keyword);
var loc = location != null ? Convert (location [0]) : AstLocation.Empty;
result.AddChild (Identifier.Create (gotoStatement.Target, loc), GotoStatement.Roles.Identifier);
if (location != null)
result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), GotoStatement.Roles.Semicolon);
return result;
}
public void AcceptGoto(GotoStatement stmt)
{
}
public void VisitGotoStatement(GotoStatement statement)
{
Formatter.StartNode(statement);
Formatter.WriteKeyword("goto");
Formatter.WriteSpace();
statement.LabelIdentifier.AcceptVisitor(this);
WriteSemicolon();
Formatter.EndNode();
}
public void AcceptGoto(GotoStatement stmt)
{
IsEmpty = false;
}
private void Process_Goto_Statement(StringBuilder sb, GotoStatement statement)
{
sb.Append("goto ");
if (statement.Identifier != null)
{
sb.Append(statement.Identifier.Text).Append(";");
}
else if (statement.Expression == null)
{
sb.Append("default;");
}
else
{
sb.Append("case ").Append(FormatExpression(statement.Expression)).Append(";");
}
}
public void Visit(GotoStatement gotoStatement)
{
}
public override void AcceptGoto(GotoStatement stmt)
{
Success = false;
}
public override void OnGotoStatement(GotoStatement node)
{
_statements.Add(new CodeGotoStatement(node.Label.Name));
}
public void AcceptGoto(GotoStatement stmt)
{
IsEmpty = false;
}
internal void RegisterGoto(GotoStatement gotostat)
{
m_ScopeTreeHead.RegisterGoto(gotostat);
}
public override void Visit(GotoStatement node)
{
}
public void AcceptGoto(GotoStatement stmt)
{
Check(stmt);
}
public override void Visit(GotoStatement s)
{
if(s.StmtType == GotoStatement.GotoStmtType.Identifier &&
s.LabelIdentifierHash == DTokens.IncompleteIdHash) {
prv = new CtrlSpaceCompletionProvider(cdgen, scopedBlock, s, MemberFilter.Labels);
scopedStatement = s;
halt = true;
}
else
base.Visit (s);
}
public override object VisitGotoStatement(GotoStatement gotoStatement, object data)
{
return(base.VisitGotoStatement(gotoStatement, data));
}
public override void VisitGotoStatement(GotoStatement gotoStatement) {
new GotoBlock(this, gotoStatement).Emit();
}
public override ControlFlowNode VisitGotoStatement(GotoStatement gotoStatement, ControlFlowNode data)
{
builder.gotoStatements.Add(data);
return(builder.CreateEndNode(gotoStatement));
}
public StringBuilder VisitGotoStatement(GotoStatement gotoStatement, int data)
{
throw new SLSharpException("SL# does not support goto.");
}
public void CSharpGotoStatementTest()
{
GotoStatement gotoStmt = ParseUtilCSharp.ParseStatement <GotoStatement>("goto myLabel;");
Assert.AreEqual("myLabel", gotoStmt.Label);
}
public void Visit(GotoStatement expression)
{
outStream.WriteLine("goto {0}", expression.TargetLabel.Name);
}
public void VBNetGotoStatementTest()
{
GotoStatement gotoStmt = ParseUtilVBNet.ParseStatement <GotoStatement>("GoTo myLabel");
Assert.AreEqual("myLabel", gotoStmt.Label);
}
public void VisitGotoStatement(GotoStatement gotoStatement)
{
StartNode(gotoStatement);
WriteKeyword(GotoStatement.GotoKeywordRole);
WriteIdentifier(gotoStatement.GetChildByRole(Roles.Identifier));
Semicolon();
EndNode(gotoStatement);
}
public virtual T VisitGotoStatement(GotoStatement gotoStatement)
{
return(VisitChildren(gotoStatement));
}
public virtual void VisitGotoStatement (GotoStatement gotoStatement)
{
VisitChildren (gotoStatement);
}
override public void LeaveGotoStatement(GotoStatement node)
{
LeaveStatement(node);
}
public void AcceptGoto(GotoStatement stmt)
{
Check(stmt);
}
void GotoStatement(
#line 3119 "VBNET.ATG"
out GotoStatement goToStatement) {
#line 3121 "VBNET.ATG"
string label = String.Empty;
Expect(119);
LabelName(
#line 3124 "VBNET.ATG"
out label);
#line 3126 "VBNET.ATG"
goToStatement = new GotoStatement(label);
}
public override void Visit(GotoStatement node)
{
result = new GotoStatement(node.Target);
}
public override Value Visit(GotoStatement node)
{
BasicBlock label = valuemap.GetValue(node.decl) as BasicBlock;
return(builder.BuildBr(label));
}
protected abstract void VisitGotoStatement(GotoStatement statement);
public override void VisitGotoStatement(GotoStatement gotoStatement)
{
this.Add(gotoStatement);
base.VisitGotoStatement(gotoStatement);
}
IStatement Statement(bool BlocksAllowed = true, bool EmptyAllowed = true, IBlockNode Scope = null, IStatement Parent=null)
{
if (EmptyAllowed && laKind == Semicolon)
{
LastParsedObject = null;
Step();
return null;
}
if (BlocksAllowed && laKind == OpenCurlyBrace)
return BlockStatement(Scope,Parent);
#region LabeledStatement (loc:... goto loc;)
if (laKind == Identifier && Lexer.CurrentPeekToken.Kind == Colon)
{
Step();
var ret = new LabeledStatement() { Location = t.Location, Identifier = t.Value, Parent = Parent };
LastParsedObject = ret;
Step();
ret.EndLocation = t.EndLocation;
return ret;
}
#endregion
#region IfStatement
else if (laKind == (If) || (laKind == Static && Lexer.CurrentPeekToken.Kind == If))
{
bool isStatic = laKind == Static;
if (isStatic)
Step();
Step();
var dbs = new IfStatement() { Location = t.Location, IsStatic = isStatic, Parent = Parent };
LastParsedObject = dbs;
Expect(OpenParenthesis);
// IfCondition
IfCondition(dbs);
// ThenStatement
if(Expect(CloseParenthesis))
dbs.ThenStatement = Statement(Scope: Scope, Parent: dbs);
// ElseStatement
if (laKind == (Else))
{
Step();
dbs.ElseStatement = Statement(Scope: Scope, Parent: dbs);
}
dbs.EndLocation = t.EndLocation;
return dbs;
}
#endregion
#region WhileStatement
else if (laKind == While)
{
Step();
var dbs = new WhileStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = dbs;
Expect(OpenParenthesis);
dbs.Condition = Expression(Scope);
Expect(CloseParenthesis);
dbs.ScopedStatement = Statement(Scope: Scope, Parent: dbs);
dbs.EndLocation = t.EndLocation;
return dbs;
}
#endregion
#region DoStatement
else if (laKind == (Do))
{
Step();
var dbs = new WhileStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = dbs;
dbs.ScopedStatement = Statement(Scope: Scope, Parent: dbs);
Expect(While);
Expect(OpenParenthesis);
dbs.Condition = Expression(Scope);
Expect(CloseParenthesis);
dbs.EndLocation = t.EndLocation;
return dbs;
}
#endregion
#region ForStatement
else if (laKind == (For))
{
Step();
var dbs = new ForStatement { Location = t.Location, Parent = Parent };
LastParsedObject = dbs;
Expect(OpenParenthesis);
// Initialize
if (laKind != Semicolon)
dbs.Initialize = Statement(false, Scope: Scope, Parent: dbs); // Against the D language theory, blocks aren't allowed here!
else
Step();
// Enforce a trailing semi-colon only if there hasn't been an expression (the ; gets already skipped in there)
// Expect(Semicolon);
// Test
if (laKind != (Semicolon))
dbs.Test = Expression(Scope);
Expect(Semicolon);
// Increment
if (laKind != (CloseParenthesis))
dbs.Increment = Expression(Scope);
Expect(CloseParenthesis);
dbs.ScopedStatement = Statement(Scope: Scope, Parent: dbs);
dbs.EndLocation = t.EndLocation;
return dbs;
}
#endregion
#region ForeachStatement
else if (laKind == Foreach || laKind == Foreach_Reverse)
return ForeachStatement(Scope, Parent);
#endregion
#region [Final] SwitchStatement
else if ((laKind == (Final) && Lexer.CurrentPeekToken.Kind == (Switch)) || laKind == (Switch))
{
var dbs = new SwitchStatement { Location = la.Location, Parent = Parent };
LastParsedObject = dbs;
if (laKind == (Final))
{
dbs.IsFinal = true;
Step();
}
Step();
Expect(OpenParenthesis);
dbs.SwitchExpression = Expression(Scope);
Expect(CloseParenthesis);
dbs.ScopedStatement = Statement(Scope: Scope, Parent: dbs);
dbs.EndLocation = t.EndLocation;
return dbs;
}
#endregion
#region CaseStatement
else if (laKind == (Case))
{
Step();
var dbs = new SwitchStatement.CaseStatement() { Location = la.Location, Parent = Parent };
LastParsedObject = dbs;
dbs.ArgumentList = Expression(Scope);
Expect(Colon);
// CaseRangeStatement
if (laKind == DoubleDot)
{
Step();
Expect(Case);
dbs.LastExpression = AssignExpression();
Expect(Colon);
}
var sl = new List<IStatement>();
while (laKind != Case && laKind != Default && laKind != CloseCurlyBrace && !IsEOF)
{
var stmt = Statement(Scope: Scope, Parent: dbs);
if (stmt != null)
{
stmt.Parent = dbs;
sl.Add(stmt);
}
}
dbs.ScopeStatementList = sl.ToArray();
dbs.EndLocation = t.EndLocation;
return dbs;
}
#endregion
#region Default
else if (laKind == (Default))
{
Step();
var dbs = new SwitchStatement.DefaultStatement()
{
Location = la.Location,
Parent = Parent
};
LastParsedObject = dbs;
Expect(Colon);
var sl = new List<IStatement>();
while (laKind != Case && laKind != Default && laKind != CloseCurlyBrace && !IsEOF)
{
var stmt = Statement(Scope: Scope, Parent: dbs);
if (stmt != null)
{
stmt.Parent = dbs;
sl.Add(stmt);
}
}
dbs.ScopeStatementList = sl.ToArray();
dbs.EndLocation = t.EndLocation;
return dbs;
}
#endregion
#region Continue | Break
else if (laKind == (Continue))
{
Step();
var s = new ContinueStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = s;
if (laKind == (Identifier))
{
Step();
s.Identifier = t.Value;
}
Expect(Semicolon);
s.EndLocation = t.EndLocation;
return s;
}
else if (laKind == (Break))
{
Step();
var s = new BreakStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = s;
if (laKind == (Identifier))
{
Step();
s.Identifier = t.Value;
}
Expect(Semicolon);
s.EndLocation = t.EndLocation;
return s;
}
#endregion
#region Return
else if (laKind == (Return))
{
Step();
var s = new ReturnStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = s;
if (laKind != (Semicolon))
s.ReturnExpression = Expression(Scope);
Expect(Semicolon);
s.EndLocation = t.EndLocation;
return s;
}
#endregion
#region Goto
else if (laKind == (Goto))
{
Step();
var s = new GotoStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = s;
if (laKind == (Identifier))
{
Step();
s.StmtType = GotoStatement.GotoStmtType.Identifier;
s.LabelIdentifier = t.Value;
}
else if (laKind == Default)
{
Step();
s.StmtType = GotoStatement.GotoStmtType.Default;
}
else if (laKind == (Case))
{
Step();
s.StmtType = GotoStatement.GotoStmtType.Case;
if (laKind != (Semicolon))
s.CaseExpression = Expression(Scope);
}
Expect(Semicolon);
s.EndLocation = t.EndLocation;
return s;
}
#endregion
#region WithStatement
else if (laKind == (With))
{
Step();
var dbs = new WithStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = dbs;
Expect(OpenParenthesis);
// Symbol
dbs.WithExpression = Expression(Scope);
Expect(CloseParenthesis);
dbs.ScopedStatement = Statement(Scope: Scope, Parent: dbs);
dbs.EndLocation = t.EndLocation;
return dbs;
}
#endregion
#region SynchronizedStatement
else if (laKind == (Synchronized))
{
Step();
var dbs = new SynchronizedStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = dbs;
if (laKind == (OpenParenthesis))
{
Step();
dbs.SyncExpression = Expression(Scope);
Expect(CloseParenthesis);
}
dbs.ScopedStatement = Statement(Scope: Scope, Parent: dbs);
dbs.EndLocation = t.EndLocation;
return dbs;
}
#endregion
#region TryStatement
else if (laKind == (Try))
{
Step();
var s = new TryStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = s;
s.ScopedStatement = Statement(Scope: Scope, Parent: s);
if (!(laKind == (Catch) || laKind == (Finally)))
SemErr(Catch, "At least one catch or a finally block expected!");
var catches = new List<TryStatement.CatchStatement>();
// Catches
while (laKind == (Catch))
{
Step();
var c = new TryStatement.CatchStatement() { Location = t.Location, Parent = s };
LastParsedObject = c;
// CatchParameter
if (laKind == (OpenParenthesis))
{
Step();
if (laKind == CloseParenthesis)
{
SemErr(CloseParenthesis, "Catch parameter expected, not ')'");
Step();
}
else
{
var catchVar = new DVariable();
LastParsedObject = catchVar;
var tt = la; //TODO?
catchVar.Type = BasicType();
if (laKind != Identifier)
{
la = tt;
catchVar.Type = new IdentifierDeclaration("Exception");
}
Expect(Identifier);
catchVar.Name = t.Value;
Expect(CloseParenthesis);
c.CatchParameter = catchVar;
}
}
c.ScopedStatement = Statement(Scope: Scope, Parent: c);
c.EndLocation = t.EndLocation;
catches.Add(c);
}
if (catches.Count > 0)
s.Catches = catches.ToArray();
if (laKind == (Finally))
{
Step();
var f = new TryStatement.FinallyStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = f;
f.ScopedStatement = Statement();
f.EndLocation = t.EndLocation;
s.FinallyStmt = f;
}
s.EndLocation = t.EndLocation;
return s;
}
#endregion
#region ThrowStatement
else if (laKind == (Throw))
{
Step();
var s = new ThrowStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = s;
s.ThrowExpression = Expression(Scope);
Expect(Semicolon);
s.EndLocation = t.EndLocation;
return s;
}
#endregion
#region ScopeGuardStatement
else if (laKind == DTokens.Scope)
{
Step();
if (laKind == OpenParenthesis)
{
var s = new ScopeGuardStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = s;
Step();
if (Expect(Identifier) && t.Value != null) // exit, failure, success
s.GuardedScope = t.Value.ToLower();
if (Expect(CloseParenthesis))
TrackerVariables.ExpectingIdentifier = false;
if (!IsEOF)
s.ScopedStatement = Statement(Scope: Scope, Parent: s);
s.EndLocation = t.EndLocation;
return s;
}
else
PushAttribute(new DAttribute(DTokens.Scope), false);
}
#endregion
#region AsmStmt
else if (laKind == Asm)
return AsmStatement(Parent);
#endregion
#region PragmaStatement
else if (laKind == (Pragma))
{
var s = new PragmaStatement { Location = la.Location };
s.Pragma = _Pragma();
s.Parent = Parent;
s.ScopedStatement = Statement(Scope: Scope, Parent: s);
s.EndLocation = t.EndLocation;
return s;
}
#endregion
#region MixinStatement
//TODO: Handle this one in terms of adding it to the node structure
else if (laKind == (Mixin))
{
if (Peek(1).Kind == OpenParenthesis)
return MixinDeclaration();
else
return TemplateMixin();
}
#endregion
#region Conditions
if (laKind == Debug)
return DebugStatement(Scope, Parent);
if (laKind == Version)
return VersionStatement(Scope, Parent);
#endregion
#region (Static) AssertExpression
else if (laKind == Assert || (laKind == Static && PK(Assert)))
{
var s = new AssertStatement() { Location = la.Location, IsStatic = laKind == Static, Parent = Parent };
LastParsedObject = s;
if (s.IsStatic)
Step();
Step();
if (Expect(OpenParenthesis))
{
s.AssertedExpression = Expression(Scope);
Expect(CloseParenthesis);
Expect(Semicolon);
}
s.EndLocation = t.EndLocation;
return s;
}
#endregion
#region D1: VolatileStatement
else if (laKind == Volatile)
{
Step();
var s = new VolatileStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = s;
s.ScopedStatement = Statement(Scope: Scope, Parent: s);
s.EndLocation = t.EndLocation;
return s;
}
#endregion
// ImportDeclaration
else if (laKind == Import)
return ImportDeclaration();
else if (!(ClassLike[laKind] || BasicTypes[laKind] || laKind == Enum || Modifiers[laKind] || laKind == PropertyAttribute || laKind == Alias || laKind == Typedef) && IsAssignExpression())
{
var s = new ExpressionStatement() { Location = la.Location, Parent = Parent };
if (!IsEOF)
LastParsedObject = s;
// a==b, a=9; is possible -> Expressions can be there, not only single AssignExpressions!
s.Expression = Expression(Scope);
if (Expect(Semicolon))
LastParsedObject = null;
s.EndLocation = t.EndLocation;
return s;
}
else
{
var s = new DeclarationStatement() { Location = la.Location, Parent = Parent };
LastParsedObject = s;
s.Declarations = Declaration(Scope);
s.EndLocation = t.EndLocation;
return s;
}
}
public override void Visit(GotoStatement gotoStatement)
{
WriteWithSeperator("goto");
Visit(gotoStatement.Label);
}
private Statement ParseGoto(TokenSet followers)
//^ requires this.currentToken == Token.Goto;
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
SourceLocationBuilder slb = new SourceLocationBuilder(this.scanner.SourceLocationOfLastScannedToken);
this.GetNextToken();
Statement result;
switch (this.currentToken) {
case Token.Case:
this.GetNextToken();
Expression caseLabel = this.ParseExpression(followers|Token.Semicolon);
slb.UpdateToSpan(caseLabel.SourceLocation);
result = new GotoSwitchCaseStatement(caseLabel, slb);
break;
case Token.Default:
slb.UpdateToSpan(this.scanner.SourceLocationOfLastScannedToken);
result = new GotoSwitchCaseStatement(null, slb);
this.GetNextToken();
break;
default:
result = new GotoStatement(this.ParseSimpleName(followers), slb);
break;
}
this.SkipSemiColon(followers);
return result;
}
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
{
GotoStatement o = other as GotoStatement;
return(o != null && MatchString(this.Label, o.Label));
}
public GotoBlock(IEmitter emitter, GotoStatement gotoStatement) : base(emitter, gotoStatement) {
gotoStatement_ = gotoStatement;
}
public void VisitGotoStatement(GotoStatement gotoStatement)
{
throw new NotImplementedException();
}
public IStatement Statement(bool BlocksAllowed = true, bool EmptyAllowed = true, IBlockNode Scope = null, IStatement Parent=null)
{
if (EmptyAllowed && laKind == Semicolon)
{
LastParsedObject = null;
Step();
return null;
}
if (BlocksAllowed && laKind == OpenCurlyBrace)
return BlockStatement(Scope,Parent);
#region LabeledStatement (loc:... goto loc;)
if (laKind == Identifier && Lexer.CurrentPeekToken.Kind == Colon)
{
Step();
var ret = new LabeledStatement() { Location = t.Location, Identifier = t.Value, Parent = Parent };
LastParsedObject = null;
Step();
ret.EndLocation = t.EndLocation;
return ret;
}
#endregion
#region IfStatement
else if (laKind == (If))
{
Step();
var dbs = new IfStatement{ Location = t.Location, Parent = Parent };
LastParsedObject = dbs;
Expect(OpenParenthesis);
// IfCondition
IfCondition(dbs);
// ThenStatement
if(Expect(CloseParenthesis))
dbs.ThenStatement = Statement(Scope: Scope, Parent: dbs);
// ElseStatement
if (laKind == (Else))
{
Step();
dbs.ElseStatement = Statement(Scope: Scope, Parent: dbs);
}
if(t != null)
dbs.EndLocation = t.EndLocation;
return dbs;
}
#endregion
#region Conditions
else if ((laKind == Static && Lexer.CurrentPeekToken.Kind == If) || laKind == Version || laKind == Debug)
return StmtCondition(Parent, Scope);
#endregion
#region WhileStatement
else if (laKind == While)
{
Step();
var dbs = new WhileStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = dbs;
Expect(OpenParenthesis);
dbs.Condition = Expression(Scope);
Expect(CloseParenthesis);
if(!IsEOF)
{
dbs.ScopedStatement = Statement(Scope: Scope, Parent: dbs);
dbs.EndLocation = t.EndLocation;
}
return dbs;
}
#endregion
#region DoStatement
else if (laKind == (Do))
{
Step();
var dbs = new WhileStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = dbs;
if(!IsEOF)
dbs.ScopedStatement = Statement(true, false, Scope, dbs);
if(Expect(While) && Expect(OpenParenthesis))
{
dbs.Condition = Expression(Scope);
Expect(CloseParenthesis);
if (Expect(Semicolon))
LastParsedObject = null;
dbs.EndLocation = t.EndLocation;
}
return dbs;
}
#endregion
#region ForStatement
else if (laKind == (For))
return ForStatement(Scope, Parent);
#endregion
#region ForeachStatement
else if (laKind == Foreach || laKind == Foreach_Reverse)
return ForeachStatement(Scope, Parent);
#endregion
#region [Final] SwitchStatement
else if ((laKind == (Final) && Lexer.CurrentPeekToken.Kind == (Switch)) || laKind == (Switch))
{
var dbs = new SwitchStatement { Location = la.Location, Parent = Parent };
LastParsedObject = dbs;
if (laKind == (Final))
{
dbs.IsFinal = true;
Step();
}
Step();
Expect(OpenParenthesis);
dbs.SwitchExpression = Expression(Scope);
Expect(CloseParenthesis);
if(!IsEOF)
dbs.ScopedStatement = Statement(Scope: Scope, Parent: dbs);
dbs.EndLocation = t.EndLocation;
return dbs;
}
#endregion
#region CaseStatement
else if (laKind == (Case))
{
Step();
var dbs = new SwitchStatement.CaseStatement() { Location = la.Location, Parent = Parent };
LastParsedObject = dbs;
dbs.ArgumentList = Expression(Scope);
if (Expect(Colon))
LastParsedObject = null;
// CaseRangeStatement
if (laKind == DoubleDot)
{
Step();
Expect(Case);
dbs.LastExpression = AssignExpression();
if (Expect(Colon))
LastParsedObject = null;
}
var sl = new List<IStatement>();
while (laKind != Case && laKind != Default && laKind != CloseCurlyBrace && !IsEOF)
{
var stmt = Statement(Scope: Scope, Parent: dbs);
if (stmt != null)
{
stmt.Parent = dbs;
sl.Add(stmt);
}
}
dbs.ScopeStatementList = sl.ToArray();
dbs.EndLocation = t.EndLocation;
return dbs;
}
#endregion
#region Default
else if (laKind == (Default))
{
Step();
var dbs = new SwitchStatement.DefaultStatement()
{
Location = la.Location,
Parent = Parent
};
LastParsedObject = dbs;
Expect(Colon);
var sl = new List<IStatement>();
while (laKind != Case && laKind != Default && laKind != CloseCurlyBrace && !IsEOF)
{
var stmt = Statement(Scope: Scope, Parent: dbs);
if (stmt != null)
{
stmt.Parent = dbs;
sl.Add(stmt);
}
}
dbs.ScopeStatementList = sl.ToArray();
dbs.EndLocation = t.EndLocation;
return dbs;
}
#endregion
#region Continue | Break
else if (laKind == (Continue))
{
Step();
var s = new ContinueStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = s;
if (laKind == (Identifier))
{
Step();
s.Identifier = t.Value;
}
if (Expect(Semicolon))
LastParsedObject = null;
s.EndLocation = t.EndLocation;
return s;
}
else if (laKind == (Break))
{
Step();
var s = new BreakStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = s;
if (laKind == (Identifier))
{
Step();
s.Identifier = t.Value;
}
if (Expect(Semicolon))
LastParsedObject = null;
s.EndLocation = t.EndLocation;
return s;
}
#endregion
#region Return
else if (laKind == (Return))
{
Step();
var s = new ReturnStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = s;
if (laKind != (Semicolon))
s.ReturnExpression = Expression(Scope);
if (Expect(Semicolon))
LastParsedObject = null;
s.EndLocation = t.EndLocation;
return s;
}
#endregion
#region Goto
else if (laKind == (Goto))
{
Step();
var s = new GotoStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = s;
if (laKind == (Identifier))
{
Step();
s.StmtType = GotoStatement.GotoStmtType.Identifier;
s.LabelIdentifier = t.Value;
}
else if (laKind == Default)
{
Step();
s.StmtType = GotoStatement.GotoStmtType.Default;
}
else if (laKind == (Case))
{
Step();
s.StmtType = GotoStatement.GotoStmtType.Case;
if (laKind != (Semicolon))
s.CaseExpression = Expression(Scope);
}
if (Expect(Semicolon))
LastParsedObject = null;
s.EndLocation = t.EndLocation;
return s;
}
#endregion
#region WithStatement
else if (laKind == (With))
{
Step();
var dbs = new WithStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = dbs;
if(Expect(OpenParenthesis))
{
// Symbol
dbs.WithExpression = Expression(Scope);
Expect(CloseParenthesis);
if(!IsEOF)
dbs.ScopedStatement = Statement(Scope: Scope, Parent: dbs);
}
dbs.EndLocation = t.EndLocation;
return dbs;
}
#endregion
#region SynchronizedStatement
else if (laKind == (Synchronized))
{
Step();
var dbs = new SynchronizedStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = dbs;
if (laKind == (OpenParenthesis))
{
Step();
dbs.SyncExpression = Expression(Scope);
Expect(CloseParenthesis);
}
if(!IsEOF)
dbs.ScopedStatement = Statement(Scope: Scope, Parent: dbs);
dbs.EndLocation = t.EndLocation;
return dbs;
}
#endregion
#region TryStatement
else if (laKind == (Try))
{
Step();
var s = new TryStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = s;
s.ScopedStatement = Statement(Scope: Scope, Parent: s);
if (!(laKind == (Catch) || laKind == (Finally)))
SemErr(Catch, "At least one catch or a finally block expected!");
var catches = new List<TryStatement.CatchStatement>();
// Catches
while (laKind == (Catch))
{
Step();
var c = new TryStatement.CatchStatement() { Location = t.Location, Parent = s };
LastParsedObject = c;
// CatchParameter
if (laKind == (OpenParenthesis))
{
Step();
if (laKind == CloseParenthesis || IsEOF)
{
SemErr(CloseParenthesis, "Catch parameter expected, not ')'");
Step();
}
else
{
var catchVar = new DVariable { Parent = Scope, Location = t.Location };
LastParsedObject = catchVar;
Lexer.PushLookAheadBackup();
catchVar.Type = BasicType();
if (laKind == CloseParenthesis)
{
Lexer.RestoreLookAheadBackup();
catchVar.Type = new IdentifierDeclaration("Exception");
}
else
Lexer.PopLookAheadBackup();
if (Expect(Identifier))
{
catchVar.Name = t.Value;
catchVar.NameLocation = t.Location;
Expect(CloseParenthesis);
}
else if(IsEOF)
ExpectingNodeName = true;
catchVar.EndLocation = t.EndLocation;
c.CatchParameter = catchVar;
}
}
if(!IsEOF)
c.ScopedStatement = Statement(Scope: Scope, Parent: c);
c.EndLocation = t.EndLocation;
catches.Add(c);
}
if (catches.Count > 0)
s.Catches = catches.ToArray();
if (laKind == (Finally))
{
Step();
var f = new TryStatement.FinallyStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = f;
f.ScopedStatement = Statement();
f.EndLocation = t.EndLocation;
s.FinallyStmt = f;
}
s.EndLocation = t.EndLocation;
return s;
}
#endregion
#region ThrowStatement
else if (laKind == (Throw))
{
Step();
var s = new ThrowStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = s;
s.ThrowExpression = Expression(Scope);
Expect(Semicolon);
s.EndLocation = t.EndLocation;
return s;
}
#endregion
#region ScopeGuardStatement
else if (laKind == DTokens.Scope)
{
Step();
if (laKind == OpenParenthesis)
{
var s = new ScopeGuardStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = s;
Step();
if (Expect(Identifier) && t.Value != null) // exit, failure, success
s.GuardedScope = t.Value.ToLower();
if (Expect(CloseParenthesis))
TrackerVariables.ExpectingIdentifier = false;
if (!IsEOF)
s.ScopedStatement = Statement(Scope: Scope, Parent: s);
s.EndLocation = t.EndLocation;
return s;
}
else
PushAttribute(new Modifier(DTokens.Scope), false);
}
#endregion
#region AsmStmt
else if (laKind == Asm)
return AsmStatement(Parent);
#endregion
#region PragmaStatement
else if (laKind == (Pragma))
{
var s = new PragmaStatement { Location = la.Location };
s.Pragma = _Pragma();
s.Parent = Parent;
s.ScopedStatement = Statement(Scope: Scope, Parent: s);
s.EndLocation = t.EndLocation;
return s;
}
#endregion
#region MixinStatement
else if (laKind == (Mixin))
{
if (Peek(1).Kind == OpenParenthesis)
{
OverPeekBrackets(OpenParenthesis);
if (Lexer.CurrentPeekToken.Kind != Semicolon)
return ExpressionStatement(Scope, Parent);
return MixinDeclaration(Scope, Parent);
}
else
{
var tmx = TemplateMixin(Scope, Parent);
if (tmx.MixinId == null)
return tmx;
else
return new DeclarationStatement { Declarations = new[] { new NamedTemplateMixinNode(tmx) }, Parent = Parent };
}
}
#endregion
#region (Static) AssertExpression
else if (laKind == Assert || (laKind == Static && Lexer.CurrentPeekToken.Kind == Assert))
{
var isStatic = laKind == Static;
AssertStatement s;
if (isStatic)
{
Step();
s = new StaticAssertStatement { Location = la.Location, Parent = Parent };
}
else
s = new AssertStatement() { Location = la.Location, Parent = Parent };
LastParsedObject = s;
Step();
if (Expect(OpenParenthesis))
{
s.AssertedExpression = Expression(Scope);
if(Expect(CloseParenthesis) && Expect(Semicolon))
LastParsedObject = null;
}
s.EndLocation = t.EndLocation;
return s;
}
#endregion
#region D1: VolatileStatement
else if (laKind == Volatile)
{
Step();
var s = new VolatileStatement() { Location = t.Location, Parent = Parent };
LastParsedObject = s;
s.ScopedStatement = Statement(Scope: Scope, Parent: s);
s.EndLocation = t.EndLocation;
return s;
}
#endregion
// ImportDeclaration
else if (laKind == Import || (laKind == Static && Lexer.CurrentPeekToken.Kind == Import))
{
if(laKind == Static)
Step(); // Will be handled in ImportDeclaration
return ImportDeclaration(Scope);
}
else if (!(ClassLike[laKind] || BasicTypes[laKind] || laKind == Enum || Modifiers[laKind] || IsAtAttribute || laKind == Alias || laKind == Typedef) && IsAssignExpression())
return ExpressionStatement(Scope, Parent);
var ds = new DeclarationStatement() { Location = la.Location, Parent = Parent, ParentNode = Scope };
LastParsedObject = ds;
ds.Declarations = Declaration(Scope);
ds.EndLocation = t.EndLocation;
return ds;
}
public void AcceptGoto(GotoStatement stmt)
{
SimpleResult(stmt);
}
public IStatement Statement(bool BlocksAllowed = true, bool EmptyAllowed = true, IBlockNode Scope = null, IStatement Parent=null)
{
switch (laKind)
{
case Semicolon:
if (!EmptyAllowed)
goto default;
Step();
return null;
case OpenCurlyBrace:
if (!BlocksAllowed)
goto default;
return BlockStatement(Scope,Parent);
// LabeledStatement (loc:... goto loc;)
case Identifier:
if (Lexer.CurrentPeekToken.Kind != Colon)
goto default;
Step();
var ls = new LabeledStatement() { Location = t.Location, Identifier = t.Value, Parent = Parent };
Step();
ls.EndLocation = t.EndLocation;
return ls;
// IfStatement
case If:
Step();
var iS = new IfStatement{ Location = t.Location, Parent = Parent };
Expect(OpenParenthesis);
// IfCondition
IfCondition(iS);
// ThenStatement
if(Expect(CloseParenthesis))
iS.ThenStatement = Statement(Scope: Scope, Parent: iS);
// ElseStatement
if (laKind == (Else))
{
Step();
iS.ElseStatement = Statement(Scope: Scope, Parent: iS);
}
if(t != null)
iS.EndLocation = t.EndLocation;
return iS;
// Conditions
case Version:
case Debug:
return StmtCondition(Parent, Scope);
case Static:
if (Lexer.CurrentPeekToken.Kind == If)
return StmtCondition(Parent, Scope);
else if (Lexer.CurrentPeekToken.Kind == Assert)
goto case Assert;
else if (Lexer.CurrentPeekToken.Kind == Import)
goto case Import;
goto default;
case For:
return ForStatement(Scope, Parent);
case Foreach:
case Foreach_Reverse:
return ForeachStatement(Scope, Parent);
case While:
Step();
var ws = new WhileStatement() { Location = t.Location, Parent = Parent };
Expect(OpenParenthesis);
ws.Condition = Expression(Scope);
Expect(CloseParenthesis);
if(!IsEOF)
{
ws.ScopedStatement = Statement(Scope: Scope, Parent: ws);
ws.EndLocation = t.EndLocation;
}
return ws;
case Do:
Step();
var dws = new WhileStatement() { Location = t.Location, Parent = Parent };
if(!IsEOF)
dws.ScopedStatement = Statement(true, false, Scope, dws);
if(Expect(While) && Expect(OpenParenthesis))
{
dws.Condition = Expression(Scope);
Expect(CloseParenthesis);
Expect(Semicolon);
dws.EndLocation = t.EndLocation;
}
return dws;
// [Final] SwitchStatement
case Final:
if (Lexer.CurrentPeekToken.Kind != Switch)
goto default;
goto case Switch;
case Switch:
var ss = new SwitchStatement { Location = la.Location, Parent = Parent };
if (laKind == (Final))
{
ss.IsFinal = true;
Step();
}
Step();
Expect(OpenParenthesis);
ss.SwitchExpression = Expression(Scope);
Expect(CloseParenthesis);
if(!IsEOF)
ss.ScopedStatement = Statement(Scope: Scope, Parent: ss);
ss.EndLocation = t.EndLocation;
return ss;
case Case:
Step();
var sscs = new SwitchStatement.CaseStatement() { Location = la.Location, Parent = Parent };
sscs.ArgumentList = Expression(Scope);
Expect(Colon);
// CaseRangeStatement
if (laKind == DoubleDot)
{
Step();
Expect(Case);
sscs.LastExpression = AssignExpression();
Expect(Colon);
}
var sscssl = new List<IStatement>();
while (laKind != Case && laKind != Default && laKind != CloseCurlyBrace && !IsEOF)
{
var stmt = Statement(Scope: Scope, Parent: sscs);
if (stmt != null)
{
stmt.Parent = sscs;
sscssl.Add(stmt);
}
}
sscs.ScopeStatementList = sscssl.ToArray();
sscs.EndLocation = t.EndLocation;
return sscs;
case Default:
Step();
var ssds = new SwitchStatement.DefaultStatement()
{
Location = la.Location,
Parent = Parent
};
Expect(Colon);
var ssdssl = new List<IStatement>();
while (laKind != Case && laKind != Default && laKind != CloseCurlyBrace && !IsEOF)
{
var stmt = Statement(Scope: Scope, Parent: ssds);
if (stmt != null)
{
stmt.Parent = ssds;
ssdssl.Add(stmt);
}
}
ssds.ScopeStatementList = ssdssl.ToArray();
ssds.EndLocation = t.EndLocation;
return ssds;
case Continue:
Step();
var cs = new ContinueStatement() { Location = t.Location, Parent = Parent };
if (laKind == (Identifier))
{
Step();
cs.Identifier = t.Value;
}
else if(IsEOF)
cs.IdentifierHash = DTokens.IncompleteIdHash;
Expect(Semicolon);
cs.EndLocation = t.EndLocation;
return cs;
case Break:
Step();
var bs = new BreakStatement() { Location = t.Location, Parent = Parent };
if (laKind == (Identifier))
{
Step();
bs.Identifier = t.Value;
}
else if(IsEOF)
bs.IdentifierHash = DTokens.IncompleteIdHash;
Expect(Semicolon);
bs.EndLocation = t.EndLocation;
return bs;
case Return:
Step();
var rs = new ReturnStatement() { Location = t.Location, Parent = Parent };
if (laKind != (Semicolon))
rs.ReturnExpression = Expression(Scope);
Expect(Semicolon);
rs.EndLocation = t.EndLocation;
return rs;
case Goto:
Step();
var gs = new GotoStatement() { Location = t.Location, Parent = Parent };
switch(laKind)
{
case Identifier:
Step();
gs.StmtType = GotoStatement.GotoStmtType.Identifier;
gs.LabelIdentifier = t.Value;
break;
case Default:
Step();
gs.StmtType = GotoStatement.GotoStmtType.Default;
break;
case Case:
Step();
gs.StmtType = GotoStatement.GotoStmtType.Case;
if (laKind != (Semicolon))
gs.CaseExpression = Expression(Scope);
break;
default:
if (IsEOF)
gs.LabelIdentifierHash = DTokens.IncompleteIdHash;
break;
}
Expect(Semicolon);
gs.EndLocation = t.EndLocation;
return gs;
case With:
Step();
var wS = new WithStatement() { Location = t.Location, Parent = Parent };
if(Expect(OpenParenthesis))
{
// Symbol
wS.WithExpression = Expression(Scope);
Expect(CloseParenthesis);
if(!IsEOF)
wS.ScopedStatement = Statement(Scope: Scope, Parent: wS);
}
wS.EndLocation = t.EndLocation;
return wS;
case Synchronized:
Step();
var syncS = new SynchronizedStatement() { Location = t.Location, Parent = Parent };
if (laKind == (OpenParenthesis))
{
Step();
syncS.SyncExpression = Expression(Scope);
Expect(CloseParenthesis);
}
if(!IsEOF)
syncS.ScopedStatement = Statement(Scope: Scope, Parent: syncS);
syncS.EndLocation = t.EndLocation;
return syncS;
case Try:
Step();
var ts = new TryStatement() { Location = t.Location, Parent = Parent };
ts.ScopedStatement = Statement(Scope: Scope, Parent: ts);
if (!(laKind == (Catch) || laKind == (Finally)))
SemErr(Catch, "At least one catch or a finally block expected!");
var catches = new List<TryStatement.CatchStatement>();
// Catches
while (laKind == (Catch))
{
Step();
var c = new TryStatement.CatchStatement() { Location = t.Location, Parent = ts };
// CatchParameter
if (laKind == (OpenParenthesis))
{
Step();
if (laKind == CloseParenthesis || IsEOF)
{
SemErr(CloseParenthesis, "Catch parameter expected, not ')'");
Step();
}
else
{
var catchVar = new DVariable { Parent = Scope, Location = t.Location };
Lexer.PushLookAheadBackup();
catchVar.Type = BasicType();
if (laKind == CloseParenthesis)
{
Lexer.RestoreLookAheadBackup();
catchVar.Type = new IdentifierDeclaration("Exception");
}
else
Lexer.PopLookAheadBackup();
if (Expect(Identifier))
{
catchVar.Name = t.Value;
catchVar.NameLocation = t.Location;
Expect(CloseParenthesis);
}
else if(IsEOF)
catchVar.NameHash = DTokens.IncompleteIdHash;
catchVar.EndLocation = t.EndLocation;
c.CatchParameter = catchVar;
}
}
if(!IsEOF)
c.ScopedStatement = Statement(Scope: Scope, Parent: c);
c.EndLocation = t.EndLocation;
catches.Add(c);
}
if (catches.Count > 0)
ts.Catches = catches.ToArray();
if (laKind == (Finally))
{
Step();
var f = new TryStatement.FinallyStatement() { Location = t.Location, Parent = Parent };
f.ScopedStatement = Statement();
f.EndLocation = t.EndLocation;
ts.FinallyStmt = f;
}
ts.EndLocation = t.EndLocation;
return ts;
case Throw:
Step();
var ths = new ThrowStatement() { Location = t.Location, Parent = Parent };
ths.ThrowExpression = Expression(Scope);
Expect(Semicolon);
ths.EndLocation = t.EndLocation;
return ths;
case DTokens.Scope:
Step();
if (laKind == OpenParenthesis)
{
var s = new ScopeGuardStatement() {
Location = t.Location,
Parent = Parent
};
Step();
if (Expect(Identifier) && t.Value != null) // exit, failure, success
s.GuardedScope = t.Value.ToLower();
else if (IsEOF)
s.GuardedScope = DTokens.IncompleteId;
Expect(CloseParenthesis);
s.ScopedStatement = Statement(Scope: Scope, Parent: s);
s.EndLocation = t.EndLocation;
return s;
}
else
PushAttribute(new Modifier(DTokens.Scope), false);
goto default;
case Asm:
return ParseAsmStatement(Scope, Parent);
case Pragma:
var ps = new PragmaStatement { Location = la.Location };
ps.Pragma = _Pragma();
ps.Parent = Parent;
ps.ScopedStatement = Statement(Scope: Scope, Parent: ps);
ps.EndLocation = t.EndLocation;
return ps;
case Mixin:
if (Peek(1).Kind == OpenParenthesis)
{
OverPeekBrackets(OpenParenthesis);
if (Lexer.CurrentPeekToken.Kind != Semicolon)
return ExpressionStatement(Scope, Parent);
return MixinDeclaration(Scope, Parent);
}
else
{
var tmx = TemplateMixin(Scope, Parent);
if (tmx.MixinId == null)
return tmx;
else
return new DeclarationStatement { Declarations = new[] { new NamedTemplateMixinNode(tmx) }, Parent = Parent };
}
case Assert:
var isStatic = laKind == Static;
AssertStatement asS;
if (isStatic)
{
Step();
asS = new StaticAssertStatement { Location = la.Location, Parent = Parent };
}
else
asS = new AssertStatement() { Location = la.Location, Parent = Parent };
Step();
if (Expect(OpenParenthesis))
{
asS.AssertedExpression = Expression(Scope);
Expect(CloseParenthesis);
Expect(Semicolon);
}
asS.EndLocation = t.EndLocation;
return asS;
case Volatile:
Step();
var vs = new VolatileStatement() { Location = t.Location, Parent = Parent };
vs.ScopedStatement = Statement(Scope: Scope, Parent: vs);
vs.EndLocation = t.EndLocation;
return vs;
case Import:
if(laKind == Static)
Step(); // Will be handled in ImportDeclaration
return ImportDeclaration(Scope);
case Enum:
case Alias:
case Typedef:
var ds = new DeclarationStatement() { Location = la.Location, Parent = Parent, ParentNode = Scope };
ds.Declarations = Declaration(Scope);
ds.EndLocation = t.EndLocation;
return ds;
default:
if (IsClassLike(laKind) || (IsBasicType(laKind) && Lexer.CurrentPeekToken.Kind != Dot) || IsModifier(laKind))
goto case Typedef;
if (IsAssignExpression())
return ExpressionStatement(Scope, Parent);
goto case Typedef;
}
}
public void AcceptGoto(GotoStatement stmt)
{
Result = stmt;
}
public override void VisitGotoStatement(GotoStatement gotoStatement)
{
VisitChildren(gotoStatement);
FixSemicolon(gotoStatement.SemicolonToken);
}
public virtual object VisitGotoStatement(GotoStatement gotoStatement, object data)
{
throw new global::System.NotImplementedException("GotoStatement");
}
public virtual void VisitGotoStatement(GotoStatement gotoStatement)
{
if (this.ThrowException)
{
throw (Exception)this.CreateException(gotoStatement);
}
}
public virtual ICodeNode VisitGotoStatement(GotoStatement node)
{
return(node);
}
public override void VisitGotoStatement(GotoStatement gotoStatement) {
_result.Add(JsStatement.Goto(gotoStatement.Label));
}
protected override void VisitGotoStatement(GotoStatement statement)
{
throw new NotImplementedException();
}
public virtual void Visit(GotoStatement s)
{
VisitAbstractStmt(s);
if (s.CaseExpression != null)
s.CaseExpression.Accept(this);
}
internal string DoStatement(Statement s)
{
if (s is AssignmentStatement && !(s is AugmentedAssignmentStatement))
{
AssignmentStatement a = s as AssignmentStatement;
StringBuilder sb = new StringBuilder();
if (a.IsLocal)
{
sb.Append("local ");
}
for (int i = 0; i < a.Lhs.Count; i++)
{
sb.Append(DoExpr(a.Lhs[i]));
if (i != a.Lhs.Count - 1)
{
sb.Append(", ");
}
}
if (a.Rhs.Count > 0)
{
sb.Append(" = ");
for (int i = 0; i < a.Rhs.Count; i++)
{
sb.Append(DoExpr(a.Rhs[i]));
if (i != a.Rhs.Count - 1)
{
sb.Append(", ");
}
}
}
return(sb.ToString());
}
else if (s is AugmentedAssignmentStatement)
{
AugmentedAssignmentStatement a = s as AugmentedAssignmentStatement;
StringBuilder sb = new StringBuilder();
//sb.Append(DoExpr(a.Lhs[0]));
if (a.IsLocal)
{
sb.Append("local ");
}
Expression assignment = ((BinOpExpr)a.Rhs[0]).Rhs;
sb.Append(DoExpr((((BinOpExpr)a.Rhs[0]).Lhs)));
sb.Append(" " + ((BinOpExpr)a.Rhs[0]).Op + "= ");
sb.Append(DoExpr(assignment));
return(sb.ToString());
}
else if (s is BreakStatement)
{
// HAHAHA this is incredibly simple...
return("break");
}
else if (s is CallStatement)
{
// Also incredibly simple...
CallStatement c = s as CallStatement;
return(DoExpr(c.Expression));
}
else if (s is DoStatement)
{
DoStatement d = s as DoStatement;
StringBuilder sb = new StringBuilder();
sb.Append("do" + EOL);
indent++;
sb.Append(DoChunk(d.Body));
sb.Append(nldedent() + "end");
return(sb.ToString());
}
else if (s is GenericForStatement)
{
GenericForStatement g = s as GenericForStatement;
StringBuilder sb = new StringBuilder();
sb.Append("for ");
for (int i = 0; i < g.VariableList.Count; i++)
{
sb.Append(g.VariableList[i].Name);
if (i != g.VariableList.Count - 1)
{
sb.Append(", ");
}
}
sb.Append(" in ");
for (int i = 0; i < g.Generators.Count; i++)
{
sb.Append(DoExpr(g.Generators[i]));
if (i != g.Generators.Count - 1)
{
sb.Append(", ");
}
}
sb.Append(" do" + EOL);
indent++;
sb.Append(DoChunk(g.Body));
sb.Append(nldedent() + "end");
return(sb.ToString());
}
else if (s is NumericForStatement)
{
NumericForStatement n = s as NumericForStatement;
StringBuilder sb = new StringBuilder();
sb.Append("for ");
sb.Append(n.Variable.Name);
sb.Append(" = ");
sb.Append(DoExpr(n.Start));
sb.Append(", ");
sb.Append(DoExpr(n.End));
if (n.Step != null)
{
sb.Append(", ");
sb.Append(DoExpr(n.Step));
}
sb.Append(" do" + EOL);
indent++;
sb.Append(DoChunk(n.Body));
sb.Append(nldedent() + "end");
return(sb.ToString());
}
else if (s is FunctionStatement)
{
FunctionStatement f = s as FunctionStatement;
StringBuilder sb = new StringBuilder();
sb.Append("function " + DoExpr(f.Name) + "(");
for (int i = 0; i < f.Arguments.Count; i++)
{
sb.Append(f.Arguments[i].Name);
if (i != f.Arguments.Count - 1 || f.IsVararg)
{
sb.Append(", ");
}
}
if (f.IsVararg)
{
sb.Append("...");
}
sb.Append(")");
if (f.Body.Count > 1)
{
sb.Append(EOL);
indent++;
sb.Append(DoChunk(f.Body));
sb.Append(nldedent());
sb.Append("end");
}
else if (f.Body.Count == 0)
{
sb.Append(" end");
}
else
{
sb.Append(" " + DoStatement(f.Body[0]));
sb.Append(" end");
}
return(sb.ToString());
}
else if (s is GotoStatement)
{
GotoStatement g = s as GotoStatement;
return("goto " + g.Label);
}
else if (s is IfStmt)
{
IfStmt i = s as IfStmt;
StringBuilder sb = new StringBuilder();
for (int x = 0; x < i.Clauses.Count; x++)
{
string ind = writeIndent();
indent++;
string ss = DoStatement(i.Clauses[x]);
if (x == 0)
{
sb.Append(ind + "if ");
sb.Append(ss);
}
else if (i.Clauses[x] is ElseStmt)
{
sb.Append(ind + "else" + EOL);
sb.Append(ss);
}
else
{
sb.Append(ind + "elseif " + ss);
}
if (x != i.Clauses.Count - 1)
{
sb.Append(EOL);
}
indent--;
}
sb.Append(EOL + writeIndent() + "end");
return(sb.ToString());
}
else if (s is LabelStatement)
{
LabelStatement l = s as LabelStatement;
return("::" + l.Label + "::");
}
else if (s is RepeatStatement)
{
RepeatStatement r = s as RepeatStatement;
StringBuilder sb = new StringBuilder();
sb.Append("repeat");
if (r.Body.Count == 1)
{
sb.Append(" " + DoStatement(r.Body[0]) + " ");
}
else
{
sb.Append(EOL);
indent++;
sb.Append(DoChunk(r.Body));
indent--;
}
sb.Append("until " + DoExpr(r.Condition));
return(sb.ToString());
}
else if (s is ReturnStatement)
{
ReturnStatement r = s as ReturnStatement;
StringBuilder sb = new StringBuilder();
sb.Append("return ");
for (int i = 0; i < r.Arguments.Count; i++)
{
sb.Append(DoExpr(r.Arguments[i]));
if (i != r.Arguments.Count - 1)
{
sb.Append(", ");
}
}
return(sb.ToString());
}
else if (s is UsingStatement)
{
UsingStatement u = s as UsingStatement;
StringBuilder sb = new StringBuilder();
sb.Append("using ");
sb.Append(DoStatement(u.Vars));
sb.Append(" do" + EOL);
indent++;
sb.Append(DoChunk(u.Body));
indent--;
sb.Append(EOL + writeIndent() + "end");
return(sb.ToString());
}
else if (s is WhileStatement)
{
WhileStatement w = s as WhileStatement;
StringBuilder sb = new StringBuilder();
sb.Append("while ");
sb.Append(DoExpr(w.Condition));
sb.Append(" do");
if (w.Body.Count == 1)
{
sb.Append(" " + DoStatement(w.Body[0]) + " ");
}
else
{
indent++;
sb.Append(DoChunk(w.Body));
indent--;
sb.Append(EOL);
}
sb.Append(writeIndent() + "end");
return(sb.ToString());
}
else if (s is ElseIfStmt)
{
ElseIfStmt e = s as ElseIfStmt;
string s2 = DoExpr(e.Condition) + " then" + EOL;
s2 += DoChunk(e.Body);
return(s2);
}
else if (s is ElseStmt)
{
return(DoChunk(((ElseStmt)s).Body));
}
throw new NotImplementedException(s.GetType().Name + " is not implemented");
}
public override object Visit(Goto gotoStatement)
{
var result = new GotoStatement();
var location = LocationsBag.GetLocations(gotoStatement);
result.AddChild(new CSharpTokenNode(Convert(gotoStatement.loc), GotoStatement.GotoKeywordRole), GotoStatement.GotoKeywordRole);
var loc = location != null ? Convert(location [0]) : TextLocation.Empty;
result.AddChild(Identifier.Create(gotoStatement.Target, loc), Roles.Identifier);
if (location != null && location.Count > 1)
result.AddChild(new CSharpTokenNode(Convert(location [1]), Roles.Semicolon), Roles.Semicolon);
return result;
}
public StringBuilder VisitGotoStatement(GotoStatement gotoStatement)
{
throw new NotImplementedException();
}
public override object Visit (Goto gotoStatement)
{
var result = new GotoStatement (GotoType.Label);
var location = LocationsBag.GetLocations (gotoStatement);
result.AddChild (new CSharpTokenNode (Convert (gotoStatement.loc), "goto".Length), GotoStatement.Roles.Keyword);
result.AddChild (new Identifier (gotoStatement.Target, Convert (gotoStatement.loc)), GotoStatement.Roles.Identifier);
if (location != null)
result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), GotoStatement.Roles.Semicolon);
return result;
}
public virtual object Visit(GotoStatement gotoStatement, object data)
{
Debug.Assert(gotoStatement != null);
return(data);
}
public override object Visit (GotoCase gotoCase)
{
var result = new GotoStatement (GotoType.Case);
result.AddChild (new CSharpTokenNode (Convert (gotoCase.loc), "goto".Length), GotoStatement.Roles.Keyword);
var location = LocationsBag.GetLocations (gotoCase);
if (location != null)
result.AddChild (new CSharpTokenNode (Convert (location[0]), "case".Length), GotoStatement.CaseKeywordRole);
result.AddChild ((INode)gotoCase.Expr.Accept (this), GotoStatement.Roles.Expression);
if (location != null)
result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), GotoStatement.Roles.Semicolon);
return result;
}
public JNode VisitGotoStatement(GotoStatement node)
{
throw new NotImplementedException();
}
public void VisitGotoStatement(GotoStatement gotoStatement)
{
StartNode(gotoStatement);
WriteKeyword(GotoStatement.GotoKeywordRole);
WriteIdentifier(gotoStatement.Label);
Semicolon();
EndNode(gotoStatement);
}
public override void VisitGotoStatement(GotoStatement gotoStatement)
{
this.AwaitExpressions.Add(new Tuple <int, AstNode>(this.InvocationLevel, gotoStatement));
base.VisitGotoStatement(gotoStatement);
}
