public override bool Parse(ParseContext context, IAstNode parent) {
TokenStream<RToken> tokens = context.Tokens;
Debug.Assert(context.Tokens.CurrentToken.TokenType == RTokenType.Identifier ||
context.Tokens.CurrentToken.TokenType == RTokenType.String);
this.Identifier = RParser.ParseToken(context, this);
this.EqualsSign = RParser.ParseToken(context, this);
if (context.Tokens.CurrentToken.TokenType != RTokenType.Comma && context.Tokens.CurrentToken.TokenType != RTokenType.CloseBrace) {
Expression exp = new Expression(inGroup: true);
if (exp.Parse(context, this)) {
this.DefaultValue = exp;
}
} else {
this.DefaultValue = new NullExpression();
if (context.Tokens.IsEndOfStream()) {
context.AddError(new ParseError(ParseErrorType.ExpressionExpected, ErrorLocation.Token, context.Tokens.CurrentToken));
} else {
context.AddError(new ParseError(ParseErrorType.ExpressionExpected, ErrorLocation.Token, EqualsSign));
}
}
return base.Parse(context, parent);
}
public override bool Parse(ParseContext context, IAstNode parent) {
this.ArgumentValue = new Expression(inGroup: true);
if (this.ArgumentValue.Parse(context, this)) {
return base.Parse(context, parent);
}
return false;
}
private ParseErrorType HandleOperator(ParseContext context, IAstNode parent, out bool isUnary) {
ParseErrorType errorType = ParseErrorType.None;
// If operands stack is empty the operator is unary.
// If operator is preceded by another operator,
// it is interpreted as unary.
TokenOperator currentOperator = new TokenOperator(_operands.Count == 0);
currentOperator.Parse(context, null);
isUnary = currentOperator.IsUnary;
IOperator lastOperator = _operators.Peek();
if (isUnary && lastOperator != null && lastOperator.IsUnary) {
// !!!x is treated as !(!(!x)))
// Step back and re-parse as expression
context.Tokens.Position -= 1;
var exp = new Expression(inGroup: false);
if (exp.Parse(context, null)) {
_operands.Push(exp);
return ParseErrorType.None;
}
}
if (currentOperator.Precedence <= lastOperator.Precedence &&
!(currentOperator.OperatorType == lastOperator.OperatorType && currentOperator.Association == Association.Right)) {
// New operator has lower or equal precedence. We need to make a tree from
// the topmost operator and its operand(s). Example: a*b+c. + has lower priority
// and a and b should be on the stack along with * on the operator stack.
// Repeat until there are no more higher precendece operators on the stack.
errorType = this.ProcessHigherPrecendenceOperators(context, currentOperator);
}
if (errorType == ParseErrorType.None) {
_operators.Push(currentOperator);
}
return errorType;
}