Bugfixes

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 1728 matching lines @@
   '0', '9', 'A', 'Z', '_', '_', 'a', 'z'
 };
 
 
 static const int kDigitRangeCount = 2;
 static const uc16 kDigitRanges[kDigitRangeCount] = {
   '0', '9'
 };
 
 
+static const int kLineTerminatorRangeCount = 6;
+static const uc16 kLineTerminatorRanges[kLineTerminatorRangeCount] = {
+  0x000A, 0x000A, 0x000D, 0x000D, 0x2028, 0x2029
+};
+
+
 static void AddClass(const uc16* elmv,
                      int elmc,
                      ZoneList<CharacterRange>* ranges) {
   for (int i = 0; i < elmc; i += 2) {
     ASSERT(elmv[i] <= elmv[i + 1]);
     ranges->Add(CharacterRange(elmv[i], elmv[i + 1]));
   }
 }
 
 
@@ skipping 28 matching lines @@
     case 'W':
       AddClassNegated(kWordRanges, kWordRangeCount, ranges);
       break;
     case 'd':
       AddClass(kDigitRanges, kDigitRangeCount, ranges);
       break;
     case 'D':
       AddClassNegated(kDigitRanges, kDigitRangeCount, ranges);
       break;
     case '.':
+      AddClassNegated(kLineTerminatorRanges,
+                      kLineTerminatorRangeCount,
+                      ranges);
+      break;
+    // This is not a character range as defined by the spec but a
+    // convenient shorthand for a character class that matches any
+    // character.
+    case '*':
       ranges->Add(CharacterRange::Everything());
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
 // -------------------------------------------------------------------
 // Interest propagation
@@ skipping 397 matching lines @@
                                                     compiler.accept(),
                                                     compiler.backtrack());
   // Add a .*? at the beginning, outside the body capture.
   // Note: We could choose to not add this if the regexp is anchored at
   //   the start of the input but I'm not sure how best to do that and
   //   since we don't even handle ^ yet I'm saving that optimization for
   //   later.
   RegExpNode* node = RegExpQuantifier::ToNode(0,
                                               RegExpQuantifier::kInfinity,
                                               false,
-                                              new RegExpCharacterClass('.'),
+                                              new RegExpCharacterClass('*'),
                                               &compiler,
                                               captured_body,
                                               compiler.backtrack());
   if (node_return != NULL) *node_return = node;
   Analysis analysis;
   analysis.EnsureAnalyzed(node);
   byte codes[1024];
   Re2kAssembler assembler(Vector<byte>(codes, 1024));
   RegExpMacroAssemblerRe2k macro_assembler(&assembler);
   return compiler.Assemble(&macro_assembler,
                            node,
                            input->capture_count,
                            ignore_case);
 }
 
 RegExpMacroAssembler::RegExpMacroAssembler() {
 }
 
 RegExpMacroAssembler::~RegExpMacroAssembler() {
 }
 
 
 }}  // namespace v8::internal