#include <preparser.h>

Inheritance diagram for v8::internal::ParserBase< Traits >:

Collaboration diagram for v8::internal::ParserBase< Traits >:

Classes
class	BASE_EMBEDDED

class	ObjectLiteralChecker

Public Types
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
	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)

Protected Types
enum	AllowEvalOrArgumentsAsIdentifier { kAllowEvalOrArguments , kDontAllowEvalOrArguments }

enum	Mode { PARSE_LAZILY , PARSE_EAGERLY }

enum	PropertyKind { kNone = 0 , kGetterProperty = 1 , kSetterProperty = 2 , kValueProperty = 7 , kValueFlag = 4 }

Protected Member Functions
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
static int	Precedence (Token::Value token, bool accept_IN)

Protected Attributes
bool	parenthesized_function_

Traits::Type::Scope *	scope_

FunctionState *	function_state_

v8::Extension *	extension_

FuncNameInferrer *	fni_

ParserRecorder *	log_

Mode	mode_

uintptr_t	stack_limit_

Private Attributes
Scanner *	scanner_

bool	stack_overflow_

bool	allow_lazy_

bool	allow_natives_syntax_

bool	allow_arrow_functions_

bool	allow_harmony_object_literals_

Traits::Type::Zone *	zone_

AstNode::IdGen *	ast_node_id_gen_

Friends
class	Traits::Checkpoint

Detailed Description

template<typename Traits>
class v8::internal::ParserBase< Traits >

Definition at line 62 of file preparser.h.

Member Typedef Documentation

◆ ExpressionT

template<typename Traits >

typedef Traits::Type::Expression v8::internal::ParserBase< Traits >::ExpressionT

Definition at line 65 of file preparser.h.

◆ FunctionLiteralT

template<typename Traits >

typedef Traits::Type::FunctionLiteral v8::internal::ParserBase< Traits >::FunctionLiteralT

Definition at line 67 of file preparser.h.

◆ IdentifierT

template<typename Traits >

typedef Traits::Type::Identifier v8::internal::ParserBase< Traits >::IdentifierT

Definition at line 66 of file preparser.h.

◆ LiteralT

template<typename Traits >

typedef Traits::Type::Literal v8::internal::ParserBase< Traits >::LiteralT

Definition at line 68 of file preparser.h.

◆ ObjectLiteralPropertyT

template<typename Traits >

typedef Traits::Type::ObjectLiteralProperty v8::internal::ParserBase< Traits >::ObjectLiteralPropertyT

Definition at line 69 of file preparser.h.

Member Enumeration Documentation

◆ AllowEvalOrArgumentsAsIdentifier

template<typename Traits >

enum v8::internal::ParserBase::AllowEvalOrArgumentsAsIdentifier

protected

Enumerator
kAllowEvalOrArguments
kDontAllowEvalOrArguments

Definition at line 128 of file preparser.h.

                                         {
     kAllowEvalOrArguments,
     kDontAllowEvalOrArguments
   };

◆ Mode

template<typename Traits >

enum v8::internal::ParserBase::Mode

protected

Enumerator
PARSE_LAZILY
PARSE_EAGERLY

Definition at line 133 of file preparser.h.

             {
     PARSE_LAZILY,
     PARSE_EAGERLY
   };

◆ PropertyKind

template<typename Traits >

enum v8::internal::ParserBase::PropertyKind

protected

Enumerator
kNone
kGetterProperty
kSetterProperty
kValueProperty
kValueFlag

Definition at line 528 of file preparser.h.

                     {
     kNone = 0,
     // Bit patterns representing different object literal property types.
     kGetterProperty = 1,
     kSetterProperty = 2,
     kValueProperty = 7,
     // Helper constants.
     kValueFlag = 4
   };

Constructor & Destructor Documentation

◆ ParserBase()

template<typename Traits >

v8::internal::ParserBase< Traits >::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
	)

inline

Definition at line 71 of file preparser.h.

       : Traits(this_object),
         parenthesized_function_(false),
         scope_(NULL),
         function_state_(NULL),
         extension_(extension),
         fni_(NULL),
         log_(log),
         mode_(PARSE_EAGERLY),  // Lazy mode must be set explicitly.
         stack_limit_(stack_limit),
         scanner_(scanner),
         stack_overflow_(false),
         allow_lazy_(false),
         allow_natives_syntax_(false),
         allow_arrow_functions_(false),
         allow_harmony_object_literals_(false),
         zone_(zone),
         ast_node_id_gen_(ast_node_id_gen) {}

Member Function Documentation

◆ allow_arrow_functions()

template<typename Traits >

bool v8::internal::ParserBase< Traits >::allow_arrow_functions ( ) const

inline

Definition at line 97 of file preparser.h.

97 { return allow_arrow_functions_; }

References v8::internal::ParserBase< Traits >::allow_arrow_functions_.

◆ allow_classes()

template<typename Traits >

bool v8::internal::ParserBase< Traits >::allow_classes ( ) const

inline

Definition at line 103 of file preparser.h.

103 { return scanner()->HarmonyClasses(); }

v8::internal::Scanner::HarmonyClasses

bool HarmonyClasses() const

Definition: scanner.h:441

References v8::internal::Scanner::HarmonyClasses(), and v8::internal::ParserBase< Traits >::scanner().

Here is the call graph for this function:

◆ allow_harmony_numeric_literals()

template<typename Traits >

bool v8::internal::ParserBase< Traits >::allow_harmony_numeric_literals ( ) const

inline

Definition at line 100 of file preparser.h.

                                               {
     return scanner()->HarmonyNumericLiterals();
   }

References v8::internal::Scanner::HarmonyNumericLiterals(), and v8::internal::ParserBase< Traits >::scanner().

Here is the call graph for this function:

◆ allow_harmony_object_literals()

template<typename Traits >

bool v8::internal::ParserBase< Traits >::allow_harmony_object_literals ( ) const

inline

Definition at line 104 of file preparser.h.

                                              {
     return allow_harmony_object_literals_;
   }

References v8::internal::ParserBase< Traits >::allow_harmony_object_literals_.

◆ allow_harmony_scoping()

template<typename Traits >

bool v8::internal::ParserBase< Traits >::allow_harmony_scoping ( ) const

inline

Definition at line 99 of file preparser.h.

99 { return scanner()->HarmonyScoping(); }

v8::internal::Scanner::HarmonyScoping

bool HarmonyScoping() const

Definition: scanner.h:423

References v8::internal::Scanner::HarmonyScoping(), and v8::internal::ParserBase< Traits >::scanner().

Here is the call graph for this function:

◆ allow_lazy()

template<typename Traits >

bool v8::internal::ParserBase< Traits >::allow_lazy ( ) const

inline

Definition at line 95 of file preparser.h.

95 { return allow_lazy_; }

References v8::internal::ParserBase< Traits >::allow_lazy_.

◆ allow_modules()

template<typename Traits >

bool v8::internal::ParserBase< Traits >::allow_modules ( ) const

inline

Definition at line 98 of file preparser.h.

98 { return scanner()->HarmonyModules(); }

v8::internal::Scanner::HarmonyModules

bool HarmonyModules() const

Definition: scanner.h:429

References v8::internal::Scanner::HarmonyModules(), and v8::internal::ParserBase< Traits >::scanner().

Here is the call graph for this function:

◆ allow_natives_syntax()

template<typename Traits >

bool v8::internal::ParserBase< Traits >::allow_natives_syntax ( ) const

inline

Definition at line 96 of file preparser.h.

96 { return allow_natives_syntax_; }

References v8::internal::ParserBase< Traits >::allow_natives_syntax_.

◆ ast_node_id_gen()

template<typename Traits >

AstNode::IdGen* v8::internal::ParserBase< Traits >::ast_node_id_gen ( ) const

inlineprotected

Definition at line 292 of file preparser.h.

292 { return ast_node_id_gen_; }

References v8::internal::ParserBase< Traits >::ast_node_id_gen_.

◆ Check()

template<typename Traits >

bool v8::internal::ParserBase< Traits >::Check ( Token::Value token )

inlineprotected

Definition at line 319 of file preparser.h.

                                {
     Token::Value next = peek();
     if (next == token) {
       Consume(next);
       return true;
     }
     return false;
   }

References v8::internal::ParserBase< Traits >::Consume().

Here is the call graph for this function:

◆ CheckAndRewriteReferenceExpression()

template<typename Traits >

ParserBase< Traits >::ExpressionT v8::internal::ParserBase< Traits >::CheckAndRewriteReferenceExpression	(	ExpressionT	expression,
		Scanner::Location	location,
		const char *	message,
		bool *	ok
	)

protected

Definition at line 2782 of file preparser.h.

                                                              {
   if (strict_mode() == STRICT && this->IsIdentifier(expression) &&
       this->IsEvalOrArguments(this->AsIdentifier(expression))) {
     this->ReportMessageAt(location, "strict_eval_arguments", false);
     *ok = false;
     return this->EmptyExpression();
   } else if (expression->IsValidReferenceExpression()) {
     return expression;
   } else if (expression->IsCall()) {
     // If it is a call, make it a runtime error for legacy web compatibility.
     // Rewrite `expr' to `expr[throw ReferenceError]'.
     int pos = location.beg_pos;
     ExpressionT error = this->NewThrowReferenceError(message, pos);
     return factory()->NewProperty(expression, error, pos);
   } else {
     this->ReportMessageAt(location, message, true);
     *ok = false;
     return this->EmptyExpression();
   }
 }

References v8::internal::Scanner::Location::beg_pos, and v8::internal::STRICT.

◆ CheckContextualKeyword()

template<typename Traits >

bool v8::internal::ParserBase< Traits >::CheckContextualKeyword ( Vector< const char > keyword )

inlineprotected

Definition at line 361 of file preparser.h.

                                                           {
     if (peek() == Token::IDENTIFIER &&
         scanner()->is_next_contextual_keyword(keyword)) {
       Consume(Token::IDENTIFIER);
       return true;
     }
     return false;
   }

References v8::internal::ParserBase< Traits >::Consume(), and v8::internal::ParserBase< Traits >::scanner().

Here is the call graph for this function:

◆ CheckOctalLiteral()

template<typename Traits >

void v8::internal::ParserBase< Traits >::CheckOctalLiteral	(	int	beg_pos,
		int	end_pos,
		bool *	ok
	)

inlineprotected

Definition at line 381 of file preparser.h.

                                                              {
     Scanner::Location octal = scanner()->octal_position();
     if (octal.IsValid() && beg_pos <= octal.beg_pos &&
         octal.end_pos <= end_pos) {
       ReportMessageAt(octal, "strict_octal_literal");
       scanner()->clear_octal_position();
       *ok = false;
     }
   }

References v8::internal::Scanner::Location::beg_pos, v8::internal::Scanner::clear_octal_position(), v8::internal::Scanner::Location::end_pos, v8::internal::Scanner::Location::IsValid(), v8::internal::Scanner::octal_position(), v8::internal::ParserBase< Traits >::ReportMessageAt(), and v8::internal::ParserBase< Traits >::scanner().

Here is the call graph for this function:

◆ CheckStrictFunctionNameAndParameters()

template<typename Traits >

void v8::internal::ParserBase< Traits >::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
	)

inlineprotected

Definition at line 394 of file preparser.h.

                 {
     if (this->IsEvalOrArguments(function_name)) {
       Traits::ReportMessageAt(function_name_loc, "strict_eval_arguments");
       *ok = false;
       return;
     }
     if (function_name_is_strict_reserved) {
       Traits::ReportMessageAt(function_name_loc, "unexpected_strict_reserved");
       *ok = false;
       return;
     }
     if (eval_args_error_loc.IsValid()) {
       Traits::ReportMessageAt(eval_args_error_loc, "strict_eval_arguments");
       *ok = false;
       return;
     }
     if (dupe_error_loc.IsValid()) {
       Traits::ReportMessageAt(dupe_error_loc, "strict_param_dupe");
       *ok = false;
       return;
     }
     if (reserved_loc.IsValid()) {
       Traits::ReportMessageAt(reserved_loc, "unexpected_strict_reserved");
       *ok = false;
       return;
     }
   }

References v8::internal::Scanner::Location::IsValid().

Here is the call graph for this function:

◆ Consume()

template<typename Traits >

void v8::internal::ParserBase< Traits >::Consume ( Token::Value token )

inlineprotected

Definition at line 312 of file preparser.h.

                                  {
     Token::Value next = Next();
     USE(next);
     USE(token);
     DCHECK(next == token);
   }

References DCHECK, and USE().

Referenced by v8::internal::ParserBase< Traits >::Check(), and v8::internal::ParserBase< Traits >::CheckContextualKeyword().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Expect()

template<typename Traits >

void v8::internal::ParserBase< Traits >::Expect	(	Token::Value	token,
		bool *	ok
	)

inlineprotected

Definition at line 328 of file preparser.h.

                                           {
     Token::Value next = Next();
     if (next != token) {
       ReportUnexpectedToken(next);
       *ok = false;
     }
   }

References v8::internal::ParserBase< Traits >::ReportUnexpectedToken().

Referenced by v8::internal::ParserBase< Traits >::ExpectContextualKeyword(), and v8::internal::ParserBase< Traits >::ExpectSemicolon().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExpectContextualKeyword()

template<typename Traits >

void v8::internal::ParserBase< Traits >::ExpectContextualKeyword	(	Vector< const char >	keyword,
		bool *	ok
	)

inlineprotected

Definition at line 370 of file preparser.h.

                                                                      {
     Expect(Token::IDENTIFIER, ok);
     if (!*ok) return;
     if (!scanner()->is_literal_contextual_keyword(keyword)) {
       ReportUnexpectedToken(scanner()->current_token());
       *ok = false;
     }
   }

References v8::internal::ParserBase< Traits >::Expect(), v8::internal::ParserBase< Traits >::ReportUnexpectedToken(), and v8::internal::ParserBase< Traits >::scanner().

Here is the call graph for this function:

◆ ExpectSemicolon()

template<typename Traits >

void v8::internal::ParserBase< Traits >::ExpectSemicolon ( bool * ok )

inlineprotected

Definition at line 336 of file preparser.h.

                                  {
     // Check for automatic semicolon insertion according to
     // the rules given in ECMA-262, section 7.9, page 21.
     Token::Value tok = peek();
     if (tok == Token::SEMICOLON) {
       Next();
       return;
     }
     if (scanner()->HasAnyLineTerminatorBeforeNext() ||
         tok == Token::RBRACE ||
         tok == Token::EOS) {
       return;
     }
     Expect(Token::SEMICOLON, ok);
   }

References v8::internal::ParserBase< Traits >::Expect(), and v8::internal::ParserBase< Traits >::scanner().

Here is the call graph for this function:

◆ factory()

template<typename Traits >

Traits::Type::Factory* v8::internal::ParserBase< Traits >::factory ( )

inlineprotected

Definition at line 436 of file preparser.h.

                                         {
     return function_state_->factory();
   }

References v8::internal::ParserBase< Traits >::function_state_.

Referenced by v8::internal::ParserTraits::NewThrowError().

Here is the caller graph for this function:

◆ INLINE() [1/2]

template<typename Traits >

v8::internal::ParserBase< Traits >::INLINE ( Token::Value Next() )

inlineprotected

Definition at line 299 of file preparser.h.

                             {
     if (stack_overflow_) return Token::ILLEGAL;
     {
       if (GetCurrentStackPosition() < stack_limit_) {
         // Any further calls to Next or peek will return the illegal token.
         // The current call must return the next token, which might already
         // have been peek'ed.
         stack_overflow_ = true;
       }
     }
     return scanner()->Next();
   }

References v8::internal::GetCurrentStackPosition(), v8::internal::Scanner::Next(), v8::internal::ParserBase< Traits >::scanner(), v8::internal::ParserBase< Traits >::stack_limit_, and v8::internal::ParserBase< Traits >::stack_overflow_.

Here is the call graph for this function:

◆ INLINE() [2/2]

template<typename Traits >

v8::internal::ParserBase< Traits >::INLINE ( Token::Value peek() )

inlineprotected

Definition at line 294 of file preparser.h.

                             {
     if (stack_overflow_) return Token::ILLEGAL;
     return scanner()->peek();
   }

References v8::internal::Scanner::peek(), v8::internal::ParserBase< Traits >::scanner(), and v8::internal::ParserBase< Traits >::stack_overflow_.

Here is the call graph for this function:

◆ is_generator()

template<typename Traits >

bool v8::internal::ParserBase< Traits >::is_generator ( ) const

inlineprotected

Definition at line 441 of file preparser.h.

441 { return function_state_->is_generator(); }

References v8::internal::ParserBase< Traits >::function_state_.

Referenced by v8::internal::ParserBase< Traits >::BASE_EMBEDDED::set_generator_object_variable(), and v8::internal::ParserBase< Traits >::BASE_EMBEDDED::set_is_generator().

Here is the caller graph for this function:

◆ mode()

template<typename Traits >

Mode v8::internal::ParserBase< Traits >::mode ( ) const

inlineprotected

Definition at line 290 of file preparser.h.

290 { return mode_; }

References v8::internal::ParserBase< Traits >::mode_.

Referenced by v8::internal::ParserBase< Traits >::BASE_EMBEDDED::ParsingModeScope().

Here is the caller graph for this function:

◆ ParseArguments()

template<class Traits >

Traits::Type::ExpressionList v8::internal::ParserBase< Traits >::ParseArguments ( bool * ok )

protected

Definition at line 2106 of file preparser.h.

               {
   // Arguments ::
   //   '(' (AssignmentExpression)*[','] ')'
  
   typename Traits::Type::ExpressionList result =
       this->NewExpressionList(4, zone_);
   Expect(Token::LPAREN, CHECK_OK_CUSTOM(NullExpressionList));
   bool done = (peek() == Token::RPAREN);
   while (!done) {
     ExpressionT argument = this->ParseAssignmentExpression(
         true, CHECK_OK_CUSTOM(NullExpressionList));
     result->Add(argument, zone_);
     if (result->length() > Code::kMaxArguments) {
       ReportMessage("too_many_arguments");
       *ok = false;
       return this->NullExpressionList();
     }
     done = (peek() == Token::RPAREN);
     if (!done) {
       // Need {} because of the CHECK_OK_CUSTOM macro.
       Expect(Token::COMMA, CHECK_OK_CUSTOM(NullExpressionList));
     }
   }
   Expect(Token::RPAREN, CHECK_OK_CUSTOM(NullExpressionList));
   return result;
 }

References CHECK_OK_CUSTOM, COMMA, and v8::internal::Code::kMaxArguments.

◆ ParseArrayLiteral()

template<class Traits >

ParserBase< Traits >::ExpressionT v8::internal::ParserBase< Traits >::ParseArrayLiteral ( bool * ok )

protected

Definition at line 1888 of file preparser.h.

               {
   // ArrayLiteral ::
   //   '[' Expression? (',' Expression?)* ']'
  
   int pos = peek_position();
   typename Traits::Type::ExpressionList values =
       this->NewExpressionList(4, zone_);
   Expect(Token::LBRACK, CHECK_OK);
   while (peek() != Token::RBRACK) {
     ExpressionT elem = this->EmptyExpression();
     if (peek() == Token::COMMA) {
       elem = this->GetLiteralTheHole(peek_position(), factory());
     } else {
       elem = this->ParseAssignmentExpression(true, CHECK_OK);
     }
     values->Add(elem, zone_);
     if (peek() != Token::RBRACK) {
       Expect(Token::COMMA, CHECK_OK);
     }
   }
   Expect(Token::RBRACK, CHECK_OK);
  
   // Update the scope information before the pre-parsing bailout.
   int literal_index = function_state_->NextMaterializedLiteralIndex();
  
   return factory()->NewArrayLiteral(values, literal_index, pos);
 }

References CHECK_OK, and COMMA.

◆ ParseArrowFunctionLiteral()

template<class Traits >

ParserBase< Traits >::ExpressionT v8::internal::ParserBase< Traits >::ParseArrowFunctionLiteral	(	int	start_pos,
		ExpressionT	params_ast,
		bool *	ok
	)

protected

Definition at line 2610 of file preparser.h.

                                                  {
   // TODO(aperez): Change this to use ARROW_SCOPE
   typename Traits::Type::ScopePtr scope =
       this->NewScope(scope_, FUNCTION_SCOPE);
   typename Traits::Type::StatementList body;
   typename Traits::Type::AstProperties ast_properties;
   BailoutReason dont_optimize_reason = kNoReason;
   int num_parameters = -1;
   int materialized_literal_count = -1;
   int expected_property_count = -1;
   int handler_count = 0;
  
   {
     FunctionState function_state(&function_state_, &scope_, &scope, zone(),
                                  this->ast_value_factory(), ast_node_id_gen_);
     Scanner::Location dupe_error_loc = Scanner::Location::invalid();
     num_parameters = Traits::DeclareArrowParametersFromExpression(
         params_ast, scope_, &dupe_error_loc, ok);
     if (!*ok) {
       ReportMessageAt(
           Scanner::Location(start_pos, scanner()->location().beg_pos),
           "malformed_arrow_function_parameter_list");
       return this->EmptyExpression();
     }
  
     if (num_parameters > Code::kMaxArguments) {
       ReportMessageAt(Scanner::Location(params_ast->position(), position()),
                       "too_many_parameters");
       *ok = false;
       return this->EmptyExpression();
     }
  
     Expect(Token::ARROW, CHECK_OK);
  
     if (peek() == Token::LBRACE) {
       // Multiple statemente body
       Consume(Token::LBRACE);
       bool is_lazily_parsed =
           (mode() == PARSE_LAZILY && scope_->AllowsLazyCompilation());
       if (is_lazily_parsed) {
         body = this->NewStatementList(0, zone());
         this->SkipLazyFunctionBody(this->EmptyIdentifier(),
                                    &materialized_literal_count,
                                    &expected_property_count, CHECK_OK);
       } else {
         body = this->ParseEagerFunctionBody(
             this->EmptyIdentifier(), RelocInfo::kNoPosition, NULL,
             Token::INIT_VAR, false,  // Not a generator.
             CHECK_OK);
         materialized_literal_count =
             function_state.materialized_literal_count();
         expected_property_count = function_state.expected_property_count();
         handler_count = function_state.handler_count();
       }
     } else {
       // Single-expression body
       int pos = position();
       parenthesized_function_ = false;
       ExpressionT expression = ParseAssignmentExpression(true, CHECK_OK);
       body = this->NewStatementList(1, zone());
       body->Add(factory()->NewReturnStatement(expression, pos), zone());
       materialized_literal_count = function_state.materialized_literal_count();
       expected_property_count = function_state.expected_property_count();
       handler_count = function_state.handler_count();
     }
  
     scope->set_start_position(start_pos);
     scope->set_end_position(scanner()->location().end_pos);
  
     // Arrow function *parameter lists* are always checked as in strict mode.
     bool function_name_is_strict_reserved = false;
     Scanner::Location function_name_loc = Scanner::Location::invalid();
     Scanner::Location eval_args_error_loc = Scanner::Location::invalid();
     Scanner::Location reserved_loc = Scanner::Location::invalid();
     this->CheckStrictFunctionNameAndParameters(
         this->EmptyIdentifier(), function_name_is_strict_reserved,
         function_name_loc, eval_args_error_loc, dupe_error_loc, reserved_loc,
         CHECK_OK);
  
     // Validate strict mode.
     if (strict_mode() == STRICT) {
       CheckOctalLiteral(start_pos, scanner()->location().end_pos, CHECK_OK);
     }
  
     if (allow_harmony_scoping() && strict_mode() == STRICT)
       this->CheckConflictingVarDeclarations(scope, CHECK_OK);
  
     ast_properties = *factory()->visitor()->ast_properties();
     dont_optimize_reason = factory()->visitor()->dont_optimize_reason();
   }
  
   FunctionLiteralT function_literal = factory()->NewFunctionLiteral(
       this->EmptyIdentifierString(), this->ast_value_factory(), scope, body,
       materialized_literal_count, expected_property_count, handler_count,
       num_parameters, FunctionLiteral::kNoDuplicateParameters,
       FunctionLiteral::ANONYMOUS_EXPRESSION, FunctionLiteral::kIsFunction,
       FunctionLiteral::kNotParenthesized, FunctionKind::kArrowFunction,
       start_pos);
  
   function_literal->set_function_token_position(start_pos);
   function_literal->set_ast_properties(&ast_properties);
   function_literal->set_dont_optimize_reason(dont_optimize_reason);
  
   if (fni_ != NULL) this->InferFunctionName(fni_, function_literal);
  
   return function_literal;
 }

References CHECK_OK, v8::internal::FUNCTION_SCOPE, v8::internal::Scanner::Location::invalid(), v8::internal::kArrowFunction, v8::internal::Code::kMaxArguments, v8::internal::RelocInfo::kNoPosition, mode(), NULL, and v8::internal::STRICT.

Here is the call graph for this function:

◆ ParseAssignmentExpression()

template<class Traits >

ParserBase< Traits >::ExpressionT v8::internal::ParserBase< Traits >::ParseAssignmentExpression	(	bool	accept_IN,
		bool *	ok
	)

protected

Definition at line 2137 of file preparser.h.

                                                                       {
   // AssignmentExpression ::
   //   ConditionalExpression
   //   ArrowFunction
   //   YieldExpression
   //   LeftHandSideExpression AssignmentOperator AssignmentExpression
  
   Scanner::Location lhs_location = scanner()->peek_location();
  
   if (peek() == Token::YIELD && is_generator()) {
     return this->ParseYieldExpression(ok);
   }
  
   if (fni_ != NULL) fni_->Enter();
   typename Traits::Checkpoint checkpoint(this);
   ExpressionT expression =
       this->ParseConditionalExpression(accept_IN, CHECK_OK);
  
   if (allow_arrow_functions() && peek() == Token::ARROW) {
     checkpoint.Restore();
     expression = this->ParseArrowFunctionLiteral(lhs_location.beg_pos,
                                                  expression, CHECK_OK);
     return expression;
   }
  
   if (!Token::IsAssignmentOp(peek())) {
     if (fni_ != NULL) fni_->Leave();
     // Parsed conditional expression only (no assignment).
     return expression;
   }
  
   expression = this->CheckAndRewriteReferenceExpression(
       expression, lhs_location, "invalid_lhs_in_assignment", CHECK_OK);
   expression = this->MarkExpressionAsAssigned(expression);
  
   Token::Value op = Next();  // Get assignment operator.
   int pos = position();
   ExpressionT right = this->ParseAssignmentExpression(accept_IN, CHECK_OK);
  
   // TODO(1231235): We try to estimate the set of properties set by
   // constructors. We define a new property whenever there is an
   // assignment to a property of 'this'. We should probably only add
   // properties if we haven't seen them before. Otherwise we'll
   // probably overestimate the number of properties.
   if (op == Token::ASSIGN && this->IsThisProperty(expression)) {
     function_state_->AddProperty();
   }
  
   this->CheckAssigningFunctionLiteralToProperty(expression, right);
  
   if (fni_ != NULL) {
     // Check if the right hand side is a call to avoid inferring a
     // name if we're dealing with "a = function(){...}();"-like
     // expression.
     if ((op == Token::INIT_VAR
          || op == Token::INIT_CONST_LEGACY
          || op == Token::ASSIGN)
         && (!right->IsCall() && !right->IsCallNew())) {
       fni_->Infer();
     } else {
       fni_->RemoveLastFunction();
     }
     fni_->Leave();
   }
  
   return factory()->NewAssignment(op, expression, right, pos);
 }

References v8::internal::Scanner::Location::beg_pos, CHECK_OK, v8::internal::Token::IsAssignmentOp(), NULL, and v8::internal::YIELD.

Here is the call graph for this function:

◆ ParseBinaryExpression()

template<class Traits >

ParserBase< Traits >::ExpressionT v8::internal::ParserBase< Traits >::ParseBinaryExpression	(	int	prec,
		bool	accept_IN,
		bool *	ok
	)

protected

Definition at line 2278 of file preparser.h.

                                                                             {
   DCHECK(prec >= 4);
   ExpressionT x = this->ParseUnaryExpression(CHECK_OK);
   for (int prec1 = Precedence(peek(), accept_IN); prec1 >= prec; prec1--) {
     // prec1 >= 4
     while (Precedence(peek(), accept_IN) == prec1) {
       Token::Value op = Next();
       int pos = position();
       ExpressionT y = ParseBinaryExpression(prec1 + 1, accept_IN, CHECK_OK);
  
       if (this->ShortcutNumericLiteralBinaryExpression(&x, y, op, pos,
                                                        factory())) {
         continue;
       }
  
       // For now we distinguish between comparisons and other binary
       // operations.  (We could combine the two and get rid of this
       // code and AST node eventually.)
       if (Token::IsCompareOp(op)) {
         // We have a comparison.
         Token::Value cmp = op;
         switch (op) {
           case Token::NE: cmp = Token::EQ; break;
           case Token::NE_STRICT: cmp = Token::EQ_STRICT; break;
           default: break;
         }
         x = factory()->NewCompareOperation(cmp, x, y, pos);
         if (cmp != op) {
           // The comparison was negated - add a NOT.
           x = factory()->NewUnaryOperation(Token::NOT, x, pos);
         }
  
       } else {
         // We have a "normal" binary operation.
         x = factory()->NewBinaryOperation(op, x, y, pos);
       }
     }
   }
   return x;
 }

References CHECK_OK, DCHECK, v8::internal::EQ, v8::internal::Token::IsCompareOp(), v8::internal::NOT, and v8::base::internal::y.

Here is the call graph for this function:

◆ ParseClassLiteral()

template<class Traits >

ParserBase< Traits >::ExpressionT v8::internal::ParserBase< Traits >::ParseClassLiteral	(	IdentifierT	name,
		Scanner::Location	function_name_location,
		bool	name_is_strict_reserved,
		int	pos,
		bool *	ok
	)

protected

Definition at line 2721 of file preparser.h.

                                                      {
   // All parts of a ClassDeclaration or a ClassExpression are strict code.
   if (name_is_strict_reserved) {
     ReportMessageAt(class_name_location, "unexpected_strict_reserved");
     *ok = false;
     return this->EmptyExpression();
   }
   if (this->IsEvalOrArguments(name)) {
     ReportMessageAt(class_name_location, "strict_eval_arguments");
     *ok = false;
     return this->EmptyExpression();
   }
  
   // TODO(arv): Implement scopes and name binding in class body only.
   // TODO(arv): Maybe add CLASS_SCOPE?
   typename Traits::Type::ScopePtr extends_scope =
       this->NewScope(scope_, BLOCK_SCOPE);
   FunctionState extends_function_state(
       &function_state_, &scope_, &extends_scope, zone(),
       this->ast_value_factory(), ast_node_id_gen_);
   scope_->SetStrictMode(STRICT);
   scope_->SetScopeName(name);
  
   ExpressionT extends = this->EmptyExpression();
   if (Check(Token::EXTENDS)) {
     extends = this->ParseLeftHandSideExpression(CHECK_OK);
   }
  
   ObjectLiteralChecker checker(this, STRICT);
   typename Traits::Type::PropertyList properties =
       this->NewPropertyList(4, zone_);
   FunctionLiteralT constructor = this->EmptyFunctionLiteral();
  
   Expect(Token::LBRACE, CHECK_OK);
   while (peek() != Token::RBRACE) {
     if (Check(Token::SEMICOLON)) continue;
     if (fni_ != NULL) fni_->Enter();
  
     const bool in_class = true;
     const bool is_static = false;
     ObjectLiteralPropertyT property =
         this->ParsePropertyDefinition(&checker, in_class, is_static, CHECK_OK);
  
     properties->Add(property, zone());
  
     if (fni_ != NULL) {
       fni_->Infer();
       fni_->Leave();
     }
   }
   Expect(Token::RBRACE, CHECK_OK);
  
   return this->ClassLiteral(name, extends, constructor, properties, pos,
                             factory());
 }

References v8::internal::BLOCK_SCOPE, CHECK_OK, name, NULL, and v8::internal::STRICT.

◆ ParseConditionalExpression()

template<class Traits >

ParserBase< Traits >::ExpressionT v8::internal::ParserBase< Traits >::ParseConditionalExpression	(	bool	accept_IN,
		bool *	ok
	)

protected

Definition at line 2255 of file preparser.h.

                                                                        {
   // ConditionalExpression ::
   //   LogicalOrExpression
   //   LogicalOrExpression '?' AssignmentExpression ':' AssignmentExpression
  
   int pos = peek_position();
   // We start using the binary expression parser for prec >= 4 only!
   ExpressionT expression = this->ParseBinaryExpression(4, accept_IN, CHECK_OK);
   if (peek() != Token::CONDITIONAL) return expression;
   Consume(Token::CONDITIONAL);
   // In parsing the first assignment expression in conditional
   // expressions we always accept the 'in' keyword; see ECMA-262,
   // section 11.12, page 58.
   ExpressionT left = ParseAssignmentExpression(true, CHECK_OK);
   Expect(Token::COLON, CHECK_OK);
   ExpressionT right = ParseAssignmentExpression(accept_IN, CHECK_OK);
   return factory()->NewConditional(expression, left, right, pos);
 }

References CHECK_OK.

◆ ParseExpression()

template<class Traits >

ParserBase< Traits >::ExpressionT v8::internal::ParserBase< Traits >::ParseExpression	(	bool	accept_IN,
		bool *	ok
	)

protected

Definition at line 1870 of file preparser.h.

                               {
   // Expression ::
   //   AssignmentExpression
   //   Expression ',' AssignmentExpression
  
   ExpressionT result = this->ParseAssignmentExpression(accept_IN, CHECK_OK);
   while (peek() == Token::COMMA) {
     Expect(Token::COMMA, CHECK_OK);
     int pos = position();
     ExpressionT right = this->ParseAssignmentExpression(accept_IN, CHECK_OK);
     result = factory()->NewBinaryOperation(Token::COMMA, result, right, pos);
   }
   return result;
 }

References CHECK_OK, and COMMA.

◆ ParseIdentifier()

template<class Traits >

ParserBase< Traits >::IdentifierT v8::internal::ParserBase< Traits >::ParseIdentifier	(	AllowEvalOrArgumentsAsIdentifier	allow_eval_or_arguments,
		bool *	ok
	)

protected

Definition at line 1637 of file preparser.h.

               {
   Token::Value next = Next();
   if (next == Token::IDENTIFIER) {
     IdentifierT name = this->GetSymbol(scanner());
     if (allow_eval_or_arguments == kDontAllowEvalOrArguments &&
         strict_mode() == STRICT && this->IsEvalOrArguments(name)) {
       ReportMessage("strict_eval_arguments");
       *ok = false;
     }
     return name;
   } else if (strict_mode() == SLOPPY &&
              (next == Token::FUTURE_STRICT_RESERVED_WORD ||
              (next == Token::LET) ||
              (next == Token::YIELD && !is_generator()))) {
     return this->GetSymbol(scanner());
   } else {
     this->ReportUnexpectedToken(next);
     *ok = false;
     return Traits::EmptyIdentifier();
   }
 }

References v8::internal::LET, name, v8::internal::SLOPPY, v8::internal::STRICT, and v8::internal::YIELD.

◆ ParseIdentifierName()

template<class Traits >

ParserBase< Traits >::IdentifierT v8::internal::ParserBase< Traits >::ParseIdentifierName ( bool * ok )

protected

Definition at line 1684 of file preparser.h.

                                                 {
   Token::Value next = Next();
   if (next != Token::IDENTIFIER && next != Token::FUTURE_RESERVED_WORD &&
       next != Token::LET && next != Token::YIELD &&
       next != Token::FUTURE_STRICT_RESERVED_WORD && !Token::IsKeyword(next)) {
     this->ReportUnexpectedToken(next);
     *ok = false;
     return Traits::EmptyIdentifier();
   }
   return this->GetSymbol(scanner());
 }

References v8::internal::Token::IsKeyword(), v8::internal::LET, and v8::internal::YIELD.

Here is the call graph for this function:

◆ ParseIdentifierNameOrGetOrSet()

template<class Traits >

ParserBase< Traits >::IdentifierT v8::internal::ParserBase< Traits >::ParseIdentifierNameOrGetOrSet	(	bool *	is_get,
		bool *	is_set,
		bool *	ok
	)

protected

Definition at line 1699 of file preparser.h.

                                                             {
   IdentifierT result = ParseIdentifierName(ok);
   if (!*ok) return Traits::EmptyIdentifier();
   scanner()->IsGetOrSet(is_get, is_set);
   return result;
 }

◆ ParseIdentifierOrStrictReservedWord()

template<class Traits >

ParserBase< Traits >::IdentifierT v8::internal::ParserBase< Traits >::ParseIdentifierOrStrictReservedWord	(	bool *	is_strict_reserved,
		bool *	ok
	)

protected

Definition at line 1664 of file preparser.h.

                                                            {
   Token::Value next = Next();
   if (next == Token::IDENTIFIER) {
     *is_strict_reserved = false;
   } else if (next == Token::FUTURE_STRICT_RESERVED_WORD ||
              next == Token::LET ||
              (next == Token::YIELD && !this->is_generator())) {
     *is_strict_reserved = true;
   } else {
     ReportUnexpectedToken(next);
     *ok = false;
     return Traits::EmptyIdentifier();
   }
   return this->GetSymbol(scanner());
 }

References v8::internal::LET, and v8::internal::YIELD.

◆ ParseLeftHandSideExpression()

template<class Traits >

ParserBase< Traits >::ExpressionT v8::internal::ParserBase< Traits >::ParseLeftHandSideExpression ( bool * ok )

protected

Definition at line 2397 of file preparser.h.

                                                         {
   // LeftHandSideExpression ::
   //   (NewExpression | MemberExpression) ...
  
   ExpressionT result = this->ParseMemberWithNewPrefixesExpression(CHECK_OK);
  
   while (true) {
     switch (peek()) {
       case Token::LBRACK: {
         Consume(Token::LBRACK);
         int pos = position();
         ExpressionT index = ParseExpression(true, CHECK_OK);
         result = factory()->NewProperty(result, index, pos);
         Expect(Token::RBRACK, CHECK_OK);
         break;
       }
  
       case Token::LPAREN: {
         int pos;
         if (scanner()->current_token() == Token::IDENTIFIER) {
           // For call of an identifier we want to report position of
           // the identifier as position of the call in the stack trace.
           pos = position();
         } else {
           // For other kinds of calls we record position of the parenthesis as
           // position of the call. Note that this is extremely important for
           // expressions of the form function(){...}() for which call position
           // should not point to the closing brace otherwise it will intersect
           // with positions recorded for function literal and confuse debugger.
           pos = peek_position();
           // Also the trailing parenthesis are a hint that the function will
           // be called immediately. If we happen to have parsed a preceding
           // function literal eagerly, we can also compile it eagerly.
           if (result->IsFunctionLiteral() && mode() == PARSE_EAGERLY) {
             result->AsFunctionLiteral()->set_parenthesized();
           }
         }
         typename Traits::Type::ExpressionList args = ParseArguments(CHECK_OK);
  
         // Keep track of eval() calls since they disable all local variable
         // optimizations.
         // The calls that need special treatment are the
         // direct eval calls. These calls are all of the form eval(...), with
         // no explicit receiver.
         // These calls are marked as potentially direct eval calls. Whether
         // they are actually direct calls to eval is determined at run time.
         this->CheckPossibleEvalCall(result, scope_);
         result = factory()->NewCall(result, args, pos);
         if (fni_ != NULL) fni_->RemoveLastFunction();
         break;
       }
  
       case Token::PERIOD: {
         Consume(Token::PERIOD);
         int pos = position();
         IdentifierT name = ParseIdentifierName(CHECK_OK);
         result = factory()->NewProperty(
             result, factory()->NewStringLiteral(name, pos), pos);
         if (fni_ != NULL) this->PushLiteralName(fni_, name);
         break;
       }
  
       default:
         return result;
     }
   }
 }

References CHECK_OK, mode(), name, and NULL.

Here is the call graph for this function:

◆ ParseMemberExpression()

template<class Traits >

ParserBase< Traits >::ExpressionT v8::internal::ParserBase< Traits >::ParseMemberExpression ( bool * ok )

protected

Definition at line 2515 of file preparser.h.

                                                   {
   // MemberExpression ::
   //   (PrimaryExpression | FunctionLiteral | ClassLiteral)
   //     ('[' Expression ']' | '.' Identifier | Arguments)*
  
   // The '[' Expression ']' and '.' Identifier parts are parsed by
   // ParseMemberExpressionContinuation, and the Arguments part is parsed by the
   // caller.
  
   // Parse the initial primary or function expression.
   ExpressionT result = this->EmptyExpression();
   if (peek() == Token::FUNCTION) {
     Consume(Token::FUNCTION);
     int function_token_position = position();
     bool is_generator = Check(Token::MUL);
     IdentifierT name = this->EmptyIdentifier();
     bool is_strict_reserved_name = false;
     Scanner::Location function_name_location = Scanner::Location::invalid();
     FunctionLiteral::FunctionType function_type =
         FunctionLiteral::ANONYMOUS_EXPRESSION;
     if (peek_any_identifier()) {
       name = ParseIdentifierOrStrictReservedWord(&is_strict_reserved_name,
                                                  CHECK_OK);
       function_name_location = scanner()->location();
       function_type = FunctionLiteral::NAMED_EXPRESSION;
     }
     result = this->ParseFunctionLiteral(
         name, function_name_location, is_strict_reserved_name,
         is_generator ? FunctionKind::kGeneratorFunction
                      : FunctionKind::kNormalFunction,
         function_token_position, function_type, FunctionLiteral::NORMAL_ARITY,
         CHECK_OK);
   } else if (peek() == Token::SUPER) {
     int beg_pos = position();
     Consume(Token::SUPER);
     Token::Value next = peek();
     if (next == Token::PERIOD || next == Token::LBRACK ||
         next == Token::LPAREN) {
       result = this->SuperReference(scope_, factory());
     } else {
       ReportMessageAt(Scanner::Location(beg_pos, position()),
                       "unexpected_super");
       *ok = false;
       return this->EmptyExpression();
     }
   } else {
     result = ParsePrimaryExpression(CHECK_OK);
   }
  
   result = ParseMemberExpressionContinuation(result, CHECK_OK);
   return result;
 }

References CHECK_OK, v8::internal::function_token_position, v8::internal::Scanner::Location::invalid(), v8::internal::kGeneratorFunction, v8::internal::kNormalFunction, v8::internal::MUL, and name.

Here is the call graph for this function:

◆ ParseMemberExpressionContinuation()

template<class Traits >

ParserBase< Traits >::ExpressionT v8::internal::ParserBase< Traits >::ParseMemberExpressionContinuation	(	ExpressionT	expression,
		bool *	ok
	)

protected

Definition at line 2571 of file preparser.h.

                                                                 {
   // Parses this part of MemberExpression:
   // ('[' Expression ']' | '.' Identifier)*
   while (true) {
     switch (peek()) {
       case Token::LBRACK: {
         Consume(Token::LBRACK);
         int pos = position();
         ExpressionT index = this->ParseExpression(true, CHECK_OK);
         expression = factory()->NewProperty(expression, index, pos);
         if (fni_ != NULL) {
           this->PushPropertyName(fni_, index);
         }
         Expect(Token::RBRACK, CHECK_OK);
         break;
       }
       case Token::PERIOD: {
         Consume(Token::PERIOD);
         int pos = position();
         IdentifierT name = ParseIdentifierName(CHECK_OK);
         expression = factory()->NewProperty(
             expression, factory()->NewStringLiteral(name, pos), pos);
         if (fni_ != NULL) {
           this->PushLiteralName(fni_, name);
         }
         break;
       }
       default:
         return expression;
     }
   }
   DCHECK(false);
   return this->EmptyExpression();
 }

References CHECK_OK, DCHECK, name, and NULL.

◆ ParseMemberWithNewPrefixesExpression()

template<class Traits >

ParserBase< Traits >::ExpressionT v8::internal::ParserBase< Traits >::ParseMemberWithNewPrefixesExpression ( bool * ok )

protected

Definition at line 2468 of file preparser.h.

                                                                  {
   // NewExpression ::
   //   ('new')+ MemberExpression
  
   // The grammar for new expressions is pretty warped. We can have several 'new'
   // keywords following each other, and then a MemberExpression. When we see '('
   // after the MemberExpression, it's associated with the rightmost unassociated
   // 'new' to create a NewExpression with arguments. However, a NewExpression
   // can also occur without arguments.
  
   // Examples of new expression:
   // new foo.bar().baz means (new (foo.bar)()).baz
   // new foo()() means (new foo())()
   // new new foo()() means (new (new foo())())
   // new new foo means new (new foo)
   // new new foo() means new (new foo())
   // new new foo().bar().baz means (new (new foo()).bar()).baz
  
   if (peek() == Token::NEW) {
     Consume(Token::NEW);
     int new_pos = position();
     ExpressionT result = this->EmptyExpression();
     if (Check(Token::SUPER)) {
       result = this->SuperReference(scope_, factory());
     } else {
       result = this->ParseMemberWithNewPrefixesExpression(CHECK_OK);
     }
     if (peek() == Token::LPAREN) {
       // NewExpression with arguments.
       typename Traits::Type::ExpressionList args =
           this->ParseArguments(CHECK_OK);
       result = factory()->NewCallNew(result, args, new_pos);
       // The expression can still continue with . or [ after the arguments.
       result = this->ParseMemberExpressionContinuation(result, CHECK_OK);
       return result;
     }
     // NewExpression without arguments.
     return factory()->NewCallNew(result, this->NewExpressionList(0, zone_),
                                  new_pos);
   }
   // No 'new' or 'super' keyword.
   return this->ParseMemberExpression(ok);
 }

References CHECK_OK.

◆ ParseObjectLiteral()

template<class Traits >

ParserBase< Traits >::ExpressionT v8::internal::ParserBase< Traits >::ParseObjectLiteral ( bool * ok )

protected

Definition at line 2047 of file preparser.h.

               {
   // ObjectLiteral ::
   // '{' (PropertyDefinition (',' PropertyDefinition)* ','? )? '}'
  
   int pos = peek_position();
   typename Traits::Type::PropertyList properties =
       this->NewPropertyList(4, zone_);
   int number_of_boilerplate_properties = 0;
   bool has_function = false;
  
   ObjectLiteralChecker checker(this, strict_mode());
  
   Expect(Token::LBRACE, CHECK_OK);
  
   while (peek() != Token::RBRACE) {
     if (fni_ != NULL) fni_->Enter();
  
     const bool in_class = false;
     const bool is_static = false;
     ObjectLiteralPropertyT property =
         this->ParsePropertyDefinition(&checker, in_class, is_static, CHECK_OK);
  
     // Mark top-level object literals that contain function literals and
     // pretenure the literal so it can be added as a constant function
     // property. (Parser only.)
     this->CheckFunctionLiteralInsideTopLevelObjectLiteral(scope_, property,
                                                           &has_function);
  
     // Count CONSTANT or COMPUTED properties to maintain the enumeration order.
     if (this->IsBoilerplateProperty(property)) {
       number_of_boilerplate_properties++;
     }
     properties->Add(property, zone());
  
     if (peek() != Token::RBRACE) {
       // Need {} because of the CHECK_OK macro.
       Expect(Token::COMMA, CHECK_OK);
     }
  
     if (fni_ != NULL) {
       fni_->Infer();
       fni_->Leave();
     }
   }
   Expect(Token::RBRACE, CHECK_OK);
  
   // Computation of literal_index must happen before pre parse bailout.
   int literal_index = function_state_->NextMaterializedLiteralIndex();
  
   return factory()->NewObjectLiteral(properties,
                                      literal_index,
                                      number_of_boilerplate_properties,
                                      has_function,
                                      pos);
 }

References CHECK_OK, COMMA, and NULL.

◆ ParsePostfixExpression()

template<class Traits >

ParserBase< Traits >::ExpressionT v8::internal::ParserBase< Traits >::ParsePostfixExpression ( bool * ok )

protected

Definition at line 2372 of file preparser.h.

                                                    {
   // PostfixExpression ::
   //   LeftHandSideExpression ('++' | '--')?
  
   Scanner::Location lhs_location = scanner()->peek_location();
   ExpressionT expression = this->ParseLeftHandSideExpression(CHECK_OK);
   if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
       Token::IsCountOp(peek())) {
     expression = this->CheckAndRewriteReferenceExpression(
         expression, lhs_location, "invalid_lhs_in_postfix_op", CHECK_OK);
     expression = this->MarkExpressionAsAssigned(expression);
  
     Token::Value next = Next();
     expression =
         factory()->NewCountOperation(next,
                                      false /* postfix */,
                                      expression,
                                      position());
   }
   return expression;
 }

References CHECK_OK, and v8::internal::Token::IsCountOp().

Here is the call graph for this function:

◆ ParsePrimaryExpression()

template<class Traits >

ParserBase< Traits >::ExpressionT v8::internal::ParserBase< Traits >::ParsePrimaryExpression ( bool * ok )

protected

Definition at line 1750 of file preparser.h.

                                                    {
   // PrimaryExpression ::
   //   'this'
   //   'null'
   //   'true'
   //   'false'
   //   Identifier
   //   Number
   //   String
   //   ArrayLiteral
   //   ObjectLiteral
   //   RegExpLiteral
   //   ClassLiteral
   //   '(' Expression ')'
  
   int pos = peek_position();
   ExpressionT result = this->EmptyExpression();
   Token::Value token = peek();
   switch (token) {
     case Token::THIS: {
       Consume(Token::THIS);
       result = this->ThisExpression(scope_, factory());
       break;
     }
  
     case Token::NULL_LITERAL:
     case Token::TRUE_LITERAL:
     case Token::FALSE_LITERAL:
     case Token::NUMBER:
       Next();
       result = this->ExpressionFromLiteral(token, pos, scanner(), factory());
       break;
  
     case Token::IDENTIFIER:
     case Token::LET:
     case Token::YIELD:
     case Token::FUTURE_STRICT_RESERVED_WORD: {
       // Using eval or arguments in this context is OK even in strict mode.
       IdentifierT name = ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
       result = this->ExpressionFromIdentifier(name, pos, scope_, factory());
       break;
     }
  
     case Token::STRING: {
       Consume(Token::STRING);
       result = this->ExpressionFromString(pos, scanner(), factory());
       break;
     }
  
     case Token::ASSIGN_DIV:
       result = this->ParseRegExpLiteral(true, CHECK_OK);
       break;
  
     case Token::DIV:
       result = this->ParseRegExpLiteral(false, CHECK_OK);
       break;
  
     case Token::LBRACK:
       result = this->ParseArrayLiteral(CHECK_OK);
       break;
  
     case Token::LBRACE:
       result = this->ParseObjectLiteral(CHECK_OK);
       break;
  
     case Token::LPAREN:
       Consume(Token::LPAREN);
       if (allow_arrow_functions() && peek() == Token::RPAREN) {
         // Arrow functions are the only expression type constructions
         // for which an empty parameter list "()" is valid input.
         Consume(Token::RPAREN);
         result = this->ParseArrowFunctionLiteral(
             pos, this->EmptyArrowParamList(), CHECK_OK);
       } else {
         // Heuristically try to detect immediately called functions before
         // seeing the call parentheses.
         parenthesized_function_ = (peek() == Token::FUNCTION);
         result = this->ParseExpression(true, CHECK_OK);
         result->increase_parenthesization_level();
         Expect(Token::RPAREN, CHECK_OK);
       }
       break;
  
     case Token::CLASS: {
       Consume(Token::CLASS);
       int class_token_position = position();
       IdentifierT name = this->EmptyIdentifier();
       bool is_strict_reserved_name = false;
       Scanner::Location class_name_location = Scanner::Location::invalid();
       if (peek_any_identifier()) {
         name = ParseIdentifierOrStrictReservedWord(&is_strict_reserved_name,
                                                    CHECK_OK);
         class_name_location = scanner()->location();
       }
       result = this->ParseClassLiteral(name, class_name_location,
                                        is_strict_reserved_name,
                                        class_token_position, CHECK_OK);
       break;
     }
  
     case Token::MOD:
       if (allow_natives_syntax() || extension_ != NULL) {
         result = this->ParseV8Intrinsic(CHECK_OK);
         break;
       }
       // If we're not allowing special syntax we fall-through to the
       // default case.
  
     default: {
       Next();
       ReportUnexpectedToken(token);
       *ok = false;
     }
   }
  
   return result;
 }

References CHECK_OK, v8::internal::DIV, v8::internal::Scanner::Location::invalid(), v8::internal::LET, name, NULL, STRING, and v8::internal::YIELD.

Here is the call graph for this function:

◆ ParsePropertyDefinition()

template<class Traits >

ParserBase< Traits >::ObjectLiteralPropertyT v8::internal::ParserBase< Traits >::ParsePropertyDefinition	(	ObjectLiteralChecker *	checker,
		bool	in_class,
		bool	is_static,
		bool *	ok
	)

protected

Definition at line 1942 of file preparser.h.

                                                                               {
   ExpressionT value = this->EmptyExpression();
   bool is_get = false;
   bool is_set = false;
   bool name_is_static = false;
   bool is_generator = allow_harmony_object_literals_ && Check(Token::MUL);
  
   Token::Value name_token = peek();
   int next_pos = peek_position();
   IdentifierT name =
       ParsePropertyName(&is_get, &is_set, &name_is_static,
                         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
  
   if (fni_ != NULL) this->PushLiteralName(fni_, name);
  
   if (!in_class && !is_generator && peek() == Token::COLON) {
     // PropertyDefinition : PropertyName ':' AssignmentExpression
     checker->CheckProperty(name_token, kValueProperty,
                            CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
     Consume(Token::COLON);
     value = this->ParseAssignmentExpression(
         true, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
  
   } else if (is_generator ||
              (allow_harmony_object_literals_ && peek() == Token::LPAREN)) {
     // Concise Method
  
     if (is_static && this->IsPrototype(name)) {
       ReportMessageAt(scanner()->location(), "static_prototype");
       *ok = false;
       return this->EmptyObjectLiteralProperty();
     }
     if (is_generator && in_class && !is_static && this->IsConstructor(name)) {
       ReportMessageAt(scanner()->location(), "constructor_special_method");
       *ok = false;
       return this->EmptyObjectLiteralProperty();
     }
  
     checker->CheckProperty(name_token, kValueProperty,
                            CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
     FunctionKind kind = is_generator ? FunctionKind::kConciseGeneratorMethod
                                      : FunctionKind::kConciseMethod;
  
     value = this->ParseFunctionLiteral(
         name, scanner()->location(),
         false,  // reserved words are allowed here
         kind, RelocInfo::kNoPosition, FunctionLiteral::ANONYMOUS_EXPRESSION,
         FunctionLiteral::NORMAL_ARITY,
         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
  
   } else if (in_class && name_is_static && !is_static) {
     // static MethodDefinition
     return ParsePropertyDefinition(checker, true, true, ok);
  
   } else if (is_get || is_set) {
     // Accessor
     bool dont_care = false;
     name_token = peek();
     name = ParsePropertyName(&dont_care, &dont_care, &dont_care,
                              CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
  
     // Validate the property.
     if (is_static && this->IsPrototype(name)) {
       ReportMessageAt(scanner()->location(), "static_prototype");
       *ok = false;
       return this->EmptyObjectLiteralProperty();
     } else if (in_class && !is_static && this->IsConstructor(name)) {
       // ES6, spec draft rev 27, treats static get constructor as an error too.
       // https://bugs.ecmascript.org/show_bug.cgi?id=3223
       // TODO(arv): Update when bug is resolved.
       ReportMessageAt(scanner()->location(), "constructor_special_method");
       *ok = false;
       return this->EmptyObjectLiteralProperty();
     }
     checker->CheckProperty(name_token,
                            is_get ? kGetterProperty : kSetterProperty,
                            CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
  
     typename Traits::Type::FunctionLiteral value = this->ParseFunctionLiteral(
         name, scanner()->location(),
         false,  // reserved words are allowed here
         FunctionKind::kNormalFunction, RelocInfo::kNoPosition,
         FunctionLiteral::ANONYMOUS_EXPRESSION,
         is_get ? FunctionLiteral::GETTER_ARITY : FunctionLiteral::SETTER_ARITY,
         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
     return factory()->NewObjectLiteralProperty(is_get, value, next_pos,
                                                is_static);
   } else {
     Token::Value next = Next();
     ReportUnexpectedToken(next);
     *ok = false;
     return this->EmptyObjectLiteralProperty();
   }
  
   uint32_t index;
   LiteralT key = this->IsArrayIndex(name, &index)
                      ? factory()->NewNumberLiteral(index, next_pos)
                      : factory()->NewStringLiteral(name, next_pos);
  
   return factory()->NewObjectLiteralProperty(key, value, is_static);
 }

References CHECK_OK_CUSTOM, v8::internal::ParserBase< Traits >::ObjectLiteralChecker::CheckProperty(), v8::internal::kConciseGeneratorMethod, v8::internal::kConciseMethod, v8::internal::RelocInfo::kNoPosition, v8::internal::kNormalFunction, v8::internal::MUL, name, and NULL.

Here is the call graph for this function:

◆ ParsePropertyName()

template<class Traits >

ParserBase< Traits >::IdentifierT v8::internal::ParserBase< Traits >::ParsePropertyName	(	bool *	is_get,
		bool *	is_set,
		bool *	is_static,
		bool *	ok
	)

protected

Definition at line 1919 of file preparser.h.

                                                            {
   Token::Value next = peek();
   switch (next) {
     case Token::STRING:
       Consume(Token::STRING);
       return this->GetSymbol(scanner_);
     case Token::NUMBER:
       Consume(Token::NUMBER);
       return this->GetNumberAsSymbol(scanner_);
     case Token::STATIC:
       *is_static = true;
       // Fall through.
     default:
       return ParseIdentifierNameOrGetOrSet(is_get, is_set, ok);
   }
   UNREACHABLE();
   return this->EmptyIdentifier();
 }

References STRING, and UNREACHABLE.

◆ ParseRegExpLiteral()

template<class Traits >

ParserBase< Traits >::ExpressionT v8::internal::ParserBase< Traits >::ParseRegExpLiteral	(	bool	seen_equal,
		bool *	ok
	)

protected

Definition at line 1710 of file preparser.h.

                                {
   int pos = peek_position();
   if (!scanner()->ScanRegExpPattern(seen_equal)) {
     Next();
     ReportMessage("unterminated_regexp");
     *ok = false;
     return Traits::EmptyExpression();
   }
  
   int literal_index = function_state_->NextMaterializedLiteralIndex();
  
   IdentifierT js_pattern = this->GetNextSymbol(scanner());
   if (!scanner()->ScanRegExpFlags()) {
     Next();
     ReportMessage("invalid_regexp_flags");
     *ok = false;
     return Traits::EmptyExpression();
   }
   IdentifierT js_flags = this->GetNextSymbol(scanner());
   Next();
   return factory()->NewRegExpLiteral(js_pattern, js_flags, literal_index, pos);
 }

◆ ParseUnaryExpression()

template<class Traits >

ParserBase< Traits >::ExpressionT v8::internal::ParserBase< Traits >::ParseUnaryExpression ( bool * ok )

protected

Definition at line 2322 of file preparser.h.

                                                  {
   // UnaryExpression ::
   //   PostfixExpression
   //   'delete' UnaryExpression
   //   'void' UnaryExpression
   //   'typeof' UnaryExpression
   //   '++' UnaryExpression
   //   '--' UnaryExpression
   //   '+' UnaryExpression
   //   '-' UnaryExpression
   //   '~' UnaryExpression
   //   '!' UnaryExpression
  
   Token::Value op = peek();
   if (Token::IsUnaryOp(op)) {
     op = Next();
     int pos = position();
     ExpressionT expression = ParseUnaryExpression(CHECK_OK);
  
     // "delete identifier" is a syntax error in strict mode.
     if (op == Token::DELETE && strict_mode() == STRICT &&
         this->IsIdentifier(expression)) {
       ReportMessage("strict_delete");
       *ok = false;
       return this->EmptyExpression();
     }
  
     // Allow Traits do rewrite the expression.
     return this->BuildUnaryExpression(expression, op, pos, factory());
   } else if (Token::IsCountOp(op)) {
     op = Next();
     Scanner::Location lhs_location = scanner()->peek_location();
     ExpressionT expression = this->ParseUnaryExpression(CHECK_OK);
     expression = this->CheckAndRewriteReferenceExpression(
         expression, lhs_location, "invalid_lhs_in_prefix_op", CHECK_OK);
     this->MarkExpressionAsAssigned(expression);
  
     return factory()->NewCountOperation(op,
                                         true /* prefix */,
                                         expression,
                                         position());
  
   } else {
     return this->ParsePostfixExpression(ok);
   }
 }

References CHECK_OK, v8::internal::Token::IsCountOp(), v8::internal::Token::IsUnaryOp(), and v8::internal::STRICT.

Here is the call graph for this function:

◆ ParseYieldExpression()

template<class Traits >

ParserBase< Traits >::ExpressionT v8::internal::ParserBase< Traits >::ParseYieldExpression ( bool * ok )

protected

Definition at line 2207 of file preparser.h.

                                                  {
   // YieldExpression ::
   //   'yield' ([no line terminator] '*'? AssignmentExpression)?
   int pos = peek_position();
   Expect(Token::YIELD, CHECK_OK);
   ExpressionT generator_object =
       factory()->NewVariableProxy(function_state_->generator_object_variable());
   ExpressionT expression = Traits::EmptyExpression();
   Yield::Kind kind = Yield::kSuspend;
   if (!scanner()->HasAnyLineTerminatorBeforeNext()) {
     if (Check(Token::MUL)) kind = Yield::kDelegating;
     switch (peek()) {
       case Token::EOS:
       case Token::SEMICOLON:
       case Token::RBRACE:
       case Token::RBRACK:
       case Token::RPAREN:
       case Token::COLON:
       case Token::COMMA:
         // The above set of tokens is the complete set of tokens that can appear
         // after an AssignmentExpression, and none of them can start an
         // AssignmentExpression.  This allows us to avoid looking for an RHS for
         // a Yield::kSuspend operation, given only one look-ahead token.
         if (kind == Yield::kSuspend)
           break;
         DCHECK_EQ(Yield::kDelegating, kind);
         // Delegating yields require an RHS; fall through.
       default:
         expression = ParseAssignmentExpression(false, CHECK_OK);
         break;
     }
   }
   if (kind == Yield::kDelegating) {
     // var iterator = subject[Symbol.iterator]();
     expression = this->GetIterator(expression, factory());
   }
   typename Traits::Type::YieldExpression yield =
       factory()->NewYield(generator_object, expression, kind, pos);
   if (kind == Yield::kDelegating) {
     yield->set_index(function_state_->NextHandlerIndex());
   }
   return yield;
 }

References CHECK_OK, COMMA, DCHECK_EQ, v8::internal::MUL, and v8::internal::YIELD.

◆ peek_any_identifier()

template<typename Traits >

bool v8::internal::ParserBase< Traits >::peek_any_identifier ( )

inlineprotected

Definition at line 352 of file preparser.h.

                              {
     Token::Value next = peek();
     return next == Token::IDENTIFIER ||
         next == Token::FUTURE_RESERVED_WORD ||
         next == Token::FUTURE_STRICT_RESERVED_WORD ||
         next == Token::LET ||
         next == Token::YIELD;
   }

References v8::internal::LET, and v8::internal::YIELD.

◆ peek_position()

template<typename Traits >

int v8::internal::ParserBase< Traits >::peek_position ( )

inlineprotected

Definition at line 287 of file preparser.h.

287 { return scanner_->peek_location().beg_pos; }

v8::internal::Scanner::Location::beg_pos

int beg_pos

Definition: scanner.h:339

References v8::internal::Scanner::Location::beg_pos, v8::internal::Scanner::peek_location(), and v8::internal::ParserBase< Traits >::scanner_.

Here is the call graph for this function:

◆ position()

template<typename Traits >

int v8::internal::ParserBase< Traits >::position ( )

inlineprotected

Definition at line 286 of file preparser.h.

286 { return scanner_->location().beg_pos; }

References v8::internal::Scanner::Location::beg_pos, v8::internal::Scanner::location(), and v8::internal::ParserBase< Traits >::scanner_.

Here is the call graph for this function:

◆ Precedence()

template<typename Traits >

static int v8::internal::ParserBase< Traits >::Precedence	(	Token::Value	token,
		bool	accept_IN
	)

inlinestaticprotected

Definition at line 430 of file preparser.h.

                                                           {
     if (token == Token::IN && !accept_IN)
       return 0;  // 0 precedence will terminate binary expression parsing
     return Token::Precedence(token);
   }

References IN, and v8::internal::Token::Precedence().

Here is the call graph for this function:

◆ ReportMessage()

template<typename Traits >

void v8::internal::ParserBase< Traits >::ReportMessage	(	const char *	message,
		const char *	arg = `NULL`,
		bool	is_reference_error = `false`
	)

inlineprotected

Definition at line 444 of file preparser.h.

                                                       {
     Scanner::Location source_location = scanner()->location();
     Traits::ReportMessageAt(source_location, message, arg, is_reference_error);
   }

References v8::internal::Scanner::location(), and v8::internal::ParserBase< Traits >::scanner().

Referenced by v8::internal::ParserBase< Traits >::ObjectLiteralChecker::CheckProperty().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReportMessageAt()

template<typename Traits >

void v8::internal::ParserBase< Traits >::ReportMessageAt	(	Scanner::Location	location,
		const char *	message,
		bool	is_reference_error = `false`
	)

inlineprotected

Definition at line 450 of file preparser.h.

                                                         {
     Traits::ReportMessageAt(location, message,
                             reinterpret_cast<const char*>(NULL),
                             is_reference_error);
   }

References NULL.

Referenced by v8::internal::ParserBase< Traits >::CheckOctalLiteral().

Here is the caller graph for this function:

◆ ReportUnexpectedToken()

template<class Traits >

void v8::internal::ParserBase< Traits >::ReportUnexpectedToken ( Token::Value token )

protected

Definition at line 1608 of file preparser.h.

                                                                {
   Scanner::Location source_location = scanner()->location();
  
   // Four of the tokens are treated specially
   switch (token) {
     case Token::EOS:
       return ReportMessageAt(source_location, "unexpected_eos");
     case Token::NUMBER:
       return ReportMessageAt(source_location, "unexpected_token_number");
     case Token::STRING:
       return ReportMessageAt(source_location, "unexpected_token_string");
     case Token::IDENTIFIER:
       return ReportMessageAt(source_location, "unexpected_token_identifier");
     case Token::FUTURE_RESERVED_WORD:
       return ReportMessageAt(source_location, "unexpected_reserved");
     case Token::LET:
     case Token::YIELD:
     case Token::FUTURE_STRICT_RESERVED_WORD:
       return ReportMessageAt(source_location, strict_mode() == SLOPPY
           ? "unexpected_token_identifier" : "unexpected_strict_reserved");
     default:
       const char* name = Token::String(token);
       DCHECK(name != NULL);
       Traits::ReportMessageAt(source_location, "unexpected_token", name);
   }
 }

References DCHECK, v8::internal::LET, name, NULL, v8::internal::SLOPPY, STRING, v8::internal::Token::String(), and v8::internal::YIELD.

Referenced by v8::internal::ParserBase< Traits >::Expect(), and v8::internal::ParserBase< Traits >::ExpectContextualKeyword().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scanner()

template<typename Traits >

Scanner* v8::internal::ParserBase< Traits >::scanner ( ) const

inlineprotected

Definition at line 285 of file preparser.h.

285 { return scanner_; }

References v8::internal::ParserBase< Traits >::scanner_.

Here is the caller graph for this function:

◆ set_allow_arrow_functions()

template<typename Traits >

void v8::internal::ParserBase< Traits >::set_allow_arrow_functions ( bool allow )

inline

Definition at line 112 of file preparser.h.

112 { allow_arrow_functions_ = allow; }

References v8::internal::ParserBase< Traits >::allow_arrow_functions_.

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

Here is the caller graph for this function:

◆ set_allow_classes()

template<typename Traits >

void v8::internal::ParserBase< Traits >::set_allow_classes ( bool allow )

inline

Definition at line 120 of file preparser.h.

120 { scanner()->SetHarmonyClasses(allow); }

v8::internal::Scanner::SetHarmonyClasses

void SetHarmonyClasses(bool classes)

Definition: scanner.h:444

References v8::internal::ParserBase< Traits >::scanner(), and v8::internal::Scanner::SetHarmonyClasses().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_allow_harmony_numeric_literals()

template<typename Traits >

void v8::internal::ParserBase< Traits >::set_allow_harmony_numeric_literals ( bool allow )

inline

Definition at line 117 of file preparser.h.

                                                       {
     scanner()->SetHarmonyNumericLiterals(allow);
   }

References v8::internal::ParserBase< Traits >::scanner(), and v8::internal::Scanner::SetHarmonyNumericLiterals().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_allow_harmony_object_literals()

template<typename Traits >

void v8::internal::ParserBase< Traits >::set_allow_harmony_object_literals ( bool allow )

inline

Definition at line 121 of file preparser.h.

                                                      {
     allow_harmony_object_literals_ = allow;
   }

References v8::internal::ParserBase< Traits >::allow_harmony_object_literals_.

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

Here is the caller graph for this function:

◆ set_allow_harmony_scoping()

template<typename Traits >

void v8::internal::ParserBase< Traits >::set_allow_harmony_scoping ( bool allow )

inline

Definition at line 114 of file preparser.h.

                                              {
     scanner()->SetHarmonyScoping(allow);
   }

References v8::internal::ParserBase< Traits >::scanner(), and v8::internal::Scanner::SetHarmonyScoping().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_allow_lazy()

template<typename Traits >

void v8::internal::ParserBase< Traits >::set_allow_lazy ( bool allow )

inline

Definition at line 110 of file preparser.h.

110 { allow_lazy_ = allow; }

References v8::internal::ParserBase< Traits >::allow_lazy_.

Referenced by v8::internal::Parser::Parse(), and v8::internal::Parser::ParseLazyFunctionBodyWithPreParser().

Here is the caller graph for this function:

◆ set_allow_modules()

template<typename Traits >

void v8::internal::ParserBase< Traits >::set_allow_modules ( bool allow )

inline

Definition at line 113 of file preparser.h.

113 { scanner()->SetHarmonyModules(allow); }

v8::internal::Scanner::SetHarmonyModules

void SetHarmonyModules(bool modules)

Definition: scanner.h:432

References v8::internal::ParserBase< Traits >::scanner(), and v8::internal::Scanner::SetHarmonyModules().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_allow_natives_syntax()

template<typename Traits >

void v8::internal::ParserBase< Traits >::set_allow_natives_syntax ( bool allow )

inline

Definition at line 111 of file preparser.h.

111 { allow_natives_syntax_ = allow; }

References v8::internal::ParserBase< Traits >::allow_natives_syntax_.

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

Here is the caller graph for this function:

◆ set_stack_overflow()

template<typename Traits >

void v8::internal::ParserBase< Traits >::set_stack_overflow ( )

inlineprotected

Definition at line 289 of file preparser.h.

289 { stack_overflow_ = true; }

References v8::internal::ParserBase< Traits >::stack_overflow_.

◆ stack_overflow()

template<typename Traits >

bool v8::internal::ParserBase< Traits >::stack_overflow ( ) const

inlineprotected

Definition at line 288 of file preparser.h.

288 { return stack_overflow_; }

References v8::internal::ParserBase< Traits >::stack_overflow_.

Referenced by v8::internal::ParserTraits::ReportMessageAt().

Here is the caller graph for this function:

◆ strict_mode()

template<typename Traits >

StrictMode v8::internal::ParserBase< Traits >::strict_mode ( )

inlineprotected

Definition at line 440 of file preparser.h.

440 { return scope_->strict_mode(); }

References v8::internal::ParserBase< Traits >::scope_.

◆ zone()

template<typename Traits >

Traits::Type::Zone* v8::internal::ParserBase< Traits >::zone ( ) const

inlineprotected

Definition at line 291 of file preparser.h.

291 { return zone_; }

References v8::internal::ParserBase< Traits >::zone_.

Referenced by v8::internal::ParserTraits::GetIterator(), and v8::internal::ParserTraits::NewThrowError().

Here is the caller graph for this function:

Friends And Related Function Documentation

◆ Traits::Checkpoint

template<typename Traits >

friend class Traits::Checkpoint

friend

Definition at line 126 of file preparser.h.

Member Data Documentation

◆ allow_arrow_functions_

template<typename Traits >

bool v8::internal::ParserBase< Traits >::allow_arrow_functions_

private

Definition at line 591 of file preparser.h.

Referenced by v8::internal::ParserBase< Traits >::allow_arrow_functions(), and v8::internal::ParserBase< Traits >::set_allow_arrow_functions().

◆ allow_harmony_object_literals_

template<typename Traits >

bool v8::internal::ParserBase< Traits >::allow_harmony_object_literals_

private

Definition at line 592 of file preparser.h.

Referenced by v8::internal::ParserBase< Traits >::allow_harmony_object_literals(), and v8::internal::ParserBase< Traits >::set_allow_harmony_object_literals().

◆ allow_lazy_

template<typename Traits >

bool v8::internal::ParserBase< Traits >::allow_lazy_

private

Definition at line 589 of file preparser.h.

Referenced by v8::internal::ParserBase< Traits >::allow_lazy(), and v8::internal::ParserBase< Traits >::set_allow_lazy().

◆ allow_natives_syntax_

template<typename Traits >

bool v8::internal::ParserBase< Traits >::allow_natives_syntax_

private

Definition at line 590 of file preparser.h.

Referenced by v8::internal::ParserBase< Traits >::allow_natives_syntax(), and v8::internal::ParserBase< Traits >::set_allow_natives_syntax().

◆ ast_node_id_gen_

template<typename Traits >

AstNode::IdGen* v8::internal::ParserBase< Traits >::ast_node_id_gen_

private

Definition at line 595 of file preparser.h.

Referenced by v8::internal::ParserBase< Traits >::ast_node_id_gen(), v8::internal::ParserTraits::Checkpoint::Checkpoint(), and v8::internal::ParserTraits::Checkpoint::Restore().

◆ extension_

template<typename Traits >

v8::Extension* v8::internal::ParserBase< Traits >::extension_

protected

Definition at line 579 of file preparser.h.

◆ fni_

template<typename Traits >

FuncNameInferrer* v8::internal::ParserBase< Traits >::fni_

protected

Definition at line 580 of file preparser.h.

Referenced by v8::internal::ParserTraits::ExpressionFromIdentifier(), and v8::internal::ParserTraits::ExpressionFromString().

◆ function_state_

template<typename Traits >

FunctionState* v8::internal::ParserBase< Traits >::function_state_

protected

Definition at line 578 of file preparser.h.

Referenced by v8::internal::ParserBase< Traits >::BASE_EMBEDDED::CheckpointBase(), v8::internal::ParserBase< Traits >::factory(), v8::internal::ParserBase< Traits >::is_generator(), and v8::internal::ParserBase< Traits >::BASE_EMBEDDED::Restore().

◆ log_

template<typename Traits >

ParserRecorder* v8::internal::ParserBase< Traits >::log_

protected

Definition at line 581 of file preparser.h.

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

◆ mode_

template<typename Traits >

Mode v8::internal::ParserBase< Traits >::mode_

protected

Definition at line 582 of file preparser.h.

Referenced by v8::internal::ParserBase< Traits >::mode().

◆ parenthesized_function_

template<typename Traits >

bool v8::internal::ParserBase< Traits >::parenthesized_function_

protected

Definition at line 575 of file preparser.h.

◆ scanner_

template<typename Traits >

Scanner* v8::internal::ParserBase< Traits >::scanner_

private

Definition at line 586 of file preparser.h.

Referenced by v8::internal::ParserBase< Traits >::peek_position(), v8::internal::ParserBase< Traits >::position(), and v8::internal::ParserBase< Traits >::scanner().

◆ scope_

template<typename Traits >

Traits::Type::Scope* v8::internal::ParserBase< Traits >::scope_

protected

Definition at line 577 of file preparser.h.

Referenced by v8::internal::ParserBase< Traits >::BASE_EMBEDDED::BlockState(), and v8::internal::ParserBase< Traits >::strict_mode().

◆ stack_limit_

template<typename Traits >

uintptr_t v8::internal::ParserBase< Traits >::stack_limit_

protected

Definition at line 583 of file preparser.h.

Referenced by v8::internal::ParserBase< Traits >::INLINE().

◆ stack_overflow_

template<typename Traits >

bool v8::internal::ParserBase< Traits >::stack_overflow_

private

Definition at line 587 of file preparser.h.

Referenced by v8::internal::ParserBase< Traits >::INLINE(), v8::internal::ParserBase< Traits >::set_stack_overflow(), and v8::internal::ParserBase< Traits >::stack_overflow().

◆ zone_

template<typename Traits >

Traits::Type::Zone* v8::internal::ParserBase< Traits >::zone_

private

Definition at line 594 of file preparser.h.

Referenced by v8::internal::ParserBase< Traits >::zone().

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

/mnt/V8SourceCode/src/preparser.h

Classes

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Attributes

Friends

Detailed Description

template<typename Traits> class v8::internal::ParserBase< Traits >

Member Typedef Documentation

◆ ExpressionT

◆ FunctionLiteralT

◆ IdentifierT

◆ LiteralT

◆ ObjectLiteralPropertyT

Member Enumeration Documentation

◆ AllowEvalOrArgumentsAsIdentifier

◆ Mode

◆ PropertyKind

Constructor & Destructor Documentation

◆ ParserBase()

Member Function Documentation

◆ allow_arrow_functions()

◆ allow_classes()

◆ allow_harmony_numeric_literals()

◆ allow_harmony_object_literals()

◆ allow_harmony_scoping()

◆ allow_lazy()

◆ allow_modules()

◆ allow_natives_syntax()

◆ ast_node_id_gen()

◆ Check()

◆ CheckAndRewriteReferenceExpression()

◆ CheckContextualKeyword()

◆ CheckOctalLiteral()

◆ CheckStrictFunctionNameAndParameters()

◆ Consume()

◆ Expect()

◆ ExpectContextualKeyword()

◆ ExpectSemicolon()

◆ factory()

◆ INLINE() [1/2]

◆ INLINE() [2/2]

◆ is_generator()

◆ mode()

◆ ParseArguments()

◆ ParseArrayLiteral()

◆ ParseArrowFunctionLiteral()

◆ ParseAssignmentExpression()

◆ ParseBinaryExpression()

◆ ParseClassLiteral()

◆ ParseConditionalExpression()

◆ ParseExpression()

◆ ParseIdentifier()

◆ ParseIdentifierName()

◆ ParseIdentifierNameOrGetOrSet()

◆ ParseIdentifierOrStrictReservedWord()

◆ ParseLeftHandSideExpression()

◆ ParseMemberExpression()

◆ ParseMemberExpressionContinuation()

◆ ParseMemberWithNewPrefixesExpression()

◆ ParseObjectLiteral()

◆ ParsePostfixExpression()

◆ ParsePrimaryExpression()

◆ ParsePropertyDefinition()

◆ ParsePropertyName()

◆ ParseRegExpLiteral()

◆ ParseUnaryExpression()

◆ ParseYieldExpression()

◆ peek_any_identifier()

◆ peek_position()

◆ position()

◆ Precedence()

◆ ReportMessage()

◆ ReportMessageAt()

◆ ReportUnexpectedToken()

◆ scanner()

◆ set_allow_arrow_functions()

template<typename Traits>
class v8::internal::ParserBase< Traits >