public:

BufferedZoneList() : list_(nullptr), last_(nullptr) {}

// Adds element at end of list. This element is buffered and can

// be read using last() or removed using RemoveLast until a new Add or until

// RemoveLast or GetList has been called.

void Add(T* value, Zone* zone) {

if (last_ != nullptr) {

if (list_ == nullptr) {

list_ = zone->New<ZoneList<T*>>(initial_size, zone);

}

list_->Add(last_, zone);

}

last_ = value;

}

T* last() {

DCHECK(last_ != nullptr);

return last_;

}

T* RemoveLast() {

DCHECK(last_ != nullptr);

T* result = last_;

if ((list_ != nullptr) && (list_->length() > 0))

last_ = list_->RemoveLast();

else

last_ = nullptr;

return result;

}

T* Get(int i) {

DCHECK((0 <= i) && (i < length()));

if (list_ == nullptr) {

DCHECK_EQ(0, i);

return last_;

} else {

if (i == list_->length()) {

DCHECK(last_ != nullptr);

return last_;

} else {

return list_->at(i);

}

}

}

void Clear() {

list_ = nullptr;

last_ = nullptr;

}

int length() {

int length = (list_ == nullptr) ? 0 : list_->length();

return length + ((last_ == nullptr) ? 0 : 1);

}

ZoneList<T*>* GetList(Zone* zone) {

if (list_ == nullptr) {

list_ = zone->New<ZoneList<T*>>(initial_size, zone);

}

if (last_ != nullptr) {

list_->Add(last_, zone);

last_ = nullptr;

}

return list_;

}

private:

ZoneList<T*>* list_;

T* last_;

public:

RegExpBuilder(Zone* zone, RegExpFlags flags);

void AddCharacter(base::uc16 character);

void AddUnicodeCharacter(base::uc32 character);

void AddEscapedUnicodeCharacter(base::uc32 character);

// "Adds" an empty expression. Does nothing except consume a

// following quantifier

void AddEmpty();

void AddCharacterClass(RegExpCharacterClass* cc);

void AddCharacterClassForDesugaring(base::uc32 c);

void AddAtom(RegExpTree* tree);

void AddTerm(RegExpTree* tree);

void AddAssertion(RegExpTree* tree);

void NewAlternative(); // '|'

bool AddQuantifierToAtom(int min, int max,

RegExpQuantifier::QuantifierType type);

void FlushText();

RegExpTree* ToRegExp();

RegExpFlags flags() const { return flags_; }

bool ignore_case() const { return IsIgnoreCase(flags_); }

bool multiline() const { return IsMultiline(flags_); }

bool dotall() const { return IsDotAll(flags_); }

private:

static const base::uc16 kNoPendingSurrogate = 0;

void AddLeadSurrogate(base::uc16 lead_surrogate);

void AddTrailSurrogate(base::uc16 trail_surrogate);

void FlushPendingSurrogate();

void FlushCharacters();

void FlushTerms();

bool NeedsDesugaringForUnicode(RegExpCharacterClass* cc);

bool NeedsDesugaringForIgnoreCase(base::uc32 c);

Zone* zone() const { return zone_; }

bool unicode() const { return IsUnicode(flags_); }

Zone* const zone_;

bool pending_empty_;

const RegExpFlags flags_;

ZoneList<base::uc16>* characters_;

base::uc16 pending_surrogate_;

BufferedZoneList<RegExpTree, 2> terms_;

BufferedZoneList<RegExpTree, 2> text_;

BufferedZoneList<RegExpTree, 2> alternatives_;

#ifdef DEBUG

enum {ADD_NONE, ADD_CHAR, ADD_TERM, ADD_ASSERT, ADD_ATOM} last_added_;

#define LAST(x) last_added_ = x;

#else

#define LAST(x)

#endif

INITIAL,

CAPTURE, // All positive values represent captures.

POSITIVE_LOOKAROUND,

NEGATIVE_LOOKAROUND,

GROUPING

public:

// Push a state on the stack.

RegExpParserState(RegExpParserState* previous_state,

SubexpressionType group_type,

RegExpLookaround::Type lookaround_type,

int disjunction_capture_index,

const ZoneVector<base::uc16>* capture_name,

RegExpFlags flags, Zone* zone)

: previous_state_(previous_state),

builder_(zone->New<RegExpBuilder>(zone, flags)),

group_type_(group_type),

lookaround_type_(lookaround_type),

disjunction_capture_index_(disjunction_capture_index),

capture_name_(capture_name) {}

// Parser state of containing expression, if any.

RegExpParserState* previous_state() const { return previous_state_; }

bool IsSubexpression() { return previous_state_ != nullptr; }

// RegExpBuilder building this regexp's AST.

RegExpBuilder* builder() const { return builder_; }

// Type of regexp being parsed (parenthesized group or entire regexp).

SubexpressionType group_type() const { return group_type_; }

// Lookahead or Lookbehind.

RegExpLookaround::Type lookaround_type() const { return lookaround_type_; }

// Index in captures array of first capture in this sub-expression, if any.

// Also the capture index of this sub-expression itself, if group_type

// is CAPTURE.

int capture_index() const { return disjunction_capture_index_; }

// The name of the current sub-expression, if group_type is CAPTURE. Only

// used for named captures.

const ZoneVector<base::uc16>* capture_name() const { return capture_name_; }

bool IsNamedCapture() const { return capture_name_ != nullptr; }

// Check whether the parser is inside a capture group with the given index.

bool IsInsideCaptureGroup(int index) const {

for (const RegExpParserState* s = this; s != nullptr;

s = s->previous_state()) {

if (s->group_type() != CAPTURE) continue;

// Return true if we found the matching capture index.

if (index == s->capture_index()) return true;

// Abort if index is larger than what has been parsed up till this state.

if (index > s->capture_index()) return false;

}

return false;

}

// Check whether the parser is inside a capture group with the given name.

bool IsInsideCaptureGroup(const ZoneVector<base::uc16>* name) const {

DCHECK_NOT_NULL(name);

for (const RegExpParserState* s = this; s != nullptr;

s = s->previous_state()) {

if (s->capture_name() == nullptr) continue;

if (*s->capture_name() == *name) return true;

}

return false;

}

private:

// Linked list implementation of stack of states.

RegExpParserState* const previous_state_;

// Builder for the stored disjunction.

RegExpBuilder* const builder_;

// Stored disjunction type (capture, look-ahead or grouping), if any.

const SubexpressionType group_type_;

// Stored read direction.

const RegExpLookaround::Type lookaround_type_;

// Stored disjunction's capture index (if any).

const int disjunction_capture_index_;

// Stored capture name (if any).

const ZoneVector<base::uc16>* const capture_name_;

private:

RegExpParserImpl(const CharT* input, int input_length, RegExpFlags flags,

uintptr_t stack_limit, Zone* zone,

const DisallowGarbageCollection& no_gc);

bool Parse(RegExpCompileData* result);

RegExpTree* ParsePattern();

RegExpTree* ParseDisjunction();

RegExpTree* ParseGroup();

// Parses a {...,...} quantifier and stores the range in the given

// out parameters.

bool ParseIntervalQuantifier(int* min_out, int* max_out);

// Checks whether the following is a length-digit hexadecimal number,

// and sets the value if it is.

bool ParseHexEscape(int length, base::uc32* value);

bool ParseUnicodeEscape(base::uc32* value);

bool ParseUnlimitedLengthHexNumber(int max_value, base::uc32* value);

bool ParsePropertyClassName(ZoneVector<char>* name_1,

ZoneVector<char>* name_2);

bool AddPropertyClassRange(ZoneList<CharacterRange>* add_to, bool negate,

const ZoneVector<char>& name_1,

const ZoneVector<char>& name_2);

RegExpTree* ParseCharacterClass(const RegExpBuilder* state);

base::uc32 ParseOctalLiteral();

// Tries to parse the input as a back reference. If successful it

// stores the result in the output parameter and returns true. If

// it fails it will push back the characters read so the same characters

// can be reparsed.

bool ParseBackReferenceIndex(int* index_out);

// Parse inside a class. Either add escaped class to the range, or return

// false and pass parsed single character through |char_out|.

void ParseClassEscape(ZoneList<CharacterRange>* ranges, Zone* zone,

bool add_unicode_case_equivalents, base::uc32* char_out,

bool* is_class_escape);

// Returns true iff parsing was successful.

bool TryParseCharacterClassEscape(base::uc32 next,

InClassEscapeState in_class_escape_state,

ZoneList<CharacterRange>* ranges,

Zone* zone,

bool add_unicode_case_equivalents);

// Parses and returns a single escaped character.

base::uc32 ParseCharacterEscape(InClassEscapeState in_class_escape_state,

bool* is_escaped_unicode_character);

RegExpTree* ReportError(RegExpError error);

void Advance();

void Advance(int dist);

void Reset(int pos);

// Reports whether the pattern might be used as a literal search string.

// Only use if the result of the parse is a single atom node.

bool simple();

bool contains_anchor() { return contains_anchor_; }

void set_contains_anchor() { contains_anchor_ = true; }

int captures_started() { return captures_started_; }

int position() { return next_pos_ - 1; }

bool failed() { return failed_; }

bool unicode() const { return IsUnicode(top_level_flags_); }

static bool IsSyntaxCharacterOrSlash(base::uc32 c);

static const base::uc32 kEndMarker = (1 << 21);

private:

// Return the 1-indexed RegExpCapture object, allocate if necessary.

RegExpCapture* GetCapture(int index);

// Creates a new named capture at the specified index. Must be called exactly

// once for each named capture. Fails if a capture with the same name is

// encountered.

bool CreateNamedCaptureAtIndex(const ZoneVector<base::uc16>* name, int index);

// Parses the name of a capture group (?<name>pattern). The name must adhere

// to IdentifierName in the ECMAScript standard.

const ZoneVector<base::uc16>* ParseCaptureGroupName();

bool ParseNamedBackReference(RegExpBuilder* builder,

RegExpParserState* state);

RegExpParserState* ParseOpenParenthesis(RegExpParserState* state);

// After the initial parsing pass, patch corresponding RegExpCapture objects

// into all RegExpBackReferences. This is done after initial parsing in order

// to avoid complicating cases in which references comes before the capture.

void PatchNamedBackReferences();

ZoneVector<RegExpCapture*>* GetNamedCaptures() const;

// Returns true iff the pattern contains named captures. May call

// ScanForCaptures to look ahead at the remaining pattern.

bool HasNamedCaptures(InClassEscapeState in_class_escape_state);

Zone* zone() const { return zone_; }

base::uc32 current() { return current_; }

bool has_more() { return has_more_; }

bool has_next() { return next_pos_ < input_length(); }

base::uc32 Next();

template <bool update_position>

base::uc32 ReadNext();

CharT InputAt(int index) const {

DCHECK(0 <= index && index < input_length());

return input_[index];

}

int input_length() const { return input_length_; }

void ScanForCaptures(InClassEscapeState in_class_escape_state);

struct RegExpCaptureNameLess {

bool operator()(const RegExpCapture* lhs, const RegExpCapture* rhs) const {

DCHECK_NOT_NULL(lhs);

DCHECK_NOT_NULL(rhs);

return *lhs->name() < *rhs->name();

}

};

const DisallowGarbageCollection no_gc_;

Zone* const zone_;

RegExpError error_ = RegExpError::kNone;

int error_pos_ = 0;

ZoneList<RegExpCapture*>* captures_;

ZoneSet<RegExpCapture*, RegExpCaptureNameLess>* named_captures_;

ZoneList<RegExpBackReference*>* named_back_references_;

const CharT* const input_;

const int input_length_;

base::uc32 current_;

const RegExpFlags top_level_flags_;

int next_pos_;

int captures_started_;

int capture_count_; // Only valid after we have scanned for captures.

bool has_more_;

bool simple_;

bool contains_anchor_;

bool is_scanned_for_captures_;

bool has_named_captures_; // Only valid after we have scanned for captures.

bool failed_;

const uintptr_t stack_limit_;

friend bool RegExpParser::ParseRegExpFromHeapString(Isolate*, Zone*,

Handle<String>,

RegExpFlags,

RegExpCompileData*);

friend bool RegExpParser::VerifyRegExpSyntax<CharT>(

Zone*, uintptr_t, const CharT*, int, RegExpFlags, RegExpCompileData*,

const DisallowGarbageCollection&);

switch (c) {

case 'd':

case 'D':

case 's':

case 'S':

case 'w':

case 'W':

return true;

default:

return false;

}