Merge regexp2000 back into bleeding_edge

src/string-stream.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 75 matching lines @@
   switch (c) {
   case '0': case '1': case '2': case '3': case '4': case '5':
   case '6': case '7': case '8': case '9': case '.': case '-':
     return true;
   default:
     return false;
   }
 }
 
 
-void StringStream::Add(const char* format, Vector<FmtElm> elms) {
+void StringStream::Add(Vector<const char> format, Vector<FmtElm> elms) {
   // If we already ran out of space then return immediately.
   if (space() == 0)
     return;
   int offset = 0;
   int elm = 0;
-  while (format[offset] != '\0') {
+  while (offset < format.length()) {
     if (format[offset] != '%' || elm == elms.length()) {
       Put(format[offset]);
       offset++;
       continue;
     }
     // Read this formatting directive into a temporary buffer
     EmbeddedVector<char, 24> temp;
     int format_length = 0;
     // Skip over the whole control character sequence until the
     // format element type
     temp[format_length++] = format[offset++];
-    // '\0' is not a control character so we don't have to
-    // explicitly check for the end of the string
-    while (IsControlChar(format[offset]))
+    while (offset < format.length() && IsControlChar(format[offset]))
       temp[format_length++] = format[offset++];
+    if (offset >= format.length())
+      return;
     char type = format[offset];
-    if (type == '\0') return;
     temp[format_length++] = type;
     temp[format_length] = '\0';
     offset++;
     FmtElm current = elms[elm++];
     switch (type) {
     case 's': {
       ASSERT_EQ(FmtElm::C_STR, current.type_);
       const char* value = current.data_.u_c_str_;
       Add(value);
       break;
     }
+    case 'w': {
+      ASSERT_EQ(FmtElm::LC_STR, current.type_);
+      Vector<const uc16> value = *current.data_.u_lc_str_;
+      for (int i = 0; i < value.length(); i++)
+        Put(static_cast<char>(value[i]));
+      break;
+    }
     case 'o': {
       ASSERT_EQ(FmtElm::OBJ, current.type_);
       Object* obj = current.data_.u_obj_;
       PrintObject(obj);
       break;
     }
-    case 'i': case 'd': case 'u': case 'x': case 'c': case 'p': {
+    case 'k': {
+      ASSERT_EQ(FmtElm::INT, current.type_);
+      int value = current.data_.u_int_;
+      if (0x20 <= value && value <= 0x7F) {
+        Put(value);
+      } else if (value <= 0xff) {
+        Add("\\x%02x", value);
+      } else {
+        Add("\\u%04x", value);
+      }
+      break;
+    }
+    case 'i': case 'd': case 'u': case 'x': case 'c': case 'p': case 'X': {
       int value = current.data_.u_int_;
       EmbeddedVector<char, 24> formatted;
-      OS::SNPrintF(formatted, temp.start(), value);
-      Add(formatted.start());
+      int length = OS::SNPrintF(formatted, temp.start(), value);
+      Add(Vector<const char>(formatted.start(), length));
       break;
     }
     case 'f': case 'g': case 'G': case 'e': case 'E': {
       double value = current.data_.u_double_;
       EmbeddedVector<char, 28> formatted;
       OS::SNPrintF(formatted, temp.start(), value);
       Add(formatted.start());
       break;
     }
     default:
       UNREACHABLE();
       break;
     }
   }
 
-  // Verify that the buffer is 0-terminated and doesn't contain any
-  // other 0-characters.
+  // Verify that the buffer is 0-terminated
   ASSERT(buffer_[length_] == '\0');
-  ASSERT(strlen(buffer_) == length_);
 }
 
 
 void StringStream::PrintObject(Object* o) {
   o->ShortPrint(this);
   if (o->IsString()) {
     if (String::cast(o)->length() <= String::kMaxMediumStringSize) {
       return;
     }
   } else if (o->IsNumber() || o->IsOddball()) {
@@ skipping 10 matching lines @@
       Add("#%d#", debug_object_cache->length());
       debug_object_cache->Add(HeapObject::cast(o));
     } else {
       Add("@%p", o);
     }
   }
 }
 
 
 void StringStream::Add(const char* format) {
+  Add(CStrVector(format));
+}
+
+
+void StringStream::Add(Vector<const char> format) {
   Add(format, Vector<FmtElm>::empty());
 }
 
 
 void StringStream::Add(const char* format, FmtElm arg0) {
   const char argc = 1;
   FmtElm argv[argc] = { arg0 };
-  Add(format, Vector<FmtElm>(argv, argc));
+  Add(CStrVector(format), Vector<FmtElm>(argv, argc));
 }
 
 
 void StringStream::Add(const char* format, FmtElm arg0, FmtElm arg1) {
   const char argc = 2;
   FmtElm argv[argc] = { arg0, arg1 };
-  Add(format, Vector<FmtElm>(argv, argc));
+  Add(CStrVector(format), Vector<FmtElm>(argv, argc));
 }
 
 
 void StringStream::Add(const char* format, FmtElm arg0, FmtElm arg1,
                        FmtElm arg2) {
   const char argc = 3;
   FmtElm argv[argc] = { arg0, arg1, arg2 };
-  Add(format, Vector<FmtElm>(argv, argc));
+  Add(CStrVector(format), Vector<FmtElm>(argv, argc));
+}
+
+
+void StringStream::Add(const char* format, FmtElm arg0, FmtElm arg1,
+                       FmtElm arg2, FmtElm arg3) {
+  const char argc = 4;
+  FmtElm argv[argc] = { arg0, arg1, arg2, arg3 };
+  Add(CStrVector(format), Vector<FmtElm>(argv, argc));
 }
 
 
 SmartPointer<const char> StringStream::ToCString() {
   char* str = NewArray<char>(length_ + 1);
   memcpy(str, buffer_, length_);
   str[length_] = '\0';
   return SmartPointer<const char>(str);
 }
 
@@ skipping 315 matching lines @@
   unsigned new_bytes = *bytes * 2;
   if (new_bytes > size_) {
     new_bytes = size_;
   }
   *bytes = new_bytes;
   return space_;
 }
 
 
 } }  // namespace v8::internal