regexp-bytecode-generator.cc | Explore in Territory

// Copyright 2008-2009 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/regexp/regexp-bytecode-generator.h"

#include "src/ast/ast.h"
#include "src/objects/fixed-array-inl.h"
#include "src/regexp/regexp-bytecode-generator-inl.h"
#include "src/regexp/regexp-bytecode-peephole.h"
#include "src/regexp/regexp-bytecodes.h"
#include "src/regexp/regexp-macro-assembler.h"

namespace v8 {
namespace internal {

RegExpBytecodeGenerator::RegExpBytecodeGenerator(Isolate* isolate, Zone* zone)
    : … { … }

RegExpBytecodeGenerator::~RegExpBytecodeGenerator() { … }

RegExpBytecodeGenerator::IrregexpImplementation
RegExpBytecodeGenerator::Implementation() { … }

void RegExpBytecodeGenerator::Bind(Label* l) { … }

void RegExpBytecodeGenerator::EmitOrLink(Label* l) { … }

void RegExpBytecodeGenerator::PopRegister(int register_index) { … }

void RegExpBytecodeGenerator::PushRegister(int register_index,
                                           StackCheckFlag check_stack_limit) { … }

void RegExpBytecodeGenerator::WriteCurrentPositionToRegister(int register_index,
                                                             int cp_offset) { … }

void RegExpBytecodeGenerator::ClearRegisters(int reg_from, int reg_to) { … }

void RegExpBytecodeGenerator::ReadCurrentPositionFromRegister(
    int register_index) { … }

void RegExpBytecodeGenerator::WriteStackPointerToRegister(int register_index) { … }

void RegExpBytecodeGenerator::ReadStackPointerFromRegister(int register_index) { … }

void RegExpBytecodeGenerator::SetCurrentPositionFromEnd(int by) { … }

void RegExpBytecodeGenerator::SetRegister(int register_index, int to) { … }

void RegExpBytecodeGenerator::AdvanceRegister(int register_index, int by) { … }

void RegExpBytecodeGenerator::PopCurrentPosition() { … }

void RegExpBytecodeGenerator::PushCurrentPosition() { … }

void RegExpBytecodeGenerator::Backtrack() { … }

void RegExpBytecodeGenerator::GoTo(Label* l) { … }

void RegExpBytecodeGenerator::PushBacktrack(Label* l) { … }

bool RegExpBytecodeGenerator::Succeed() { … }

void RegExpBytecodeGenerator::Fail() { … }

void RegExpBytecodeGenerator::AdvanceCurrentPosition(int by) { … }

void RegExpBytecodeGenerator::CheckGreedyLoop(
    Label* on_tos_equals_current_position) { … }

void RegExpBytecodeGenerator::LoadCurrentCharacterImpl(int cp_offset,
                                                       Label* on_failure,
                                                       bool check_bounds,
                                                       int characters,
                                                       int eats_at_least) { … }

void RegExpBytecodeGenerator::CheckCharacterLT(base::uc16 limit,
                                               Label* on_less) { … }

void RegExpBytecodeGenerator::CheckCharacterGT(base::uc16 limit,
                                               Label* on_greater) { … }

void RegExpBytecodeGenerator::CheckCharacter(uint32_t c, Label* on_equal) { … }

void RegExpBytecodeGenerator::CheckAtStart(int cp_offset, Label* on_at_start) { … }

void RegExpBytecodeGenerator::CheckNotAtStart(int cp_offset,
                                              Label* on_not_at_start) { … }

void RegExpBytecodeGenerator::CheckNotCharacter(uint32_t c,
                                                Label* on_not_equal) { … }

void RegExpBytecodeGenerator::CheckCharacterAfterAnd(uint32_t c, uint32_t mask,
                                                     Label* on_equal) { … }

void RegExpBytecodeGenerator::CheckNotCharacterAfterAnd(uint32_t c,
                                                        uint32_t mask,
                                                        Label* on_not_equal) { … }

void RegExpBytecodeGenerator::CheckNotCharacterAfterMinusAnd(
    base::uc16 c, base::uc16 minus, base::uc16 mask, Label* on_not_equal) { … }

void RegExpBytecodeGenerator::CheckCharacterInRange(base::uc16 from,
                                                    base::uc16 to,
                                                    Label* on_in_range) { … }

void RegExpBytecodeGenerator::CheckCharacterNotInRange(base::uc16 from,
                                                       base::uc16 to,
                                                       Label* on_not_in_range) { … }

void RegExpBytecodeGenerator::CheckBitInTable(Handle<ByteArray> table,
                                              Label* on_bit_set) { … }

void RegExpBytecodeGenerator::CheckNotBackReference(int start_reg,
                                                    bool read_backward,
                                                    Label* on_not_equal) { … }

void RegExpBytecodeGenerator::CheckNotBackReferenceIgnoreCase(
    int start_reg, bool read_backward, bool unicode, Label* on_not_equal) { … }

void RegExpBytecodeGenerator::IfRegisterLT(int register_index, int comparand,
                                           Label* on_less_than) { … }

void RegExpBytecodeGenerator::IfRegisterGE(int register_index, int comparand,
                                           Label* on_greater_or_equal) { … }

void RegExpBytecodeGenerator::IfRegisterEqPos(int register_index,
                                              Label* on_eq) { … }

Handle<HeapObject> RegExpBytecodeGenerator::GetCode(Handle<String> source) { … }

int RegExpBytecodeGenerator::length() { … }

void RegExpBytecodeGenerator::Copy(uint8_t* a) { … }

void RegExpBytecodeGenerator::ExpandBuffer() { … }

}  // namespace internal
}  // namespace v8
chromium/v8/src/regexp/regexp-bytecode-generator.cc
