#include <parser.h>

Inheritance diagram for v8::internal::Parser:

Collaboration diagram for v8::internal::Parser:

Classes
struct	ParseInfo

Public Member Functions
	Parser (CompilationInfo info, ParseInfo parse_info)

	~Parser ()

bool	Parse ()

void	ParseOnBackground ()

void	Internalize ()

Public Member Functions inherited from v8::internal::ParserBase< ParserTraits >
	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::ParserTraits
	ParserTraits (Parser *parser)

bool	IsEvalOrArguments (const AstRawString *identifier) const

bool	IsFutureStrictReserved (const AstRawString *identifier) const

bool	IsPrototype (const AstRawString *identifier) const

bool	IsConstructor (const AstRawString *identifier) const

void	PushPropertyName (FuncNameInferrer fni, Expression expression)

void	CheckPossibleEvalCall (Expression expression, Scope scope)

bool	ShortcutNumericLiteralBinaryExpression (Expression *x, Expression y, Token::Value op, int pos, AstNodeFactory< AstConstructionVisitor > *factory)

Expression *	BuildUnaryExpression (Expression expression, Token::Value op, int pos, AstNodeFactory< AstConstructionVisitor > factory)

Expression *	NewThrowReferenceError (const char *type, int pos)

Expression *	NewThrowSyntaxError (const char type, const AstRawString arg, int pos)

Expression *	NewThrowTypeError (const char type, const AstRawString arg, int pos)

Expression *	NewThrowError (const AstRawString constructor, const char type, const AstRawString *arg, int pos)

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

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

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

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

const AstRawString *	EmptyIdentifierString ()

Literal *	GetLiteralTheHole (int position, AstNodeFactory< AstConstructionVisitor > *factory)

const AstRawString *	GetSymbol (Scanner *scanner)

const AstRawString *	GetNextSymbol (Scanner *scanner)

const AstRawString *	GetNumberAsSymbol (Scanner *scanner)

Expression *	ThisExpression (Scope scope, AstNodeFactory< AstConstructionVisitor > factory, int pos=RelocInfo::kNoPosition)

Expression *	SuperReference (Scope scope, AstNodeFactory< AstConstructionVisitor > factory, int pos=RelocInfo::kNoPosition)

Expression *	ClassLiteral (const AstRawString name, Expression extends, Expression constructor, ZoneList< ObjectLiteral::Property > properties, int pos, AstNodeFactory< AstConstructionVisitor > factory)

Literal *	ExpressionFromLiteral (Token::Value token, int pos, Scanner scanner, AstNodeFactory< AstConstructionVisitor > factory)

Expression *	ExpressionFromIdentifier (const AstRawString name, int pos, Scope scope, AstNodeFactory< AstConstructionVisitor > *factory)

Expression *	ExpressionFromString (int pos, Scanner scanner, AstNodeFactory< AstConstructionVisitor > factory)

Expression *	GetIterator (Expression iterable, AstNodeFactory< AstConstructionVisitor > factory)

ZoneList< v8::internal::Expression * > *	NewExpressionList (int size, Zone *zone)

ZoneList< ObjectLiteral::Property * > *	NewPropertyList (int size, Zone *zone)

ZoneList< v8::internal::Statement * > *	NewStatementList (int size, Zone *zone)

Scope *	NewScope (Scope *parent_scope, ScopeType scope_type)

int	DeclareArrowParametersFromExpression (Expression expression, Scope scope, Scanner::Location dupe_loc, bool ok)

AstValueFactory *	ast_value_factory ()

Expression *	ParseV8Intrinsic (bool *ok)

FunctionLiteral *	ParseFunctionLiteral (const AstRawString 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)

void	SkipLazyFunctionBody (const AstRawString name, int materialized_literal_count, int expected_property_count, bool ok)

ZoneList< Statement * > *	ParseEagerFunctionBody (const AstRawString name, int pos, Variable fvar, Token::Value fvar_init_op, bool is_generator, bool *ok)

void	CheckConflictingVarDeclarations (v8::internal::Scope scope, bool ok)

Static Public Member Functions
static bool	Parse (CompilationInfo *info, bool allow_lazy=false)

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

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

static bool	IsThisProperty (Expression *expression)

static bool	IsIdentifier (Expression *expression)

static const AstRawString *	AsIdentifier (Expression *expression)

static bool	IsBoilerplateProperty (ObjectLiteral::Property *property)

static bool	IsArrayIndex (const AstRawString string, uint32_t index)

static void	PushLiteralName (FuncNameInferrer fni, const AstRawString id)

static void	InferFunctionName (FuncNameInferrer fni, FunctionLiteral func_to_infer)

static void	CheckFunctionLiteralInsideTopLevelObjectLiteral (Scope scope, ObjectLiteralProperty property, bool *has_function)

static void	CheckAssigningFunctionLiteralToProperty (Expression left, Expression right)

static Expression *	MarkExpressionAsAssigned (Expression *expression)

static const AstRawString *	EmptyIdentifier ()

static Expression *	EmptyExpression ()

static Expression *	EmptyArrowParamList ()

static Literal *	EmptyLiteral ()

static ObjectLiteralProperty *	EmptyObjectLiteralProperty ()

static FunctionLiteral *	EmptyFunctionLiteral ()

static ZoneList< Expression * > *	NullExpressionList ()

Private Types
enum	VariableDeclarationContext { kModuleElement , kBlockElement , kStatement , kForStatement }

enum	VariableDeclarationProperties { kHasInitializers , kHasNoInitializers }

Private Member Functions
FunctionLiteral *	ParseProgram ()

FunctionLiteral *	ParseLazy ()

FunctionLiteral *	ParseLazy (Utf16CharacterStream *source)

Isolate *	isolate ()

CompilationInfo *	info () const

Handle< Script >	script () const

AstValueFactory *	ast_value_factory () const

FunctionLiteral *	DoParseProgram (CompilationInfo info, Scope scope, Scope *ad_hoc_eval_scope)

void	SetCachedData ()

bool	inside_with () const

ScriptCompiler::CompileOptions	compile_options () const

Scope *	DeclarationScope (VariableMode mode)

void *	ParseSourceElements (ZoneList< Statement * > processor, int end_token, bool is_eval, bool is_global, Scope ad_hoc_eval_scope, bool ok)

Statement *	ParseModuleElement (ZoneList< const AstRawString * > labels, bool ok)

Statement *	ParseModuleDeclaration (ZoneList< const AstRawString * > names, bool ok)

Module *	ParseModule (bool *ok)

Module *	ParseModuleLiteral (bool *ok)

Module *	ParseModulePath (bool *ok)

Module *	ParseModuleVariable (bool *ok)

Module *	ParseModuleUrl (bool *ok)

Module *	ParseModuleSpecifier (bool *ok)

Block *	ParseImportDeclaration (bool *ok)

Statement *	ParseExportDeclaration (bool *ok)

Statement *	ParseBlockElement (ZoneList< const AstRawString * > labels, bool ok)

Statement *	ParseStatement (ZoneList< const AstRawString * > labels, bool ok)

Statement *	ParseFunctionDeclaration (ZoneList< const AstRawString * > names, bool ok)

Statement *	ParseClassDeclaration (ZoneList< const AstRawString * > names, bool ok)

Statement *	ParseNativeDeclaration (bool *ok)

Block *	ParseBlock (ZoneList< const AstRawString * > labels, bool ok)

Block *	ParseVariableStatement (VariableDeclarationContext var_context, ZoneList< const AstRawString * > names, bool ok)

Block *	ParseVariableDeclarations (VariableDeclarationContext var_context, VariableDeclarationProperties decl_props, ZoneList< const AstRawString > names, const AstRawString out, bool ok)

Statement *	ParseExpressionOrLabelledStatement (ZoneList< const AstRawString * > labels, bool ok)

IfStatement *	ParseIfStatement (ZoneList< const AstRawString * > labels, bool ok)

Statement *	ParseContinueStatement (bool *ok)

Statement *	ParseBreakStatement (ZoneList< const AstRawString * > labels, bool ok)

Statement *	ParseReturnStatement (bool *ok)

Statement *	ParseWithStatement (ZoneList< const AstRawString * > labels, bool ok)

CaseClause *	ParseCaseClause (bool default_seen_ptr, bool ok)

SwitchStatement *	ParseSwitchStatement (ZoneList< const AstRawString * > labels, bool ok)

DoWhileStatement *	ParseDoWhileStatement (ZoneList< const AstRawString * > labels, bool ok)

WhileStatement *	ParseWhileStatement (ZoneList< const AstRawString * > labels, bool ok)

Statement *	ParseForStatement (ZoneList< const AstRawString * > labels, bool ok)

Statement *	ParseThrowStatement (bool *ok)

Expression *	MakeCatchContext (Handle< String > id, VariableProxy *value)

TryStatement *	ParseTryStatement (bool *ok)

DebuggerStatement *	ParseDebuggerStatement (bool *ok)

Block *	ParseScopedBlock (ZoneList< const AstRawString * > labels, bool ok)

void	InitializeForEachStatement (ForEachStatement stmt, Expression each, Expression subject, Statement body)

Statement *	DesugarLetBindingsInForStatement (Scope inner_scope, ZoneList< const AstRawString > names, ForStatement loop, Statement init, Expression cond, Statement next, Statement body, bool *ok)

FunctionLiteral *	ParseFunctionLiteral (const AstRawString 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)

Expression *	ParseV8Intrinsic (bool *ok)

bool	CheckInOrOf (bool accept_OF, ForEachStatement::VisitMode *visit_mode)

Literal *	GetLiteralUndefined (int position)

void	CheckConflictingVarDeclarations (Scope scope, bool ok)

VariableProxy *	NewUnresolved (const AstRawString name, VariableMode mode, Interface interface)

void	Declare (Declaration declaration, bool resolve, bool ok)

bool	TargetStackContainsLabel (const AstRawString *label)

BreakableStatement *	LookupBreakTarget (const AstRawString label, bool ok)

IterationStatement *	LookupContinueTarget (const AstRawString label, bool ok)

void	RegisterTargetUse (Label target, Target stop)

Scope *	NewScope (Scope *parent, ScopeType type)

void	SkipLazyFunctionBody (const AstRawString function_name, int materialized_literal_count, int expected_property_count, bool ok)

PreParser::PreParseResult	ParseLazyFunctionBodyWithPreParser (SingletonLogger *logger)

ZoneList< Statement * > *	ParseEagerFunctionBody (const AstRawString function_name, int pos, Variable fvar, Token::Value fvar_init_op, bool is_generator, bool *ok)

void	HandleSourceURLComments ()

void	ThrowPendingError ()

Private Attributes
Scanner	scanner_

PreParser *	reusable_preparser_

Scope *	original_scope_

Target *	target_stack_

ParseData *	cached_parse_data_

CompilationInfo *	info_

bool	has_pending_error_

Scanner::Location	pending_error_location_

const char *	pending_error_message_

const AstRawString *	pending_error_arg_

const char *	pending_error_char_arg_

bool	pending_error_is_reference_error_

int	use_counts_ [v8::Isolate::kUseCounterFeatureCount]

int	total_preparse_skipped_

HistogramTimer *	pre_parse_timer_

Static Private Attributes
static const int	kMaxNumFunctionLocals = 4194303

Friends
class	ParserTraits

Additional Inherited Members
Public Types inherited from v8::internal::ParserBase< ParserTraits >
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

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

enum	Mode

enum	PropertyKind

Protected Member Functions inherited from v8::internal::ParserBase< ParserTraits >
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< ParserTraits >
static int	Precedence (Token::Value token, bool accept_IN)

Protected Attributes inherited from v8::internal::ParserBase< ParserTraits >
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 606 of file parser.h.

Member Enumeration Documentation

◆ VariableDeclarationContext

enum v8::internal::Parser::VariableDeclarationContext

private

Enumerator
kModuleElement
kBlockElement
kStatement
kForStatement

Definition at line 660 of file parser.h.

                                   {
     kModuleElement,
     kBlockElement,
     kStatement,
     kForStatement
   };

◆ VariableDeclarationProperties

enum v8::internal::Parser::VariableDeclarationProperties

private

Enumerator
kHasInitializers
kHasNoInitializers

Definition at line 668 of file parser.h.

                                      {
     kHasInitializers,
     kHasNoInitializers
   };

Constructor & Destructor Documentation

◆ Parser()

v8::internal::Parser::Parser	(	CompilationInfo *	info,
		ParseInfo *	parse_info
	)

Definition at line 755 of file parser.cc.

     : ParserBase<ParserTraits>(&scanner_, parse_info->stack_limit,
                                info->extension(), NULL, info->zone(),
                                info->ast_node_id_gen(), this),
       scanner_(parse_info->unicode_cache),
       reusable_preparser_(NULL),
       original_scope_(NULL),
       target_stack_(NULL),
       cached_parse_data_(NULL),
       info_(info),
       has_pending_error_(false),
       pending_error_message_(NULL),
       pending_error_arg_(NULL),
       pending_error_char_arg_(NULL),
       total_preparse_skipped_(0),
       pre_parse_timer_(NULL) {
   DCHECK(!script().is_null() || info->source_stream() != NULL);
   set_allow_harmony_scoping(!info->is_native() && FLAG_harmony_scoping);
   set_allow_modules(!info->is_native() && FLAG_harmony_modules);
   set_allow_natives_syntax(FLAG_allow_natives_syntax || info->is_native());
   set_allow_lazy(false);  // Must be explicitly enabled.
   set_allow_arrow_functions(FLAG_harmony_arrow_functions);
   set_allow_harmony_numeric_literals(FLAG_harmony_numeric_literals);
   set_allow_classes(FLAG_harmony_classes);
   set_allow_harmony_object_literals(FLAG_harmony_object_literals);
   for (int feature = 0; feature < v8::Isolate::kUseCounterFeatureCount;
        ++feature) {
     use_counts_[feature] = 0;
   }
   if (info->ast_value_factory() == NULL) {
     // info takes ownership of AstValueFactory.
     info->SetAstValueFactory(
         new AstValueFactory(zone(), parse_info->hash_seed));
   }
 }

Here is the call graph for this function:

◆ ~Parser()

v8::internal::Parser::~Parser ( )

inline

Definition at line 618 of file parser.h.

             {
     delete reusable_preparser_;
     reusable_preparser_ = NULL;
     delete cached_parse_data_;
     cached_parse_data_ = NULL;
   }

References cached_parse_data_, NULL, and reusable_preparser_.

Member Function Documentation

◆ ast_value_factory()

AstValueFactory* v8::internal::Parser::ast_value_factory ( ) const

inlineprivate

Definition at line 682 of file parser.h.

                                              {
     return info_->ast_value_factory();
   }

References v8::internal::CompilationInfo::ast_value_factory(), and info_.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CheckConflictingVarDeclarations()

void v8::internal::Parser::CheckConflictingVarDeclarations	(	Scope *	scope,
		bool *	ok
	)

private

Definition at line 3919 of file parser.cc.

                                                                    {
   Declaration* decl = scope->CheckConflictingVarDeclarations();
   if (decl != NULL) {
     // In harmony mode we treat conflicting variable bindinds as early
     // errors. See ES5 16 for a definition of early errors.
     const AstRawString* name = decl->proxy()->raw_name();
     int position = decl->proxy()->position();
     Scanner::Location location = position == RelocInfo::kNoPosition
         ? Scanner::Location::invalid()
         : Scanner::Location(position, position + 1);
     ParserTraits::ReportMessageAt(location, "var_redeclaration", name);
     *ok = false;
   }
 }

References v8::internal::Scope::CheckConflictingVarDeclarations(), v8::internal::Scanner::Location::invalid(), v8::internal::RelocInfo::kNoPosition, name, NULL, v8::internal::ParserBase< ParserTraits >::position(), v8::internal::Declaration::proxy(), and v8::internal::ParserTraits::ReportMessageAt().

Referenced by v8::internal::ParserTraits::CheckConflictingVarDeclarations(), DoParseProgram(), and ParseFunctionLiteral().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CheckInOrOf()

bool v8::internal::Parser::CheckInOrOf	(	bool	accept_OF,
		ForEachStatement::VisitMode *	visit_mode
	)

private

Definition at line 2856 of file parser.cc.

                                                                 {
   if (Check(Token::IN)) {
     *visit_mode = ForEachStatement::ENUMERATE;
     return true;
   } else if (accept_OF && CheckContextualKeyword(CStrVector("of"))) {
     *visit_mode = ForEachStatement::ITERATE;
     return true;
   }
   return false;
 }

References v8::internal::ParserBase< ParserTraits >::Check(), v8::internal::ParserBase< ParserTraits >::CheckContextualKeyword(), v8::internal::CStrVector(), v8::internal::ForEachStatement::ENUMERATE, IN, and v8::internal::ForEachStatement::ITERATE.

Referenced by ParseForStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compile_options()

ScriptCompiler::CompileOptions v8::internal::Parser::compile_options ( ) const

inlineprivate

Definition at line 693 of file parser.h.

                                                        {
     return info_->compile_options();
   }

References v8::internal::CompilationInfo::compile_options(), and info_.

Referenced by ParseOnBackground(), ParseProgram(), SetCachedData(), and SkipLazyFunctionBody().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeclarationScope()

Scope* v8::internal::Parser::DeclarationScope ( VariableMode mode )

inlineprivate

Definition at line 696 of file parser.h.

                                              {
     return IsLexicalVariableMode(mode)
         ? scope_ : scope_->DeclarationScope();
   }

References v8::internal::IsLexicalVariableMode(), v8::internal::ParserBase< ParserTraits >::mode(), and v8::internal::ParserBase< ParserTraits >::scope_.

Referenced by Declare(), NewUnresolved(), ParseNativeDeclaration(), and ParseVariableDeclarations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Declare()

void v8::internal::Parser::Declare	(	Declaration *	declaration,
		bool	resolve,
		bool *	ok
	)

private

Definition at line 1717 of file parser.cc.

                                                                      {
   VariableProxy* proxy = declaration->proxy();
   DCHECK(proxy->raw_name() != NULL);
   const AstRawString* name = proxy->raw_name();
   VariableMode mode = declaration->mode();
   Scope* declaration_scope = DeclarationScope(mode);
   Variable* var = NULL;
  
   // If a suitable scope exists, then we can statically declare this
   // variable and also set its mode. In any case, a Declaration node
   // will be added to the scope so that the declaration can be added
   // to the corresponding activation frame at runtime if necessary.
   // For instance declarations inside an eval scope need to be added
   // to the calling function context.
   // Similarly, strict mode eval scope does not leak variable declarations to
   // the caller's scope so we declare all locals, too.
   if (declaration_scope->is_function_scope() ||
       declaration_scope->is_strict_eval_scope() ||
       declaration_scope->is_block_scope() ||
       declaration_scope->is_module_scope() ||
       declaration_scope->is_global_scope()) {
     // Declare the variable in the declaration scope.
     // For the global scope, we have to check for collisions with earlier
     // (i.e., enclosing) global scopes, to maintain the illusion of a single
     // global scope.
     var = declaration_scope->is_global_scope()
         ? declaration_scope->Lookup(name)
         : declaration_scope->LookupLocal(name);
     if (var == NULL) {
       // Declare the name.
       var = declaration_scope->DeclareLocal(name, mode,
                                             declaration->initialization(),
                                             kNotAssigned, proxy->interface());
     } else if (IsLexicalVariableMode(mode) || IsLexicalVariableMode(var->mode())
                || ((mode == CONST_LEGACY || var->mode() == CONST_LEGACY) &&
                    !declaration_scope->is_global_scope())) {
       // The name was declared in this scope before; check for conflicting
       // re-declarations. We have a conflict if either of the declarations is
       // not a var (in the global scope, we also have to ignore legacy const for
       // compatibility). There is similar code in runtime.cc in the Declare
       // functions. The function CheckConflictingVarDeclarations checks for
       // var and let bindings from different scopes whereas this is a check for
       // conflicting declarations within the same scope. This check also covers
       // the special case
       //
       // function () { let x; { var x; } }
       //
       // because the var declaration is hoisted to the function scope where 'x'
       // is already bound.
       DCHECK(IsDeclaredVariableMode(var->mode()));
       if (allow_harmony_scoping() && strict_mode() == STRICT) {
         // In harmony we treat re-declarations as early errors. See
         // ES5 16 for a definition of early errors.
         ParserTraits::ReportMessage("var_redeclaration", name);
         *ok = false;
         return;
       }
       Expression* expression = NewThrowTypeError(
           "var_redeclaration", name, declaration->position());
       declaration_scope->SetIllegalRedeclaration(expression);
     } else if (mode == VAR) {
       var->set_maybe_assigned();
     }
   }
  
   // We add a declaration node for every declaration. The compiler
   // will only generate code if necessary. In particular, declarations
   // for inner local variables that do not represent functions won't
   // result in any generated code.
   //
   // Note that we always add an unresolved proxy even if it's not
   // used, simply because we don't know in this method (w/o extra
   // parameters) if the proxy is needed or not. The proxy will be
   // bound during variable resolution time unless it was pre-bound
   // below.
   //
   // WARNING: This will lead to multiple declaration nodes for the
   // same variable if it is declared several times. This is not a
   // semantic issue as long as we keep the source order, but it may be
   // a performance issue since it may lead to repeated
   // RuntimeHidden_DeclareLookupSlot calls.
   declaration_scope->AddDeclaration(declaration);
  
   if (mode == CONST_LEGACY && declaration_scope->is_global_scope()) {
     // For global const variables we bind the proxy to a variable.
     DCHECK(resolve);  // should be set by all callers
     Variable::Kind kind = Variable::NORMAL;
     var = new (zone())
         Variable(declaration_scope, name, mode, true, kind,
                  kNeedsInitialization, kNotAssigned, proxy->interface());
   } else if (declaration_scope->is_eval_scope() &&
              declaration_scope->strict_mode() == SLOPPY) {
     // For variable declarations in a sloppy eval scope the proxy is bound
     // to a lookup variable to force a dynamic declaration using the
     // DeclareLookupSlot runtime function.
     Variable::Kind kind = Variable::NORMAL;
     // TODO(sigurds) figure out if kNotAssigned is OK here
     var = new (zone()) Variable(declaration_scope, name, mode, true, kind,
                                 declaration->initialization(), kNotAssigned,
                                 proxy->interface());
     var->AllocateTo(Variable::LOOKUP, -1);
     resolve = true;
   }
  
   // If requested and we have a local variable, bind the proxy to the variable
   // at parse-time. This is used for functions (and consts) declared inside
   // statements: the corresponding function (or const) variable must be in the
   // function scope and not a statement-local scope, e.g. as provided with a
   // 'with' statement:
   //
   //   with (obj) {
   //     function f() {}
   //   }
   //
   // which is translated into:
   //
   //   with (obj) {
   //     // in this case this is not: 'var f; f = function () {};'
   //     var f = function () {};
   //   }
   //
   // Note that if 'f' is accessed from inside the 'with' statement, it
   // will be allocated in the context (because we must be able to look
   // it up dynamically) but it will also be accessed statically, i.e.,
   // with a context slot index and a context chain length for this
   // initialization code. Thus, inside the 'with' statement, we need
   // both access to the static and the dynamic context chain; the
   // runtime needs to provide both.
   if (resolve && var != NULL) {
     proxy->BindTo(var);
  
     if (FLAG_harmony_modules) {
       bool ok;
 #ifdef DEBUG
       if (FLAG_print_interface_details) {
         PrintF("# Declare %.*s ", var->raw_name()->length(),
                var->raw_name()->raw_data());
       }
 #endif
       proxy->interface()->Unify(var->interface(), zone(), &ok);
       if (!ok) {
 #ifdef DEBUG
         if (FLAG_print_interfaces) {
           PrintF("DECLARE TYPE ERROR\n");
           PrintF("proxy: ");
           proxy->interface()->Print();
           PrintF("var: ");
           var->interface()->Print();
         }
 #endif
         ParserTraits::ReportMessage("module_type_error", name);
       }
     }
   }
 }

References v8::internal::Scope::AddDeclaration(), v8::internal::Variable::AllocateTo(), v8::internal::ParserBase< ParserTraits >::allow_harmony_scoping(), v8::internal::CONST_LEGACY, DCHECK, DeclarationScope(), v8::internal::Scope::DeclareLocal(), v8::internal::Declaration::initialization(), v8::internal::Variable::interface(), v8::internal::Scope::is_block_scope(), v8::internal::Scope::is_eval_scope(), v8::internal::Scope::is_function_scope(), v8::internal::Scope::is_global_scope(), v8::internal::Scope::is_module_scope(), v8::internal::Scope::is_strict_eval_scope(), v8::internal::IsDeclaredVariableMode(), v8::internal::IsLexicalVariableMode(), v8::internal::kNeedsInitialization, v8::internal::kNotAssigned, v8::internal::AstRawString::length(), v8::internal::Scope::Lookup(), v8::internal::Variable::LOOKUP, v8::internal::Scope::LookupLocal(), v8::internal::Declaration::mode(), v8::internal::ParserBase< ParserTraits >::mode(), v8::internal::Variable::mode(), name, v8::internal::ParserTraits::NewThrowTypeError(), v8::internal::Variable::NORMAL, NULL, v8::internal::AstNode::position(), v8::internal::PrintF(), v8::internal::Declaration::proxy(), v8::internal::AstRawString::raw_data(), v8::internal::Variable::raw_name(), v8::internal::ParserTraits::ReportMessage(), v8::internal::Variable::set_maybe_assigned(), v8::internal::Scope::SetIllegalRedeclaration(), v8::internal::SLOPPY, v8::internal::STRICT, v8::internal::ParserBase< ParserTraits >::strict_mode(), v8::internal::Scope::strict_mode(), v8::internal::VAR, and v8::internal::ParserBase< ParserTraits >::zone().

Referenced by DesugarLetBindingsInForStatement(), ParseClassDeclaration(), ParseFunctionDeclaration(), ParseImportDeclaration(), ParseModuleDeclaration(), ParseNativeDeclaration(), and ParseVariableDeclarations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DesugarLetBindingsInForStatement()

Statement * v8::internal::Parser::DesugarLetBindingsInForStatement	(	Scope *	inner_scope,
		ZoneList< const AstRawString * > *	names,
		ForStatement *	loop,
		Statement *	init,
		Expression *	cond,
		Statement *	next,
		Statement *	body,
		bool *	ok
	)

private

Definition at line 2938 of file parser.cc.

                                {
   // ES6 13.6.3.4 specifies that on each loop iteration the let variables are
   // copied into a new environment. After copying, the "next" statement of the
   // loop is executed to update the loop variables. The loop condition is
   // checked and the loop body is executed.
   //
   // We rewrite a for statement of the form
   //
   //  for (let x = i; cond; next) body
   //
   // into
   //
   //  {
   //     let x = i;
   //     temp_x = x;
   //     flag = 1;
   //     for (;;) {
   //        let x = temp_x;
   //        if (flag == 1) {
   //          flag = 0;
   //        } else {
   //          next;
   //        }
   //        if (cond) {
   //          <empty>
   //        } else {
   //          break;
   //        }
   //        b
   //        temp_x = x;
   //     }
   //  }
  
   DCHECK(names->length() > 0);
   Scope* for_scope = scope_;
   ZoneList<Variable*> temps(names->length(), zone());
  
   Block* outer_block = factory()->NewBlock(NULL, names->length() + 3, false,
                                            RelocInfo::kNoPosition);
   outer_block->AddStatement(init, zone());
  
   const AstRawString* temp_name = ast_value_factory()->dot_for_string();
  
   // For each let variable x:
   //   make statement: temp_x = x.
   for (int i = 0; i < names->length(); i++) {
     VariableProxy* proxy =
         NewUnresolved(names->at(i), LET, Interface::NewValue());
     Variable* temp = scope_->DeclarationScope()->NewTemporary(temp_name);
     VariableProxy* temp_proxy = factory()->NewVariableProxy(temp);
     Assignment* assignment = factory()->NewAssignment(
         Token::ASSIGN, temp_proxy, proxy, RelocInfo::kNoPosition);
     Statement* assignment_statement = factory()->NewExpressionStatement(
         assignment, RelocInfo::kNoPosition);
     outer_block->AddStatement(assignment_statement, zone());
     temps.Add(temp, zone());
   }
  
   Variable* flag = scope_->DeclarationScope()->NewTemporary(temp_name);
   // Make statement: flag = 1.
   {
     VariableProxy* flag_proxy = factory()->NewVariableProxy(flag);
     Expression* const1 = factory()->NewSmiLiteral(1, RelocInfo::kNoPosition);
     Assignment* assignment = factory()->NewAssignment(
         Token::ASSIGN, flag_proxy, const1, RelocInfo::kNoPosition);
     Statement* assignment_statement = factory()->NewExpressionStatement(
         assignment, RelocInfo::kNoPosition);
     outer_block->AddStatement(assignment_statement, zone());
   }
  
   outer_block->AddStatement(loop, zone());
   outer_block->set_scope(for_scope);
   scope_ = inner_scope;
  
   Block* inner_block = factory()->NewBlock(NULL, 2 * names->length() + 3,
                                            false, RelocInfo::kNoPosition);
   int pos = scanner()->location().beg_pos;
   ZoneList<Variable*> inner_vars(names->length(), zone());
  
   // For each let variable x:
   //    make statement: let x = temp_x.
   for (int i = 0; i < names->length(); i++) {
     VariableProxy* proxy =
         NewUnresolved(names->at(i), LET, Interface::NewValue());
     Declaration* declaration =
         factory()->NewVariableDeclaration(proxy, LET, scope_, pos);
     Declare(declaration, true, CHECK_OK);
     inner_vars.Add(declaration->proxy()->var(), zone());
     VariableProxy* temp_proxy = factory()->NewVariableProxy(temps.at(i));
     Assignment* assignment = factory()->NewAssignment(
         Token::INIT_LET, proxy, temp_proxy, pos);
     Statement* assignment_statement = factory()->NewExpressionStatement(
         assignment, pos);
     proxy->var()->set_initializer_position(pos);
     inner_block->AddStatement(assignment_statement, zone());
   }
  
   // Make statement: if (flag == 1) { flag = 0; } else { next; }.
   if (next) {
     Expression* compare = NULL;
     // Make compare expresion: flag == 1.
     {
       Expression* const1 = factory()->NewSmiLiteral(1, RelocInfo::kNoPosition);
       VariableProxy* flag_proxy = factory()->NewVariableProxy(flag);
       compare = factory()->NewCompareOperation(
           Token::EQ, flag_proxy, const1, pos);
     }
     Statement* clear_flag = NULL;
     // Make statement: flag = 0.
     {
       VariableProxy* flag_proxy = factory()->NewVariableProxy(flag);
       Expression* const0 = factory()->NewSmiLiteral(0, RelocInfo::kNoPosition);
       Assignment* assignment = factory()->NewAssignment(
           Token::ASSIGN, flag_proxy, const0, RelocInfo::kNoPosition);
       clear_flag = factory()->NewExpressionStatement(assignment, pos);
     }
     Statement* clear_flag_or_next = factory()->NewIfStatement(
         compare, clear_flag, next, RelocInfo::kNoPosition);
     inner_block->AddStatement(clear_flag_or_next, zone());
   }
  
  
   // Make statement: if (cond) { } else { break; }.
   if (cond) {
     Statement* empty = factory()->NewEmptyStatement(RelocInfo::kNoPosition);
     BreakableStatement* t = LookupBreakTarget(NULL, CHECK_OK);
     Statement* stop = factory()->NewBreakStatement(t, RelocInfo::kNoPosition);
     Statement* if_not_cond_break = factory()->NewIfStatement(
         cond, empty, stop, cond->position());
     inner_block->AddStatement(if_not_cond_break, zone());
   }
  
   inner_block->AddStatement(body, zone());
  
   // For each let variable x:
   //   make statement: temp_x = x;
   for (int i = 0; i < names->length(); i++) {
     VariableProxy* temp_proxy = factory()->NewVariableProxy(temps.at(i));
     int pos = scanner()->location().end_pos;
     VariableProxy* proxy = factory()->NewVariableProxy(inner_vars.at(i), pos);
     Assignment* assignment = factory()->NewAssignment(
         Token::ASSIGN, temp_proxy, proxy, RelocInfo::kNoPosition);
     Statement* assignment_statement = factory()->NewExpressionStatement(
         assignment, RelocInfo::kNoPosition);
     inner_block->AddStatement(assignment_statement, zone());
   }
  
   inner_scope->set_end_position(scanner()->location().end_pos);
   inner_block->set_scope(inner_scope);
   scope_ = for_scope;
  
   loop->Initialize(NULL, NULL, NULL, inner_block);
   return outer_block;
 }

References v8::internal::List< T, AllocationPolicy >::Add(), ast_value_factory(), v8::internal::List< T, AllocationPolicy >::at(), v8::internal::Scanner::Location::beg_pos, CHECK_OK, DCHECK, Declare(), v8::internal::Scanner::Location::end_pos, v8::internal::EQ, v8::internal::ParserBase< ParserTraits >::factory(), v8::internal::flag, v8::internal::Scope::Initialize(), v8::internal::RelocInfo::kNoPosition, v8::internal::LET, v8::internal::Scanner::location(), LookupBreakTarget(), NewUnresolved(), v8::internal::Interface::NewValue(), NULL, v8::internal::AstNode::position(), v8::internal::Declaration::proxy(), v8::internal::ParserBase< ParserTraits >::scanner(), v8::internal::ParserBase< ParserTraits >::scope_, v8::internal::Scope::set_end_position(), and v8::internal::ParserBase< ParserTraits >::zone().

Referenced by ParseForStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoParseProgram()

FunctionLiteral * v8::internal::Parser::DoParseProgram	(	CompilationInfo *	info,
		Scope **	scope,
		Scope **	ad_hoc_eval_scope
	)

private

Definition at line 861 of file parser.cc.

                                                             {
   DCHECK(scope_ == NULL);
   DCHECK(target_stack_ == NULL);
  
   FunctionLiteral* result = NULL;
   {
     *scope = NewScope(scope_, GLOBAL_SCOPE);
     info->SetGlobalScope(*scope);
     if (!info->context().is_null() && !info->context()->IsNativeContext()) {
       *scope = Scope::DeserializeScopeChain(*info->context(), *scope, zone());
       // The Scope is backed up by ScopeInfo (which is in the V8 heap); this
       // means the Parser cannot operate independent of the V8 heap. Tell the
       // string table to internalize strings and values right after they're
       // created.
       ast_value_factory()->Internalize(isolate());
     }
     original_scope_ = *scope;
     if (info->is_eval()) {
       if (!(*scope)->is_global_scope() || info->strict_mode() == STRICT) {
         *scope = NewScope(*scope, EVAL_SCOPE);
       }
     } else if (info->is_global()) {
       *scope = NewScope(*scope, GLOBAL_SCOPE);
     }
     (*scope)->set_start_position(0);
     // End position will be set by the caller.
  
     // Compute the parsing mode.
     Mode mode = (FLAG_lazy && allow_lazy()) ? PARSE_LAZILY : PARSE_EAGERLY;
     if (allow_natives_syntax() || extension_ != NULL ||
         (*scope)->is_eval_scope()) {
       mode = PARSE_EAGERLY;
     }
     ParsingModeScope parsing_mode(this, mode);
  
     // Enters 'scope'.
     FunctionState function_state(&function_state_, &scope_, *scope, zone(),
                                  ast_value_factory(), info->ast_node_id_gen());
  
     scope_->SetStrictMode(info->strict_mode());
     ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(16, zone());
     bool ok = true;
     int beg_pos = scanner()->location().beg_pos;
     ParseSourceElements(body, Token::EOS, info->is_eval(), true, eval_scope,
                         &ok);
  
     if (ok && strict_mode() == STRICT) {
       CheckOctalLiteral(beg_pos, scanner()->location().end_pos, &ok);
     }
  
     if (ok && allow_harmony_scoping() && strict_mode() == STRICT) {
       CheckConflictingVarDeclarations(scope_, &ok);
     }
  
     if (ok && info->parse_restriction() == ONLY_SINGLE_FUNCTION_LITERAL) {
       if (body->length() != 1 ||
           !body->at(0)->IsExpressionStatement() ||
           !body->at(0)->AsExpressionStatement()->
               expression()->IsFunctionLiteral()) {
         ReportMessage("single_function_literal");
         ok = false;
       }
     }
  
     if (ok) {
       result = factory()->NewFunctionLiteral(
           ast_value_factory()->empty_string(), ast_value_factory(), scope_,
           body, function_state.materialized_literal_count(),
           function_state.expected_property_count(),
           function_state.handler_count(), 0,
           FunctionLiteral::kNoDuplicateParameters,
           FunctionLiteral::ANONYMOUS_EXPRESSION, FunctionLiteral::kGlobalOrEval,
           FunctionLiteral::kNotParenthesized, FunctionKind::kNormalFunction, 0);
       result->set_ast_properties(factory()->visitor()->ast_properties());
       result->set_dont_optimize_reason(
           factory()->visitor()->dont_optimize_reason());
     }
   }
  
   // Make sure the target stack is empty.
   DCHECK(target_stack_ == NULL);
  
   return result;
 }

References v8::internal::ParserBase< ParserTraits >::allow_harmony_scoping(), v8::internal::ParserBase< ParserTraits >::allow_lazy(), v8::internal::ParserBase< ParserTraits >::allow_natives_syntax(), v8::internal::CompilationInfo::ast_node_id_gen(), ast_value_factory(), v8::internal::List< T, AllocationPolicy >::at(), v8::internal::Scanner::Location::beg_pos, CheckConflictingVarDeclarations(), v8::internal::ParserBase< ParserTraits >::CheckOctalLiteral(), v8::internal::CompilationInfo::context(), DCHECK, v8::internal::Scope::DeserializeScopeChain(), v8::internal::EVAL_SCOPE, v8::internal::ParserBase< ParserTraits >::extension_, v8::internal::ParserBase< ParserTraits >::factory(), v8::internal::ParserBase< ParserTraits >::function_state_, v8::internal::GLOBAL_SCOPE, info(), v8::internal::AstValueFactory::Internalize(), v8::internal::CompilationInfo::is_eval(), v8::internal::CompilationInfo::is_global(), isolate(), v8::internal::kNormalFunction, v8::internal::Scanner::location(), v8::internal::ParserBase< ParserTraits >::mode(), NewScope(), NULL, v8::internal::ONLY_SINGLE_FUNCTION_LITERAL, original_scope_, v8::internal::ParserBase< ParserTraits >::PARSE_EAGERLY, v8::internal::ParserBase< ParserTraits >::PARSE_LAZILY, v8::internal::CompilationInfo::parse_restriction(), ParseSourceElements(), v8::internal::ParserBase< ParserTraits >::ReportMessage(), v8::internal::ParserBase< ParserTraits >::scanner(), v8::internal::ParserBase< ParserTraits >::scope_, v8::internal::CompilationInfo::SetGlobalScope(), v8::internal::STRICT, v8::internal::ParserBase< ParserTraits >::strict_mode(), v8::internal::CompilationInfo::strict_mode(), target_stack_, and v8::internal::ParserBase< ParserTraits >::zone().

Referenced by ParseOnBackground(), and ParseProgram().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetLiteralUndefined()

Literal * v8::internal::Parser::GetLiteralUndefined ( int position )

private

Definition at line 3914 of file parser.cc.

                                                  {
   return factory()->NewUndefinedLiteral(position);
 }

References v8::internal::ParserBase< ParserTraits >::factory(), and v8::internal::ParserBase< ParserTraits >::position().

Referenced by ParseReturnStatement(), and ParseVariableDeclarations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleSourceURLComments()

void v8::internal::Parser::HandleSourceURLComments ( )

private

Definition at line 3993 of file parser.cc.

                                      {
   if (scanner_.source_url()->length() > 0) {
     Handle<String> source_url = scanner_.source_url()->Internalize(isolate());
     info_->script()->set_source_url(*source_url);
   }
   if (scanner_.source_mapping_url()->length() > 0) {
     Handle<String> source_mapping_url =
         scanner_.source_mapping_url()->Internalize(isolate());
     info_->script()->set_source_mapping_url(*source_mapping_url);
   }
 }

References info_, v8::internal::LiteralBuffer::Internalize(), isolate(), v8::internal::LiteralBuffer::length(), scanner_, v8::internal::CompilationInfo::script(), v8::internal::Scanner::source_mapping_url(), and v8::internal::Scanner::source_url().

Referenced by ParseProgram().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ info()

CompilationInfo* v8::internal::Parser::info ( ) const

inlineprivate

Definition at line 680 of file parser.h.

680 { return info_; }

References info_.

Referenced by DoParseProgram(), Internalize(), Parse(), ParseFunctionLiteral(), ParseLazy(), ParseOnBackground(), ParseProgram(), and Parser().

Here is the caller graph for this function:

◆ InitializeForEachStatement()

void v8::internal::Parser::InitializeForEachStatement	(	ForEachStatement *	stmt,
		Expression *	each,
		Expression *	subject,
		Statement *	body
	)

private

Definition at line 2869 of file parser.cc.

                                                          {
   ForOfStatement* for_of = stmt->AsForOfStatement();
  
   if (for_of != NULL) {
     Variable* iterator = scope_->DeclarationScope()->NewTemporary(
         ast_value_factory()->dot_iterator_string());
     Variable* result = scope_->DeclarationScope()->NewTemporary(
         ast_value_factory()->dot_result_string());
  
     Expression* assign_iterator;
     Expression* next_result;
     Expression* result_done;
     Expression* assign_each;
  
     // var iterator = subject[Symbol.iterator]();
     assign_iterator = factory()->NewAssignment(
         Token::ASSIGN, factory()->NewVariableProxy(iterator),
         GetIterator(subject, factory()), RelocInfo::kNoPosition);
  
     // var result = iterator.next();
     {
       Expression* iterator_proxy = factory()->NewVariableProxy(iterator);
       Expression* next_literal = factory()->NewStringLiteral(
           ast_value_factory()->next_string(), RelocInfo::kNoPosition);
       Expression* next_property = factory()->NewProperty(
           iterator_proxy, next_literal, RelocInfo::kNoPosition);
       ZoneList<Expression*>* next_arguments =
           new(zone()) ZoneList<Expression*>(0, zone());
       Expression* next_call = factory()->NewCall(
           next_property, next_arguments, RelocInfo::kNoPosition);
       Expression* result_proxy = factory()->NewVariableProxy(result);
       next_result = factory()->NewAssignment(
           Token::ASSIGN, result_proxy, next_call, RelocInfo::kNoPosition);
     }
  
     // result.done
     {
       Expression* done_literal = factory()->NewStringLiteral(
           ast_value_factory()->done_string(), RelocInfo::kNoPosition);
       Expression* result_proxy = factory()->NewVariableProxy(result);
       result_done = factory()->NewProperty(
           result_proxy, done_literal, RelocInfo::kNoPosition);
     }
  
     // each = result.value
     {
       Expression* value_literal = factory()->NewStringLiteral(
           ast_value_factory()->value_string(), RelocInfo::kNoPosition);
       Expression* result_proxy = factory()->NewVariableProxy(result);
       Expression* result_value = factory()->NewProperty(
           result_proxy, value_literal, RelocInfo::kNoPosition);
       assign_each = factory()->NewAssignment(
           Token::ASSIGN, each, result_value, RelocInfo::kNoPosition);
     }
  
     for_of->Initialize(each, subject, body,
                        assign_iterator,
                        next_result,
                        result_done,
                        assign_each);
   } else {
     stmt->Initialize(each, subject, body);
   }
 }

References ast_value_factory(), v8::internal::ParserBase< ParserTraits >::factory(), v8::internal::ParserTraits::GetIterator(), v8::internal::ForEachStatement::Initialize(), v8::internal::RelocInfo::kNoPosition, NULL, v8::internal::ParserBase< ParserTraits >::scope_, and v8::internal::ParserBase< ParserTraits >::zone().

Referenced by ParseForStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ inside_with()

bool v8::internal::Parser::inside_with ( ) const

inlineprivate

Definition at line 692 of file parser.h.

692 { return scope_->inside_with(); }

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

Referenced by ParseVariableDeclarations().

Here is the caller graph for this function:

◆ Internalize()

void v8::internal::Parser::Internalize ( )

Definition at line 4037 of file parser.cc.

                          {
   // Internalize strings.
   ast_value_factory()->Internalize(isolate());
  
   // Error processing.
   if (info()->function() == NULL) {
     if (stack_overflow()) {
       isolate()->StackOverflow();
     } else {
       ThrowPendingError();
     }
   }
  
   // Move statistics to Isolate.
   for (int feature = 0; feature < v8::Isolate::kUseCounterFeatureCount;
        ++feature) {
     for (int i = 0; i < use_counts_[feature]; ++i) {
       isolate()->CountUsage(v8::Isolate::UseCounterFeature(feature));
     }
   }
   isolate()->counters()->total_preparse_skipped()->Increment(
       total_preparse_skipped_);
 }

References ast_value_factory(), v8::internal::Isolate::counters(), v8::internal::Isolate::CountUsage(), info(), v8::internal::AstValueFactory::Internalize(), isolate(), v8::Isolate::kUseCounterFeatureCount, NULL, v8::internal::ParserBase< ParserTraits >::stack_overflow(), v8::internal::Isolate::StackOverflow(), ThrowPendingError(), total_preparse_skipped_, and use_counts_.

Referenced by Parse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isolate()

Isolate* v8::internal::Parser::isolate ( )

inlineprivate

Definition at line 679 of file parser.h.

679 { return info_->isolate(); }

v8::internal::CompilationInfo::isolate

Isolate * isolate() const

Definition: compiler.h:96

References info_, and v8::internal::CompilationInfo::isolate().

Referenced by DoParseProgram(), v8::internal::CompileTimeValue::GetValue(), HandleSourceURLComments(), Internalize(), Parse(), ParseLazy(), ParseProgram(), and ThrowPendingError().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LookupBreakTarget()

BreakableStatement * v8::internal::Parser::LookupBreakTarget	(	const AstRawString *	label,
		bool *	ok
	)

private

Definition at line 3949 of file parser.cc.

                                                         {
   bool anonymous = label == NULL;
   for (Target* t = target_stack_; t != NULL; t = t->previous()) {
     BreakableStatement* stat = t->node()->AsBreakableStatement();
     if (stat == NULL) continue;
     if ((anonymous && stat->is_target_for_anonymous()) ||
         (!anonymous && ContainsLabel(stat->labels(), label))) {
       RegisterTargetUse(stat->break_target(), t->previous());
       return stat;
     }
   }
   return NULL;
 }

References v8::internal::BreakableStatement::AsBreakableStatement(), v8::internal::BreakableStatement::break_target(), v8::internal::ContainsLabel(), v8::internal::BreakableStatement::is_target_for_anonymous(), v8::internal::BreakableStatement::labels(), NULL, RegisterTargetUse(), and target_stack_.

Referenced by DesugarLetBindingsInForStatement(), and ParseBreakStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LookupContinueTarget()

IterationStatement * v8::internal::Parser::LookupContinueTarget	(	const AstRawString *	label,
		bool *	ok
	)

private

Definition at line 3965 of file parser.cc.

                                                            {
   bool anonymous = label == NULL;
   for (Target* t = target_stack_; t != NULL; t = t->previous()) {
     IterationStatement* stat = t->node()->AsIterationStatement();
     if (stat == NULL) continue;
  
     DCHECK(stat->is_target_for_anonymous());
     if (anonymous || ContainsLabel(stat->labels(), label)) {
       RegisterTargetUse(stat->continue_target(), t->previous());
       return stat;
     }
   }
   return NULL;
 }

References v8::internal::IterationStatement::AsIterationStatement(), v8::internal::ContainsLabel(), v8::internal::IterationStatement::continue_target(), DCHECK, v8::internal::BreakableStatement::is_target_for_anonymous(), v8::internal::BreakableStatement::labels(), NULL, RegisterTargetUse(), and target_stack_.

Referenced by ParseContinueStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MakeCatchContext()

Expression* v8::internal::Parser::MakeCatchContext	(	Handle< String >	id,
		VariableProxy *	value
	)

private

◆ NewScope()

Scope * v8::internal::Parser::NewScope	(	Scope *	parent,
		ScopeType	type
	)

private

Definition at line 269 of file parser.cc.

                                                            {
   DCHECK(ast_value_factory());
   Scope* result =
       new (zone()) Scope(parent, scope_type, ast_value_factory(), zone());
   result->Initialize();
   return result;
 }

References ast_value_factory(), DCHECK, v8::internal::Scope::Initialize(), and v8::internal::ParserBase< ParserTraits >::zone().

Referenced by DoParseProgram(), v8::internal::ParserTraits::NewScope(), ParseForStatement(), ParseFunctionLiteral(), ParseLazy(), ParseModuleLiteral(), ParseModuleUrl(), ParseScopedBlock(), ParseSourceElements(), ParseTryStatement(), and ParseWithStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NewUnresolved()

VariableProxy * v8::internal::Parser::NewUnresolved	(	const AstRawString *	name,
		VariableMode	mode,
		Interface *	interface
	)

private

Definition at line 1705 of file parser.cc.

                                                                               {
   // If we are inside a function, a declaration of a var/const variable is a
   // truly local variable, and the scope of the variable is always the function
   // scope.
   // Let/const variables in harmony mode are always added to the immediately
   // enclosing scope.
   return DeclarationScope(mode)->NewUnresolved(
       factory(), name, interface, position());
 }

References DeclarationScope(), v8::internal::ParserBase< ParserTraits >::factory(), v8::internal::ParserBase< ParserTraits >::mode(), name, v8::internal::Scope::NewUnresolved(), and v8::internal::ParserBase< ParserTraits >::position().

Referenced by DesugarLetBindingsInForStatement(), ParseClassDeclaration(), ParseExportDeclaration(), ParseForStatement(), ParseFunctionDeclaration(), ParseImportDeclaration(), ParseModuleDeclaration(), ParseNativeDeclaration(), and ParseVariableDeclarations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Parse() [1/2]

bool v8::internal::Parser::Parse ( )

Definition at line 4893 of file parser.cc.

                    {
   DCHECK(info()->function() == NULL);
   FunctionLiteral* result = NULL;
   pre_parse_timer_ = isolate()->counters()->pre_parse();
   if (FLAG_trace_parse || allow_natives_syntax() || extension_ != NULL) {
     // If intrinsics are allowed, the Parser cannot operate independent of the
     // V8 heap because of Runtime. Tell the string table to internalize strings
     // and values right after they're created.
     ast_value_factory()->Internalize(isolate());
   }
  
   if (info()->is_lazy()) {
     DCHECK(!info()->is_eval());
     if (info()->shared_info()->is_function()) {
       result = ParseLazy();
     } else {
       result = ParseProgram();
     }
   } else {
     SetCachedData();
     result = ParseProgram();
   }
   info()->SetFunction(result);
  
   Internalize();
   DCHECK(ast_value_factory()->IsInternalized());
   return (result != NULL);
 }

References v8::internal::ParserBase< ParserTraits >::allow_natives_syntax(), ast_value_factory(), v8::internal::Isolate::counters(), DCHECK, v8::internal::ParserBase< ParserTraits >::extension_, info(), Internalize(), v8::internal::AstValueFactory::Internalize(), isolate(), NULL, ParseLazy(), ParseProgram(), pre_parse_timer_, SetCachedData(), and v8::internal::CompilationInfo::SetFunction().

Referenced by v8::internal::Compiler::CompileForLiveEdit(), v8::internal::CompileOptimizedPrologue(), v8::internal::CompileToplevel(), v8::internal::GetUnoptimizedCodeCommon(), v8::internal::compiler::Parse(), v8::internal::ScopeIterator::ScopeIterator(), and v8::internal::HOptimizedGraphBuilder::TryInline().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Parse() [2/2]

static bool v8::internal::Parser::Parse	(	CompilationInfo *	info,
		bool	allow_lazy = `false`
	)

inlinestatic

Definition at line 628 of file parser.h.

                                              {
     ParseInfo parse_info = {info->isolate()->stack_guard()->real_climit(),
                             info->isolate()->heap()->HashSeed(),
                             info->isolate()->unicode_cache()};
     Parser parser(info, &parse_info);
     parser.set_allow_lazy(allow_lazy);
     if (parser.Parse()) {
       info->SetStrictMode(info->function()->strict_mode());
       return true;
     }
     return false;
   }

References v8::internal::ParserBase< ParserTraits >::allow_lazy(), v8::internal::CompilationInfo::function(), v8::internal::Heap::HashSeed(), v8::internal::Isolate::heap(), info(), v8::internal::CompilationInfo::isolate(), Parse(), v8::internal::ParserBase< Traits >::set_allow_lazy(), v8::internal::CompilationInfo::SetStrictMode(), v8::internal::Isolate::stack_guard(), and v8::internal::Isolate::unicode_cache().

Referenced by Parse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseBlock()

Block * v8::internal::Parser::ParseBlock	(	ZoneList< const AstRawString * > *	labels,
		bool *	ok
	)

private

Definition at line 1995 of file parser.cc.

                                                                          {
   if (allow_harmony_scoping() && strict_mode() == STRICT) {
     return ParseScopedBlock(labels, ok);
   }
  
   // Block ::
   //   '{' Statement* '}'
  
   // Note that a Block does not introduce a new execution scope!
   // (ECMA-262, 3rd, 12.2)
   //
   // Construct block expecting 16 statements.
   Block* result =
       factory()->NewBlock(labels, 16, false, RelocInfo::kNoPosition);
   Target target(&this->target_stack_, result);
   Expect(Token::LBRACE, CHECK_OK);
   while (peek() != Token::RBRACE) {
     Statement* stat = ParseStatement(NULL, CHECK_OK);
     if (stat && !stat->IsEmpty()) {
       result->AddStatement(stat, zone());
     }
   }
   Expect(Token::RBRACE, CHECK_OK);
   return result;
 }

References v8::internal::ParserBase< ParserTraits >::allow_harmony_scoping(), CHECK_OK, v8::internal::ParserBase< ParserTraits >::Expect(), v8::internal::ParserBase< ParserTraits >::factory(), v8::internal::Statement::IsEmpty(), v8::internal::RelocInfo::kNoPosition, NULL, ParseScopedBlock(), ParseStatement(), v8::internal::STRICT, v8::internal::ParserBase< ParserTraits >::strict_mode(), target_stack_, and v8::internal::ParserBase< ParserTraits >::zone().

Referenced by ParseStatement(), and ParseTryStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseBlockElement()

Statement * v8::internal::Parser::ParseBlockElement	(	ZoneList< const AstRawString * > *	labels,
		bool *	ok
	)

private

Definition at line 1553 of file parser.cc.

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

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

Referenced by ParseScopedBlock(), and ParseSourceElements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseBreakStatement()

Statement * v8::internal::Parser::ParseBreakStatement	(	ZoneList< const AstRawString * > *	labels,
		bool *	ok
	)

private

Definition at line 2515 of file parser.cc.

                                                  {
   // BreakStatement ::
   //   'break' Identifier? ';'
  
   int pos = peek_position();
   Expect(Token::BREAK, CHECK_OK);
   const AstRawString* label = NULL;
   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.
     label = ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
   }
   // Parse labeled break statements that target themselves into
   // empty statements, e.g. 'l1: l2: l3: break l2;'
   if (label != NULL && ContainsLabel(labels, label)) {
     ExpectSemicolon(CHECK_OK);
     return factory()->NewEmptyStatement(pos);
   }
   BreakableStatement* target = NULL;
   target = LookupBreakTarget(label, CHECK_OK);
   if (target == NULL) {
     // Illegal break statement.
     const char* message = "illegal_break";
     if (label != NULL) {
       message = "unknown_label";
     }
     ParserTraits::ReportMessage(message, label);
     *ok = false;
     return NULL;
   }
   ExpectSemicolon(CHECK_OK);
   return factory()->NewBreakStatement(target, pos);
 }

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseCaseClause()

CaseClause * v8::internal::Parser::ParseCaseClause	(	bool *	default_seen_ptr,
		bool *	ok
	)

private

Definition at line 2624 of file parser.cc.

                                                                     {
   // CaseClause ::
   //   'case' Expression ':' Statement*
   //   'default' ':' Statement*
  
   Expression* label = NULL;  // NULL expression indicates default case
   if (peek() == Token::CASE) {
     Expect(Token::CASE, CHECK_OK);
     label = ParseExpression(true, CHECK_OK);
   } else {
     Expect(Token::DEFAULT, CHECK_OK);
     if (*default_seen_ptr) {
       ReportMessage("multiple_defaults_in_switch");
       *ok = false;
       return NULL;
     }
     *default_seen_ptr = true;
   }
   Expect(Token::COLON, CHECK_OK);
   int pos = position();
   ZoneList<Statement*>* statements =
       new(zone()) ZoneList<Statement*>(5, zone());
   while (peek() != Token::CASE &&
          peek() != Token::DEFAULT &&
          peek() != Token::RBRACE) {
     Statement* stat = ParseStatement(NULL, CHECK_OK);
     statements->Add(stat, zone());
   }
  
   return factory()->NewCaseClause(label, statements, pos);
 }

References v8::internal::List< T, AllocationPolicy >::Add(), CASE, CHECK_OK, v8::internal::DEFAULT, v8::internal::ParserBase< ParserTraits >::Expect(), v8::internal::ParserBase< ParserTraits >::factory(), NULL, v8::internal::ParserBase< ParserTraits >::ParseExpression(), ParseStatement(), v8::internal::ParserBase< ParserTraits >::position(), v8::internal::ParserBase< ParserTraits >::ReportMessage(), and v8::internal::ParserBase< ParserTraits >::zone().

Referenced by ParseSwitchStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseClassDeclaration()

Statement * v8::internal::Parser::ParseClassDeclaration	(	ZoneList< const AstRawString * > *	names,
		bool *	ok
	)

private

Definition at line 1954 of file parser.cc.

                                                    {
   // ClassDeclaration ::
   //   'class' Identifier ('extends' LeftHandExpression)? '{' ClassBody '}'
   //
   // A ClassDeclaration
   //
   //   class C { ... }
   //
   // has the same semantics as:
   //
   //   let C = class C { ... };
   //
   // so rewrite it as such.
  
   Expect(Token::CLASS, CHECK_OK);
   int pos = position();
   bool is_strict_reserved = false;
   const AstRawString* name =
       ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
   Expression* value = ParseClassLiteral(name, scanner()->location(),
                                         is_strict_reserved, pos, CHECK_OK);
  
   Block* block = factory()->NewBlock(NULL, 1, true, pos);
   VariableMode mode = LET;
   VariableProxy* proxy = NewUnresolved(name, mode, Interface::NewValue());
   Declaration* declaration =
       factory()->NewVariableDeclaration(proxy, mode, scope_, pos);
   Declare(declaration, true, CHECK_OK);
  
   Token::Value init_op = Token::INIT_LET;
   Assignment* assignment = factory()->NewAssignment(init_op, proxy, value, pos);
   block->AddStatement(
       factory()->NewExpressionStatement(assignment, RelocInfo::kNoPosition),
       zone());
  
   if (names) names->Add(name, zone());
   return block;
 }

Referenced by ParseBlockElement(), ParseExportDeclaration(), ParseModuleElement(), and ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseContinueStatement()

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

private

Definition at line 2486 of file parser.cc.

                                                   {
   // ContinueStatement ::
   //   'continue' Identifier? ';'
  
   int pos = peek_position();
   Expect(Token::CONTINUE, CHECK_OK);
   const AstRawString* label = NULL;
   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.
     label = ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
   }
   IterationStatement* target = LookupContinueTarget(label, CHECK_OK);
   if (target == NULL) {
     // Illegal continue statement.
     const char* message = "illegal_continue";
     if (label != NULL) {
       message = "unknown_label";
     }
     ParserTraits::ReportMessage(message, label);
     *ok = false;
     return NULL;
   }
   ExpectSemicolon(CHECK_OK);
   return factory()->NewContinueStatement(target, pos);
 }

References CHECK_OK, v8::internal::ParserBase< ParserTraits >::Expect(), v8::internal::ParserBase< ParserTraits >::ExpectSemicolon(), v8::internal::ParserBase< ParserTraits >::factory(), v8::internal::ParserBase< ParserTraits >::kAllowEvalOrArguments, LookupContinueTarget(), NULL, v8::internal::ParserBase< ParserTraits >::ParseIdentifier(), v8::internal::ParserBase< ParserTraits >::peek_position(), v8::internal::ParserTraits::ReportMessage(), and v8::internal::ParserBase< ParserTraits >::scanner().

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseDebuggerStatement()

DebuggerStatement * v8::internal::Parser::ParseDebuggerStatement ( bool * ok )

private

Definition at line 3317 of file parser.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 i a
   // break point is present.
   // DebuggerStatement ::
   //   'debugger' ';'
  
   int pos = peek_position();
   Expect(Token::DEBUGGER, CHECK_OK);
   ExpectSemicolon(CHECK_OK);
   return factory()->NewDebuggerStatement(pos);
 }

References CHECK_OK, v8::internal::ParserBase< ParserTraits >::Expect(), v8::internal::ParserBase< ParserTraits >::ExpectSemicolon(), v8::internal::ParserBase< ParserTraits >::factory(), and v8::internal::ParserBase< ParserTraits >::peek_position().

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseDoWhileStatement()

DoWhileStatement * v8::internal::Parser::ParseDoWhileStatement	(	ZoneList< const AstRawString * > *	labels,
		bool *	ok
	)

private

Definition at line 2809 of file parser.cc.

                                                      {
   // DoStatement ::
   //   'do' Statement 'while' '(' Expression ')' ';'
  
   DoWhileStatement* loop =
       factory()->NewDoWhileStatement(labels, peek_position());
   Target target(&this->target_stack_, loop);
  
   Expect(Token::DO, CHECK_OK);
   Statement* body = ParseStatement(NULL, CHECK_OK);
   Expect(Token::WHILE, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
  
   Expression* cond = ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
  
   // Allow do-statements to be terminated with and without
   // semi-colons. This allows code such as 'do;while(0)return' to
   // parse, which would not be the case if we had used the
   // ExpectSemicolon() functionality here.
   if (peek() == Token::SEMICOLON) Consume(Token::SEMICOLON);
  
   if (loop != NULL) loop->Initialize(cond, body);
   return loop;
 }

References CHECK_OK, v8::internal::ParserBase< ParserTraits >::Consume(), v8::internal::ParserBase< ParserTraits >::Expect(), v8::internal::ParserBase< ParserTraits >::factory(), NULL, v8::internal::ParserBase< ParserTraits >::ParseExpression(), ParseStatement(), v8::internal::ParserBase< ParserTraits >::peek_position(), and target_stack_.

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseEagerFunctionBody()

ZoneList< Statement * > * v8::internal::Parser::ParseEagerFunctionBody	(	const AstRawString *	function_name,
		int	pos,
		Variable *	fvar,
		Token::Value	fvar_init_op,
		bool	is_generator,
		bool *	ok
	)

private

Definition at line 3767 of file parser.cc.

                                                           {
   // Everything inside an eagerly parsed function will be parsed eagerly
   // (see comment above).
   ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
   ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(8, zone());
   if (fvar != NULL) {
     VariableProxy* fproxy = scope_->NewUnresolved(
         factory(), function_name, Interface::NewConst());
     fproxy->BindTo(fvar);
     body->Add(factory()->NewExpressionStatement(
         factory()->NewAssignment(fvar_init_op,
                                  fproxy,
                                  factory()->NewThisFunction(pos),
                                  RelocInfo::kNoPosition),
         RelocInfo::kNoPosition), zone());
   }
  
   // For generators, allocate and yield an iterator on function entry.
   if (is_generator) {
     ZoneList<Expression*>* arguments =
         new(zone()) ZoneList<Expression*>(0, zone());
     CallRuntime* allocation = factory()->NewCallRuntime(
         ast_value_factory()->empty_string(),
         Runtime::FunctionForId(Runtime::kCreateJSGeneratorObject), arguments,
         pos);
     VariableProxy* init_proxy = factory()->NewVariableProxy(
         function_state_->generator_object_variable());
     Assignment* assignment = factory()->NewAssignment(
         Token::INIT_VAR, init_proxy, allocation, RelocInfo::kNoPosition);
     VariableProxy* get_proxy = factory()->NewVariableProxy(
         function_state_->generator_object_variable());
     Yield* yield = factory()->NewYield(
         get_proxy, assignment, Yield::kInitial, RelocInfo::kNoPosition);
     body->Add(factory()->NewExpressionStatement(
         yield, RelocInfo::kNoPosition), zone());
   }
  
   ParseSourceElements(body, Token::RBRACE, false, false, NULL, CHECK_OK);
  
   if (is_generator) {
     VariableProxy* get_proxy = factory()->NewVariableProxy(
         function_state_->generator_object_variable());
     Expression* undefined =
         factory()->NewUndefinedLiteral(RelocInfo::kNoPosition);
     Yield* yield = factory()->NewYield(get_proxy, undefined, Yield::kFinal,
                                        RelocInfo::kNoPosition);
     body->Add(factory()->NewExpressionStatement(
         yield, RelocInfo::kNoPosition), zone());
   }
  
   Expect(Token::RBRACE, CHECK_OK);
   scope_->set_end_position(scanner()->location().end_pos);
  
   return body;
 }

Referenced by v8::internal::ParserTraits::ParseEagerFunctionBody(), and ParseFunctionLiteral().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseExportDeclaration()

Statement * v8::internal::Parser::ParseExportDeclaration ( bool * ok )

private

Definition at line 1460 of file parser.cc.

                                                   {
   // ExportDeclaration:
   //    'export' Identifier (',' Identifier)* ';'
   //    'export' VariableDeclaration
   //    'export' FunctionDeclaration
   //    'export' GeneratorDeclaration
   //    'export' ModuleDeclaration
   //
   // TODO(ES6): implement structuring ExportSpecifiers
  
   Expect(Token::EXPORT, CHECK_OK);
  
   Statement* result = NULL;
   ZoneList<const AstRawString*> names(1, zone());
   switch (peek()) {
     case Token::IDENTIFIER: {
       int pos = position();
       const AstRawString* name =
           ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
       // Handle 'module' as a context-sensitive keyword.
       if (name != ast_value_factory()->module_string()) {
         names.Add(name, zone());
         while (peek() == Token::COMMA) {
           Consume(Token::COMMA);
           name = ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
           names.Add(name, zone());
         }
         ExpectSemicolon(CHECK_OK);
         result = factory()->NewEmptyStatement(pos);
       } else {
         result = ParseModuleDeclaration(&names, CHECK_OK);
       }
       break;
     }
  
     case Token::FUNCTION:
       result = ParseFunctionDeclaration(&names, CHECK_OK);
       break;
  
     case Token::CLASS:
       result = ParseClassDeclaration(&names, CHECK_OK);
       break;
  
     case Token::VAR:
     case Token::LET:
     case Token::CONST:
       result = ParseVariableStatement(kModuleElement, &names, CHECK_OK);
       break;
  
     default:
       *ok = false;
       ReportUnexpectedToken(scanner()->current_token());
       return NULL;
   }
  
   // Every export of a module may be assigned.
   for (int i = 0; i < names.length(); ++i) {
     Variable* var = scope_->Lookup(names[i]);
     if (var == NULL) {
       // TODO(sigurds) This is an export that has no definition yet,
       // not clear what to do in this case.
       continue;
     }
     if (!IsImmutableVariableMode(var->mode())) {
       var->set_maybe_assigned();
     }
   }
  
   // Extract declared names into export declarations and interface.
   Interface* interface = scope_->interface();
   for (int i = 0; i < names.length(); ++i) {
 #ifdef DEBUG
     if (FLAG_print_interface_details)
       PrintF("# Export %.*s ", names[i]->length(), names[i]->raw_data());
 #endif
     Interface* inner = Interface::NewUnknown(zone());
     interface->Add(names[i], inner, zone(), CHECK_OK);
     if (!*ok)
       return NULL;
     VariableProxy* proxy = NewUnresolved(names[i], LET, inner);
     USE(proxy);
     // TODO(rossberg): Rethink whether we actually need to store export
     // declarations (for compilation?).
     // ExportDeclaration* declaration =
     //     factory()->NewExportDeclaration(proxy, scope_, position);
     // scope_->AddDeclaration(declaration);
   }
  
   DCHECK(result != NULL);
   return result;
 }

Referenced by ParseModuleElement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseExpressionOrLabelledStatement()

Statement * v8::internal::Parser::ParseExpressionOrLabelledStatement	(	ZoneList< const AstRawString * > *	labels,
		bool *	ok
	)

private

Definition at line 2400 of file parser.cc.

                                                      {
   // ExpressionStatement | LabelledStatement ::
   //   Expression ';'
   //   Identifier ':' Statement
   int pos = peek_position();
   bool starts_with_idenfifier = peek_any_identifier();
   Expression* expr = ParseExpression(true, CHECK_OK);
   if (peek() == Token::COLON && starts_with_idenfifier && expr != NULL &&
       expr->AsVariableProxy() != NULL &&
       !expr->AsVariableProxy()->is_this()) {
     // Expression is a single identifier, and not, e.g., a parenthesized
     // identifier.
     VariableProxy* var = expr->AsVariableProxy();
     const AstRawString* label = var->raw_name();
     // TODO(1240780): We don't check for redeclaration of labels
     // during preparsing since keeping track of the set of active
     // labels requires nontrivial changes to the way scopes are
     // structured.  However, these are probably changes we want to
     // make later anyway so we should go back and fix this then.
     if (ContainsLabel(labels, label) || TargetStackContainsLabel(label)) {
       ParserTraits::ReportMessage("label_redeclaration", label);
       *ok = false;
       return NULL;
     }
     if (labels == NULL) {
       labels = new(zone()) ZoneList<const AstRawString*>(4, zone());
     }
     labels->Add(label, zone());
     // Remove the "ghost" variable that turned out to be a label
     // from the top scope. This way, we don't try to resolve it
     // during the scope processing.
     scope_->RemoveUnresolved(var);
     Expect(Token::COLON, CHECK_OK);
     return ParseStatement(labels, ok);
   }
  
   // If we have an extension, we allow a native function declaration.
   // A native function declaration starts with "native function" with
   // no line-terminator between the two words.
   if (extension_ != NULL && peek() == Token::FUNCTION &&
       !scanner()->HasAnyLineTerminatorBeforeNext() && expr != NULL &&
       expr->AsVariableProxy() != NULL &&
       expr->AsVariableProxy()->raw_name() ==
           ast_value_factory()->native_string() &&
       !scanner()->literal_contains_escapes()) {
     return ParseNativeDeclaration(ok);
   }
  
   // Parsed expression statement, or the context-sensitive 'module' keyword.
   // Only expect semicolon in the former case.
   if (!FLAG_harmony_modules || peek() != Token::IDENTIFIER ||
       scanner()->HasAnyLineTerminatorBeforeNext() ||
       expr->AsVariableProxy() == NULL ||
       expr->AsVariableProxy()->raw_name() !=
           ast_value_factory()->module_string() ||
       scanner()->literal_contains_escapes()) {
     ExpectSemicolon(CHECK_OK);
   }
   return factory()->NewExpressionStatement(expr, pos);
 }

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseForStatement()

Statement * v8::internal::Parser::ParseForStatement	(	ZoneList< const AstRawString * > *	labels,
		bool *	ok
	)

private

Definition at line 3097 of file parser.cc.

                                                {
   // ForStatement ::
   //   'for' '(' Expression? ';' Expression? ';' Expression? ')' Statement
  
   int pos = peek_position();
   Statement* init = NULL;
   ZoneList<const AstRawString*> let_bindings(1, zone());
  
   // Create an in-between scope for let-bound iteration variables.
   Scope* saved_scope = scope_;
   Scope* for_scope = NewScope(scope_, BLOCK_SCOPE);
   scope_ = for_scope;
  
   Expect(Token::FOR, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   for_scope->set_start_position(scanner()->location().beg_pos);
   if (peek() != Token::SEMICOLON) {
     if (peek() == Token::VAR || peek() == Token::CONST) {
       bool is_const = peek() == Token::CONST;
       const AstRawString* name = NULL;
       VariableDeclarationProperties decl_props = kHasNoInitializers;
       Block* variable_statement =
           ParseVariableDeclarations(kForStatement, &decl_props, NULL, &name,
                                     CHECK_OK);
       bool accept_OF = decl_props == kHasNoInitializers;
       ForEachStatement::VisitMode mode;
  
       if (name != NULL && CheckInOrOf(accept_OF, &mode)) {
         Interface* interface =
             is_const ? Interface::NewConst() : Interface::NewValue();
         ForEachStatement* loop =
             factory()->NewForEachStatement(mode, labels, pos);
         Target target(&this->target_stack_, loop);
  
         Expression* enumerable = ParseExpression(true, CHECK_OK);
         Expect(Token::RPAREN, CHECK_OK);
  
         VariableProxy* each =
             scope_->NewUnresolved(factory(), name, interface);
         Statement* body = ParseStatement(NULL, CHECK_OK);
         InitializeForEachStatement(loop, each, enumerable, body);
         Block* result =
             factory()->NewBlock(NULL, 2, false, RelocInfo::kNoPosition);
         result->AddStatement(variable_statement, zone());
         result->AddStatement(loop, zone());
         scope_ = saved_scope;
         for_scope->set_end_position(scanner()->location().end_pos);
         for_scope = for_scope->FinalizeBlockScope();
         DCHECK(for_scope == NULL);
         // Parsed for-in loop w/ variable/const declaration.
         return result;
       } else {
         init = variable_statement;
       }
     } else if (peek() == Token::LET && strict_mode() == STRICT) {
       DCHECK(allow_harmony_scoping());
       const AstRawString* name = NULL;
       VariableDeclarationProperties decl_props = kHasNoInitializers;
       Block* variable_statement =
           ParseVariableDeclarations(kForStatement, &decl_props, &let_bindings,
                                     &name, CHECK_OK);
       bool accept_IN = name != NULL && decl_props != kHasInitializers;
       bool accept_OF = decl_props == kHasNoInitializers;
       ForEachStatement::VisitMode mode;
  
       if (accept_IN && CheckInOrOf(accept_OF, &mode)) {
         // Rewrite a for-in statement of the form
         //
         //   for (let x in e) b
         //
         // into
         //
         //   <let x' be a temporary variable>
         //   for (x' in e) {
         //     let x;
         //     x = x';
         //     b;
         //   }
  
         // TODO(keuchel): Move the temporary variable to the block scope, after
         // implementing stack allocated block scoped variables.
         Variable* temp = scope_->DeclarationScope()->NewTemporary(
             ast_value_factory()->dot_for_string());
         VariableProxy* temp_proxy = factory()->NewVariableProxy(temp);
         ForEachStatement* loop =
             factory()->NewForEachStatement(mode, labels, pos);
         Target target(&this->target_stack_, loop);
  
         // The expression does not see the loop variable.
         scope_ = saved_scope;
         Expression* enumerable = ParseExpression(true, CHECK_OK);
         scope_ = for_scope;
         Expect(Token::RPAREN, CHECK_OK);
  
         VariableProxy* each =
             scope_->NewUnresolved(factory(), name, Interface::NewValue());
         Statement* body = ParseStatement(NULL, CHECK_OK);
         Block* body_block =
             factory()->NewBlock(NULL, 3, false, RelocInfo::kNoPosition);
         Assignment* assignment = factory()->NewAssignment(
             Token::ASSIGN, each, temp_proxy, RelocInfo::kNoPosition);
         Statement* assignment_statement = factory()->NewExpressionStatement(
             assignment, RelocInfo::kNoPosition);
         body_block->AddStatement(variable_statement, zone());
         body_block->AddStatement(assignment_statement, zone());
         body_block->AddStatement(body, zone());
         InitializeForEachStatement(loop, temp_proxy, enumerable, body_block);
         scope_ = saved_scope;
         for_scope->set_end_position(scanner()->location().end_pos);
         for_scope = for_scope->FinalizeBlockScope();
         body_block->set_scope(for_scope);
         // Parsed for-in loop w/ let declaration.
         return loop;
  
       } else {
         init = variable_statement;
       }
     } else {
       Scanner::Location lhs_location = scanner()->peek_location();
       Expression* expression = ParseExpression(false, CHECK_OK);
       ForEachStatement::VisitMode mode;
       bool accept_OF = expression->AsVariableProxy();
  
       if (CheckInOrOf(accept_OF, &mode)) {
         expression = this->CheckAndRewriteReferenceExpression(
             expression, lhs_location, "invalid_lhs_in_for", CHECK_OK);
  
         ForEachStatement* loop =
             factory()->NewForEachStatement(mode, labels, pos);
         Target target(&this->target_stack_, loop);
  
         Expression* enumerable = ParseExpression(true, CHECK_OK);
         Expect(Token::RPAREN, CHECK_OK);
  
         Statement* body = ParseStatement(NULL, CHECK_OK);
         InitializeForEachStatement(loop, expression, enumerable, body);
         scope_ = saved_scope;
         for_scope->set_end_position(scanner()->location().end_pos);
         for_scope = for_scope->FinalizeBlockScope();
         DCHECK(for_scope == NULL);
         // Parsed for-in loop.
         return loop;
  
       } else {
         init = factory()->NewExpressionStatement(
             expression, RelocInfo::kNoPosition);
       }
     }
   }
  
   // Standard 'for' loop
   ForStatement* loop = factory()->NewForStatement(labels, pos);
   Target target(&this->target_stack_, loop);
  
   // Parsed initializer at this point.
   Expect(Token::SEMICOLON, CHECK_OK);
  
   // If there are let bindings, then condition and the next statement of the
   // for loop must be parsed in a new scope.
   Scope* inner_scope = NULL;
   if (let_bindings.length() > 0) {
     inner_scope = NewScope(for_scope, BLOCK_SCOPE);
     inner_scope->set_start_position(scanner()->location().beg_pos);
     scope_ = inner_scope;
   }
  
   Expression* cond = NULL;
   if (peek() != Token::SEMICOLON) {
     cond = ParseExpression(true, CHECK_OK);
   }
   Expect(Token::SEMICOLON, CHECK_OK);
  
   Statement* next = NULL;
   if (peek() != Token::RPAREN) {
     Expression* exp = ParseExpression(true, CHECK_OK);
     next = factory()->NewExpressionStatement(exp, RelocInfo::kNoPosition);
   }
   Expect(Token::RPAREN, CHECK_OK);
  
   Statement* body = ParseStatement(NULL, CHECK_OK);
  
   Statement* result = NULL;
   if (let_bindings.length() > 0) {
     scope_ = for_scope;
     result = DesugarLetBindingsInForStatement(inner_scope, &let_bindings, loop,
                                               init, cond, next, body, CHECK_OK);
     scope_ = saved_scope;
     for_scope->set_end_position(scanner()->location().end_pos);
   } else {
     scope_ = saved_scope;
     for_scope->set_end_position(scanner()->location().end_pos);
     for_scope = for_scope->FinalizeBlockScope();
     if (for_scope) {
       // Rewrite a for statement of the form
       //   for (const x = i; c; n) b
       //
       // into
       //
       //   {
       //     const x = i;
       //     for (; c; n) b
       //   }
       DCHECK(init != NULL);
       Block* block =
           factory()->NewBlock(NULL, 2, false, RelocInfo::kNoPosition);
       block->AddStatement(init, zone());
       block->AddStatement(loop, zone());
       block->set_scope(for_scope);
       loop->Initialize(NULL, cond, next, body);
       result = block;
     } else {
       loop->Initialize(init, cond, next, body);
       result = loop;
     }
   }
   return result;
 }

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseFunctionDeclaration()

Statement * v8::internal::Parser::ParseFunctionDeclaration	(	ZoneList< const AstRawString * > *	names,
		bool *	ok
	)

private

Definition at line 1917 of file parser.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;
   const AstRawString* name = ParseIdentifierOrStrictReservedWord(
       &is_strict_reserved, CHECK_OK);
   FunctionLiteral* fun =
       ParseFunctionLiteral(name, scanner()->location(), is_strict_reserved,
                            is_generator ? FunctionKind::kGeneratorFunction
                                         : FunctionKind::kNormalFunction,
                            pos, FunctionLiteral::DECLARATION,
                            FunctionLiteral::NORMAL_ARITY, CHECK_OK);
   // Even if we're not at the top-level of the global or a function
   // scope, we treat it as such and introduce the function with its
   // initial value upon entering the corresponding scope.
   // In ES6, a function behaves as a lexical binding, except in the
   // global scope, or the initial scope of eval or another function.
   VariableMode mode =
       allow_harmony_scoping() && strict_mode() == STRICT &&
       !(scope_->is_global_scope() || scope_->is_eval_scope() ||
           scope_->is_function_scope()) ? LET : VAR;
   VariableProxy* proxy = NewUnresolved(name, mode, Interface::NewValue());
   Declaration* declaration =
       factory()->NewFunctionDeclaration(proxy, mode, fun, scope_, pos);
   Declare(declaration, true, CHECK_OK);
   if (names) names->Add(name, zone());
   return factory()->NewEmptyStatement(RelocInfo::kNoPosition);
 }

Referenced by ParseBlockElement(), ParseExportDeclaration(), ParseModuleElement(), and ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseFunctionLiteral()

FunctionLiteral * v8::internal::Parser::ParseFunctionLiteral	(	const AstRawString *	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

Definition at line 3436 of file parser.cc.

                                                                  {
   // Function ::
   //   '(' FormalParameterList? ')' '{' FunctionBody '}'
   //
   // Getter ::
   //   '(' ')' '{' FunctionBody '}'
   //
   // Setter ::
   //   '(' PropertySetParameterList ')' '{' FunctionBody '}'
  
   int pos = function_token_pos == RelocInfo::kNoPosition
       ? peek_position() : function_token_pos;
  
   bool is_generator = IsGeneratorFunction(kind);
  
   // Anonymous functions were passed either the empty symbol or a null
   // handle as the function name.  Remember if we were passed a non-empty
   // handle to decide whether to invoke function name inference.
   bool should_infer_name = function_name == NULL;
  
   // We want a non-null handle as the function name.
   if (should_infer_name) {
     function_name = ast_value_factory()->empty_string();
   }
  
   int num_parameters = 0;
   // Function declarations are function scoped in normal mode, so they are
   // hoisted. In harmony block scoping mode they are block scoped, so they
   // are not hoisted.
   //
   // One tricky case are function declarations in a local sloppy-mode eval:
   // their declaration is hoisted, but they still see the local scope. E.g.,
   //
   // function() {
   //   var x = 0
   //   try { throw 1 } catch (x) { eval("function g() { return x }") }
   //   return g()
   // }
   //
   // needs to return 1. To distinguish such cases, we need to detect
   // (1) whether a function stems from a sloppy eval, and
   // (2) whether it actually hoists across the eval.
   // Unfortunately, we do not represent sloppy eval scopes, so we do not have
   // either information available directly, especially not when lazily compiling
   // a function like 'g'. We hence rely on the following invariants:
   // - (1) is the case iff the innermost scope of the deserialized scope chain
   //   under which we compile is _not_ a declaration scope. This holds because
   //   in all normal cases, function declarations are fully hoisted to a
   //   declaration scope and compiled relative to that.
   // - (2) is the case iff the current declaration scope is still the original
   //   one relative to the deserialized scope chain. Otherwise we must be
   //   compiling a function in an inner declaration scope in the eval, e.g. a
   //   nested function, and hoisting works normally relative to that.
   Scope* declaration_scope = scope_->DeclarationScope();
   Scope* original_declaration_scope = original_scope_->DeclarationScope();
   Scope* scope =
       function_type == FunctionLiteral::DECLARATION &&
       (!allow_harmony_scoping() || strict_mode() == SLOPPY) &&
       (original_scope_ == original_declaration_scope ||
        declaration_scope != original_declaration_scope)
           ? NewScope(declaration_scope, FUNCTION_SCOPE)
           : NewScope(scope_, FUNCTION_SCOPE);
   ZoneList<Statement*>* body = NULL;
   int materialized_literal_count = -1;
   int expected_property_count = -1;
   int handler_count = 0;
   FunctionLiteral::ParameterFlag duplicate_parameters =
       FunctionLiteral::kNoDuplicateParameters;
   FunctionLiteral::IsParenthesizedFlag parenthesized = parenthesized_function_
       ? FunctionLiteral::kIsParenthesized
       : FunctionLiteral::kNotParenthesized;
   AstProperties ast_properties;
   BailoutReason dont_optimize_reason = kNoReason;
   // Parse function body.
   {
     FunctionState function_state(&function_state_, &scope_, scope, zone(),
                                  ast_value_factory(),
                                  info()->ast_node_id_gen());
     scope_->SetScopeName(function_name);
  
     if (is_generator) {
       // For generators, allocating variables in contexts is currently a win
       // because it minimizes the work needed to suspend and resume an
       // activation.
       scope_->ForceContextAllocation();
  
       // Calling a generator returns a generator object.  That object is stored
       // in a temporary variable, a definition that is used by "yield"
       // expressions. This also marks the FunctionState as a generator.
       Variable* temp = scope_->DeclarationScope()->NewTemporary(
           ast_value_factory()->dot_generator_object_string());
       function_state.set_generator_object_variable(temp);
     }
  
     //  FormalParameterList ::
     //    '(' (Identifier)*[','] ')'
     Expect(Token::LPAREN, CHECK_OK);
     scope->set_start_position(scanner()->location().beg_pos);
  
     // 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_log = Scanner::Location::invalid();
     Scanner::Location dupe_error_loc = Scanner::Location::invalid();
     Scanner::Location reserved_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;
       const AstRawString* param_name =
           ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
  
       // Store locations for possible future error reports.
       if (!eval_args_error_log.IsValid() && IsEvalOrArguments(param_name)) {
         eval_args_error_log = scanner()->location();
       }
       if (!reserved_loc.IsValid() && is_strict_reserved) {
         reserved_loc = scanner()->location();
       }
       if (!dupe_error_loc.IsValid() && scope_->IsDeclared(param_name)) {
         duplicate_parameters = FunctionLiteral::kHasDuplicateParameters;
         dupe_error_loc = scanner()->location();
       }
  
       Variable* var = scope_->DeclareParameter(param_name, VAR);
       if (scope->strict_mode() == SLOPPY) {
         // TODO(sigurds) Mark every parameter as maybe assigned. This is a
         // conservative approximation necessary to account for parameters
         // that are assigned via the arguments array.
         var->set_maybe_assigned();
       }
  
       num_parameters++;
       if (num_parameters > Code::kMaxArguments) {
         ReportMessage("too_many_parameters");
         *ok = false;
         return NULL;
       }
       if (arity_restriction == FunctionLiteral::SETTER_ARITY) break;
       done = (peek() == Token::RPAREN);
       if (!done) Expect(Token::COMMA, CHECK_OK);
     }
     Expect(Token::RPAREN, CHECK_OK);
  
     Expect(Token::LBRACE, CHECK_OK);
  
     // If we have a named function expression, we add a local variable
     // declaration to the body of the function with the name of the
     // function and let it refer to the function itself (closure).
     // NOTE: We create a proxy and resolve it here so that in the
     // future we can change the AST to only refer to VariableProxies
     // instead of Variables and Proxis as is the case now.
     Variable* fvar = NULL;
     Token::Value fvar_init_op = Token::INIT_CONST_LEGACY;
     if (function_type == FunctionLiteral::NAMED_EXPRESSION) {
       if (allow_harmony_scoping() && strict_mode() == STRICT) {
         fvar_init_op = Token::INIT_CONST;
       }
       VariableMode fvar_mode =
           allow_harmony_scoping() && strict_mode() == STRICT
               ? CONST : CONST_LEGACY;
       DCHECK(function_name != NULL);
       fvar = new (zone())
           Variable(scope_, function_name, fvar_mode, true /* is valid LHS */,
                    Variable::NORMAL, kCreatedInitialized, kNotAssigned,
                    Interface::NewConst());
       VariableProxy* proxy = factory()->NewVariableProxy(fvar);
       VariableDeclaration* fvar_declaration = factory()->NewVariableDeclaration(
           proxy, fvar_mode, scope_, RelocInfo::kNoPosition);
       scope_->DeclareFunctionVar(fvar_declaration);
     }
  
     // Determine if the function can be parsed lazily. Lazy parsing is different
     // from lazy compilation; we need to parse more eagerly than we compile.
  
     // We can only parse lazily if we also compile lazily. The heuristics for
     // lazy compilation are:
     // - It must not have been prohibited by the caller to Parse (some callers
     //   need a full AST).
     // - The outer scope must allow lazy compilation of inner functions.
     // - The function mustn't be a function expression with an open parenthesis
     //   before; we consider that a hint that the function will be called
     //   immediately, and it would be a waste of time to make it lazily
     //   compiled.
     // These are all things we can know at this point, without looking at the
     // function itself.
  
     // In addition, we need to distinguish between these cases:
     // (function foo() {
     //   bar = function() { return 1; }
     //  })();
     // and
     // (function foo() {
     //   var a = 1;
     //   bar = function() { return a; }
     //  })();
  
     // Now foo will be parsed eagerly and compiled eagerly (optimization: assume
     // parenthesis before the function means that it will be called
     // immediately). The inner function *must* be parsed eagerly to resolve the
     // possible reference to the variable in foo's scope. However, it's possible
     // that it will be compiled lazily.
  
     // To make this additional case work, both Parser and PreParser implement a
     // logic where only top-level functions will be parsed lazily.
     bool is_lazily_parsed = (mode() == PARSE_LAZILY &&
                              scope_->AllowsLazyCompilation() &&
                              !parenthesized_function_);
     parenthesized_function_ = false;  // The bit was set for this function only.
  
     if (is_lazily_parsed) {
       SkipLazyFunctionBody(function_name, &materialized_literal_count,
                            &expected_property_count, CHECK_OK);
     } else {
       body = ParseEagerFunctionBody(function_name, pos, fvar, fvar_init_op,
                                     is_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();
     }
  
     // Validate strict mode.
     // Concise methods use StrictFormalParameters.
     if (strict_mode() == STRICT || IsConciseMethod(kind)) {
       CheckStrictFunctionNameAndParameters(function_name,
                                            name_is_strict_reserved,
                                            function_name_location,
                                            eval_args_error_log,
                                            dupe_error_loc,
                                            reserved_loc,
                                            CHECK_OK);
     }
     if (strict_mode() == STRICT) {
       CheckOctalLiteral(scope->start_position(),
                         scope->end_position(),
                         CHECK_OK);
     }
     ast_properties = *factory()->visitor()->ast_properties();
     dont_optimize_reason = factory()->visitor()->dont_optimize_reason();
  
     if (allow_harmony_scoping() && strict_mode() == STRICT) {
       CheckConflictingVarDeclarations(scope, CHECK_OK);
     }
   }
  
   FunctionLiteral* function_literal = factory()->NewFunctionLiteral(
       function_name, ast_value_factory(), scope, body,
       materialized_literal_count, expected_property_count, handler_count,
       num_parameters, duplicate_parameters, function_type,
       FunctionLiteral::kIsFunction, parenthesized, kind, pos);
   function_literal->set_function_token_position(function_token_pos);
   function_literal->set_ast_properties(&ast_properties);
   function_literal->set_dont_optimize_reason(dont_optimize_reason);
  
   if (fni_ != NULL && should_infer_name) fni_->AddFunction(function_literal);
   return function_literal;
 }

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseIfStatement()

IfStatement * v8::internal::Parser::ParseIfStatement	(	ZoneList< const AstRawString * > *	labels,
		bool *	ok
	)

private

Definition at line 2463 of file parser.cc.

                                                 {
   // IfStatement ::
   //   'if' '(' Expression ')' Statement ('else' Statement)?
  
   int pos = peek_position();
   Expect(Token::IF, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   Expression* condition = ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
   Statement* then_statement = ParseStatement(labels, CHECK_OK);
   Statement* else_statement = NULL;
   if (peek() == Token::ELSE) {
     Next();
     else_statement = ParseStatement(labels, CHECK_OK);
   } else {
     else_statement = factory()->NewEmptyStatement(RelocInfo::kNoPosition);
   }
   return factory()->NewIfStatement(
       condition, then_statement, else_statement, pos);
 }

References CHECK_OK, v8::internal::ParserBase< ParserTraits >::Expect(), v8::internal::ParserBase< ParserTraits >::factory(), v8::internal::RelocInfo::kNoPosition, NULL, v8::internal::ParserBase< ParserTraits >::ParseExpression(), ParseStatement(), and v8::internal::ParserBase< ParserTraits >::peek_position().

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseImportDeclaration()

Block * v8::internal::Parser::ParseImportDeclaration ( bool * ok )

private

Definition at line 1406 of file parser.cc.

                                               {
   // ImportDeclaration:
   //    'import' IdentifierName (',' IdentifierName)* 'from' ModuleSpecifier ';'
   //
   // TODO(ES6): implement destructuring ImportSpecifiers
  
   int pos = peek_position();
   Expect(Token::IMPORT, CHECK_OK);
   ZoneList<const AstRawString*> names(1, zone());
  
   const AstRawString* name = ParseIdentifierName(CHECK_OK);
   names.Add(name, zone());
   while (peek() == Token::COMMA) {
     Consume(Token::COMMA);
     name = ParseIdentifierName(CHECK_OK);
     names.Add(name, zone());
   }
  
   ExpectContextualKeyword(CStrVector("from"), CHECK_OK);
   Module* module = ParseModuleSpecifier(CHECK_OK);
   ExpectSemicolon(CHECK_OK);
  
   // Generate a separate declaration for each identifier.
   // TODO(ES6): once we implement destructuring, make that one declaration.
   Block* block = factory()->NewBlock(NULL, 1, true, RelocInfo::kNoPosition);
   for (int i = 0; i < names.length(); ++i) {
 #ifdef DEBUG
     if (FLAG_print_interface_details)
       PrintF("# Import %.*s ", name->length(), name->raw_data());
 #endif
     Interface* interface = Interface::NewUnknown(zone());
     module->interface()->Add(names[i], interface, zone(), ok);
     if (!*ok) {
 #ifdef DEBUG
       if (FLAG_print_interfaces) {
         PrintF("IMPORT TYPE ERROR at '%.*s'\n", name->length(),
                name->raw_data());
         PrintF("module: ");
         module->interface()->Print();
       }
 #endif
       ParserTraits::ReportMessage("invalid_module_path", name);
       return NULL;
     }
     VariableProxy* proxy = NewUnresolved(names[i], LET, interface);
     Declaration* declaration =
         factory()->NewImportDeclaration(proxy, module, scope_, pos);
     Declare(declaration, true, CHECK_OK);
   }
  
   return block;
 }

References v8::internal::Interface::Add(), v8::internal::List< T, AllocationPolicy >::Add(), CHECK_OK, COMMA, v8::internal::ParserBase< ParserTraits >::Consume(), v8::internal::CStrVector(), Declare(), v8::internal::ParserBase< ParserTraits >::Expect(), v8::internal::ParserBase< ParserTraits >::ExpectContextualKeyword(), v8::internal::ParserBase< ParserTraits >::ExpectSemicolon(), v8::internal::ParserBase< ParserTraits >::factory(), v8::internal::Module::interface(), v8::internal::RelocInfo::kNoPosition, v8::internal::LET, name, v8::internal::Interface::NewUnknown(), NewUnresolved(), NULL, v8::internal::ParserBase< ParserTraits >::ParseIdentifierName(), ParseModuleSpecifier(), v8::internal::ParserBase< ParserTraits >::peek_position(), v8::internal::PrintF(), v8::internal::ParserTraits::ReportMessage(), v8::internal::ParserBase< ParserTraits >::scope_, and v8::internal::ParserBase< ParserTraits >::zone().

Referenced by ParseModuleElement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseLazy() [1/2]

FunctionLiteral * v8::internal::Parser::ParseLazy ( )

private

Definition at line 948 of file parser.cc.

                                    {
   // It's OK to use the counters here, since this function is only called in
   // the main thread.
   HistogramTimerScope timer_scope(isolate()->counters()->parse_lazy());
   Handle<String> source(String::cast(script()->source()));
   isolate()->counters()->total_parse_size()->Increment(source->length());
   base::ElapsedTimer timer;
   if (FLAG_trace_parse) {
     timer.Start();
   }
   Handle<SharedFunctionInfo> shared_info = info()->shared_info();
  
   // Initialize parser state.
   source = String::Flatten(source);
   FunctionLiteral* result;
   if (source->IsExternalTwoByteString()) {
     ExternalTwoByteStringUtf16CharacterStream stream(
         Handle<ExternalTwoByteString>::cast(source),
         shared_info->start_position(),
         shared_info->end_position());
     result = ParseLazy(&stream);
   } else {
     GenericStringUtf16CharacterStream stream(source,
                                              shared_info->start_position(),
                                              shared_info->end_position());
     result = ParseLazy(&stream);
   }
  
   if (FLAG_trace_parse && result != NULL) {
     double ms = timer.Elapsed().InMillisecondsF();
     SmartArrayPointer<char> name_chars = result->debug_name()->ToCString();
     PrintF("[parsing function: %s - took %0.3f ms]\n", name_chars.get(), ms);
   }
   return result;
 }

References v8::internal::Isolate::counters(), v8::internal::String::Flatten(), v8::internal::SmartPointerBase< Deallocator, T >::get(), info(), isolate(), NULL, v8::internal::PrintF(), script(), and v8::internal::CompilationInfo::shared_info().

Referenced by Parse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseLazy() [2/2]

FunctionLiteral * v8::internal::Parser::ParseLazy ( Utf16CharacterStream * source )

private

Definition at line 985 of file parser.cc.

                                                                {
   Handle<SharedFunctionInfo> shared_info = info()->shared_info();
   scanner_.Initialize(source);
   DCHECK(scope_ == NULL);
   DCHECK(target_stack_ == NULL);
  
   Handle<String> name(String::cast(shared_info->name()));
   DCHECK(ast_value_factory());
   fni_ = new (zone()) FuncNameInferrer(ast_value_factory(), zone());
   const AstRawString* raw_name = ast_value_factory()->GetString(name);
   fni_->PushEnclosingName(raw_name);
  
   ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
  
   // Place holder for the result.
   FunctionLiteral* result = NULL;
  
   {
     // Parse the function literal.
     Scope* scope = NewScope(scope_, GLOBAL_SCOPE);
     info()->SetGlobalScope(scope);
     if (!info()->closure().is_null()) {
       scope = Scope::DeserializeScopeChain(info()->closure()->context(), scope,
                                            zone());
     }
     original_scope_ = scope;
     FunctionState function_state(&function_state_, &scope_, scope, zone(),
                                  ast_value_factory(),
                                  info()->ast_node_id_gen());
     DCHECK(scope->strict_mode() == SLOPPY || info()->strict_mode() == STRICT);
     DCHECK(info()->strict_mode() == shared_info->strict_mode());
     scope->SetStrictMode(shared_info->strict_mode());
     FunctionLiteral::FunctionType function_type = shared_info->is_expression()
         ? (shared_info->is_anonymous()
               ? FunctionLiteral::ANONYMOUS_EXPRESSION
               : FunctionLiteral::NAMED_EXPRESSION)
         : FunctionLiteral::DECLARATION;
     bool ok = true;
  
     if (shared_info->is_arrow()) {
       Expression* expression = ParseExpression(false, &ok);
       DCHECK(expression->IsFunctionLiteral());
       result = expression->AsFunctionLiteral();
     } else {
       result = ParseFunctionLiteral(raw_name, Scanner::Location::invalid(),
                                     false,  // Strict mode name already checked.
                                     shared_info->kind(), RelocInfo::kNoPosition,
                                     function_type,
                                     FunctionLiteral::NORMAL_ARITY, &ok);
     }
     // Make sure the results agree.
     DCHECK(ok == (result != NULL));
   }
  
   // Make sure the target stack is empty.
   DCHECK(target_stack_ == NULL);
  
   if (result != NULL) {
     Handle<String> inferred_name(shared_info->inferred_name());
     result->set_inferred_name(inferred_name);
   }
   return result;
 }

Here is the call graph for this function:

◆ ParseLazyFunctionBodyWithPreParser()

PreParser::PreParseResult v8::internal::Parser::ParseLazyFunctionBodyWithPreParser ( SingletonLogger * logger )

private

Definition at line 3826 of file parser.cc.

                              {
   // This function may be called on a background thread too; record only the
   // main thread preparse times.
   if (pre_parse_timer_ != NULL) {
     pre_parse_timer_->Start();
   }
   DCHECK_EQ(Token::LBRACE, scanner()->current_token());
  
   if (reusable_preparser_ == NULL) {
     reusable_preparser_ = new PreParser(&scanner_, NULL, stack_limit_);
     reusable_preparser_->set_allow_harmony_scoping(allow_harmony_scoping());
     reusable_preparser_->set_allow_modules(allow_modules());
     reusable_preparser_->set_allow_natives_syntax(allow_natives_syntax());
     reusable_preparser_->set_allow_lazy(true);
     reusable_preparser_->set_allow_arrow_functions(allow_arrow_functions());
     reusable_preparser_->set_allow_harmony_numeric_literals(
         allow_harmony_numeric_literals());
     reusable_preparser_->set_allow_classes(allow_classes());
     reusable_preparser_->set_allow_harmony_object_literals(
         allow_harmony_object_literals());
   }
   PreParser::PreParseResult result =
       reusable_preparser_->PreParseLazyFunction(strict_mode(),
                                                 is_generator(),
                                                 logger);
   if (pre_parse_timer_ != NULL) {
     pre_parse_timer_->Stop();
   }
   return result;
 }

Referenced by SkipLazyFunctionBody().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseModule()

Module * v8::internal::Parser::ParseModule ( bool * ok )

private

Definition at line 1230 of file parser.cc.

                                     {
   // Module:
   //    '{' ModuleElement '}'
   //    '=' ModulePath ';'
   //    'at' String ';'
  
   switch (peek()) {
     case Token::LBRACE:
       return ParseModuleLiteral(ok);
  
     case Token::ASSIGN: {
       Expect(Token::ASSIGN, CHECK_OK);
       Module* result = ParseModulePath(CHECK_OK);
       ExpectSemicolon(CHECK_OK);
       return result;
     }
  
     default: {
       ExpectContextualKeyword(CStrVector("at"), CHECK_OK);
       Module* result = ParseModuleUrl(CHECK_OK);
       ExpectSemicolon(CHECK_OK);
       return result;
     }
   }
 }

References CHECK_OK, v8::internal::CStrVector(), v8::internal::ParserBase< ParserTraits >::Expect(), v8::internal::ParserBase< ParserTraits >::ExpectContextualKeyword(), v8::internal::ParserBase< ParserTraits >::ExpectSemicolon(), ParseModuleLiteral(), ParseModulePath(), and ParseModuleUrl().

Referenced by ParseModuleDeclaration().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseModuleDeclaration()

Statement * v8::internal::Parser::ParseModuleDeclaration	(	ZoneList< const AstRawString * > *	names,
		bool *	ok
	)

private

Definition at line 1193 of file parser.cc.

                                                     {
   // ModuleDeclaration:
   //    'module' Identifier Module
  
   int pos = peek_position();
   const AstRawString* name =
       ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
  
 #ifdef DEBUG
   if (FLAG_print_interface_details)
     PrintF("# Module %.*s ", name->length(), name->raw_data());
 #endif
  
   Module* module = ParseModule(CHECK_OK);
   VariableProxy* proxy = NewUnresolved(name, MODULE, module->interface());
   Declaration* declaration =
       factory()->NewModuleDeclaration(proxy, module, scope_, pos);
   Declare(declaration, true, CHECK_OK);
  
 #ifdef DEBUG
   if (FLAG_print_interface_details)
     PrintF("# Module %.*s ", name->length(), name->raw_data());
   if (FLAG_print_interfaces) {
     PrintF("module %.*s: ", name->length(), name->raw_data());
     module->interface()->Print();
   }
 #endif
  
   if (names) names->Add(name, zone());
   if (module->body() == NULL)
     return factory()->NewEmptyStatement(pos);
   else
     return factory()->NewModuleStatement(proxy, module->body(), pos);
 }

References v8::internal::List< T, AllocationPolicy >::Add(), v8::internal::Module::body(), CHECK_OK, Declare(), v8::internal::ParserBase< ParserTraits >::factory(), v8::internal::Module::interface(), v8::internal::ParserBase< ParserTraits >::kDontAllowEvalOrArguments, v8::internal::MODULE, name, NewUnresolved(), NULL, v8::internal::ParserBase< ParserTraits >::ParseIdentifier(), ParseModule(), v8::internal::ParserBase< ParserTraits >::peek_position(), v8::internal::PrintF(), v8::internal::ParserBase< ParserTraits >::scope_, and v8::internal::ParserBase< ParserTraits >::zone().

Referenced by ParseExportDeclaration(), and ParseModuleElement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseModuleElement()

Statement * v8::internal::Parser::ParseModuleElement	(	ZoneList< const AstRawString * > *	labels,
		bool *	ok
	)

private

Definition at line 1139 of file parser.cc.

                                                 {
   // (Ecma 262 5th Edition, clause 14):
   // SourceElement:
   //    Statement
   //    FunctionDeclaration
   //
   // In harmony mode we allow additionally the following productions
   // ModuleElement:
   //    LetDeclaration
   //    ConstDeclaration
   //    ModuleDeclaration
   //    ImportDeclaration
   //    ExportDeclaration
   //    GeneratorDeclaration
  
   switch (peek()) {
     case Token::FUNCTION:
       return ParseFunctionDeclaration(NULL, ok);
     case Token::CLASS:
       return ParseClassDeclaration(NULL, ok);
     case Token::IMPORT:
       return ParseImportDeclaration(ok);
     case Token::EXPORT:
       return ParseExportDeclaration(ok);
     case Token::CONST:
       return ParseVariableStatement(kModuleElement, NULL, ok);
     case Token::LET:
       DCHECK(allow_harmony_scoping());
       if (strict_mode() == STRICT) {
         return ParseVariableStatement(kModuleElement, NULL, ok);
       }
       // Fall through.
     default: {
       Statement* stmt = ParseStatement(labels, CHECK_OK);
       // Handle 'module' as a context-sensitive keyword.
       if (FLAG_harmony_modules &&
           peek() == Token::IDENTIFIER &&
           !scanner()->HasAnyLineTerminatorBeforeNext() &&
           stmt != NULL) {
         ExpressionStatement* estmt = stmt->AsExpressionStatement();
         if (estmt != NULL && estmt->expression()->AsVariableProxy() != NULL &&
             estmt->expression()->AsVariableProxy()->raw_name() ==
                 ast_value_factory()->module_string() &&
             !scanner()->literal_contains_escapes()) {
           return ParseModuleDeclaration(NULL, ok);
         }
       }
       return stmt;
     }
   }
 }

References v8::internal::ParserBase< ParserTraits >::allow_harmony_scoping(), ast_value_factory(), CHECK_OK, v8::internal::CONST, DCHECK, kModuleElement, v8::internal::LET, NULL, ParseClassDeclaration(), ParseExportDeclaration(), ParseFunctionDeclaration(), ParseImportDeclaration(), ParseModuleDeclaration(), ParseStatement(), ParseVariableStatement(), v8::internal::ParserBase< ParserTraits >::scanner(), v8::internal::STRICT, and v8::internal::ParserBase< ParserTraits >::strict_mode().

Referenced by ParseModuleLiteral(), and ParseSourceElements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseModuleLiteral()

Module * v8::internal::Parser::ParseModuleLiteral ( bool * ok )

private

Definition at line 1257 of file parser.cc.

                                            {
   // Module:
   //    '{' ModuleElement '}'
  
   int pos = peek_position();
   // Construct block expecting 16 statements.
   Block* body = factory()->NewBlock(NULL, 16, false, RelocInfo::kNoPosition);
 #ifdef DEBUG
   if (FLAG_print_interface_details) PrintF("# Literal ");
 #endif
   Scope* scope = NewScope(scope_, MODULE_SCOPE);
  
   Expect(Token::LBRACE, CHECK_OK);
   scope->set_start_position(scanner()->location().beg_pos);
   scope->SetStrictMode(STRICT);
  
   {
     BlockState block_state(&scope_, scope);
     TargetCollector collector(zone());
     Target target(&this->target_stack_, &collector);
     Target target_body(&this->target_stack_, body);
  
     while (peek() != Token::RBRACE) {
       Statement* stat = ParseModuleElement(NULL, CHECK_OK);
       if (stat && !stat->IsEmpty()) {
         body->AddStatement(stat, zone());
       }
     }
   }
  
   Expect(Token::RBRACE, CHECK_OK);
   scope->set_end_position(scanner()->location().end_pos);
   body->set_scope(scope);
  
   // Check that all exports are bound.
   Interface* interface = scope->interface();
   for (Interface::Iterator it = interface->iterator();
        !it.done(); it.Advance()) {
     if (scope->LookupLocal(it.name()) == NULL) {
       ParserTraits::ReportMessage("module_export_undefined", it.name());
       *ok = false;
       return NULL;
     }
   }
  
   interface->MakeModule(ok);
   DCHECK(*ok);
   interface->Freeze(ok);
   DCHECK(*ok);
   return factory()->NewModuleLiteral(body, interface, pos);
 }

References CHECK_OK, DCHECK, v8::internal::Interface::Iterator::done(), v8::internal::ParserBase< ParserTraits >::Expect(), v8::internal::ParserBase< ParserTraits >::factory(), v8::internal::Statement::IsEmpty(), v8::internal::RelocInfo::kNoPosition, v8::internal::Scope::LookupLocal(), v8::internal::MODULE_SCOPE, NewScope(), NULL, ParseModuleElement(), v8::internal::ParserBase< ParserTraits >::peek_position(), v8::internal::PrintF(), v8::internal::ParserTraits::ReportMessage(), v8::internal::ParserBase< ParserTraits >::scanner(), v8::internal::ParserBase< ParserTraits >::scope_, v8::internal::Scope::set_end_position(), v8::internal::Scope::set_start_position(), v8::internal::Scope::SetStrictMode(), v8::internal::STRICT, target_stack_, and v8::internal::ParserBase< ParserTraits >::zone().

Referenced by ParseModule().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseModulePath()

Module * v8::internal::Parser::ParseModulePath ( bool * ok )

private

Definition at line 1310 of file parser.cc.

                                         {
   // ModulePath:
   //    Identifier
   //    ModulePath '.' Identifier
  
   int pos = peek_position();
   Module* result = ParseModuleVariable(CHECK_OK);
   while (Check(Token::PERIOD)) {
     const AstRawString* name = ParseIdentifierName(CHECK_OK);
 #ifdef DEBUG
     if (FLAG_print_interface_details)
       PrintF("# Path .%.*s ", name->length(), name->raw_data());
 #endif
     Module* member = factory()->NewModulePath(result, name, pos);
     result->interface()->Add(name, member->interface(), zone(), ok);
     if (!*ok) {
 #ifdef DEBUG
       if (FLAG_print_interfaces) {
         PrintF("PATH TYPE ERROR at '%.*s'\n", name->length(), name->raw_data());
         PrintF("result: ");
         result->interface()->Print();
         PrintF("member: ");
         member->interface()->Print();
       }
 #endif
       ParserTraits::ReportMessage("invalid_module_path", name);
       return NULL;
     }
     result = member;
   }
  
   return result;
 }

References v8::internal::Interface::Add(), v8::internal::ParserBase< ParserTraits >::Check(), CHECK_OK, v8::internal::ParserBase< ParserTraits >::factory(), v8::internal::Module::interface(), name, NULL, v8::internal::ParserBase< ParserTraits >::ParseIdentifierName(), ParseModuleVariable(), v8::internal::ParserBase< ParserTraits >::peek_position(), v8::internal::PrintF(), v8::internal::ParserTraits::ReportMessage(), and v8::internal::ParserBase< ParserTraits >::zone().

Referenced by ParseModule(), and ParseModuleSpecifier().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseModuleSpecifier()

Module * v8::internal::Parser::ParseModuleSpecifier ( bool * ok )

private

Definition at line 1393 of file parser.cc.

                                              {
   // ModuleSpecifier:
   //    String
   //    ModulePath
  
   if (peek() == Token::STRING) {
     return ParseModuleUrl(ok);
   } else {
     return ParseModulePath(ok);
   }
 }

References ParseModulePath(), ParseModuleUrl(), and STRING.

Referenced by ParseImportDeclaration().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseModuleUrl()

Module * v8::internal::Parser::ParseModuleUrl ( bool * ok )

private

Definition at line 1364 of file parser.cc.

                                        {
   // Module:
   //    String
  
   int pos = peek_position();
   Expect(Token::STRING, CHECK_OK);
   const AstRawString* symbol = GetSymbol(scanner());
  
   // TODO(ES6): Request JS resource from environment...
  
 #ifdef DEBUG
   if (FLAG_print_interface_details) PrintF("# Url ");
 #endif
  
   // Create an empty literal as long as the feature isn't finished.
   USE(symbol);
   Scope* scope = NewScope(scope_, MODULE_SCOPE);
   Block* body = factory()->NewBlock(NULL, 1, false, RelocInfo::kNoPosition);
   body->set_scope(scope);
   Interface* interface = scope->interface();
   Module* result = factory()->NewModuleLiteral(body, interface, pos);
   interface->Freeze(ok);
   DCHECK(*ok);
   interface->Unify(scope->interface(), zone(), ok);
   DCHECK(*ok);
   return result;
 }

References CHECK_OK, DCHECK, v8::internal::ParserBase< ParserTraits >::Expect(), v8::internal::ParserBase< ParserTraits >::factory(), v8::internal::ParserTraits::GetSymbol(), v8::internal::Scope::interface(), v8::internal::RelocInfo::kNoPosition, v8::internal::MODULE_SCOPE, NewScope(), NULL, v8::internal::ParserBase< ParserTraits >::peek_position(), v8::internal::PrintF(), v8::internal::ParserBase< ParserTraits >::scanner(), v8::internal::ParserBase< ParserTraits >::scope_, STRING, USE(), and v8::internal::ParserBase< ParserTraits >::zone().

Referenced by ParseModule(), and ParseModuleSpecifier().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseModuleVariable()

Module * v8::internal::Parser::ParseModuleVariable ( bool * ok )

private

Definition at line 1345 of file parser.cc.

                                             {
   // ModulePath:
   //    Identifier
  
   int pos = peek_position();
   const AstRawString* name =
       ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
 #ifdef DEBUG
   if (FLAG_print_interface_details)
     PrintF("# Module variable %.*s ", name->length(), name->raw_data());
 #endif
   VariableProxy* proxy = scope_->NewUnresolved(
       factory(), name, Interface::NewModule(zone()),
       scanner()->location().beg_pos);
  
   return factory()->NewModuleVariable(proxy, pos);
 }

References CHECK_OK, v8::internal::ParserBase< ParserTraits >::factory(), v8::internal::ParserBase< ParserTraits >::kDontAllowEvalOrArguments, name, v8::internal::Interface::NewModule(), v8::internal::ParserBase< ParserTraits >::ParseIdentifier(), v8::internal::ParserBase< ParserTraits >::peek_position(), v8::internal::PrintF(), v8::internal::ParserBase< ParserTraits >::scanner(), v8::internal::ParserBase< ParserTraits >::scope_, and v8::internal::ParserBase< ParserTraits >::zone().

Referenced by ParseModulePath().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseNativeDeclaration()

Statement * v8::internal::Parser::ParseNativeDeclaration ( bool * ok )

private

Definition at line 1878 of file parser.cc.

                                                   {
   int pos = peek_position();
   Expect(Token::FUNCTION, CHECK_OK);
   // Allow "eval" or "arguments" for backward compatibility.
   const AstRawString* name = ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   bool done = (peek() == Token::RPAREN);
   while (!done) {
     ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
     done = (peek() == Token::RPAREN);
     if (!done) {
       Expect(Token::COMMA, CHECK_OK);
     }
   }
   Expect(Token::RPAREN, CHECK_OK);
   Expect(Token::SEMICOLON, CHECK_OK);
  
   // Make sure that the function containing the native declaration
   // isn't lazily compiled. The extension structures are only
   // accessible while parsing the first time not when reparsing
   // because of lazy compilation.
   DeclarationScope(VAR)->ForceEagerCompilation();
  
   // TODO(1240846): It's weird that native function declarations are
   // introduced dynamically when we meet their declarations, whereas
   // other functions are set up when entering the surrounding scope.
   VariableProxy* proxy = NewUnresolved(name, VAR, Interface::NewValue());
   Declaration* declaration =
       factory()->NewVariableDeclaration(proxy, VAR, scope_, pos);
   Declare(declaration, true, CHECK_OK);
   NativeFunctionLiteral* lit = factory()->NewNativeFunctionLiteral(
       name, extension_, RelocInfo::kNoPosition);
   return factory()->NewExpressionStatement(
       factory()->NewAssignment(
           Token::INIT_VAR, proxy, lit, RelocInfo::kNoPosition),
       pos);
 }

References CHECK_OK, COMMA, DeclarationScope(), Declare(), v8::internal::ParserBase< ParserTraits >::Expect(), v8::internal::ParserBase< ParserTraits >::extension_, v8::internal::ParserBase< ParserTraits >::factory(), v8::internal::Scope::ForceEagerCompilation(), v8::internal::ParserBase< ParserTraits >::kAllowEvalOrArguments, v8::internal::RelocInfo::kNoPosition, name, NewUnresolved(), v8::internal::Interface::NewValue(), v8::internal::ParserBase< ParserTraits >::ParseIdentifier(), v8::internal::ParserBase< ParserTraits >::peek_position(), v8::internal::ParserBase< ParserTraits >::scope_, and v8::internal::VAR.

Referenced by ParseExpressionOrLabelledStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseOnBackground()

void v8::internal::Parser::ParseOnBackground ( )

Definition at line 4923 of file parser.cc.

                                {
   DCHECK(info()->function() == NULL);
   FunctionLiteral* result = NULL;
   fni_ = new (zone()) FuncNameInferrer(ast_value_factory(), zone());
  
   CompleteParserRecorder recorder;
   if (compile_options() == ScriptCompiler::kProduceParserCache) {
     log_ = &recorder;
   }
  
   DCHECK(info()->source_stream() != NULL);
   ExternalStreamingStream stream(info()->source_stream(),
                                  info()->source_stream_encoding());
   scanner_.Initialize(&stream);
   DCHECK(info()->context().is_null() || info()->context()->IsNativeContext());
  
   // When streaming, we don't know the length of the source until we have parsed
   // it. The raw data can be UTF-8, so we wouldn't know the source length until
   // we have decoded it anyway even if we knew the raw data length (which we
   // don't). We work around this by storing all the scopes which need their end
   // position set at the end of the script (the top scope and possible eval
   // scopes) and set their end position after we know the script length.
   Scope* top_scope = NULL;
   Scope* eval_scope = NULL;
   result = DoParseProgram(info(), &top_scope, &eval_scope);
  
   top_scope->set_end_position(scanner()->location().end_pos);
   if (eval_scope != NULL) {
     eval_scope->set_end_position(scanner()->location().end_pos);
   }
  
   info()->SetFunction(result);
  
   // We cannot internalize on a background thread; a foreground task will take
   // care of calling Parser::Internalize just before compilation.
  
   if (compile_options() == ScriptCompiler::kProduceParserCache) {
     if (result != NULL) *info_->cached_data() = recorder.GetScriptData();
     log_ = NULL;
   }
 }

References ast_value_factory(), v8::internal::CompilationInfo::cached_data(), compile_options(), DCHECK, DoParseProgram(), v8::internal::ParserBase< ParserTraits >::fni_, v8::internal::CompleteParserRecorder::GetScriptData(), info(), info_, v8::internal::Scanner::Initialize(), v8::ScriptCompiler::kProduceParserCache, v8::internal::ParserBase< ParserTraits >::log_, NULL, v8::internal::ParserBase< ParserTraits >::scanner(), scanner_, v8::internal::Scope::set_end_position(), v8::internal::CompilationInfo::SetFunction(), and v8::internal::ParserBase< ParserTraits >::zone().

Here is the call graph for this function:

◆ ParseProgram()

FunctionLiteral * v8::internal::Parser::ParseProgram ( )

private

Definition at line 792 of file parser.cc.

                                       {
   // TODO(bmeurer): We temporarily need to pass allow_nesting = true here,
   // see comment for HistogramTimerScope class.
  
   // It's OK to use the counters here, since this function is only called in
   // the main thread.
   HistogramTimerScope timer_scope(isolate()->counters()->parse(), true);
   Handle<String> source(String::cast(script()->source()));
   isolate()->counters()->total_parse_size()->Increment(source->length());
   base::ElapsedTimer timer;
   if (FLAG_trace_parse) {
     timer.Start();
   }
   fni_ = new (zone()) FuncNameInferrer(ast_value_factory(), zone());
  
   // Initialize parser state.
   CompleteParserRecorder recorder;
  
   if (compile_options() == ScriptCompiler::kProduceParserCache) {
     log_ = &recorder;
   } else if (compile_options() == ScriptCompiler::kConsumeParserCache) {
     cached_parse_data_->Initialize();
   }
  
   source = String::Flatten(source);
   FunctionLiteral* result;
  
   Scope* top_scope = NULL;
   Scope* eval_scope = NULL;
   if (source->IsExternalTwoByteString()) {
     // Notice that the stream is destroyed at the end of the branch block.
     // The last line of the blocks can't be moved outside, even though they're
     // identical calls.
     ExternalTwoByteStringUtf16CharacterStream stream(
         Handle<ExternalTwoByteString>::cast(source), 0, source->length());
     scanner_.Initialize(&stream);
     result = DoParseProgram(info(), &top_scope, &eval_scope);
   } else {
     GenericStringUtf16CharacterStream stream(source, 0, source->length());
     scanner_.Initialize(&stream);
     result = DoParseProgram(info(), &top_scope, &eval_scope);
   }
   top_scope->set_end_position(source->length());
   if (eval_scope != NULL) {
     eval_scope->set_end_position(source->length());
   }
   HandleSourceURLComments();
  
   if (FLAG_trace_parse && result != NULL) {
     double ms = timer.Elapsed().InMillisecondsF();
     if (info()->is_eval()) {
       PrintF("[parsing eval");
     } else if (info()->script()->name()->IsString()) {
       String* name = String::cast(info()->script()->name());
       SmartArrayPointer<char> name_chars = name->ToCString();
       PrintF("[parsing script: %s", name_chars.get());
     } else {
       PrintF("[parsing script");
     }
     PrintF(" - took %0.3f ms]\n", ms);
   }
   if (compile_options() == ScriptCompiler::kProduceParserCache) {
     if (result != NULL) *info_->cached_data() = recorder.GetScriptData();
     log_ = NULL;
   }
   return result;
 }

References ast_value_factory(), v8::internal::CompilationInfo::cached_data(), cached_parse_data_, compile_options(), v8::internal::Isolate::counters(), DoParseProgram(), v8::internal::String::Flatten(), v8::internal::ParserBase< ParserTraits >::fni_, v8::internal::SmartPointerBase< Deallocator, T >::get(), v8::internal::CompleteParserRecorder::GetScriptData(), HandleSourceURLComments(), info(), info_, v8::internal::ParseData::Initialize(), v8::internal::Scanner::Initialize(), isolate(), v8::ScriptCompiler::kConsumeParserCache, v8::ScriptCompiler::kProduceParserCache, v8::internal::ParserBase< ParserTraits >::log_, name, NULL, v8::internal::PrintF(), scanner_, script(), v8::internal::Scope::set_end_position(), and v8::internal::ParserBase< ParserTraits >::zone().

Referenced by Parse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseReturnStatement()

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

private

Definition at line 2552 of file parser.cc.

                                                 {
   // ReturnStatement ::
   //   'return' Expression? ';'
  
   // Consume the return token. It is necessary to do that before
   // reporting any errors on it, because of the way errors are
   // reported (underlining).
   Expect(Token::RETURN, CHECK_OK);
   Scanner::Location loc = scanner()->location();
  
   Token::Value tok = peek();
   Statement* result;
   Expression* return_value;
   if (scanner()->HasAnyLineTerminatorBeforeNext() ||
       tok == Token::SEMICOLON ||
       tok == Token::RBRACE ||
       tok == Token::EOS) {
     return_value = GetLiteralUndefined(position());
   } else {
     return_value = ParseExpression(true, CHECK_OK);
   }
   ExpectSemicolon(CHECK_OK);
   if (is_generator()) {
     Expression* generator = factory()->NewVariableProxy(
         function_state_->generator_object_variable());
     Expression* yield = factory()->NewYield(
         generator, return_value, Yield::kFinal, loc.beg_pos);
     result = factory()->NewExpressionStatement(yield, loc.beg_pos);
   } else {
     result = factory()->NewReturnStatement(return_value, loc.beg_pos);
   }
  
   Scope* decl_scope = scope_->DeclarationScope();
   if (decl_scope->is_global_scope() || decl_scope->is_eval_scope()) {
     ReportMessageAt(loc, "illegal_return");
     *ok = false;
     return NULL;
   }
   return result;
 }

References v8::internal::Scanner::Location::beg_pos, CHECK_OK, v8::internal::ParserBase< ParserTraits >::Expect(), v8::internal::ParserBase< ParserTraits >::ExpectSemicolon(), v8::internal::ParserBase< ParserTraits >::factory(), v8::internal::ParserBase< ParserTraits >::function_state_, GetLiteralUndefined(), v8::internal::Scope::is_eval_scope(), v8::internal::ParserBase< ParserTraits >::is_generator(), v8::internal::Scope::is_global_scope(), v8::internal::Scanner::location(), NULL, v8::internal::ParserBase< ParserTraits >::ParseExpression(), v8::internal::ParserBase< ParserTraits >::position(), v8::internal::ParserBase< ParserTraits >::ReportMessageAt(), v8::internal::ParserBase< ParserTraits >::scanner(), and v8::internal::ParserBase< ParserTraits >::scope_.

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseScopedBlock()

Block * v8::internal::Parser::ParseScopedBlock	(	ZoneList< const AstRawString * > *	labels,
		bool *	ok
	)

private

Definition at line 2022 of file parser.cc.

                                           {
   // The harmony mode uses block elements instead of statements.
   //
   // Block ::
   //   '{' BlockElement* '}'
  
   // Construct block expecting 16 statements.
   Block* body =
       factory()->NewBlock(labels, 16, false, RelocInfo::kNoPosition);
   Scope* block_scope = NewScope(scope_, BLOCK_SCOPE);
  
   // Parse the statements and collect escaping labels.
   Expect(Token::LBRACE, CHECK_OK);
   block_scope->set_start_position(scanner()->location().beg_pos);
   { BlockState block_state(&scope_, block_scope);
     TargetCollector collector(zone());
     Target target(&this->target_stack_, &collector);
     Target target_body(&this->target_stack_, body);
  
     while (peek() != Token::RBRACE) {
       Statement* stat = ParseBlockElement(NULL, CHECK_OK);
       if (stat && !stat->IsEmpty()) {
         body->AddStatement(stat, zone());
       }
     }
   }
   Expect(Token::RBRACE, CHECK_OK);
   block_scope->set_end_position(scanner()->location().end_pos);
   block_scope = block_scope->FinalizeBlockScope();
   body->set_scope(block_scope);
   return body;
 }

References v8::internal::BLOCK_SCOPE, CHECK_OK, v8::internal::ParserBase< ParserTraits >::Expect(), v8::internal::ParserBase< ParserTraits >::factory(), v8::internal::Scope::FinalizeBlockScope(), v8::internal::Statement::IsEmpty(), v8::internal::RelocInfo::kNoPosition, NewScope(), NULL, ParseBlockElement(), v8::internal::ParserBase< ParserTraits >::scanner(), v8::internal::ParserBase< ParserTraits >::scope_, v8::internal::Scope::set_end_position(), v8::internal::Scope::set_start_position(), target_stack_, and v8::internal::ParserBase< ParserTraits >::zone().

Referenced by ParseBlock().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseSourceElements()

void * v8::internal::Parser::ParseSourceElements	(	ZoneList< Statement * > *	processor,
		int	end_token,
		bool	is_eval,
		bool	is_global,
		Scope **	ad_hoc_eval_scope,
		bool *	ok
	)

private

Definition at line 1050 of file parser.cc.

                                                                 {
   // SourceElements ::
   //   (ModuleElement)* <end_token>
  
   // Allocate a target stack to use for this set of source
   // elements. This way, all scripts and functions get their own
   // target stack thus avoiding illegal breaks and continues across
   // functions.
   TargetScope scope(&this->target_stack_);
  
   DCHECK(processor != NULL);
   bool directive_prologue = true;     // Parsing directive prologue.
  
   while (peek() != end_token) {
     if (directive_prologue && peek() != Token::STRING) {
       directive_prologue = false;
     }
  
     Scanner::Location token_loc = scanner()->peek_location();
     Statement* stat;
     if (is_global && !is_eval) {
       stat = ParseModuleElement(NULL, CHECK_OK);
     } else {
       stat = ParseBlockElement(NULL, CHECK_OK);
     }
     if (stat == NULL || stat->IsEmpty()) {
       directive_prologue = false;   // End of directive prologue.
       continue;
     }
  
     if (directive_prologue) {
       // A shot at a directive.
       ExpressionStatement* e_stat;
       Literal* literal;
       // Still processing directive prologue?
       if ((e_stat = stat->AsExpressionStatement()) != NULL &&
           (literal = e_stat->expression()->AsLiteral()) != NULL &&
           literal->raw_value()->IsString()) {
         // Check "use strict" directive (ES5 14.1) and "use asm" directive. Only
         // one can be present.
         if (strict_mode() == SLOPPY &&
             literal->raw_value()->AsString() ==
                 ast_value_factory()->use_strict_string() &&
             token_loc.end_pos - token_loc.beg_pos ==
                 ast_value_factory()->use_strict_string()->length() + 2) {
           // TODO(mstarzinger): Global strict eval calls, need their own scope
           // as specified in ES5 10.4.2(3). The correct fix would be to always
           // add this scope in DoParseProgram(), but that requires adaptations
           // all over the code base, so we go with a quick-fix for now.
           // In the same manner, we have to patch the parsing mode.
           if (is_eval && !scope_->is_eval_scope()) {
             DCHECK(scope_->is_global_scope());
             Scope* scope = NewScope(scope_, EVAL_SCOPE);
             scope->set_start_position(scope_->start_position());
             scope->set_end_position(scope_->end_position());
             scope_ = scope;
             if (eval_scope != NULL) {
               // Caller will correct the positions of the ad hoc eval scope.
               *eval_scope = scope;
             }
             mode_ = PARSE_EAGERLY;
           }
           scope_->SetStrictMode(STRICT);
           // "use strict" is the only directive for now.
           directive_prologue = false;
         } else if (literal->raw_value()->AsString() ==
                        ast_value_factory()->use_asm_string() &&
                    token_loc.end_pos - token_loc.beg_pos ==
                        ast_value_factory()->use_asm_string()->length() + 2) {
           // Store the usage count; The actual use counter on the isolate is
           // incremented after parsing is done.
           ++use_counts_[v8::Isolate::kUseAsm];
           scope_->SetAsmModule();
         }
       } else {
         // End of the directive prologue.
         directive_prologue = false;
       }
     }
  
     processor->Add(stat, zone());
   }
  
   return 0;
 }

References v8::internal::List< T, AllocationPolicy >::Add(), ast_value_factory(), v8::internal::Scanner::Location::beg_pos, CHECK_OK, DCHECK, v8::internal::Scanner::Location::end_pos, v8::internal::EVAL_SCOPE, v8::internal::Statement::IsEmpty(), v8::Isolate::kUseAsm, v8::internal::ParserBase< ParserTraits >::mode_, NewScope(), NULL, v8::internal::ParserBase< ParserTraits >::PARSE_EAGERLY, ParseBlockElement(), ParseModuleElement(), v8::internal::Scanner::peek_location(), v8::internal::ParserBase< ParserTraits >::scanner(), v8::internal::ParserBase< ParserTraits >::scope_, v8::internal::Scope::set_end_position(), v8::internal::Scope::set_start_position(), v8::internal::SLOPPY, v8::internal::STRICT, v8::internal::ParserBase< ParserTraits >::strict_mode(), STRING, target_stack_, use_counts_, and v8::internal::ParserBase< ParserTraits >::zone().

Referenced by DoParseProgram(), and ParseEagerFunctionBody().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseStatement()

Statement * v8::internal::Parser::ParseStatement	(	ZoneList< const AstRawString * > *	labels,
		bool *	ok
	)

private

Definition at line 1586 of file parser.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.
   switch (peek()) {
     case Token::LBRACE:
       return ParseBlock(labels, ok);
  
     case Token::SEMICOLON:
       Next();
       return factory()->NewEmptyStatement(RelocInfo::kNoPosition);
  
     case Token::IF:
       return ParseIfStatement(labels, ok);
  
     case Token::DO:
       return ParseDoWhileStatement(labels, ok);
  
     case Token::WHILE:
       return ParseWhileStatement(labels, ok);
  
     case Token::FOR:
       return ParseForStatement(labels, ok);
  
     case Token::CONTINUE:
       return ParseContinueStatement(ok);
  
     case Token::BREAK:
       return ParseBreakStatement(labels, ok);
  
     case Token::RETURN:
       return ParseReturnStatement(ok);
  
     case Token::WITH:
       return ParseWithStatement(labels, ok);
  
     case Token::SWITCH:
       return ParseSwitchStatement(labels, ok);
  
     case Token::THROW:
       return ParseThrowStatement(ok);
  
     case Token::TRY: {
       // NOTE: It is somewhat complicated to have labels on
       // try-statements. When breaking out of a try-finally statement,
       // one must take great care not to treat it as a
       // fall-through. It is much easier just to wrap the entire
       // try-statement in a statement block and put the labels there
       Block* result =
           factory()->NewBlock(labels, 1, false, RelocInfo::kNoPosition);
       Target target(&this->target_stack_, result);
       TryStatement* statement = ParseTryStatement(CHECK_OK);
       if (result) result->AddStatement(statement, zone());
       return result;
     }
  
     case Token::FUNCTION: {
       // FunctionDeclaration is only allowed in the context of SourceElements
       // (Ecma 262 5th Edition, clause 14):
       // SourceElement:
       //    Statement
       //    FunctionDeclaration
       // Common language extension is to allow function declaration in place
       // of any statement. This language extension is disabled in strict mode.
       //
       // In Harmony mode, this case also handles the extension:
       // Statement:
       //    GeneratorDeclaration
       if (strict_mode() == STRICT) {
         ReportMessageAt(scanner()->peek_location(), "strict_function");
         *ok = false;
         return NULL;
       }
       return ParseFunctionDeclaration(NULL, ok);
     }
  
     case Token::CLASS:
       return ParseClassDeclaration(NULL, ok);
  
     case Token::DEBUGGER:
       return ParseDebuggerStatement(ok);
  
     case Token::VAR:
     case Token::CONST:
       return ParseVariableStatement(kStatement, NULL, ok);
  
     case Token::LET:
       DCHECK(allow_harmony_scoping());
       if (strict_mode() == STRICT) {
         return ParseVariableStatement(kStatement, NULL, ok);
       }
       // Fall through.
     default:
       return ParseExpressionOrLabelledStatement(labels, ok);
   }
 }

References v8::internal::ParserBase< ParserTraits >::allow_harmony_scoping(), v8::internal::BREAK, CHECK_OK, v8::internal::CONST, DCHECK, v8::internal::ParserBase< ParserTraits >::factory(), v8::internal::RelocInfo::kNoPosition, kStatement, v8::internal::LET, NULL, ParseBlock(), ParseBreakStatement(), ParseClassDeclaration(), ParseContinueStatement(), ParseDebuggerStatement(), ParseDoWhileStatement(), ParseExpressionOrLabelledStatement(), ParseForStatement(), ParseFunctionDeclaration(), ParseIfStatement(), ParseReturnStatement(), ParseSwitchStatement(), ParseThrowStatement(), ParseTryStatement(), ParseVariableStatement(), ParseWhileStatement(), ParseWithStatement(), v8::internal::ParserBase< ParserTraits >::ReportMessageAt(), v8::internal::ParserBase< ParserTraits >::scanner(), v8::internal::STRICT, v8::internal::ParserBase< ParserTraits >::strict_mode(), target_stack_, v8::internal::VAR, and v8::internal::ParserBase< ParserTraits >::zone().

Referenced by ParseBlock(), ParseBlockElement(), ParseCaseClause(), ParseDoWhileStatement(), ParseExpressionOrLabelledStatement(), ParseForStatement(), ParseIfStatement(), ParseModuleElement(), ParseWhileStatement(), and ParseWithStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseSwitchStatement()

SwitchStatement * v8::internal::Parser::ParseSwitchStatement	(	ZoneList< const AstRawString * > *	labels,
		bool *	ok
	)

private

Definition at line 2657 of file parser.cc.

                                                      {
   // SwitchStatement ::
   //   'switch' '(' Expression ')' '{' CaseClause* '}'
  
   SwitchStatement* statement =
       factory()->NewSwitchStatement(labels, peek_position());
   Target target(&this->target_stack_, statement);
  
   Expect(Token::SWITCH, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   Expression* tag = ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
  
   bool default_seen = false;
   ZoneList<CaseClause*>* cases = new(zone()) ZoneList<CaseClause*>(4, zone());
   Expect(Token::LBRACE, CHECK_OK);
   while (peek() != Token::RBRACE) {
     CaseClause* clause = ParseCaseClause(&default_seen, CHECK_OK);
     cases->Add(clause, zone());
   }
   Expect(Token::RBRACE, CHECK_OK);
  
   if (statement) statement->Initialize(tag, cases);
   return statement;
 }

References v8::internal::List< T, AllocationPolicy >::Add(), CHECK_OK, v8::internal::ParserBase< ParserTraits >::Expect(), v8::internal::ParserBase< ParserTraits >::factory(), ParseCaseClause(), v8::internal::ParserBase< ParserTraits >::ParseExpression(), v8::internal::ParserBase< ParserTraits >::peek_position(), target_stack_, and v8::internal::ParserBase< ParserTraits >::zone().

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseThrowStatement()

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

private

Definition at line 2685 of file parser.cc.

                                                {
   // ThrowStatement ::
   //   'throw' Expression ';'
  
   Expect(Token::THROW, CHECK_OK);
   int pos = position();
   if (scanner()->HasAnyLineTerminatorBeforeNext()) {
     ReportMessage("newline_after_throw");
     *ok = false;
     return NULL;
   }
   Expression* exception = ParseExpression(true, CHECK_OK);
   ExpectSemicolon(CHECK_OK);
  
   return factory()->NewExpressionStatement(
       factory()->NewThrow(exception, pos), pos);
 }

References CHECK_OK, v8::internal::ParserBase< ParserTraits >::Expect(), v8::internal::ParserBase< ParserTraits >::ExpectSemicolon(), v8::internal::ParserBase< ParserTraits >::factory(), NULL, v8::internal::ParserBase< ParserTraits >::ParseExpression(), v8::internal::ParserBase< ParserTraits >::position(), v8::internal::ParserBase< ParserTraits >::ReportMessage(), and v8::internal::ParserBase< ParserTraits >::scanner().

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseTryStatement()

TryStatement * v8::internal::Parser::ParseTryStatement ( bool * ok )

private

Definition at line 2704 of file parser.cc.

                                                 {
   // TryStatement ::
   //   'try' Block Catch
   //   'try' Block Finally
   //   'try' Block Catch Finally
   //
   // Catch ::
   //   'catch' '(' Identifier ')' Block
   //
   // Finally ::
   //   'finally' Block
  
   Expect(Token::TRY, CHECK_OK);
   int pos = position();
  
   TargetCollector try_collector(zone());
   Block* try_block;
  
   { Target target(&this->target_stack_, &try_collector);
     try_block = ParseBlock(NULL, CHECK_OK);
   }
  
   Token::Value tok = peek();
   if (tok != Token::CATCH && tok != Token::FINALLY) {
     ReportMessage("no_catch_or_finally");
     *ok = false;
     return NULL;
   }
  
   // If we can break out from the catch block and there is a finally block,
   // then we will need to collect escaping targets from the catch
   // block. Since we don't know yet if there will be a finally block, we
   // always collect the targets.
   TargetCollector catch_collector(zone());
   Scope* catch_scope = NULL;
   Variable* catch_variable = NULL;
   Block* catch_block = NULL;
   const AstRawString* name = NULL;
   if (tok == Token::CATCH) {
     Consume(Token::CATCH);
  
     Expect(Token::LPAREN, CHECK_OK);
     catch_scope = NewScope(scope_, CATCH_SCOPE);
     catch_scope->set_start_position(scanner()->location().beg_pos);
     name = ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
  
     Expect(Token::RPAREN, CHECK_OK);
  
     Target target(&this->target_stack_, &catch_collector);
     VariableMode mode =
         allow_harmony_scoping() && strict_mode() == STRICT ? LET : VAR;
     catch_variable = catch_scope->DeclareLocal(name, mode, kCreatedInitialized);
     BlockState block_state(&scope_, catch_scope);
     catch_block = ParseBlock(NULL, CHECK_OK);
  
     catch_scope->set_end_position(scanner()->location().end_pos);
     tok = peek();
   }
  
   Block* finally_block = NULL;
   DCHECK(tok == Token::FINALLY || catch_block != NULL);
   if (tok == Token::FINALLY) {
     Consume(Token::FINALLY);
     finally_block = ParseBlock(NULL, CHECK_OK);
   }
  
   // Simplify the AST nodes by converting:
   //   'try B0 catch B1 finally B2'
   // to:
   //   'try { try B0 catch B1 } finally B2'
  
   if (catch_block != NULL && finally_block != NULL) {
     // If we have both, create an inner try/catch.
     DCHECK(catch_scope != NULL && catch_variable != NULL);
     int index = function_state_->NextHandlerIndex();
     TryCatchStatement* statement = factory()->NewTryCatchStatement(
         index, try_block, catch_scope, catch_variable, catch_block,
         RelocInfo::kNoPosition);
     statement->set_escaping_targets(try_collector.targets());
     try_block = factory()->NewBlock(NULL, 1, false, RelocInfo::kNoPosition);
     try_block->AddStatement(statement, zone());
     catch_block = NULL;  // Clear to indicate it's been handled.
   }
  
   TryStatement* result = NULL;
   if (catch_block != NULL) {
     DCHECK(finally_block == NULL);
     DCHECK(catch_scope != NULL && catch_variable != NULL);
     int index = function_state_->NextHandlerIndex();
     result = factory()->NewTryCatchStatement(
         index, try_block, catch_scope, catch_variable, catch_block, pos);
   } else {
     DCHECK(finally_block != NULL);
     int index = function_state_->NextHandlerIndex();
     result = factory()->NewTryFinallyStatement(
         index, try_block, finally_block, pos);
     // Combine the jump targets of the try block and the possible catch block.
     try_collector.targets()->AddAll(*catch_collector.targets(), zone());
   }
  
   result->set_escaping_targets(try_collector.targets());
   return result;
 }

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseV8Intrinsic()

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

private

Definition at line 3859 of file parser.cc.

                                              {
   // CallRuntime ::
   //   '%' Identifier Arguments
  
   int pos = peek_position();
   Expect(Token::MOD, CHECK_OK);
   // Allow "eval" or "arguments" for backward compatibility.
   const AstRawString* name = ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
   ZoneList<Expression*>* args = ParseArguments(CHECK_OK);
  
   if (extension_ != NULL) {
     // The extension structures are only accessible while parsing the
     // very first time not when reparsing because of lazy compilation.
     scope_->DeclarationScope()->ForceEagerCompilation();
   }
  
   const Runtime::Function* function = Runtime::FunctionForName(name->string());
  
   // Check for built-in IS_VAR macro.
   if (function != NULL &&
       function->intrinsic_type == Runtime::RUNTIME &&
       function->function_id == Runtime::kIS_VAR) {
     // %IS_VAR(x) evaluates to x if x is a variable,
     // leads to a parse error otherwise.  Could be implemented as an
     // inline function %_IS_VAR(x) to eliminate this special case.
     if (args->length() == 1 && args->at(0)->AsVariableProxy() != NULL) {
       return args->at(0);
     } else {
       ReportMessage("not_isvar");
       *ok = false;
       return NULL;
     }
   }
  
   // Check that the expected number of arguments are being passed.
   if (function != NULL &&
       function->nargs != -1 &&
       function->nargs != args->length()) {
     ReportMessage("illegal_access");
     *ok = false;
     return NULL;
   }
  
   // Check that the function is defined if it's an inline runtime call.
   if (function == NULL && name->FirstCharacter() == '_') {
     ParserTraits::ReportMessage("not_defined", name);
     *ok = false;
     return NULL;
   }
  
   // We have a valid intrinsics call or a call to a builtin.
   return factory()->NewCallRuntime(name, function, args, pos);
 }

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseVariableDeclarations()

Block * v8::internal::Parser::ParseVariableDeclarations	(	VariableDeclarationContext	var_context,
		VariableDeclarationProperties *	decl_props,
		ZoneList< const AstRawString * > *	names,
		const AstRawString **	out,
		bool *	ok
	)

private

Definition at line 2076 of file parser.cc.

               {
   // VariableDeclarations ::
   //   ('var' | 'const' | 'let') (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
  
   int pos = peek_position();
   VariableMode mode = VAR;
   // True if the binding needs initialization. 'let' and 'const' declared
   // bindings are created uninitialized by their declaration nodes and
   // need initialization. 'var' declared bindings are always initialized
   // immediately by their declaration nodes.
   bool needs_init = false;
   bool is_const = false;
   Token::Value init_op = Token::INIT_VAR;
   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);
     switch (strict_mode()) {
       case SLOPPY:
         mode = CONST_LEGACY;
         init_op = Token::INIT_CONST_LEGACY;
         break;
       case STRICT:
         if (allow_harmony_scoping()) {
           if (var_context == kStatement) {
             // In strict mode 'const' declarations are only allowed in source
             // element positions.
             ReportMessage("unprotected_const");
             *ok = false;
             return NULL;
           }
           mode = CONST;
           init_op = Token::INIT_CONST;
         } else {
           ReportMessage("strict_const");
           *ok = false;
           return NULL;
         }
     }
     is_const = true;
     needs_init = true;
   } else if (peek() == Token::LET && strict_mode() == STRICT) {
     DCHECK(allow_harmony_scoping());
     Consume(Token::LET);
     if (var_context == kStatement) {
       // Let declarations are only allowed in source element positions.
       ReportMessage("unprotected_let");
       *ok = false;
       return NULL;
     }
     mode = LET;
     needs_init = true;
     init_op = Token::INIT_LET;
   } else {
     UNREACHABLE();  // by current callers
   }
  
   Scope* declaration_scope = DeclarationScope(mode);
  
   // 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). Thus we can
   // transform a source-level var/const declaration into a (Function)
   // Scope declaration, and rewrite the source-level initialization into an
   // assignment statement. We use a block to collect multiple assignments.
   //
   // We mark the block as initializer block because we don't want the
   // rewriter to add a '.result' assignment to such a block (to get compliant
   // behavior for code such as print(eval('var x = 7')), and for cosmetic
   // reasons when pretty-printing. Also, unless an assignment (initialization)
   // is inside an initializer block, it is ignored.
   //
   // Create new block with one expected declaration.
   Block* block = factory()->NewBlock(NULL, 1, true, pos);
   int nvars = 0;  // the number of variables declared
   const AstRawString* name = NULL;
   do {
     if (fni_ != NULL) fni_->Enter();
  
     // Parse variable name.
     if (nvars > 0) Consume(Token::COMMA);
     name = ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
     if (fni_ != NULL) fni_->PushVariableName(name);
  
     // Declare variable.
     // Note that we *always* must treat the initial value via a separate init
     // assignment for variables and constants because the value must be assigned
     // when the variable is encountered in the source. But the variable/constant
     // is declared (and set to 'undefined') upon entering the function within
     // which the variable or constant is declared. Only function variables have
     // an initial value in the declaration (because they are initialized upon
     // entering the function).
     //
     // If we have a const declaration, in an inner scope, the proxy is always
     // bound to the declared variable (independent of possibly surrounding with
     // statements).
     // For let/const declarations in harmony mode, we can also immediately
     // pre-resolve the proxy because it resides in the same scope as the
     // declaration.
     Interface* interface =
         is_const ? Interface::NewConst() : Interface::NewValue();
     VariableProxy* proxy = NewUnresolved(name, mode, interface);
     Declaration* declaration =
         factory()->NewVariableDeclaration(proxy, mode, scope_, pos);
     Declare(declaration, mode != VAR, CHECK_OK);
     nvars++;
     if (declaration_scope->num_var_or_const() > kMaxNumFunctionLocals) {
       ReportMessage("too_many_variables");
       *ok = false;
       return NULL;
     }
     if (names) names->Add(name, zone());
  
     // Parse initialization expression if present and/or needed. A
     // declaration of the form:
     //
     //    var v = x;
     //
     // is syntactic sugar for:
     //
     //    var v; v = x;
     //
     // In particular, we need to re-lookup 'v' (in scope_, not
     // declaration_scope) as it may be a different 'v' than the 'v' in the
     // declaration (e.g., if we are inside a 'with' statement or 'catch'
     // block).
     //
     // However, note that const declarations are different! A const
     // declaration of the form:
     //
     //   const c = x;
     //
     // is *not* syntactic sugar for:
     //
     //   const c; c = x;
     //
     // The "variable" c initialized to x is the same as the declared
     // one - there is no re-lookup (see the last parameter of the
     // Declare() call above).
  
     Scope* initialization_scope = is_const ? declaration_scope : scope_;
     Expression* value = NULL;
     int pos = -1;
     // Harmony consts have non-optional initializers.
     if (peek() == Token::ASSIGN || mode == CONST) {
       Expect(Token::ASSIGN, CHECK_OK);
       pos = position();
       value = ParseAssignmentExpression(var_context != kForStatement, CHECK_OK);
       // Don't infer if it is "a = function(){...}();"-like expression.
       if (fni_ != NULL &&
           value->AsCall() == NULL &&
           value->AsCallNew() == NULL) {
         fni_->Infer();
       } else {
         fni_->RemoveLastFunction();
       }
       if (decl_props != NULL) *decl_props = kHasInitializers;
     }
  
     // Record the end position of the initializer.
     if (proxy->var() != NULL) {
       proxy->var()->set_initializer_position(position());
     }
  
     // Make sure that 'const x' and 'let x' initialize 'x' to undefined.
     if (value == NULL && needs_init) {
       value = GetLiteralUndefined(position());
     }
  
     // Global variable declarations must be compiled in a specific
     // way. When the script containing the global variable declaration
     // is entered, the global variable must be declared, so that if it
     // doesn't exist (on the global object itself, see ES5 errata) it
     // gets created with an initial undefined value. This is handled
     // by the declarations part of the function representing the
     // top-level global code; see Runtime::DeclareGlobalVariable. If
     // it already exists (in the object or in a prototype), it is
     // *not* touched until the variable declaration statement is
     // executed.
     //
     // Executing the variable declaration statement will always
     // guarantee to give the global object an own property.
     // This way, global variable declarations can shadow
     // properties in the prototype chain, but only after the variable
     // declaration statement has been executed. This is important in
     // browsers where the global object (window) has lots of
     // properties defined in prototype objects.
     if (initialization_scope->is_global_scope() &&
         !IsLexicalVariableMode(mode)) {
       // Compute the arguments for the runtime call.
       ZoneList<Expression*>* arguments =
           new(zone()) ZoneList<Expression*>(3, zone());
       // We have at least 1 parameter.
       arguments->Add(factory()->NewStringLiteral(name, pos), zone());
       CallRuntime* initialize;
  
       if (is_const) {
         arguments->Add(value, zone());
         value = NULL;  // zap the value to avoid the unnecessary assignment
  
         // Construct the call to Runtime_InitializeConstGlobal
         // and add it to the initialization statement block.
         // Note that the function does different things depending on
         // the number of arguments (1 or 2).
         initialize = factory()->NewCallRuntime(
             ast_value_factory()->initialize_const_global_string(),
             Runtime::FunctionForId(Runtime::kInitializeConstGlobal), arguments,
             pos);
       } else {
         // Add strict mode.
         // We may want to pass singleton to avoid Literal allocations.
         StrictMode strict_mode = initialization_scope->strict_mode();
         arguments->Add(factory()->NewNumberLiteral(strict_mode, pos), zone());
  
         // Be careful not to assign a value to the global variable if
         // we're in a with. The initialization value should not
         // necessarily be stored in the global object in that case,
         // which is why we need to generate a separate assignment node.
         if (value != NULL && !inside_with()) {
           arguments->Add(value, zone());
           value = NULL;  // zap the value to avoid the unnecessary assignment
           // Construct the call to Runtime_InitializeVarGlobal
           // and add it to the initialization statement block.
           initialize = factory()->NewCallRuntime(
               ast_value_factory()->initialize_var_global_string(),
               Runtime::FunctionForId(Runtime::kInitializeVarGlobal), arguments,
               pos);
         } else {
           initialize = NULL;
         }
       }
  
       if (initialize != NULL) {
         block->AddStatement(factory()->NewExpressionStatement(
                                 initialize, RelocInfo::kNoPosition),
                             zone());
       }
     } else if (needs_init) {
       // Constant initializations always assign to the declared constant which
       // is always at the function scope level. This is only relevant for
       // dynamically looked-up variables and constants (the start context for
       // constant lookups is always the function context, while it is the top
       // context for var declared variables). Sigh...
       // For 'let' and 'const' declared variables in harmony mode the
       // initialization also always assigns to the declared variable.
       DCHECK(proxy != NULL);
       DCHECK(proxy->var() != NULL);
       DCHECK(value != NULL);
       Assignment* assignment =
           factory()->NewAssignment(init_op, proxy, value, pos);
       block->AddStatement(
           factory()->NewExpressionStatement(assignment, RelocInfo::kNoPosition),
           zone());
       value = NULL;
     }
  
     // Add an assignment node to the initialization statement block if we still
     // have a pending initialization value.
     if (value != NULL) {
       DCHECK(mode == VAR);
       // 'var' initializations are simply assignments (with all the consequences
       // if they are inside a 'with' statement - they may change a 'with' object
       // property).
       VariableProxy* proxy =
           initialization_scope->NewUnresolved(factory(), name, interface);
       Assignment* assignment =
           factory()->NewAssignment(init_op, proxy, value, pos);
       block->AddStatement(
           factory()->NewExpressionStatement(assignment, RelocInfo::kNoPosition),
           zone());
     }
  
     if (fni_ != NULL) fni_->Leave();
   } while (peek() == Token::COMMA);
  
   // If there was a single non-const declaration, return it in the output
   // parameter for possible use by for/in.
   if (nvars == 1 && !is_const) {
     *out = name;
   }
  
   return block;
 }

Referenced by ParseForStatement(), and ParseVariableStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseVariableStatement()

Block * v8::internal::Parser::ParseVariableStatement	(	VariableDeclarationContext	var_context,
		ZoneList< const AstRawString * > *	names,
		bool *	ok
	)

private

Definition at line 2057 of file parser.cc.

                                                 {
   // VariableStatement ::
   //   VariableDeclarations ';'
  
   const AstRawString* ignore;
   Block* result =
       ParseVariableDeclarations(var_context, NULL, names, &ignore, CHECK_OK);
   ExpectSemicolon(CHECK_OK);
   return result;
 }

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

Referenced by ParseBlockElement(), ParseExportDeclaration(), ParseModuleElement(), and ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseWhileStatement()

WhileStatement * v8::internal::Parser::ParseWhileStatement	(	ZoneList< const AstRawString * > *	labels,
		bool *	ok
	)

private

Definition at line 2837 of file parser.cc.

                                                      {
   // WhileStatement ::
   //   'while' '(' Expression ')' Statement
  
   WhileStatement* loop = factory()->NewWhileStatement(labels, peek_position());
   Target target(&this->target_stack_, loop);
  
   Expect(Token::WHILE, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   Expression* cond = ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
   Statement* body = ParseStatement(NULL, CHECK_OK);
  
   if (loop != NULL) loop->Initialize(cond, body);
   return loop;
 }

References CHECK_OK, v8::internal::ParserBase< ParserTraits >::Expect(), v8::internal::ParserBase< ParserTraits >::factory(), NULL, v8::internal::ParserBase< ParserTraits >::ParseExpression(), ParseStatement(), v8::internal::ParserBase< ParserTraits >::peek_position(), and target_stack_.

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseWithStatement()

Statement * v8::internal::Parser::ParseWithStatement	(	ZoneList< const AstRawString * > *	labels,
		bool *	ok
	)

private

Definition at line 2594 of file parser.cc.

                                                 {
   // WithStatement ::
   //   'with' '(' Expression ')' Statement
  
   Expect(Token::WITH, CHECK_OK);
   int pos = position();
  
   if (strict_mode() == STRICT) {
     ReportMessage("strict_mode_with");
     *ok = false;
     return NULL;
   }
  
   Expect(Token::LPAREN, CHECK_OK);
   Expression* expr = ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
  
   scope_->DeclarationScope()->RecordWithStatement();
   Scope* with_scope = NewScope(scope_, WITH_SCOPE);
   Statement* stmt;
   { BlockState block_state(&scope_, with_scope);
     with_scope->set_start_position(scanner()->peek_location().beg_pos);
     stmt = ParseStatement(labels, CHECK_OK);
     with_scope->set_end_position(scanner()->location().end_pos);
   }
   return factory()->NewWithStatement(with_scope, expr, stmt, pos);
 }

Referenced by ParseStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RegisterTargetUse()

void v8::internal::Parser::RegisterTargetUse	(	Label *	target,
		Target *	stop
	)

private

Definition at line 3982 of file parser.cc.

                                                           {
   // Register that a break target found at the given stop in the
   // target stack has been used from the top of the target stack. Add
   // the break target to any TargetCollectors passed on the stack.
   for (Target* t = target_stack_; t != stop; t = t->previous()) {
     TargetCollector* collector = t->node()->AsTargetCollector();
     if (collector != NULL) collector->AddTarget(target, zone());
   }
 }

References NULL, target_stack_, and v8::internal::ParserBase< ParserTraits >::zone().

Referenced by LookupBreakTarget(), and LookupContinueTarget().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ script()

Handle<Script> v8::internal::Parser::script ( ) const

inlineprivate

Definition at line 681 of file parser.h.

681 { return info_->script(); }

References info_, and v8::internal::CompilationInfo::script().

Referenced by ParseLazy(), ParseProgram(), Parser(), and ThrowPendingError().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetCachedData()

void v8::internal::Parser::SetCachedData ( )

private

Definition at line 257 of file parser.cc.

                            {
   if (compile_options() == ScriptCompiler::kNoCompileOptions) {
     cached_parse_data_ = NULL;
   } else {
     DCHECK(info_->cached_data() != NULL);
     if (compile_options() == ScriptCompiler::kConsumeParserCache) {
       cached_parse_data_ = new ParseData(*info_->cached_data());
     }
   }
 }

References v8::internal::CompilationInfo::cached_data(), cached_parse_data_, compile_options(), DCHECK, info_, v8::ScriptCompiler::kConsumeParserCache, v8::ScriptCompiler::kNoCompileOptions, and NULL.

Referenced by Parse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SkipLazyFunctionBody()

void v8::internal::Parser::SkipLazyFunctionBody	(	const AstRawString *	function_name,
		int *	materialized_literal_count,
		int *	expected_property_count,
		bool *	ok
	)

private

Definition at line 3701 of file parser.cc.

                                             {
   int function_block_pos = position();
   if (compile_options() == ScriptCompiler::kConsumeParserCache) {
     // If we have cached data, we use it to skip parsing the function body. The
     // data contains the information we need to construct the lazy function.
     FunctionEntry entry =
         cached_parse_data_->GetFunctionEntry(function_block_pos);
     // Check that cached data is valid.
     CHECK(entry.is_valid());
     // End position greater than end of stream is safe, and hard to check.
     CHECK(entry.end_pos() > function_block_pos);
     scanner()->SeekForward(entry.end_pos() - 1);
  
     scope_->set_end_position(entry.end_pos());
     Expect(Token::RBRACE, ok);
     if (!*ok) {
       return;
     }
     total_preparse_skipped_ += scope_->end_position() - function_block_pos;
     *materialized_literal_count = entry.literal_count();
     *expected_property_count = entry.property_count();
     scope_->SetStrictMode(entry.strict_mode());
   } else {
     // With no cached data, we partially parse the function, without building an
     // AST. This gathers the data needed to build a lazy function.
     SingletonLogger logger;
     PreParser::PreParseResult result =
         ParseLazyFunctionBodyWithPreParser(&logger);
     if (result == PreParser::kPreParseStackOverflow) {
       // Propagate stack overflow.
       set_stack_overflow();
       *ok = false;
       return;
     }
     if (logger.has_error()) {
       ParserTraits::ReportMessageAt(
           Scanner::Location(logger.start(), logger.end()),
           logger.message(), logger.argument_opt(), logger.is_reference_error());
       *ok = false;
       return;
     }
     scope_->set_end_position(logger.end());
     Expect(Token::RBRACE, ok);
     if (!*ok) {
       return;
     }
     total_preparse_skipped_ += scope_->end_position() - function_block_pos;
     *materialized_literal_count = logger.literals();
     *expected_property_count = logger.properties();
     scope_->SetStrictMode(logger.strict_mode());
     if (compile_options() == ScriptCompiler::kProduceParserCache) {
       DCHECK(log_);
       // Position right after terminal '}'.
       int body_end = scanner()->location().end_pos;
       log_->LogFunction(function_block_pos, body_end,
                         *materialized_literal_count,
                         *expected_property_count,
                         scope_->strict_mode());
     }
   }
 }

References v8::internal::SingletonLogger::argument_opt(), cached_parse_data_, CHECK, compile_options(), DCHECK, v8::internal::SingletonLogger::end(), v8::internal::Scanner::Location::end_pos, v8::internal::ParserBase< ParserTraits >::Expect(), v8::internal::ParseData::GetFunctionEntry(), v8::internal::SingletonLogger::has_error(), v8::internal::SingletonLogger::is_reference_error(), v8::ScriptCompiler::kConsumeParserCache, v8::internal::PreParser::kPreParseStackOverflow, v8::ScriptCompiler::kProduceParserCache, v8::internal::SingletonLogger::literals(), v8::internal::Scanner::location(), v8::internal::ParserBase< ParserTraits >::log_, v8::internal::ParserRecorder::LogFunction(), v8::internal::SingletonLogger::message(), ParseLazyFunctionBodyWithPreParser(), v8::internal::ParserBase< ParserTraits >::position(), v8::internal::SingletonLogger::properties(), v8::internal::ParserTraits::ReportMessageAt(), v8::internal::ParserBase< ParserTraits >::scanner(), v8::internal::ParserBase< ParserTraits >::scope_, v8::internal::Scanner::SeekForward(), v8::internal::ParserBase< ParserTraits >::set_stack_overflow(), v8::internal::SingletonLogger::start(), v8::internal::SingletonLogger::strict_mode(), and total_preparse_skipped_.

Referenced by ParseFunctionLiteral(), and v8::internal::ParserTraits::SkipLazyFunctionBody().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TargetStackContainsLabel()

bool v8::internal::Parser::TargetStackContainsLabel ( const AstRawString * label )

private

Definition at line 3939 of file parser.cc.

                                                                {
   for (Target* t = target_stack_; t != NULL; t = t->previous()) {
     BreakableStatement* stat = t->node()->AsBreakableStatement();
     if (stat != NULL && ContainsLabel(stat->labels(), label))
       return true;
   }
   return false;
 }

References v8::internal::BreakableStatement::AsBreakableStatement(), v8::internal::ContainsLabel(), v8::internal::BreakableStatement::labels(), NULL, and target_stack_.

Referenced by ParseExpressionOrLabelledStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ThrowPendingError()

void v8::internal::Parser::ThrowPendingError ( )

private

Definition at line 4006 of file parser.cc.

                                {
   DCHECK(ast_value_factory()->IsInternalized());
   if (has_pending_error_) {
     MessageLocation location(script(), pending_error_location_.beg_pos,
                              pending_error_location_.end_pos);
     Factory* factory = isolate()->factory();
     bool has_arg =
         pending_error_arg_ != NULL || pending_error_char_arg_ != NULL;
     Handle<FixedArray> elements = factory->NewFixedArray(has_arg ? 1 : 0);
     if (pending_error_arg_ != NULL) {
       Handle<String> arg_string = pending_error_arg_->string();
       elements->set(0, *arg_string);
     } else if (pending_error_char_arg_ != NULL) {
       Handle<String> arg_string =
           factory->NewStringFromUtf8(CStrVector(pending_error_char_arg_))
           .ToHandleChecked();
       elements->set(0, *arg_string);
     }
     isolate()->debug()->OnCompileError(script());
  
     Handle<JSArray> array = factory->NewJSArrayWithElements(elements);
     Handle<Object> error;
     MaybeHandle<Object> maybe_error =
         pending_error_is_reference_error_
             ? factory->NewReferenceError(pending_error_message_, array)
             : factory->NewSyntaxError(pending_error_message_, array);
     if (maybe_error.ToHandle(&error)) isolate()->Throw(*error, &location);
   }
 }

References ast_value_factory(), v8::internal::Scanner::Location::beg_pos, v8::internal::CStrVector(), DCHECK, v8::internal::Isolate::debug(), v8::internal::Scanner::Location::end_pos, v8::internal::Isolate::factory(), v8::internal::ParserBase< ParserTraits >::factory(), has_pending_error_, isolate(), NULL, v8::internal::Debug::OnCompileError(), pending_error_arg_, pending_error_char_arg_, pending_error_is_reference_error_, pending_error_location_, pending_error_message_, script(), v8::internal::AstString::string(), and v8::internal::Isolate::Throw().

Referenced by Internalize().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

◆ ParserTraits

friend class ParserTraits

friend

Definition at line 649 of file parser.h.

Member Data Documentation

◆ cached_parse_data_

ParseData* v8::internal::Parser::cached_parse_data_

private

Definition at line 836 of file parser.h.

Referenced by ParseProgram(), SetCachedData(), SkipLazyFunctionBody(), and ~Parser().

◆ has_pending_error_

bool v8::internal::Parser::has_pending_error_

private

Definition at line 841 of file parser.h.

Referenced by v8::internal::ParserTraits::ReportMessageAt(), and ThrowPendingError().

◆ info_

CompilationInfo* v8::internal::Parser::info_

private

Definition at line 838 of file parser.h.

Referenced by ast_value_factory(), compile_options(), HandleSourceURLComments(), info(), isolate(), ParseOnBackground(), ParseProgram(), script(), and SetCachedData().

◆ kMaxNumFunctionLocals

const int v8::internal::Parser::kMaxNumFunctionLocals = 4194303

staticprivate

Definition at line 658 of file parser.h.

Referenced by ParseVariableDeclarations().

◆ original_scope_

Scope* v8::internal::Parser::original_scope_

private

Definition at line 834 of file parser.h.

Referenced by DoParseProgram(), ParseFunctionLiteral(), and ParseLazy().

◆ pending_error_arg_

const AstRawString* v8::internal::Parser::pending_error_arg_

private

Definition at line 844 of file parser.h.

Referenced by v8::internal::ParserTraits::ReportMessageAt(), and ThrowPendingError().

◆ pending_error_char_arg_

const char* v8::internal::Parser::pending_error_char_arg_

private

Definition at line 845 of file parser.h.

Referenced by v8::internal::ParserTraits::ReportMessageAt(), and ThrowPendingError().

◆ pending_error_is_reference_error_

bool v8::internal::Parser::pending_error_is_reference_error_

private

Definition at line 846 of file parser.h.

Referenced by v8::internal::ParserTraits::ReportMessageAt(), and ThrowPendingError().

◆ pending_error_location_

Scanner::Location v8::internal::Parser::pending_error_location_

private

Definition at line 842 of file parser.h.

Referenced by v8::internal::ParserTraits::ReportMessageAt(), and ThrowPendingError().

◆ pending_error_message_

const char* v8::internal::Parser::pending_error_message_

private

Definition at line 843 of file parser.h.

Referenced by v8::internal::ParserTraits::ReportMessageAt(), and ThrowPendingError().

◆ pre_parse_timer_

HistogramTimer* v8::internal::Parser::pre_parse_timer_

private

Definition at line 852 of file parser.h.

Referenced by Parse(), and ParseLazyFunctionBodyWithPreParser().

◆ reusable_preparser_

PreParser* v8::internal::Parser::reusable_preparser_

private

Definition at line 833 of file parser.h.

Referenced by ParseLazyFunctionBodyWithPreParser(), and ~Parser().

◆ scanner_

Scanner v8::internal::Parser::scanner_

private

Definition at line 832 of file parser.h.

Referenced by HandleSourceURLComments(), ParseLazy(), ParseLazyFunctionBodyWithPreParser(), ParseOnBackground(), and ParseProgram().

◆ target_stack_

Target* v8::internal::Parser::target_stack_

private

Definition at line 835 of file parser.h.

Referenced by DoParseProgram(), LookupBreakTarget(), LookupContinueTarget(), ParseBlock(), ParseDoWhileStatement(), ParseForStatement(), ParseLazy(), ParseModuleLiteral(), ParseScopedBlock(), ParseSourceElements(), ParseStatement(), ParseSwitchStatement(), ParseTryStatement(), ParseWhileStatement(), RegisterTargetUse(), and TargetStackContainsLabel().

◆ total_preparse_skipped_

int v8::internal::Parser::total_preparse_skipped_

private

Definition at line 851 of file parser.h.

Referenced by Internalize(), and SkipLazyFunctionBody().

◆ use_counts_

int v8::internal::Parser::use_counts_[v8::Isolate::kUseCounterFeatureCount]

private

Definition at line 850 of file parser.h.

Referenced by Internalize(), Parser(), and ParseSourceElements().

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

/mnt/V8SourceCode/src/parser.h
/mnt/V8SourceCode/src/parser.cc

Classes

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ VariableDeclarationContext

◆ VariableDeclarationProperties

Constructor & Destructor Documentation

◆ Parser()

◆ ~Parser()

Member Function Documentation

◆ ast_value_factory()

◆ CheckConflictingVarDeclarations()

◆ CheckInOrOf()

◆ compile_options()

◆ DeclarationScope()

◆ Declare()

◆ DesugarLetBindingsInForStatement()

◆ DoParseProgram()

◆ GetLiteralUndefined()

◆ HandleSourceURLComments()

◆ info()

◆ InitializeForEachStatement()

◆ inside_with()

◆ Internalize()

◆ isolate()

◆ LookupBreakTarget()

◆ LookupContinueTarget()

◆ MakeCatchContext()

◆ NewScope()

◆ NewUnresolved()

◆ Parse() [1/2]

◆ Parse() [2/2]

◆ ParseBlock()

◆ ParseBlockElement()

◆ ParseBreakStatement()

◆ ParseCaseClause()

◆ ParseClassDeclaration()

◆ ParseContinueStatement()

◆ ParseDebuggerStatement()

◆ ParseDoWhileStatement()

◆ ParseEagerFunctionBody()

◆ ParseExportDeclaration()

◆ ParseExpressionOrLabelledStatement()

◆ ParseForStatement()

◆ ParseFunctionDeclaration()

◆ ParseFunctionLiteral()

◆ ParseIfStatement()

◆ ParseImportDeclaration()

◆ ParseLazy() [1/2]

◆ ParseLazy() [2/2]

◆ ParseLazyFunctionBodyWithPreParser()

◆ ParseModule()

◆ ParseModuleDeclaration()

◆ ParseModuleElement()

◆ ParseModuleLiteral()

◆ ParseModulePath()

◆ ParseModuleSpecifier()

◆ ParseModuleUrl()

◆ ParseModuleVariable()

◆ ParseNativeDeclaration()

◆ ParseOnBackground()

◆ ParseProgram()

◆ ParseReturnStatement()

◆ ParseScopedBlock()

◆ ParseSourceElements()

◆ ParseStatement()

◆ ParseSwitchStatement()

◆ ParseThrowStatement()

◆ ParseTryStatement()

◆ ParseV8Intrinsic()

◆ ParseVariableDeclarations()

◆ ParseVariableStatement()

◆ ParseWhileStatement()