#include <preparser.h>

Inheritance diagram for v8::internal::PreParser:

Collaboration diagram for v8::internal::PreParser:

Public Types
enum	PreParseResult { kPreParseStackOverflow , kPreParseSuccess }

typedef PreParserIdentifier	Identifier

typedef PreParserExpression	Expression

typedef PreParserStatement	Statement

Public Types inherited from v8::internal::ParserBase< PreParserTraits >
typedef Traits::Type::Expression	ExpressionT

typedef Traits::Type::Identifier	IdentifierT

typedef Traits::Type::FunctionLiteral	FunctionLiteralT

typedef Traits::Type::Literal	LiteralT

typedef Traits::Type::ObjectLiteralProperty	ObjectLiteralPropertyT

Public Member Functions
	PreParser (Scanner scanner, ParserRecorder log, uintptr_t stack_limit)

PreParseResult	PreParseProgram ()

PreParseResult	PreParseLazyFunction (StrictMode strict_mode, bool is_generator, ParserRecorder *log)

Public Member Functions inherited from v8::internal::ParserBase< PreParserTraits >
	ParserBase (Scanner scanner, uintptr_t stack_limit, v8::Extension extension, ParserRecorder log, typename Traits::Type::Zone zone, AstNode::IdGen *ast_node_id_gen, typename Traits::Type::Parser this_object)

bool	allow_lazy () const

bool	allow_natives_syntax () const

bool	allow_arrow_functions () const

bool	allow_modules () const

bool	allow_harmony_scoping () const

bool	allow_harmony_numeric_literals () const

bool	allow_classes () const

bool	allow_harmony_object_literals () const

void	set_allow_lazy (bool allow)

void	set_allow_natives_syntax (bool allow)

void	set_allow_arrow_functions (bool allow)

void	set_allow_modules (bool allow)

void	set_allow_harmony_scoping (bool allow)

void	set_allow_harmony_numeric_literals (bool allow)

void	set_allow_classes (bool allow)

void	set_allow_harmony_object_literals (bool allow)

Public Member Functions inherited from v8::internal::PreParserTraits
	PreParserTraits (PreParser *pre_parser)

bool	ShortcutNumericLiteralBinaryExpression (PreParserExpression x, PreParserExpression y, Token::Value op, int pos, PreParserFactory factory)

PreParserExpression	BuildUnaryExpression (PreParserExpression expression, Token::Value op, int pos, PreParserFactory *factory)

PreParserExpression	NewThrowReferenceError (const char *type, int pos)

PreParserExpression	NewThrowSyntaxError (const char *type, Handle< Object > arg, int pos)

PreParserExpression	NewThrowTypeError (const char *type, Handle< Object > arg, int pos)

PreParserScope	NewScope (PreParserScope *outer_scope, ScopeType scope_type)

void	ReportMessageAt (Scanner::Location location, const char message, const char arg=NULL, bool is_reference_error=false)

void	ReportMessageAt (int start_pos, int end_pos, const char message, const char arg=NULL, bool is_reference_error=false)

PreParserIdentifier	GetSymbol (Scanner *scanner)

PreParserIdentifier	GetNumberAsSymbol (Scanner *scanner)

PreParserExpression	ExpressionFromString (int pos, Scanner scanner, PreParserFactory factory=NULL)

PreParserExpression	GetIterator (PreParserExpression iterable, PreParserFactory *factory)

void	SkipLazyFunctionBody (PreParserIdentifier function_name, int materialized_literal_count, int expected_property_count, bool *ok)

PreParserStatementList	ParseEagerFunctionBody (PreParserIdentifier function_name, int pos, Variable fvar, Token::Value fvar_init_op, bool is_generator, bool ok)

int	DeclareArrowParametersFromExpression (PreParserExpression expression, PreParserScope scope, Scanner::Location dupe_loc, bool *ok)

void	CheckConflictingVarDeclarations (PreParserScope scope, bool *ok)

PreParserExpression	ParseV8Intrinsic (bool *ok)

PreParserExpression	ParseFunctionLiteral (PreParserIdentifier name, Scanner::Location function_name_location, bool name_is_strict_reserved, FunctionKind kind, int function_token_position, FunctionLiteral::FunctionType type, FunctionLiteral::ArityRestriction arity_restriction, bool *ok)

Private Types
enum	VariableDeclarationContext { kSourceElement , kStatement , kForStatement }

enum	VariableDeclarationProperties { kHasInitializers , kHasNoInitializers }

enum	SourceElements { kUnknownSourceElements }

Private Member Functions
Statement	ParseSourceElement (bool *ok)

SourceElements	ParseSourceElements (int end_token, bool *ok)

Statement	ParseStatement (bool *ok)

Statement	ParseFunctionDeclaration (bool *ok)

Statement	ParseClassDeclaration (bool *ok)

Statement	ParseBlock (bool *ok)

Statement	ParseVariableStatement (VariableDeclarationContext var_context, bool *ok)

Statement	ParseVariableDeclarations (VariableDeclarationContext var_context, VariableDeclarationProperties decl_props, int num_decl, bool *ok)

Statement	ParseExpressionOrLabelledStatement (bool *ok)

Statement	ParseIfStatement (bool *ok)

Statement	ParseContinueStatement (bool *ok)

Statement	ParseBreakStatement (bool *ok)

Statement	ParseReturnStatement (bool *ok)

Statement	ParseWithStatement (bool *ok)

Statement	ParseSwitchStatement (bool *ok)

Statement	ParseDoWhileStatement (bool *ok)

Statement	ParseWhileStatement (bool *ok)

Statement	ParseForStatement (bool *ok)

Statement	ParseThrowStatement (bool *ok)

Statement	ParseTryStatement (bool *ok)

Statement	ParseDebuggerStatement (bool *ok)

Expression	ParseConditionalExpression (bool accept_IN, bool *ok)

Expression	ParseObjectLiteral (bool *ok)

Expression	ParseV8Intrinsic (bool *ok)

void	SkipLazyFunctionBody (PreParserIdentifier function_name, int materialized_literal_count, int expected_property_count, bool *ok)

PreParserStatementList	ParseEagerFunctionBody (PreParserIdentifier function_name, int pos, Variable fvar, Token::Value fvar_init_op, bool is_generator, bool ok)

Expression	ParseFunctionLiteral (Identifier name, Scanner::Location function_name_location, bool name_is_strict_reserved, FunctionKind kind, int function_token_pos, FunctionLiteral::FunctionType function_type, FunctionLiteral::ArityRestriction arity_restriction, bool *ok)

void	ParseLazyFunctionLiteralBody (bool *ok)

bool	CheckInOrOf (bool accept_OF)

Friends
class	PreParserTraits

Additional Inherited Members
Static Public Member Functions inherited from v8::internal::PreParserTraits
template<typename FunctionState >
static void	SetUpFunctionState (FunctionState *function_state)

template<typename FunctionState >
static void	TearDownFunctionState (FunctionState *function_state)

static bool	IsEvalOrArguments (PreParserIdentifier identifier)

static bool	IsPrototype (PreParserIdentifier identifier)

static bool	IsConstructor (PreParserIdentifier identifier)

static bool	IsThisProperty (PreParserExpression expression)

static bool	IsIdentifier (PreParserExpression expression)

static PreParserIdentifier	AsIdentifier (PreParserExpression expression)

static bool	IsFutureStrictReserved (PreParserIdentifier identifier)

static bool	IsBoilerplateProperty (PreParserExpression property)

static bool	IsArrayIndex (PreParserIdentifier string, uint32_t *index)

static void	PushLiteralName (FuncNameInferrer *fni, PreParserIdentifier id)

static void	PushPropertyName (FuncNameInferrer *fni, PreParserExpression expression)

static void	InferFunctionName (FuncNameInferrer *fni, PreParserExpression expression)

static void	CheckFunctionLiteralInsideTopLevelObjectLiteral (PreParserScope scope, PreParserExpression property, bool has_function)

static void	CheckAssigningFunctionLiteralToProperty (PreParserExpression left, PreParserExpression right)

static void	CheckPossibleEvalCall (PreParserExpression expression, PreParserScope *scope)

static PreParserExpression	MarkExpressionAsAssigned (PreParserExpression expression)

static PreParserIdentifier	EmptyIdentifier ()

static PreParserIdentifier	EmptyIdentifierString ()

static PreParserExpression	EmptyExpression ()

static PreParserExpression	EmptyArrowParamList ()

static PreParserExpression	EmptyLiteral ()

static PreParserExpression	EmptyObjectLiteralProperty ()

static PreParserExpression	EmptyFunctionLiteral ()

static PreParserExpressionList	NullExpressionList ()

static PreParserExpression	GetLiteralTheHole (int position, PreParserFactory *factory)

static PreParserIdentifier	GetNextSymbol (Scanner *scanner)

static PreParserExpression	ThisExpression (PreParserScope scope, PreParserFactory factory)

static PreParserExpression	SuperReference (PreParserScope scope, PreParserFactory factory)

static PreParserExpression	ClassLiteral (PreParserIdentifier name, PreParserExpression extends, PreParserExpression constructor, PreParserExpressionList properties, int position, PreParserFactory *factory)

static PreParserExpression	ExpressionFromLiteral (Token::Value token, int pos, Scanner scanner, PreParserFactory factory)

static PreParserExpression	ExpressionFromIdentifier (PreParserIdentifier name, int pos, PreParserScope scope, PreParserFactory factory)

static PreParserExpressionList	NewExpressionList (int size, void *zone)

static PreParserStatementList	NewStatementList (int size, void *zone)

static PreParserExpressionList	NewPropertyList (int size, void *zone)

static AstValueFactory *	ast_value_factory ()

Protected Types inherited from v8::internal::ParserBase< PreParserTraits >
enum	AllowEvalOrArgumentsAsIdentifier

enum	Mode

enum	PropertyKind

Protected Member Functions inherited from v8::internal::ParserBase< PreParserTraits >
Scanner *	scanner () const

int	position ()

int	peek_position ()

bool	stack_overflow () const

void	set_stack_overflow ()

Mode	mode () const

Traits::Type::Zone *	zone () const

AstNode::IdGen *	ast_node_id_gen () const

	INLINE (Token::Value peek())

	INLINE (Token::Value Next())

void	Consume (Token::Value token)

bool	Check (Token::Value token)

void	Expect (Token::Value token, bool *ok)

void	ExpectSemicolon (bool *ok)

bool	peek_any_identifier ()

bool	CheckContextualKeyword (Vector< const char > keyword)

void	ExpectContextualKeyword (Vector< const char > keyword, bool *ok)

void	CheckOctalLiteral (int beg_pos, int end_pos, bool *ok)

void	CheckStrictFunctionNameAndParameters (IdentifierT function_name, bool function_name_is_strict_reserved, const Scanner::Location &function_name_loc, const Scanner::Location &eval_args_error_loc, const Scanner::Location &dupe_error_loc, const Scanner::Location &reserved_loc, bool *ok)

Traits::Type::Factory *	factory ()

StrictMode	strict_mode ()

bool	is_generator () const

void	ReportMessage (const char message, const char arg=NULL, bool is_reference_error=false)

void	ReportMessageAt (Scanner::Location location, const char *message, bool is_reference_error=false)

void	ReportUnexpectedToken (Token::Value token)

IdentifierT	ParseIdentifier (AllowEvalOrArgumentsAsIdentifier, bool *ok)

IdentifierT	ParseIdentifierOrStrictReservedWord (bool is_strict_reserved, bool ok)

IdentifierT	ParseIdentifierName (bool *ok)

IdentifierT	ParseIdentifierNameOrGetOrSet (bool is_get, bool is_set, bool *ok)

ExpressionT	ParseRegExpLiteral (bool seen_equal, bool *ok)

ExpressionT	ParsePrimaryExpression (bool *ok)

ExpressionT	ParseExpression (bool accept_IN, bool *ok)

ExpressionT	ParseArrayLiteral (bool *ok)

IdentifierT	ParsePropertyName (bool is_get, bool is_set, bool is_static, bool ok)

ExpressionT	ParseObjectLiteral (bool *ok)

ObjectLiteralPropertyT	ParsePropertyDefinition (ObjectLiteralChecker checker, bool in_class, bool is_static, bool ok)

Traits::Type::ExpressionList	ParseArguments (bool *ok)

ExpressionT	ParseAssignmentExpression (bool accept_IN, bool *ok)

ExpressionT	ParseYieldExpression (bool *ok)

ExpressionT	ParseConditionalExpression (bool accept_IN, bool *ok)

ExpressionT	ParseBinaryExpression (int prec, bool accept_IN, bool *ok)

ExpressionT	ParseUnaryExpression (bool *ok)

ExpressionT	ParsePostfixExpression (bool *ok)

ExpressionT	ParseLeftHandSideExpression (bool *ok)

ExpressionT	ParseMemberWithNewPrefixesExpression (bool *ok)

ExpressionT	ParseMemberExpression (bool *ok)

ExpressionT	ParseMemberExpressionContinuation (ExpressionT expression, bool *ok)

ExpressionT	ParseArrowFunctionLiteral (int start_pos, ExpressionT params_ast, bool *ok)

ExpressionT	ParseClassLiteral (IdentifierT name, Scanner::Location function_name_location, bool name_is_strict_reserved, int pos, bool *ok)

ExpressionT	CheckAndRewriteReferenceExpression (ExpressionT expression, Scanner::Location location, const char message, bool ok)

Static Protected Member Functions inherited from v8::internal::ParserBase< PreParserTraits >
static int	Precedence (Token::Value token, bool accept_IN)

Protected Attributes inherited from v8::internal::ParserBase< PreParserTraits >
bool	parenthesized_function_

Traits::Type::Scope *	scope_

FunctionState *	function_state_

v8::Extension *	extension_

FuncNameInferrer *	fni_

ParserRecorder *	log_

Mode	mode_

uintptr_t	stack_limit_

Detailed Description

Definition at line 1409 of file preparser.h.

Member Typedef Documentation

◆ Expression

typedef PreParserExpression v8::internal::PreParser::Expression

Definition at line 1412 of file preparser.h.

◆ Identifier

typedef PreParserIdentifier v8::internal::PreParser::Identifier

Definition at line 1411 of file preparser.h.

◆ Statement

typedef PreParserStatement v8::internal::PreParser::Statement

Definition at line 1413 of file preparser.h.

Member Enumeration Documentation

◆ PreParseResult

enum v8::internal::PreParser::PreParseResult

Enumerator
kPreParseStackOverflow
kPreParseSuccess

Definition at line 1415 of file preparser.h.

                       {
     kPreParseStackOverflow,
     kPreParseSuccess
   };

◆ SourceElements

enum v8::internal::PreParser::SourceElements

private

Enumerator
kUnknownSourceElements

Definition at line 1476 of file preparser.h.

                       {
     kUnknownSourceElements
   };

◆ VariableDeclarationContext

enum v8::internal::PreParser::VariableDeclarationContext

private

Enumerator
kSourceElement
kStatement
kForStatement

Definition at line 1463 of file preparser.h.

                                   {
     kSourceElement,
     kStatement,
     kForStatement
   };

◆ VariableDeclarationProperties

enum v8::internal::PreParser::VariableDeclarationProperties

private

Enumerator
kHasInitializers
kHasNoInitializers

Definition at line 1470 of file preparser.h.

                                      {
     kHasInitializers,
     kHasNoInitializers
   };

Constructor & Destructor Documentation

◆ PreParser()

v8::internal::PreParser::PreParser	(	Scanner *	scanner,
		ParserRecorder *	log,
		uintptr_t	stack_limit
	)

inline

Definition at line 1420 of file preparser.h.

1421 : ParserBase<PreParserTraits>(scanner, stack_limit, NULL, log, NULL, NULL,

1422 this) {}

v8::internal::ParserBase< PreParserTraits >::scanner

Scanner * scanner() const

Definition: preparser.h:285

NULL

enable harmony numeric enable harmony object literal extensions Optimize object Array DOM strings and string trace pretenuring decisions of HAllocate instructions Enables optimizations which favor memory size over execution speed maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining trace the tracking of allocation sites deoptimize every n garbage collections perform array bounds checks elimination analyze liveness of environment slots and zap dead values flushes the cache of optimized code for closures on every GC allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes enable context specialization in TurboFan execution budget before interrupt is triggered max percentage of megamorphic generic ICs to allow optimization enable use of SAHF instruction if enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable use of MLS instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long enable alignment of csp to bytes on platforms which prefer the register to always be NULL

Definition: flag-definitions.h:407

Member Function Documentation

◆ CheckInOrOf()

bool v8::internal::PreParser::CheckInOrOf ( bool accept_OF )

private

Definition at line 681 of file preparser.cc.

                                           {
   if (Check(Token::IN) ||
       (accept_OF && CheckContextualKeyword(CStrVector("of")))) {
     return true;
   }
   return false;
 }

References v8::internal::ParserBase< PreParserTraits >::Check(), v8::internal::ParserBase< PreParserTraits >::CheckContextualKeyword(), v8::internal::CStrVector(), and IN.

Referenced by ParseForStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseBlock()

PreParser::Statement v8::internal::PreParser::ParseBlock ( bool * ok )

private

Definition at line 371 of file preparser.cc.

                                                  {
   // Block ::
   //   '{' Statement* '}'
  
   // Note that a Block does not introduce a new execution scope!
   // (ECMA-262, 3rd, 12.2)
   //
   Expect(Token::LBRACE, CHECK_OK);
   while (peek() != Token::RBRACE) {
     if (allow_harmony_scoping() && strict_mode() == STRICT) {
       ParseSourceElement(CHECK_OK);
     } else {
       ParseStatement(CHECK_OK);
     }
   }
   Expect(Token::RBRACE, ok);
   return Statement::Default();
 }

References v8::internal::ParserBase< PreParserTraits >::allow_harmony_scoping(), CHECK_OK, v8::internal::PreParserStatement::Default(), v8::internal::ParserBase< PreParserTraits >::Expect(), ParseSourceElement(), ParseStatement(), v8::internal::STRICT, and v8::internal::ParserBase< PreParserTraits >::strict_mode().

Referenced by ParseStatement(), and ParseTryStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseBreakStatement()

PreParser::Statement v8::internal::PreParser::ParseBreakStatement ( bool * ok )

private

Definition at line 557 of file preparser.cc.

                                                           {
   // BreakStatement ::
   //   'break' [no line terminator] Identifier? ';'
  
   Expect(Token::BREAK, CHECK_OK);
   Token::Value tok = peek();
   if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
       tok != Token::SEMICOLON &&
       tok != Token::RBRACE &&
       tok != Token::EOS) {
     // ECMA allows "eval" or "arguments" as labels even in strict mode.
     ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
   }
   ExpectSemicolon(CHECK_OK);
   return Statement::Default();
 }

References v8::internal::BREAK, CHECK_OK, v8::internal::PreParserStatement::Default(), v8::internal::ParserBase< PreParserTraits >::Expect(), v8::internal::ParserBase< PreParserTraits >::ExpectSemicolon(), v8::internal::ParserBase< PreParserTraits >::kAllowEvalOrArguments, v8::internal::ParserBase< PreParserTraits >::ParseIdentifier(), and v8::internal::ParserBase< PreParserTraits >::scanner().

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseClassDeclaration()

PreParser::Statement v8::internal::PreParser::ParseClassDeclaration ( bool * ok )

private

Definition at line 359 of file preparser.cc.

                                                             {
   Expect(Token::CLASS, CHECK_OK);
   int pos = position();
   bool is_strict_reserved = false;
   Identifier name =
       ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
   ParseClassLiteral(name, scanner()->location(), is_strict_reserved, pos,
                     CHECK_OK);
   return Statement::Default();
 }

References CHECK_OK, v8::internal::PreParserStatement::Default(), v8::internal::ParserBase< PreParserTraits >::Expect(), name, v8::internal::ParserBase< PreParserTraits >::ParseClassLiteral(), v8::internal::ParserBase< PreParserTraits >::ParseIdentifierOrStrictReservedWord(), v8::internal::ParserBase< PreParserTraits >::position(), and v8::internal::ParserBase< PreParserTraits >::scanner().

Referenced by ParseSourceElement(), and ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseConditionalExpression()

Expression v8::internal::PreParser::ParseConditionalExpression	(	bool	accept_IN,
		bool *	ok
	)

private

◆ ParseContinueStatement()

PreParser::Statement v8::internal::PreParser::ParseContinueStatement ( bool * ok )

private

Definition at line 539 of file preparser.cc.

                                                              {
   // ContinueStatement ::
   //   'continue' [no line terminator] Identifier? ';'
  
   Expect(Token::CONTINUE, CHECK_OK);
   Token::Value tok = peek();
   if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
       tok != Token::SEMICOLON &&
       tok != Token::RBRACE &&
       tok != Token::EOS) {
     // ECMA allows "eval" or "arguments" as labels even in strict mode.
     ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
   }
   ExpectSemicolon(CHECK_OK);
   return Statement::Default();
 }

References CHECK_OK, v8::internal::PreParserStatement::Default(), v8::internal::ParserBase< PreParserTraits >::Expect(), v8::internal::ParserBase< PreParserTraits >::ExpectSemicolon(), v8::internal::ParserBase< PreParserTraits >::kAllowEvalOrArguments, v8::internal::ParserBase< PreParserTraits >::ParseIdentifier(), and v8::internal::ParserBase< PreParserTraits >::scanner().

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseDebuggerStatement()

PreParser::Statement v8::internal::PreParser::ParseDebuggerStatement ( bool * ok )

private

Definition at line 802 of file preparser.cc.

                                                              {
   // In ECMA-262 'debugger' is defined as a reserved keyword. In some browser
   // contexts this is used as a statement which invokes the debugger as if a
   // break point is present.
   // DebuggerStatement ::
   //   'debugger' ';'
  
   Expect(Token::DEBUGGER, CHECK_OK);
   ExpectSemicolon(ok);
   return Statement::Default();
 }

References CHECK_OK, v8::internal::PreParserStatement::Default(), v8::internal::ParserBase< PreParserTraits >::Expect(), and v8::internal::ParserBase< PreParserTraits >::ExpectSemicolon().

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseDoWhileStatement()

PreParser::Statement v8::internal::PreParser::ParseDoWhileStatement ( bool * ok )

private

Definition at line 653 of file preparser.cc.

                                                             {
   // DoStatement ::
   //   'do' Statement 'while' '(' Expression ')' ';'
  
   Expect(Token::DO, CHECK_OK);
   ParseStatement(CHECK_OK);
   Expect(Token::WHILE, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, ok);
   if (peek() == Token::SEMICOLON) Consume(Token::SEMICOLON);
   return Statement::Default();
 }

References CHECK_OK, v8::internal::ParserBase< PreParserTraits >::Consume(), v8::internal::PreParserStatement::Default(), v8::internal::ParserBase< PreParserTraits >::Expect(), v8::internal::ParserBase< PreParserTraits >::ParseExpression(), and ParseStatement().

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseEagerFunctionBody()

PreParserStatementList v8::internal::PreParser::ParseEagerFunctionBody	(	PreParserIdentifier	function_name,
		int	pos,
		Variable *	fvar,
		Token::Value	fvar_init_op,
		bool	is_generator,
		bool *	ok
	)

inlineprivate

Definition at line 1532 of file preparser.h.

                                                           {
   ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
  
   ParseSourceElements(Token::RBRACE, ok);
   if (!*ok) return PreParserStatementList();
  
   Expect(Token::RBRACE, ok);
   return PreParserStatementList();
 }

References v8::internal::ParserBase< PreParserTraits >::Expect(), v8::internal::ParserBase< PreParserTraits >::PARSE_EAGERLY, and ParseSourceElements().

Referenced by v8::internal::PreParserTraits::ParseEagerFunctionBody().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseExpressionOrLabelledStatement()

PreParser::Statement v8::internal::PreParser::ParseExpressionOrLabelledStatement ( bool * ok )

private

Definition at line 493 of file preparser.cc.

                                                                          {
   // ExpressionStatement | LabelledStatement ::
   //   Expression ';'
   //   Identifier ':' Statement
  
   bool starts_with_identifier = peek_any_identifier();
   Expression expr = ParseExpression(true, CHECK_OK);
   // Even if the expression starts with an identifier, it is not necessarily an
   // identifier. For example, "foo + bar" starts with an identifier but is not
   // an identifier.
   if (starts_with_identifier && expr.IsIdentifier() && peek() == Token::COLON) {
     // Expression is a single identifier, and not, e.g., a parenthesized
     // identifier.
     DCHECK(!expr.AsIdentifier().IsFutureReserved());
     DCHECK(strict_mode() == SLOPPY ||
            (!expr.AsIdentifier().IsFutureStrictReserved() &&
             !expr.AsIdentifier().IsYield()));
     Consume(Token::COLON);
     return ParseStatement(ok);
     // Preparsing is disabled for extensions (because the extension details
     // aren't passed to lazily compiled functions), so we don't
     // accept "native function" in the preparser.
   }
   // Parsed expression statement.
   ExpectSemicolon(CHECK_OK);
   return Statement::ExpressionStatement(expr);
 }

References v8::internal::PreParserExpression::AsIdentifier(), CHECK_OK, v8::internal::ParserBase< PreParserTraits >::Consume(), DCHECK, v8::internal::ParserBase< PreParserTraits >::ExpectSemicolon(), v8::internal::PreParserStatement::ExpressionStatement(), v8::internal::PreParserIdentifier::IsFutureReserved(), v8::internal::PreParserIdentifier::IsFutureStrictReserved(), v8::internal::PreParserExpression::IsIdentifier(), v8::internal::PreParserIdentifier::IsYield(), v8::internal::ParserBase< PreParserTraits >::ParseExpression(), ParseStatement(), v8::internal::ParserBase< PreParserTraits >::peek_any_identifier(), v8::internal::SLOPPY, and v8::internal::ParserBase< PreParserTraits >::strict_mode().

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseForStatement()

PreParser::Statement v8::internal::PreParser::ParseForStatement ( bool * ok )

private

Definition at line 690 of file preparser.cc.

                                                         {
   // ForStatement ::
   //   'for' '(' Expression? ';' Expression? ';' Expression? ')' Statement
  
   Expect(Token::FOR, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   if (peek() != Token::SEMICOLON) {
     if (peek() == Token::VAR || peek() == Token::CONST ||
         (peek() == Token::LET && strict_mode() == STRICT)) {
       bool is_let = peek() == Token::LET;
       int decl_count;
       VariableDeclarationProperties decl_props = kHasNoInitializers;
       ParseVariableDeclarations(
           kForStatement, &decl_props, &decl_count, CHECK_OK);
       bool has_initializers = decl_props == kHasInitializers;
       bool accept_IN = decl_count == 1 && !(is_let && has_initializers);
       bool accept_OF = !has_initializers;
       if (accept_IN && CheckInOrOf(accept_OF)) {
         ParseExpression(true, CHECK_OK);
         Expect(Token::RPAREN, CHECK_OK);
  
         ParseStatement(CHECK_OK);
         return Statement::Default();
       }
     } else {
       Expression lhs = ParseExpression(false, CHECK_OK);
       if (CheckInOrOf(lhs.IsIdentifier())) {
         ParseExpression(true, CHECK_OK);
         Expect(Token::RPAREN, CHECK_OK);
  
         ParseStatement(CHECK_OK);
         return Statement::Default();
       }
     }
   }
  
   // Parsed initializer at this point.
   Expect(Token::SEMICOLON, CHECK_OK);
  
   if (peek() != Token::SEMICOLON) {
     ParseExpression(true, CHECK_OK);
   }
   Expect(Token::SEMICOLON, CHECK_OK);
  
   if (peek() != Token::RPAREN) {
     ParseExpression(true, CHECK_OK);
   }
   Expect(Token::RPAREN, CHECK_OK);
  
   ParseStatement(ok);
   return Statement::Default();
 }

References CHECK_OK, CheckInOrOf(), v8::internal::CONST, v8::internal::PreParserStatement::Default(), v8::internal::ParserBase< PreParserTraits >::Expect(), v8::internal::PreParserExpression::IsIdentifier(), kForStatement, kHasInitializers, kHasNoInitializers, v8::internal::LET, v8::internal::ParserBase< PreParserTraits >::ParseExpression(), ParseStatement(), ParseVariableDeclarations(), v8::internal::STRICT, v8::internal::ParserBase< PreParserTraits >::strict_mode(), and v8::internal::VAR.

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseFunctionDeclaration()

PreParser::Statement v8::internal::PreParser::ParseFunctionDeclaration ( bool * ok )

private

Definition at line 338 of file preparser.cc.

                                                                {
   // FunctionDeclaration ::
   //   'function' Identifier '(' FormalParameterListopt ')' '{' FunctionBody '}'
   // GeneratorDeclaration ::
   //   'function' '*' Identifier '(' FormalParameterListopt ')'
   //      '{' FunctionBody '}'
   Expect(Token::FUNCTION, CHECK_OK);
   int pos = position();
   bool is_generator = Check(Token::MUL);
   bool is_strict_reserved = false;
   Identifier name = ParseIdentifierOrStrictReservedWord(
       &is_strict_reserved, CHECK_OK);
   ParseFunctionLiteral(name, scanner()->location(), is_strict_reserved,
                        is_generator ? FunctionKind::kGeneratorFunction
                                     : FunctionKind::kNormalFunction,
                        pos, FunctionLiteral::DECLARATION,
                        FunctionLiteral::NORMAL_ARITY, CHECK_OK);
   return Statement::FunctionDeclaration();
 }

References v8::internal::ParserBase< PreParserTraits >::Check(), CHECK_OK, v8::internal::ParserBase< PreParserTraits >::Expect(), v8::internal::PreParserStatement::FunctionDeclaration(), v8::internal::ParserBase< PreParserTraits >::is_generator(), v8::internal::kGeneratorFunction, v8::internal::kNormalFunction, v8::internal::MUL, name, ParseFunctionLiteral(), v8::internal::ParserBase< PreParserTraits >::ParseIdentifierOrStrictReservedWord(), v8::internal::ParserBase< PreParserTraits >::position(), and v8::internal::ParserBase< PreParserTraits >::scanner().

Referenced by ParseSourceElement(), and ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseFunctionLiteral()

PreParser::Expression v8::internal::PreParser::ParseFunctionLiteral	(	Identifier	name,
		Scanner::Location	function_name_location,
		bool	name_is_strict_reserved,
		FunctionKind	kind,
		int	function_token_pos,
		FunctionLiteral::FunctionType	function_type,
		FunctionLiteral::ArityRestriction	arity_restriction,
		bool *	ok
	)

private

Definition at line 823 of file preparser.cc.

                                                                  {
   // Function ::
   //   '(' FormalParameterList? ')' '{' FunctionBody '}'
  
   // Parse function body.
   ScopeType outer_scope_type = scope_->type();
   PreParserScope function_scope(scope_, FUNCTION_SCOPE);
   FunctionState function_state(&function_state_, &scope_, &function_scope, NULL,
                                this->ast_value_factory());
   function_state.set_is_generator(IsGeneratorFunction(kind));
   //  FormalParameterList ::
   //    '(' (Identifier)*[','] ')'
   Expect(Token::LPAREN, CHECK_OK);
   int start_position = position();
   DuplicateFinder duplicate_finder(scanner()->unicode_cache());
   // We don't yet know if the function will be strict, so we cannot yet produce
   // errors for parameter names or duplicates. However, we remember the
   // locations of these errors if they occur and produce the errors later.
   Scanner::Location eval_args_error_loc = Scanner::Location::invalid();
   Scanner::Location dupe_error_loc = Scanner::Location::invalid();
   Scanner::Location reserved_error_loc = Scanner::Location::invalid();
  
   bool done = arity_restriction == FunctionLiteral::GETTER_ARITY ||
       (peek() == Token::RPAREN &&
        arity_restriction != FunctionLiteral::SETTER_ARITY);
   while (!done) {
     bool is_strict_reserved = false;
     Identifier param_name =
         ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
     if (!eval_args_error_loc.IsValid() && param_name.IsEvalOrArguments()) {
       eval_args_error_loc = scanner()->location();
     }
     if (!reserved_error_loc.IsValid() && is_strict_reserved) {
       reserved_error_loc = scanner()->location();
     }
  
     int prev_value = scanner()->FindSymbol(&duplicate_finder, 1);
  
     if (!dupe_error_loc.IsValid() && prev_value != 0) {
       dupe_error_loc = scanner()->location();
     }
  
     if (arity_restriction == FunctionLiteral::SETTER_ARITY) break;
     done = (peek() == Token::RPAREN);
     if (!done) Expect(Token::COMMA, CHECK_OK);
   }
   Expect(Token::RPAREN, CHECK_OK);
  
   // See Parser::ParseFunctionLiteral for more information about lazy parsing
   // and lazy compilation.
   bool is_lazily_parsed = (outer_scope_type == GLOBAL_SCOPE && allow_lazy() &&
                            !parenthesized_function_);
   parenthesized_function_ = false;
  
   Expect(Token::LBRACE, CHECK_OK);
   if (is_lazily_parsed) {
     ParseLazyFunctionLiteralBody(CHECK_OK);
   } else {
     ParseSourceElements(Token::RBRACE, ok);
   }
   Expect(Token::RBRACE, CHECK_OK);
  
   // Validate strict mode. We can do this only after parsing the function,
   // since the function can declare itself strict.
   // Concise methods use StrictFormalParameters.
   if (strict_mode() == STRICT || IsConciseMethod(kind)) {
     if (function_name.IsEvalOrArguments()) {
       ReportMessageAt(function_name_location, "strict_eval_arguments");
       *ok = false;
       return Expression::Default();
     }
     if (name_is_strict_reserved) {
       ReportMessageAt(function_name_location, "unexpected_strict_reserved");
       *ok = false;
       return Expression::Default();
     }
     if (eval_args_error_loc.IsValid()) {
       ReportMessageAt(eval_args_error_loc, "strict_eval_arguments");
       *ok = false;
       return Expression::Default();
     }
     if (dupe_error_loc.IsValid()) {
       ReportMessageAt(dupe_error_loc, "strict_param_dupe");
       *ok = false;
       return Expression::Default();
     }
     if (reserved_error_loc.IsValid()) {
       ReportMessageAt(reserved_error_loc, "unexpected_strict_reserved");
       *ok = false;
       return Expression::Default();
     }
  
     int end_position = scanner()->location().end_pos;
     CheckOctalLiteral(start_position, end_position, CHECK_OK);
   }
  
   return Expression::Default();
 }

Referenced by ParseFunctionDeclaration(), and v8::internal::PreParserTraits::ParseFunctionLiteral().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseIfStatement()

PreParser::Statement v8::internal::PreParser::ParseIfStatement ( bool * ok )

private

Definition at line 522 of file preparser.cc.

                                                        {
   // IfStatement ::
   //   'if' '(' Expression ')' Statement ('else' Statement)?
  
   Expect(Token::IF, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
   ParseStatement(CHECK_OK);
   if (peek() == Token::ELSE) {
     Next();
     ParseStatement(CHECK_OK);
   }
   return Statement::Default();
 }

References CHECK_OK, v8::internal::PreParserStatement::Default(), v8::internal::ParserBase< PreParserTraits >::Expect(), v8::internal::ParserBase< PreParserTraits >::ParseExpression(), and ParseStatement().

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseLazyFunctionLiteralBody()

void v8::internal::PreParser::ParseLazyFunctionLiteralBody ( bool * ok )

private

Definition at line 927 of file preparser.cc.

                                                      {
   int body_start = position();
   ParseSourceElements(Token::RBRACE, ok);
   if (!*ok) return;
  
   // Position right after terminal '}'.
   DCHECK_EQ(Token::RBRACE, scanner()->peek());
   int body_end = scanner()->peek_location().end_pos;
   log_->LogFunction(body_start, body_end,
                     function_state_->materialized_literal_count(),
                     function_state_->expected_property_count(),
                     strict_mode());
 }

References DCHECK_EQ, v8::internal::Scanner::Location::end_pos, v8::internal::ParserBase< PreParserTraits >::function_state_, v8::internal::ParserBase< PreParserTraits >::log_, v8::internal::ParserRecorder::LogFunction(), ParseSourceElements(), v8::internal::Scanner::peek_location(), v8::internal::ParserBase< PreParserTraits >::position(), v8::internal::ParserBase< PreParserTraits >::scanner(), and v8::internal::ParserBase< PreParserTraits >::strict_mode().

Referenced by ParseFunctionLiteral(), and PreParseLazyFunction().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseObjectLiteral()

Expression v8::internal::PreParser::ParseObjectLiteral ( bool * ok )

private

◆ ParseReturnStatement()

PreParser::Statement v8::internal::PreParser::ParseReturnStatement ( bool * ok )

private

Definition at line 575 of file preparser.cc.

                                                            {
   // ReturnStatement ::
   //   'return' [no line terminator] Expression? ';'
  
   // Consume the return token. It is necessary to do before
   // reporting any errors on it, because of the way errors are
   // reported (underlining).
   Expect(Token::RETURN, CHECK_OK);
  
   // An ECMAScript program is considered syntactically incorrect if it
   // contains a return statement that is not within the body of a
   // function. See ECMA-262, section 12.9, page 67.
   // This is not handled during preparsing.
  
   Token::Value tok = peek();
   if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
       tok != Token::SEMICOLON &&
       tok != Token::RBRACE &&
       tok != Token::EOS) {
     ParseExpression(true, CHECK_OK);
   }
   ExpectSemicolon(CHECK_OK);
   return Statement::Default();
 }

References CHECK_OK, v8::internal::PreParserStatement::Default(), v8::internal::ParserBase< PreParserTraits >::Expect(), v8::internal::ParserBase< PreParserTraits >::ExpectSemicolon(), v8::internal::ParserBase< PreParserTraits >::ParseExpression(), and v8::internal::ParserBase< PreParserTraits >::scanner().

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseSourceElement()

PreParser::Statement v8::internal::PreParser::ParseSourceElement ( bool * ok )

private

Definition at line 172 of file preparser.cc.

                                                          {
   // (Ecma 262 5th Edition, clause 14):
   // SourceElement:
   //    Statement
   //    FunctionDeclaration
   //
   // In harmony mode we allow additionally the following productions
   // SourceElement:
   //    LetDeclaration
   //    ConstDeclaration
   //    GeneratorDeclaration
  
   switch (peek()) {
     case Token::FUNCTION:
       return ParseFunctionDeclaration(ok);
     case Token::CLASS:
       return ParseClassDeclaration(ok);
     case Token::CONST:
       return ParseVariableStatement(kSourceElement, ok);
     case Token::LET:
       DCHECK(allow_harmony_scoping());
       if (strict_mode() == STRICT) {
         return ParseVariableStatement(kSourceElement, ok);
       }
       // Fall through.
     default:
       return ParseStatement(ok);
   }
 }

References v8::internal::ParserBase< PreParserTraits >::allow_harmony_scoping(), v8::internal::CONST, DCHECK, kSourceElement, v8::internal::LET, ParseClassDeclaration(), ParseFunctionDeclaration(), ParseStatement(), ParseVariableStatement(), v8::internal::STRICT, and v8::internal::ParserBase< PreParserTraits >::strict_mode().

Referenced by ParseBlock(), and ParseSourceElements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseSourceElements()

PreParser::SourceElements v8::internal::PreParser::ParseSourceElements	(	int	end_token,
		bool *	ok
	)

private

Definition at line 203 of file preparser.cc.

                                                                    {
   // SourceElements ::
   //   (Statement)* <end_token>
  
   bool directive_prologue = true;
   while (peek() != end_token) {
     if (directive_prologue && peek() != Token::STRING) {
       directive_prologue = false;
     }
     Statement statement = ParseSourceElement(CHECK_OK);
     if (directive_prologue) {
       if (statement.IsUseStrictLiteral()) {
         scope_->SetStrictMode(STRICT);
       } else if (!statement.IsStringLiteral()) {
         directive_prologue = false;
       }
     }
   }
   return kUnknownSourceElements;
 }

References CHECK_OK, v8::internal::PreParserStatement::IsStringLiteral(), v8::internal::PreParserStatement::IsUseStrictLiteral(), kUnknownSourceElements, ParseSourceElement(), v8::internal::ParserBase< PreParserTraits >::scope_, v8::internal::STRICT, and STRING.

Referenced by ParseEagerFunctionBody(), ParseFunctionLiteral(), ParseLazyFunctionLiteralBody(), and PreParseProgram().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseStatement()

PreParser::Statement v8::internal::PreParser::ParseStatement ( bool * ok )

private

Definition at line 234 of file preparser.cc.

                                                      {
   // Statement ::
   //   Block
   //   VariableStatement
   //   EmptyStatement
   //   ExpressionStatement
   //   IfStatement
   //   IterationStatement
   //   ContinueStatement
   //   BreakStatement
   //   ReturnStatement
   //   WithStatement
   //   LabelledStatement
   //   SwitchStatement
   //   ThrowStatement
   //   TryStatement
   //   DebuggerStatement
  
   // Note: Since labels can only be used by 'break' and 'continue'
   // statements, which themselves are only valid within blocks,
   // iterations or 'switch' statements (i.e., BreakableStatements),
   // labels can be simply ignored in all other cases; except for
   // trivial labeled break statements 'label: break label' which is
   // parsed into an empty statement.
  
   // Keep the source position of the statement
   switch (peek()) {
     case Token::LBRACE:
       return ParseBlock(ok);
  
     case Token::SEMICOLON:
       Next();
       return Statement::Default();
  
     case Token::IF:
       return ParseIfStatement(ok);
  
     case Token::DO:
       return ParseDoWhileStatement(ok);
  
     case Token::WHILE:
       return ParseWhileStatement(ok);
  
     case Token::FOR:
       return ParseForStatement(ok);
  
     case Token::CONTINUE:
       return ParseContinueStatement(ok);
  
     case Token::BREAK:
       return ParseBreakStatement(ok);
  
     case Token::RETURN:
       return ParseReturnStatement(ok);
  
     case Token::WITH:
       return ParseWithStatement(ok);
  
     case Token::SWITCH:
       return ParseSwitchStatement(ok);
  
     case Token::THROW:
       return ParseThrowStatement(ok);
  
     case Token::TRY:
       return ParseTryStatement(ok);
  
     case Token::FUNCTION: {
       Scanner::Location start_location = scanner()->peek_location();
       Statement statement = ParseFunctionDeclaration(CHECK_OK);
       Scanner::Location end_location = scanner()->location();
       if (strict_mode() == STRICT) {
         PreParserTraits::ReportMessageAt(start_location.beg_pos,
                                          end_location.end_pos,
                                          "strict_function");
         *ok = false;
         return Statement::Default();
       } else {
         return statement;
       }
     }
  
     case Token::CLASS:
       return ParseClassDeclaration(CHECK_OK);
  
     case Token::DEBUGGER:
       return ParseDebuggerStatement(ok);
  
     case Token::VAR:
     case Token::CONST:
       return ParseVariableStatement(kStatement, ok);
  
     case Token::LET:
       DCHECK(allow_harmony_scoping());
       if (strict_mode() == STRICT) {
         return ParseVariableStatement(kStatement, ok);
       }
       // Fall through.
     default:
       return ParseExpressionOrLabelledStatement(ok);
   }
 }

References v8::internal::ParserBase< PreParserTraits >::allow_harmony_scoping(), v8::internal::Scanner::Location::beg_pos, v8::internal::BREAK, CHECK_OK, v8::internal::CONST, DCHECK, v8::internal::PreParserStatement::Default(), v8::internal::Scanner::Location::end_pos, kStatement, v8::internal::LET, v8::internal::Scanner::location(), ParseBlock(), ParseBreakStatement(), ParseClassDeclaration(), ParseContinueStatement(), ParseDebuggerStatement(), ParseDoWhileStatement(), ParseExpressionOrLabelledStatement(), ParseForStatement(), ParseFunctionDeclaration(), ParseIfStatement(), ParseReturnStatement(), ParseSwitchStatement(), ParseThrowStatement(), ParseTryStatement(), ParseVariableStatement(), ParseWhileStatement(), ParseWithStatement(), v8::internal::Scanner::peek_location(), v8::internal::PreParserTraits::ReportMessageAt(), v8::internal::ParserBase< PreParserTraits >::scanner(), v8::internal::STRICT, v8::internal::ParserBase< PreParserTraits >::strict_mode(), and v8::internal::VAR.

Referenced by ParseBlock(), ParseDoWhileStatement(), ParseExpressionOrLabelledStatement(), ParseForStatement(), ParseIfStatement(), ParseSourceElement(), ParseSwitchStatement(), ParseWhileStatement(), and ParseWithStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseSwitchStatement()

PreParser::Statement v8::internal::PreParser::ParseSwitchStatement ( bool * ok )

private

Definition at line 621 of file preparser.cc.

                                                            {
   // SwitchStatement ::
   //   'switch' '(' Expression ')' '{' CaseClause* '}'
  
   Expect(Token::SWITCH, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
  
   Expect(Token::LBRACE, CHECK_OK);
   Token::Value token = peek();
   while (token != Token::RBRACE) {
     if (token == Token::CASE) {
       Expect(Token::CASE, CHECK_OK);
       ParseExpression(true, CHECK_OK);
     } else {
       Expect(Token::DEFAULT, CHECK_OK);
     }
     Expect(Token::COLON, CHECK_OK);
     token = peek();
     while (token != Token::CASE &&
            token != Token::DEFAULT &&
            token != Token::RBRACE) {
       ParseStatement(CHECK_OK);
       token = peek();
     }
   }
   Expect(Token::RBRACE, ok);
   return Statement::Default();
 }

References CASE, CHECK_OK, v8::internal::DEFAULT, v8::internal::PreParserStatement::Default(), v8::internal::ParserBase< PreParserTraits >::Expect(), v8::internal::ParserBase< PreParserTraits >::ParseExpression(), and ParseStatement().

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseThrowStatement()

PreParser::Statement v8::internal::PreParser::ParseThrowStatement ( bool * ok )

private

Definition at line 744 of file preparser.cc.

                                                           {
   // ThrowStatement ::
   //   'throw' [no line terminator] Expression ';'
  
   Expect(Token::THROW, CHECK_OK);
   if (scanner()->HasAnyLineTerminatorBeforeNext()) {
     ReportMessageAt(scanner()->location(), "newline_after_throw");
     *ok = false;
     return Statement::Default();
   }
   ParseExpression(true, CHECK_OK);
   ExpectSemicolon(ok);
   return Statement::Default();
 }

References CHECK_OK, v8::internal::PreParserStatement::Default(), v8::internal::ParserBase< PreParserTraits >::Expect(), v8::internal::ParserBase< PreParserTraits >::ExpectSemicolon(), v8::internal::ParserBase< PreParserTraits >::ParseExpression(), v8::internal::ParserBase< PreParserTraits >::ReportMessageAt(), and v8::internal::ParserBase< PreParserTraits >::scanner().

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseTryStatement()

PreParser::Statement v8::internal::PreParser::ParseTryStatement ( bool * ok )

private

Definition at line 760 of file preparser.cc.

                                                         {
   // TryStatement ::
   //   'try' Block Catch
   //   'try' Block Finally
   //   'try' Block Catch Finally
   //
   // Catch ::
   //   'catch' '(' Identifier ')' Block
   //
   // Finally ::
   //   'finally' Block
  
   Expect(Token::TRY, CHECK_OK);
  
   ParseBlock(CHECK_OK);
  
   Token::Value tok = peek();
   if (tok != Token::CATCH && tok != Token::FINALLY) {
     ReportMessageAt(scanner()->location(), "no_catch_or_finally");
     *ok = false;
     return Statement::Default();
   }
   if (tok == Token::CATCH) {
     Consume(Token::CATCH);
     Expect(Token::LPAREN, CHECK_OK);
     ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
     Expect(Token::RPAREN, CHECK_OK);
     {
       PreParserScope with_scope(scope_, WITH_SCOPE);
       BlockState block_state(&scope_, &with_scope);
       ParseBlock(CHECK_OK);
     }
     tok = peek();
   }
   if (tok == Token::FINALLY) {
     Consume(Token::FINALLY);
     ParseBlock(CHECK_OK);
   }
   return Statement::Default();
 }

References CHECK_OK, v8::internal::ParserBase< PreParserTraits >::Consume(), v8::internal::PreParserStatement::Default(), v8::internal::ParserBase< PreParserTraits >::Expect(), v8::internal::ParserBase< PreParserTraits >::kDontAllowEvalOrArguments, ParseBlock(), v8::internal::ParserBase< PreParserTraits >::ParseIdentifier(), v8::internal::ParserBase< PreParserTraits >::ReportMessageAt(), v8::internal::ParserBase< PreParserTraits >::scanner(), v8::internal::ParserBase< PreParserTraits >::scope_, and v8::internal::WITH_SCOPE.

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseV8Intrinsic()

PreParser::Expression v8::internal::PreParser::ParseV8Intrinsic ( bool * ok )

private

Definition at line 942 of file preparser.cc.

                                                         {
   // CallRuntime ::
   //   '%' Identifier Arguments
   Expect(Token::MOD, CHECK_OK);
   if (!allow_natives_syntax()) {
     *ok = false;
     return Expression::Default();
   }
   // Allow "eval" or "arguments" for backward compatibility.
   ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
   ParseArguments(ok);
  
   return Expression::Default();
 }

References v8::internal::ParserBase< PreParserTraits >::allow_natives_syntax(), CHECK_OK, v8::internal::PreParserExpression::Default(), v8::internal::ParserBase< PreParserTraits >::Expect(), v8::internal::ParserBase< PreParserTraits >::kAllowEvalOrArguments, v8::internal::ParserBase< PreParserTraits >::ParseArguments(), and v8::internal::ParserBase< PreParserTraits >::ParseIdentifier().

Referenced by v8::internal::PreParserTraits::ParseV8Intrinsic().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseVariableDeclarations()

PreParser::Statement v8::internal::PreParser::ParseVariableDeclarations	(	VariableDeclarationContext	var_context,
		VariableDeclarationProperties *	decl_props,
		int *	num_decl,
		bool *	ok
	)

private

Definition at line 411 of file preparser.cc.

               {
   // VariableDeclarations ::
   //   ('var' | 'const') (Identifier ('=' AssignmentExpression)?)+[',']
   //
   // The ES6 Draft Rev3 specifies the following grammar for const declarations
   //
   // ConstDeclaration ::
   //   const ConstBinding (',' ConstBinding)* ';'
   // ConstBinding ::
   //   Identifier '=' AssignmentExpression
   //
   // TODO(ES6):
   // ConstBinding ::
   //   BindingPattern '=' AssignmentExpression
   bool require_initializer = false;
   if (peek() == Token::VAR) {
     Consume(Token::VAR);
   } else if (peek() == Token::CONST) {
     // TODO(ES6): The ES6 Draft Rev4 section 12.2.2 reads:
     //
     // ConstDeclaration : const ConstBinding (',' ConstBinding)* ';'
     //
     // * It is a Syntax Error if the code that matches this production is not
     //   contained in extended code.
     //
     // However disallowing const in sloppy mode will break compatibility with
     // existing pages. Therefore we keep allowing const with the old
     // non-harmony semantics in sloppy mode.
     Consume(Token::CONST);
     if (strict_mode() == STRICT) {
       if (allow_harmony_scoping()) {
         if (var_context != kSourceElement && var_context != kForStatement) {
           ReportMessageAt(scanner()->peek_location(), "unprotected_const");
           *ok = false;
           return Statement::Default();
         }
         require_initializer = true;
       } else {
         Scanner::Location location = scanner()->peek_location();
         ReportMessageAt(location, "strict_const");
         *ok = false;
         return Statement::Default();
       }
     }
   } else if (peek() == Token::LET && strict_mode() == STRICT) {
     Consume(Token::LET);
     if (var_context != kSourceElement && var_context != kForStatement) {
       ReportMessageAt(scanner()->peek_location(), "unprotected_let");
       *ok = false;
       return Statement::Default();
     }
   } else {
     *ok = false;
     return Statement::Default();
   }
  
   // The scope of a var/const declared variable anywhere inside a function
   // is the entire function (ECMA-262, 3rd, 10.1.3, and 12.2). The scope
   // of a let declared variable is the scope of the immediately enclosing
   // block.
   int nvars = 0;  // the number of variables declared
   do {
     // Parse variable name.
     if (nvars > 0) Consume(Token::COMMA);
     ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
     nvars++;
     if (peek() == Token::ASSIGN || require_initializer) {
       Expect(Token::ASSIGN, CHECK_OK);
       ParseAssignmentExpression(var_context != kForStatement, CHECK_OK);
       if (decl_props != NULL) *decl_props = kHasInitializers;
     }
   } while (peek() == Token::COMMA);
  
   if (num_decl != NULL) *num_decl = nvars;
   return Statement::Default();
 }

Referenced by ParseForStatement(), and ParseVariableStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseVariableStatement()

PreParser::Statement v8::internal::PreParser::ParseVariableStatement	(	VariableDeclarationContext	var_context,
		bool *	ok
	)

private

Definition at line 391 of file preparser.cc.

               {
   // VariableStatement ::
   //   VariableDeclarations ';'
  
   Statement result = ParseVariableDeclarations(var_context,
                                                NULL,
                                                NULL,
                                                CHECK_OK);
   ExpectSemicolon(CHECK_OK);
   return result;
 }

References CHECK_OK, v8::internal::ParserBase< PreParserTraits >::ExpectSemicolon(), NULL, and ParseVariableDeclarations().

Referenced by ParseSourceElement(), and ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseWhileStatement()

PreParser::Statement v8::internal::PreParser::ParseWhileStatement ( bool * ok )

private

Definition at line 668 of file preparser.cc.

                                                           {
   // WhileStatement ::
   //   'while' '(' Expression ')' Statement
  
   Expect(Token::WHILE, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
   ParseStatement(ok);
   return Statement::Default();
 }

References CHECK_OK, v8::internal::PreParserStatement::Default(), v8::internal::ParserBase< PreParserTraits >::Expect(), v8::internal::ParserBase< PreParserTraits >::ParseExpression(), and ParseStatement().

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseWithStatement()

PreParser::Statement v8::internal::PreParser::ParseWithStatement ( bool * ok )

private

Definition at line 601 of file preparser.cc.

                                                          {
   // WithStatement ::
   //   'with' '(' Expression ')' Statement
   Expect(Token::WITH, CHECK_OK);
   if (strict_mode() == STRICT) {
     ReportMessageAt(scanner()->location(), "strict_mode_with");
     *ok = false;
     return Statement::Default();
   }
   Expect(Token::LPAREN, CHECK_OK);
   ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
  
   PreParserScope with_scope(scope_, WITH_SCOPE);
   BlockState block_state(&scope_, &with_scope);
   ParseStatement(CHECK_OK);
   return Statement::Default();
 }

References CHECK_OK, v8::internal::PreParserStatement::Default(), v8::internal::ParserBase< PreParserTraits >::Expect(), v8::internal::ParserBase< PreParserTraits >::ParseExpression(), ParseStatement(), v8::internal::ParserBase< PreParserTraits >::ReportMessageAt(), v8::internal::ParserBase< PreParserTraits >::scanner(), v8::internal::ParserBase< PreParserTraits >::scope_, v8::internal::STRICT, v8::internal::ParserBase< PreParserTraits >::strict_mode(), and v8::internal::WITH_SCOPE.

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PreParseLazyFunction()

PreParser::PreParseResult v8::internal::PreParser::PreParseLazyFunction	(	StrictMode	strict_mode,
		bool	is_generator,
		ParserRecorder *	log
	)

Definition at line 121 of file preparser.cc.

                                                                     {
   log_ = log;
   // Lazy functions always have trivial outer scopes (no with/catch scopes).
   PreParserScope top_scope(scope_, GLOBAL_SCOPE);
   FunctionState top_state(&function_state_, &scope_, &top_scope, NULL,
                           this->ast_value_factory());
   scope_->SetStrictMode(strict_mode);
   PreParserScope function_scope(scope_, FUNCTION_SCOPE);
   FunctionState function_state(&function_state_, &scope_, &function_scope, NULL,
                                this->ast_value_factory());
   function_state.set_is_generator(is_generator);
   DCHECK_EQ(Token::LBRACE, scanner()->current_token());
   bool ok = true;
   int start_position = peek_position();
   ParseLazyFunctionLiteralBody(&ok);
   if (stack_overflow()) return kPreParseStackOverflow;
   if (!ok) {
     ReportUnexpectedToken(scanner()->current_token());
   } else {
     DCHECK_EQ(Token::RBRACE, scanner()->peek());
     if (scope_->strict_mode() == STRICT) {
       int end_pos = scanner()->location().end_pos;
       CheckOctalLiteral(start_position, end_pos, &ok);
     }
   }
   return kPreParseSuccess;
 }

Referenced by v8::internal::Parser::ParseLazyFunctionBodyWithPreParser().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PreParseProgram()

PreParseResult v8::internal::PreParser::PreParseProgram ( )

inline

Definition at line 1428 of file preparser.h.

                                    {
     PreParserScope scope(scope_, GLOBAL_SCOPE);
     FunctionState top_scope(&function_state_, &scope_, &scope);
     bool ok = true;
     int start_position = scanner()->peek_location().beg_pos;
     ParseSourceElements(Token::EOS, &ok);
     if (stack_overflow()) return kPreParseStackOverflow;
     if (!ok) {
       ReportUnexpectedToken(scanner()->current_token());
     } else if (scope_->strict_mode() == STRICT) {
       CheckOctalLiteral(start_position, scanner()->location().end_pos, &ok);
     }
     return kPreParseSuccess;
   }

References v8::internal::Scanner::Location::beg_pos, v8::internal::ParserBase< PreParserTraits >::CheckOctalLiteral(), v8::internal::ParserBase< PreParserTraits >::function_state_, v8::internal::GLOBAL_SCOPE, kPreParseStackOverflow, kPreParseSuccess, ParseSourceElements(), v8::internal::Scanner::peek_location(), v8::internal::ParserBase< PreParserTraits >::ReportUnexpectedToken(), v8::internal::ParserBase< PreParserTraits >::scanner(), v8::internal::ParserBase< PreParserTraits >::scope_, v8::internal::ParserBase< PreParserTraits >::stack_overflow(), and v8::internal::STRICT.

Here is the call graph for this function:

◆ SkipLazyFunctionBody()

void v8::internal::PreParser::SkipLazyFunctionBody	(	PreParserIdentifier	function_name,
		int *	materialized_literal_count,
		int *	expected_property_count,
		bool *	ok
	)

inlineprivate

Friends And Related Function Documentation

◆ PreParserTraits

friend class PreParserTraits

friend

Definition at line 1456 of file preparser.h.

The documentation for this class was generated from the following files:

/mnt/V8SourceCode/src/preparser.h
/mnt/V8SourceCode/src/preparser.cc

Public Types

Public Member Functions

Private Types

Private Member Functions

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Expression

◆ Identifier

◆ Statement

Member Enumeration Documentation

◆ PreParseResult

◆ SourceElements

◆ VariableDeclarationContext

◆ VariableDeclarationProperties

Constructor & Destructor Documentation

◆ PreParser()

Member Function Documentation

◆ CheckInOrOf()

◆ ParseBlock()

◆ ParseBreakStatement()

◆ ParseClassDeclaration()

◆ ParseConditionalExpression()

◆ ParseContinueStatement()

◆ ParseDebuggerStatement()

◆ ParseDoWhileStatement()

◆ ParseEagerFunctionBody()

◆ ParseExpressionOrLabelledStatement()

◆ ParseForStatement()

◆ ParseFunctionDeclaration()

◆ ParseFunctionLiteral()

◆ ParseIfStatement()

◆ ParseLazyFunctionLiteralBody()

◆ ParseObjectLiteral()

◆ ParseReturnStatement()

◆ ParseSourceElement()

◆ ParseSourceElements()

◆ ParseStatement()

◆ ParseSwitchStatement()

◆ ParseThrowStatement()

◆ ParseTryStatement()

◆ ParseV8Intrinsic()

◆ ParseVariableDeclarations()

◆ ParseVariableStatement()

◆ ParseWhileStatement()

◆ ParseWithStatement()

◆ PreParseLazyFunction()

◆ PreParseProgram()

◆ SkipLazyFunctionBody()

Friends And Related Function Documentation

◆ PreParserTraits