* Changed string-representation of regexps to handle unprintable chars.

regexp2000/src/parser.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 369 matching lines @@
   LAST(ADD_CHAR);
 }
 
 
 void RegExpBuilder::AddEmpty() {
   pending_empty_ = true;
 }
 
 
 void RegExpBuilder::AddAtom(RegExpTree* term) {
+  if (term->IsEmpty()) {
+    AddEmpty();
+    return;
+  }
   if (term->IsTextElement()) {
     FlushCharacters();
     text_.Add(term);
   } else {
     FlushText();
     terms_.Add(term);
   }
   LAST(ADD_ATOM);
 }
 
@@ skipping 63 matching lines @@
     characters_ = NULL;
     atom = new RegExpAtom(char_vector);
     FlushText();
   } else if (text_.length() > 0) {
     ASSERT(last_added_ == ADD_ATOM);
     atom = text_.RemoveLast();
     FlushText();
   } else if (terms_.length() > 0) {
     ASSERT(last_added_ == ADD_ATOM);
     atom = terms_.RemoveLast();
+    if (atom->IsLookahead() || atom->IsAssertion()) {

[Christian Plesner Hansen, 2008/11/17 10:54:35]

I wonder if this is worthwhile?

[Lasse Reichstein, 2008/11/17 11:26:32]

It probably isn't. It's optimizing the case where the user has written a stupid
RegExp to begin with. It might be worthwhile if the following translations can
ignore the pathological cases.

+      // Guaranteed not to match a non-empty string.
+      // Assertion as an atom can happen as, e.g., (?:\b)
+      LAST(ADD_TERM);
+      if (min == 0) {
+        return;
+      }
+      terms_.Add(atom);
+      return;
+    }
   } else {
     // Only call immediately after adding an atom or character!
     UNREACHABLE();
     return;
   }
   terms_.Add(new RegExpQuantifier(min, max, is_greedy, atom));
   LAST(ADD_TERM);
 }
 
 
@@ skipping 3836 matching lines @@
                        start_position,
                        is_expression);
   return result;
 }
 
 
 #undef NEW
 
 
 } }  // namespace v8::internal