mirror of
https://github.com/SSCLI/sscli_20021101
synced 2026-06-08 12:28:57 +00:00
yallie
5013 lines
216 KiB
C#
5013 lines
216 KiB
C#
// ==++==
|
|
//
|
|
//
|
|
// Copyright (c) 2002 Microsoft Corporation. All rights reserved.
|
|
//
|
|
// The use and distribution terms for this software are contained in the file
|
|
// named license.txt, which can be found in the root of this distribution.
|
|
// By using this software in any fashion, you are agreeing to be bound by the
|
|
// terms of this license.
|
|
//
|
|
// You must not remove this notice, or any other, from this software.
|
|
//
|
|
//
|
|
// ==--==
|
|
namespace Microsoft.JScript
|
|
{
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Reflection;
|
|
using System.Text.RegularExpressions;
|
|
using Microsoft.Vsa;
|
|
|
|
//***************************************************************************************
|
|
// JSParser
|
|
//
|
|
// The JScript Parser.
|
|
//***************************************************************************************
|
|
public class JSParser{
|
|
|
|
private Context sourceContext;
|
|
private JSScanner scanner;
|
|
private Context currentToken;
|
|
private Context errorToken; // used for errors to flag that the same token has to be returned.
|
|
// We could have used just a boolean but having a Context does not
|
|
// add any overhead and allow to really save the info, if that will ever be needed
|
|
private int tokensSkipped;
|
|
private const int c_MaxSkippedTokenNumber = 50;
|
|
private NoSkipTokenSet noSkipTokenSet;
|
|
private long goodTokensProcessed;
|
|
|
|
private Block program;
|
|
|
|
// label related info
|
|
private ArrayList blockType ;
|
|
private SimpleHashtable labelTable;
|
|
enum BlockType {Block, Loop, Switch, Finally}
|
|
private int finallyEscaped;
|
|
|
|
private int breakRecursion = 0;
|
|
private static int s_cDummyName;
|
|
#if DEBUG
|
|
private static int s_filenameSuffix = 0;
|
|
#endif
|
|
|
|
Globals Globals;
|
|
private int Severity;
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// JSParser
|
|
//
|
|
// create a parser with a context. The context is the code that has to be compiled.
|
|
// Typically used by the runtime
|
|
//---------------------------------------------------------------------------------------
|
|
public JSParser(Context context){
|
|
this.sourceContext = context;
|
|
this.currentToken = context.Clone();
|
|
this.scanner = new JSScanner(this.currentToken);
|
|
this.noSkipTokenSet = new NoSkipTokenSet();
|
|
|
|
this.errorToken = null;
|
|
this.program = null;
|
|
this.blockType = new ArrayList(16);
|
|
this.labelTable = new SimpleHashtable(16);
|
|
this.finallyEscaped = 0;
|
|
this.Globals = context.document.engine.Globals;
|
|
this.Severity = 5;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// Parse
|
|
//
|
|
// Parser main entry point. Parse all the source code and return the root of the AST
|
|
//---------------------------------------------------------------------------------------
|
|
public ScriptBlock Parse(){
|
|
Block ast = ParseStatements(false);
|
|
return new ScriptBlock(this.sourceContext.Clone(), ast);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseEvalBody
|
|
//
|
|
// Parser main entry point for Eval. Parse all the source code and return the root of the AST
|
|
//---------------------------------------------------------------------------------------
|
|
public Block ParseEvalBody(){
|
|
return ParseStatements(true);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseExpressionItem
|
|
//
|
|
// A VSAITEMTYPE2.EXPRESSION call into here to parse an expression
|
|
//---------------------------------------------------------------------------------------
|
|
internal ScriptBlock ParseExpressionItem(){
|
|
try{
|
|
Block block = new Block(this.sourceContext.Clone());
|
|
GetNextToken();
|
|
block.Append(new Expression(this.sourceContext.Clone(), ParseExpression()));
|
|
return new ScriptBlock(this.sourceContext.Clone(), block);
|
|
}catch (EndOfFile){
|
|
}catch (ScannerException se){
|
|
// a scanner exception implies that the end of file has been reached with an error.
|
|
// Mark the end of file as the error location
|
|
EOFError(se.m_errorId);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseStatements
|
|
//
|
|
// statements :
|
|
// <empty> |
|
|
// statement statements |
|
|
// ImportStatement
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
private Block ParseStatements(bool insideEval){
|
|
this.program = new Block(this.sourceContext.Clone());
|
|
this.blockType.Add(BlockType.Block);
|
|
this.errorToken = null;
|
|
try{
|
|
GetNextToken();
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_TopLevelNoSkipTokenSet);
|
|
|
|
try{
|
|
while (this.currentToken.token != JSToken.EndOfFile){
|
|
AST ast = null;
|
|
try{
|
|
if (this.currentToken.token == JSToken.Package && !insideEval){
|
|
ast = ParsePackage(this.currentToken.Clone());
|
|
}else if (this.currentToken.token == JSToken.Import && !insideEval){
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet);
|
|
try{
|
|
ast = ParseImportStatement();
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet, exc) != -1){
|
|
ast = exc._partiallyComputedNode;
|
|
if (exc._token == JSToken.Semicolon)
|
|
GetNextToken();
|
|
}else{
|
|
throw exc;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet);
|
|
}
|
|
}else
|
|
ast = ParseStatement();
|
|
}catch(RecoveryTokenException exc){
|
|
if (TokenInList(NoSkipTokenSet.s_TopLevelNoSkipTokenSet, exc)
|
|
|| TokenInList(NoSkipTokenSet.s_StartStatementNoSkipTokenSet, exc)){
|
|
ast = exc._partiallyComputedNode;
|
|
}else{
|
|
this.errorToken = null;
|
|
do{
|
|
GetNextToken();
|
|
}while(this.currentToken.token != JSToken.EndOfFile && !TokenInList(NoSkipTokenSet.s_TopLevelNoSkipTokenSet, this.currentToken.token)
|
|
&& !TokenInList(NoSkipTokenSet.s_StartStatementNoSkipTokenSet, this.currentToken.token));
|
|
}
|
|
}
|
|
|
|
if (null != ast)
|
|
this.program.Append(ast);
|
|
}
|
|
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_TopLevelNoSkipTokenSet);
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
|
|
}
|
|
|
|
}catch (EndOfFile){
|
|
}catch (ScannerException se){
|
|
// a scanner exception implies that the end of file has been reached with an error.
|
|
// Mark the end of file as the error location
|
|
EOFError(se.m_errorId);
|
|
}
|
|
return this.program;
|
|
}
|
|
|
|
#if DEBUG
|
|
//---------------------------------------------------------------------------------------
|
|
// Tokenize
|
|
//
|
|
// Debug only
|
|
//---------------------------------------------------------------------------------------
|
|
public void Tokenize(){
|
|
try{
|
|
GetNextToken();
|
|
long i = 1;
|
|
while(this.currentToken.token != JSToken.EndOfFile){
|
|
//Console.Out.WriteLine(this.currentToken.GetCode());
|
|
GetNextToken();
|
|
i++;
|
|
}
|
|
Console.Out.WriteLine("\nNumber of Tokens: " + i);
|
|
}catch (ScannerException se){
|
|
Console.Out.WriteLine("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
|
|
Console.Out.WriteLine("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
|
|
Console.Out.WriteLine("Scanner Error:\t");
|
|
Console.Out.WriteLine(se.Message);
|
|
}
|
|
}
|
|
#endif //DEBUG
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseStatement
|
|
//
|
|
// OptionalStatement:
|
|
// Statement |
|
|
// <empty>
|
|
//
|
|
// Statement :
|
|
// Block |
|
|
// VariableStatement |
|
|
// EmptyStatement |
|
|
// ExpressionStatement |
|
|
// IfStatement |
|
|
// IterationStatement |
|
|
// ContinueStatement |
|
|
// BreakStatement |
|
|
// ReturnStatement |
|
|
// WithStatement |
|
|
// LabeledStatement |
|
|
// SwitchStatement |
|
|
// ThrowStatement |
|
|
// TryStatement |
|
|
// QualifiedDeclaration |
|
|
// Class |
|
|
// FunctionDeclaration
|
|
//
|
|
// IterationStatement :
|
|
// 'for' '(' ForLoopControl ')' | ===> ForStatement
|
|
// 'do' Statement 'while' '(' Expression ')' | ===> DoStatement
|
|
// 'while' '(' Expression ')' Statement ===> WhileStatement
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
|
|
// ParseStatement deals with the end of statement issue (EOL vs ';') so if any of the
|
|
// ParseXXX routine does it as well, it should return directly from the switch statement
|
|
// without any further execution in the ParseStatement
|
|
private AST ParseStatement(){
|
|
AST statement = null;
|
|
String id = null;
|
|
|
|
switch (this.currentToken.token){
|
|
case JSToken.EndOfFile:
|
|
EOFError(JSError.ErrEOF);
|
|
throw new EndOfFile(); // abort parsing, get back to the main parse routine
|
|
case JSToken.Debugger:
|
|
statement = new DebugBreak(this.currentToken.Clone());
|
|
GetNextToken();
|
|
break;
|
|
case JSToken.Semicolon:
|
|
// make an empty statement
|
|
statement = new Block(this.currentToken.Clone());
|
|
GetNextToken();
|
|
return statement;
|
|
case JSToken.RightCurly:
|
|
ReportError(JSError.SyntaxError);
|
|
SkipTokensAndThrow();
|
|
break;
|
|
case JSToken.LeftCurly:
|
|
return ParseBlock();
|
|
case JSToken.Var:
|
|
case JSToken.Const:
|
|
return ParseVariableStatement((FieldAttributes)0, null, this.currentToken.token);
|
|
case JSToken.If:
|
|
return ParseIfStatement();
|
|
case JSToken.For:
|
|
return ParseForStatement();
|
|
case JSToken.Do:
|
|
return ParseDoStatement();
|
|
case JSToken.While:
|
|
return ParseWhileStatement();
|
|
case JSToken.Continue:
|
|
statement = ParseContinueStatement();
|
|
if (null == statement)
|
|
return new Block(CurrentPositionContext());
|
|
else
|
|
return statement;
|
|
case JSToken.Break:
|
|
statement = ParseBreakStatement();
|
|
if (null == statement)
|
|
return new Block(CurrentPositionContext());
|
|
else
|
|
return statement;
|
|
case JSToken.Return:
|
|
statement = ParseReturnStatement();
|
|
if (null == statement)
|
|
return new Block(CurrentPositionContext());
|
|
else
|
|
return statement;
|
|
case JSToken.With:
|
|
return ParseWithStatement();
|
|
case JSToken.Switch:
|
|
return ParseSwitchStatement();
|
|
case JSToken.Super:
|
|
case JSToken.This:
|
|
Context superCtx = this.currentToken.Clone();
|
|
if (JSToken.LeftParen == this.scanner.PeekToken())
|
|
statement = ParseConstructorCall(superCtx);
|
|
else
|
|
goto default;
|
|
break;
|
|
case JSToken.Throw:
|
|
statement = ParseThrowStatement();
|
|
if (statement == null)
|
|
return new Block(CurrentPositionContext());
|
|
else
|
|
break;
|
|
case JSToken.Try:
|
|
return ParseTryStatement();
|
|
case JSToken.Internal:
|
|
case JSToken.Public:
|
|
case JSToken.Static:
|
|
case JSToken.Private:
|
|
case JSToken.Protected:
|
|
case JSToken.Abstract:
|
|
case JSToken.Final:
|
|
bool parsedOK;
|
|
statement = ParseAttributes(null, false, false, out parsedOK);
|
|
if (!parsedOK){
|
|
statement = ParseExpression(statement, false, true, JSToken.None);
|
|
statement = new Expression(statement.context.Clone(), statement);
|
|
break;
|
|
}else
|
|
return statement;
|
|
case JSToken.Package:
|
|
Context packageContext = this.currentToken.Clone();
|
|
statement = ParsePackage(packageContext);
|
|
if (statement is Package){
|
|
// handle common error of using import in function
|
|
ReportError(JSError.PackageInWrongContext, packageContext, true);
|
|
// make an empty statement
|
|
statement = new Block(packageContext);
|
|
}
|
|
break;
|
|
case JSToken.Interface:
|
|
case JSToken.Class:
|
|
return ParseClass((FieldAttributes)0, false, this.currentToken.Clone(), false, false, null);
|
|
case JSToken.Enum:
|
|
return ParseEnum((FieldAttributes)0, this.currentToken.Clone(), null);
|
|
case JSToken.Function:
|
|
return ParseFunction((FieldAttributes)0, false, this.currentToken.Clone(), false, false, false, false, null); //Parse a function as a statement
|
|
case JSToken.Else:
|
|
ReportError(JSError.InvalidElse);
|
|
SkipTokensAndThrow();
|
|
break;
|
|
case JSToken.Import:
|
|
// handle common error of using import in function
|
|
ReportError(JSError.InvalidImport, true);
|
|
// make an empty statement
|
|
statement = new Block(this.currentToken.Clone());
|
|
try{
|
|
ParseImportStatement();
|
|
}catch(RecoveryTokenException){
|
|
}
|
|
break;
|
|
default:
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet);
|
|
bool exprError = false;
|
|
try{
|
|
bool bAssign, canBeAttribute = true;
|
|
statement = ParseUnaryExpression(out bAssign, ref canBeAttribute, false);
|
|
if (canBeAttribute){
|
|
// look for labels
|
|
if (statement is Lookup){
|
|
if (JSToken.Colon == this.currentToken.token){
|
|
// can be a label
|
|
id = statement.ToString();
|
|
if (null != this.labelTable[id]){
|
|
// there is already a label with that name. Ignore the current label
|
|
ReportError(JSError.BadLabel, statement.context.Clone(), true);
|
|
id = null;
|
|
GetNextToken(); // skip over ':'
|
|
return new Block(CurrentPositionContext());
|
|
}else{
|
|
GetNextToken();
|
|
this.labelTable[id] = this.blockType.Count;
|
|
if (JSToken.EndOfFile != this.currentToken.token)
|
|
statement = ParseStatement();
|
|
else
|
|
statement = new Block(CurrentPositionContext());
|
|
this.labelTable.Remove(id);
|
|
return statement;
|
|
}
|
|
}
|
|
}
|
|
// look for custom attributes
|
|
if (JSToken.Semicolon != this.currentToken.token && !this.scanner.GotEndOfLine()){
|
|
bool parsed;
|
|
statement = ParseAttributes(statement, false, false, out parsed);
|
|
if (parsed)
|
|
return statement;
|
|
}
|
|
}
|
|
statement = ParseExpression(statement, false, bAssign, JSToken.None);
|
|
statement = new Expression(statement.context.Clone(), statement);
|
|
}catch(RecoveryTokenException exc){
|
|
if (exc._partiallyComputedNode != null)
|
|
statement = exc._partiallyComputedNode;
|
|
|
|
if (statement == null){
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet);
|
|
exprError = true;
|
|
SkipTokensAndThrow();
|
|
}
|
|
|
|
if (IndexOfToken(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet, exc) == -1){
|
|
exc._partiallyComputedNode = statement;
|
|
throw exc;
|
|
}
|
|
}finally{
|
|
if (!exprError)
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet);
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (JSToken.Semicolon == this.currentToken.token){
|
|
statement.context.UpdateWith(this.currentToken);
|
|
GetNextToken();
|
|
}else if (!this.scanner.GotEndOfLine() && JSToken.RightCurly != this.currentToken.token && JSToken.EndOfFile != this.currentToken.token)
|
|
ReportError(JSError.NoSemicolon, true);
|
|
|
|
return statement;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseAttributes
|
|
//
|
|
// Package :
|
|
// Attributes 'package' QualifiedIdentifier '{' ClassList '}'
|
|
// AttributesStart 'package' QualifiedIdentifier '{' ClassList '}'
|
|
//
|
|
// Class :
|
|
// Attributes 'class' Identifier ['extends' QualifiedIdentifier] '{' ClassBody '}'
|
|
// AttributesStart 'class' Identifier ['extends' QualifiedIdentifier] '{' ClassBody '}'
|
|
//
|
|
// FunctionDeclaration :
|
|
// Attributes 'function' Identifier '(' [FormalParameterList] ')' [':' TypeExpression] '{' FunctionBody '}'
|
|
// AttributesStart 'function' Identifier '(' [FormalParameterList] ')' [':' TypeExpression] '{' FunctionBody '}'
|
|
//
|
|
// VariableStatement :
|
|
// Attributes 'var' VariableDeclarationList
|
|
// AttributesStart 'var' VariableDeclarationList
|
|
//
|
|
// Attributes :
|
|
// AttributesStart AttributesNext |
|
|
// Modifier [AttributeNext]
|
|
//
|
|
// AttributesStart :
|
|
// QualifiedIdentifier /no LineTerminator here/ |
|
|
// QualifiedIdentifier Arguments /no LineTerminator here/
|
|
//
|
|
// AttributesNext :
|
|
// QualifiedIdentifier [AttributesNext] |
|
|
// QualifiedIdentifier Arguments [AttributesNext] |
|
|
// Modifier [AttributesNext]
|
|
//
|
|
// Modifier :
|
|
// 'private' |
|
|
// 'public' |
|
|
// 'protected' |
|
|
// 'internal' |
|
|
// 'package' | //This is going away
|
|
// 'static' |
|
|
// 'abstract'
|
|
//
|
|
//
|
|
// Parse the list of attributes and the statement those attributes refer to.
|
|
// It comes back with one of the following: package, class, function, variable declaration.
|
|
// When in error it may return other AST constructs depending on the context.
|
|
// The input is a possible attribute in the form of 'QualifiedIdentifier' or a sequence
|
|
// 'QualifiedIdentifier Arguments' or null when the first attribute was a Modifier.
|
|
// The whole sequence may be an error in the first place, so we want to keep
|
|
// things such that we can always parse the supposed list of attributes as an ast list
|
|
//---------------------------------------------------------------------------------------
|
|
|
|
AST ParseAttributes(AST statement, bool unambiguousContext, bool isInsideClass, out bool parsedOK){
|
|
|
|
// used later to verify whether anything at all has been processed
|
|
AST inputAST = statement;
|
|
|
|
// keep two list of errors. One holds the 'missing ;' errors that would result in the token
|
|
// stream being parsed as a list of expressions, the other is the list of attributes errors
|
|
// that would result from the token stream being parsed as a list of attributes. We need both because
|
|
// we don't know until the end which is which
|
|
ArrayList semicolonErrors = new ArrayList();
|
|
|
|
// keep track of the modifiers context in case they'll have to be parsed as identifiers, we give the warning out
|
|
ArrayList modifiersAsIdentifier = new ArrayList();
|
|
|
|
// this list has two elements for each error, the first (even position - 0 based) is the error type
|
|
// the second is the context
|
|
ArrayList attributesErrors = new ArrayList();
|
|
|
|
// keep the last ast node parsed. Used if we have to "revert" to the expression list production.
|
|
// We just return the last ast processed, after all is an error condition
|
|
AST lastAST = null;
|
|
|
|
// keep the list of attributes
|
|
ArrayList attributes = new ArrayList();
|
|
|
|
// hold the context for the 'abstract' keyword and it is used as a flag for its presence
|
|
Context abstractContext = null;
|
|
// hold the context for the 'static' keyword and it is used as a flag for its presence
|
|
Context staticContext = null;
|
|
// hold the context for the 'final' keyword and it is used as a flag for its presence
|
|
Context finalContext = null;
|
|
|
|
// keep the number of consecutive token no separated by end of line. Once that number
|
|
// reaches 2 the token stream is parsed *only* as a sequence of attributes
|
|
int TokenCountNoEOL = 0;
|
|
if (unambiguousContext)
|
|
TokenCountNoEOL = 2;
|
|
|
|
FieldAttributes visibilitySpec = (FieldAttributes)0, currVis = (FieldAttributes)0;
|
|
|
|
Context statementContext = null;
|
|
// null when coming from a visibility modifier
|
|
if (statement != null){
|
|
lastAST = statement;
|
|
attributes.Add(statement);
|
|
semicolonErrors.Add(CurrentPositionContext());
|
|
statementContext = statement.context.Clone();
|
|
TokenCountNoEOL = 1;
|
|
}else{
|
|
statementContext = this.currentToken.Clone();
|
|
}
|
|
|
|
parsedOK = true;
|
|
while (true){
|
|
JSToken attributeToken = JSToken.None;
|
|
switch (this.currentToken.token){
|
|
case JSToken.Public:
|
|
case JSToken.Static:
|
|
case JSToken.Private:
|
|
case JSToken.Protected:
|
|
case JSToken.Abstract:
|
|
case JSToken.Final:
|
|
case JSToken.Internal:
|
|
attributeToken = this.currentToken.token;
|
|
goto case JSToken.Identifier;
|
|
case JSToken.Var:
|
|
case JSToken.Const:
|
|
for (int i = 0, n = attributesErrors.Count; i < n; i += 2)
|
|
ReportError((JSError)attributesErrors[i], (Context)attributesErrors[i + 1], true);
|
|
if (abstractContext != null)
|
|
ReportError(JSError.IllegalVisibility, abstractContext, true);
|
|
if (finalContext != null)
|
|
ReportError(JSError.IllegalVisibility, finalContext, true);
|
|
statementContext.UpdateWith(this.currentToken);
|
|
return ParseVariableStatement(visibilitySpec, FromASTListToCustomAttributeList(attributes), this.currentToken.token);
|
|
case JSToken.Function:
|
|
for (int i = 0, n = attributesErrors.Count; i < n; i += 2)
|
|
ReportError((JSError)attributesErrors[i], (Context)attributesErrors[i + 1], true);
|
|
statementContext.UpdateWith(this.currentToken);
|
|
if (staticContext != null)
|
|
if (abstractContext != null){
|
|
staticContext.HandleError(JSError.AbstractCannotBeStatic);
|
|
staticContext = null;
|
|
}else if (finalContext != null){
|
|
finalContext.HandleError(JSError.StaticIsAlreadyFinal);
|
|
finalContext = null;
|
|
}
|
|
if (abstractContext != null){
|
|
if (finalContext != null){
|
|
finalContext.HandleError(JSError.FinalPrecludesAbstract);
|
|
finalContext = null;
|
|
}
|
|
if (currVis == FieldAttributes.Private){
|
|
abstractContext.HandleError(JSError.AbstractCannotBePrivate);
|
|
currVis = FieldAttributes.Family;
|
|
}
|
|
}
|
|
return ParseFunction(visibilitySpec, false, statementContext, isInsideClass,
|
|
abstractContext != null, finalContext != null, false, FromASTListToCustomAttributeList(attributes));
|
|
case JSToken.Interface:
|
|
if (abstractContext != null){
|
|
ReportError(JSError.IllegalVisibility, abstractContext, true);
|
|
abstractContext = null;
|
|
}
|
|
if (finalContext != null){
|
|
ReportError(JSError.IllegalVisibility, finalContext, true);
|
|
finalContext = null;
|
|
}
|
|
if (staticContext != null){
|
|
ReportError(JSError.IllegalVisibility, staticContext, true);
|
|
staticContext = null;
|
|
}
|
|
goto case JSToken.Class;
|
|
case JSToken.Class:
|
|
for (int i = 0, n = attributesErrors.Count; i < n; i += 2)
|
|
ReportError((JSError)attributesErrors[i], (Context)attributesErrors[i + 1], true);
|
|
statementContext.UpdateWith(this.currentToken);
|
|
if (finalContext != null && abstractContext != null)
|
|
finalContext.HandleError(JSError.FinalPrecludesAbstract);
|
|
return ParseClass(visibilitySpec, staticContext != null, statementContext,
|
|
abstractContext != null, finalContext != null, FromASTListToCustomAttributeList(attributes));
|
|
case JSToken.Enum:
|
|
for (int i = 0, n = attributesErrors.Count; i < n; i += 2)
|
|
ReportError((JSError)attributesErrors[i], (Context)attributesErrors[i + 1], true);
|
|
statementContext.UpdateWith(this.currentToken);
|
|
if (abstractContext != null)
|
|
ReportError(JSError.IllegalVisibility, abstractContext, true);
|
|
if (finalContext != null)
|
|
ReportError(JSError.IllegalVisibility, finalContext, true);
|
|
if (staticContext != null)
|
|
ReportError(JSError.IllegalVisibility, staticContext, true);
|
|
return ParseEnum(visibilitySpec, statementContext, FromASTListToCustomAttributeList(attributes));
|
|
case JSToken.Void:
|
|
case JSToken.Boolean:
|
|
case JSToken.Byte:
|
|
case JSToken.Char:
|
|
case JSToken.Double:
|
|
case JSToken.Float:
|
|
case JSToken.Int:
|
|
case JSToken.Long:
|
|
case JSToken.Short: {
|
|
|
|
// The user has some sequence like "public int foo()", which
|
|
// is probably a C-style function declaration. Save that away,
|
|
// keep parsing and see if this ends in what looks like a function
|
|
// or variable declaration.
|
|
|
|
parsedOK = false;
|
|
lastAST = new Lookup(this.currentToken);
|
|
attributeToken = JSToken.None;
|
|
attributes.Add(lastAST);
|
|
GetNextToken();
|
|
goto continueLoop;
|
|
}
|
|
case JSToken.Identifier: {
|
|
bool bAssign, canBeAttribute = true;
|
|
statement = ParseUnaryExpression(out bAssign, ref canBeAttribute, false, attributeToken == JSToken.None);
|
|
lastAST = statement;
|
|
if (attributeToken != JSToken.None){
|
|
if (statement is Lookup)
|
|
break;
|
|
else{
|
|
if (TokenCountNoEOL != 2)
|
|
modifiersAsIdentifier.Add(this.currentToken.Clone());
|
|
}
|
|
}
|
|
attributeToken = JSToken.None;
|
|
if (canBeAttribute){
|
|
attributes.Add(statement);
|
|
goto continueLoop;
|
|
}else
|
|
goto default;
|
|
}
|
|
// the following cases are somewhat interesting because they can be determined by a user missing
|
|
// the keyword 'var' or 'function', as, for instance, when coming from C/C++/C# code
|
|
default:
|
|
parsedOK = false;
|
|
if (TokenCountNoEOL != 2){
|
|
if (inputAST != statement || statement == null){
|
|
Debug.Assert(lastAST != null);
|
|
// only return the last statement
|
|
statement = lastAST;
|
|
// output the semicolon errors
|
|
for (int i = 0, n = modifiersAsIdentifier.Count; i < n; i++)
|
|
ForceReportInfo((Context)modifiersAsIdentifier[i], JSError.KeywordUsedAsIdentifier);
|
|
for (int i = 0, n = semicolonErrors.Count; i < n; i++)
|
|
if (!this.currentToken.Equals((Context)semicolonErrors[i]))
|
|
ReportError(JSError.NoSemicolon, (Context)semicolonErrors[i], true);
|
|
}
|
|
return statement;
|
|
}else{
|
|
if (attributes.Count > 0){
|
|
// check for possible common mistakes
|
|
AST ast = (AST)attributes[attributes.Count - 1];
|
|
if (ast is Lookup){
|
|
if (JSToken.Semicolon == this.currentToken.token
|
|
|| JSToken.Colon == this.currentToken.token){
|
|
ReportError(JSError.BadVariableDeclaration, ast.context.Clone());
|
|
SkipTokensAndThrow();
|
|
}
|
|
}else if (ast is Call && ((Call)ast).CanBeFunctionDeclaration()){
|
|
if (JSToken.Colon == this.currentToken.token
|
|
|| JSToken.LeftCurly == this.currentToken.token){
|
|
ReportError(JSError.BadFunctionDeclaration, ast.context.Clone(), true);
|
|
if (JSToken.Colon == this.currentToken.token){
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_StartBlockNoSkipTokenSet);
|
|
try{
|
|
SkipTokensAndThrow();
|
|
}catch(RecoveryTokenException){
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_StartBlockNoSkipTokenSet);
|
|
}
|
|
}
|
|
this.errorToken = null;
|
|
if (JSToken.LeftCurly == this.currentToken.token){
|
|
FunctionScope fscope = new FunctionScope(Globals.ScopeStack.Peek(), isInsideClass);
|
|
Globals.ScopeStack.Push(fscope);
|
|
try{
|
|
ParseBlock();
|
|
}finally{
|
|
Globals.ScopeStack.Pop();
|
|
}
|
|
SkipTokensAndThrow();
|
|
}
|
|
}
|
|
else
|
|
ReportError(JSError.SyntaxError, ast.context.Clone());
|
|
SkipTokensAndThrow();
|
|
}
|
|
}
|
|
|
|
if (JSToken.LeftCurly == this.currentToken.token){
|
|
if (isInsideClass){
|
|
// parse it like a static initializer
|
|
|
|
// flush all the possible attribute errors
|
|
for (int i = 0, n = attributesErrors.Count; i < n; i += 2)
|
|
ReportError((JSError)attributesErrors[i], (Context)attributesErrors[i + 1]);
|
|
if (staticContext == null)
|
|
ReportError(JSError.StaticMissingInStaticInit, CurrentPositionContext());
|
|
String className = ((ClassScope)Globals.ScopeStack.Peek()).name;
|
|
bool reportNoIdentifier = true;
|
|
foreach (Object attr in attributes){
|
|
reportNoIdentifier = false;
|
|
if (staticContext != null && attr is Lookup && attr.ToString() == className &&
|
|
((Lookup)attr).context.StartColumn > staticContext.StartColumn)
|
|
continue;
|
|
ReportError(JSError.SyntaxError, ((AST)attr).context);
|
|
}
|
|
if (reportNoIdentifier)
|
|
ReportError(JSError.NoIdentifier, CurrentPositionContext());
|
|
|
|
this.errorToken = null; // we want to go to next token regardless of whether or not we had an error
|
|
// return a static initializer
|
|
parsedOK = true;
|
|
return ParseStaticInitializer(statementContext);
|
|
}
|
|
}
|
|
|
|
//mark them all as errors
|
|
ReportError(JSError.MissingConstructForAttributes, statementContext.CombineWith(this.currentToken));
|
|
}
|
|
|
|
SkipTokensAndThrow();
|
|
break;
|
|
}
|
|
|
|
switch (attributeToken){
|
|
case JSToken.Public:
|
|
currVis = FieldAttributes.Public;
|
|
break;
|
|
case JSToken.Static:
|
|
if (isInsideClass){
|
|
currVis = FieldAttributes.Static;
|
|
if (staticContext != null){
|
|
attributesErrors.Add(JSError.SyntaxError);
|
|
attributesErrors.Add(statement.context.Clone());
|
|
}else
|
|
staticContext = statement.context.Clone();
|
|
}else{
|
|
attributesErrors.Add(JSError.NotInsideClass);
|
|
attributesErrors.Add(statement.context.Clone());
|
|
}
|
|
break;
|
|
case JSToken.Private:
|
|
if (isInsideClass)
|
|
currVis = FieldAttributes.Private;
|
|
else{
|
|
attributesErrors.Add(JSError.NotInsideClass);
|
|
attributesErrors.Add(statement.context.Clone());
|
|
}
|
|
break;
|
|
case JSToken.Protected:
|
|
if (isInsideClass){
|
|
currVis = FieldAttributes.Family;
|
|
}else{
|
|
attributesErrors.Add(JSError.NotInsideClass);
|
|
attributesErrors.Add(statement.context.Clone());
|
|
}
|
|
break;
|
|
case JSToken.Abstract:
|
|
if (abstractContext != null){
|
|
attributesErrors.Add(JSError.SyntaxError);
|
|
attributesErrors.Add(statement.context.Clone());
|
|
}else
|
|
abstractContext = statement.context.Clone();
|
|
goto continueLoop;
|
|
case JSToken.Final:
|
|
if (finalContext != null){
|
|
attributesErrors.Add(JSError.SyntaxError);
|
|
attributesErrors.Add(statement.context.Clone());
|
|
}else
|
|
finalContext = statement.context.Clone();
|
|
goto continueLoop;
|
|
case JSToken.Internal:
|
|
currVis = FieldAttributes.Assembly;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
// come here only after a visibility Modifer
|
|
if ((visibilitySpec & FieldAttributes.FieldAccessMask) == currVis && currVis != (FieldAttributes)0){
|
|
attributesErrors.Add(JSError.DupVisibility);
|
|
attributesErrors.Add(statement.context.Clone());
|
|
}else if ((visibilitySpec & FieldAttributes.FieldAccessMask) > (FieldAttributes)0 && (currVis & FieldAttributes.FieldAccessMask) > (FieldAttributes)0){
|
|
if ((currVis == FieldAttributes.Family && (visibilitySpec & FieldAttributes.FieldAccessMask) == FieldAttributes.Assembly) ||
|
|
(currVis == FieldAttributes.Assembly && (visibilitySpec & FieldAttributes.FieldAccessMask) == FieldAttributes.Family)){
|
|
visibilitySpec &= ~FieldAttributes.FieldAccessMask;
|
|
visibilitySpec |= FieldAttributes.FamORAssem;
|
|
}else{
|
|
attributesErrors.Add(JSError.IncompatibleVisibility);
|
|
attributesErrors.Add(statement.context.Clone());
|
|
}
|
|
}else{
|
|
visibilitySpec |= currVis;
|
|
statementContext.UpdateWith(statement.context);
|
|
}
|
|
continueLoop:
|
|
if (TokenCountNoEOL != 2){
|
|
if (this.scanner.GotEndOfLine()){
|
|
TokenCountNoEOL = 0;
|
|
}else{
|
|
TokenCountNoEOL++;
|
|
semicolonErrors.Add(this.currentToken.Clone());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseBlock
|
|
//
|
|
// Block :
|
|
// '{' OptionalStatements '}'
|
|
//---------------------------------------------------------------------------------------
|
|
Block ParseBlock(){
|
|
Context ctx;
|
|
return ParseBlock(out ctx);
|
|
}
|
|
|
|
Block ParseBlock(out Context closingBraceContext){
|
|
closingBraceContext = null;
|
|
this.blockType.Add(BlockType.Block);
|
|
Block codeBlock = new Block(this.currentToken.Clone());
|
|
GetNextToken();
|
|
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_BlockNoSkipTokenSet);
|
|
try{
|
|
try{
|
|
while (JSToken.RightCurly != this.currentToken.token){
|
|
try{
|
|
codeBlock.Append(ParseStatement());
|
|
}catch(RecoveryTokenException exc){
|
|
if (exc._partiallyComputedNode != null)
|
|
codeBlock.Append(exc._partiallyComputedNode);
|
|
if (IndexOfToken(NoSkipTokenSet.s_StartStatementNoSkipTokenSet, exc) == -1)
|
|
throw exc;
|
|
}
|
|
}
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_BlockNoSkipTokenSet, exc) == -1){
|
|
exc._partiallyComputedNode = codeBlock;
|
|
throw exc;
|
|
}
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockNoSkipTokenSet);
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
|
|
this.blockType.RemoveAt(this.blockType.Count - 1);
|
|
}
|
|
|
|
closingBraceContext = this.currentToken.Clone();
|
|
// update the block context
|
|
codeBlock.context.UpdateWith(this.currentToken);
|
|
GetNextToken();
|
|
return codeBlock;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseVariableStatement
|
|
//
|
|
// VariableStatement :
|
|
// ('var' | 'const') VariableDeclarationList
|
|
//
|
|
// VariableDeclarationList :
|
|
// VariableDeclaration |
|
|
// VariableDeclaration ',' VariableDeclarationList
|
|
//
|
|
// VariableDeclaration :
|
|
// Identifier Type Initializer
|
|
//
|
|
// Type :
|
|
// <empty> |
|
|
// ':' TypeExpression
|
|
//
|
|
// Initializer :
|
|
// <empty> |
|
|
// '=' AssignmentExpression
|
|
//---------------------------------------------------------------------------------------
|
|
private AST ParseVariableStatement(FieldAttributes visibility, CustomAttributeList customAttributes, JSToken kind){
|
|
Block varList = new Block(this.currentToken.Clone());
|
|
bool single = true;
|
|
AST vdecl = null;
|
|
|
|
for (;;){
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_EndOfLineToken);
|
|
try{
|
|
vdecl = ParseIdentifierInitializer(JSToken.None, visibility, customAttributes, kind);
|
|
}catch(RecoveryTokenException exc){
|
|
// an exception is passing by, possibly bringing some info, save the info if any
|
|
if (exc._partiallyComputedNode != null){
|
|
if (!single){
|
|
varList.Append(exc._partiallyComputedNode);
|
|
varList.context.UpdateWith(exc._partiallyComputedNode.context);
|
|
exc._partiallyComputedNode = varList;
|
|
}
|
|
}
|
|
if (IndexOfToken(NoSkipTokenSet.s_EndOfLineToken, exc) == -1)
|
|
throw exc;
|
|
else{
|
|
if (single)
|
|
vdecl = exc._partiallyComputedNode;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_EndOfLineToken);
|
|
}
|
|
|
|
if (JSToken.Semicolon == this.currentToken.token || JSToken.RightCurly == this.currentToken.token){
|
|
if (JSToken.Semicolon == this.currentToken.token){
|
|
vdecl.context.UpdateWith(this.currentToken);
|
|
GetNextToken();
|
|
}
|
|
break;
|
|
}else if (JSToken.Comma == this.currentToken.token){
|
|
single = false;
|
|
varList.Append(vdecl);
|
|
continue;
|
|
}else if (this.scanner.GotEndOfLine()){
|
|
break;
|
|
}else{
|
|
// assume the variable statement was terminated and move on
|
|
ReportError(JSError.NoSemicolon, true);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (single)
|
|
return vdecl;
|
|
else{
|
|
varList.Append(vdecl);
|
|
varList.context.UpdateWith(vdecl.context);
|
|
return varList;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseIdentifierInitializer
|
|
//
|
|
// Does the real work of parsing a single variable declaration.
|
|
// inToken is JSToken.In whenever the potential expression that initialize a variable
|
|
// cannot contain an 'in', as in the for statement. inToken is JSToken.None otherwise
|
|
//---------------------------------------------------------------------------------------
|
|
private AST ParseIdentifierInitializer(JSToken inToken,
|
|
FieldAttributes visibility,
|
|
CustomAttributeList customAttributes,
|
|
JSToken kind){
|
|
Lookup id = null;
|
|
TypeExpression typeExpr = null;
|
|
AST assignmentExpr = null;
|
|
RecoveryTokenException except = null;
|
|
|
|
GetNextToken();
|
|
if (JSToken.Identifier != this.currentToken.token){
|
|
String identifier = JSKeyword.CanBeIdentifier(this.currentToken.token);
|
|
if (null != identifier){
|
|
ForceReportInfo(JSError.KeywordUsedAsIdentifier);
|
|
id = new Lookup(identifier, this.currentToken.Clone());
|
|
}else{
|
|
// make up an identifier and keep going; life goes on...
|
|
ReportError(JSError.NoIdentifier);
|
|
id = new Lookup("#_Missing Identifier_#" + s_cDummyName++, CurrentPositionContext());
|
|
}
|
|
}else
|
|
id = new Lookup(this.scanner.GetIdentifier(), this.currentToken.Clone());
|
|
GetNextToken();
|
|
Context context = id.context.Clone();
|
|
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_VariableDeclNoSkipTokenSet);
|
|
try{
|
|
if (JSToken.Colon == this.currentToken.token){
|
|
try{
|
|
typeExpr = ParseTypeExpression();
|
|
}catch(RecoveryTokenException exc){
|
|
typeExpr = (TypeExpression)exc._partiallyComputedNode;
|
|
throw exc;
|
|
}finally{
|
|
if (null != typeExpr)
|
|
context.UpdateWith(typeExpr.context);
|
|
}
|
|
}
|
|
|
|
if (JSToken.Assign == this.currentToken.token || JSToken.Equal == this.currentToken.token){
|
|
if (JSToken.Equal == this.currentToken.token)
|
|
ReportError(JSError.NoEqual, true);
|
|
GetNextToken();
|
|
try{
|
|
assignmentExpr = ParseExpression(true, inToken);
|
|
}catch(RecoveryTokenException exc){
|
|
assignmentExpr = exc._partiallyComputedNode;
|
|
throw exc;
|
|
}finally{
|
|
if (null != assignmentExpr)
|
|
context.UpdateWith(assignmentExpr.context);
|
|
}
|
|
}
|
|
}catch(RecoveryTokenException exc){
|
|
// If the exception is in the vardecl no-skip set then we successfully
|
|
// recovered to the end of the declaration and can just return
|
|
// normally. Otherwise we re-throw after constructing the partial result.
|
|
if (IndexOfToken(NoSkipTokenSet.s_VariableDeclNoSkipTokenSet, exc) == -1)
|
|
except = exc;
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_VariableDeclNoSkipTokenSet);
|
|
}
|
|
|
|
AST result = null;
|
|
if (JSToken.Var == kind)
|
|
result = new VariableDeclaration(context, id, typeExpr, assignmentExpr, visibility, customAttributes);
|
|
else{
|
|
if (assignmentExpr == null)
|
|
ForceReportInfo(JSError.NoEqual);
|
|
result = new Constant(context, id, typeExpr, assignmentExpr, visibility, customAttributes);
|
|
}
|
|
if (customAttributes != null)
|
|
customAttributes.SetTarget(result);
|
|
if (null != except){
|
|
except._partiallyComputedNode = result;
|
|
throw except;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseQualifiedIdentifier
|
|
//
|
|
// QualifiedIdentifier :
|
|
// 'double' | 'float' | 'int' | 'long' | Scope Identifier
|
|
//
|
|
// Scope
|
|
// <empty> |
|
|
// Identifier '.' Scope
|
|
//
|
|
// The argument error is passed by the caller and it is used in error situation
|
|
// to provide better error information. The caller knows in which context this
|
|
// qualified identifier is parsed (i.e. var x : QualifiedIdentifier vs.
|
|
// import QualifiedIdentifier)
|
|
// On error condition this method may return null. Regardless of its return value, though,
|
|
// this method will always be pointing to the next token and no error token will be set.
|
|
//---------------------------------------------------------------------------------------
|
|
private AST ParseQualifiedIdentifier(JSError error){
|
|
GetNextToken();
|
|
AST qualid = null;
|
|
string identifier = null;
|
|
Context idContext = this.currentToken.Clone();
|
|
if (JSToken.Identifier != this.currentToken.token){
|
|
identifier = JSKeyword.CanBeIdentifier(this.currentToken.token);
|
|
if (null != identifier){
|
|
switch (this.currentToken.token){
|
|
case JSToken.Boolean :
|
|
case JSToken.Byte :
|
|
case JSToken.Char :
|
|
case JSToken.Double :
|
|
case JSToken.Float :
|
|
case JSToken.Int :
|
|
case JSToken.Long :
|
|
case JSToken.Short :
|
|
case JSToken.Void :
|
|
break;
|
|
default:
|
|
ForceReportInfo(JSError.KeywordUsedAsIdentifier);
|
|
break;
|
|
}
|
|
qualid = new Lookup(identifier, idContext);
|
|
}else{
|
|
ReportError(error, true);
|
|
SkipTokensAndThrow(); // this will always throw
|
|
}
|
|
}else{
|
|
qualid = new Lookup(this.scanner.GetIdentifier(), idContext);
|
|
}
|
|
GetNextToken();
|
|
if (JSToken.AccessField == this.currentToken.token)
|
|
qualid = ParseScopeSequence(qualid, error);
|
|
|
|
return qualid;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseScopeSequence
|
|
//
|
|
// Scope
|
|
// <empty> |
|
|
// Identifier '.' Scope
|
|
//
|
|
// The argument error is passed by the caller and it is used in error situation
|
|
// to provide better error information. The caller knows in which context this
|
|
// qualified identifier is parsed (i.e. var x : QualifiedIdentifier vs.
|
|
// import QualifiedIdentifier)
|
|
// This function is called after a 'JSToken.Identifier JSToken.AccessField' sequence
|
|
// has been processed and the whole scope production has to be returned
|
|
//---------------------------------------------------------------------------------------
|
|
private AST ParseScopeSequence(AST qualid, JSError error){
|
|
ConstantWrapper id = null;
|
|
string identifier = null;
|
|
do{
|
|
GetNextToken(); // move after '.'
|
|
if (JSToken.Identifier != this.currentToken.token){
|
|
identifier = JSKeyword.CanBeIdentifier(this.currentToken.token);
|
|
if (null != identifier){
|
|
ForceReportInfo(JSError.KeywordUsedAsIdentifier);
|
|
id = new ConstantWrapper(identifier, this.currentToken.Clone());
|
|
}else{
|
|
ReportError(error, true);
|
|
SkipTokensAndThrow(qualid); // this will always throw
|
|
}
|
|
}else
|
|
id = new ConstantWrapper(this.scanner.GetIdentifier(), this.currentToken.Clone());
|
|
qualid = new Member(qualid.context.CombineWith(this.currentToken), qualid, id);
|
|
GetNextToken();
|
|
} while (JSToken.AccessField == this.currentToken.token);
|
|
|
|
return qualid;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseTypeExpression
|
|
//
|
|
// TypeExpression :
|
|
// QualifiedIdentifier |
|
|
// TypeExpression <no line break> '[' ']'
|
|
//
|
|
//--------------------------------------------------------------------------------------
|
|
private TypeExpression ParseTypeExpression(){
|
|
AST typeId = null;
|
|
try{
|
|
typeId = ParseQualifiedIdentifier(JSError.NeedType);
|
|
}catch(RecoveryTokenException exc){
|
|
if (exc._partiallyComputedNode != null){
|
|
exc._partiallyComputedNode = new TypeExpression(exc._partiallyComputedNode);
|
|
}
|
|
throw exc;
|
|
}
|
|
TypeExpression type = new TypeExpression(typeId);
|
|
if (type != null){
|
|
while (!this.scanner.GotEndOfLine() && JSToken.LeftBracket == this.currentToken.token){
|
|
GetNextToken();
|
|
int rank = 1;
|
|
while (JSToken.Comma == this.currentToken.token){
|
|
GetNextToken(); rank++;
|
|
}
|
|
if (JSToken.RightBracket != this.currentToken.token)
|
|
ReportError(JSError.NoRightBracket);
|
|
GetNextToken();
|
|
if (type.isArray)
|
|
type = new TypeExpression(type);
|
|
type.isArray = true;
|
|
type.rank = rank;
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseIfStatement
|
|
//
|
|
// IfStatement :
|
|
// 'if' '(' Expression ')' Statement ElseStatement
|
|
//
|
|
// ElseStatement :
|
|
// <empty> |
|
|
// 'else' Statement
|
|
//---------------------------------------------------------------------------------------
|
|
private If ParseIfStatement(){
|
|
Context ifCtx = this.currentToken.Clone();
|
|
AST condition = null;
|
|
AST trueBranch = null;
|
|
AST falseBranch = null;
|
|
|
|
this.blockType.Add(BlockType.Block);
|
|
try{
|
|
// parse condition
|
|
GetNextToken();
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
|
|
try{
|
|
if (JSToken.LeftParen != this.currentToken.token)
|
|
ReportError(JSError.NoLeftParen);
|
|
GetNextToken();
|
|
condition = ParseExpression();
|
|
|
|
// parse statements
|
|
if (JSToken.RightParen != this.currentToken.token){
|
|
ifCtx.UpdateWith(condition.context);
|
|
ReportError(JSError.NoRightParen);
|
|
}else
|
|
ifCtx.UpdateWith(this.currentToken);
|
|
|
|
GetNextToken();
|
|
}catch(RecoveryTokenException exc){
|
|
// make up an if condition
|
|
if (exc._partiallyComputedNode != null)
|
|
condition = exc._partiallyComputedNode;
|
|
else
|
|
condition = new ConstantWrapper(true, CurrentPositionContext());
|
|
|
|
if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1){
|
|
exc._partiallyComputedNode = null; // really not much to pass up
|
|
// the if condition was so bogus we do not have a chance to make an If node, give up
|
|
throw exc;
|
|
}else{
|
|
if (exc._token == JSToken.RightParen)
|
|
GetNextToken();
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
|
|
}
|
|
|
|
if (condition is Assign)
|
|
condition.context.HandleError(JSError.SuspectAssignment);
|
|
|
|
if (JSToken.Semicolon == this.currentToken.token)
|
|
ForceReportInfo(JSError.SuspectSemicolon);
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_IfBodyNoSkipTokenSet);
|
|
try{
|
|
trueBranch = ParseStatement();
|
|
}catch(RecoveryTokenException exc){
|
|
// make up a block for the if part
|
|
if (exc._partiallyComputedNode != null)
|
|
trueBranch = exc._partiallyComputedNode;
|
|
else
|
|
trueBranch = new Block(CurrentPositionContext());
|
|
if (IndexOfToken(NoSkipTokenSet.s_IfBodyNoSkipTokenSet, exc) == -1){
|
|
// we have to pass the exception to someone else, make as much as you can from the if
|
|
exc._partiallyComputedNode = new If(ifCtx, condition, trueBranch, falseBranch);
|
|
throw exc;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_IfBodyNoSkipTokenSet);
|
|
}
|
|
|
|
// parse else, if any
|
|
if (JSToken.Else == this.currentToken.token){
|
|
GetNextToken();
|
|
if (JSToken.Semicolon == this.currentToken.token)
|
|
ForceReportInfo(JSError.SuspectSemicolon);
|
|
try{
|
|
falseBranch = ParseStatement();
|
|
}catch(RecoveryTokenException exc){
|
|
// make up a block for the else part
|
|
if (exc._partiallyComputedNode != null)
|
|
falseBranch = exc._partiallyComputedNode;
|
|
else
|
|
falseBranch = new Block(CurrentPositionContext());
|
|
exc._partiallyComputedNode = new If(ifCtx, condition, trueBranch, falseBranch);
|
|
throw exc;
|
|
}
|
|
}
|
|
}finally{
|
|
this.blockType.RemoveAt(this.blockType.Count - 1);
|
|
}
|
|
|
|
return new If(ifCtx, condition, trueBranch, falseBranch);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseForStatement
|
|
//
|
|
// ForStatement :
|
|
// 'for' '(' OptionalExpressionNoIn ';' OptionalExpression ';' OptionalExpression ')'
|
|
// 'for' '(' 'var' VariableDeclarationListNoIn ';' OptionalExpression ';' OptionalExpression ')'
|
|
// 'for' '(' LeftHandSideExpression 'in' Expression')'
|
|
// 'for' '(' 'var' Identifier OptionalInitializerNoIn 'in' Expression')'
|
|
//
|
|
// OptionalExpressionNoIn :
|
|
// <empty> |
|
|
// ExpressionNoIn // same as Expression but does not process 'in' as an operator
|
|
//
|
|
// OptionalInitializerNoIn :
|
|
// <empty> |
|
|
// InitializerNoIn // same as initializer but does not process 'in' as an operator
|
|
//---------------------------------------------------------------------------------------
|
|
private AST ParseForStatement(){
|
|
this.blockType.Add(BlockType.Loop);
|
|
AST forNode = null;
|
|
try{
|
|
Context forCtx = this.currentToken.Clone();
|
|
GetNextToken();
|
|
if (JSToken.LeftParen != this.currentToken.token)
|
|
ReportError(JSError.NoLeftParen);
|
|
GetNextToken();
|
|
bool isForIn = false, recoveryInForIn = false;
|
|
AST lhs = null, initializer = null, condOrColl = null, increment = null;
|
|
|
|
try{
|
|
if (JSToken.Var == this.currentToken.token){
|
|
isForIn = true;
|
|
initializer = ParseIdentifierInitializer(JSToken.In, (FieldAttributes)0, null, JSToken.Var);
|
|
|
|
// a list of variable initializers is allowed only in a for(;;)
|
|
AST var = null;
|
|
while (JSToken.Comma == this.currentToken.token){
|
|
isForIn = false;
|
|
var = ParseIdentifierInitializer(JSToken.In, (FieldAttributes)0, null, JSToken.Var);
|
|
initializer = new Comma(initializer.context.CombineWith(var.context), initializer, var);
|
|
}
|
|
|
|
// if it could still be a for..in, now it's time to get the 'in'
|
|
if (isForIn){
|
|
if (JSToken.In == this.currentToken.token){
|
|
GetNextToken();
|
|
condOrColl = ParseExpression();
|
|
}else
|
|
isForIn = false;
|
|
}
|
|
}else{
|
|
if (JSToken.Semicolon != this.currentToken.token){
|
|
bool isLHS;
|
|
initializer = ParseUnaryExpression(out isLHS, false);
|
|
if (isLHS && JSToken.In == this.currentToken.token){
|
|
isForIn = true;
|
|
lhs = initializer;
|
|
initializer = null;
|
|
GetNextToken();
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
|
|
try{
|
|
condOrColl = ParseExpression();
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1){
|
|
exc._partiallyComputedNode = null;
|
|
throw exc;
|
|
}else{
|
|
if (exc._partiallyComputedNode == null)
|
|
condOrColl = new ConstantWrapper(true, CurrentPositionContext()); // what could we put here?
|
|
else
|
|
condOrColl = exc._partiallyComputedNode;
|
|
}
|
|
if (exc._token == JSToken.RightParen){
|
|
GetNextToken();
|
|
recoveryInForIn = true;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
|
|
}
|
|
}else
|
|
initializer = ParseExpression(initializer, false, isLHS, JSToken.In);
|
|
}else
|
|
initializer = new EmptyLiteral(CurrentPositionContext());
|
|
}
|
|
}catch(RecoveryTokenException exc){
|
|
// error is too early abort for
|
|
exc._partiallyComputedNode = null;
|
|
throw exc;
|
|
}
|
|
|
|
// at this point we know whether or not is a for..in
|
|
if (isForIn){
|
|
if (!recoveryInForIn){
|
|
if (JSToken.RightParen != this.currentToken.token)
|
|
ReportError(JSError.NoRightParen);
|
|
forCtx.UpdateWith(this.currentToken);
|
|
GetNextToken();
|
|
}
|
|
AST body = null;
|
|
try{
|
|
body = ParseStatement();
|
|
}catch(RecoveryTokenException exc){
|
|
if (exc._partiallyComputedNode == null)
|
|
body = new Block(CurrentPositionContext());
|
|
else
|
|
body = exc._partiallyComputedNode;
|
|
exc._partiallyComputedNode = new ForIn(forCtx, lhs, initializer, condOrColl, body);
|
|
throw exc;
|
|
}
|
|
forNode = new ForIn(forCtx, lhs, initializer, condOrColl, body);
|
|
}else{
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
|
|
try{
|
|
if (JSToken.Semicolon != this.currentToken.token){
|
|
ReportError(JSError.NoSemicolon);
|
|
if (JSToken.Colon == this.currentToken.token){
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_VariableDeclNoSkipTokenSet);
|
|
try{
|
|
SkipTokensAndThrow();
|
|
}catch(RecoveryTokenException exc){
|
|
if (JSToken.Semicolon == this.currentToken.token)
|
|
this.errorToken = null;
|
|
else
|
|
throw exc;
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_VariableDeclNoSkipTokenSet);
|
|
}
|
|
}
|
|
}
|
|
GetNextToken();
|
|
if (JSToken.Semicolon != this.currentToken.token){
|
|
condOrColl = ParseExpression();
|
|
if (JSToken.Semicolon != this.currentToken.token)
|
|
ReportError(JSError.NoSemicolon);
|
|
}else
|
|
condOrColl = new ConstantWrapper(true, CurrentPositionContext());
|
|
GetNextToken();
|
|
if (JSToken.RightParen != this.currentToken.token)
|
|
increment = ParseExpression();
|
|
else
|
|
increment = new EmptyLiteral(CurrentPositionContext());
|
|
if (JSToken.RightParen != this.currentToken.token)
|
|
ReportError(JSError.NoRightParen);
|
|
forCtx.UpdateWith(this.currentToken);
|
|
GetNextToken();
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1){
|
|
exc._partiallyComputedNode = null;
|
|
throw exc;
|
|
}else{
|
|
// discard any partial info, just genrate empty condition and increment and keep going
|
|
exc._partiallyComputedNode = null;
|
|
if (condOrColl == null)
|
|
condOrColl = new ConstantWrapper(true, CurrentPositionContext());
|
|
if (increment == null)
|
|
increment = new EmptyLiteral(CurrentPositionContext());
|
|
}
|
|
if (exc._token == JSToken.RightParen){
|
|
GetNextToken();
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
|
|
}
|
|
AST body = null;
|
|
try{
|
|
body = ParseStatement();
|
|
}catch(RecoveryTokenException exc){
|
|
if (exc._partiallyComputedNode == null)
|
|
body = new Block(CurrentPositionContext());
|
|
else
|
|
body = exc._partiallyComputedNode;
|
|
exc._partiallyComputedNode = new For(forCtx, initializer, condOrColl, increment, body);
|
|
throw exc;
|
|
}
|
|
forNode = new For(forCtx, initializer, condOrColl, increment, body);
|
|
}
|
|
}finally{
|
|
this.blockType.RemoveAt(this.blockType.Count - 1);
|
|
}
|
|
|
|
return forNode;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseDoStatement
|
|
//
|
|
// DoStatement:
|
|
// 'do' Statement 'while' '(' Expression ')'
|
|
//---------------------------------------------------------------------------------------
|
|
private DoWhile ParseDoStatement(){
|
|
Context doCtx = null; // this.currentToken.Clone();
|
|
AST body = null;
|
|
AST condition = null;
|
|
this.blockType.Add(BlockType.Loop);
|
|
try{
|
|
GetNextToken();
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_DoWhileBodyNoSkipTokenSet);
|
|
try{
|
|
body = ParseStatement();
|
|
}catch(RecoveryTokenException exc){
|
|
// make up a block for the do while
|
|
if (exc._partiallyComputedNode != null)
|
|
body = exc._partiallyComputedNode;
|
|
else
|
|
body = new Block(CurrentPositionContext());
|
|
if (IndexOfToken(NoSkipTokenSet.s_DoWhileBodyNoSkipTokenSet, exc) == -1){
|
|
// we have to pass the exception to someone else, make as much as you can from the 'do while'
|
|
exc._partiallyComputedNode = new DoWhile(CurrentPositionContext(),
|
|
body,
|
|
new ConstantWrapper(false, CurrentPositionContext()));
|
|
throw exc;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_DoWhileBodyNoSkipTokenSet);
|
|
}
|
|
if (JSToken.While != this.currentToken.token){
|
|
ReportError(JSError.NoWhile);
|
|
}
|
|
doCtx = this.currentToken.Clone();
|
|
GetNextToken();
|
|
if (JSToken.LeftParen != this.currentToken.token){
|
|
ReportError(JSError.NoLeftParen);
|
|
}
|
|
GetNextToken();
|
|
// catch here so the body of the do_while is not thrown away
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
|
|
try{
|
|
condition = ParseExpression();
|
|
if (JSToken.RightParen != this.currentToken.token){
|
|
ReportError(JSError.NoRightParen);
|
|
doCtx.UpdateWith(condition.context);
|
|
}else
|
|
doCtx.UpdateWith(this.currentToken);
|
|
GetNextToken();
|
|
}catch(RecoveryTokenException exc){
|
|
// make up a condition
|
|
if (exc._partiallyComputedNode != null)
|
|
condition = exc._partiallyComputedNode;
|
|
else
|
|
condition = new ConstantWrapper(false, CurrentPositionContext());
|
|
|
|
if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1){
|
|
exc._partiallyComputedNode = new DoWhile(doCtx, body, condition);
|
|
throw exc;
|
|
}else{
|
|
if (JSToken.RightParen == this.currentToken.token)
|
|
GetNextToken();
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
|
|
}
|
|
if (JSToken.Semicolon == this.currentToken.token){
|
|
// JScript 5 allowed statements like
|
|
// do{print(++x)}while(x<10) print(0)
|
|
// even though that does not strictly follow the automatic semicolon insertion
|
|
// rules for the required semi after the while(). For backwards compatibility
|
|
// we should continue to support this.
|
|
doCtx.UpdateWith(this.currentToken);
|
|
GetNextToken();
|
|
}
|
|
|
|
}finally{
|
|
this.blockType.RemoveAt(this.blockType.Count - 1);
|
|
}
|
|
|
|
return new DoWhile(doCtx, body, condition);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseWhileStatement
|
|
//
|
|
// WhileStatement :
|
|
// 'while' '(' Expression ')' Statement
|
|
//---------------------------------------------------------------------------------------
|
|
private While ParseWhileStatement(){
|
|
Context whileCtx = this.currentToken.Clone();
|
|
AST condition = null;
|
|
AST body = null;
|
|
this.blockType.Add(BlockType.Loop);
|
|
try{
|
|
GetNextToken();
|
|
if (JSToken.LeftParen != this.currentToken.token){
|
|
ReportError(JSError.NoLeftParen);
|
|
}
|
|
GetNextToken();
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
|
|
try{
|
|
condition = ParseExpression();
|
|
if (JSToken.RightParen != this.currentToken.token){
|
|
ReportError(JSError.NoRightParen);
|
|
whileCtx.UpdateWith(condition.context);
|
|
}else
|
|
whileCtx.UpdateWith(this.currentToken);
|
|
|
|
GetNextToken();
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1){
|
|
// abort the while there is really no much to do here
|
|
exc._partiallyComputedNode = null;
|
|
throw exc;
|
|
}else{
|
|
// make up a condition
|
|
if (exc._partiallyComputedNode != null)
|
|
condition = exc._partiallyComputedNode;
|
|
else
|
|
condition = new ConstantWrapper(false, CurrentPositionContext());
|
|
|
|
if (JSToken.RightParen == this.currentToken.token)
|
|
GetNextToken();
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
|
|
}
|
|
|
|
try{
|
|
body = ParseStatement();
|
|
}catch(RecoveryTokenException exc){
|
|
if (exc._partiallyComputedNode != null)
|
|
body = exc._partiallyComputedNode;
|
|
else
|
|
body = new Block(CurrentPositionContext());
|
|
|
|
exc._partiallyComputedNode = new While(whileCtx, condition, body);
|
|
throw exc;
|
|
}
|
|
|
|
}finally{
|
|
this.blockType.RemoveAt(this.blockType.Count - 1);
|
|
}
|
|
|
|
return new While(whileCtx, condition, body);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseContinueStatement
|
|
//
|
|
// ContinueStatement :
|
|
// 'continue' OptionalLabel
|
|
//
|
|
// OptionalLabel :
|
|
// <empty> |
|
|
// Identifier
|
|
//
|
|
// This function may return a null AST under error condition. The caller should handle
|
|
// that case.
|
|
// Regardless of error conditions, on exit the parser points to the first token after
|
|
// the continue statement
|
|
//---------------------------------------------------------------------------------------
|
|
private Continue ParseContinueStatement(){
|
|
Context context = this.currentToken.Clone();
|
|
int blocks = 0;
|
|
GetNextToken();
|
|
string label = null;
|
|
if (!this.scanner.GotEndOfLine() && (JSToken.Identifier == this.currentToken.token || (label = JSKeyword.CanBeIdentifier(this.currentToken.token)) != null)){
|
|
context.UpdateWith(this.currentToken);
|
|
// get the label block
|
|
if (null != label)
|
|
ForceReportInfo(JSError.KeywordUsedAsIdentifier);
|
|
else
|
|
label = this.scanner.GetIdentifier();
|
|
Object value = this.labelTable[label];
|
|
if (null == value){
|
|
// the label does not exist. Continue as if it there was no continue at all
|
|
ReportError(JSError.NoLabel, true);
|
|
GetNextToken();
|
|
return null; // ignore it
|
|
}else{
|
|
blocks = (int)value;
|
|
if ((BlockType)this.blockType[blocks] != BlockType.Loop){
|
|
ReportError(JSError.BadContinue, context.Clone(), true);
|
|
}
|
|
GetNextToken();
|
|
}
|
|
}else{
|
|
blocks = this.blockType.Count - 1;
|
|
while (blocks >= 0 && (BlockType)this.blockType[blocks] != BlockType.Loop) blocks--;
|
|
if (blocks < 0){
|
|
// the continue is malformed. Continue as if there was no continue at all
|
|
ReportError(JSError.BadContinue, context, true);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
if (JSToken.Semicolon == this.currentToken.token){
|
|
context.UpdateWith(this.currentToken);
|
|
GetNextToken();
|
|
}else if (JSToken.RightCurly != this.currentToken.token && !this.scanner.GotEndOfLine()){
|
|
ReportError(JSError.NoSemicolon, true);
|
|
}
|
|
|
|
// must ignore the Finally block
|
|
int finallyNum = 0;
|
|
for (int i = blocks, n = this.blockType.Count; i < n; i++)
|
|
if ((BlockType)this.blockType[i] == BlockType.Finally){
|
|
blocks++;
|
|
finallyNum++;
|
|
}
|
|
if (finallyNum > this.finallyEscaped)
|
|
this.finallyEscaped = finallyNum;
|
|
|
|
return new Continue(context, this.blockType.Count - blocks, finallyNum > 0);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseBreakStatement
|
|
//
|
|
// BreakStatement :
|
|
// 'break' OptionalLabel
|
|
//
|
|
// This function may return a null AST under error condition. The caller should handle
|
|
// that case.
|
|
// Regardless of error conditions, on exit the parser points to the first token after
|
|
// the break statement.
|
|
//---------------------------------------------------------------------------------------
|
|
private Break ParseBreakStatement(){
|
|
Context context = this.currentToken.Clone();
|
|
int blocks = 0;
|
|
GetNextToken();
|
|
string label = null;
|
|
if (!this.scanner.GotEndOfLine() && (JSToken.Identifier == this.currentToken.token || (label = JSKeyword.CanBeIdentifier(this.currentToken.token)) != null)){
|
|
context.UpdateWith(this.currentToken);
|
|
// get the label block
|
|
if (null != label)
|
|
ForceReportInfo(JSError.KeywordUsedAsIdentifier);
|
|
else
|
|
label = this.scanner.GetIdentifier();
|
|
Object value = this.labelTable[label];
|
|
if (null == value){
|
|
// as if it was a non label case
|
|
ReportError(JSError.NoLabel, true);
|
|
GetNextToken();
|
|
return null; // ignore it
|
|
}else{
|
|
blocks = (int)value - 1; // the outer block
|
|
Debug.Assert((BlockType)this.blockType[blocks] != BlockType.Finally);
|
|
GetNextToken();
|
|
}
|
|
}else{
|
|
blocks = this.blockType.Count - 1;
|
|
// search for an enclosing loop, if there is no loop it is an error
|
|
while (((BlockType)this.blockType[blocks] == BlockType.Block || (BlockType)this.blockType[blocks] == BlockType.Finally) && --blocks >= 0);
|
|
--blocks;
|
|
if (blocks < 0){
|
|
ReportError(JSError.BadBreak, context, true);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
if (JSToken.Semicolon == this.currentToken.token){
|
|
context.UpdateWith(this.currentToken);
|
|
GetNextToken();
|
|
}else if (JSToken.RightCurly != this.currentToken.token && !this.scanner.GotEndOfLine()){
|
|
ReportError(JSError.NoSemicolon, true);
|
|
}
|
|
|
|
// must ignore the Finally block
|
|
int finallyNum = 0;
|
|
for (int i = blocks, n = this.blockType.Count; i < n; i++)
|
|
if ((BlockType)this.blockType[i] == BlockType.Finally){
|
|
blocks++;
|
|
finallyNum++;
|
|
}
|
|
if (finallyNum > this.finallyEscaped)
|
|
this.finallyEscaped = finallyNum;
|
|
|
|
return new Break(context, this.blockType.Count - blocks - 1, finallyNum > 0);
|
|
}
|
|
|
|
private bool CheckForReturnFromFinally(){
|
|
int finallyNum = 0;
|
|
for (int i = this.blockType.Count - 1; i >= 0; i--)
|
|
if ((BlockType)this.blockType[i] == BlockType.Finally)
|
|
finallyNum++;
|
|
|
|
if (finallyNum > this.finallyEscaped)
|
|
this.finallyEscaped = finallyNum;
|
|
|
|
return finallyNum > 0;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseReturnStatement
|
|
//
|
|
// ReturnStatement :
|
|
// 'return' Expression
|
|
//
|
|
// This function may return a null AST under error condition. The caller should handle
|
|
// that case.
|
|
// Regardless of error conditions, on exit the parser points to the first token after
|
|
// the return statement.
|
|
//---------------------------------------------------------------------------------------
|
|
private Return ParseReturnStatement(){
|
|
Context retCtx = this.currentToken.Clone();
|
|
if (Globals.ScopeStack.Peek() is FunctionScope){
|
|
AST expr = null;
|
|
GetNextToken();
|
|
if (!this.scanner.GotEndOfLine()){
|
|
if (JSToken.Semicolon != this.currentToken.token && JSToken.RightCurly != this.currentToken.token){
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet);
|
|
try{
|
|
expr = ParseExpression();
|
|
}catch(RecoveryTokenException exc){
|
|
expr = exc._partiallyComputedNode;
|
|
if (IndexOfToken(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet, exc) == -1){
|
|
if (expr != null)
|
|
retCtx.UpdateWith(expr.context);
|
|
exc._partiallyComputedNode = new Return(retCtx, expr, CheckForReturnFromFinally());
|
|
throw exc;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet);
|
|
}
|
|
if (JSToken.Semicolon != this.currentToken.token
|
|
&& JSToken.RightCurly != this.currentToken.token
|
|
&& !this.scanner.GotEndOfLine()){
|
|
ReportError(JSError.NoSemicolon, true);
|
|
}
|
|
}
|
|
if (JSToken.Semicolon == this.currentToken.token){
|
|
retCtx.UpdateWith(this.currentToken);
|
|
GetNextToken();
|
|
}else if (expr != null)
|
|
retCtx.UpdateWith(expr.context);
|
|
}
|
|
return new Return(retCtx, expr, CheckForReturnFromFinally());
|
|
}else{
|
|
// the return is not inside a function, report an error and skip to the next token
|
|
ReportError(JSError.BadReturn, retCtx, true);
|
|
GetNextToken();
|
|
return null;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseImportStatement
|
|
//
|
|
// ImportStatement :
|
|
// 'import' QualifiedIdentifier
|
|
//---------------------------------------------------------------------------------------
|
|
private Import ParseImportStatement(){
|
|
Context context = this.currentToken.Clone();
|
|
AST name = null;
|
|
try{
|
|
name = ParseQualifiedIdentifier(JSError.PackageExpected);
|
|
}catch(RecoveryTokenException exc){
|
|
// an exception is passing by, mae an Import if possible and rethrow
|
|
if (exc._partiallyComputedNode != null){
|
|
exc._partiallyComputedNode = new Import(context, exc._partiallyComputedNode);
|
|
}
|
|
}
|
|
if (this.currentToken.token != JSToken.Semicolon && !this.scanner.GotEndOfLine())
|
|
ReportError(JSError.NoSemicolon, this.currentToken.Clone());
|
|
return new Import(context, name);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseWithStatement
|
|
//
|
|
// WithStatement :
|
|
// 'with' '(' Expression ')' Statement
|
|
//---------------------------------------------------------------------------------------
|
|
private With ParseWithStatement(){
|
|
Context withCtx = this.currentToken.Clone();
|
|
AST obj = null;
|
|
AST block = null;
|
|
this.blockType.Add(BlockType.Block);
|
|
try{
|
|
GetNextToken();
|
|
if (JSToken.LeftParen != this.currentToken.token)
|
|
ReportError(JSError.NoLeftParen);
|
|
GetNextToken();
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
|
|
try{
|
|
obj = ParseExpression();
|
|
if (JSToken.RightParen != this.currentToken.token){
|
|
withCtx.UpdateWith(obj.context);
|
|
ReportError(JSError.NoRightParen);
|
|
}else
|
|
withCtx.UpdateWith(this.currentToken);
|
|
GetNextToken();
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1){
|
|
// give up
|
|
exc._partiallyComputedNode = null;
|
|
throw exc;
|
|
}else{
|
|
if (exc._partiallyComputedNode == null)
|
|
obj = new ConstantWrapper(true, CurrentPositionContext());
|
|
else
|
|
obj = exc._partiallyComputedNode;
|
|
withCtx.UpdateWith(obj.context);
|
|
|
|
if (exc._token == JSToken.RightParen)
|
|
GetNextToken();
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
|
|
}
|
|
|
|
try{
|
|
block = ParseStatement();
|
|
}catch(RecoveryTokenException exc){
|
|
if (exc._partiallyComputedNode == null)
|
|
block = new Block(CurrentPositionContext());
|
|
else
|
|
block = exc._partiallyComputedNode;
|
|
exc._partiallyComputedNode = new With(withCtx, obj, block);
|
|
}
|
|
}finally{
|
|
this.blockType.RemoveAt(this.blockType.Count - 1);
|
|
}
|
|
|
|
return new With(withCtx, obj, block);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseSwitchStatement
|
|
//
|
|
// SwitchStatement :
|
|
// 'switch' '(' Expression ')' '{' CaseBlock '}'
|
|
//
|
|
// CaseBlock :
|
|
// CaseList DefaultCaseClause CaseList
|
|
//
|
|
// CaseList :
|
|
// <empty> |
|
|
// CaseClause CaseList
|
|
//
|
|
// CaseClause :
|
|
// 'case' Expression ':' OptionalStatements
|
|
//
|
|
// DefaultCaseClause :
|
|
// <empty> |
|
|
// 'default' ':' OptionalStatements
|
|
//---------------------------------------------------------------------------------------
|
|
private AST ParseSwitchStatement(){
|
|
Context switchCtx = this.currentToken.Clone();
|
|
AST expr = null;
|
|
ASTList cases = null;
|
|
this.blockType.Add(BlockType.Switch);
|
|
try{
|
|
// read switch(expr)
|
|
GetNextToken();
|
|
if (JSToken.LeftParen != this.currentToken.token)
|
|
ReportError(JSError.NoLeftParen);
|
|
GetNextToken();
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_SwitchNoSkipTokenSet);
|
|
try{
|
|
expr = ParseExpression();
|
|
|
|
if (JSToken.RightParen != this.currentToken.token){
|
|
ReportError(JSError.NoRightParen);
|
|
}
|
|
|
|
GetNextToken();
|
|
if (JSToken.LeftCurly != this.currentToken.token){
|
|
ReportError(JSError.NoLeftCurly);
|
|
}
|
|
GetNextToken();
|
|
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1
|
|
&& IndexOfToken(NoSkipTokenSet.s_SwitchNoSkipTokenSet, exc) == -1 ){
|
|
// give up
|
|
exc._partiallyComputedNode = null;
|
|
throw exc;
|
|
}else{
|
|
if (exc._partiallyComputedNode == null)
|
|
expr = new ConstantWrapper(true, CurrentPositionContext());
|
|
else
|
|
expr = exc._partiallyComputedNode;
|
|
|
|
if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) != -1){
|
|
if (exc._token == JSToken.RightParen)
|
|
GetNextToken();
|
|
|
|
if (JSToken.LeftCurly != this.currentToken.token){
|
|
ReportError(JSError.NoLeftCurly);
|
|
}
|
|
GetNextToken();
|
|
}
|
|
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_SwitchNoSkipTokenSet);
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
|
|
}
|
|
|
|
// parse the switch body
|
|
cases = new ASTList(this.currentToken.Clone());
|
|
bool defaultStatement = false;
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_BlockNoSkipTokenSet);
|
|
try{
|
|
while (JSToken.RightCurly != this.currentToken.token){
|
|
SwitchCase caseClause = null;
|
|
AST caseValue = null;
|
|
Context caseCtx = this.currentToken.Clone();
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_CaseNoSkipTokenSet);
|
|
try{
|
|
if (JSToken.Case == this.currentToken.token){
|
|
// get the case
|
|
GetNextToken();
|
|
caseValue = ParseExpression();
|
|
}else if (JSToken.Default == this.currentToken.token){
|
|
// get the default
|
|
if (defaultStatement)
|
|
// we report an error but we still accept the default
|
|
ReportError(JSError.DupDefault, true);
|
|
else
|
|
defaultStatement = true;
|
|
GetNextToken();
|
|
}else{
|
|
// This is an error, there is no case or default. Assume a default was missing and keep going
|
|
defaultStatement = true;
|
|
ReportError(JSError.BadSwitch);
|
|
}
|
|
if (JSToken.Colon != this.currentToken.token)
|
|
ReportError(JSError.NoColon);
|
|
|
|
// read the statements inside the case or default
|
|
GetNextToken();
|
|
}catch(RecoveryTokenException exc){
|
|
// right now we can only get here for the 'case' statement
|
|
if (IndexOfToken(NoSkipTokenSet.s_CaseNoSkipTokenSet, exc) == -1){
|
|
// ignore the current case or default
|
|
exc._partiallyComputedNode = null;
|
|
throw exc;
|
|
}else{
|
|
caseValue = exc._partiallyComputedNode;
|
|
|
|
if (exc._token == JSToken.Colon)
|
|
GetNextToken();
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_CaseNoSkipTokenSet);
|
|
}
|
|
|
|
this.blockType.Add(BlockType.Block);
|
|
try{
|
|
Block statements = new Block(this.currentToken.Clone());
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_SwitchNoSkipTokenSet);
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
|
|
try{
|
|
while (JSToken.RightCurly != this.currentToken.token && JSToken.Case != this.currentToken.token && JSToken.Default != this.currentToken.token){
|
|
try{
|
|
statements.Append(ParseStatement());
|
|
}catch(RecoveryTokenException exc){
|
|
if (exc._partiallyComputedNode != null){
|
|
statements.Append(exc._partiallyComputedNode);
|
|
exc._partiallyComputedNode = null;
|
|
}
|
|
if (IndexOfToken(NoSkipTokenSet.s_StartStatementNoSkipTokenSet, exc) == -1)
|
|
throw exc;
|
|
}
|
|
}
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_SwitchNoSkipTokenSet, exc) == -1){
|
|
if (null == caseValue)
|
|
caseClause = new SwitchCase(caseCtx, statements);
|
|
else
|
|
caseClause = new SwitchCase(caseCtx, caseValue, statements);
|
|
cases.Append(caseClause);
|
|
|
|
throw exc;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_SwitchNoSkipTokenSet);
|
|
}
|
|
if (JSToken.RightCurly == this.currentToken.token)
|
|
statements.context.UpdateWith(this.currentToken);
|
|
if (null == caseValue){
|
|
caseCtx.UpdateWith(statements.context);
|
|
caseClause = new SwitchCase(caseCtx, statements);
|
|
}else{
|
|
caseCtx.UpdateWith(statements.context);
|
|
caseClause = new SwitchCase(caseCtx, caseValue, statements);
|
|
}
|
|
cases.Append(caseClause);
|
|
}finally{
|
|
this.blockType.RemoveAt(this.blockType.Count - 1);
|
|
}
|
|
}
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_BlockNoSkipTokenSet, exc) == -1){
|
|
//save what you can a rethrow
|
|
switchCtx.UpdateWith(CurrentPositionContext());
|
|
exc._partiallyComputedNode = new Switch(switchCtx, expr, cases);
|
|
throw exc;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockNoSkipTokenSet);
|
|
}
|
|
switchCtx.UpdateWith(this.currentToken);
|
|
GetNextToken();
|
|
}finally{
|
|
this.blockType.RemoveAt(this.blockType.Count - 1);
|
|
}
|
|
|
|
return new Switch(switchCtx, expr, cases);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseThrowStatement
|
|
//
|
|
// ThrowStatement :
|
|
// throw |
|
|
// throw Expression
|
|
//---------------------------------------------------------------------------------------
|
|
private AST ParseThrowStatement(){
|
|
Context throwCtx = this.currentToken.Clone();
|
|
GetNextToken();
|
|
AST operand = null;
|
|
if (!this.scanner.GotEndOfLine()){
|
|
if (JSToken.Semicolon != this.currentToken.token){
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet);
|
|
try{
|
|
operand = ParseExpression();
|
|
}catch(RecoveryTokenException exc){
|
|
operand = exc._partiallyComputedNode;
|
|
if (IndexOfToken(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet, exc) == -1){
|
|
if (operand != null)
|
|
exc._partiallyComputedNode = new Throw(throwCtx, exc._partiallyComputedNode);
|
|
throw exc;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (operand != null)
|
|
throwCtx.UpdateWith(operand.context);
|
|
return new Throw(throwCtx, operand);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseTryStatement
|
|
//
|
|
// TryStatement :
|
|
// 'try' Block CatchList Finally
|
|
//
|
|
// CatchList :
|
|
// <empty> |
|
|
// CatchList Catch
|
|
//
|
|
// Catch :
|
|
// 'catch' '(' Identifier Type ')' Block
|
|
//
|
|
// Finally :
|
|
// <empty> |
|
|
// 'finally' Block
|
|
//---------------------------------------------------------------------------------------
|
|
private AST ParseTryStatement(){
|
|
Context tryCtx = this.currentToken.Clone();
|
|
Context tryEndContext = null;
|
|
AST body = null;
|
|
AST id = null;
|
|
AST handler = null;
|
|
AST finally_block = null;
|
|
RecoveryTokenException excInFinally = null;
|
|
TypeExpression type = null;
|
|
this.blockType.Add(BlockType.Block);
|
|
try{
|
|
bool catchOrFinally = false;
|
|
bool foundCatchAll = false;
|
|
GetNextToken();
|
|
if (JSToken.LeftCurly != this.currentToken.token)
|
|
ReportError(JSError.NoLeftCurly);
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_NoTrySkipTokenSet);
|
|
try{
|
|
body = ParseBlock(out tryEndContext);
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_NoTrySkipTokenSet, exc) == -1)
|
|
// do nothing and just return the containing block, if any
|
|
throw exc;
|
|
else
|
|
body = exc._partiallyComputedNode;
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_NoTrySkipTokenSet);
|
|
}
|
|
while (JSToken.Catch == this.currentToken.token){
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_NoTrySkipTokenSet);
|
|
try{
|
|
if (handler != null){
|
|
body = new Try(tryCtx, body, id, type, handler, null, false, tryEndContext);
|
|
id = null;
|
|
type = null;
|
|
handler = null;
|
|
}
|
|
catchOrFinally = true;
|
|
GetNextToken();
|
|
if (JSToken.LeftParen != this.currentToken.token)
|
|
ReportError(JSError.NoLeftParen);
|
|
GetNextToken();
|
|
if (JSToken.Identifier != this.currentToken.token){
|
|
string identifier = JSKeyword.CanBeIdentifier(this.currentToken.token);
|
|
if (null != identifier){
|
|
ForceReportInfo(JSError.KeywordUsedAsIdentifier);
|
|
id = new Lookup(identifier, this.currentToken.Clone());
|
|
}else{
|
|
ReportError(JSError.NoIdentifier);
|
|
id = new Lookup("##Exc##" + s_cDummyName++, CurrentPositionContext());
|
|
}
|
|
}else
|
|
id = new Lookup(this.scanner.GetIdentifier(), this.currentToken.Clone());
|
|
GetNextToken();
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
|
|
try{
|
|
if (JSToken.Colon == this.currentToken.token)
|
|
type = ParseTypeExpression();
|
|
else{
|
|
if (foundCatchAll) //no point in having another
|
|
ForceReportInfo(id.context, JSError.UnreachableCatch);
|
|
foundCatchAll = true;
|
|
}
|
|
if (JSToken.RightParen != this.currentToken.token)
|
|
ReportError(JSError.NoRightParen);
|
|
GetNextToken();
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1){
|
|
exc._partiallyComputedNode = null;
|
|
// rethrow
|
|
throw exc;
|
|
}else{
|
|
type = (TypeExpression)exc._partiallyComputedNode;
|
|
if (this.currentToken.token == JSToken.RightParen)
|
|
GetNextToken();
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
|
|
}
|
|
if (JSToken.LeftCurly != this.currentToken.token)
|
|
ReportError(JSError.NoLeftCurly);
|
|
handler = ParseBlock();
|
|
tryCtx.UpdateWith(handler.context);
|
|
}catch(RecoveryTokenException exc){
|
|
if (exc._partiallyComputedNode == null)
|
|
handler = new Block(CurrentPositionContext());
|
|
else
|
|
handler = exc._partiallyComputedNode;
|
|
if (IndexOfToken(NoSkipTokenSet.s_NoTrySkipTokenSet, exc) == -1){
|
|
Debug.Assert((type == null) ? exc._partiallyComputedNode == null : true);
|
|
if (type != null)
|
|
exc._partiallyComputedNode = new Try(tryCtx, body, id, type, handler, null, false, tryEndContext);
|
|
throw exc;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_NoTrySkipTokenSet);
|
|
}
|
|
}
|
|
|
|
try{
|
|
if (JSToken.Finally == this.currentToken.token){
|
|
GetNextToken();
|
|
this.blockType.Add(BlockType.Finally);
|
|
try{
|
|
finally_block = ParseBlock();
|
|
catchOrFinally = true;
|
|
}finally{
|
|
this.blockType.RemoveAt(this.blockType.Count - 1);
|
|
}
|
|
tryCtx.UpdateWith(finally_block.context);
|
|
}
|
|
}catch(RecoveryTokenException exc){
|
|
excInFinally = exc; // thrown later so we can execute code below
|
|
}
|
|
|
|
if (!catchOrFinally){
|
|
ReportError(JSError.NoCatch, true);
|
|
finally_block = new Block(CurrentPositionContext()); // make a dummy empty block
|
|
}
|
|
}finally{
|
|
this.blockType.RemoveAt(this.blockType.Count - 1);
|
|
}
|
|
|
|
bool isFinallyEscaped = false;
|
|
if (this.finallyEscaped > 0){
|
|
this.finallyEscaped--;
|
|
isFinallyEscaped = true;
|
|
}
|
|
if (excInFinally != null){
|
|
excInFinally._partiallyComputedNode = new Try(tryCtx, body, id, type, handler, finally_block, isFinallyEscaped, tryEndContext);
|
|
throw excInFinally;
|
|
}else
|
|
return new Try(tryCtx, body, id, type, handler, finally_block, isFinallyEscaped, tryEndContext);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseClass
|
|
//
|
|
// Class :
|
|
// 'class' identifier OptionalExtends ClassBody
|
|
//
|
|
// Extends :
|
|
// 'extends' QualifiedIdentifier
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
private AST ParseClass(FieldAttributes visibilitySpec, bool isStatic, Context classCtx, bool isAbstract, bool isFinal, CustomAttributeList customAttributes){
|
|
AST name = null;
|
|
AST baseId = null;
|
|
TypeExpression baseType = null;
|
|
Block body = null;
|
|
ArrayList interfaces = new ArrayList();
|
|
|
|
bool isInterface = JSToken.Interface == this.currentToken.token;
|
|
|
|
GetNextToken();
|
|
if (JSToken.Identifier == this.currentToken.token){
|
|
name = new IdentifierLiteral(this.scanner.GetIdentifier(), this.currentToken.Clone());
|
|
}else{
|
|
ReportError(JSError.NoIdentifier);
|
|
if (JSToken.Extends != this.currentToken.token
|
|
&& JSToken.Implements != this.currentToken.token
|
|
&& JSToken.LeftCurly != this.currentToken.token)
|
|
SkipTokensAndThrow(); // what the is this?
|
|
name = new IdentifierLiteral("##Missing Class Name##" + s_cDummyName++, CurrentPositionContext());
|
|
}
|
|
|
|
GetNextToken();
|
|
if (JSToken.Extends == this.currentToken.token || JSToken.Implements == this.currentToken.token){
|
|
if (isInterface && JSToken.Extends == this.currentToken.token)
|
|
this.currentToken.token = JSToken.Implements;
|
|
if (JSToken.Extends == this.currentToken.token){
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_ClassExtendsNoSkipTokenSet);
|
|
try{
|
|
baseId = ParseQualifiedIdentifier(JSError.NeedType);
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_ClassExtendsNoSkipTokenSet, exc) == -1){
|
|
exc._partiallyComputedNode = null;
|
|
throw exc;
|
|
}else{
|
|
baseId = exc._partiallyComputedNode;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_ClassExtendsNoSkipTokenSet);
|
|
}
|
|
}
|
|
if (JSToken.Implements == this.currentToken.token){
|
|
do{
|
|
AST typeId = null;
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_ClassImplementsNoSkipTokenSet);
|
|
try{
|
|
typeId = ParseQualifiedIdentifier(JSError.NeedType);
|
|
interfaces.Add(new TypeExpression(typeId));
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_ClassImplementsNoSkipTokenSet, exc) == -1){
|
|
exc._partiallyComputedNode = null;
|
|
throw exc;
|
|
}else{
|
|
if (exc._partiallyComputedNode != null)
|
|
interfaces.Add(new TypeExpression(exc._partiallyComputedNode));
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_ClassImplementsNoSkipTokenSet);
|
|
}
|
|
}while (JSToken.Comma == this.currentToken.token);
|
|
}
|
|
}
|
|
if (baseId != null)
|
|
baseType = new TypeExpression(baseId);
|
|
if (JSToken.LeftCurly != this.currentToken.token){
|
|
ReportError(JSError.NoLeftCurly);
|
|
}
|
|
|
|
// make a new state and save the old one
|
|
ArrayList blockType = this.blockType;
|
|
this.blockType = new ArrayList(16);
|
|
SimpleHashtable labelTable = this.labelTable;
|
|
this.labelTable = new SimpleHashtable(16);
|
|
|
|
Globals.ScopeStack.Push(new ClassScope(name, ((IActivationObject)Globals.ScopeStack.Peek()).GetGlobalScope())); //Give declarations a place to go while building AST
|
|
|
|
TypeExpression[] ifaces;
|
|
try{
|
|
body = ParseClassBody(false, isInterface);
|
|
classCtx.UpdateWith(body.context);
|
|
ifaces = new TypeExpression[interfaces.Count]; interfaces.CopyTo(ifaces);
|
|
Class result = new Class(classCtx, name, baseType, ifaces, body, visibilitySpec, isAbstract, isFinal, isStatic, isInterface, customAttributes);
|
|
if (customAttributes != null) customAttributes.SetTarget(result);
|
|
return result;
|
|
}catch(RecoveryTokenException exc){
|
|
classCtx.UpdateWith(exc._partiallyComputedNode.context);
|
|
ifaces = new TypeExpression[interfaces.Count]; interfaces.CopyTo(ifaces);
|
|
exc._partiallyComputedNode =
|
|
new Class(classCtx, name, baseType, ifaces, (Block)exc._partiallyComputedNode, visibilitySpec, isAbstract, isFinal, isStatic, isInterface, customAttributes);
|
|
if (customAttributes != null) customAttributes.SetTarget(exc._partiallyComputedNode);
|
|
throw exc;
|
|
}finally{
|
|
Globals.ScopeStack.Pop();
|
|
this.blockType = blockType;
|
|
this.labelTable = labelTable;
|
|
}
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseClassBody
|
|
//
|
|
// ClassBody :
|
|
// '{' OptionalClassMembers '}'
|
|
//---------------------------------------------------------------------------------------
|
|
Block ParseClassBody(bool isEnum, bool isInterface){
|
|
this.blockType.Add(BlockType.Block);
|
|
Block codeBlock = new Block(this.currentToken.Clone());
|
|
try{
|
|
GetNextToken();
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_BlockNoSkipTokenSet);
|
|
JSToken[] noSkip = null;
|
|
if (isEnum)
|
|
noSkip = NoSkipTokenSet.s_EnumBodyNoSkipTokenSet;
|
|
else if (isInterface)
|
|
noSkip = NoSkipTokenSet.s_InterfaceBodyNoSkipTokenSet;
|
|
else
|
|
noSkip = NoSkipTokenSet.s_ClassBodyNoSkipTokenSet;
|
|
try{
|
|
while (JSToken.RightCurly != this.currentToken.token){
|
|
if (JSToken.EndOfFile == this.currentToken.token){
|
|
ReportError(JSError.NoRightCurly, true);
|
|
SkipTokensAndThrow();
|
|
}
|
|
this.noSkipTokenSet.Add(noSkip);
|
|
try{
|
|
AST classMember = isEnum ? ParseEnumMember() : ParseClassMember(isInterface);
|
|
if (classMember != null)
|
|
codeBlock.Append(classMember);
|
|
}catch(RecoveryTokenException exc){
|
|
if (exc._partiallyComputedNode != null)
|
|
codeBlock.Append(exc._partiallyComputedNode);
|
|
if (IndexOfToken(noSkip, exc) == -1){
|
|
exc._partiallyComputedNode = null;
|
|
throw exc;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(noSkip);
|
|
}
|
|
}
|
|
|
|
}catch(RecoveryTokenException exc){
|
|
exc._partiallyComputedNode = codeBlock;
|
|
throw exc;
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockNoSkipTokenSet);
|
|
}
|
|
codeBlock.context.UpdateWith(this.currentToken);
|
|
GetNextToken();
|
|
}finally{
|
|
this.blockType.RemoveAt(this.blockType.Count - 1);
|
|
}
|
|
|
|
return codeBlock;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseClassMember
|
|
//
|
|
// OptionalClassMembers:
|
|
// ClassMember OptionalClassMembers |
|
|
// <empty>
|
|
//
|
|
// ClassMember :
|
|
// VariableStatement |
|
|
// Class |
|
|
// Enum |
|
|
// FunctionDeclaration
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
private AST ParseClassMember(bool isInterface){
|
|
bool parsed = false;
|
|
// Interface members can be declared public ( as a no-op).
|
|
if (isInterface && this.currentToken.token == JSToken.Public)
|
|
GetNextToken();
|
|
switch (this.currentToken.token){
|
|
case JSToken.RightCurly:
|
|
return null;
|
|
case JSToken.Semicolon:
|
|
GetNextToken();
|
|
return ParseClassMember(isInterface);
|
|
case JSToken.Const:
|
|
case JSToken.Var:
|
|
if (isInterface){
|
|
ReportError(JSError.VarIllegalInInterface, true);
|
|
GetNextToken();
|
|
SkipTokensAndThrow();
|
|
}
|
|
return ParseVariableStatement((FieldAttributes)0, null, this.currentToken.token);
|
|
case JSToken.Internal:
|
|
case JSToken.Public:
|
|
case JSToken.Static:
|
|
case JSToken.Private:
|
|
case JSToken.Protected:
|
|
case JSToken.Abstract:
|
|
case JSToken.Final:
|
|
if (isInterface){
|
|
ReportError(JSError.BadModifierInInterface, true);
|
|
GetNextToken();
|
|
SkipTokensAndThrow();
|
|
}
|
|
return ParseAttributes(null, true, true, out parsed);
|
|
case JSToken.Interface:
|
|
if (isInterface){
|
|
ReportError(JSError.InterfaceIllegalInInterface, true);
|
|
GetNextToken();
|
|
SkipTokensAndThrow();
|
|
}
|
|
return ParseClass((FieldAttributes)0, false, this.currentToken.Clone(), false, false, null);
|
|
case JSToken.Class:
|
|
if (isInterface){
|
|
ReportError(JSError.SyntaxError, true);
|
|
GetNextToken();
|
|
SkipTokensAndThrow();
|
|
}
|
|
return ParseClass((FieldAttributes)0, false, this.currentToken.Clone(), false, false, null);
|
|
case JSToken.Enum:
|
|
return ParseEnum((FieldAttributes)0, this.currentToken.Clone(), null);
|
|
case JSToken.Function:
|
|
return ParseFunction((FieldAttributes)0, false, this.currentToken.Clone(), true, isInterface, false, isInterface, null);
|
|
case JSToken.Identifier:
|
|
if (isInterface){
|
|
ReportError(JSError.SyntaxError, true);
|
|
GetNextToken();
|
|
SkipTokensAndThrow();
|
|
}
|
|
bool bAssign, canBeAttribute = true;
|
|
AST ast = ParseUnaryExpression(out bAssign, ref canBeAttribute, false);
|
|
if (canBeAttribute){
|
|
ast = ParseAttributes(ast, true, true, out parsed);
|
|
if (parsed)
|
|
return ast;
|
|
}
|
|
ReportError(JSError.SyntaxError, ast.context.Clone(), true);
|
|
SkipTokensAndThrow();
|
|
return null; // we'll never be executed, make the compiler happy
|
|
case JSToken.Import:
|
|
// handle common error of using import in class
|
|
ReportError(JSError.InvalidImport, true);
|
|
try{
|
|
ParseImportStatement();
|
|
}catch(RecoveryTokenException){
|
|
}
|
|
return null;
|
|
case JSToken.Package:
|
|
// handle common error of using package in class
|
|
Context packageContext = this.currentToken.Clone();
|
|
AST statement = ParsePackage(packageContext);
|
|
if (statement is Package)
|
|
ReportError(JSError.PackageInWrongContext, packageContext, true);
|
|
return null;
|
|
default:
|
|
ReportError(JSError.SyntaxError, true);
|
|
GetNextToken();
|
|
SkipTokensAndThrow();
|
|
return null; // we'll never be executed, make the compiler happy
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseEnum
|
|
//
|
|
// Enum :
|
|
// 'enum' identifier [':' baseType] EnumBody (in the guise of ClassBody with a param)
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
private AST ParseEnum(FieldAttributes visibilitySpec, Context enumCtx, CustomAttributeList customAttributes){
|
|
IdentifierLiteral name = null;
|
|
AST baseId = null;
|
|
TypeExpression baseType = null;
|
|
Block body = null;
|
|
|
|
GetNextToken();
|
|
if (JSToken.Identifier == this.currentToken.token){
|
|
name = new IdentifierLiteral(this.scanner.GetIdentifier(), this.currentToken.Clone());
|
|
}else{
|
|
ReportError(JSError.NoIdentifier);
|
|
if (JSToken.Colon != this.currentToken.token && JSToken.LeftCurly != this.currentToken.token)
|
|
SkipTokensAndThrow(); // what the is this?
|
|
name = new IdentifierLiteral("##Missing Enum Name##" + s_cDummyName++, CurrentPositionContext());
|
|
}
|
|
|
|
GetNextToken();
|
|
if (JSToken.Colon == this.currentToken.token){
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_EnumBaseTypeNoSkipTokenSet);
|
|
try{
|
|
baseId = ParseQualifiedIdentifier(JSError.NeedType);
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_ClassExtendsNoSkipTokenSet, exc) == -1){
|
|
exc._partiallyComputedNode = null;
|
|
throw exc;
|
|
}else{
|
|
baseId = exc._partiallyComputedNode;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_EnumBaseTypeNoSkipTokenSet);
|
|
}
|
|
}
|
|
if (baseId != null)
|
|
baseType = new TypeExpression(baseId);
|
|
if (JSToken.LeftCurly != this.currentToken.token)
|
|
ReportError(JSError.NoLeftCurly);
|
|
|
|
// make a new state and save the old one
|
|
ArrayList blockType = this.blockType;
|
|
this.blockType = new ArrayList(16);
|
|
SimpleHashtable labelTable = this.labelTable;
|
|
this.labelTable = new SimpleHashtable(16);
|
|
|
|
Globals.ScopeStack.Push(new ClassScope(name, ((IActivationObject)Globals.ScopeStack.Peek()).GetGlobalScope())); //Give declarations a place to go while building AST
|
|
|
|
try{
|
|
body = ParseClassBody(true, false);
|
|
enumCtx.UpdateWith(body.context);
|
|
EnumDeclaration result = new EnumDeclaration(enumCtx, name, baseType, body, visibilitySpec, customAttributes);
|
|
if (customAttributes != null) customAttributes.SetTarget(result);
|
|
return result;
|
|
}catch(RecoveryTokenException exc){
|
|
enumCtx.UpdateWith(exc._partiallyComputedNode.context);
|
|
exc._partiallyComputedNode = new EnumDeclaration(enumCtx, name, baseType, (Block)exc._partiallyComputedNode, visibilitySpec, customAttributes);
|
|
if (customAttributes != null) customAttributes.SetTarget(exc._partiallyComputedNode);
|
|
throw exc;
|
|
}finally{
|
|
Globals.ScopeStack.Pop();
|
|
this.blockType = blockType;
|
|
this.labelTable = labelTable;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseEnumMember
|
|
//
|
|
// OptionalEnumMembers:
|
|
// EnumMember ',' OptionalEnumMembers |
|
|
// <empty>
|
|
//
|
|
// EnumMember :
|
|
// Identifier |
|
|
// Identifer '=' IntegerLiteral
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
private AST ParseEnumMember(){
|
|
AST ast = null;
|
|
Lookup memberName = null;
|
|
AST memberValue = null;
|
|
switch (this.currentToken.token){
|
|
case JSToken.Semicolon:
|
|
GetNextToken();
|
|
return ParseEnumMember();
|
|
case JSToken.Identifier:
|
|
memberName = new Lookup(this.currentToken.Clone());
|
|
Context context = this.currentToken.Clone();
|
|
GetNextToken();
|
|
if (JSToken.Assign == this.currentToken.token){
|
|
GetNextToken();
|
|
memberValue = ParseExpression(true);
|
|
}
|
|
if (JSToken.Comma == this.currentToken.token)
|
|
GetNextToken();
|
|
else if (JSToken.RightCurly != this.currentToken.token)
|
|
ReportError(JSError.NoComma, true);
|
|
return new Constant(context, memberName, null, memberValue, FieldAttributes.Public, null);
|
|
case JSToken.Var:
|
|
// handle common error
|
|
ReportError(JSError.NoVarInEnum, true);
|
|
GetNextToken();
|
|
return ParseEnumMember();
|
|
default:
|
|
ReportError(JSError.SyntaxError, true);
|
|
SkipTokensAndThrow();
|
|
return ast; // will never be executed, but make the C# compiler happy
|
|
}
|
|
}
|
|
|
|
private bool GuessIfAbstract(){
|
|
//
|
|
// We have a class method declaraction without the "abstract"
|
|
// attribute and need to know whether to treat it as abstract
|
|
// for error reporting purposes.
|
|
//
|
|
// function bar(); -- clearly abstract, "missing abstract" error
|
|
// function bar(){ -- clearly concrete, correct
|
|
// function bar() -- clearly an error, but should it be
|
|
// "missing abstract" or "missing left curly"?
|
|
//
|
|
// In the last case we look what comes next.
|
|
//
|
|
// * If it looks like something that would start a function body -- a "var" statement or
|
|
// an expression for instance -- then we assume that the curly is missing.
|
|
//
|
|
// * If it looks like a global/package/class level declaration then we assume that it was supposed
|
|
// to be abstract.
|
|
//
|
|
// * If it is a right-curly then we assume that the class scope is being
|
|
// closed and this is therefore an abstract function.
|
|
//
|
|
|
|
switch(this.currentToken.token){
|
|
case JSToken.Const:
|
|
case JSToken.Package:
|
|
case JSToken.Internal:
|
|
case JSToken.Public:
|
|
case JSToken.Static:
|
|
case JSToken.Private:
|
|
case JSToken.Protected:
|
|
case JSToken.Abstract:
|
|
case JSToken.Final:
|
|
case JSToken.Interface:
|
|
case JSToken.Class:
|
|
case JSToken.Enum:
|
|
case JSToken.Function:
|
|
case JSToken.RightCurly:
|
|
return true;
|
|
case JSToken.Semicolon:
|
|
GetNextToken();
|
|
return true;
|
|
case JSToken.Var:
|
|
case JSToken.LeftCurly:
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseFunction
|
|
//
|
|
// FunctionDeclaration :
|
|
// VisibilityModifier 'function' GetSet Identifier '('
|
|
// FormalParameterList ')' '{' FunctionBody '}'
|
|
//
|
|
// GetSet:
|
|
// <empty> |
|
|
// 'get' |
|
|
// 'set'
|
|
//
|
|
// FormalParameterList :
|
|
// <empty> |
|
|
// IdentifierList Identifier
|
|
//
|
|
// IdentifierList :
|
|
// <empty> |
|
|
// Identifier, IdentifierList
|
|
//---------------------------------------------------------------------------------------
|
|
private AST ParseFunction(FieldAttributes visibilitySpec,
|
|
bool inExpression,
|
|
Context fncCtx,
|
|
bool isMethod,
|
|
bool isAbstract,
|
|
bool isFinal,
|
|
bool isInterface,
|
|
CustomAttributeList customAttributes){
|
|
return ParseFunction(visibilitySpec, inExpression, fncCtx, isMethod, isAbstract, isFinal, isInterface, customAttributes, null);
|
|
}
|
|
|
|
private AST ParseFunction(FieldAttributes visibilitySpec,
|
|
bool inExpression,
|
|
Context fncCtx,
|
|
bool isMethod,
|
|
bool isAbstract,
|
|
bool isFinal,
|
|
bool isInterface,
|
|
CustomAttributeList customAttributes,
|
|
Call function){
|
|
IdentifierLiteral name = null;
|
|
AST interfaceName = null;
|
|
ArrayList formalParameters = null;
|
|
TypeExpression returnType = null;
|
|
Block body = null;
|
|
bool isGetter = false;
|
|
bool isSetter = false;
|
|
|
|
if (function == null){
|
|
GetNextToken();
|
|
if (isMethod)
|
|
if (JSToken.Get == this.currentToken.token){
|
|
isGetter = true;
|
|
GetNextToken();
|
|
}else if (JSToken.Set == this.currentToken.token){
|
|
isSetter = true;
|
|
GetNextToken();
|
|
}
|
|
|
|
// get the function name or make an anonymous function if in expression "position"
|
|
if (JSToken.Identifier == this.currentToken.token){
|
|
name = new IdentifierLiteral(this.scanner.GetIdentifier(), this.currentToken.Clone());
|
|
GetNextToken();
|
|
if (JSToken.AccessField == this.currentToken.token){
|
|
if (isInterface) // "function IBar.foo()" is illegal in an interface declaration
|
|
ReportError(JSError.SyntaxError, true);
|
|
GetNextToken();
|
|
if (JSToken.Identifier == this.currentToken.token){
|
|
interfaceName = new Lookup(name.context);
|
|
name = new IdentifierLiteral(this.scanner.GetIdentifier(), this.currentToken.Clone());
|
|
GetNextToken();
|
|
while (JSToken.AccessField == this.currentToken.token){
|
|
GetNextToken();
|
|
if (JSToken.Identifier == this.currentToken.token){
|
|
interfaceName = new Member(interfaceName.context.CombineWith(this.currentToken), interfaceName,
|
|
new ConstantWrapper(name.ToString(), name.context));
|
|
name = new IdentifierLiteral(this.scanner.GetIdentifier(), this.currentToken.Clone());
|
|
GetNextToken();
|
|
}else
|
|
ReportError(JSError.NoIdentifier, true);
|
|
}
|
|
}else
|
|
ReportError(JSError.NoIdentifier, true);
|
|
}
|
|
}else{
|
|
string identifier = JSKeyword.CanBeIdentifier(this.currentToken.token);
|
|
if (null != identifier){
|
|
ForceReportInfo(JSError.KeywordUsedAsIdentifier, isMethod);
|
|
name = new IdentifierLiteral(identifier, this.currentToken.Clone());
|
|
GetNextToken();
|
|
}else{
|
|
if (!inExpression){
|
|
identifier = this.currentToken.GetCode();
|
|
ReportError(JSError.NoIdentifier, true);
|
|
GetNextToken();
|
|
}else
|
|
identifier = "";
|
|
name = new IdentifierLiteral(identifier, CurrentPositionContext());
|
|
}
|
|
}
|
|
}else{ // function was passed in, this is an error condition
|
|
name = function.GetName();
|
|
}
|
|
|
|
// make a new state and save the old one
|
|
ArrayList blockType = this.blockType;
|
|
this.blockType = new ArrayList(16);
|
|
SimpleHashtable labelTable = this.labelTable;
|
|
this.labelTable = new SimpleHashtable(16);
|
|
FunctionScope fscope = new FunctionScope(Globals.ScopeStack.Peek(), isMethod);
|
|
Globals.ScopeStack.Push(fscope); //Give declarations a place to go while building AST
|
|
|
|
try{
|
|
formalParameters = new ArrayList();
|
|
Context paramArrayContext = null;
|
|
if (function == null){
|
|
// get the formal parameters
|
|
if (JSToken.LeftParen != this.currentToken.token)
|
|
ReportError(JSError.NoLeftParen);
|
|
GetNextToken();
|
|
// create the list of arguments and update the context
|
|
while (JSToken.RightParen != this.currentToken.token){
|
|
if (paramArrayContext != null){
|
|
ReportError(JSError.ParamListNotLast, paramArrayContext, true);
|
|
paramArrayContext = null;
|
|
}
|
|
String id = null;
|
|
TypeExpression typeExpr = null;
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_FunctionDeclNoSkipTokenSet);
|
|
try{
|
|
if (JSToken.ParamArray == this.currentToken.token){
|
|
paramArrayContext = this.currentToken.Clone();
|
|
GetNextToken();
|
|
}
|
|
if (JSToken.Identifier != this.currentToken.token && (id = JSKeyword.CanBeIdentifier(this.currentToken.token)) == null){
|
|
if (JSToken.LeftCurly == this.currentToken.token){
|
|
ReportError(JSError.NoRightParen);
|
|
break;
|
|
}else if (JSToken.Comma == this.currentToken.token){
|
|
// We're missing an argument (or previous argument was malformed and
|
|
// we skipped to the comma.) Keep trying to parse the argument list --
|
|
// we will skip the comma below.
|
|
ReportError(JSError.SyntaxError, true);
|
|
}else{
|
|
ReportError(JSError.SyntaxError, true);
|
|
SkipTokensAndThrow();
|
|
}
|
|
}else{
|
|
if (null == id)
|
|
id = this.scanner.GetIdentifier();
|
|
else
|
|
ForceReportInfo(JSError.KeywordUsedAsIdentifier);
|
|
Context paramCtx = this.currentToken.Clone();
|
|
GetNextToken();
|
|
if (JSToken.Colon == this.currentToken.token){
|
|
typeExpr = ParseTypeExpression();
|
|
if (null != typeExpr)
|
|
paramCtx.UpdateWith(typeExpr.context);
|
|
}
|
|
|
|
|
|
CustomAttributeList custAttrs = null;
|
|
if (paramArrayContext != null){
|
|
custAttrs = new CustomAttributeList(paramArrayContext);
|
|
custAttrs.Append(new CustomAttribute(paramArrayContext, new Lookup("...", paramArrayContext), new ASTList(null)));
|
|
}
|
|
formalParameters.Add(new ParameterDeclaration(paramCtx, id, typeExpr, custAttrs));
|
|
}
|
|
|
|
// got an arg, it should be either a ',' or ')'
|
|
if (JSToken.RightParen == this.currentToken.token)
|
|
break;
|
|
else if (JSToken.Comma != this.currentToken.token){
|
|
// deal with error in some "intelligent" way
|
|
if (JSToken.LeftCurly == this.currentToken.token){
|
|
ReportError(JSError.NoRightParen);
|
|
break;
|
|
}else{
|
|
if (JSToken.Identifier == this.currentToken.token && typeExpr == null){
|
|
// it's possible that the guy was writing the type in C/C++ style (i.e. int x)
|
|
ReportError(JSError.NoCommaOrTypeDefinitionError);
|
|
}else
|
|
ReportError(JSError.NoComma);
|
|
}
|
|
}
|
|
GetNextToken();
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_FunctionDeclNoSkipTokenSet, exc) == -1)
|
|
throw exc;
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_FunctionDeclNoSkipTokenSet);
|
|
}
|
|
}
|
|
fncCtx.UpdateWith(this.currentToken);
|
|
// if it is a getter/setter must have 0/1 arg only
|
|
if (isGetter && formalParameters.Count != 0){
|
|
ReportError(JSError.BadPropertyDeclaration, true);
|
|
isGetter = false;
|
|
}else if (isSetter && formalParameters.Count != 1){
|
|
ReportError(JSError.BadPropertyDeclaration, true);
|
|
isSetter = false;
|
|
}
|
|
GetNextToken();
|
|
|
|
// check the return type
|
|
if (JSToken.Colon == this.currentToken.token){
|
|
if (isSetter)
|
|
ReportError(JSError.SyntaxError);
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_StartBlockNoSkipTokenSet);
|
|
try{
|
|
returnType = ParseTypeExpression();
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_StartBlockNoSkipTokenSet, exc) == -1){
|
|
exc._partiallyComputedNode = null;
|
|
throw exc;
|
|
}else{
|
|
if (exc._partiallyComputedNode != null)
|
|
returnType = (TypeExpression)exc._partiallyComputedNode;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_StartBlockNoSkipTokenSet);
|
|
}
|
|
if (isSetter)
|
|
returnType = null;
|
|
}
|
|
}else{ // function was passed in, this is an error condition
|
|
function.GetParameters(formalParameters);
|
|
}
|
|
|
|
// read the function body of non-abstract functions.
|
|
|
|
if (JSToken.LeftCurly != this.currentToken.token && (isAbstract || (isMethod && GuessIfAbstract()))){
|
|
if (!isAbstract){
|
|
isAbstract = true;
|
|
ReportError(JSError.ShouldBeAbstract, fncCtx, true);
|
|
}
|
|
body = new Block(this.currentToken.Clone());
|
|
}else{
|
|
if (JSToken.LeftCurly != this.currentToken.token)
|
|
ReportError(JSError.NoLeftCurly, true);
|
|
else if (isAbstract)
|
|
ReportError(JSError.AbstractWithBody, fncCtx, true);
|
|
|
|
this.blockType.Add(BlockType.Block);
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_BlockNoSkipTokenSet);
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
|
|
try{
|
|
// parse the block locally to get the exact end of function
|
|
body = new Block(this.currentToken.Clone());
|
|
GetNextToken();
|
|
|
|
while (JSToken.RightCurly != this.currentToken.token){
|
|
try{
|
|
body.Append(ParseStatement());
|
|
}catch(RecoveryTokenException exc){
|
|
if (exc._partiallyComputedNode != null){
|
|
body.Append(exc._partiallyComputedNode);
|
|
}
|
|
if (IndexOfToken(NoSkipTokenSet.s_StartStatementNoSkipTokenSet, exc) == -1)
|
|
throw exc;
|
|
}
|
|
}
|
|
|
|
body.context.UpdateWith(this.currentToken);
|
|
fncCtx.UpdateWith(this.currentToken);
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_BlockNoSkipTokenSet, exc) == -1){
|
|
Globals.ScopeStack.Pop(); //Pop current scope so that FunctionDeclaration sees proper scope stack
|
|
try{
|
|
ParameterDeclaration[] foParameters = new ParameterDeclaration[formalParameters.Count]; formalParameters.CopyTo(foParameters);
|
|
if (inExpression)
|
|
exc._partiallyComputedNode =
|
|
new FunctionExpression(fncCtx, name, foParameters, returnType, body, fscope, visibilitySpec);
|
|
else
|
|
exc._partiallyComputedNode =
|
|
new FunctionDeclaration(fncCtx, interfaceName, name, foParameters, returnType, body, fscope, visibilitySpec,
|
|
isMethod, isGetter, isSetter, isAbstract, isFinal, customAttributes);
|
|
if (customAttributes != null) customAttributes.SetTarget(exc._partiallyComputedNode);
|
|
}finally{
|
|
Globals.ScopeStack.Push(fscope); //Push it back so that the next finally can pop it
|
|
}
|
|
throw exc;
|
|
}
|
|
}finally{
|
|
this.blockType.RemoveAt(this.blockType.Count - 1);
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockNoSkipTokenSet);
|
|
}
|
|
|
|
GetNextToken();
|
|
}
|
|
}finally{
|
|
// restore state
|
|
this.blockType = blockType;
|
|
this.labelTable = labelTable;
|
|
Globals.ScopeStack.Pop();
|
|
}
|
|
|
|
ParameterDeclaration[] fParameters = new ParameterDeclaration[formalParameters.Count]; formalParameters.CopyTo(fParameters);
|
|
AST func;
|
|
if (inExpression)
|
|
func = new FunctionExpression(fncCtx, name, fParameters, returnType, body, fscope, visibilitySpec);
|
|
else
|
|
func = new FunctionDeclaration(fncCtx, interfaceName, name, fParameters, returnType, body, fscope, visibilitySpec,
|
|
isMethod, isGetter, isSetter, isAbstract, isFinal, customAttributes);
|
|
|
|
if (customAttributes != null) customAttributes.SetTarget(func);
|
|
return func;
|
|
|
|
}
|
|
|
|
//used by FunctionConstructor
|
|
internal AST ParseFunctionExpression(){
|
|
GetNextToken(); //skip over function keyword
|
|
return ParseFunction((FieldAttributes)0, true, this.currentToken.Clone(), false, false, false, false, null);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseNamedBreakpoint
|
|
//
|
|
// Used by the debugger to parsed a named breakpoint, that is a name of a function with
|
|
// possible arguments and optionally followed by an il offset
|
|
//---------------------------------------------------------------------------------------
|
|
internal String[] ParseNamedBreakpoint(out int argNumber){
|
|
argNumber = 0;
|
|
|
|
// parse the function name
|
|
AST function = ParseQualifiedIdentifier(JSError.SyntaxError);
|
|
if (function != null){
|
|
String[] parsedFunction = new String[4];
|
|
parsedFunction[0] = function.ToString();
|
|
|
|
if (JSToken.LeftParen == this.currentToken.token){
|
|
String id = null;
|
|
String typeString = null;
|
|
AST qualid = null;
|
|
|
|
parsedFunction[1] = "";
|
|
|
|
GetNextToken();
|
|
// parse the formal parameters
|
|
while (JSToken.RightParen != this.currentToken.token){
|
|
id = null;
|
|
if (JSToken.Identifier != this.currentToken.token && (id = JSKeyword.CanBeIdentifier(this.currentToken.token)) == null){
|
|
return null;
|
|
}else{
|
|
if (null == id)
|
|
id = this.scanner.GetIdentifier();
|
|
qualid = new Lookup(id, this.currentToken.Clone());
|
|
GetNextToken();
|
|
if (JSToken.AccessField == this.currentToken.token){
|
|
qualid = ParseScopeSequence(qualid, JSError.SyntaxError);
|
|
typeString = qualid.ToString();
|
|
while (JSToken.LeftBracket == this.currentToken.token){
|
|
GetNextToken();
|
|
if (JSToken.RightBracket != this.currentToken.token)
|
|
return null;
|
|
typeString += "[]";
|
|
GetNextToken();
|
|
}
|
|
}else if (JSToken.Colon == this.currentToken.token){
|
|
GetNextToken();
|
|
if (JSToken.RightParen == this.currentToken.token)
|
|
return null;
|
|
continue;
|
|
}else{
|
|
typeString = qualid.ToString();
|
|
}
|
|
parsedFunction[1] += typeString + " ";
|
|
}
|
|
argNumber++;
|
|
|
|
if (JSToken.Comma == this.currentToken.token){
|
|
GetNextToken();
|
|
if (JSToken.RightParen == this.currentToken.token)
|
|
return null;
|
|
}
|
|
}
|
|
|
|
GetNextToken();
|
|
|
|
// parse a return value if any
|
|
if (JSToken.Colon == this.currentToken.token){
|
|
GetNextToken();
|
|
id = null;
|
|
if (JSToken.Identifier != this.currentToken.token && (id = JSKeyword.CanBeIdentifier(this.currentToken.token)) == null){
|
|
return null;
|
|
}else{
|
|
if (null == id)
|
|
id = this.scanner.GetIdentifier();
|
|
qualid = new Lookup(id, this.currentToken.Clone());
|
|
GetNextToken();
|
|
if (JSToken.AccessField == this.currentToken.token){
|
|
qualid = ParseScopeSequence(qualid, JSError.SyntaxError);
|
|
parsedFunction[2] = qualid.ToString();
|
|
while (JSToken.LeftBracket == this.currentToken.token){
|
|
GetNextToken();
|
|
if (JSToken.RightBracket != this.currentToken.token)
|
|
return null;
|
|
parsedFunction[2] += "[]";
|
|
GetNextToken();
|
|
}
|
|
}else{
|
|
parsedFunction[2] = qualid.ToString();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
if (JSToken.Plus == this.currentToken.token){
|
|
GetNextToken();
|
|
if (JSToken.IntegerLiteral != this.currentToken.token)
|
|
return null;
|
|
parsedFunction[3] = this.currentToken.GetCode();
|
|
GetNextToken();
|
|
}
|
|
|
|
if (JSToken.EndOfFile != this.currentToken.token)
|
|
return null; // some extra crap
|
|
return parsedFunction;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParsePackage
|
|
//
|
|
// Package :
|
|
// 'package' QualifiedIdentifier '{' ClassList '}'
|
|
//
|
|
// ClassList :
|
|
// <empty> |
|
|
// Class ClassList |
|
|
// Attributes Class ClassList |
|
|
// Attributes Enum ClassList
|
|
//---------------------------------------------------------------------------------------
|
|
// Because 'package' is not a reserved word in JS5 we have to deal with an ambiguity
|
|
// in the grammar. A source sequence like the following
|
|
// package
|
|
// x
|
|
// { }
|
|
// can be legally parsed in two ways:
|
|
// Identifier Identifier Block or
|
|
// Package
|
|
// we give Package priority in this situation.
|
|
// Here is how we deal with some possible cases:
|
|
// 1- ** package <no line break> QualifiedIdentifier ** is parsed unambiguously as a package production regardless of what comes after Identifier
|
|
// 2- ** package <no line break> NotOneOf(Operator | '[' | '.' | '(' | Identifier) '{' ** is parsed as a package production with an error
|
|
// 3- ** package <line break> '{' ** is parsed as a package (anonymous) with an error
|
|
// 4- ** package <line break> Not(Identifier) ** is never parsed as a package
|
|
private AST ParsePackage(Context packageContext){
|
|
GetNextToken();
|
|
AST qualid = null;
|
|
bool gotLineBreak = this.scanner.GotEndOfLine();
|
|
|
|
// erroneous package production
|
|
if (JSToken.Identifier != this.currentToken.token){
|
|
if (JSScanner.CanParseAsExpression(this.currentToken.token)){
|
|
// it's an expression. Report a warning. package and this.currentToken can be an expression (i.e. 'package +')
|
|
ReportError(JSError.KeywordUsedAsIdentifier, packageContext.Clone(), true);
|
|
qualid = new Lookup("package", packageContext);
|
|
// get the member expression
|
|
qualid = MemberExpression(qualid, null);
|
|
bool isLeftHandSide;
|
|
qualid = ParsePostfixExpression(qualid, out isLeftHandSide);
|
|
qualid = ParseExpression(qualid, false, isLeftHandSide, JSToken.None);
|
|
return new Expression(qualid.context.Clone(), qualid);
|
|
}else if (!gotLineBreak){
|
|
if (JSToken.Increment == this.currentToken.token || JSToken.Decrement == this.currentToken.token){
|
|
// it's a postfix expression. Report a warning
|
|
ReportError(JSError.KeywordUsedAsIdentifier, packageContext.Clone(), true);
|
|
bool dummy;
|
|
qualid = new Lookup("package", packageContext);
|
|
qualid = ParsePostfixExpression(qualid, out dummy);
|
|
qualid = ParseExpression(qualid, false, false, JSToken.None);
|
|
return new Expression(qualid.context.Clone(), qualid);
|
|
}
|
|
}else{
|
|
// it's an expression. Report a warning which, as a side effect, will make the current token be the next token fetched
|
|
ReportError(JSError.KeywordUsedAsIdentifier, packageContext.Clone(), true);
|
|
return new Lookup("package", packageContext);
|
|
}
|
|
}else{
|
|
// it is an identifier, parse it as a qualified identifier
|
|
this.errorToken = this.currentToken; // this will make GetNextToken() in ParseQualifiedIdentifier() return this.currentToken
|
|
qualid = ParseQualifiedIdentifier(JSError.NoIdentifier);
|
|
}
|
|
|
|
// if we are here we have:
|
|
// ** package QualifiedIdentifier ** or
|
|
// ** package SomeNonSenseToken **, that is a token that does not make an expression
|
|
|
|
Context nonSenseToken = null;
|
|
if (JSToken.LeftCurly != this.currentToken.token && qualid == null){
|
|
// we want to peek and see whether the next token is a LeftCurly
|
|
nonSenseToken = this.currentToken.Clone();
|
|
GetNextToken();
|
|
}
|
|
|
|
if (JSToken.LeftCurly == this.currentToken.token){
|
|
// sounds like a package, possibly with an error. If qualid is not null is actually a good package, otherwise we treat it
|
|
// as an anonymous package and keep going.
|
|
if (qualid == null){
|
|
if (nonSenseToken == null)
|
|
nonSenseToken = this.currentToken.Clone();
|
|
ReportError(JSError.NoIdentifier, nonSenseToken, true);
|
|
}
|
|
}else{
|
|
if (qualid == null){
|
|
// this is pretty screwy, let's ignore the package keyword for a start
|
|
ReportError(JSError.SyntaxError, packageContext);
|
|
if (JSScanner.CanStartStatement(nonSenseToken.token)){
|
|
// this is tricky we assign nonSenseToken to this.currentToken and call ParseStatement, because we know it is a statement start token.
|
|
// The parser should then call GetNextToken() which will return the this.currentToken that is assigned to this.errorToken
|
|
this.currentToken = nonSenseToken;
|
|
return ParseStatement();
|
|
}else{
|
|
//ReportError(JSError.SyntaxError, nonSenseToken);
|
|
if (JSScanner.CanStartStatement(this.currentToken.token)){
|
|
this.errorToken = null;
|
|
return ParseStatement();
|
|
}else{
|
|
ReportError(JSError.SyntaxError);
|
|
SkipTokensAndThrow();
|
|
}
|
|
}
|
|
}else{
|
|
if (gotLineBreak){
|
|
// we are here with the following: 'package' <line break> QalifiedIdentifier' however we do not have a left curly.
|
|
// if the token in our hand can start an expression we go with two expressions, otherwise we accept it as a package
|
|
//if (JSScanner.CanParseAsExpression(this.currentToken.token)){
|
|
ReportError(JSError.KeywordUsedAsIdentifier, packageContext.Clone(), true);
|
|
Block block = new Block(packageContext.Clone());
|
|
block.Append(new Lookup("package", packageContext));
|
|
qualid = MemberExpression(qualid, null);
|
|
bool isLeftHandSide;
|
|
qualid = ParsePostfixExpression(qualid, out isLeftHandSide);
|
|
qualid = ParseExpression(qualid, false, true, JSToken.None);
|
|
block.Append(new Expression(qualid.context.Clone(), qualid));
|
|
block.context.UpdateWith(qualid.context);
|
|
return block;
|
|
//}
|
|
}
|
|
// the package production rule is entered regardless of the presence of a left curly.
|
|
ReportError(JSError.NoLeftCurly);
|
|
}
|
|
}
|
|
|
|
PackageScope pscope = new PackageScope(Globals.ScopeStack.Peek());
|
|
Globals.ScopeStack.Push(pscope); //Give declarations a place to go while building AST
|
|
try{
|
|
string name = (qualid != null) ? qualid.ToString() : "anonymous package";
|
|
pscope.name = name;
|
|
packageContext.UpdateWith(this.currentToken);
|
|
ASTList classList = new ASTList(packageContext);
|
|
|
|
GetNextToken();
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_BlockNoSkipTokenSet);
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_PackageBodyNoSkipTokenSet);
|
|
try{
|
|
while (this.currentToken.token != JSToken.RightCurly){
|
|
AST ast = null;
|
|
try{
|
|
switch (this.currentToken.token){
|
|
|
|
case JSToken.Interface:
|
|
case JSToken.Class:
|
|
classList.Append(ParseClass((FieldAttributes)0, false, this.currentToken.Clone(), false, false, null));
|
|
break;
|
|
|
|
case JSToken.Enum:
|
|
classList.Append(ParseEnum((FieldAttributes)0, this.currentToken.Clone(), null));
|
|
break;
|
|
case JSToken.Internal:
|
|
case JSToken.Public:
|
|
case JSToken.Static:
|
|
case JSToken.Private:
|
|
case JSToken.Protected:
|
|
case JSToken.Abstract:
|
|
case JSToken.Final:
|
|
bool parsedOK;
|
|
ast = ParseAttributes(null, true, false, out parsedOK);
|
|
if (parsedOK){
|
|
if (ast is Class){
|
|
classList.Append(ast);
|
|
break;
|
|
}
|
|
}
|
|
ReportError(JSError.OnlyClassesAllowed, ast.context.Clone(), true);
|
|
SkipTokensAndThrow();
|
|
break;
|
|
|
|
case JSToken.Identifier:
|
|
bool bAssign, canBeAttribute = true;
|
|
ast = ParseUnaryExpression(out bAssign, ref canBeAttribute, false);
|
|
if (canBeAttribute){
|
|
bool parsed;
|
|
ast = ParseAttributes(ast, true, false, out parsed);
|
|
if (parsed){
|
|
if (ast is Class){
|
|
classList.Append(ast);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
ReportError(JSError.OnlyClassesAllowed, ast.context.Clone(), true);
|
|
SkipTokensAndThrow();
|
|
break;
|
|
|
|
case JSToken.EndOfFile:
|
|
EOFError(JSError.ErrEOF);
|
|
throw new EndOfFile(); // abort parsing, get back to the main parse routine
|
|
|
|
case JSToken.Semicolon: // ignore any spurious semicolon
|
|
GetNextToken();
|
|
break;
|
|
case JSToken.Import:
|
|
// handle common error of using import in package
|
|
ReportError(JSError.InvalidImport, true);
|
|
try{
|
|
ParseImportStatement();
|
|
}catch(RecoveryTokenException){
|
|
}
|
|
break;
|
|
case JSToken.Package:
|
|
// handle common error of using package in package
|
|
Context nestedPackageContext = this.currentToken.Clone();
|
|
AST statement = ParsePackage(nestedPackageContext);
|
|
if (statement is Package)
|
|
ReportError(JSError.PackageInWrongContext, nestedPackageContext, true);
|
|
break;
|
|
default:
|
|
ReportError(JSError.OnlyClassesAllowed, (ast != null) ? ast.context.Clone() : CurrentPositionContext(), true);
|
|
SkipTokensAndThrow();
|
|
break;
|
|
}
|
|
}catch(RecoveryTokenException exc){
|
|
if (exc._partiallyComputedNode != null && exc._partiallyComputedNode is Class){
|
|
classList.Append((Class)exc._partiallyComputedNode);
|
|
exc._partiallyComputedNode = null;
|
|
}
|
|
if (IndexOfToken(NoSkipTokenSet.s_PackageBodyNoSkipTokenSet, exc) == -1)
|
|
throw exc;
|
|
}
|
|
}
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_BlockNoSkipTokenSet, exc) == -1){
|
|
ReportError(JSError.NoRightCurly, CurrentPositionContext());
|
|
exc._partiallyComputedNode = new Package(name, qualid, classList, packageContext);
|
|
throw exc;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_PackageBodyNoSkipTokenSet);
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockNoSkipTokenSet);
|
|
}
|
|
GetNextToken();
|
|
return new Package(name, qualid, classList, packageContext);
|
|
}finally{
|
|
Globals.ScopeStack.Pop();
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseStaticInitializer
|
|
//
|
|
// StaticInitializer :
|
|
// '{' FunctionBody '}'
|
|
//---------------------------------------------------------------------------------------
|
|
private AST ParseStaticInitializer(Context initContext){
|
|
Block body = null;
|
|
FunctionScope scope = new FunctionScope(Globals.ScopeStack.Peek());
|
|
scope.isStatic = true;
|
|
|
|
// make a new state and save the old one
|
|
ArrayList blockType = this.blockType;
|
|
this.blockType = new ArrayList(16);
|
|
SimpleHashtable labelTable = this.labelTable;
|
|
this.labelTable = new SimpleHashtable(16);
|
|
|
|
this.blockType.Add(BlockType.Block);
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_BlockNoSkipTokenSet);
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
|
|
try{
|
|
Globals.ScopeStack.Push(scope); //Give declarations a place to go while building AST
|
|
// parse the block locally to get the exact end of function
|
|
body = new Block(this.currentToken.Clone());
|
|
GetNextToken();
|
|
|
|
while (JSToken.RightCurly != this.currentToken.token){
|
|
try{
|
|
body.Append(ParseStatement());
|
|
}catch(RecoveryTokenException exc){
|
|
if (exc._partiallyComputedNode != null)
|
|
body.Append(exc._partiallyComputedNode);
|
|
if (IndexOfToken(NoSkipTokenSet.s_StartStatementNoSkipTokenSet, exc) == -1)
|
|
throw exc;
|
|
}
|
|
}
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_BlockNoSkipTokenSet, exc) == -1){
|
|
exc._partiallyComputedNode = new StaticInitializer(initContext, body, scope);
|
|
throw exc;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockNoSkipTokenSet);
|
|
this.blockType = blockType;
|
|
this.labelTable = labelTable;
|
|
Globals.ScopeStack.Pop();
|
|
}
|
|
body.context.UpdateWith(this.currentToken);
|
|
initContext.UpdateWith(this.currentToken);
|
|
|
|
GetNextToken();
|
|
return new StaticInitializer(initContext, body, scope);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseExpression
|
|
//
|
|
// Expression :
|
|
// AssignmentExpressionList AssignmentExpression
|
|
//
|
|
// AssignmentExpressionList :
|
|
// <empty> |
|
|
// AssignmentExpression ',' AssignmentExpressionList
|
|
//
|
|
// AssignmentExpression :
|
|
// ConditionalExpression |
|
|
// LeftHandSideExpression AssignmentOperator AssignmentExpression
|
|
//
|
|
// ConditionalExpression :
|
|
// LogicalORExpression OptionalConditionalExpression
|
|
//
|
|
// OptionalConditionalExpression :
|
|
// <empty> |
|
|
// '?' AssignmentExpression ':' AssignmentExpression
|
|
//
|
|
// LogicalORExpression :
|
|
// LogicalANDExpression OptionalLogicalOrExpression
|
|
//
|
|
// OptionalLogicalOrExpression :
|
|
// <empty> |
|
|
// '||' LogicalANDExpression OptionalLogicalOrExpression
|
|
//
|
|
// LogicalANDExpression :
|
|
// BitwiseORExpression OptionalLogicalANDExpression
|
|
//
|
|
// OptionalLogicalANDExpression :
|
|
// <empty> |
|
|
// '&&' BitwiseORExpression OptionalLogicalANDExpression
|
|
//
|
|
// BitwiseORExpression :
|
|
// BitwiseXORExpression OptionalBitwiseORExpression
|
|
//
|
|
// OptionalBitwiseORExpression :
|
|
// <empty> |
|
|
// '|' BitwiseXORExpression OptionalBitwiseORExpression
|
|
//
|
|
// BitwiseXORExpression :
|
|
// BitwiseANDExpression OptionalBitwiseXORExpression
|
|
//
|
|
// OptionalBitwiseXORExpression :
|
|
// <empty> |
|
|
// '^' BitwiseANDExpression OptionalBitwiseXORExpression
|
|
//
|
|
// BitwiseANDExpression :
|
|
// EqualityExpression OptionalBitwiseANDExpression
|
|
//
|
|
// OptionalBitwiseANDExpression :
|
|
// <empty> |
|
|
// '&' EqualityExpression OptionalBitwiseANDExpression
|
|
//
|
|
// EqualityExpression :
|
|
// RelationalExpression |
|
|
// RelationalExpression '==' EqualityExpression |
|
|
// RelationalExpression '!=' EqualityExpression |
|
|
// RelationalExpression '===' EqualityExpression |
|
|
// RelationalExpression '!==' EqualityExpression
|
|
//
|
|
// RelationalExpression :
|
|
// ShiftExpression |
|
|
// ShiftExpression '<' RelationalExpression |
|
|
// ShiftExpression '>' RelationalExpression |
|
|
// ShiftExpression '<=' RelationalExpression |
|
|
// ShiftExpression '>=' RelationalExpression
|
|
//
|
|
// ShiftExpression :
|
|
// AdditiveExpression |
|
|
// AdditiveExpression '<<' ShiftExpression |
|
|
// AdditiveExpression '>>' ShiftExpression |
|
|
// AdditiveExpression '>>>' ShiftExpression
|
|
//
|
|
// AdditiveExpression :
|
|
// MultiplicativeExpression |
|
|
// MultiplicativeExpression '+' AdditiveExpression |
|
|
// MultiplicativeExpression '-' AdditiveExpression
|
|
//
|
|
// MultiplicativeExpression :
|
|
// UnaryExpression |
|
|
// UnaryExpression '*' MultiplicativeExpression |
|
|
// UnaryExpression '/' MultiplicativeExpression |
|
|
// UnaryExpression '%' MultiplicativeExpression
|
|
//---------------------------------------------------------------------------------------
|
|
private AST ParseExpression(){
|
|
bool bAssign;
|
|
AST lhs = ParseUnaryExpression(out bAssign, false);
|
|
return ParseExpression(lhs, false, bAssign, JSToken.None);
|
|
}
|
|
|
|
private AST ParseExpression(bool single){
|
|
bool bAssign;
|
|
AST lhs = ParseUnaryExpression(out bAssign, false);
|
|
return ParseExpression(lhs, single, bAssign, JSToken.None);
|
|
}
|
|
|
|
private AST ParseExpression(bool single, JSToken inToken){
|
|
bool bAssign;
|
|
AST lhs = ParseUnaryExpression(out bAssign, false);
|
|
return ParseExpression(lhs, single, bAssign, inToken);
|
|
}
|
|
|
|
private AST ParseExpression(AST leftHandSide, bool single, bool bCanAssign, JSToken inToken){
|
|
OpListItem opsStack = new OpListItem(JSToken.None, OpPrec.precNone, null); // dummy element
|
|
AstListItem termStack = new AstListItem(leftHandSide, null);
|
|
|
|
AST expr = null;
|
|
|
|
try{
|
|
for (;;){
|
|
// if 'binary op' or 'conditional' but not 'comma'
|
|
// inToken is a special case because of the for..in crap. When ParseExpression is called from
|
|
// for, inToken = JSToken.In which excludes JSToken.In from the list of operators, otherwise
|
|
// inToken = JSToken.None which is always true if the first condition is true
|
|
if (JSScanner.IsProcessableOperator(this.currentToken.token) && inToken != this.currentToken.token){
|
|
|
|
OpPrec prec = JSScanner.GetOperatorPrecedence(this.currentToken.token);
|
|
bool rightAssoc = JSScanner.IsRightAssociativeOperator(this.currentToken.token);
|
|
// the current operator has lower precedence than the operator at the top of the stack
|
|
// or it has the same precedence and it is left associative (that is, no 'assign op' or 'conditional')
|
|
while (prec < opsStack._prec || prec == opsStack._prec && !rightAssoc){
|
|
//Console.Out.WriteLine("lower prec or same and left assoc");
|
|
expr = CreateExpressionNode(opsStack._operator, termStack._prev._term, termStack._term);
|
|
|
|
// pop the operator stack
|
|
opsStack = opsStack._prev;
|
|
// pop the term stack twice
|
|
termStack = termStack._prev._prev;
|
|
// push node onto the stack
|
|
termStack = new AstListItem(expr, termStack);
|
|
}
|
|
|
|
// the current operator has higher precedence that every scanned operators on the stack, or
|
|
// it has the same precedence as the one at the top of the stack and it is right associative
|
|
|
|
// push operator and next term
|
|
|
|
// special case conditional '?:'
|
|
if (JSToken.ConditionalIf == this.currentToken.token){
|
|
//Console.Out.WriteLine("Condition expression");
|
|
|
|
AST condition = termStack._term;
|
|
// pop term stack
|
|
termStack = termStack._prev;
|
|
|
|
GetNextToken();
|
|
|
|
// get expr1 in logOrExpr ? expr1 : expr2
|
|
AST operand1 = ParseExpression(true);
|
|
|
|
if (JSToken.Colon != this.currentToken.token)
|
|
ReportError(JSError.NoColon);
|
|
GetNextToken();
|
|
|
|
// get expr2 in logOrExpr ? expr1 : expr2
|
|
AST operand2 = ParseExpression(true, inToken);
|
|
|
|
expr = new Conditional(condition.context.CombineWith(operand2.context), condition, operand1, operand2);
|
|
termStack = new AstListItem(expr, termStack);
|
|
}else{
|
|
//Console.Out.WriteLine("higher prec or right assoc");
|
|
|
|
if (JSScanner.IsAssignmentOperator(this.currentToken.token)){
|
|
if (!bCanAssign){
|
|
ReportError(JSError.IllegalAssignment);
|
|
SkipTokensAndThrow();
|
|
}
|
|
}else
|
|
bCanAssign = false;
|
|
|
|
// push the operator onto the operators stack
|
|
opsStack = new OpListItem(this.currentToken.token, prec, opsStack);
|
|
// push new term
|
|
GetNextToken();
|
|
if (bCanAssign)
|
|
termStack = new AstListItem(ParseUnaryExpression(out bCanAssign, false), termStack);
|
|
else{
|
|
bool dummy;
|
|
termStack = new AstListItem(ParseUnaryExpression(out dummy, false), termStack);
|
|
dummy = dummy;
|
|
}
|
|
}
|
|
}else
|
|
break; // done, go and unwind the stack of expressions/operators
|
|
}
|
|
|
|
//Console.Out.WriteLine("unwinding stack");
|
|
// there are still operators to be processed
|
|
while (opsStack._operator != JSToken.None){
|
|
// make the ast operator node
|
|
expr = CreateExpressionNode(opsStack._operator, termStack._prev._term, termStack._term);
|
|
|
|
// pop the operator stack
|
|
opsStack = opsStack._prev;
|
|
// pop the term stack twice
|
|
termStack = termStack._prev._prev;
|
|
|
|
// push node onto the stack
|
|
termStack = new AstListItem(expr, termStack);
|
|
}
|
|
|
|
// if we have a ',' and we are not looking for a single expression reenter
|
|
if (!single && JSToken.Comma == this.currentToken.token){
|
|
//Console.Out.WriteLine("Next expr");
|
|
GetNextToken();
|
|
AST expr2 = ParseExpression(false, inToken);
|
|
termStack._term = new Comma(termStack._term.context.CombineWith(expr2.context), termStack._term, expr2);
|
|
}
|
|
|
|
Debug.Assert(termStack._prev == null);
|
|
return termStack._term;
|
|
}catch(RecoveryTokenException exc){
|
|
exc._partiallyComputedNode = leftHandSide;
|
|
throw exc;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseUnaryExpression
|
|
//
|
|
// UnaryExpression :
|
|
// PostfixExpression |
|
|
// 'delete' UnaryExpression |
|
|
// 'void' UnaryExpression |
|
|
// 'typeof' UnaryExpression |
|
|
// '++' UnaryExpression |
|
|
// '--' UnaryExpression |
|
|
// '+' UnaryExpression |
|
|
// '-' UnaryExpression |
|
|
// '~' UnaryExpression |
|
|
// '!' UnaryExpression
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
private AST ParseUnaryExpression(out bool isLeftHandSideExpr, bool isMinus){
|
|
bool canBeAttribute = false;
|
|
return ParseUnaryExpression(out isLeftHandSideExpr, ref canBeAttribute, isMinus, false);
|
|
}
|
|
|
|
private AST ParseUnaryExpression(out bool isLeftHandSideExpr, ref bool canBeAttribute, bool isMinus){
|
|
return ParseUnaryExpression(out isLeftHandSideExpr, ref canBeAttribute, isMinus, true);
|
|
}
|
|
|
|
private AST ParseUnaryExpression(out bool isLeftHandSideExpr, ref bool canBeAttribute, bool isMinus, bool warnForKeyword){
|
|
AST ast = null;
|
|
isLeftHandSideExpr = false;
|
|
bool dummy = false;
|
|
Context exprCtx = null;
|
|
AST expr = null;
|
|
switch (this.currentToken.token){
|
|
case JSToken.Void:
|
|
exprCtx = this.currentToken.Clone();
|
|
GetNextToken();
|
|
canBeAttribute = false;
|
|
expr = ParseUnaryExpression(out dummy, ref canBeAttribute, false);
|
|
exprCtx.UpdateWith(expr.context);
|
|
ast = new VoidOp(exprCtx, expr);
|
|
break;
|
|
case JSToken.Typeof:
|
|
exprCtx = this.currentToken.Clone();
|
|
GetNextToken();
|
|
canBeAttribute = false;
|
|
expr = ParseUnaryExpression(out dummy, ref canBeAttribute, false);
|
|
exprCtx.UpdateWith(expr.context);
|
|
ast = new Typeof(exprCtx, expr);
|
|
break;
|
|
case JSToken.Plus:
|
|
exprCtx = this.currentToken.Clone();
|
|
GetNextToken();
|
|
canBeAttribute = false;
|
|
expr = ParseUnaryExpression(out dummy, ref canBeAttribute, false);
|
|
exprCtx.UpdateWith(expr.context);
|
|
ast = new NumericUnary(exprCtx, expr, JSToken.Plus);
|
|
break;
|
|
case JSToken.Minus:
|
|
exprCtx = this.currentToken.Clone();
|
|
GetNextToken();
|
|
canBeAttribute = false;
|
|
expr = ParseUnaryExpression(out dummy, ref canBeAttribute, true);
|
|
// deal with '-floatNumber' being parsed as a single entity (NumericLiteral) and not as a -NumericLiteral
|
|
if (expr.context.token == JSToken.NumericLiteral){
|
|
exprCtx.UpdateWith(expr.context);
|
|
expr.context = exprCtx;
|
|
ast = expr;
|
|
}else{
|
|
exprCtx.UpdateWith(expr.context);
|
|
ast = new NumericUnary(exprCtx, expr, JSToken.Minus);
|
|
}
|
|
break;
|
|
case JSToken.BitwiseNot:
|
|
exprCtx = this.currentToken.Clone();
|
|
GetNextToken();
|
|
canBeAttribute = false;
|
|
expr = ParseUnaryExpression(out dummy, ref canBeAttribute, false);
|
|
exprCtx.UpdateWith(expr.context);
|
|
ast = new NumericUnary(exprCtx, expr, JSToken.BitwiseNot);
|
|
break;
|
|
case JSToken.LogicalNot:
|
|
exprCtx = this.currentToken.Clone();
|
|
GetNextToken();
|
|
canBeAttribute = false;
|
|
expr = ParseUnaryExpression(out dummy, ref canBeAttribute, false);
|
|
exprCtx.UpdateWith(expr.context);
|
|
ast = new NumericUnary(exprCtx, expr, JSToken.LogicalNot);
|
|
break;
|
|
case JSToken.Delete:
|
|
exprCtx = this.currentToken.Clone();
|
|
GetNextToken();
|
|
canBeAttribute = false;
|
|
expr = ParseUnaryExpression(out dummy, ref canBeAttribute, false);
|
|
exprCtx.UpdateWith(expr.context);
|
|
ast = new Delete(exprCtx, expr);
|
|
break;
|
|
case JSToken.Increment:
|
|
exprCtx = this.currentToken.Clone();
|
|
GetNextToken();
|
|
canBeAttribute = false;
|
|
expr = ParseUnaryExpression(out dummy, ref canBeAttribute, false);
|
|
exprCtx.UpdateWith(expr.context);
|
|
ast = new PostOrPrefixOperator(exprCtx, expr, PostOrPrefix.PrefixIncrement);
|
|
break;
|
|
case JSToken.Decrement:
|
|
exprCtx = this.currentToken.Clone();
|
|
GetNextToken();
|
|
canBeAttribute = false;
|
|
expr = ParseUnaryExpression(out dummy, ref canBeAttribute, false);
|
|
exprCtx.UpdateWith(expr.context);
|
|
ast = new PostOrPrefixOperator(exprCtx, expr, PostOrPrefix.PrefixDecrement);
|
|
break;
|
|
default:
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_PostfixExpressionNoSkipTokenSet);
|
|
try{
|
|
ast = ParseLeftHandSideExpression(isMinus, ref canBeAttribute, warnForKeyword);
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_PostfixExpressionNoSkipTokenSet, exc) == -1){
|
|
throw exc;
|
|
}else{
|
|
if (exc._partiallyComputedNode == null)
|
|
SkipTokensAndThrow();
|
|
else
|
|
ast = exc._partiallyComputedNode;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_PostfixExpressionNoSkipTokenSet);
|
|
}
|
|
ast = ParsePostfixExpression(ast, out isLeftHandSideExpr, ref canBeAttribute);
|
|
break;
|
|
}
|
|
dummy = dummy;
|
|
|
|
return ast;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParsePostfixExpression
|
|
//
|
|
// PostfixExpression:
|
|
// LeftHandSideExpression |
|
|
// LeftHandSideExpression '++' |
|
|
// LeftHandSideExpression '--'
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
private AST ParsePostfixExpression(AST ast, out bool isLeftHandSideExpr){
|
|
bool canBeAttribute = false;
|
|
return ParsePostfixExpression(ast, out isLeftHandSideExpr, ref canBeAttribute);
|
|
}
|
|
|
|
private AST ParsePostfixExpression(AST ast, out bool isLeftHandSideExpr, ref bool canBeAttribute){
|
|
isLeftHandSideExpr = true;
|
|
Context exprCtx = null;
|
|
if (null != ast){
|
|
if (!this.scanner.GotEndOfLine()){
|
|
if (JSToken.Increment == this.currentToken.token){
|
|
isLeftHandSideExpr = false;
|
|
exprCtx = ast.context.Clone();
|
|
exprCtx.UpdateWith(this.currentToken);
|
|
canBeAttribute = false;
|
|
ast = new PostOrPrefixOperator(exprCtx, ast, PostOrPrefix.PostfixIncrement);
|
|
GetNextToken();
|
|
}else if (JSToken.Decrement == this.currentToken.token){
|
|
isLeftHandSideExpr = false;
|
|
exprCtx = ast.context.Clone();
|
|
exprCtx.UpdateWith(this.currentToken);
|
|
canBeAttribute = false;
|
|
ast = new PostOrPrefixOperator(exprCtx, ast, PostOrPrefix.PostfixDecrement);
|
|
GetNextToken();
|
|
}
|
|
}
|
|
}
|
|
return ast;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseLeftHandSideExpression
|
|
//
|
|
// LeftHandSideExpression :
|
|
// PrimaryExpression Accessor |
|
|
// 'new' LeftHandSideExpression |
|
|
// FunctionExpression
|
|
//
|
|
// PrimaryExpression :
|
|
// 'this' |
|
|
// Identifier |
|
|
// Literal |
|
|
// '(' Expression ')'
|
|
//
|
|
// FunctionExpression :
|
|
// 'function' OptionalFuncName '(' FormalParameterList ')' { FunctionBody }
|
|
//
|
|
// OptionalFuncName :
|
|
// <empty> |
|
|
// Identifier
|
|
//---------------------------------------------------------------------------------------
|
|
private AST ParseLeftHandSideExpression(){
|
|
return ParseLeftHandSideExpression(false);
|
|
}
|
|
|
|
private AST ParseLeftHandSideExpression(bool isMinus){
|
|
bool canBeAttribute = false;
|
|
return ParseLeftHandSideExpression(isMinus, ref canBeAttribute, false);
|
|
}
|
|
|
|
private AST ParseLeftHandSideExpression(bool isMinus, ref bool canBeAttribute, bool warnForKeyword){
|
|
AST ast = null;
|
|
bool isFunction = false;
|
|
ArrayList newContexts = null;
|
|
|
|
// new expression
|
|
while (JSToken.New == this.currentToken.token){
|
|
if (null == newContexts)
|
|
newContexts = new ArrayList(4);
|
|
newContexts.Add(this.currentToken.Clone());
|
|
GetNextToken();
|
|
}
|
|
|
|
JSToken token = this.currentToken.token;
|
|
switch (token){
|
|
// primary expression
|
|
case JSToken.Identifier:
|
|
ast = new Lookup(this.scanner.GetIdentifier(), this.currentToken.Clone());
|
|
break;
|
|
|
|
case JSToken.This:
|
|
canBeAttribute = false;
|
|
ast = new ThisLiteral(this.currentToken.Clone(), false);
|
|
break;
|
|
|
|
case JSToken.Super:
|
|
canBeAttribute = false;
|
|
ast = new ThisLiteral(this.currentToken.Clone(), true);
|
|
break;
|
|
|
|
case JSToken.StringLiteral:
|
|
canBeAttribute = false;
|
|
ast = new ConstantWrapper(this.scanner.GetStringLiteral(), this.currentToken.Clone());
|
|
break;
|
|
|
|
case JSToken.IntegerLiteral:
|
|
{canBeAttribute = false;
|
|
String number = this.currentToken.GetCode();
|
|
Object n = Convert.LiteralToNumber(number, this.currentToken);
|
|
if (n == null)
|
|
n = 0;
|
|
ast = new ConstantWrapper(n, this.currentToken.Clone());
|
|
((ConstantWrapper)ast).isNumericLiteral = true;
|
|
break;}
|
|
|
|
case JSToken.NumericLiteral:
|
|
{canBeAttribute = false;
|
|
String number = (isMinus) ? "-" + this.currentToken.GetCode() : this.currentToken.GetCode();
|
|
double d = Convert.ToNumber(number, false, false, Missing.Value);
|
|
ast = new ConstantWrapper(d, this.currentToken.Clone());
|
|
((ConstantWrapper)ast).isNumericLiteral = true;
|
|
break;}
|
|
|
|
case JSToken.True:
|
|
canBeAttribute = false;
|
|
ast = new ConstantWrapper(true, this.currentToken.Clone());
|
|
break;
|
|
|
|
case JSToken.False:
|
|
canBeAttribute = false;
|
|
ast = new ConstantWrapper(false, this.currentToken.Clone());
|
|
break;
|
|
|
|
case JSToken.Null:
|
|
canBeAttribute = false;
|
|
ast = new NullLiteral(this.currentToken.Clone());
|
|
break;
|
|
|
|
case JSToken.PreProcessorConstant:
|
|
canBeAttribute = false;
|
|
ast = new ConstantWrapper(this.scanner.GetPreProcessorValue(), this.currentToken.Clone());
|
|
break;
|
|
|
|
case JSToken.Divide:
|
|
canBeAttribute = false;
|
|
// could it be a regexp?
|
|
String source = this.scanner.ScanRegExp();
|
|
if (source != null){
|
|
bool badRegExp = false;
|
|
try {
|
|
new Regex(source, RegexOptions.ECMAScript);
|
|
} catch (System.ArgumentException) {
|
|
// Replace the invalid source with the trivial regular expression.
|
|
source = "";
|
|
badRegExp = true;
|
|
}
|
|
String flags = this.scanner.ScanRegExpFlags();
|
|
if (flags == null)
|
|
ast = new RegExpLiteral(source, null, this.currentToken.Clone());
|
|
else
|
|
try{
|
|
ast = new RegExpLiteral(source, flags, this.currentToken.Clone());
|
|
}catch (JScriptException){
|
|
// The flags are invalid, so use null instead.
|
|
ast = new RegExpLiteral(source, null, this.currentToken.Clone());
|
|
badRegExp = true;
|
|
}
|
|
if (badRegExp){
|
|
ReportError(JSError.RegExpSyntax, true);
|
|
}
|
|
break;
|
|
}
|
|
goto default;
|
|
|
|
// expression
|
|
case JSToken.LeftParen:
|
|
canBeAttribute = false;
|
|
GetNextToken();
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_ParenExpressionNoSkipToken);
|
|
try{
|
|
ast = ParseExpression();
|
|
if (JSToken.RightParen != this.currentToken.token)
|
|
ReportError(JSError.NoRightParen);
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_ParenExpressionNoSkipToken, exc) == -1)
|
|
throw exc;
|
|
else
|
|
ast = exc._partiallyComputedNode;
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_ParenExpressionNoSkipToken);
|
|
}
|
|
if (ast == null) //this can only happen when catching the exception and nothing was sent up by the caller
|
|
SkipTokensAndThrow();
|
|
break;
|
|
|
|
// array initializer
|
|
case JSToken.LeftBracket:
|
|
canBeAttribute = false;
|
|
Context listCtx = this.currentToken.Clone();
|
|
ASTList list = new ASTList(this.currentToken.Clone());
|
|
GetNextToken();
|
|
if (this.currentToken.token == JSToken.Identifier && this.scanner.PeekToken() == JSToken.Colon){
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_BracketToken);
|
|
try{
|
|
if (this.currentToken.GetCode() == "assembly"){
|
|
GetNextToken(); GetNextToken();
|
|
return new AssemblyCustomAttributeList(this.ParseCustomAttributeList());
|
|
}else{
|
|
ReportError(JSError.ExpectedAssembly);
|
|
SkipTokensAndThrow();
|
|
}
|
|
}catch(RecoveryTokenException exc){
|
|
exc._partiallyComputedNode = new Block(listCtx);
|
|
return exc._partiallyComputedNode;
|
|
}finally{
|
|
if (this.currentToken.token == JSToken.RightBracket){
|
|
this.errorToken = null;
|
|
GetNextToken();
|
|
}
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_BracketToken);
|
|
}
|
|
}
|
|
while (JSToken.RightBracket != this.currentToken.token){
|
|
if (JSToken.Comma != this.currentToken.token){
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_ArrayInitNoSkipTokenSet);
|
|
try{
|
|
list.Append(ParseExpression(true));
|
|
if (JSToken.Comma != this.currentToken.token){
|
|
if (JSToken.RightBracket != this.currentToken.token)
|
|
ReportError(JSError.NoRightBracket);
|
|
break;
|
|
}
|
|
}catch(RecoveryTokenException exc){
|
|
if (exc._partiallyComputedNode != null)
|
|
list.Append(exc._partiallyComputedNode);
|
|
if (IndexOfToken(NoSkipTokenSet.s_ArrayInitNoSkipTokenSet, exc) == -1){
|
|
listCtx.UpdateWith(CurrentPositionContext());
|
|
exc._partiallyComputedNode = new ArrayLiteral(listCtx, list);
|
|
throw exc;
|
|
}else{
|
|
if (JSToken.RightBracket == this.currentToken.token)
|
|
break;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_ArrayInitNoSkipTokenSet);
|
|
}
|
|
}else{
|
|
list.Append(new ConstantWrapper(Missing.Value, this.currentToken.Clone()));
|
|
}
|
|
GetNextToken();
|
|
}
|
|
listCtx.UpdateWith(this.currentToken);
|
|
ast = new ArrayLiteral(listCtx, list);
|
|
break;
|
|
|
|
// object initializer
|
|
case JSToken.LeftCurly:
|
|
canBeAttribute = false;
|
|
Context objCtx = this.currentToken.Clone();
|
|
GetNextToken();
|
|
ASTList fields = new ASTList(this.currentToken.Clone());
|
|
if (JSToken.RightCurly != this.currentToken.token){
|
|
for (;;){
|
|
AST field = null;
|
|
AST value = null;
|
|
|
|
if (JSToken.Identifier == this.currentToken.token)
|
|
field = new ConstantWrapper(this.scanner.GetIdentifier(), this.currentToken.Clone());
|
|
else if (JSToken.StringLiteral == this.currentToken.token)
|
|
field = new ConstantWrapper(this.scanner.GetStringLiteral(), this.currentToken.Clone());
|
|
else if (JSToken.IntegerLiteral == this.currentToken.token || JSToken.NumericLiteral == this.currentToken.token ){
|
|
String numberString = this.currentToken.GetCode();
|
|
double dValue = Convert.ToNumber(numberString, true, true, Missing.Value);
|
|
field = new ConstantWrapper(dValue, this.currentToken.Clone());
|
|
((ConstantWrapper)field).isNumericLiteral = true;
|
|
}else{
|
|
ReportError(JSError.NoMemberIdentifier);
|
|
field = new IdentifierLiteral("_#Missing_Field#_" + s_cDummyName++, CurrentPositionContext());
|
|
}
|
|
ASTList pair = new ASTList(field.context.Clone());
|
|
GetNextToken();
|
|
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_ObjectInitNoSkipTokenSet);
|
|
try{
|
|
// get the value
|
|
if (JSToken.Colon != this.currentToken.token){
|
|
ReportError(JSError.NoColon, true);
|
|
value = ParseExpression(true);
|
|
}else{
|
|
GetNextToken();
|
|
value = ParseExpression(true);
|
|
}
|
|
|
|
// put the pair into the list of fields
|
|
pair.Append(field);
|
|
pair.Append(value);
|
|
fields.Append(pair);
|
|
|
|
if (JSToken.RightCurly == this.currentToken.token)
|
|
break;
|
|
else{
|
|
if (JSToken.Comma == this.currentToken.token)
|
|
GetNextToken();
|
|
else{
|
|
if (this.scanner.GotEndOfLine()){
|
|
ReportError(JSError.NoRightCurly);
|
|
}else
|
|
ReportError(JSError.NoComma, true);
|
|
SkipTokensAndThrow();
|
|
}
|
|
}
|
|
}catch(RecoveryTokenException exc){
|
|
if (exc._partiallyComputedNode != null){
|
|
// the problem was in ParseExpression trying to determine value
|
|
value = exc._partiallyComputedNode;
|
|
pair.Append(field);
|
|
pair.Append(value);
|
|
fields.Append(pair);
|
|
}
|
|
if (IndexOfToken(NoSkipTokenSet.s_ObjectInitNoSkipTokenSet, exc) == -1){
|
|
exc._partiallyComputedNode = new ObjectLiteral(objCtx, fields);
|
|
throw exc;
|
|
}else{
|
|
if (JSToken.Comma == this.currentToken.token)
|
|
GetNextToken();
|
|
if (JSToken.RightCurly == this.currentToken.token)
|
|
break;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_ObjectInitNoSkipTokenSet);
|
|
}
|
|
}
|
|
}
|
|
fields.context.UpdateWith(this.currentToken);
|
|
objCtx.UpdateWith(this.currentToken);
|
|
ast = new ObjectLiteral(objCtx, fields);
|
|
break;
|
|
|
|
// function expression
|
|
case JSToken.Function:
|
|
canBeAttribute = false;
|
|
ast = ParseFunction((FieldAttributes)0, true, this.currentToken.Clone(), false, false, false, false, null);
|
|
isFunction = true;
|
|
break;
|
|
|
|
default:
|
|
string identifier = JSKeyword.CanBeIdentifier(this.currentToken.token);
|
|
if (null != identifier){
|
|
if (warnForKeyword){
|
|
switch (this.currentToken.token){
|
|
case JSToken.Boolean :
|
|
case JSToken.Byte :
|
|
case JSToken.Char :
|
|
case JSToken.Double :
|
|
case JSToken.Float :
|
|
case JSToken.Int :
|
|
case JSToken.Long :
|
|
case JSToken.Short :
|
|
case JSToken.Void :
|
|
break;
|
|
default:
|
|
ForceReportInfo(JSError.KeywordUsedAsIdentifier);
|
|
break;
|
|
}
|
|
}
|
|
canBeAttribute = false;
|
|
ast = new Lookup(identifier, this.currentToken.Clone());
|
|
}else if (this.currentToken.token == JSToken.BitwiseAnd){ //& expr used outside of a parameter list
|
|
ReportError(JSError.WrongUseOfAddressOf);
|
|
this.errorToken = null;
|
|
GetNextToken();
|
|
return this.ParseLeftHandSideExpression(isMinus, ref canBeAttribute, warnForKeyword);
|
|
}else{
|
|
ReportError(JSError.ExpressionExpected);
|
|
SkipTokensAndThrow();
|
|
}
|
|
break;
|
|
}
|
|
|
|
// can be a CallExpression, that is, followed by '.' or '(' or '['
|
|
if (!isFunction)
|
|
GetNextToken();
|
|
|
|
return MemberExpression(ast, newContexts, ref canBeAttribute);
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
// ParseConstructorCall
|
|
//
|
|
// ConstructorCall :
|
|
// 'this' Arguments
|
|
// 'super' Arguments
|
|
//--------------------------------------------------------------------------------------------
|
|
private AST ParseConstructorCall(Context superCtx){
|
|
bool isSuperConstructorCall = JSToken.Super == this.currentToken.token;
|
|
GetNextToken();
|
|
Context listCtx = this.currentToken.Clone();
|
|
ASTList args = new ASTList(listCtx);
|
|
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet);
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_ParenToken);
|
|
try{
|
|
args = ParseExpressionList(JSToken.RightParen);
|
|
GetNextToken(); //Skip the )
|
|
}catch(RecoveryTokenException exc){
|
|
if (exc._partiallyComputedNode != null)
|
|
args = (ASTList)exc._partiallyComputedNode;
|
|
if (IndexOfToken(NoSkipTokenSet.s_ParenToken, exc) == -1
|
|
&& IndexOfToken(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet, exc) == -1){
|
|
exc._partiallyComputedNode = new ConstructorCall(superCtx, args, isSuperConstructorCall);
|
|
throw exc;
|
|
}else{
|
|
if (exc._token == JSToken.RightParen)
|
|
GetNextToken();
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_ParenToken);
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet);
|
|
}
|
|
|
|
superCtx.UpdateWith(listCtx);
|
|
return new ConstructorCall(superCtx, args, isSuperConstructorCall);
|
|
}
|
|
|
|
private CustomAttributeList ParseCustomAttributeList(){
|
|
CustomAttributeList result = new CustomAttributeList(this.currentToken.Clone());
|
|
do{
|
|
Context attrStart = currentToken.Clone();
|
|
bool bAssign, canBeAttribute = true;
|
|
AST statement = ParseUnaryExpression(out bAssign, ref canBeAttribute, false, false);
|
|
if (canBeAttribute){
|
|
if (statement is Lookup || statement is Member)
|
|
result.Append(new CustomAttribute(statement.context, statement, new ASTList(null)));
|
|
else
|
|
result.Append(((Call)statement).ToCustomAttribute());
|
|
}else if (this.tokensSkipped == 0)
|
|
ReportError(JSError.SyntaxError, attrStart);
|
|
if (this.currentToken.token == JSToken.RightBracket)
|
|
return result;
|
|
else if (this.currentToken.token == JSToken.Comma)
|
|
this.GetNextToken();
|
|
else{
|
|
ReportError(JSError.NoRightBracketOrComma);
|
|
SkipTokensAndThrow();
|
|
}
|
|
}while(true);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// MemberExpression
|
|
//
|
|
// Accessor :
|
|
// <empty> |
|
|
// Arguments Accessor
|
|
// '[' Expression ']' Accessor |
|
|
// '.' Identifier Accessor |
|
|
//
|
|
// Don't have this function throwing an exception without checking all the calling sites.
|
|
// There is state in instance variable that is saved on the calling stack in some function
|
|
// (i.e ParseFunction and ParseClass) and you don't want to blow up the stack
|
|
//---------------------------------------------------------------------------------------
|
|
private AST MemberExpression(AST expression, ArrayList newContexts){
|
|
bool canBeAttribute = false;
|
|
return MemberExpression(expression, newContexts, ref canBeAttribute);
|
|
}
|
|
|
|
private AST MemberExpression(AST expression, ArrayList newContexts, ref bool canBeAttribute){
|
|
bool canBeQualid;
|
|
return MemberExpression(expression, newContexts, out canBeQualid, ref canBeAttribute);
|
|
}
|
|
|
|
private AST MemberExpression(AST expression, ArrayList newContexts, out bool canBeQualid, ref bool canBeAttribute){
|
|
bool noMoreForAttr = false;
|
|
canBeQualid = true;
|
|
for(;;){
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_MemberExprNoSkipTokenSet);
|
|
try{
|
|
switch (this.currentToken.token){
|
|
case JSToken.LeftParen:
|
|
if (noMoreForAttr)
|
|
canBeAttribute = false;
|
|
else
|
|
noMoreForAttr = true;
|
|
canBeQualid = false;
|
|
|
|
ASTList args = null;
|
|
RecoveryTokenException callError = null;
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_ParenToken);
|
|
try{
|
|
args = ParseExpressionList(JSToken.RightParen);
|
|
}catch(RecoveryTokenException exc){
|
|
args = (ASTList)exc._partiallyComputedNode;
|
|
if (IndexOfToken(NoSkipTokenSet.s_ParenToken, exc) == -1)
|
|
callError = exc; // thrown later on
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_ParenToken);
|
|
}
|
|
|
|
//treat eval and print specially
|
|
if (expression is Lookup){
|
|
String name = expression.ToString();
|
|
if (name.Equals("eval")){
|
|
expression.context.UpdateWith(args.context);
|
|
if (args.count > 0)
|
|
expression = new Eval(expression.context, args[0]);
|
|
else
|
|
expression = new Eval(expression.context, new ConstantWrapper("", CurrentPositionContext()));
|
|
}else if (this.Globals.engine.doPrint && name.Equals("print")){
|
|
expression.context.UpdateWith(args.context);
|
|
expression = new Print(expression.context, args);
|
|
}else{
|
|
if (name == "GetObject")
|
|
this.ForceReportInfo(JSError.GetObjectNotSupportedOnRotor);
|
|
expression = new Call(expression.context.CombineWith(args.context), expression, args, false);
|
|
}
|
|
}else
|
|
expression = new Call(expression.context.CombineWith(args.context), expression, args, false);
|
|
|
|
if (null != newContexts && newContexts.Count > 0){
|
|
((Context)newContexts[newContexts.Count - 1]).UpdateWith(expression.context);
|
|
if (!(expression is Call))
|
|
expression = new Call((Context)newContexts[newContexts.Count - 1], expression, new ASTList(CurrentPositionContext()), false);
|
|
else
|
|
expression.context = (Context)newContexts[newContexts.Count - 1];
|
|
((Call)expression).isConstructor = true;
|
|
newContexts.RemoveAt(newContexts.Count - 1);
|
|
}
|
|
|
|
if (callError != null){
|
|
callError._partiallyComputedNode = expression;
|
|
throw callError;
|
|
}
|
|
|
|
GetNextToken();
|
|
break;
|
|
|
|
case JSToken.LeftBracket:
|
|
canBeQualid = false;
|
|
canBeAttribute = false;
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_BracketToken);
|
|
try{
|
|
args = ParseExpressionList(JSToken.RightBracket);
|
|
}catch(RecoveryTokenException exc){
|
|
if(IndexOfToken(NoSkipTokenSet.s_BracketToken, exc) == -1){
|
|
if (exc._partiallyComputedNode != null){
|
|
exc._partiallyComputedNode =
|
|
new Call(expression.context.CombineWith(this.currentToken.Clone()), expression, (ASTList)exc._partiallyComputedNode, true);
|
|
}else{
|
|
exc._partiallyComputedNode = expression;
|
|
}
|
|
throw exc;
|
|
}else
|
|
args = (ASTList)exc._partiallyComputedNode;
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_BracketToken);
|
|
}
|
|
expression = new Call(expression.context.CombineWith(this.currentToken.Clone()), expression, args, true);
|
|
|
|
if (null != newContexts && newContexts.Count > 0){
|
|
((Context)newContexts[newContexts.Count - 1]).UpdateWith(expression.context);
|
|
expression.context = (Context)newContexts[newContexts.Count - 1];
|
|
((Call)expression).isConstructor = true;
|
|
newContexts.RemoveAt(newContexts.Count - 1);
|
|
}
|
|
GetNextToken();
|
|
break;
|
|
|
|
case JSToken.AccessField:
|
|
if (noMoreForAttr)
|
|
canBeAttribute = false;
|
|
ConstantWrapper id = null;
|
|
GetNextToken();
|
|
if (JSToken.Identifier != this.currentToken.token){
|
|
string identifier = JSKeyword.CanBeIdentifier(this.currentToken.token);
|
|
if (null != identifier){
|
|
ForceReportInfo(JSError.KeywordUsedAsIdentifier);
|
|
id = new ConstantWrapper(identifier, this.currentToken.Clone());
|
|
}else{
|
|
ReportError(JSError.NoIdentifier);
|
|
SkipTokensAndThrow(expression);
|
|
}
|
|
}else
|
|
id = new ConstantWrapper(this.scanner.GetIdentifier(), this.currentToken.Clone());
|
|
GetNextToken();
|
|
expression = new Member(expression.context.CombineWith(id.context), expression, id);
|
|
break;
|
|
default:
|
|
if (null != newContexts){
|
|
while (newContexts.Count > 0){
|
|
((Context)newContexts[newContexts.Count - 1]).UpdateWith(expression.context);
|
|
expression = new Call((Context)newContexts[newContexts.Count - 1],
|
|
expression,
|
|
new ASTList(CurrentPositionContext()),
|
|
false);
|
|
((Call)expression).isConstructor = true;
|
|
newContexts.RemoveAt(newContexts.Count - 1);
|
|
}
|
|
}
|
|
return expression;
|
|
}
|
|
}catch(RecoveryTokenException exc){
|
|
if (IndexOfToken(NoSkipTokenSet.s_MemberExprNoSkipTokenSet, exc) != -1)
|
|
expression = exc._partiallyComputedNode;
|
|
else{
|
|
Debug.Assert(exc._partiallyComputedNode == expression);
|
|
throw exc;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_MemberExprNoSkipTokenSet);
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ParseExpressionList
|
|
//
|
|
// Given a starting this.currentToken '(' or '[', parse a list of expression separated by
|
|
// ',' until matching ')' or ']'
|
|
//---------------------------------------------------------------------------------------
|
|
private ASTList ParseExpressionList(JSToken terminator){
|
|
Context listCtx = this.currentToken.Clone();
|
|
int line = this.scanner.GetCurrentLine();
|
|
GetNextToken();
|
|
ASTList list = new ASTList(listCtx);
|
|
if (terminator != this.currentToken.token){
|
|
for (;;){
|
|
this.noSkipTokenSet.Add(NoSkipTokenSet.s_ExpressionListNoSkipTokenSet);
|
|
try{
|
|
if (JSToken.BitwiseAnd == this.currentToken.token){ // address of operator
|
|
Context addressOfCtx = this.currentToken.Clone();
|
|
GetNextToken();
|
|
AST lhexpr = ParseLeftHandSideExpression();
|
|
if (lhexpr is Member || lhexpr is Lookup){
|
|
addressOfCtx.UpdateWith(lhexpr.context);
|
|
list.Append(new AddressOf(addressOfCtx, lhexpr));
|
|
}else{
|
|
ReportError(JSError.DoesNotHaveAnAddress, addressOfCtx.Clone());
|
|
list.Append(lhexpr);
|
|
}
|
|
}else if (JSToken.Comma == this.currentToken.token){
|
|
list.Append(new ConstantWrapper(System.Reflection.Missing.Value, this.currentToken.Clone()));
|
|
}else if (terminator == this.currentToken.token){
|
|
break;
|
|
}else
|
|
list.Append(ParseExpression(true));
|
|
|
|
if (terminator == this.currentToken.token)
|
|
break;
|
|
else{
|
|
if (JSToken.Comma != this.currentToken.token){
|
|
if (terminator == JSToken.RightParen){
|
|
// in ASP+ it's easy to write a semicolon at the end of an expression
|
|
// not realizing it is going to go inside a function call
|
|
// (ie. Response.Write()), so make a special check here
|
|
if (JSToken.Semicolon == this.currentToken.token){
|
|
if (JSToken.RightParen == this.scanner.PeekToken()){
|
|
ReportError(JSError.UnexpectedSemicolon, true);
|
|
GetNextToken();
|
|
break;
|
|
}
|
|
}
|
|
ReportError(JSError.NoRightParenOrComma);
|
|
}else
|
|
ReportError(JSError.NoRightBracketOrComma);
|
|
SkipTokensAndThrow();
|
|
}
|
|
}
|
|
}catch(RecoveryTokenException exc){
|
|
if (exc._partiallyComputedNode != null)
|
|
list.Append(exc._partiallyComputedNode);
|
|
if (IndexOfToken(NoSkipTokenSet.s_ExpressionListNoSkipTokenSet, exc) == -1){
|
|
exc._partiallyComputedNode = list;
|
|
throw exc;
|
|
}
|
|
}finally{
|
|
this.noSkipTokenSet.Remove(NoSkipTokenSet.s_ExpressionListNoSkipTokenSet);
|
|
}
|
|
GetNextToken();
|
|
}
|
|
}
|
|
listCtx.UpdateWith(this.currentToken);
|
|
return list;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// CreateExpressionNode
|
|
//
|
|
// Create the proper AST object according to operator
|
|
//---------------------------------------------------------------------------------------
|
|
private AST CreateExpressionNode(JSToken op, AST operand1, AST operand2){
|
|
Context context = operand1.context.CombineWith(operand2.context);
|
|
switch (op){
|
|
case JSToken.Assign:
|
|
return new Assign(context, operand1, operand2);
|
|
case JSToken.BitwiseAnd:
|
|
return new BitwiseBinary(context, operand1, operand2, JSToken.BitwiseAnd);
|
|
case JSToken.BitwiseAndAssign:
|
|
return new BitwiseBinaryAssign(context, operand1, operand2, JSToken.BitwiseAnd);
|
|
case JSToken.BitwiseOr:
|
|
return new BitwiseBinary(context, operand1, operand2, JSToken.BitwiseOr);
|
|
case JSToken.BitwiseOrAssign:
|
|
return new BitwiseBinaryAssign(context, operand1, operand2, JSToken.BitwiseOr);
|
|
case JSToken.BitwiseXor:
|
|
return new BitwiseBinary(context, operand1, operand2, JSToken.BitwiseXor);
|
|
case JSToken.BitwiseXorAssign:
|
|
return new BitwiseBinaryAssign(context, operand1, operand2, JSToken.BitwiseXor);
|
|
case JSToken.Comma:
|
|
return new Comma(context, operand1, operand2);
|
|
case JSToken.Divide:
|
|
return new NumericBinary(context, operand1, operand2, JSToken.Divide);
|
|
case JSToken.DivideAssign:
|
|
return new NumericBinaryAssign(context, operand1, operand2, JSToken.Divide);
|
|
case JSToken.Equal:
|
|
return new Equality(context, operand1, operand2, JSToken.Equal);
|
|
case JSToken.GreaterThan:
|
|
return new Relational(context, operand1, operand2, JSToken.GreaterThan);
|
|
case JSToken.GreaterThanEqual:
|
|
return new Relational(context, operand1, operand2, JSToken.GreaterThanEqual);
|
|
case JSToken.In:
|
|
return new In(context, operand1, operand2);
|
|
case JSToken.Instanceof:
|
|
return new Instanceof(context, operand1, operand2);
|
|
case JSToken.LeftShift:
|
|
return new BitwiseBinary(context, operand1, operand2, JSToken.LeftShift);
|
|
case JSToken.LeftShiftAssign:
|
|
return new BitwiseBinaryAssign(context, operand1, operand2, JSToken.LeftShift);
|
|
case JSToken.LessThan:
|
|
return new Relational(context, operand1, operand2, JSToken.LessThan);
|
|
case JSToken.LessThanEqual:
|
|
return new Relational(context, operand1, operand2, JSToken.LessThanEqual);
|
|
case JSToken.LogicalAnd:
|
|
return new Logical_and(context, operand1, operand2);
|
|
case JSToken.LogicalOr:
|
|
return new Logical_or(context, operand1, operand2);
|
|
case JSToken.Minus:
|
|
return new NumericBinary(context, operand1, operand2, JSToken.Minus);
|
|
case JSToken.MinusAssign:
|
|
return new NumericBinaryAssign(context, operand1, operand2, JSToken.Minus);
|
|
case JSToken.Modulo:
|
|
return new NumericBinary(context, operand1, operand2, JSToken.Modulo);
|
|
case JSToken.ModuloAssign:
|
|
return new NumericBinaryAssign(context, operand1, operand2, JSToken.Modulo);
|
|
case JSToken.Multiply:
|
|
return new NumericBinary(context, operand1, operand2, JSToken.Multiply);
|
|
case JSToken.MultiplyAssign:
|
|
return new NumericBinaryAssign(context, operand1, operand2, JSToken.Multiply);
|
|
case JSToken.NotEqual:
|
|
return new Equality(context, operand1, operand2, JSToken.NotEqual);
|
|
case JSToken.Plus:
|
|
return new Plus(context, operand1, operand2);
|
|
case JSToken.PlusAssign:
|
|
return new PlusAssign(context, operand1, operand2);
|
|
case JSToken.RightShift:
|
|
return new BitwiseBinary(context, operand1, operand2, JSToken.RightShift);
|
|
case JSToken.RightShiftAssign:
|
|
return new BitwiseBinaryAssign(context, operand1, operand2, JSToken.RightShift);
|
|
case JSToken.StrictEqual:
|
|
return new StrictEquality(context, operand1, operand2, JSToken.StrictEqual);
|
|
case JSToken.StrictNotEqual:
|
|
return new StrictEquality(context, operand1, operand2, JSToken.StrictNotEqual);
|
|
case JSToken.UnsignedRightShift:
|
|
return new BitwiseBinary(context, operand1, operand2, JSToken.UnsignedRightShift);
|
|
case JSToken.UnsignedRightShiftAssign:
|
|
return new BitwiseBinaryAssign(context, operand1, operand2, JSToken.UnsignedRightShift);
|
|
default:
|
|
Debug.Assert(false);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// GetNextToken
|
|
//
|
|
// Return the next token or peeked token if this.errorToken is not null.
|
|
// Usually this.errorToken is set by AddError even though any code can look ahead
|
|
// by assigning this.errorToken.
|
|
// At this point the context is not saved so if position information is needed
|
|
// they have to be saved explicitely
|
|
//---------------------------------------------------------------------------------------
|
|
private void GetNextToken(){
|
|
if (null != this.errorToken){
|
|
if (this.breakRecursion > 10){
|
|
#if DEBUG
|
|
JSParser.WriteToFile(this.errorToken);
|
|
#endif
|
|
this.errorToken = null;
|
|
this.scanner.GetNextToken();
|
|
return;
|
|
}
|
|
this.breakRecursion++;
|
|
this.currentToken = this.errorToken;
|
|
this.errorToken = null;
|
|
}else{
|
|
this.goodTokensProcessed++;
|
|
this.breakRecursion = 0;
|
|
// the scanner shares this.currentToken with the parser
|
|
this.scanner.GetNextToken();
|
|
}
|
|
}
|
|
|
|
#if DEBUG
|
|
private static void WriteToFile(Context context){
|
|
String filename = "error_" + (s_filenameSuffix++).ToString() + ".js";
|
|
ScriptStream.WriteLine("possible infinite recursion in parser recovery code...");
|
|
ScriptStream.WriteLine("Please send the file " + filename + " to hermanv");
|
|
|
|
System.IO.TextWriter stream = new System.IO.StreamWriter(System.IO.File.Create(filename));
|
|
String code = context.source_string.Substring(0, context.EndPosition);
|
|
stream.Write(code.ToCharArray());
|
|
stream.Flush();
|
|
stream.Close();
|
|
}
|
|
#endif
|
|
|
|
private Context CurrentPositionContext(){
|
|
Context context = this.currentToken.Clone();
|
|
context.endPos = (context.startPos < context.source_string.Length) ? context.startPos + 1 : context.startPos;
|
|
return context;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ReportError
|
|
//
|
|
// Generate a parser error.
|
|
// When no context is provided the token is missing so the context is the current position
|
|
//---------------------------------------------------------------------------------------
|
|
private void ReportError(JSError errorId){
|
|
ReportError(errorId, false);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ReportError
|
|
//
|
|
// Generate a parser error.
|
|
// When no context is provided the token is missing so the context is the current position
|
|
// The function is told whether or not next call to GetToken() should return the same
|
|
// token or not
|
|
//---------------------------------------------------------------------------------------
|
|
private void ReportError(JSError errorId, bool skipToken){
|
|
// get the current position token
|
|
Context context = this.currentToken.Clone();
|
|
context.endPos = context.startPos + 1;
|
|
ReportError(errorId, context, skipToken);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ReportError
|
|
//
|
|
// Generate a parser error.
|
|
// This is usually generated when a bad token is found, the context identifies the
|
|
// bad token
|
|
//---------------------------------------------------------------------------------------
|
|
private void ReportError(JSError errorId, Context context){
|
|
ReportError(errorId, context, false);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ReportError
|
|
//
|
|
// Generate a parser error.
|
|
// The function is told whether or not next call to GetToken() should return the same
|
|
// token or not
|
|
//---------------------------------------------------------------------------------------
|
|
private void ReportError(JSError errorId, Context context, bool skipToken){
|
|
Debug.Assert(context != null);
|
|
int previousSeverity = this.Severity;
|
|
this.Severity = (new JScriptException(errorId)).Severity;
|
|
// EOF error is special and it's the last error we can possibly get
|
|
if (JSToken.EndOfFile == context.token)
|
|
EOFError(errorId); // EOF context is special
|
|
else{
|
|
// report the error if not in error condition and the
|
|
// error for this token is not worse than the one for the
|
|
// previous token
|
|
if (this.goodTokensProcessed > 0 || this.Severity < previousSeverity)
|
|
context.HandleError(errorId);
|
|
|
|
// reset proper info
|
|
if (skipToken)
|
|
this.goodTokensProcessed = -1;
|
|
else{
|
|
this.errorToken = this.currentToken;
|
|
this.goodTokensProcessed = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ForceReportInfo
|
|
//
|
|
// Generate a parser error (info), does not change the error state in the parse
|
|
//---------------------------------------------------------------------------------------
|
|
private void ForceReportInfo(JSError errorId){
|
|
ForceReportInfo(this.currentToken.Clone(), errorId);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ForceReportInfo
|
|
//
|
|
// Generate a parser error (info), does not change the error state in the parse
|
|
//---------------------------------------------------------------------------------------
|
|
private void ForceReportInfo(Context context, JSError errorId){
|
|
Debug.Assert(context != null);
|
|
context.HandleError(errorId);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ForceReportInfo
|
|
//
|
|
// Generate a parser error (info), does not change the error state in the parse
|
|
//---------------------------------------------------------------------------------------
|
|
private void ForceReportInfo(JSError errorId, bool treatAsError){
|
|
this.currentToken.Clone().HandleError(errorId, treatAsError);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// EOFError
|
|
//
|
|
// Create a context for EOF error. The created context points to the end of the source
|
|
// code. Assume the the scanner actually reached the end of file
|
|
//---------------------------------------------------------------------------------------
|
|
private void EOFError(JSError errorId){
|
|
Context eofCtx = this.sourceContext.Clone();
|
|
eofCtx.lineNumber = this.scanner.GetCurrentLine();
|
|
eofCtx.endLineNumber = eofCtx.lineNumber;
|
|
eofCtx.startLinePos = this.scanner.GetStartLinePosition();
|
|
eofCtx.endLinePos = eofCtx.startLinePos;
|
|
eofCtx.startPos = this.sourceContext.endPos;
|
|
eofCtx.endPos++;
|
|
eofCtx.HandleError(errorId);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// SkipTokensAndThrow
|
|
//
|
|
// Skip tokens until one in the no skip set is found.
|
|
// A call to this function always ends in a throw statement that will be caught by the
|
|
// proper rule
|
|
//---------------------------------------------------------------------------------------
|
|
private void SkipTokensAndThrow(){
|
|
SkipTokensAndThrow(null);
|
|
}
|
|
|
|
private void SkipTokensAndThrow(AST partialAST){
|
|
this.errorToken = null; // make sure we go to the next token
|
|
bool checkForEndOfLine = this.noSkipTokenSet.HasToken(JSToken.EndOfLine);
|
|
while (!this.noSkipTokenSet.HasToken(this.currentToken.token)){
|
|
if (checkForEndOfLine){
|
|
if (this.scanner.GotEndOfLine()){
|
|
this.errorToken = this.currentToken;
|
|
throw new RecoveryTokenException(JSToken.EndOfLine, partialAST);
|
|
}
|
|
}
|
|
GetNextToken();
|
|
if (++this.tokensSkipped > c_MaxSkippedTokenNumber){
|
|
ForceReportInfo(JSError.TooManyTokensSkipped);
|
|
throw new EndOfFile();
|
|
}
|
|
if (JSToken.EndOfFile == this.currentToken.token)
|
|
throw new EndOfFile();
|
|
}
|
|
this.errorToken = this.currentToken;
|
|
// got a token in the no skip set, throw
|
|
throw new RecoveryTokenException(this.currentToken.token, partialAST);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// IndexOfToken
|
|
//
|
|
// check whether the recovery token is a good one for the caller
|
|
//---------------------------------------------------------------------------------------
|
|
private int IndexOfToken(JSToken[] tokens, RecoveryTokenException exc){
|
|
return IndexOfToken(tokens, exc._token);
|
|
}
|
|
|
|
private int IndexOfToken(JSToken[] tokens, JSToken token){
|
|
int i, c;
|
|
for (i = 0, c = tokens.Length; i < c; i++)
|
|
if (tokens[i] == token)
|
|
break;
|
|
if (i >= c)
|
|
i = -1;
|
|
else{
|
|
// assume that the caller will deal with the token so move the state back to normal
|
|
this.errorToken = null;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
private bool TokenInList(JSToken[] tokens, JSToken token){
|
|
return (-1 != IndexOfToken(tokens, token));
|
|
}
|
|
|
|
private bool TokenInList(JSToken[] tokens, RecoveryTokenException exc){
|
|
return (-1 != IndexOfToken(tokens, exc._token));
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// FromASTListToCustomAttributeList
|
|
//
|
|
// Utility function that takes a list of AST nodes (Call and Lookup nodes) and makes
|
|
// a CustomAttributeList. It is invoked once a list of calls and lookups is unambiguosly
|
|
// parsed as a custom attribute list
|
|
//---------------------------------------------------------------------------------------
|
|
private CustomAttributeList FromASTListToCustomAttributeList(ArrayList attributes){
|
|
CustomAttributeList customAttributes = null;
|
|
if (attributes != null && attributes.Count > 0)
|
|
customAttributes = new CustomAttributeList(((AST)attributes[0]).context);
|
|
for (int i = 0, n = attributes.Count; i < n; i++){
|
|
ASTList args = new ASTList(null);
|
|
if (attributes[i] is Lookup || attributes[i] is Member)
|
|
customAttributes.Append(new CustomAttribute(((AST)attributes[i]).context, (AST)attributes[i], args));
|
|
else
|
|
customAttributes.Append(((Call)attributes[i]).ToCustomAttribute());
|
|
}
|
|
|
|
return customAttributes;
|
|
}
|
|
|
|
internal bool HasAborted{
|
|
get{
|
|
return this.tokensSkipped > c_MaxSkippedTokenNumber;
|
|
}
|
|
}
|
|
}
|
|
|
|
// helper classes
|
|
//***************************************************************************************
|
|
//
|
|
//***************************************************************************************
|
|
internal class AstListItem{
|
|
internal AstListItem _prev;
|
|
internal AST _term;
|
|
|
|
internal AstListItem(AST term, AstListItem prev){
|
|
_prev = prev;
|
|
_term = term;
|
|
}
|
|
|
|
}
|
|
|
|
//***************************************************************************************
|
|
//
|
|
//***************************************************************************************
|
|
internal class OpListItem{
|
|
internal OpListItem _prev;
|
|
internal JSToken _operator;
|
|
internal OpPrec _prec;
|
|
//internal OpAssoc _assoc;
|
|
|
|
internal OpListItem(JSToken op, OpPrec prec, /*OpAssoc assoc,*/ OpListItem prev){
|
|
_prev = prev;
|
|
_operator = op;
|
|
_prec = prec;
|
|
//_assoc = assoc;
|
|
}
|
|
}
|
|
|
|
//***************************************************************************************
|
|
//
|
|
//***************************************************************************************
|
|
public class ParserException : Exception{
|
|
internal ParserException() : base("JSParser Exception"){
|
|
}
|
|
}
|
|
|
|
internal class UnexpectedToken : ParserException{
|
|
internal JSToken _unexpectedToken;
|
|
|
|
internal UnexpectedToken() : base(){
|
|
}
|
|
|
|
internal UnexpectedToken(JSToken unexpectedToken) : base(){
|
|
_unexpectedToken = unexpectedToken;
|
|
}
|
|
}
|
|
|
|
internal class RecoveryTokenException : ParserException{
|
|
internal JSToken _token;
|
|
internal AST _partiallyComputedNode;
|
|
|
|
internal RecoveryTokenException(JSToken token, AST partialAST) : base(){
|
|
_token = token;
|
|
_partiallyComputedNode = partialAST;
|
|
}
|
|
}
|
|
|
|
public class EndOfFile : ParserException{
|
|
internal EndOfFile() : base(){
|
|
}
|
|
}
|
|
|
|
//***************************************************************************************
|
|
// NoSkipTokenSet
|
|
//
|
|
// This class is a possible implementation of the no skip token set. It relies on the
|
|
// fact that the array passed in are static. Should you change it, this implementation
|
|
// should change as well.
|
|
// It keeps a linked list of token arrays that are passed in during parsing, on error
|
|
// condition the list is traversed looking for a matching token. If a match is found
|
|
// the token should not be skipped and an exception is thrown to let the proper
|
|
// rule deal with the token
|
|
//***************************************************************************************
|
|
internal class NoSkipTokenSet{
|
|
TokenSetListItem _tokenSet;
|
|
|
|
internal NoSkipTokenSet(){
|
|
_tokenSet = null;
|
|
}
|
|
|
|
internal void Add(JSToken[] tokens){
|
|
_tokenSet = new TokenSetListItem(tokens, _tokenSet);
|
|
}
|
|
|
|
internal void Remove(JSToken[] tokens){
|
|
TokenSetListItem curr = _tokenSet, prev = null;
|
|
while (curr != null){
|
|
if (curr._tokens == tokens){
|
|
if (prev == null){
|
|
Debug.Assert(_tokenSet == curr);
|
|
_tokenSet = _tokenSet._next;
|
|
}else{
|
|
prev._next = curr._next;
|
|
}
|
|
return;
|
|
}
|
|
prev = curr;
|
|
curr = curr._next;
|
|
}
|
|
Debug.Assert(false, "Token set not in no skip token");
|
|
}
|
|
|
|
internal bool HasToken(JSToken token){
|
|
TokenSetListItem curr = _tokenSet;
|
|
while (curr != null){
|
|
for (int i = 0, c = curr._tokens.Length; i < c; i++){
|
|
if (curr._tokens[i] == token)
|
|
return true;
|
|
}
|
|
curr = curr._next;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// list of static no skip token set for specifc rules
|
|
internal static readonly JSToken[] s_ArrayInitNoSkipTokenSet = new JSToken[]{JSToken.RightBracket,
|
|
JSToken.Comma};
|
|
internal static readonly JSToken[] s_BlockConditionNoSkipTokenSet = new JSToken[]{JSToken.RightParen,
|
|
JSToken.LeftCurly,
|
|
JSToken.EndOfLine};
|
|
internal static readonly JSToken[] s_BlockNoSkipTokenSet = new JSToken[]{JSToken.RightCurly};
|
|
internal static readonly JSToken[] s_BracketToken = new JSToken[]{JSToken.RightBracket};
|
|
internal static readonly JSToken[] s_CaseNoSkipTokenSet = new JSToken[]{JSToken.Case,
|
|
JSToken.Default,
|
|
JSToken.Colon,
|
|
JSToken.EndOfLine};
|
|
internal static readonly JSToken[] s_ClassBodyNoSkipTokenSet = new JSToken[]{JSToken.Class,
|
|
JSToken.Interface,
|
|
JSToken.Enum,
|
|
JSToken.Function,
|
|
JSToken.Var,
|
|
JSToken.Const,
|
|
JSToken.Static,
|
|
JSToken.Public,
|
|
JSToken.Private,
|
|
JSToken.Protected};
|
|
internal static readonly JSToken[] s_InterfaceBodyNoSkipTokenSet = new JSToken[]{JSToken.Enum,
|
|
JSToken.Function,
|
|
JSToken.Public,
|
|
JSToken.EndOfLine,
|
|
JSToken.Semicolon};
|
|
internal static readonly JSToken[] s_ClassExtendsNoSkipTokenSet = new JSToken[]{JSToken.LeftCurly,
|
|
JSToken.Implements};
|
|
internal static readonly JSToken[] s_ClassImplementsNoSkipTokenSet = new JSToken[]{JSToken.LeftCurly,
|
|
JSToken.Comma};
|
|
internal static readonly JSToken[] s_DoWhileBodyNoSkipTokenSet = new JSToken[]{JSToken.While};
|
|
internal static readonly JSToken[] s_EndOfLineToken = new JSToken[]{JSToken.EndOfLine};
|
|
internal static readonly JSToken[] s_EndOfStatementNoSkipTokenSet = new JSToken[]{JSToken.Semicolon,
|
|
JSToken.EndOfLine};
|
|
internal static readonly JSToken[] s_EnumBaseTypeNoSkipTokenSet = new JSToken[]{JSToken.LeftCurly};
|
|
internal static readonly JSToken[] s_EnumBodyNoSkipTokenSet = new JSToken[]{JSToken.Identifier};
|
|
internal static readonly JSToken[] s_ExpressionListNoSkipTokenSet = new JSToken[]{JSToken.Comma};
|
|
internal static readonly JSToken[] s_FunctionDeclNoSkipTokenSet = new JSToken[]{JSToken.RightParen,
|
|
JSToken.LeftCurly,
|
|
JSToken.Comma};
|
|
internal static readonly JSToken[] s_IfBodyNoSkipTokenSet = new JSToken[]{JSToken.Else};
|
|
internal static readonly JSToken[] s_MemberExprNoSkipTokenSet = new JSToken[]{JSToken.LeftBracket,
|
|
JSToken.LeftParen,
|
|
JSToken.AccessField};
|
|
internal static readonly JSToken[] s_NoTrySkipTokenSet = new JSToken[]{JSToken.Catch,
|
|
JSToken.Finally};
|
|
internal static readonly JSToken[] s_ObjectInitNoSkipTokenSet = new JSToken[]{JSToken.RightCurly,
|
|
JSToken.Comma};
|
|
internal static readonly JSToken[] s_PackageBodyNoSkipTokenSet = new JSToken[]{JSToken.Class,
|
|
JSToken.Interface,
|
|
JSToken.Enum};
|
|
internal static readonly JSToken[] s_ParenExpressionNoSkipToken = new JSToken[]{JSToken.RightParen};
|
|
internal static readonly JSToken[] s_ParenToken = new JSToken[]{JSToken.RightParen};
|
|
internal static readonly JSToken[] s_PostfixExpressionNoSkipTokenSet = new JSToken[]{JSToken.Increment,
|
|
JSToken.Decrement};
|
|
internal static readonly JSToken[] s_StartBlockNoSkipTokenSet = new JSToken[]{JSToken.LeftCurly};
|
|
internal static readonly JSToken[] s_StartStatementNoSkipTokenSet = new JSToken[]{JSToken.LeftCurly,
|
|
JSToken.Var,
|
|
JSToken.Const,
|
|
JSToken.If,
|
|
JSToken.For,
|
|
JSToken.Do,
|
|
JSToken.While,
|
|
JSToken.With,
|
|
JSToken.Switch,
|
|
JSToken.Try};
|
|
internal static readonly JSToken[] s_SwitchNoSkipTokenSet = new JSToken[]{JSToken.Case,
|
|
JSToken.Default};
|
|
internal static readonly JSToken[] s_TopLevelNoSkipTokenSet = new JSToken[]{JSToken.Package,
|
|
JSToken.Class,
|
|
JSToken.Interface,
|
|
JSToken.Enum,
|
|
JSToken.Function,
|
|
JSToken.Import};
|
|
internal static readonly JSToken[] s_VariableDeclNoSkipTokenSet = new JSToken[]{JSToken.Comma,
|
|
JSToken.Semicolon};
|
|
|
|
private class TokenSetListItem{
|
|
internal TokenSetListItem _next;
|
|
internal JSToken[] _tokens;
|
|
|
|
internal TokenSetListItem(JSToken[] tokens, TokenSetListItem next){
|
|
_next = next;
|
|
_tokens = tokens;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|