public StatementParser Identify(INextAwareEnumerator<Token> reader)
{
if (reader.Current.Value == Keywords.If)
return new IfStatementParser();
if (reader.Current.Value == Keywords.While)
return new WhileStatementParser();
if (reader.Current.Value == Keywords.Return)
return new ReturnStatementParser();
if (reader.Current.Value == Keywords.For)
return new ForStatementParser();
if (reader.Current.Value == LuaToken.Semicolon)
return new EmptyStatementParser();
if (reader.Current.Value == Keywords.Do)
return new DoEndBlockStatementParser();
bool local = false;
if (reader.Current.Value == Keywords.Local)
{
local = true;
reader.MoveNext();
}
if (reader.Current.Value == Keywords.Function)
return new FunctionDeclarationStatementParser(local);
return new AssignmentStatementParser(local);
}
public override LuaStatement Parse(INextAwareEnumerator<Token> reader, IParserContext context)
{
var token = reader.GetAndMoveNext();
if (string.IsNullOrWhiteSpace(token.Value) || token.Value == LuaToken.Semicolon)
return new EmptyStatement();
throw new UnexpectedTokenException(token);
}
public override LuaStatement Parse(INextAwareEnumerator<Token> reader, IParserContext context)
{
reader.VerifyExpectedTokenAndMoveNext(Keywords.Function);
if (reader.Next.Value == LuaToken.Colon)
{
reader.MoveNext();
reader.MoveNext();
}
var functionName = reader.GetAndMoveNext();
reader.VerifyExpectedToken(LuaToken.LeftBracket);
var argumentNames = new List<string>();
reader.MoveNext();
while (reader.Current.Value != LuaToken.RightBracket)
{
argumentNames.Add(reader.Current.Value);
reader.MoveNext();
reader.VerifyExpectedToken(LuaToken.Comma, LuaToken.RightBracket);
if (reader.Current.Value == LuaToken.RightBracket)
break;
reader.MoveNext();
}
reader.VerifyExpectedTokenAndMoveNext(LuaToken.RightBracket);
var statementsParser = new StatementBlockParser(Keywords.End);
var body = statementsParser.ParseBlock(reader, context);
return new FunctionDeclarationStatement(functionName.Value,argumentNames,body);
}
public override LuaExpression Parse(INextAwareEnumerator<Token> reader, IParserContext context)
{
var leftExpression = SyntaxParser.ReadExpression(reader,context);
var operation = reader.Current.Value;
reader.VerifyExpectedTokenAndMoveNext(LuaToken.BinaryOperations);
var rightExpression = SyntaxParser.ReadExpression(reader, context);
return new BinaryExpression(leftExpression,rightExpression, operation);
}
public static void VerifyExpectedToken(this INextAwareEnumerator <Token> enumerator,
params string[] expectedTokens)
{
if (!expectedTokens.Contains(enumerator.Current.Value))
{
throw new UnexpectedTokenException(enumerator.Current, expectedTokens);
}
}
public override LuaStatement Parse(INextAwareEnumerator<Token> reader, IParserContext context)
{
reader.VerifyExpectedTokenAndMoveNext(Keywords.While);
var conditionExpression = SyntaxParser.ReadExpression(reader, context);
reader.VerifyExpectedTokenAndMoveNext(Keywords.Do);
var blockParser = new StatementBlockParser(Keywords.End);
var bodyBlock = blockParser.ParseBlock(reader, context);
return new WhileStatement(conditionExpression, bodyBlock);
}
public IEnumerable<LuaExpression> Parse(INextAwareEnumerator<Token> reader, IParserContext context)
{
var expressions = new List<LuaExpression>();
do
{
expressions.Add(SyntaxParser.ReadExpression(reader, context));
} while (reader.Current.Value == LuaToken.Comma && reader.MoveNext());
return expressions;
}
public override LuaExpression Parse(INextAwareEnumerator<Token> reader, IParserContext context)
{
reader.VerifyExpectedToken(LuaToken.LeftBracket);
reader.MoveNext();
var expression = SyntaxParser.ReadExpression(reader, context);
reader.VerifyExpectedToken(LuaToken.RightBracket);
reader.MoveNext();
return new BracketedExpression(expression);
}
public LuaExpression Parse(INextAwareEnumerator <Token> reader, IParserContext context)
{
var expression = new ConstantExpression(new LuaValue {
BooleanValue = bool.Parse(reader.Current.Value)
});
reader.MoveNext();
return(expression);
}
public LuaExpression Parse(INextAwareEnumerator <Token> reader, IParserContext context)
{
var constantValue = double.Parse(reader.Current.Value);
reader.MoveNext();
return(new ConstantExpression(new LuaValue {
NumericValue = constantValue
}));
}
public LuaStatement Parse(INextAwareEnumerator <Token> reader, IParserContext context)
{
var token = reader.GetAndMoveNext();
if (string.IsNullOrWhiteSpace(token.Value) || token.Value == LuaToken.Semicolon)
{
return(new EmptyStatement());
}
throw new UnexpectedTokenException(token);
}
public virtual LuaExpression Parse(INextAwareEnumerator <Token> reader, IParserContext context)
{
var leftExpression = SyntaxParser.ReadExpression(reader, context);
var operation = reader.Current.Value;
reader.VerifyExpectedTokenAndMoveNext(LuaToken.BinaryOperations);
var rightExpression = SyntaxParser.ReadExpression(reader, context);
return(new BinaryExpression(leftExpression, rightExpression, operation));
}
public static LuaStatement ReadStatement(INextAwareEnumerator<Token> reader, IParserContext context)
{
while (string.IsNullOrEmpty(reader.Current.Value)
|| reader.Current.Value == "\n"
|| reader.Current.Type == TokenType.Comment)
reader.MoveNext();
var statementDiscriminator = new StatementParserDiscriminator();
var statementParser = statementDiscriminator.Identify(reader);
return statementParser.Parse(reader, context);
}
public LuaExpression Parse(INextAwareEnumerator <Token> reader, IParserContext context)
{
reader.VerifyExpectedToken(LuaToken.LeftBracket);
reader.MoveNext();
var expression = SyntaxParser.ReadExpression(reader, context);
reader.VerifyExpectedToken(LuaToken.RightBracket);
reader.MoveNext();
return(new BracketedExpression(expression));
}
public LuaStatement Parse(INextAwareEnumerator <Token> reader, IParserContext context)
{
reader.VerifyExpectedTokenAndMoveNext(Keywords.While);
var conditionExpression = SyntaxParser.ReadExpression(reader, context);
reader.VerifyExpectedTokenAndMoveNext(Keywords.Do);
var blockParser = new StatementBlockParser(Keywords.End);
var bodyBlock = blockParser.ParseBlock(reader, context);
return(new WhileStatement(conditionExpression, bodyBlock));
}
public override LuaExpression Parse(INextAwareEnumerator<Token> reader, IParserContext context)
{
reader.VerifyExpectedTokenAndMoveNext(LuaToken.DoubleQuote, LuaToken.DoubleLeftSquareBracket);
var builder = new StringBuilder();
while (reader.HasNext && reader.Current.Value != LuaToken.DoubleQuote &&
reader.Current.Value != LuaToken.DoubleRightSquareBracket)
builder.Append(reader.GetAndMoveNext());
reader.VerifyExpectedTokenAndMoveNext(LuaToken.DoubleQuote, LuaToken.DoubleRightSquareBracket);
return new StringConstantExpression(builder.ToString());
}
public static IExpressionParser Identify(INextAwareEnumerator <Token> reader, IParserContext context)
{
var tableExpression = new TableIndexExpressionParser().Parse(reader, context);
if (reader.HasNext && reader.Next.Value == LuaToken.LeftBracket)
{
return(new FunctionCallExpressionParser());
}
throw new NotImplementedException();
}
public override LuaStatement Parse(INextAwareEnumerator<Token> reader, IParserContext context)
{
var variables = ReadDeclarations(reader);
foreach (var variable in variables)
context.CurrentScope.AddVariable(variable);
reader.VerifyExpectedTokenAndMoveNext(LuaToken.EqualsSign);
var assignedExpressionParser = new ExpressionListParser();
var expressions = assignedExpressionParser.Parse(reader, context);
return new Assignment(variables, expressions, _local);
}
public override LuaExpression Parse(INextAwareEnumerator<Token> reader, IParserContext context)
{
var name = reader.Current.Value;
reader.MoveNext();
reader.VerifyExpectedToken(LuaToken.LeftBracket);
var parametersParser = new ExpressionListParser();
var expression = new FunctionCallExpression(name, parametersParser.Parse(reader, context).ToList());
reader.VerifyExpectedToken(LuaToken.RightBracket);
return expression;
}
public override LuaStatement Parse(INextAwareEnumerator<Token> reader, IParserContext context)
{
var scope = context.AcquireScope();
reader.VerifyExpectedToken(Keywords.Do);
reader.MoveNext();
var statements = new List<LuaStatement>();
while (reader.Current.Value != Keywords.End)
statements.Add(SyntaxParser.ReadStatement(reader, context));
reader.VerifyExpectedTokenAndMoveNext(Keywords.End);
context.ReleaseScope(scope);
return new DoEndBlock(new StatementBlock(statements));
}
public static LuaStatement ReadStatement(INextAwareEnumerator <Token> reader, IParserContext context)
{
while (string.IsNullOrEmpty(reader.Current.Value) ||
reader.Current.Value == "\n" ||
reader.Current.Type == TokenType.Comment)
{
reader.MoveNext();
}
var statementParser = StatementParserDiscriminator.Identify(reader);
return(statementParser.Parse(reader, context));
}
public StatementBlock ParseBlock(INextAwareEnumerator<Token> reader, IParserContext context, out Token terminationToken)
{
var statements = new List<LuaStatement>();
while (!_terminatingTokens.Contains(reader.Current.Value))
{
statements.Add(SyntaxParser.ReadStatement(reader, context));
while (string.IsNullOrEmpty(reader.Current.Value) || reader.Current.Value == "\n")
reader.MoveNext();
}
terminationToken = reader.Current;
reader.VerifyExpectedTokenAndMoveNext(_terminatingTokens);
return new StatementBlock(statements);
}
public static LuaExpression ReadExpression(INextAwareEnumerator <Token> reader, IParserContext context)
{
var expressionParser = ExpressionParserDiscriminator.Identify(reader, context);
var expression = expressionParser.Parse(reader, context);
if (LuaToken.IsBinaryOperation(reader.Current.Value))
{
var operation = reader.GetAndMoveNext();
var rightSideExpression = ReadExpression(reader, context);
expression = new BinaryExpression(expression, rightSideExpression, operation.Value);
}
return(expression);
}
public LuaExpression Parse(INextAwareEnumerator <Token> reader, IParserContext context)
{
var name = reader.Current.Value;
reader.MoveNext();
reader.VerifyExpectedTokenAndMoveNext(LuaToken.LeftBracket);
var parametersParser = new ExpressionListParser();
var expression = new FunctionCallExpression(name, parametersParser.Parse(reader, context).ToList());
reader.VerifyExpectedToken(LuaToken.RightBracket);
return(expression);
}
public override LuaExpression Parse(INextAwareEnumerator<Token> reader, IParserContext context)
{
var variableName = reader.Current.Value;
var visibleVariables = context.CurrentScope.GetVisibleVariables();
Variable variable;
if (!visibleVariables.ContainsKey(variableName))
{
context.AddError("Undefined variable: " + variableName);
variable = new Variable(variableName);
}
else variable = visibleVariables[variableName];
reader.MoveNext();
return new VariableExpression(variable);
}
public LuaStatement Parse(INextAwareEnumerator <Token> reader, IParserContext context)
{
var variables = ReadDeclarations(reader);
foreach (var variable in variables)
{
context.CurrentScope.AddVariable(variable);
}
reader.VerifyExpectedTokenAndMoveNext(LuaToken.EqualsSign);
var assignedExpressionParser = new ExpressionListParser();
var expressions = assignedExpressionParser.Parse(reader, context);
return(new Assignment(variables, expressions, _local));
}
public override LuaExpression Parse(INextAwareEnumerator<Token> reader, IParserContext context)
{
reader.VerifyExpectedToken(LuaToken.LeftCurlyBrace);
reader.MoveNext();
var expressions = new List<LuaExpression>();
while (reader.Current.Value != LuaToken.RightCurlyBrace)
{
expressions.Add(SyntaxParser.ReadExpression(reader, context));
reader.VerifyExpectedToken(LuaToken.RightCurlyBrace, LuaToken.Comma);
}
reader.VerifyExpectedToken(LuaToken.RightCurlyBrace);
reader.MoveNext();
return new TableInitializerExpression(expressions);
}
public IEnumerable <LuaExpression> Parse(INextAwareEnumerator <Token> reader, IParserContext context)
{
var expressions = new List <LuaExpression>();
do
{
if (reader.Current.Value == LuaToken.RightBracket)
{
break;
}
expressions.Add(SyntaxParser.ReadExpression(reader, context));
} while (reader.Current.Value == LuaToken.Comma && reader.MoveNext());
return(expressions);
}
private IList<Variable> ReadDeclarations(INextAwareEnumerator<Token> reader)
{
var result = new List<Variable>();
while (reader.HasNext && reader.Next.Value != null)
{
var variable = new Variable(reader.Current.Value);
result.Add(variable);
reader.MoveNext();
reader.VerifyExpectedToken(LuaToken.Comma,LuaToken.EqualsSign);
if (reader.Current.Value == LuaToken.EqualsSign)
break;
reader.MoveNext();
}
return result;
}
public static LuaExpression ReadExpression(INextAwareEnumerator<Token> reader, IParserContext context)
{
var expressionDiscriminator = new ExpressionParserDiscriminator();
var expressionParser = expressionDiscriminator.Identify(reader);
var expression = expressionParser.Parse(reader, context);
if (LuaToken.IsBinaryOperation(reader.Current.Value))
{
var operation = reader.GetAndMoveNext();
var rightSideExpression = ReadExpression(reader,context);
expression = new BinaryExpression(expression,rightSideExpression,operation.Value);
}
return expression;
}
public LuaStatement Parse(INextAwareEnumerator <Token> reader, IParserContext context)
{
var scope = context.AcquireScope();
reader.VerifyExpectedToken(Keywords.Do);
reader.MoveNext();
var statements = new List <LuaStatement>();
while (reader.Current.Value != Keywords.End)
{
statements.Add(SyntaxParser.ReadStatement(reader, context));
}
reader.VerifyExpectedTokenAndMoveNext(Keywords.End);
context.ReleaseScope(scope);
return(new DoEndBlock(new StatementBlock(statements)));
}
public override LuaStatement Parse(INextAwareEnumerator<Token> reader, IParserContext context)
{
reader.VerifyExpectedTokenAndMoveNext(Keywords.For);
var scope = context.AcquireScope();
reader.VerifyIsIdentifier();
var forVariableName = reader.GetAndMoveNext();
reader.VerifyExpectedTokenAndMoveNext(LuaToken.EqualsSign);
var conditionsParser = new ExpressionListParser();
var conditions = conditionsParser.Parse(reader, context).ToList();
reader.VerifyExpectedTokenAndMoveNext(Keywords.Do);
var statementsParser = new StatementBlockParser(Keywords.End);
var bodyBlock = statementsParser.ParseBlock(reader, context);
context.ReleaseScope(scope);
return new ForStatement(conditions,bodyBlock);
}
public StatementBlock ParseBlock(INextAwareEnumerator <Token> reader, IParserContext context,
out Token terminationToken)
{
var statements = new List <LuaStatement>();
while (!_terminatingTokens.Contains(reader.Current.Value))
{
statements.Add(SyntaxParser.ReadStatement(reader, context));
while (string.IsNullOrEmpty(reader.Current.Value) || reader.Current.Value == "\n")
{
reader.MoveNext();
}
}
terminationToken = reader.Current;
reader.VerifyExpectedTokenAndMoveNext(_terminatingTokens);
return(new StatementBlock(statements));
}
public ExpressionParser Identify(INextAwareEnumerator<Token> reader)
{
if (reader.Current.Value == LuaToken.LeftBracket)
return new BracketedExpressionParser();
if (LuaToken.IsIdentifier(reader.Current.Value) && reader.Next.Value == LuaToken.LeftBracket)
return new FunctionCallExpressionParser();
if (reader.Current.Type == TokenType.BooleanConstant)
return new BooleanConstantExpressionParser();
if (LuaToken.IsIdentifier(reader.Current.Value))
return new SingleVariableExpressionParser();
if (LuaToken.IsNumericConstant(reader.Current.Value))
return new NumericConstantExpressionParser();
if (reader.Current.Value == LuaToken.LeftCurlyBrace)
return new TableInitializerExpressionParser();
if (reader.Current.Type == TokenType.StringConstant)
return new StringConstantExpressionParser();
throw new UnexpectedTokenException(reader.Current);
}
private IList <Variable> ReadDeclarations(INextAwareEnumerator <Token> reader)
{
var result = new List <Variable>();
while (reader.HasNext && reader.Next.Value != null)
{
var variable = new Variable(reader.Current.Value);
result.Add(variable);
reader.MoveNext();
reader.VerifyExpectedToken(LuaToken.Comma, LuaToken.EqualsSign);
if (reader.Current.Value == LuaToken.EqualsSign)
{
break;
}
reader.MoveNext();
}
return(result);
}
public LuaExpression Parse(INextAwareEnumerator <Token> reader, IParserContext context)
{
var variableName = reader.Current.Value;
var visibleVariables = context.CurrentScope.GetVisibleVariables();
Variable variable;
if (!visibleVariables.ContainsKey(variableName))
{
context.AddError("Undefined variable: " + variableName);
variable = new Variable(variableName);
}
else
{
variable = visibleVariables[variableName];
}
reader.MoveNext();
return(new VariableExpression(variable));
}
public override LuaStatement Parse(INextAwareEnumerator<Token> reader, IParserContext context)
{
StatementBlock elseBlock = null;
reader.VerifyExpectedTokenAndMoveNext(Keywords.If);
var conditionExpression = SyntaxParser.ReadExpression(reader, context);
reader.VerifyExpectedTokenAndMoveNext(Keywords.Then);
var ifBlockParser = new StatementBlockParser(Keywords.End, Keywords.Else);
Token delimiterToken;
var ifBlock = ifBlockParser.ParseBlock(reader, context, out delimiterToken);
if (delimiterToken.Value == Keywords.Else)
{
var elseBlockParser = new StatementBlockParser(Keywords.End);
elseBlock = elseBlockParser.ParseBlock(reader, context);
}
return new IfStatement(conditionExpression, ifBlock, elseBlock);
}
public static IStatementParser Identify(INextAwareEnumerator <Token> reader)
{
if (reader.Current.Value == Keywords.If)
{
return(new IfStatementParser());
}
if (reader.Current.Value == Keywords.While)
{
return(new WhileStatementParser());
}
if (reader.Current.Value == Keywords.Return)
{
return(new ReturnStatementParser());
}
if (reader.Current.Value == Keywords.For)
{
return(new ForStatementParser());
}
if (reader.Current.Value == LuaToken.Semicolon)
{
return(new EmptyStatementParser());
}
if (reader.Current.Value == Keywords.Do)
{
return(new DoEndBlockStatementParser());
}
var local = false;
if (reader.Current.Value == Keywords.Local)
{
local = true;
reader.MoveNext();
}
if (reader.Current.Value == Keywords.Function)
{
return(new FunctionDeclarationStatementParser(local));
}
// If nothing else, the statement is probably an assignment statement
return(new AssignmentStatementParser(local));
}
public LuaExpression Parse(INextAwareEnumerator <Token> reader, IParserContext context)
{
reader.VerifyExpectedToken(LuaToken.LeftCurlyBrace);
reader.MoveNext();
var expressions = Enumerable.Empty <LuaExpression>();
if (reader.Current.Value != LuaToken.RightCurlyBrace)
{
var parser = new ExpressionListParser();
expressions = parser.Parse(reader, context);
reader.VerifyExpectedToken(LuaToken.RightCurlyBrace);
reader.MoveNext();
}
else
{
reader.VerifyExpectedTokenAndMoveNext(LuaToken.RightCurlyBrace);
}
return(new TableInitializerExpression(expressions));
}
public LuaStatement Parse(INextAwareEnumerator <Token> reader, IParserContext context)
{
reader.VerifyExpectedTokenAndMoveNext(Keywords.For);
var scope = context.AcquireScope();
reader.VerifyIsIdentifier();
var forVariableName = reader.GetAndMoveNext();
reader.VerifyExpectedTokenAndMoveNext(LuaToken.EqualsSign);
var conditionsParser = new ExpressionListParser();
var conditions = conditionsParser.Parse(reader, context).ToList();
reader.VerifyExpectedTokenAndMoveNext(Keywords.Do);
var statementsParser = new StatementBlockParser(Keywords.End);
var bodyBlock = statementsParser.ParseBlock(reader, context);
context.ReleaseScope(scope);
return(new ForStatement(conditions, bodyBlock));
}
public LuaStatement Parse(INextAwareEnumerator <Token> reader, IParserContext context)
{
StatementBlock elseBlock = null;
reader.VerifyExpectedTokenAndMoveNext(Keywords.If);
var conditionExpression = SyntaxParser.ReadExpression(reader, context);
reader.VerifyExpectedTokenAndMoveNext(Keywords.Then);
var ifBlockParser = new StatementBlockParser(Keywords.End, Keywords.Else);
Token delimiterToken;
var ifBlock = ifBlockParser.ParseBlock(reader, context, out delimiterToken);
if (delimiterToken.Value == Keywords.Else)
{
var elseBlockParser = new StatementBlockParser(Keywords.End);
elseBlock = elseBlockParser.ParseBlock(reader, context);
}
return(new IfStatement(conditionExpression, ifBlock, elseBlock));
}
public static IExpressionParser Identify(INextAwareEnumerator <Token> reader, IParserContext context)
{
if (reader.Current.Type == TokenType.StringConstant)
{
return(new StringConstantExpressionParser());
}
if (LuaToken.IsIdentifier(reader.Current.Value) && reader.HasNext &&
(reader.Next.Value == LuaToken.Dot || reader.Next.Value == LuaToken.LeftSquareBracket))
{
TableExpressionParserDiscriminator.Identify(reader, context);
}
if (reader.Current.Value == LuaToken.LeftBracket)
{
return(new BracketedExpressionParser());
}
if (LuaToken.IsIdentifier(reader.Current.Value) && reader.HasNext &&
reader.Next.Value == LuaToken.LeftBracket)
{
return(new FunctionCallExpressionParser());
}
if (reader.Current.Type == TokenType.BooleanConstant)
{
return(new BooleanConstantExpressionParser());
}
if (LuaToken.IsIdentifier(reader.Current.Value))
{
return(new SingleVariableExpressionParser());
}
if (LuaToken.IsNumericConstant(reader.Current.Value))
{
return(new NumericConstantExpressionParser());
}
if (reader.Current.Value == LuaToken.LeftCurlyBrace)
{
return(new TableInitializerExpressionParser());
}
throw new UnexpectedTokenException(reader.Current);
}
public LuaExpression Parse(INextAwareEnumerator <Token> reader, IParserContext context)
{
var tableName = reader.Current.Value;
LuaExpression indexerExpression;
reader.MoveNext();
if (reader.Current.Value == LuaToken.Dot)
{
reader.MoveNext();
indexerExpression = new StringConstantExpression(reader.Current.Value);
}
else if (reader.Current.Value == LuaToken.LeftSquareBracket)
{
reader.MoveNext();
indexerExpression = SyntaxParser.ReadExpression(reader, context);
reader.VerifyExpectedTokenAndMoveNext(LuaToken.RightSquareBracket);
}
else
{
throw new UnexpectedTokenException(reader.Current, LuaToken.Dot, LuaToken.LeftSquareBracket);
}
return(new TableIndexExpression(new Variable(tableName), indexerExpression));
}
public static void VerifyExpectedTokenAndMoveNext(this INextAwareEnumerator <Token> enumerator,
IEnumerable <string> expectedTokens)
{
VerifyExpectedTokenAndMoveNext(enumerator, expectedTokens.ToArray());
}
public StatementBlock ParseBlock(INextAwareEnumerator<Token> reader, IParserContext context)
{
Token terminationToken;
return ParseBlock(reader, context, out terminationToken);
}
public override LuaStatement Parse(INextAwareEnumerator<Token> reader, IParserContext context)
{
return ParseBlock(reader, context);
}
public StatementBlock ParseBlock(INextAwareEnumerator <Token> reader, IParserContext context)
{
Token terminationToken;
return(ParseBlock(reader, context, out terminationToken));
}
public static void VerifyExpectedTokenAndMoveNext(this INextAwareEnumerator <Token> enumerator,
params string[] expectedTokens)
{
enumerator.VerifyExpectedToken(expectedTokens);
enumerator.MoveNext();
}
public LuaStatement Parse(INextAwareEnumerator <Token> reader, IParserContext context)
{
return(ParseBlock(reader, context));
}
public LuaExpression Parse(INextAwareEnumerator <Token> reader, IParserContext context)
{
return(_expression);
}
/// <summary> /// Parses an expression from reader /// Advances the TokenEnumerator one past last expression token /// </summary> /// <param name="reader"></param> /// <param name="context"></param> /// <returns></returns> public abstract LuaExpression Parse(INextAwareEnumerator<Token> reader, IParserContext context);
public LuaExpression Parse(INextAwareEnumerator <Token> reader, IParserContext context)
{
return(new StringConstantExpression(reader.GetAndMoveNext().Value));
}
public override LuaStatement Parse(INextAwareEnumerator<Token> reader, IParserContext context)
{
reader.VerifyExpectedTokenAndMoveNext(Keywords.Return);
var returnedExpression = SyntaxParser.ReadExpression(reader, context);
return new ReturnStatement(returnedExpression);
}
public override LuaExpression Parse(INextAwareEnumerator<Token> reader, IParserContext context)
{
var expression = new ConstantExpression(new LuaValue { BooleanValue = Boolean.Parse(reader.Current.Value) });
reader.MoveNext();
return expression;
}
public override LuaExpression Parse(INextAwareEnumerator<Token> reader, IParserContext context)
{
var constantValue = Double.Parse(reader.Current.Value);
reader.MoveNext();
return new ConstantExpression(new LuaValue {NumericValue = constantValue});
}
