Line data    Source code

       1             : // Copyright 2008 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_REGEXP_REGEXP_MACRO_ASSEMBLER_TRACER_H_
       6             : #define V8_REGEXP_REGEXP_MACRO_ASSEMBLER_TRACER_H_
       7             : 
       8             : #include "src/regexp/regexp-macro-assembler.h"
       9             : 
      10             : namespace v8 {
      11             : namespace internal {
      12             : 
      13             : // Decorator on a RegExpMacroAssembler that write all calls.
      14           0 : class RegExpMacroAssemblerTracer: public RegExpMacroAssembler {
      15             :  public:
      16             :   RegExpMacroAssemblerTracer(Isolate* isolate, RegExpMacroAssembler* assembler);
      17             :   ~RegExpMacroAssemblerTracer() override;
      18             :   void AbortedCodeGeneration() override;
      19           0 :   int stack_limit_slack() override { return assembler_->stack_limit_slack(); }
      20           0 :   bool CanReadUnaligned() override { return assembler_->CanReadUnaligned(); }
      21             :   void AdvanceCurrentPosition(int by) override;    // Signed cp change.
      22             :   void AdvanceRegister(int reg, int by) override;  // r[reg] += by.
      23             :   void Backtrack() override;
      24             :   void Bind(Label* label) override;
      25             :   void CheckAtStart(Label* on_at_start) override;
      26             :   void CheckCharacter(unsigned c, Label* on_equal) override;
      27             :   void CheckCharacterAfterAnd(unsigned c, unsigned and_with,
      28             :                               Label* on_equal) override;
      29             :   void CheckCharacterGT(uc16 limit, Label* on_greater) override;
      30             :   void CheckCharacterLT(uc16 limit, Label* on_less) override;
      31             :   void CheckGreedyLoop(Label* on_tos_equals_current_position) override;
      32             :   void CheckNotAtStart(int cp_offset, Label* on_not_at_start) override;
      33             :   void CheckNotBackReference(int start_reg, bool read_backward,
      34             :                              Label* on_no_match) override;
      35             :   void CheckNotBackReferenceIgnoreCase(int start_reg, bool read_backward,
      36             :                                        bool unicode,
      37             :                                        Label* on_no_match) override;
      38             :   void CheckNotCharacter(unsigned c, Label* on_not_equal) override;
      39             :   void CheckNotCharacterAfterAnd(unsigned c, unsigned and_with,
      40             :                                  Label* on_not_equal) override;
      41             :   void CheckNotCharacterAfterMinusAnd(uc16 c, uc16 minus, uc16 and_with,
      42             :                                       Label* on_not_equal) override;
      43             :   void CheckCharacterInRange(uc16 from, uc16 to, Label* on_in_range) override;
      44             :   void CheckCharacterNotInRange(uc16 from, uc16 to,
      45             :                                 Label* on_not_in_range) override;
      46             :   void CheckBitInTable(Handle<ByteArray> table, Label* on_bit_set) override;
      47             :   void CheckPosition(int cp_offset, Label* on_outside_input) override;
      48             :   bool CheckSpecialCharacterClass(uc16 type, Label* on_no_match) override;
      49             :   void Fail() override;
      50             :   Handle<HeapObject> GetCode(Handle<String> source) override;
      51             :   void GoTo(Label* label) override;
      52             :   void IfRegisterGE(int reg, int comparand, Label* if_ge) override;
      53             :   void IfRegisterLT(int reg, int comparand, Label* if_lt) override;
      54             :   void IfRegisterEqPos(int reg, Label* if_eq) override;
      55             :   IrregexpImplementation Implementation() override;
      56             :   void LoadCurrentCharacter(int cp_offset, Label* on_end_of_input,
      57             :                             bool check_bounds = true,
      58             :                             int characters = 1) override;
      59             :   void PopCurrentPosition() override;
      60             :   void PopRegister(int register_index) override;
      61             :   void PushBacktrack(Label* label) override;
      62             :   void PushCurrentPosition() override;
      63             :   void PushRegister(int register_index,
      64             :                     StackCheckFlag check_stack_limit) override;
      65             :   void ReadCurrentPositionFromRegister(int reg) override;
      66             :   void ReadStackPointerFromRegister(int reg) override;
      67             :   void SetCurrentPositionFromEnd(int by) override;
      68             :   void SetRegister(int register_index, int to) override;
      69             :   bool Succeed() override;
      70             :   void WriteCurrentPositionToRegister(int reg, int cp_offset) override;
      71             :   void ClearRegisters(int reg_from, int reg_to) override;
      72             :   void WriteStackPointerToRegister(int reg) override;
      73             : 
      74             :  private:
      75             :   RegExpMacroAssembler* assembler_;
      76             : };
      77             : 
      78             : }  // namespace internal
      79             : }  // namespace v8
      80             : 
      81             : #endif  // V8_REGEXP_REGEXP_MACRO_ASSEMBLER_TRACER_H_