Merge code review fixes.

src/jsregexp.cc

 // 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 899 matching lines @@
   List<RegExpNode*>* work_list_;
   int recursion_depth_;
   RegExpMacroAssembler* macro_assembler_;
   bool is_case_independent_;
 };
 
 
 // Attempts to compile the regexp using an Irregexp code generator.  Returns
 // a fixed array or a null handle depending on whether it succeeded.
 RegExpCompiler::RegExpCompiler(int capture_count, bool ignore_case)
-  : next_register_(2 * (capture_count + 1)),
-    work_list_(NULL),
-    recursion_depth_(0),
-    is_case_independent_(ignore_case) {
+    : next_register_(2 * (capture_count + 1)),
+      work_list_(NULL),
+      recursion_depth_(0),
+      is_case_independent_(ignore_case) {
   accept_ = new EndNode(EndNode::ACCEPT);
   backtrack_ = new EndNode(EndNode::BACKTRACK);
 }
 
 
 Handle<FixedArray> RegExpCompiler::Assemble(
     RegExpMacroAssembler* macro_assembler,
     RegExpNode* start,
     int capture_count) {
   if (!FLAG_attempt_case_independent && is_case_independent_) {
@@ skipping 608 matching lines @@
 void DotPrinter::PrintOnFailure(RegExpNode* from, RegExpNode* on_failure) {
   if (on_failure->IsBacktrack()) return;
   stream()->Add("  n%p -> n%p [style=dotted];\n", from, on_failure);
   Visit(on_failure);
 }
 
 
 class TableEntryBodyPrinter {
  public:
   TableEntryBodyPrinter(StringStream* stream, ChoiceNode* choice)
-    : stream_(stream), choice_(choice) { }
+      : stream_(stream), choice_(choice) { }
   void Call(uc16 from, DispatchTable::Entry entry) {
     OutSet* out_set = entry.out_set();
     for (unsigned i = 0; i < OutSet::kFirstLimit; i++) {
       if (out_set->Get(i)) {
         stream()->Add("    n%p:s%io%i -> n%p;\n",
                       choice(),
                       from,
                       i,
                       choice()->alternatives()->at(i).node());
       }
     }
   }
  private:
   StringStream* stream() { return stream_; }
   ChoiceNode* choice() { return choice_; }
   StringStream* stream_;
   ChoiceNode* choice_;
 };
 
 
 class TableEntryHeaderPrinter {
  public:
   explicit TableEntryHeaderPrinter(StringStream* stream)
-    : first_(true), stream_(stream) { }
+      : first_(true), stream_(stream) { }
   void Call(uc16 from, DispatchTable::Entry entry) {
     if (first_) {
       first_ = false;
     } else {
       stream()->Add("|");
     }
     stream()->Add("{\\%k-\\%k|{", from, entry.to());
     OutSet* out_set = entry.out_set();
     int priority = 0;
     for (unsigned i = 0; i < OutSet::kFirstLimit; i++) {
@@ skipping 493 matching lines @@
   unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
   if (IsSingleton()) {
     // If this is a singleton we just expand the one character.
     int length = uncanonicalize.get(from(), '\0', chars);
     for (int i = 0; i < length; i++) {
       uc32 chr = chars[i];
       if (chr != from()) {
         ranges->Add(CharacterRange::Singleton(chars[i]));
       }
     }
-  } else if (from() <= kRangeCanonicalizeMax
-          && to() <= kRangeCanonicalizeMax) {
+  } else if (from() <= kRangeCanonicalizeMax &&
+      to() <= kRangeCanonicalizeMax) {

[Mads Ager (chromium), 2008/11/26 07:33:58]

Align to() with from().

     // If this is a range we expand the characters block by block,
     // expanding contiguous subranges (blocks) one at a time.
     // The approach is as follows.  For a given start character we
     // look up the block that contains it, for instance 'a' if the
     // start character is 'c'.  A block is characterized by the property
     // that all characters uncanonicalize in the same way as the first
     // element, except that each entry in the result is incremented
     // by the distance from the first element.  So a-z is a block
     // because 'a' uncanonicalizes to ['a', 'A'] and the k'th letter
     // uncanonicalizes to ['a' + k, 'A' + k].
@@ skipping 493 matching lines @@
   byte codes[1024];
   IrregexpAssembler assembler(Vector<byte>(codes, 1024));
   RegExpMacroAssemblerIrregexp macro_assembler(&assembler);
   return compiler.Assemble(&macro_assembler,
                            node,
                            input->capture_count);
 }
 
 
 }}  // namespace v8::internal