Merge code review fixes.

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 165 matching lines @@
   static int utf8_position_;
   static int character_position_;
 };
 
 
 class CharacterRange {
  public:
   CharacterRange() : from_(0), to_(0) { }
   // For compatibility with the CHECK_OK macro
   CharacterRange(void* null) { ASSERT_EQ(NULL, null); }  //NOLINT
-  CharacterRange(uc16 from, uc16 to)
-    : from_(from),
-      to_(to) {
-  }
+  CharacterRange(uc16 from, uc16 to) : from_(from), 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);
@@ skipping 69 matching lines @@
 
   // Perform the splay operation for the given key. Moves the node with
   // the given key to the top of the tree.  If no node has the given
   // key, the last node on the search path is moved to the top of the
   // tree.
   void Splay(const Key& key);
 
   class Node : public ZoneObject {
    public:
     Node(const Key& key, const Value& value)
-      : key_(key),
-        value_(value),
-        left_(NULL),
-        right_(NULL) { }
-     Key key() { return key_; }
-     Value value() { return value_; }
-     Node* left() { return left_; }
-     Node* right() { return right_; }
+        : key_(key),
+          value_(value),
+          left_(NULL),
+          right_(NULL) { }
+    Key key() { return key_; }
+    Value value() { return value_; }
+    Node* left() { return left_; }
+    Node* right() { return right_; }
    private:
     friend class ZoneSplayTree;
     friend class Locator;
     Key key_;
     Value value_;
     Node* left_;
     Node* right_;
   };
 
   // A locator provides access to a node in the tree without actually
@@ skipping 21 matching lines @@
 
 
 // A set of unsigned integers that behaves especially well on small
 // integers (< 32).  May do zone-allocation.
 class OutSet: public ZoneObject {
  public:
   OutSet() : first_(0), remaining_(NULL), successors_(NULL) { }
   OutSet* Extend(unsigned value);
   bool Get(unsigned value);
   static const unsigned kFirstLimit = 32;
+
  private:
-
   // Destructively set a value in this set.  In most cases you want
   // to use Extend instead to ensure that only one instance exists
   // that contains the same values.
   void Set(unsigned value);
 
   // The successors are a list of sets that contain the same values
   // as this set and the one more value that is not present in this
   // set.
   ZoneList<OutSet*>* successors() { return successors_; }
 
   OutSet(uint32_t first, ZoneList<unsigned>* remaining)
-    : first_(first), remaining_(remaining), successors_(NULL) { }
+      : first_(first), remaining_(remaining), successors_(NULL) { }
   uint32_t first_;
   ZoneList<unsigned>* remaining_;
   ZoneList<OutSet*>* successors_;
 };
 
 
 // A mapping from integers, specified as ranges, to a set of integers.
 // Used for mapping character ranges to choices.
 class DispatchTable {
  public:
   class Entry {
    public:
-    Entry()
-      : from_(0), to_(0), out_set_(NULL) { }
+    Entry() : from_(0), to_(0), out_set_(NULL) { }
     Entry(uc16 from, uc16 to, OutSet* out_set)
-      : from_(from), to_(to), out_set_(out_set) { }
+        : from_(from), to_(to), out_set_(out_set) { }
     uc16 from() { return from_; }
     uc16 to() { return to_; }
     void set_to(uc16 value) { to_ = value; }
     void AddValue(int value) { out_set_ = out_set_->Extend(value); }
     OutSet* out_set() { return out_set_; }
    private:
     uc16 from_;
     uc16 to_;
     OutSet* out_set_;
   };
@@ skipping 67 matching lines @@
   Type type;
   union {
     RegExpAtom* u_atom;
     RegExpCharacterClass* u_char_class;
   } data;
 };
 
 
 struct NodeInfo {
   NodeInfo()
-    : being_analyzed(false),
-      been_analyzed(false),
-      determine_word(false),
-      determine_newline(false),
-      determine_start(false),
-      follows_word_interest(false),
-      follows_newline_interest(false),
-      follows_start_interest(false) { }
+      : being_analyzed(false),
+        been_analyzed(false),
+        determine_word(false),
+        determine_newline(false),
+        determine_start(false),
+        follows_word_interest(false),
+        follows_newline_interest(false),
+        follows_start_interest(false) { }
   bool SameInterests(NodeInfo* that) {
     return (follows_word_interest == that->follows_word_interest)
         && (follows_newline_interest == that->follows_newline_interest)
         && (follows_start_interest == that->follows_start_interest);
   }
   void AdoptInterests(NodeInfo* that) {
     follows_word_interest = that->follows_word_interest;
     follows_newline_interest = that->follows_newline_interest;
     follows_start_interest = that->follows_start_interest;
   }
@@ skipping 63 matching lines @@
  private:
   Label label_;
   NodeInfo info_;
   SiblingList siblings_;
 };
 
 
 class SeqRegExpNode: public RegExpNode {
  public:
   explicit SeqRegExpNode(RegExpNode* on_success)
-    : on_success_(on_success) { }
+      : on_success_(on_success) { }
   RegExpNode* on_success() { return on_success_; }
   void set_on_success(RegExpNode* node) { on_success_ = node; }
   virtual bool Emit(RegExpCompiler* compiler) { return false; }
  private:
   RegExpNode* on_success_;
 };
 
 
 class ActionNode: public SeqRegExpNode {
  public:
@@ skipping 26 matching lines @@
       int reg;
     } u_increment_register;
     struct {
       int reg;
     } u_position_register;
     struct {
       int reg;
     } u_submatch_stack_pointer_register;
   } data_;
   ActionNode(Type type, RegExpNode* on_success)
-    : SeqRegExpNode(on_success),
-      type_(type) { }
+      : SeqRegExpNode(on_success),
+        type_(type) { }
   Type type_;
   friend class DotPrinter;
 };
 
 
 class TextNode: public SeqRegExpNode {
  public:
   TextNode(ZoneList<TextElement>* elms,
            RegExpNode* on_success,
            RegExpNode* on_failure)
-    : SeqRegExpNode(on_success),
-      on_failure_(on_failure),
-      elms_(elms) { }
+      : SeqRegExpNode(on_success),
+        on_failure_(on_failure),
+        elms_(elms) { }
   virtual void Accept(NodeVisitor* visitor);
   virtual RegExpNode* PropagateInterest(NodeInfo* info);
   RegExpNode* on_failure() { return on_failure_; }
   virtual bool Emit(RegExpCompiler* compiler);
   ZoneList<TextElement>* elements() { return elms_; }
  private:
   RegExpNode* on_failure_;
   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) { }
+      : 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);
   virtual RegExpNode* PropagateInterest(NodeInfo* info);
  private:
   RegExpNode* on_failure_;
   int start_reg_;
   int end_reg_;
@@ skipping 11 matching lines @@
   virtual bool GoTo(RegExpCompiler* compiler);
  private:
   Action action_;
 };
 
 
 class Guard: public ZoneObject {
  public:
   enum Relation { LT, GEQ };
   Guard(int reg, Relation op, int value)
-    : reg_(reg),
-      op_(op),
-      value_(value) { }
+      : reg_(reg),
+        op_(op),
+        value_(value) { }
   int reg() { return reg_; }
   Relation op() { return op_; }
   int value() { return value_; }
  private:
   int reg_;
   Relation op_;
   int value_;
 };
 
 
 class GuardedAlternative {
  public:
   explicit GuardedAlternative(RegExpNode* node) : node_(node), guards_(NULL) { }
   void AddGuard(Guard* guard);
   RegExpNode* node() { return node_; }
   void set_node(RegExpNode* node) { node_ = node; }
   ZoneList<Guard*>* guards() { return guards_; }
  private:
   RegExpNode* node_;
   ZoneList<Guard*>* guards_;
 };
 
 
 class ChoiceNode: public RegExpNode {
  public:
   explicit ChoiceNode(int expected_size, RegExpNode* on_failure)
-    : on_failure_(on_failure),
-      alternatives_(new ZoneList<GuardedAlternative>(expected_size)),
-      table_calculated_(false),
-      being_calculated_(false) { }
+      : on_failure_(on_failure),
+        alternatives_(new ZoneList<GuardedAlternative>(expected_size)),
+        table_calculated_(false),
+        being_calculated_(false) { }
   virtual void Accept(NodeVisitor* visitor);
   void AddAlternative(GuardedAlternative node) { alternatives()->Add(node); }
   ZoneList<GuardedAlternative>* alternatives() { return alternatives_; }
   DispatchTable* table() { return &table_; }
   RegExpNode* on_failure() { return on_failure_; }
   virtual bool Emit(RegExpCompiler* compiler);
   virtual RegExpNode* PropagateInterest(NodeInfo* info);
   bool table_calculated() { return table_calculated_; }
   void set_table_calculated(bool b) { table_calculated_ = b; }
   bool being_calculated() { return being_calculated_; }
@@ skipping 18 matching lines @@
 FOR_EACH_NODE_TYPE(DECLARE_VISIT)
 #undef DECLARE_VISIT
 };
 
 
 // Node visitor used to add the start set of the alternatives to the
 // dispatch table of a choice node.
 class DispatchTableConstructor: public NodeVisitor {
  public:
   explicit DispatchTableConstructor(DispatchTable* table)
-    : table_(table),
-      choice_index_(-1) { }
+      : table_(table),
+        choice_index_(-1) { }
 
   void BuildTable(ChoiceNode* node);
 
   void AddRange(CharacterRange range) {
     table()->AddRange(range, choice_index_);
   }
 
   void AddInverse(ZoneList<CharacterRange>* ranges);
 
 #define DECLARE_VISIT(Type)                                          \
@@ skipping 34 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_