public void Visit(ParameterDeclaration node)
{
// invalid! ignore
IsValid = false;
}
public void Visit(ParameterDeclaration node)
{
// invalid! ignore
IsValid = false;
}
public void Visit(ParameterDeclaration node)
{
// not applicable; terminate
}
public void Visit(ParameterDeclaration node)
{
// we're good
}
private static void ResolveGhostedCatchParameter(ActivationObject scope, ParameterDeclaration catchParameter)
{
// check to see if the name exists in the outer variable scope.
var ghostField = scope[catchParameter.Name];
if (ghostField == null)
{
// set up a ghost field to keep track of the relationship
ghostField = new JSVariableField(FieldType.GhostCatch, catchParameter.Name, 0, null)
{
OriginalContext = catchParameter.Context.Clone()
};
scope.AddField(ghostField);
}
else if (ghostField.FieldType == FieldType.GhostCatch)
{
// there is, but it's another ghost catch variable. That's fine; just use it.
// don't even flag it as ambiguous because if someone is later referencing the error variable
// used in a couple catch variables, we'll say something then because other browsers will have that
// variable undefined or from an outer scope.
}
else
{
// there is, and it's NOT another ghosted catch variable. Possible naming
// collision in IE -- if an error happens, it will clobber the existing field's value,
// although that MAY be the intention; we don't know for sure. But it IS a cross-
// browser behavior difference.
ghostField.IsAmbiguous = true;
if (ghostField.OuterField != null)
{
// and to make matters worse, it's actually bound to an OUTER field
// in modern browsers, but will bind to this catch variable in older
// versions of IE! Definitely a cross-browser difference!
// throw a cross-browser issue error.
catchParameter.Context.HandleError(JSError.AmbiguousCatchVar);
}
}
// link them so they all keep the same name going forward
// (since they are named the same in the sources)
catchParameter.VariableField.OuterField = ghostField;
// TODO: this really should be a LIST of ghosted fields, since multiple
// elements can ghost to the same field.
ghostField.GhostedField = catchParameter.VariableField;
// if the actual field has references, we want to bubble those up
// since we're now linking those fields
if (catchParameter.VariableField.RefCount > 0)
{
// add the catch parameter's references to the ghost field
ghostField.AddReferences(catchParameter.VariableField.References);
}
}
internal CatchScope(ActivationObject parent, Context catchContext, CodeSettings settings, ParameterDeclaration catchParameter)
: base(parent, catchContext, settings)
{
CatchParameter = catchParameter;
}
internal CatchScope(ActivationObject parent, Context catchContext, CodeSettings settings, ParameterDeclaration catchParameter)
: base(parent, catchContext, settings)
{
CatchParameter = catchParameter;
}
public void Visit(ParameterDeclaration node)
{
// nothing to do
}
public void Visit(ParameterDeclaration node)
{
// we're good
}
private FunctionObject ParseFunction(FunctionType functionType, Context fncCtx)
{
Lookup name = null;
AstNodeList formalParameters = null;
Block body = null;
bool inExpression = (functionType == FunctionType.Expression);
Context paramsContext = null;
GetNextToken();
// get the function name or make an anonymous function if in expression "position"
if (JSToken.Identifier == m_currentToken.Token)
{
name = new Lookup(m_currentToken.Clone(), this)
{
Name = m_scanner.Identifier
};
GetNextToken();
}
else
{
string identifier = JSKeyword.CanBeIdentifier(m_currentToken.Token);
if (null != identifier)
{
name = new Lookup(m_currentToken.Clone(), this)
{
Name = identifier
};
GetNextToken();
}
else
{
if (!inExpression)
{
// if this isn't a function expression, then we need to throw an error because
// function DECLARATIONS always need a valid identifier name
ReportError(JSError.NoIdentifier, m_currentToken.Clone(), true);
// BUT if the current token is a left paren, we don't want to use it as the name.
// (fix for issue #14152)
if (m_currentToken.Token != JSToken.LeftParenthesis
&& m_currentToken.Token != JSToken.LeftCurly)
{
identifier = m_currentToken.Code;
name = new Lookup(CurrentPositionContext(), this)
{
Name = identifier
};
GetNextToken();
}
}
}
}
// make a new state and save the old one
List<BlockType> blockType = m_blockType;
m_blockType = new List<BlockType>(16);
Dictionary<string, LabelInfo> labelTable = m_labelTable;
m_labelTable = new Dictionary<string, LabelInfo>();
try
{
// get the formal parameters
if (JSToken.LeftParenthesis != m_currentToken.Token)
{
// we expect a left paren at this point for standard cross-browser support.
// BUT -- some versions of IE allow an object property expression to be a function name, like window.onclick.
// we still want to throw the error, because it syntax errors on most browsers, but we still want to
// be able to parse it and return the intended results.
// Skip to the open paren and use whatever is in-between as the function name. Doesn't matter that it's
// an invalid identifier; it won't be accessible as a valid field anyway.
bool expandedIndentifier = false;
while (m_currentToken.Token != JSToken.LeftParenthesis
&& m_currentToken.Token != JSToken.LeftCurly
&& m_currentToken.Token != JSToken.Semicolon
&& m_currentToken.Token != JSToken.EndOfFile)
{
name.Context.UpdateWith(m_currentToken);
GetNextToken();
expandedIndentifier = true;
}
// if we actually expanded the identifier context, then we want to report that
// the function name needs to be an identifier. Otherwise we didn't expand the
// name, so just report that we expected an open paren at this point.
if (expandedIndentifier)
{
name.Name = name.Context.Code;
name.Context.HandleError(JSError.FunctionNameMustBeIdentifier, false);
}
else
{
ReportError(JSError.NoLeftParenthesis, true);
}
}
if (m_currentToken.Token == JSToken.LeftParenthesis)
{
// create the parameter list
formalParameters = new AstNodeList(m_currentToken.Clone(), this);
paramsContext = m_currentToken.Clone();
// skip the open paren
GetNextToken();
// create the list of arguments and update the context
while (JSToken.RightParenthesis != m_currentToken.Token)
{
String id = null;
m_noSkipTokenSet.Add(NoSkipTokenSet.s_FunctionDeclNoSkipTokenSet);
try
{
ParameterDeclaration paramDecl = null;
if (JSToken.Identifier != m_currentToken.Token && (id = JSKeyword.CanBeIdentifier(m_currentToken.Token)) == null)
{
if (JSToken.LeftCurly == m_currentToken.Token)
{
ReportError(JSError.NoRightParenthesis);
break;
}
else if (JSToken.Comma == m_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 = m_scanner.Identifier;
}
paramDecl = new ParameterDeclaration(m_currentToken.Clone(), this)
{
Name = id,
Position = formalParameters.Count
};
formalParameters.Append(paramDecl);
GetNextToken();
}
// got an arg, it should be either a ',' or ')'
if (JSToken.RightParenthesis == m_currentToken.Token)
{
break;
}
else if (JSToken.Comma == m_currentToken.Token)
{
// append the comma context as the terminator for the parameter
paramDecl.IfNotNull(p => p.TerminatingContext = m_currentToken.Clone());
}
else
{
// deal with error in some "intelligent" way
if (JSToken.LeftCurly == m_currentToken.Token)
{
ReportError(JSError.NoRightParenthesis);
break;
}
else
{
if (JSToken.Identifier == m_currentToken.Token)
{
// 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;
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_FunctionDeclNoSkipTokenSet);
}
}
fncCtx.UpdateWith(m_currentToken);
GetNextToken();
}
// read the function body of non-abstract functions.
if (JSToken.LeftCurly != m_currentToken.Token)
ReportError(JSError.NoLeftCurly, true);
m_blockType.Add(BlockType.Block);
m_noSkipTokenSet.Add(NoSkipTokenSet.s_BlockNoSkipTokenSet);
m_noSkipTokenSet.Add(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
try
{
// parse the block locally to get the exact end of function
body = new Block(m_currentToken.Clone(), this);
body.BraceOnNewLine = m_foundEndOfLine;
GetNextToken();
var possibleDirectivePrologue = true;
while (JSToken.RightCurly != m_currentToken.Token)
{
try
{
// function body's are SourceElements (Statements + FunctionDeclarations)
var statement = ParseStatement(true);
if (possibleDirectivePrologue)
{
var constantWrapper = statement as ConstantWrapper;
if (constantWrapper != null && constantWrapper.PrimitiveType == PrimitiveType.String)
{
// if it's already a directive prologues, we're good to go
if (!(constantWrapper is DirectivePrologue))
{
// make the statement a directive prologue instead of a constant wrapper
statement = new DirectivePrologue(constantWrapper.Value.ToString(), constantWrapper.Context, constantWrapper.Parser)
{
MayHaveIssues = constantWrapper.MayHaveIssues
};
}
}
else if (!m_newModule)
{
// no longer considering constant wrappers
possibleDirectivePrologue = false;
}
}
else if (m_newModule)
{
// we scanned into a new module -- we might find directive prologues again
possibleDirectivePrologue = true;
}
// add it to the body
body.Append(statement);
}
catch (RecoveryTokenException exc)
{
if (exc._partiallyComputedNode != null)
{
body.Append(exc._partiallyComputedNode);
}
if (IndexOfToken(NoSkipTokenSet.s_StartStatementNoSkipTokenSet, exc) == -1)
throw;
}
}
// make sure any important comments before the closing brace are kept
if (m_importantComments.Count > 0
&& m_settings.PreserveImportantComments
&& m_settings.IsModificationAllowed(TreeModifications.PreserveImportantComments))
{
// we have important comments before the EOF. Add the comment(s) to the program.
foreach (var importantComment in m_importantComments)
{
body.Append(new ImportantComment(importantComment, this));
}
m_importantComments.Clear();
}
body.Context.UpdateWith(m_currentToken);
fncCtx.UpdateWith(m_currentToken);
}
catch (EndOfFileException)
{
// if we get an EOF here, we never had a chance to find the closing curly-brace
fncCtx.HandleError(JSError.UnclosedFunction, true);
}
catch (RecoveryTokenException exc)
{
if (IndexOfToken(NoSkipTokenSet.s_BlockNoSkipTokenSet, exc) == -1)
{
exc._partiallyComputedNode = new FunctionObject(fncCtx, this)
{
FunctionType = (inExpression ? FunctionType.Expression : FunctionType.Declaration),
IdContext = name.IfNotNull(n => n.Context),
Name = name.IfNotNull(n => n.Name),
ParameterDeclarations = formalParameters,
ParametersContext = paramsContext,
Body = body
};
throw;
}
}
finally
{
m_blockType.RemoveAt(m_blockType.Count - 1);
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockNoSkipTokenSet);
}
GetNextToken();
}
finally
{
// restore state
m_blockType = blockType;
m_labelTable = labelTable;
}
return new FunctionObject(fncCtx, this)
{
FunctionType = functionType,
IdContext = name.IfNotNull(n => n.Context),
Name = name.IfNotNull(n => n.Name),
ParameterDeclarations = formalParameters,
ParametersContext = paramsContext,
Body = body
};
}
//---------------------------------------------------------------------------------------
// ParseTryStatement
//
// TryStatement :
// 'try' Block Catch Finally
//
// Catch :
// <empty> | 'catch' '(' Identifier ')' Block
//
// Finally :
// <empty> |
// 'finally' Block
//---------------------------------------------------------------------------------------
private AstNode ParseTryStatement()
{
Context tryCtx = m_currentToken.Clone();
Context catchContext = null;
Context finallyContext = null;
Context tryEndContext = null;
Block body = null;
Context idContext = null;
Block handler = null;
Block finally_block = null;
RecoveryTokenException excInFinally = null;
m_blockType.Add(BlockType.Block);
try
{
bool catchOrFinally = false;
GetNextToken();
if (JSToken.LeftCurly != m_currentToken.Token)
{
ReportError(JSError.NoLeftCurly);
}
m_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;
}
else
{
body = exc._partiallyComputedNode as Block;
if (body == null)
{
body = new Block(exc._partiallyComputedNode.Context, this);
body.Append(exc._partiallyComputedNode);
}
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_NoTrySkipTokenSet);
}
if (JSToken.Catch == m_currentToken.Token)
{
m_noSkipTokenSet.Add(NoSkipTokenSet.s_NoTrySkipTokenSet);
try
{
catchOrFinally = true;
catchContext = m_currentToken.Clone();
GetNextToken();
if (JSToken.LeftParenthesis != m_currentToken.Token)
{
ReportError(JSError.NoLeftParenthesis);
}
GetNextToken();
if (JSToken.Identifier != m_currentToken.Token)
{
string identifier = JSKeyword.CanBeIdentifier(m_currentToken.Token);
if (null != identifier)
{
idContext = m_currentToken.Clone();
}
else
{
ReportError(JSError.NoIdentifier);
}
}
else
{
idContext = m_currentToken.Clone();
}
GetNextToken();
m_noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
try
{
if (JSToken.RightParenthesis != m_currentToken.Token)
{
ReportError(JSError.NoRightParenthesis);
}
GetNextToken();
}
catch (RecoveryTokenException exc)
{
if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1)
{
exc._partiallyComputedNode = null;
// rethrow
throw;
}
else
{
if (m_currentToken.Token == JSToken.RightParenthesis)
{
GetNextToken();
}
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
}
if (JSToken.LeftCurly != m_currentToken.Token)
{
ReportError(JSError.NoLeftCurly);
}
// parse the block
handler = ParseBlock();
tryCtx.UpdateWith(handler.Context);
}
catch (RecoveryTokenException exc)
{
if (exc._partiallyComputedNode == null)
{
handler = new Block(CurrentPositionContext(), this);
}
else
{
handler = exc._partiallyComputedNode as Block;
if (handler == null)
{
handler = new Block(exc._partiallyComputedNode.Context, this);
handler.Append(exc._partiallyComputedNode);
}
}
if (IndexOfToken(NoSkipTokenSet.s_NoTrySkipTokenSet, exc) == -1)
{
throw;
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_NoTrySkipTokenSet);
}
}
try
{
if (JSToken.Finally == m_currentToken.Token)
{
finallyContext = m_currentToken.Clone();
GetNextToken();
m_blockType.Add(BlockType.Finally);
try
{
finally_block = ParseBlock();
catchOrFinally = true;
}
finally
{
m_blockType.RemoveAt(m_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(), this); // make a dummy empty block
}
}
finally
{
m_blockType.RemoveAt(m_blockType.Count - 1);
}
ParameterDeclaration catchParameter = null;
if (idContext != null)
{
catchParameter = new ParameterDeclaration(idContext, this)
{
Name = idContext.Code
};
}
if (excInFinally != null)
{
excInFinally._partiallyComputedNode = new TryNode(tryCtx, this)
{
TryBlock = body,
CatchContext = catchContext,
CatchParameter = catchParameter,
CatchBlock = handler,
FinallyContext = finallyContext,
FinallyBlock = finally_block
};
throw excInFinally;
}
return new TryNode(tryCtx, this)
{
TryBlock = body,
CatchContext = catchContext,
CatchParameter = catchParameter,
CatchBlock = handler,
FinallyContext = finallyContext,
FinallyBlock = finally_block
};
}
public void Visit(ParameterDeclaration node)
{
// not applicable; terminate
}
public void Visit(ParameterDeclaration node)
{
// nothing to do
}