v8::internal::ParserTraits Class Reference

#include <parser.h>

Inheritance diagram for v8::internal::ParserTraits:

Collaboration diagram for v8::internal::ParserTraits:

Classes
class	Checkpoint
struct	Type

Public Member Functions
	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
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 Attributes
Parser *	parser_

Detailed Description

Definition at line 345 of file parser.h.

Constructor & Destructor Documentation

ParserTraits()

v8::internal::ParserTraits::ParserTraits ( Parser *  parser )

inlineexplicit

Definition at line 379 of file parser.h.

: parser_(parser) {}

Member Function Documentation

AsIdentifier()

static const AstRawString* v8::internal::ParserTraits::AsIdentifier ( Expression *  expression )

inlinestatic

Definition at line 409 of file parser.h.

                                                                  {
    DCHECK(IsIdentifier(expression));
    return expression->AsVariableProxy()->raw_name();
  }

References DCHECK, and IsIdentifier().

Here is the call graph for this function:

ast_value_factory()

AstValueFactory * v8::internal::ParserTraits::ast_value_factory ( )

inline

Definition at line 895 of file parser.h.

                                                 {
  return parser_->ast_value_factory();
}

References v8::internal::Parser::ast_value_factory(), and parser_.

Referenced by GetNumberAsSymbol().

Here is the call graph for this function:

Here is the caller graph for this function:

BuildUnaryExpression()

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

Definition at line 494 of file parser.cc.

                                                     {
  DCHECK(expression != NULL);
  if (expression->IsLiteral()) {
    const AstValue* literal = expression->AsLiteral()->raw_value();
    if (op == Token::NOT) {
      // Convert the literal to a boolean condition and negate it.
      bool condition = literal->BooleanValue();
      return factory->NewBooleanLiteral(!condition, pos);
    } else if (literal->IsNumber()) {
      // Compute some expressions involving only number literals.
      double value = literal->AsNumber();
      switch (op) {
        case Token::ADD:
          return expression;
        case Token::SUB:
          return factory->NewNumberLiteral(-value, pos);
        case Token::BIT_NOT:
          return factory->NewNumberLiteral(~DoubleToInt32(value), pos);
        default:
          break;
      }
    }
  }
  // Desugar '+foo' => 'foo*1'
  if (op == Token::ADD) {
    return factory->NewBinaryOperation(
        Token::MUL, expression, factory->NewNumberLiteral(1, pos), pos);
  }
  // The same idea for '-foo' => 'foo*(-1)'.
  if (op == Token::SUB) {
    return factory->NewBinaryOperation(
        Token::MUL, expression, factory->NewNumberLiteral(-1, pos), pos);
  }
  // ...and one more time for '~foo' => 'foo^(~0)'.
  if (op == Token::BIT_NOT) {
    return factory->NewBinaryOperation(
        Token::BIT_XOR, expression, factory->NewNumberLiteral(~0, pos), pos);
  }
  return factory->NewUnaryOperation(op, expression, pos);
}

References v8::internal::ADD, v8::internal::AstValue::AsNumber(), v8::internal::AstValue::BooleanValue(), DCHECK, v8::internal::DoubleToInt32(), v8::internal::AstValue::IsNumber(), v8::internal::MUL, v8::internal::NOT, NULL, and v8::internal::SUB.

Here is the call graph for this function:

CheckAssigningFunctionLiteralToProperty()

void v8::internal::ParserTraits::CheckAssigningFunctionLiteralToProperty ( Expression *  left, Expression *  right  )

static

Definition at line 406 of file parser.cc.

                                                                              {
  DCHECK(left != NULL);
  if (left->AsProperty() != NULL &&
      right->AsFunctionLiteral() != NULL) {
    right->AsFunctionLiteral()->set_pretenure();
  }
}

References DCHECK, and NULL.

CheckConflictingVarDeclarations()

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

inline

Definition at line 889 of file parser.h.

                                                             {
  parser_->CheckConflictingVarDeclarations(scope, ok);
}

References v8::internal::Parser::CheckConflictingVarDeclarations(), and parser_.

Here is the call graph for this function:

CheckFunctionLiteralInsideTopLevelObjectLiteral()

static void v8::internal::ParserTraits::CheckFunctionLiteralInsideTopLevelObjectLiteral ( Scope *  scope, ObjectLiteralProperty *  property, bool *  has_function  )

inlinestatic

Definition at line 433 of file parser.h.

                                                                         {
    Expression* value = property->value();
    if (scope->DeclarationScope()->is_global_scope() &&
        value->AsFunctionLiteral() != NULL) {
      *has_function = true;
      value->AsFunctionLiteral()->set_pretenure();
    }
  }

References v8::internal::Scope::DeclarationScope(), v8::internal::Scope::is_global_scope(), and NULL.

Here is the call graph for this function:

CheckPossibleEvalCall()

void v8::internal::ParserTraits::CheckPossibleEvalCall	(	Expression *	expression,
		Scope *	scope
	)

Definition at line 416 of file parser.cc.

                                                       {
  VariableProxy* callee = expression->AsVariableProxy();
  if (callee != NULL &&
      callee->raw_name() == parser_->ast_value_factory()->eval_string()) {
    scope->DeclarationScope()->RecordEvalCall();
  }
}

References v8::internal::Parser::ast_value_factory(), v8::internal::Scope::DeclarationScope(), NULL, parser_, and v8::internal::Scope::RecordEvalCall().

Here is the call graph for this function:

ClassLiteral()

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

Definition at line 668 of file parser.cc.

                                                     {
  return factory->NewClassLiteral(name, extends, constructor, properties, pos);
}

References name.

DeclareArrowParametersFromExpression()

int v8::internal::ParserTraits::DeclareArrowParametersFromExpression	(	Expression *	expression,
		Scope *	scope,
		Scanner::Location *	dupe_loc,
		bool *	ok
	)

Definition at line 3426 of file parser.cc.

              {
  int num_params = 0;
  *ok = CheckAndDeclareArrowParameter(this, expression, scope, &num_params,
                                      dupe_loc);
  return num_params;
}

References v8::internal::CheckAndDeclareArrowParameter().

Here is the call graph for this function:

EmptyArrowParamList()

static Expression* v8::internal::ParserTraits::EmptyArrowParamList ( )

inlinestatic

Definition at line 521 of file parser.h.

{ return NULL; }

References NULL.

EmptyExpression()

static Expression* v8::internal::ParserTraits::EmptyExpression ( )

inlinestatic

Definition at line 518 of file parser.h.

                                       {
    return NULL;
  }

References NULL.

EmptyFunctionLiteral()

static FunctionLiteral* v8::internal::ParserTraits::EmptyFunctionLiteral ( )

inlinestatic

Definition at line 526 of file parser.h.

{ return NULL; }

References NULL.

EmptyIdentifier()

static const AstRawString* v8::internal::ParserTraits::EmptyIdentifier ( )

inlinestatic

Definition at line 515 of file parser.h.

                                               {
    return NULL;
  }

References NULL.

EmptyIdentifierString()

const AstRawString * v8::internal::ParserTraits::EmptyIdentifierString ( )

inline

Definition at line 868 of file parser.h.

                                                        {
  return parser_->ast_value_factory()->empty_string();
}

References v8::internal::Parser::ast_value_factory(), and parser_.

Here is the call graph for this function:

EmptyLiteral()

static Literal* v8::internal::ParserTraits::EmptyLiteral ( )

inlinestatic

Definition at line 522 of file parser.h.

                                 {
    return NULL;
  }

References NULL.

EmptyObjectLiteralProperty()

static ObjectLiteralProperty* v8::internal::ParserTraits::EmptyObjectLiteralProperty ( )

inlinestatic

Definition at line 525 of file parser.h.

{ return NULL; }

References NULL.

ExpressionFromIdentifier()

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

Definition at line 697 of file parser.cc.

                                                     {
  if (parser_->fni_ != NULL) parser_->fni_->PushVariableName(name);
  // The name may refer to a module instance object, so its type is unknown.
#ifdef DEBUG
  if (FLAG_print_interface_details)
    PrintF("# Variable %.*s ", name->length(), name->raw_data());
#endif
  Interface* interface = Interface::NewUnknown(parser_->zone());
  return scope->NewUnresolved(factory, name, interface, pos);
}

References v8::internal::ParserBase< Traits >::fni_, name, v8::internal::Interface::NewUnknown(), v8::internal::Scope::NewUnresolved(), NULL, parser_, v8::internal::PrintF(), and v8::internal::FuncNameInferrer::PushVariableName().

Here is the call graph for this function:

ExpressionFromLiteral()

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

Definition at line 675 of file parser.cc.

                                                     {
  switch (token) {
    case Token::NULL_LITERAL:
      return factory->NewNullLiteral(pos);
    case Token::TRUE_LITERAL:
      return factory->NewBooleanLiteral(true, pos);
    case Token::FALSE_LITERAL:
      return factory->NewBooleanLiteral(false, pos);
    case Token::NUMBER: {
      double value = scanner->DoubleValue();
      return factory->NewNumberLiteral(value, pos);
    }
    default:
      DCHECK(false);
  }
  return NULL;
}

References DCHECK, v8::internal::Scanner::DoubleValue(), and NULL.

Here is the call graph for this function:

ExpressionFromString()

Expression * v8::internal::ParserTraits::ExpressionFromString	(	int	pos,
		Scanner *	scanner,
		AstNodeFactory< AstConstructionVisitor > *	factory
	)

Definition at line 711 of file parser.cc.

                                                     {
  const AstRawString* symbol = GetSymbol(scanner);
  if (parser_->fni_ != NULL) parser_->fni_->PushLiteralName(symbol);
  return factory->NewStringLiteral(symbol, pos);
}

References v8::internal::ParserBase< Traits >::fni_, GetSymbol(), NULL, parser_, and v8::internal::FuncNameInferrer::PushLiteralName().

Here is the call graph for this function:

GetIterator()

Expression * v8::internal::ParserTraits::GetIterator	(	Expression *	iterable,
		AstNodeFactory< AstConstructionVisitor > *	factory
	)

Definition at line 720 of file parser.cc.

                                                                           {
  Expression* iterator_symbol_literal =
      factory->NewSymbolLiteral("symbolIterator", RelocInfo::kNoPosition);
  int pos = iterable->position();
  Expression* prop =
      factory->NewProperty(iterable, iterator_symbol_literal, pos);
  Zone* zone = parser_->zone();
  ZoneList<Expression*>* args = new (zone) ZoneList<Expression*>(0, zone);
  return factory->NewCall(prop, args, pos);
}

References v8::internal::RelocInfo::kNoPosition, parser_, v8::internal::AstNode::position(), and v8::internal::ParserBase< Traits >::zone().

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

Here is the call graph for this function:

Here is the caller graph for this function:

GetLiteralTheHole()

Literal * v8::internal::ParserTraits::GetLiteralTheHole	(	int	position,
		AstNodeFactory< AstConstructionVisitor > *	factory
	)

Definition at line 733 of file parser.cc.

                                                                   {
  return factory->NewTheHoleLiteral(RelocInfo::kNoPosition);
}

References v8::internal::RelocInfo::kNoPosition.

GetNextSymbol()

const AstRawString * v8::internal::ParserTraits::GetNextSymbol

(

Scanner *

scanner

)

Definition at line 651 of file parser.cc.

                                                                {
  return parser_->scanner()->NextSymbol(parser_->ast_value_factory());
}

References v8::internal::Parser::ast_value_factory(), v8::internal::Scanner::NextSymbol(), parser_, and v8::internal::ParserBase< Traits >::scanner().

Here is the call graph for this function:

GetNumberAsSymbol()

const AstRawString * v8::internal::ParserTraits::GetNumberAsSymbol

(

Scanner *

scanner

)

Definition at line 642 of file parser.cc.

                                                                    {
  double double_value = parser_->scanner()->DoubleValue();
  char array[100];
  const char* string =
      DoubleToCString(double_value, Vector<char>(array, arraysize(array)));
  return ast_value_factory()->GetOneByteString(string);
}

References arraysize, ast_value_factory(), v8::internal::DoubleToCString(), v8::internal::Scanner::DoubleValue(), v8::internal::AstValueFactory::GetOneByteString(), parser_, and v8::internal::ParserBase< Traits >::scanner().

Here is the call graph for this function:

GetSymbol()

const AstRawString * v8::internal::ParserTraits::GetSymbol

(

Scanner *

scanner

)

Definition at line 634 of file parser.cc.

                                                            {
  const AstRawString* result =
      parser_->scanner()->CurrentSymbol(parser_->ast_value_factory());
  DCHECK(result != NULL);
  return result;
}

References v8::internal::Parser::ast_value_factory(), v8::internal::Scanner::CurrentSymbol(), DCHECK, NULL, parser_, and v8::internal::ParserBase< Traits >::scanner().

Referenced by ExpressionFromString(), and v8::internal::Parser::ParseModuleUrl().

Here is the call graph for this function:

Here is the caller graph for this function:

InferFunctionName()

static void v8::internal::ParserTraits::InferFunctionName ( FuncNameInferrer *  fni, FunctionLiteral *  func_to_infer  )

inlinestatic

Definition at line 428 of file parser.h.

                                                                {
    fni->AddFunction(func_to_infer);
  }

References v8::internal::FuncNameInferrer::AddFunction().

Here is the call graph for this function:

IsArrayIndex()

static bool v8::internal::ParserTraits::IsArrayIndex ( const AstRawString *  string, uint32_t *  index  )

inlinestatic

Definition at line 418 of file parser.h.

                                                                        {
    return string->AsArrayIndex(index);
  }

IsBoilerplateProperty()

static bool v8::internal::ParserTraits::IsBoilerplateProperty ( ObjectLiteral::Property *  property )

inlinestatic

Definition at line 414 of file parser.h.

                                                                     {
    return ObjectLiteral::IsBoilerplateProperty(property);
  }

IsConstructor()

bool v8::internal::ParserTraits::IsConstructor

(

const AstRawString *

identifier

)

const

Definition at line 375 of file parser.cc.

                                                                     {
  return identifier == parser_->ast_value_factory()->constructor_string();
}

References v8::internal::Parser::ast_value_factory(), and parser_.

Here is the call graph for this function:

IsEvalOrArguments()

bool v8::internal::ParserTraits::IsEvalOrArguments

(

const AstRawString *

identifier

)

const

Definition at line 364 of file parser.cc.

                                                                         {
  return identifier == parser_->ast_value_factory()->eval_string() ||
         identifier == parser_->ast_value_factory()->arguments_string();
}

References v8::internal::Parser::ast_value_factory(), and parser_.

Referenced by v8::internal::CheckAndDeclareArrowParameter(), and v8::internal::Parser::ParseFunctionLiteral().

Here is the call graph for this function:

Here is the caller graph for this function:

IsFutureStrictReserved()

bool v8::internal::ParserTraits::IsFutureStrictReserved ( const AstRawString *  identifier ) const

inline

Definition at line 856 of file parser.h.

                                          {
  return identifier->IsOneByteEqualTo("yield") ||
         parser_->scanner()->IdentifierIsFutureStrictReserved(identifier);
}

References v8::internal::Scanner::IdentifierIsFutureStrictReserved(), v8::internal::AstRawString::IsOneByteEqualTo(), parser_, and v8::internal::ParserBase< Traits >::scanner().

Referenced by v8::internal::CheckAndDeclareArrowParameter().

Here is the call graph for this function:

Here is the caller graph for this function:

IsIdentifier()

bool v8::internal::ParserTraits::IsIdentifier ( Expression *  expression )

static

Definition at line 389 of file parser.cc.

                                                      {
  VariableProxy* operand = expression->AsVariableProxy();
  return operand != NULL && !operand->is_this();
}

References NULL.

Referenced by AsIdentifier().

Here is the caller graph for this function:

IsPrototype()

bool v8::internal::ParserTraits::IsPrototype

(

const AstRawString *

identifier

)

const

Definition at line 370 of file parser.cc.

                                                                   {
  return identifier == parser_->ast_value_factory()->prototype_string();
}

References v8::internal::Parser::ast_value_factory(), and parser_.

Here is the call graph for this function:

IsThisProperty()

bool v8::internal::ParserTraits::IsThisProperty ( Expression *  expression )

static

Definition at line 380 of file parser.cc.

                                                        {
  DCHECK(expression != NULL);
  Property* property = expression->AsProperty();
  return property != NULL &&
      property->obj()->AsVariableProxy() != NULL &&
      property->obj()->AsVariableProxy()->is_this();
}

References DCHECK, and NULL.

MarkExpressionAsAssigned()

Expression * v8::internal::ParserTraits::MarkExpressionAsAssigned ( Expression *  expression )

static

Definition at line 426 of file parser.cc.

                                                                         {
  VariableProxy* proxy =
      expression != NULL ? expression->AsVariableProxy() : NULL;
  if (proxy != NULL) proxy->set_is_assigned();
  return expression;
}

References NULL.

NewExpressionList()

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

inline

Definition at line 568 of file parser.h.

                                                                           {
    return new(zone) ZoneList<v8::internal::Expression*>(size, zone);
  }

References size.

NewPropertyList()

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

inline

Definition at line 571 of file parser.h.

                                                                          {
    return new(zone) ZoneList<ObjectLiteral::Property*>(size, zone);
  }

References size.

NewScope()

Scope * v8::internal::ParserTraits::NewScope ( Scope *  parent_scope, ScopeType  scope_type  )

inline

Definition at line 863 of file parser.h.

                                                                       {
  return parser_->NewScope(parent_scope, scope_type);
}

References v8::internal::Parser::NewScope(), and parser_.

Here is the call graph for this function:

NewStatementList()

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

inline

Definition at line 574 of file parser.h.

                                                                         {
    return new(zone) ZoneList<v8::internal::Statement*>(size, zone);
  }

References size.

NewThrowError()

Expression * v8::internal::ParserTraits::NewThrowError	(	const AstRawString *	constructor,
		const char *	type,
		const AstRawString *	arg,
		int	pos
	)

Definition at line 559 of file parser.cc.

                                      {
  Zone* zone = parser_->zone();
  int argc = arg != NULL ? 1 : 0;
  const AstRawString* type =
      parser_->ast_value_factory()->GetOneByteString(message);
  ZoneList<const AstRawString*>* array =
      new (zone) ZoneList<const AstRawString*>(argc, zone);
  if (arg != NULL) {
    array->Add(arg, zone);
  }
  ZoneList<Expression*>* args = new (zone) ZoneList<Expression*>(2, zone);
  args->Add(parser_->factory()->NewStringLiteral(type, pos), zone);
  args->Add(parser_->factory()->NewStringListLiteral(array, pos), zone);
  CallRuntime* call_constructor =
      parser_->factory()->NewCallRuntime(constructor, NULL, args, pos);
  return parser_->factory()->NewThrow(call_constructor, pos);
}

References v8::internal::List< T, AllocationPolicy >::Add(), v8::internal::Parser::ast_value_factory(), v8::internal::ParserBase< Traits >::factory(), v8::internal::AstValueFactory::GetOneByteString(), NULL, parser_, and v8::internal::ParserBase< Traits >::zone().

Referenced by NewThrowReferenceError(), NewThrowSyntaxError(), and NewThrowTypeError().

Here is the call graph for this function:

Here is the caller graph for this function:

NewThrowReferenceError()

Expression * v8::internal::ParserTraits::NewThrowReferenceError	(	const char *	type,
		int	pos
	)

Definition at line 538 of file parser.cc.

                                                                             {
  return NewThrowError(
      parser_->ast_value_factory()->make_reference_error_string(), message,
      NULL, pos);
}

References v8::internal::Parser::ast_value_factory(), NewThrowError(), NULL, and parser_.

Here is the call graph for this function:

NewThrowSyntaxError()

Expression * v8::internal::ParserTraits::NewThrowSyntaxError	(	const char *	type,
		const AstRawString *	arg,
		int	pos
	)

Definition at line 545 of file parser.cc.

                                                           {
  return NewThrowError(parser_->ast_value_factory()->make_syntax_error_string(),
                       message, arg, pos);
}

References v8::internal::Parser::ast_value_factory(), NewThrowError(), and parser_.

Here is the call graph for this function:

NewThrowTypeError()

Expression * v8::internal::ParserTraits::NewThrowTypeError	(	const char *	type,
		const AstRawString *	arg,
		int	pos
	)

Definition at line 552 of file parser.cc.

                                                           {
  return NewThrowError(parser_->ast_value_factory()->make_type_error_string(),
                       message, arg, pos);
}

References v8::internal::Parser::ast_value_factory(), NewThrowError(), and parser_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

NullExpressionList()

static ZoneList<Expression*>* v8::internal::ParserTraits::NullExpressionList ( )

inlinestatic

Definition at line 529 of file parser.h.

                                                     {
    return NULL;
  }

References NULL.

ParseEagerFunctionBody()

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

inline

Definition at line 882 of file parser.h.

                                                          {
  return parser_->ParseEagerFunctionBody(name, pos, fvar, fvar_init_op,
                                         is_generator, ok);
}

References name, v8::internal::Parser::ParseEagerFunctionBody(), and parser_.

Here is the call graph for this function:

ParseFunctionLiteral()

FunctionLiteral * v8::internal::ParserTraits::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
	)

Definition at line 744 of file parser.cc.

                                                                 {
  return parser_->ParseFunctionLiteral(
      name, function_name_location, name_is_strict_reserved, kind,
      function_token_position, type, arity_restriction, ok);
}

References v8::internal::function_token_position, name, v8::internal::Parser::ParseFunctionLiteral(), and parser_.

Here is the call graph for this function:

ParseV8Intrinsic()

Expression * v8::internal::ParserTraits::ParseV8Intrinsic

(

bool *

ok

)

Definition at line 739 of file parser.cc.

                                                   {
  return parser_->ParseV8Intrinsic(ok);
}

References parser_, and v8::internal::Parser::ParseV8Intrinsic().

Here is the call graph for this function:

PushLiteralName()

static void v8::internal::ParserTraits::PushLiteralName ( FuncNameInferrer *  fni, const AstRawString *  id  )

inlinestatic

Definition at line 424 of file parser.h.

                                                                             {
    fni->PushLiteralName(id);
  }

References v8::internal::FuncNameInferrer::PushLiteralName().

Here is the call graph for this function:

PushPropertyName()

void v8::internal::ParserTraits::PushPropertyName	(	FuncNameInferrer *	fni,
		Expression *	expression
	)

Definition at line 395 of file parser.cc.

                                                            {
  if (expression->IsPropertyName()) {
    fni->PushLiteralName(expression->AsLiteral()->AsRawPropertyName());
  } else {
    fni->PushLiteralName(
        parser_->ast_value_factory()->anonymous_function_string());
  }
}

References v8::internal::Parser::ast_value_factory(), v8::internal::Expression::IsPropertyName(), parser_, and v8::internal::FuncNameInferrer::PushLiteralName().

Here is the call graph for this function:

ReportMessage() [1/2]

void v8::internal::ParserTraits::ReportMessage	(	const char *	message,
		const AstRawString *	arg,
		bool	is_reference_error = false
	)

Definition at line 607 of file parser.cc.

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

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

Here is the call graph for this function:

ReportMessage() [2/2]

void v8::internal::ParserTraits::ReportMessage	(	const char *	message,
		const char *	arg = NULL,
		bool	is_reference_error = false
	)

Definition at line 599 of file parser.cc.

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

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

Referenced by v8::internal::Parser::Declare(), v8::internal::Parser::ParseBreakStatement(), v8::internal::Parser::ParseContinueStatement(), v8::internal::Parser::ParseExpressionOrLabelledStatement(), v8::internal::Parser::ParseImportDeclaration(), v8::internal::Parser::ParseModuleLiteral(), v8::internal::Parser::ParseModulePath(), and v8::internal::Parser::ParseV8Intrinsic().

Here is the call graph for this function:

Here is the caller graph for this function:

ReportMessageAt() [1/2]

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

Definition at line 615 of file parser.cc.

                                                            {
  if (parser_->stack_overflow()) {
    // Suppress the error message (syntax error or such) in the presence of a
    // stack overflow. The isolate allows only one pending exception at at time
    // and we want to report the stack overflow later.
    return;
  }
  parser_->has_pending_error_ = true;
  parser_->pending_error_location_ = source_location;
  parser_->pending_error_message_ = message;
  parser_->pending_error_char_arg_ = NULL;
  parser_->pending_error_arg_ = arg;
  parser_->pending_error_is_reference_error_ = is_reference_error;
}

References v8::internal::Parser::has_pending_error_, NULL, parser_, v8::internal::Parser::pending_error_arg_, v8::internal::Parser::pending_error_char_arg_, v8::internal::Parser::pending_error_is_reference_error_, v8::internal::Parser::pending_error_location_, v8::internal::Parser::pending_error_message_, and v8::internal::ParserBase< Traits >::stack_overflow().

Here is the call graph for this function:

ReportMessageAt() [2/2]

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

Definition at line 580 of file parser.cc.

                                                            {
  if (parser_->stack_overflow()) {
    // Suppress the error message (syntax error or such) in the presence of a
    // stack overflow. The isolate allows only one pending exception at at time
    // and we want to report the stack overflow later.
    return;
  }
  parser_->has_pending_error_ = true;
  parser_->pending_error_location_ = source_location;
  parser_->pending_error_message_ = message;
  parser_->pending_error_char_arg_ = arg;
  parser_->pending_error_arg_ = NULL;
  parser_->pending_error_is_reference_error_ = is_reference_error;
}

References v8::internal::Parser::has_pending_error_, NULL, parser_, v8::internal::Parser::pending_error_arg_, v8::internal::Parser::pending_error_char_arg_, v8::internal::Parser::pending_error_is_reference_error_, v8::internal::Parser::pending_error_location_, v8::internal::Parser::pending_error_message_, and v8::internal::ParserBase< Traits >::stack_overflow().

Referenced by v8::internal::Parser::CheckConflictingVarDeclarations(), ReportMessage(), and v8::internal::Parser::SkipLazyFunctionBody().

Here is the call graph for this function:

Here is the caller graph for this function:

SetUpFunctionState()

template<typename FunctionState >

static void v8::internal::ParserTraits::SetUpFunctionState ( FunctionState *  function_state )

inlinestatic

Definition at line 383 of file parser.h.

                                                                {
    function_state->saved_id_gen_ = *function_state->ast_node_id_gen_;
    *function_state->ast_node_id_gen_ =
        AstNode::IdGen(BailoutId::FirstUsable().ToInt());
  }

References v8::internal::BailoutId::FirstUsable().

Here is the call graph for this function:

ShortcutNumericLiteralBinaryExpression()

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

Definition at line 434 of file parser.cc.

                                                     {
  if ((*x)->AsLiteral() && (*x)->AsLiteral()->raw_value()->IsNumber() &&
      y->AsLiteral() && y->AsLiteral()->raw_value()->IsNumber()) {
    double x_val = (*x)->AsLiteral()->raw_value()->AsNumber();
    double y_val = y->AsLiteral()->raw_value()->AsNumber();
    switch (op) {
      case Token::ADD:
        *x = factory->NewNumberLiteral(x_val + y_val, pos);
        return true;
      case Token::SUB:
        *x = factory->NewNumberLiteral(x_val - y_val, pos);
        return true;
      case Token::MUL:
        *x = factory->NewNumberLiteral(x_val * y_val, pos);
        return true;
      case Token::DIV:
        *x = factory->NewNumberLiteral(x_val / y_val, pos);
        return true;
      case Token::BIT_OR: {
        int value = DoubleToInt32(x_val) | DoubleToInt32(y_val);
        *x = factory->NewNumberLiteral(value, pos);
        return true;
      }
      case Token::BIT_AND: {
        int value = DoubleToInt32(x_val) & DoubleToInt32(y_val);
        *x = factory->NewNumberLiteral(value, pos);
        return true;
      }
      case Token::BIT_XOR: {
        int value = DoubleToInt32(x_val) ^ DoubleToInt32(y_val);
        *x = factory->NewNumberLiteral(value, pos);
        return true;
      }
      case Token::SHL: {
        int value = DoubleToInt32(x_val) << (DoubleToInt32(y_val) & 0x1f);
        *x = factory->NewNumberLiteral(value, pos);
        return true;
      }
      case Token::SHR: {
        uint32_t shift = DoubleToInt32(y_val) & 0x1f;
        uint32_t value = DoubleToUint32(x_val) >> shift;
        *x = factory->NewNumberLiteral(value, pos);
        return true;
      }
      case Token::SAR: {
        uint32_t shift = DoubleToInt32(y_val) & 0x1f;
        int value = ArithmeticShiftRight(DoubleToInt32(x_val), shift);
        *x = factory->NewNumberLiteral(value, pos);
        return true;
      }
      default:
        break;
    }
  }
  return false;
}

References v8::internal::ADD, v8::internal::ArithmeticShiftRight(), v8::internal::DIV, v8::internal::DoubleToInt32(), v8::internal::DoubleToUint32(), v8::internal::MUL, shift, v8::internal::SUB, and v8::base::internal::y.

Here is the call graph for this function:

SkipLazyFunctionBody()

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

inline

Definition at line 873 of file parser.h.

                                                  {
  return parser_->SkipLazyFunctionBody(
      function_name, materialized_literal_count, expected_property_count, ok);
}

References parser_, and v8::internal::Parser::SkipLazyFunctionBody().

Here is the call graph for this function:

SuperReference()

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

Definition at line 661 of file parser.cc.

                                                                            {
  return factory->NewSuperReference(
      ThisExpression(scope, factory, pos)->AsVariableProxy(),
      pos);
}

References ThisExpression().

Here is the call graph for this function:

TearDownFunctionState()

template<typename FunctionState >

static void v8::internal::ParserTraits::TearDownFunctionState ( FunctionState *  function_state )

inlinestatic

Definition at line 390 of file parser.h.

                                                                   {
    if (function_state->outer_function_state_ != NULL) {
      *function_state->ast_node_id_gen_ = function_state->saved_id_gen_;
    }
  }

References NULL.

ThisExpression()

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

Definition at line 656 of file parser.cc.

                                                                            {
  return factory->NewVariableProxy(scope->receiver(), pos);
}

References v8::internal::Scope::receiver().

Referenced by SuperReference().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

parser_

Parser* v8::internal::ParserTraits::parser_

private

Definition at line 602 of file parser.h.

Referenced by ast_value_factory(), CheckConflictingVarDeclarations(), CheckPossibleEvalCall(), EmptyIdentifierString(), ExpressionFromIdentifier(), ExpressionFromString(), GetIterator(), GetNextSymbol(), GetNumberAsSymbol(), GetSymbol(), IsConstructor(), IsEvalOrArguments(), IsFutureStrictReserved(), IsPrototype(), NewScope(), NewThrowError(), NewThrowReferenceError(), NewThrowSyntaxError(), NewThrowTypeError(), ParseEagerFunctionBody(), ParseFunctionLiteral(), ParseV8Intrinsic(), PushPropertyName(), ReportMessage(), ReportMessageAt(), and SkipLazyFunctionBody().

---

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

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