Bugfixes

test/cctest/test-regexp.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 201 matching lines @@
   CHECK_ESCAPES("a(?:b)", false);
   CHECK_ESCAPES("a(?=b)", false);
   CHECK_ESCAPES("a(?!b)", false);
   CHECK_ESCAPES("\\x60", true);
   CHECK_ESCAPES("\\u0060", true);
   CHECK_ESCAPES("\\cA", true);
   CHECK_ESCAPES("\\q", true);
   CHECK_ESCAPES("\\1112", true);
   CHECK_ESCAPES("\\0", true);
   CHECK_ESCAPES("(a)\\1", false);
+
+  CHECK_PARSE_EQ("a{}", "'a{}'");
+  CHECK_PARSE_EQ("a{,}", "'a{,}'");
+  CHECK_PARSE_EQ("a{", "'a{'");
+  CHECK_PARSE_EQ("a{z}", "'a{z}'");
+  CHECK_PARSE_EQ("a{1z}", "'a{1z}'");
+  CHECK_PARSE_EQ("a{12z}", "'a{12z}'");
+  CHECK_PARSE_EQ("a{12,", "'a{12,'");
+  CHECK_PARSE_EQ("a{12,3b", "'a{12,3b'");
+  CHECK_PARSE_EQ("{}", "'{}'");
+  CHECK_PARSE_EQ("{,}", "'{,}'");
+  CHECK_PARSE_EQ("{", "'{'");
+  CHECK_PARSE_EQ("{z}", "'{z}'");
+  CHECK_PARSE_EQ("{1z}", "'{1z}'");
+  CHECK_PARSE_EQ("{12z}", "'{12z}'");
+  CHECK_PARSE_EQ("{12,", "'{12,'");
+  CHECK_PARSE_EQ("{12,3b", "'{12,3b'");
 }
 
 TEST(ParserRegression) {
   CHECK_PARSE_EQ("[A-Z$-][x]", "(! [A-Z $ -] [x])");
+  CHECK_PARSE_EQ("a{3,4*}", "(: 'a{3,' (# 0 - g '4') '}')");
+  CHECK_PARSE_EQ("{", "'{'");
+  CHECK_PARSE_EQ("a|", "(| 'a' %)");
 }
 
 static void ExpectError(const char* input,
                         const char* expected) {
   v8::HandleScope scope;
   ZoneScope zone_scope(DELETE_ON_EXIT);
   FlatStringReader reader(CStrVector(input));
   RegExpParseResult result;
   CHECK_EQ(false, v8::internal::ParseRegExp(&reader, &result));
   CHECK(result.tree == NULL);
   CHECK(!result.error.is_null());
   SmartPointer<char> str = result.error->ToCString(ALLOW_NULLS);
   CHECK_EQ(expected, *str);
 }
 
 
 TEST(Errors) {
   V8::Initialize(NULL);
   const char* kEndBackslash = "\\ at end of pattern";
   ExpectError("\\", kEndBackslash);
-  const char* kInvalidQuantifier = "Invalid quantifier";
-  ExpectError("a{}", kInvalidQuantifier);
-  ExpectError("a{,}", kInvalidQuantifier);
-  ExpectError("a{", kInvalidQuantifier);
-  ExpectError("a{z}", kInvalidQuantifier);
-  ExpectError("a{1z}", kInvalidQuantifier);
-  ExpectError("a{12z}", kInvalidQuantifier);
-  ExpectError("a{12,", kInvalidQuantifier);
-  ExpectError("a{12,3b", kInvalidQuantifier);
   const char* kUnterminatedGroup = "Unterminated group";
   ExpectError("(foo", kUnterminatedGroup);
   const char* kInvalidGroup = "Invalid group";
   ExpectError("(?", kInvalidGroup);
   const char* kUnterminatedCharacterClass = "Unterminated character class";
   ExpectError("[", kUnterminatedCharacterClass);
   ExpectError("[a-", kUnterminatedCharacterClass);
   const char* kIllegalCharacterClass = "Illegal character class";
   ExpectError("[a-\\w]", kIllegalCharacterClass);
   const char* kEndControl = "\\c at end of pattern";
   ExpectError("\\c", kEndControl);
+  static char* kNothingToRepeat = "Nothing to repeat";
+  ExpectError("*", kNothingToRepeat);
+  ExpectError("?", kNothingToRepeat);
+  ExpectError("+", kNothingToRepeat);
+  ExpectError("{1}", kNothingToRepeat);
+  ExpectError("{1,2}", kNothingToRepeat);
+  ExpectError("{1,}", kNothingToRepeat);
 }
 
 
 static bool IsDigit(uc16 c) {
   return ('0' <= c && c <= '9');
 }
 
 
 static bool NotDigit(uc16 c) {
   return !IsDigit(c);
@@ skipping 30 matching lines @@
       || (c == '_');
 }
 
 
 static bool NotWord(uc16 c) {
   return !IsWord(c);
 }
 
 
 static bool Dot(uc16 c) {
-  return true;
+  switch (c) {
+    //   CR           LF           LS           PS
+    case 0x000A: case 0x000D: case 0x2028: case 0x2029:
+      return false;
+    default:
+      return true;
+  }
 }
 
 
 static void TestCharacterClassEscapes(uc16 c, bool (pred)(uc16 c)) {
   ZoneScope scope(DELETE_ON_EXIT);
   ZoneList<CharacterRange>* ranges = new ZoneList<CharacterRange>(2);
   CharacterRange::AddClassEscape(c, ranges);
   for (unsigned i = 0; i < (1 << 16); i++) {
     bool in_class = false;
     for (int j = 0; !in_class && j < ranges->length(); j++) {
@@ skipping 458 matching lines @@
   ZoneScope zone_scope(DELETE_ON_EXIT);
   RegExpNode* node = Compile("(a|^b|c)");
   CHECK(node->info()->determine_start);
 }
 
 
 TEST(Graph) {
   V8::Initialize(NULL);
   Execute("(a|^b|c)", "", true);
 }