public Expression(Statement statement, SourceData sourceData)
{
Statement = statement;
SourceData = sourceData;
resolveContext = new ExpressionResolveContext();
}
public MethodCallOrArrayDereference(Statement statement, FullNamedExpression member, Expression[] args,
SourceData sourceData)
: base(statement, sourceData)
{
// TODO: Complete member initialization
Member = member;
Arguments = args;
}
public BinaryExpression(Statement statement, Operator op, Expression ret, Expression rhs, SourceData sourceData)
: base(statement, sourceData)
{
// TODO: Complete member initialization
Operator = op;
Left = ret;
Right = rhs;
Left.SetParent(this);
Right.SetParent(this);
}
public GenericNameExpression(Statement statement, SimpleName left, GenericArguments arguments,
SourceData sourceData)
: base(statement, left, sourceData)
{
Arguments = arguments;
}
private void ParseField()
{
#region Old
//bool b = Expect(Token.LeftSquareBracket);
//TokenInfo token = Tokenizer.PeekToken();
//if (token.Is(Token.Identifier) || token.Is(Token.ReservedWord))
//{
//}
//if (Expect(Token.As))
//{
// token = Tokenizer.PeekToken();
// if (Expect(Token.Identifier))
// {
// }
// else
// {
// }
//}
//else
//{
//}
//if (Expect(Token.Equality))
//{
// token = Tokenizer.PeekToken();
// if (Expect(Token.Identifier))
// {
// }
// else
// {
// }
//}
//else
//{
//}
#endregion
TokenInfo token;
Modifier modifiers;
SimpleName name;
FullNamedExpression type;
Expression expr;
modifiers = ParseMethodModifiers();
token = tokenQueue.Dequeue();
name = null;
type = null;
expr = null;
if (token.Is(Token.Identifier))
{
name = new SimpleName(statement, token.Value,
new SourceData(token.GetSpan(token), SourceFile, statementSymbols));
if (EatOptional(Token.As))
{
type = ParseFullName();
}
TokenInfo token3 = Tokenizer.PeekToken();
if (EatOptional(Token.Equality))
{
EatOptional(Token.EOL);
//Set parse context to initializer
MethodDef initializer;
if ((modifiers & Modifier.Shared) == Modifier.Shared)
{
initializer = (MethodDef) this.type.GetTypeInitializer();
}
else
{
initializer = (MethodDef) this.type.GetDefaultConstructor();
}
//Initalize context
method = initializer;
block = method.Body;
var assignStmt = new ExpressionStatement(initializer.Body);
statement = assignStmt;
//Parse initialization expression
expr = ParseExpression();
//Build initialization expression statement
assignStmt.SetExpression(
new BinaryExpression(assignStmt, Operator.Assign,
new VariableAccess(assignStmt,
new SimpleName(assignStmt, name, null), null),
expr, null));
//Add statement
initializer.Body.AddStatement(assignStmt);
//Reset context to null
method = null;
block = null;
statement = null;
if (expr == null)
{
Report.AddItem(VBErrors.ExpressionExpected, SourceFile,
token3.GetSpan(token3), statementSymbols);
}
}
TokenInfo token4 = Tokenizer.PeekToken();
if (token4.Is(Token.EOL))
{
//GetNextToken(); //*
resetStmtTokens();
}
else
{
ExpectEndOfStatementOrEat();
}
}
else
{
GetNextToken();
TokenInfo token2 = Tokenizer.PeekToken();
Report.AddItem(VBErrors.IdentifierExpected, SourceFile,
new SourceSpan(token.GetSourceLocation(), token2.GetSourceLocation()), statementSymbols);
EatToEOL();
}
var fieldDef = new FieldDef(this.type, name, type, modifiers);
fieldDef.SetInitalizationExpression(expr);
((ClassStructOrModuleDef) this.type).AddField(fieldDef);
}
private Statement ParseDeclareStmt()
{
TokenInfo token;
SimpleName name;
FullNamedExpression type;
Expression expr;
tokenQueue.Dequeue();
token = Tokenizer.PeekToken();
name = null;
type = null;
expr = null;
var stmt = new DeclareStatement(block);
statement = stmt;
if (EatOptional(Token.Identifier))
{
name = new SimpleName(statement, token.Value,
new SourceData(token.GetSpan(token), SourceFile, statementSymbols));
if (EatOptional(Token.As))
{
type = ParseFullName();
}
TokenInfo token3 = Tokenizer.PeekToken();
if (EatOptional(Token.Equality))
{
EatOptional(Token.EOL);
expr = ParseExpression();
if (expr == null)
{
Report.AddItem(VBErrors.ExpressionExpected, SourceFile,
token3.GetSpan(token3), statementSymbols);
}
}
TokenInfo token4 = Tokenizer.PeekToken();
if (token4.Is(Token.EOL))
{
//GetNextToken(); //*
resetStmtTokens();
}
else
{
ExpectEndOfStatementOrEat();
}
}
else
{
GetNextToken();
TokenInfo token2 = Tokenizer.PeekToken();
Report.AddItem(VBErrors.IdentifierExpected, SourceFile,
new SourceSpan(token.GetSourceLocation(), token2.GetSourceLocation()), statementSymbols);
EatToEOL();
}
stmt.SetName(name);
stmt.SetType(type);
stmt.SetInitializationExpression(expr);
return stmt;
}
private Statement ParseWhileStmt()
{
tokenQueue.Dequeue();
Expression expr;
Statement inlineStmt;
TokenInfo token;
bool flag = true;
bool inElse;
WhileStatement whileStatement = new WhileStatement(block);
statement = whileStatement;
expr = ParseCompExpr();
whileStatement.SetCondition(expr);
ExpectEndOfStatementOrEat();
block = whileStatement;
while (flag)
{
token = this.Tokenizer.PeekToken();
switch (token.Token)
{
case Token.EOL:
GetNextToken();
break;
case Token.EOF:
GetNextToken();
flag = false;
break;
case Token.End:
GetNextToken();
token = this.Tokenizer.PeekToken();
if (token.Is(Token.While))
{
GetNextToken();
flag = false;
}
else
{
//Unexpected
}
break;
default:
inlineStmt = ParseStatement();
whileStatement.AddStatement(inlineStmt);
statement = whileStatement;
break;
}
}
block = whileStatement.ContainingBlock;
return whileStatement;
}
///// <summary>
///// Parse a REPL-statement.
///// </summary>
///// <returns></returns>
//public Statement ParseReplStatement()
//{
// TokenInfo token;
// Statement statement = null;
// token = Tokenizer.PeekToken();
// if (token.Is(Token.EOF))
// {
// GetNextToken();
// }
// else
// {
// tokenQueue.Enqueue(token);
// switch (token.Token)
// {
// //case Token.Sub:
// // GetNextToken();
// // return new MethodDefStatement(ParseSubroutine(), new SourceData(sourceFile );
// //case Token.Function:
// // GetNextToken();
// // return new MethodDefStatement(ParseFunction());
// case Token.EOL:
// tokenQueue.Dequeue();
// GetNextToken();
// break;
// default:
// tokenQueue.Dequeue();
// statement = ParseStatement();
// break;
// }
// }
// if (statement == null)
// {
// statement = new ErrorStatement(null);
// }
// SourceLocation loc = token.GetSourceLocation();
// //statement.SetLoc(loc);
// return statement;
//}
//private TopLevelBlock ParseBlock(Token end)
//{
// TopLevelBlock block;
// Statement statement;
// bool flag;
// TokenInfo token;
// block = new TopLevelBlock();
// statement = null;
// flag = true;
// while (flag)
// {
// token = this.GetNextToken();
// // Has the end of file been reached?
// if (token.Is(Token.EOF))
// break;
// //Push first token on the token stack
// this.tokenStack.Enqueue(token);
// switch (token.Token)
// {
// // Declaration statement
// case Token.Dim:
// statement = this.state_DeclareStmt();
// break;
// // If statement
// case Token.If:
// statement = this.ParseIfStmt();
// break;
// // For statement
// case Token.For:
// this.Report.FeatureNotImplemented("For statement", token);
// goto default;
// // Return statement
// case Token.Return:
// this.Report.FeatureNotImplemented("Return statement", token);
// goto default;
// // Could be an en of this block
// case Token.End:
// flag = !this.ParseEndStmt(end);
// if (flag)
// continue;
// else
// break;
// // Empty line
// case Token.EOL:
// this.tokenStack.Dequeue();
// continue;
// // Error: Invalid statement
// default:
// this.tokenStack.Dequeue();
// this.Report.Warning("Invalid statement.", token.SourceFile, token.GetSourceLocation(), null);
// ExpectOrEatToEOL();
// break;
// }
// // If faulty statement was found and null was returned then emit error statement
// if (statement == null) statement = new ErrorStatement();
// // Set source location
// SourceLocation loc = token.GetSourceLocation();
// statement.SetLoc(loc);
// // Add statement to block collection
// block.AddStatement(statement);
// }
// return block;
//}
private Statement ParseIfStmt()
{
tokenQueue.Dequeue();
Expression expr;
Statement inlineStmt;
TokenInfo token;
bool flag = true;
bool inElse;
IfStatement ifStatement = new IfStatement(block);
statement = ifStatement;
expr = ParseCompExpr();
ifStatement.SetCondition(expr);
Expect(Token.Then);
ExpectEndOfStatementOrEat();
block = ifStatement;
//flag = ParseBlock(Token.If);
while(flag)
{
token = this.Tokenizer.PeekToken();
switch (token.Token)
{
case Token.EOL:
GetNextToken();
break;
case Token.EOF:
GetNextToken();
flag = false;
break;
case Token.End:
GetNextToken();
token = this.Tokenizer.PeekToken();
if (token.Is(Token.If))
{
GetNextToken();
flag = false;
}
else
{
//Unexpected
}
break;
case Token.Else:
GetNextToken();
EatOptional(Token.EOL);
token = this.Tokenizer.PeekToken();
if (token.Is(Token.If))
{
var tmp1 = ParseIfStmt();
ifStatement.SetElse(tmp1);
statement = ifStatement;
}
else
{
ParseBlock(Token.If);
var tmp1 = CloseBlock();
ifStatement.SetElse(tmp1);
statement = ifStatement;
}
break;
default:
inlineStmt = ParseStatement();
ifStatement.AddStatement(inlineStmt);
statement = ifStatement;
break;
}
}
block = ifStatement.ContainingBlock;
return ifStatement;
}
private Statement ParseReturnStatement()
{
tokenQueue.Dequeue();
var stmt = new ReturnStatement(block);
statement = stmt;
Expression expr = ParseExpression();
stmt.SetExpression(expr);
return stmt;
}
/// <summary>
/// Parse the next-coming statement.
/// </summary>
/// <returns></returns>
public Statement ParseStatement()
{
Expression expr;
bool flag;
TokenInfo token;
statement = null;
flag = true;
while (flag)
{
token = Tokenizer.PeekToken();
if (token.Is(Token.EOF))
break;
tokenQueue.Enqueue(token);
switch (token.Token)
{
case Token.Dim:
GetNextToken();
statement = ParseDeclareStmt();
break;
case Token.If:
GetNextToken();
statement = ParseIfStmt();
break;
case Token.While:
GetNextToken();
statement = ParseWhileStmt();
break;
case Token.For:
GetNextToken();
FeatureNotImplemented(Report, "For statement", token);
goto default;
case Token.Return:
GetNextToken();
statement = ParseReturnStatement();
EatToEOL();
break;
case Token.Sub:
case Token.Function:
GetNextToken();
Report.AddItem(VBErrors.StatementCannotAppearWithinAMethodBodyEndOfMethodAssumedError,
SourceFile, new SourceSpan(token.GetSourceLocation(), default(SourceLocation)),
null);
EatToEOL();
break;
case Token.EOL:
tokenQueue.Dequeue();
GetNextToken();
continue;
default:
tokenQueue.Dequeue();
if (token.Is(Token.LeftParenthesis)
|| Helpers.IsNumber(token)
|| Helpers.IsIdentifier(token)
|| Helpers.IsReservedWord(token))
{
var ret = new ExpressionStatement(block);
statement = ret;
expr = ParseExpression();
ExpectEndOfStatementOrEat();
ret.SetExpression(expr);
return ret;
}
GetNextToken();
Report.AddItem(VBErrors.SyntaxError, SourceFile,
token.GetSpan(token),
statementSymbols);
EatToEOL();
break;
}
break;
}
return statement;
}
private bool ParseBlock(Token end)
{
TokenInfo token;
Statement statement = null;
bool flag = true;
block = new ScopeBlock(method, block);
while (flag)
{
token = Tokenizer.PeekToken();
if (token.Is(Token.EOF))
{
GetNextToken();
return false;
}
tokenQueue.Enqueue(token);
if (token.Is(Token.EOL))
{
tokenQueue.Dequeue();
GetNextToken();
continue;
}
switch (token.Token)
{
case Token.End:
GetNextToken();
flag = !ParseEndStmt(end);
if (flag)
continue;
else
goto end;
//case Token.EOL:
// tokenQueue.Dequeue();
// GetNextToken();
// continue;
case Token.SingleQuote:
TokenList list;
ParseComment(out list);
//CommentStatement stmt = new CommentStatement(block);
//stmt.SetTokenList(list);
//statement = stmt;
//break;
continue;
case Token.DoubleQuote:
SourceLocation slocEnd = skipCharStringLiteral();
var span = new SourceSpan(token.GetSourceLocation(), slocEnd);
Report.AddItem(VBErrors.SyntaxError, SourceFile, span, statementSymbols);
EatToEOL();
resetStmtTokens();
//statement = null;
continue; //break;
default:
tokenQueue.Dequeue();
statement = ParseStatement();
resetStmtTokens();
break;
}
if (statement == null)
{
statement = new ErrorStatement(block);
}
// Set source location
SourceLocation loc = token.GetSourceLocation();
//statement.SetLoc(loc);
// Add statement to block collection
block.AddStatement(statement);
}
end:
return true;
}
public CharStringLiteral(Statement statement, List<TokenInfo> tokens, SourceData sourceData)
: base(statement, sourceData)
{
// TODO: Complete member initialization
this.tokens = tokens;
}
public void AddStatement(Statement statement)
{
statements.Add(statement);
}
public IntegerConstant(Statement statement, int nr, SourceData sourceData)
: base(statement, sourceData)
{
// TODO: Complete member initialization
this.nr = nr;
}
public void SetElse(Ast.Statement statement)
{
this.Else = statement;
}
