public void Visit(AspNetBlockNode node) { // invalid! ignore IsValid = false; }
public void Visit(AspNetBlockNode node) { // don't bother recursing, but let's wrap in parens, just in case // (since we don't know what will be inserted here) m_needsParens = true; }
public void Visit(AspNetBlockNode node) { // nothing to do }
public void Visit(AspNetBlockNode node) { // not applicable; terminate }
private AstNode ParseStatement(bool fSourceElement) { AstNode statement = null; if (m_importantComments.Count > 0 && m_settings.PreserveImportantComments && m_settings.IsModificationAllowed(TreeModifications.PreserveImportantComments)) { // we have at least one important comment before the upcoming statement. // pop the first important comment off the queue, return that node instead. // don't advance the token -- we'll probably be coming back again for the next one (if any) statement = new ImportantComment(m_importantComments[0], this); m_importantComments.RemoveAt(0); } else { String id = null; var isNewModule = m_newModule; switch (m_currentToken.Token) { case JSToken.EndOfFile: EOFError(JSError.ErrorEndOfFile); throw new EndOfFileException(); // abort parsing, get back to the main parse routine case JSToken.Semicolon: // make an empty statement statement = new EmptyStatement(m_currentToken.Clone(), this); GetNextToken(); return statement; case JSToken.RightCurly: ReportError(JSError.SyntaxError); SkipTokensAndThrow(); break; case JSToken.LeftCurly: return ParseBlock(); case JSToken.Debugger: return ParseDebuggerStatement(); case JSToken.Var: case JSToken.Const: case JSToken.Let: return ParseVariableStatement(); 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(), this); else return statement; case JSToken.Break: statement = ParseBreakStatement(); if (null == statement) return new Block(CurrentPositionContext(), this); else return statement; case JSToken.Return: statement = ParseReturnStatement(); if (null == statement) return new Block(CurrentPositionContext(), this); else return statement; case JSToken.With: return ParseWithStatement(); case JSToken.Switch: return ParseSwitchStatement(); case JSToken.Throw: statement = ParseThrowStatement(); if (statement == null) return new Block(CurrentPositionContext(), this); else break; case JSToken.Try: return ParseTryStatement(); case JSToken.Function: // parse a function declaration FunctionObject function = ParseFunction(FunctionType.Declaration, m_currentToken.Clone()); function.IsSourceElement = fSourceElement; return function; case JSToken.Else: ReportError(JSError.InvalidElse); SkipTokensAndThrow(); break; case JSToken.ConditionalCommentStart: return ParseStatementLevelConditionalComment(fSourceElement); case JSToken.ConditionalCompilationOn: { ConditionalCompilationOn ccOn = new ConditionalCompilationOn(m_currentToken.Clone(), this); GetNextToken(); return ccOn; } case JSToken.ConditionalCompilationSet: return ParseConditionalCompilationSet(); case JSToken.ConditionalCompilationIf: return ParseConditionalCompilationIf(false); case JSToken.ConditionalCompilationElseIf: return ParseConditionalCompilationIf(true); case JSToken.ConditionalCompilationElse: { ConditionalCompilationElse elseStatement = new ConditionalCompilationElse(m_currentToken.Clone(), this); GetNextToken(); return elseStatement; } case JSToken.ConditionalCompilationEnd: { ConditionalCompilationEnd endStatement = new ConditionalCompilationEnd(m_currentToken.Clone(), this); GetNextToken(); return endStatement; } default: m_noSkipTokenSet.Add(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet); bool exprError = false; try { bool bAssign; // if this statement starts with a function within parens, we want to know now bool parenFunction = (m_currentToken.Token == JSToken.LeftParenthesis && PeekToken() == JSToken.Function); statement = ParseUnaryExpression(out bAssign, false); if (statement != null && parenFunction) { FunctionObject functionObject = statement.LeftHandSide as FunctionObject; if (functionObject != null) { functionObject.LeftHandFunctionExpression = true; } } // look for labels if (statement is Lookup && JSToken.Colon == m_currentToken.Token) { // can be a label id = statement.ToString(); if (m_labelTable.ContainsKey(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(), this); } else { var colonContext = m_currentToken.Clone(); GetNextToken(); int labelNestCount = m_labelTable.Count + 1; m_labelTable.Add(id, new LabelInfo(m_blockType.Count, labelNestCount)); if (JSToken.EndOfFile != m_currentToken.Token) { statement = new LabeledStatement(statement.Context.Clone(), this) { Label = id, ColonContext = colonContext, NestCount = labelNestCount, Statement = ParseStatement(fSourceElement) }; } else { // end of the file! //just pass null for the labeled statement statement = new LabeledStatement(statement.Context.Clone(), this) { Label = id, ColonContext = colonContext, NestCount = labelNestCount }; } m_labelTable.Remove(id); return statement; } } statement = ParseExpression(statement, false, bAssign, JSToken.None); // if we just started a new module and this statement happens to be an expression statement... if (isNewModule && statement.IsExpression) { // see if it's a constant wrapper var constantWrapper = statement as ConstantWrapper; if (constantWrapper != null && constantWrapper.PrimitiveType == PrimitiveType.String) { // we found a string constant expression statement right after the start of a new // module. Let's make it a DirectivePrologue if it isn't already if (!(statement is DirectivePrologue)) { statement = new DirectivePrologue(constantWrapper.Value.ToString(), constantWrapper.Context, this) { MayHaveIssues = constantWrapper.MayHaveIssues }; } } } var binaryOp = statement as BinaryOperator; if (binaryOp != null && (binaryOp.OperatorToken == JSToken.Equal || binaryOp.OperatorToken == JSToken.StrictEqual)) { // an expression statement with equality operator? Doesn't really do anything. // Did the developer intend this to be an assignment operator instead? Low-pri warning. binaryOp.OperatorContext.IfNotNull(c => c.HandleError(JSError.SuspectEquality, false)); } var lookup = statement as Lookup; if (lookup != null && lookup.Name.StartsWith("<%=", StringComparison.Ordinal) && lookup.Name.EndsWith("%>", StringComparison.Ordinal)) { // single lookup, but it's actually one or more ASP.NET blocks. // convert back to an asp.net block node statement = new AspNetBlockNode(statement.Context, this) { AspNetBlockText = lookup.Name }; } var aspNetBlock = statement as AspNetBlockNode; if (aspNetBlock != null && JSToken.Semicolon == m_currentToken.Token) { aspNetBlock.IsTerminatedByExplicitSemicolon = true; statement.IfNotNull(s => s.TerminatingContext = m_currentToken.Clone()); GetNextToken(); } // we just parsed an expression statement. Now see if we have an appropriate // semicolon to terminate it. if (JSToken.Semicolon == m_currentToken.Token) { statement.IfNotNull(s => s.TerminatingContext = m_currentToken.Clone()); GetNextToken(); } else if (m_foundEndOfLine || JSToken.RightCurly == m_currentToken.Token || JSToken.EndOfFile == m_currentToken.Token) { // semicolon insertion rules // (if there was no statement parsed, then don't fire a warning) // a right-curly or an end of line is something we don't WANT to throw a warning for. // Just too common and doesn't really warrant a warning (in my opinion) if (statement != null && JSToken.RightCurly != m_currentToken.Token && JSToken.EndOfFile != m_currentToken.Token) { ReportError(JSError.SemicolonInsertion, statement.Context.IfNotNull(c => c.FlattenToEnd()), true); } } else { ReportError(JSError.NoSemicolon, true); } } catch (RecoveryTokenException exc) { if (exc._partiallyComputedNode != null) statement = exc._partiallyComputedNode; if (statement == null) { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet); exprError = true; SkipTokensAndThrow(); } if (IndexOfToken(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet, exc) == -1) { exc._partiallyComputedNode = statement; throw; } } finally { if (!exprError) m_noSkipTokenSet.Remove(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet); } break; } } return statement; }
private AstNode ParseLeftHandSideExpression(bool isMinus) { AstNode ast = null; bool skipToken = true; List<Context> newContexts = null; TryItAgain: // new expression while (JSToken.New == m_currentToken.Token) { if (null == newContexts) newContexts = new List<Context>(4); newContexts.Add(m_currentToken.Clone()); GetNextToken(); } JSToken token = m_currentToken.Token; switch (token) { // primary expression case JSToken.Identifier: ast = new Lookup(m_currentToken.Clone(), this) { Name = m_scanner.Identifier }; break; case JSToken.ConditionalCommentStart: // skip past the start to the next token GetNextToken(); if (m_currentToken.Token == JSToken.ConditionalCompilationVariable) { // we have /*@id ast = new ConstantWrapperPP(m_currentToken.Clone(), this) { VarName = m_currentToken.Code, ForceComments = true }; GetNextToken(); if (m_currentToken.Token == JSToken.ConditionalCommentEnd) { // skip past the closing comment GetNextToken(); } else { // we ONLY support /*@id@*/ in expressions right now. If there's not // a closing comment after the ID, then we don't support it. // throw an error, skip to the end of the comment, then ignore it and start // looking for the next token. CCTooComplicated(null); goto TryItAgain; } } else if (m_currentToken.Token == JSToken.ConditionalCommentEnd) { // empty conditional comment! Ignore. GetNextToken(); goto TryItAgain; } else { // we DON'T have "/*@IDENT". We only support "/*@IDENT @*/", so since this isn't // and id, throw the error, skip to the end of the comment, and ignore it // by looping back and looking for the NEXT token. m_currentToken.HandleError(JSError.ConditionalCompilationTooComplex); // skip to end of conditional comment while (m_currentToken.Token != JSToken.EndOfFile && m_currentToken.Token != JSToken.ConditionalCommentEnd) { GetNextToken(); } GetNextToken(); goto TryItAgain; } break; case JSToken.This: ast = new ThisLiteral(m_currentToken.Clone(), this); break; case JSToken.StringLiteral: ast = new ConstantWrapper(m_scanner.StringLiteralValue, PrimitiveType.String, m_currentToken.Clone(), this) { MayHaveIssues = m_scanner.LiteralHasIssues }; break; case JSToken.IntegerLiteral: case JSToken.NumericLiteral: { Context numericContext = m_currentToken.Clone(); double doubleValue; if (ConvertNumericLiteralToDouble(m_currentToken.Code, (token == JSToken.IntegerLiteral), out doubleValue)) { // conversion worked fine // check for some boundary conditions var mayHaveIssues = m_scanner.LiteralHasIssues; if (doubleValue == double.MaxValue) { ReportError(JSError.NumericMaximum, numericContext, true); } else if (isMinus && -doubleValue == double.MinValue) { ReportError(JSError.NumericMinimum, numericContext, true); } // create the constant wrapper from the value ast = new ConstantWrapper(doubleValue, PrimitiveType.Number, numericContext, this) { MayHaveIssues = mayHaveIssues }; } else { // check to see if we went overflow if (double.IsInfinity(doubleValue)) { ReportError(JSError.NumericOverflow, numericContext, true); } // regardless, we're going to create a special constant wrapper // that simply echos the input as-is ast = new ConstantWrapper(m_currentToken.Code, PrimitiveType.Other, numericContext, this) { MayHaveIssues = true }; } break; } case JSToken.True: ast = new ConstantWrapper(true, PrimitiveType.Boolean, m_currentToken.Clone(), this); break; case JSToken.False: ast = new ConstantWrapper(false, PrimitiveType.Boolean, m_currentToken.Clone(), this); break; case JSToken.Null: ast = new ConstantWrapper(null, PrimitiveType.Null, m_currentToken.Clone(), this); break; case JSToken.ConditionalCompilationVariable: ast = new ConstantWrapperPP(m_currentToken.Clone(), this) { VarName = m_currentToken.Code, ForceComments = false }; break; case JSToken.DivideAssign: // normally this token is not allowed on the left-hand side of an expression. // BUT, this might be the start of a regular expression that begins with an equals sign! // we need to test to see if we can parse a regular expression, and if not, THEN // we can fail the parse. case JSToken.Divide: // could it be a regexp? String source = m_scanner.ScanRegExp(); if (source != null) { // parse the flags (if any) String flags = m_scanner.ScanRegExpFlags(); // create the literal ast = new RegExpLiteral(m_currentToken.Clone(), this) { Pattern = source, PatternSwitches = flags }; break; } goto default; // expression case JSToken.LeftParenthesis: { var groupingOp = new GroupingOperator(m_currentToken.Clone(), this); ast = groupingOp; GetNextToken(); m_noSkipTokenSet.Add(NoSkipTokenSet.s_ParenExpressionNoSkipToken); try { // parse an expression groupingOp.Operand = ParseExpression(); if (JSToken.RightParenthesis != m_currentToken.Token) { ReportError(JSError.NoRightParenthesis); } else { // add the closing paren to the expression context ast.Context.UpdateWith(m_currentToken); } } catch (RecoveryTokenException exc) { if (IndexOfToken(NoSkipTokenSet.s_ParenExpressionNoSkipToken, exc) == -1) throw; else groupingOp.Operand = exc._partiallyComputedNode; } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_ParenExpressionNoSkipToken); } } break; // array initializer case JSToken.LeftBracket: Context listCtx = m_currentToken.Clone(); GetNextToken(); AstNodeList list = new AstNodeList(CurrentPositionContext(), this); while (JSToken.RightBracket != m_currentToken.Token) { if (JSToken.Comma != m_currentToken.Token) { m_noSkipTokenSet.Add(NoSkipTokenSet.s_ArrayInitNoSkipTokenSet); try { var expression = ParseExpression(true); list.Append(expression); if (JSToken.Comma != m_currentToken.Token) { if (JSToken.RightBracket != m_currentToken.Token) { ReportError(JSError.NoRightBracket); } break; } else { // we have a comma -- skip it after adding it as a terminator // on the previous expression expression.IfNotNull(e => e.TerminatingContext = m_currentToken.Clone()); GetNextToken(); // if the next token is the closing brackets, then we need to // add a missing value to the array because we end in a comma and // we need to keep it for cross-platform compat. // TECHNICALLY, that puts an extra item into the array for most modern browsers, but not ALL. if (m_currentToken.Token == JSToken.RightBracket) { list.Append(new ConstantWrapper(Missing.Value, PrimitiveType.Other, m_currentToken.Clone(), this)); } } } 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, this) { Elements = list }; throw; } else { if (JSToken.RightBracket == m_currentToken.Token) break; } } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_ArrayInitNoSkipTokenSet); } } else { // comma -- missing array item in the list list.Append(new ConstantWrapper(Missing.Value, PrimitiveType.Other, m_currentToken.Clone(), this) { TerminatingContext = m_currentToken.Clone() }); // skip over the comma GetNextToken(); // if the next token is the closing brace, then we end with a comma -- and we need to // add ANOTHER missing value to make sure this last comma doesn't get left off. // TECHNICALLY, that puts an extra item into the array for most modern browsers, but not ALL. if (m_currentToken.Token == JSToken.RightBracket) { list.Append(new ConstantWrapper(Missing.Value, PrimitiveType.Other, m_currentToken.Clone(), this)); } } } listCtx.UpdateWith(m_currentToken); ast = new ArrayLiteral(listCtx, this) { Elements = list }; break; // object initializer case JSToken.LeftCurly: Context objCtx = m_currentToken.Clone(); GetNextToken(); var propertyList = new AstNodeList(CurrentPositionContext(), this); if (JSToken.RightCurly != m_currentToken.Token) { for (; ; ) { ObjectLiteralField field = null; AstNode value = null; bool getterSetter = false; string ident; switch (m_currentToken.Token) { case JSToken.Identifier: field = new ObjectLiteralField(m_scanner.Identifier, PrimitiveType.String, m_currentToken.Clone(), this); break; case JSToken.StringLiteral: field = new ObjectLiteralField(m_scanner.StringLiteralValue, PrimitiveType.String, m_currentToken.Clone(), this) { MayHaveIssues = m_scanner.LiteralHasIssues }; break; case JSToken.IntegerLiteral: case JSToken.NumericLiteral: { double doubleValue; if (ConvertNumericLiteralToDouble(m_currentToken.Code, (m_currentToken.Token == JSToken.IntegerLiteral), out doubleValue)) { // conversion worked fine field = new ObjectLiteralField( doubleValue, PrimitiveType.Number, m_currentToken.Clone(), this ); } else { // something went wrong and we're not sure the string representation in the source is // going to convert to a numeric value well if (double.IsInfinity(doubleValue)) { ReportError(JSError.NumericOverflow, m_currentToken.Clone(), true); } // use the source as the field name, not the numeric value field = new ObjectLiteralField( m_currentToken.Code, PrimitiveType.Other, m_currentToken.Clone(), this); } break; } case JSToken.Get: case JSToken.Set: if (PeekToken() == JSToken.Colon) { // the field is either "get" or "set" and isn't the special Mozilla getter/setter field = new ObjectLiteralField(m_currentToken.Code, PrimitiveType.String, m_currentToken.Clone(), this); } else { // ecma-script get/set property construct getterSetter = true; bool isGet = (m_currentToken.Token == JSToken.Get); value = ParseFunction( (JSToken.Get == m_currentToken.Token ? FunctionType.Getter : FunctionType.Setter), m_currentToken.Clone() ); FunctionObject funcExpr = value as FunctionObject; if (funcExpr != null) { // getter/setter is just the literal name with a get/set flag field = new GetterSetter( funcExpr.Name, isGet, funcExpr.IdContext.Clone(), this ); } else { ReportError(JSError.FunctionExpressionExpected); } } break; default: // NOT: identifier token, string, number, or getter/setter. // see if it's a token that COULD be an identifierName. ident = m_scanner.Identifier; if (JSScanner.IsValidIdentifier(ident)) { // BY THE SPEC, if it's a valid identifierName -- which includes reserved words -- then it's // okay for object literal syntax. However, reserved words here won't work in all browsers, // so if it is a reserved word, let's throw a low-sev cross-browser warning on the code. if (JSKeyword.CanBeIdentifier(m_currentToken.Token) == null) { ReportError(JSError.ObjectLiteralKeyword, m_currentToken.Clone(), true); } field = new ObjectLiteralField(ident, PrimitiveType.String, m_currentToken.Clone(), this); } else { // throw an error but use it anyway, since that's what the developer has going on ReportError(JSError.NoMemberIdentifier, m_currentToken.Clone(), true); field = new ObjectLiteralField(m_currentToken.Code, PrimitiveType.String, m_currentToken.Clone(), this); } break; } if (field != null) { if (!getterSetter) { GetNextToken(); } m_noSkipTokenSet.Add(NoSkipTokenSet.s_ObjectInitNoSkipTokenSet); try { if (!getterSetter) { // get the value if (JSToken.Colon != m_currentToken.Token) { ReportError(JSError.NoColon, true); value = ParseExpression(true); } else { field.ColonContext = m_currentToken.Clone(); GetNextToken(); value = ParseExpression(true); } } // put the pair into the list of fields var propCtx = field.Context.Clone().CombineWith(value.IfNotNull(v => v.Context)); var property = new ObjectLiteralProperty(propCtx, this) { Name = field, Value = value }; propertyList.Append(property); if (JSToken.RightCurly == m_currentToken.Token) { break; } else { if (JSToken.Comma == m_currentToken.Token) { // skip the comma after adding it to the property as a terminating context property.IfNotNull(p => p.TerminatingContext = m_currentToken.Clone()); GetNextToken(); // if the next token is the right-curly brace, then we ended // the list with a comma, which is perfectly fine if (m_currentToken.Token == JSToken.RightCurly) { break; } } else { if (m_foundEndOfLine) { 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; var propCtx = field.Context.Clone().CombineWith(value.IfNotNull(v => v.Context)); var property = new ObjectLiteralProperty(propCtx, this) { Name = field, Value = value }; propertyList.Append(property); } if (IndexOfToken(NoSkipTokenSet.s_ObjectInitNoSkipTokenSet, exc) == -1) { exc._partiallyComputedNode = new ObjectLiteral(objCtx, this) { Properties = propertyList }; throw; } else { if (JSToken.Comma == m_currentToken.Token) GetNextToken(); if (JSToken.RightCurly == m_currentToken.Token) break; } } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_ObjectInitNoSkipTokenSet); } } } } objCtx.UpdateWith(m_currentToken); ast = new ObjectLiteral(objCtx, this) { Properties = propertyList }; break; // function expression case JSToken.Function: ast = ParseFunction(FunctionType.Expression, m_currentToken.Clone()); skipToken = false; break; case JSToken.AspNetBlock: ast = new AspNetBlockNode(m_currentToken.Clone(), this) { AspNetBlockText = m_currentToken.Code }; break; default: string identifier = JSKeyword.CanBeIdentifier(m_currentToken.Token); if (null != identifier) { ast = new Lookup(m_currentToken.Clone(), this) { Name = identifier }; } else { ReportError(JSError.ExpressionExpected); SkipTokensAndThrow(); } break; } // can be a CallExpression, that is, followed by '.' or '(' or '[' if (skipToken) GetNextToken(); return MemberExpression(ast, newContexts); }