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