Dispatch tables

src/ast.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 16 matching lines @@
 
 #ifndef V8_AST_H_
 #define V8_AST_H_
 
 #include "execution.h"
 #include "factory.h"
 #include "runtime.h"
 #include "token.h"
 #include "variables.h"
 #include "macro-assembler.h"
+#include "jsregexp.h"
 
 namespace v8 { namespace internal {
 
 // The abstract syntax tree is an intermediate, light-weight
 // representation of the parsed JavaScript code suitable for
 // compilation to native code.
 
 // Nodes are allocated in a separate zone, which allows faster
 // allocation and constant-time deallocation of the entire syntax
 // tree.
@@ skipping 1204 matching lines @@
   };
   explicit RegExpAssertion(Type type) : type_(type) { }
   virtual void* Accept(RegExpVisitor* visitor, void* data);
   virtual RegExpAssertion* AsAssertion();
   Type type() { return type_; }
  private:
   Type type_;
 };
 
 
-class CharacterRange {
- public:
-  // For compatibility with the CHECK_OK macro
-  CharacterRange(void* null) { ASSERT_EQ(NULL, null); }  //NOLINT
-  CharacterRange(uc32 from, uc32 to, bool is_character_class)
-    : from_(from),
-      to_(to),
-      is_character_class_(is_character_class) {
-    // Assert that truncating doesn't throw away information.
-    ASSERT_EQ(from, from_);
-    ASSERT_EQ(to_, to);
-  }
-  static inline CharacterRange CharacterClass(uc32 tag) {
-    return CharacterRange(tag, tag, true);
-  }
-  static inline CharacterRange Singleton(uc32 value) {
-    return CharacterRange(value, value, false);
-  }
-  static inline CharacterRange Range(uc32 from, uc32 to) {
-    return CharacterRange(from, to, false);
-  }
-  unsigned from() { return from_; }
-  unsigned to() { return to_; }
-  bool is_character_class() { return is_character_class_; }
-  bool IsSingleton() { return (from_ == to_) && !is_character_class(); }
- private:
-  unsigned from_ : 16;
-  unsigned to_ : 16;
-  bool is_character_class_ : 1;
-};
-
-
-STATIC_CHECK(sizeof(CharacterRange) == 2 * sizeof(int));  // NOLINT
-
-
 class RegExpCharacterClass: public RegExpTree {
  public:
-  explicit RegExpCharacterClass(CharacterRange range)
-    : ranges_(new ZoneList<CharacterRange>(1)),
-      is_negated_(false) {
-    ranges_->Add(range);
-  }
   RegExpCharacterClass(ZoneList<CharacterRange>* ranges, bool is_negated)
     : ranges_(ranges),
       is_negated_(is_negated) { }
   virtual void* Accept(RegExpVisitor* visitor, void* data);
   virtual RegExpCharacterClass* AsCharacterClass();
   ZoneList<CharacterRange>* ranges() { return ranges_; }
   bool is_negated() { return is_negated_; }
  private:
   ZoneList<CharacterRange>* ranges_;
   bool is_negated_;
@@ skipping 132 matching lines @@
 #undef DEF_VISIT
 
  private:
   bool stack_overflow_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_