Introduce text nodes

src/jsregexp.h

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 173 matching lines @@
       to_(to) {
   }
   static void AddClassEscape(uc16 type, ZoneList<CharacterRange>* ranges);
   static inline CharacterRange Singleton(uc16 value) {
     return CharacterRange(value, value);
   }
   static inline CharacterRange Range(uc16 from, uc16 to) {
     ASSERT(from <= to);
     return CharacterRange(from, to);
   }
+  static inline CharacterRange Everything() {
+    return CharacterRange(0, 0xFFFF);
+  }
   bool Contains(uc16 i) { return from_ <= i && i <= to_; }
   uc16 from() const { return from_; }
   void set_from(uc16 value) { from_ = value; }
   uc16 to() const { return to_; }
   void set_to(uc16 value) { to_ = value; }
   bool is_valid() { return from_ <= to_; }
   bool IsSingleton() { return (from_ == to_); }
  private:
   uc16 from_;
   uc16 to_;
@@ skipping 178 matching lines @@
   // successors in a zone and caches them.
   OutSet* empty() { return &empty_; }
   OutSet empty_;
   ZoneSplayTree<Config>* tree() { return &tree_; }
   ZoneSplayTree<Config> tree_;
 };
 
 
 #define FOR_EACH_NODE_TYPE(VISIT)                                    \
   VISIT(End)                                                         \
-  VISIT(Atom)                                                        \
   VISIT(Action)                                                      \
   VISIT(Choice)                                                      \
   VISIT(Backreference)                                               \
-  VISIT(CharacterClass)
+  VISIT(Text)
+
+
+#define FOR_EACH_REG_EXP_TREE_TYPE(VISIT)                            \
+  VISIT(Disjunction)                                                 \
+  VISIT(Alternative)                                                 \
+  VISIT(Assertion)                                                   \
+  VISIT(CharacterClass)                                              \
+  VISIT(Atom)                                                        \
+  VISIT(Quantifier)                                                  \
+  VISIT(Capture)                                                     \
+  VISIT(Lookahead)                                                   \
+  VISIT(Backreference)                                               \
+  VISIT(Empty)                                                       \
+  VISIT(Text)
+
+
+#define FORWARD_DECLARE(Name) class RegExp##Name;
+FOR_EACH_REG_EXP_TREE_TYPE(FORWARD_DECLARE)
+#undef FORWARD_DECLARE
+
+
+class TextElement {
+ public:
+  enum Type {UNINITIALIZED, ATOM, CHAR_CLASS};
+  TextElement() : type(UNINITIALIZED) { }
+  TextElement(Type t) : type(t) { }
+  static TextElement Atom(RegExpAtom* atom);
+  static TextElement CharClass(RegExpCharacterClass* char_class);
+  Type type;
+  union {
+    RegExpAtom* u_atom;
+    RegExpCharacterClass* u_char_class;
+  } data;
+};
 
 
 class NodeInfo {
  public:
   NodeInfo()
     : being_analyzed(false),
       been_analyzed(false),
       propagate_word(false),
       propagate_line(false) { }
   bool being_analyzed: 1;
@@ skipping 72 matching lines @@
     } u_position_register;
   } data_;
   ActionNode(Type type, RegExpNode* on_success)
     : SeqRegExpNode(on_success),
       type_(type) { }
   Type type_;
   friend class DotPrinter;
 };
 
 
-class AtomNode: public SeqRegExpNode {
+class TextNode: public SeqRegExpNode {
  public:
-  AtomNode(Vector<const uc16> data,
+  TextNode(ZoneList<TextElement>* elms,
            RegExpNode* on_success,
            RegExpNode* on_failure)
     : SeqRegExpNode(on_success),
       on_failure_(on_failure),
-      data_(data) { }
+      elms_(elms) { }
   virtual void Accept(NodeVisitor* visitor);
-  Vector<const uc16> data() { return data_; }
+  virtual bool Emit(RegExpCompiler* compiler) { return false; }
   RegExpNode* on_failure() { return on_failure_; }
-  virtual bool Emit(RegExpCompiler* compiler) { return false; }
+  ZoneList<TextElement>* elements() { return elms_; }
  private:
   RegExpNode* on_failure_;
-  Vector<const uc16> data_;
+  ZoneList<TextElement>* elms_;
 };
 
 
 class BackreferenceNode: public SeqRegExpNode {
  public:
   BackreferenceNode(int start_reg,
                     int end_reg,
                     RegExpNode* on_success,
                     RegExpNode* on_failure)
     : SeqRegExpNode(on_success),
       on_failure_(on_failure),
       start_reg_(start_reg),
       end_reg_(end_reg) { }
   virtual void Accept(NodeVisitor* visitor);
   RegExpNode* on_failure() { return on_failure_; }
   int start_register() { return start_reg_; }
   int end_register() { return end_reg_; }
   virtual bool Emit(RegExpCompiler* compiler) { return false; }
  private:
   RegExpNode* on_failure_;
   int start_reg_;
   int end_reg_;
 };
 
 
-class CharacterClassNode: public SeqRegExpNode {
- public:
-  CharacterClassNode(ZoneList<CharacterRange>* ranges,
-                     bool is_negated,
-                     RegExpNode* on_success,
-                     RegExpNode* on_failure)
-    : SeqRegExpNode(on_success),
-      on_failure_(on_failure),
-      ranges_(ranges),
-      is_negated_(is_negated ) { }
-  virtual void Accept(NodeVisitor* visitor);
-  ZoneList<CharacterRange>* ranges() { return ranges_; }
-  bool is_negated() { return is_negated_; }
-  RegExpNode* on_failure() { return on_failure_; }
-  virtual bool Emit(RegExpCompiler* compiler) { return false; }
-  static void AddInverseToTable(ZoneList<CharacterRange>* ranges,
-                                DispatchTable* table,
-                                int index);
- private:
-  RegExpNode* on_failure_;
-  ZoneList<CharacterRange>* ranges_;
-  bool is_negated_;
-};
-
-
 class EndNode: public RegExpNode {
  public:
   enum Action { ACCEPT, BACKTRACK };
   explicit EndNode(Action action) : action_(action) { }
   virtual void Accept(NodeVisitor* visitor);
   virtual bool Emit(RegExpCompiler* compiler);
   virtual bool IsBacktrack() { return action_ == BACKTRACK; }
  private:
   Action action_;
 };
@@ skipping 121 matching lines @@
   static Handle<FixedArray> Compile(RegExpParseResult* input,
                                     RegExpNode** node_return,
                                     bool ignore_case);
   static void DotPrint(const char* label, RegExpNode* node);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_JSREGEXP_H_