Remove dependency on Vector from platform files

test/cctest/test-api.cc

 // Copyright 2012 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 168 matching lines @@
   CHECK(env->GetIsolate()->InContext());
   CHECK(env->GetIsolate() == CcTest::isolate());
   env->Exit();
   CHECK(!env->GetIsolate()->InContext());
   CHECK(env->GetIsolate() == CcTest::isolate());
 }
 
 
 static void TestSignature(const char* loop_js, Local<Value> receiver) {
   i::ScopedVector<char> source(200);
-  i::OS::SNPrintF(source,
-                  "for (var i = 0; i < 10; i++) {"
-                  "  %s"
-                  "}",
-                  loop_js);
+  i::SNPrintF(source,
+              "for (var i = 0; i < 10; i++) {"
+              "  %s"
+              "}",
+              loop_js);
   signature_callback_count = 0;
   signature_expected_receiver = receiver;
   bool expected_to_throw = receiver.IsEmpty();
   v8::TryCatch try_catch;
   CompileRun(source.start());
   CHECK_EQ(expected_to_throw, try_catch.HasCaught());
   if (!expected_to_throw) {
     CHECK_EQ(10, signature_callback_count);
   } else {
     CHECK_EQ(v8_str("TypeError: Illegal invocation"),
@@ skipping 52 matching lines @@
       "var obj = {};"
       "copy_props(obj);"
       "var unrel = new UnrelFun();"
       "copy_props(unrel);");
   // Test with and without ICs
   const char* test_objects[] = {
       "fun_instance", "sub_fun_instance", "obj", "unrel" };
   unsigned bad_signature_start_offset = 2;
   for (unsigned i = 0; i < ARRAY_SIZE(test_objects); i++) {
     i::ScopedVector<char> source(200);
-    i::OS::SNPrintF(
+    i::SNPrintF(
         source, "var test_object = %s; test_object", test_objects[i]);
     Local<Value> test_object = CompileRun(source.start());
     TestSignature("test_object.prop();", test_object);
     TestSignature("test_object.accessor;", test_object);
     TestSignature("test_object[accessor_key];", test_object);
     TestSignature("test_object.accessor = 1;", test_object);
     TestSignature("test_object[accessor_key] = 1;", test_object);
     if (i >= bad_signature_start_offset) test_object = Local<Value>();
     TestSignature("test_object.prop_sig();", test_object);
     TestSignature("test_object.accessor_sig;", test_object);
@@ skipping 2797 matching lines @@
 
 static void CheckIsNeutered(v8::Handle<v8::TypedArray> ta) {
   CHECK_EQ(0, static_cast<int>(ta->ByteLength()));
   CHECK_EQ(0, static_cast<int>(ta->Length()));
   CHECK_EQ(0, static_cast<int>(ta->ByteOffset()));
 }
 
 
 static void CheckIsTypedArrayVarNeutered(const char* name) {
   i::ScopedVector<char> source(1024);
-  i::OS::SNPrintF(source,
+  i::SNPrintF(source,
       "%s.byteLength == 0 && %s.byteOffset == 0 && %s.length == 0",
       name, name, name);
   CHECK(CompileRun(source.start())->IsTrue());
   v8::Handle<v8::TypedArray> ta =
     v8::Handle<v8::TypedArray>::Cast(CompileRun(name));
   CheckIsNeutered(ta);
 }
 
 
 template <typename TypedArray, int kElementSize>
@@ skipping 3628 matching lines @@
       Context::New(CcTest::isolate(), &extensions);
   CHECK_EQ(0, *context);
 }
 
 
 TEST(ExtensionWithSourceLength) {
   for (int source_len = kEmbeddedExtensionSourceValidLen - 1;
        source_len <= kEmbeddedExtensionSourceValidLen + 1; ++source_len) {
     v8::HandleScope handle_scope(CcTest::isolate());
     i::ScopedVector<char> extension_name(32);
-    i::OS::SNPrintF(extension_name, "ext #%d", source_len);
+    i::SNPrintF(extension_name, "ext #%d", source_len);
     v8::RegisterExtension(new Extension(extension_name.start(),
                                         kEmbeddedExtensionSource, 0, 0,
                                         source_len));
     const char* extension_names[1] = { extension_name.start() };
     v8::ExtensionConfiguration extensions(1, extension_names);
     v8::Handle<Context> context =
       Context::New(CcTest::isolate(), &extensions);
     if (source_len == kEmbeddedExtensionSourceValidLen) {
       Context::Scope lock(context);
       v8::Handle<Value> result = CompileRun("Ret54321()");
@@ skipping 3557 matching lines @@
   t2->InstanceTemplate()->Set(v8_str("fuz2"), v8_num(2));
   Local<v8::FunctionTemplate> t3 = v8::FunctionTemplate::New(isolate);
   t3->SetHiddenPrototype(true);
   t3->InstanceTemplate()->Set(v8_str("boo"), v8_num(3));
   Local<v8::FunctionTemplate> t4 = v8::FunctionTemplate::New(isolate);
   t4->InstanceTemplate()->Set(v8_str("baz"), v8_num(4));
 
   // Force dictionary-based properties.
   i::ScopedVector<char> name_buf(1024);
   for (int i = 1; i <= 1000; i++) {
-    i::OS::SNPrintF(name_buf, "sdf%d", i);
+    i::SNPrintF(name_buf, "sdf%d", i);
     t2->InstanceTemplate()->Set(v8_str(name_buf.start()), v8_num(2));
   }
 
   Local<v8::Object> o1 = t1->GetFunction()->NewInstance();
   Local<v8::Object> o2 = t2->GetFunction()->NewInstance();
   Local<v8::Object> o3 = t3->GetFunction()->NewInstance();
   Local<v8::Object> o4 = t4->GetFunction()->NewInstance();
 
   // Create prototype chain of hidden prototypes.
   CHECK(o4->SetPrototype(o3));
@@ skipping 5987 matching lines @@
   // The repeated loads and stores ensure the ICs are exercised.
   const char* boundary_program =
       "var res = 0;"
       "for (var i = 0; i < 16; i++) {"
       "  ext_array[i] = %lld;"
       "  if (i > 8) {"
       "    res = ext_array[i];"
       "  }"
       "}"
       "res;";
-  i::OS::SNPrintF(test_buf,
-                  boundary_program,
-                  low);
+  i::SNPrintF(test_buf,
+              boundary_program,
+              low);
   result = CompileRun(test_buf.start());
   CHECK_EQ(low, result->IntegerValue());
 
-  i::OS::SNPrintF(test_buf,
-                  boundary_program,
-                  high);
+  i::SNPrintF(test_buf,
+              boundary_program,
+              high);
   result = CompileRun(test_buf.start());
   CHECK_EQ(high, result->IntegerValue());
 
   // Check misprediction of type in IC.
   result = CompileRun("var tmp_array = ext_array;"
                       "var sum = 0;"
                       "for (var i = 0; i < 8; i++) {"
                       "  tmp_array[i] = i;"
                       "  sum += tmp_array[i];"
                       "  if (i == 4) {"
                       "    tmp_array = {};"
                       "  }"
                       "}"
                       "sum;");
   // Force GC to trigger verification.
   CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
   CHECK_EQ(28, result->Int32Value());
 
   // Make sure out-of-range loads do not throw.
-  i::OS::SNPrintF(test_buf,
-                  "var caught_exception = false;"
-                  "try {"
-                  "  ext_array[%d];"
-                  "} catch (e) {"
-                  "  caught_exception = true;"
-                  "}"
-                  "caught_exception;",
-                  element_count);
+  i::SNPrintF(test_buf,
+              "var caught_exception = false;"
+              "try {"
+              "  ext_array[%d];"
+              "} catch (e) {"
+              "  caught_exception = true;"
+              "}"
+              "caught_exception;",
+              element_count);
   result = CompileRun(test_buf.start());
   CHECK_EQ(false, result->BooleanValue());
 
   // Make sure out-of-range stores do not throw.
-  i::OS::SNPrintF(test_buf,
-                  "var caught_exception = false;"
-                  "try {"
-                  "  ext_array[%d] = 1;"
-                  "} catch (e) {"
-                  "  caught_exception = true;"
-                  "}"
-                  "caught_exception;",
-                  element_count);
+  i::SNPrintF(test_buf,
+              "var caught_exception = false;"
+              "try {"
+              "  ext_array[%d] = 1;"
+              "} catch (e) {"
+              "  caught_exception = true;"
+              "}"
+              "caught_exception;",
+              element_count);
   result = CompileRun(test_buf.start());
   CHECK_EQ(false, result->BooleanValue());
 
   // Check other boundary conditions, values and operations.
   result = CompileRun("for (var i = 0; i < 8; i++) {"
                       "  ext_array[7] = undefined;"
                       "}"
                       "ext_array[7];");
   CHECK_EQ(0, result->Int32Value());
   if (array_type == v8::kExternalFloat64Array ||
@@ skipping 61 matching lines @@
         "var expected_results = [0, 10, 0, -10];";
     const char* pixel_data =
         "var source_data = [0.6, 10.6];"
         "var expected_results = [1, 11];";
     bool is_unsigned =
         (array_type == v8::kExternalUint8Array ||
          array_type == v8::kExternalUint16Array ||
          array_type == v8::kExternalUint32Array);
     bool is_pixel_data = array_type == v8::kExternalUint8ClampedArray;
 
-    i::OS::SNPrintF(test_buf,
-                    "%s"
-                    "var all_passed = true;"
-                    "for (var i = 0; i < source_data.length; i++) {"
-                    "  for (var j = 0; j < 8; j++) {"
-                    "    ext_array[j] = source_data[i];"
-                    "  }"
-                    "  all_passed = all_passed &&"
-                    "               (ext_array[5] == expected_results[i]);"
-                    "}"
-                    "all_passed;",
-                    (is_unsigned ?
-                         unsigned_data :
-                         (is_pixel_data ? pixel_data : signed_data)));
+    i::SNPrintF(test_buf,
+                "%s"
+                "var all_passed = true;"
+                "for (var i = 0; i < source_data.length; i++) {"
+                "  for (var j = 0; j < 8; j++) {"
+                "    ext_array[j] = source_data[i];"
+                "  }"
+                "  all_passed = all_passed &&"
+                "               (ext_array[5] == expected_results[i]);"
+                "}"
+                "all_passed;",
+                (is_unsigned ?
+                     unsigned_data :
+                     (is_pixel_data ? pixel_data : signed_data)));
     result = CompileRun(test_buf.start());
     CHECK_EQ(true, result->BooleanValue());
   }
 
   i::Handle<ExternalArrayClass> array(
       ExternalArrayClass::cast(jsobj->elements()));
   for (int i = 0; i < element_count; i++) {
     array->set(i, static_cast<ElementType>(i));
   }
 
@@ skipping 1060 matching lines @@
     "}\n"
     "function foo() {\n"
     "\n"
     "  bar();\n"
     "}\n"
     "foo();\n"
     "}\n"
     "eval('(' + outer +')()%s');";
 
   i::ScopedVector<char> code(1024);
-  i::OS::SNPrintF(code, source, "//# sourceURL=eval_url");
+  i::SNPrintF(code, source, "//# sourceURL=eval_url");
   CHECK(CompileRun(code.start())->IsUndefined());
-  i::OS::SNPrintF(code, source, "//@ sourceURL=eval_url");
+  i::SNPrintF(code, source, "//@ sourceURL=eval_url");
   CHECK(CompileRun(code.start())->IsUndefined());
 }
 
 
 static int scriptIdInStack[2];
 
 void AnalyzeScriptIdInStack(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::HandleScope scope(args.GetIsolate());
   v8::Handle<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(
@@ skipping 60 matching lines @@
     "}\n"
     "function foo() {\n"
     "\n"
     "  bar();\n"
     "}\n"
     "foo();\n"
     "}\n"
     "outer()\n%s";
 
   i::ScopedVector<char> code(1024);
-  i::OS::SNPrintF(code, source, "//# sourceURL=source_url");
+  i::SNPrintF(code, source, "//# sourceURL=source_url");
   CHECK(CompileRunWithOrigin(code.start(), "url", 0, 1)->IsUndefined());
-  i::OS::SNPrintF(code, source, "//@ sourceURL=source_url");
+  i::SNPrintF(code, source, "//@ sourceURL=source_url");
   CHECK(CompileRunWithOrigin(code.start(), "url", 0, 1)->IsUndefined());
 }
 
 
 void AnalyzeStackOfDynamicScriptWithSourceURL(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::HandleScope scope(args.GetIsolate());
   v8::Handle<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(
       args.GetIsolate(), 10, v8::StackTrace::kDetailed);
   CHECK_EQ(4, stackTrace->GetFrameCount());
@@ skipping 23 matching lines @@
     "}\n"
     "function foo() {\n"
     "\n"
     "  bar();\n"
     "}\n"
     "foo();\n"
     "}\n"
     "outer()\n%s";
 
   i::ScopedVector<char> code(1024);
-  i::OS::SNPrintF(code, source, "//# sourceURL=source_url");
+  i::SNPrintF(code, source, "//# sourceURL=source_url");
   CHECK(CompileRunWithOrigin(code.start(), "url", 0, 0)->IsUndefined());
-  i::OS::SNPrintF(code, source, "//@ sourceURL=source_url");
+  i::SNPrintF(code, source, "//@ sourceURL=source_url");
   CHECK(CompileRunWithOrigin(code.start(), "url", 0, 0)->IsUndefined());
 }
 
 
 TEST(DynamicWithSourceURLInStackTraceString) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
 
   const char *source =
     "function outer() {\n"
     "  function foo() {\n"
     "    FAIL.FAIL;\n"
     "  }\n"
     "  foo();\n"
     "}\n"
     "outer()\n%s";
 
   i::ScopedVector<char> code(1024);
-  i::OS::SNPrintF(code, source, "//# sourceURL=source_url");
+  i::SNPrintF(code, source, "//# sourceURL=source_url");
   v8::TryCatch try_catch;
   CompileRunWithOrigin(code.start(), "", 0, 0);
   CHECK(try_catch.HasCaught());
   v8::String::Utf8Value stack(try_catch.StackTrace());
   CHECK(strstr(*stack, "at foo (source_url:3:5)") != NULL);
 }
 
 
 static void CreateGarbageInOldSpace() {
   i::Factory* factory = CcTest::i_isolate()->factory();
@@ skipping 1717 matching lines @@
     ExpectTrue("function f() { return isDefaultIsolate; }; f()");
   }
 }
 
 
 static int CalcFibonacci(v8::Isolate* isolate, int limit) {
   v8::Isolate::Scope isolate_scope(isolate);
   v8::HandleScope scope(isolate);
   LocalContext context(isolate);
   i::ScopedVector<char> code(1024);
-  i::OS::SNPrintF(code, "function fib(n) {"
-                        "  if (n <= 2) return 1;"
-                        "  return fib(n-1) + fib(n-2);"
-                        "}"
-                        "fib(%d)", limit);
+  i::SNPrintF(code, "function fib(n) {"
+                    "  if (n <= 2) return 1;"
+                    "  return fib(n-1) + fib(n-2);"
+                    "}"
+                    "fib(%d)", limit);
   Local<Value> value = CompileRun(code.start());
   CHECK(value->IsNumber());
   return static_cast<int>(value->NumberValue());
 }
 
 class IsolateThread : public v8::internal::Thread {
  public:
   IsolateThread(v8::Isolate* isolate, int fib_limit)
       : Thread("IsolateThread"),
         isolate_(isolate),
@@ skipping 1186 matching lines @@
 }
 
 
 void RecursiveCall(const v8::FunctionCallbackInfo<v8::Value>& args) {
   int32_t level = args[0]->Int32Value();
   if (level < 3) {
     level++;
     i::OS::Print("Entering recursion level %d.\n", level);
     char script[64];
     i::Vector<char> script_vector(script, sizeof(script));
-    i::OS::SNPrintF(script_vector, "recursion(%d)", level);
+    i::SNPrintF(script_vector, "recursion(%d)", level);
     CompileRun(script_vector.start());
     i::OS::Print("Leaving recursion level %d.\n", level);
     CHECK_EQ(0, callback_fired);
   } else {
     i::OS::Print("Recursion ends.\n");
     CHECK_EQ(0, callback_fired);
   }
 }
 
 
@@ skipping 1045 matching lines @@
 }
 
 
 void CheckCorrectThrow(const char* script) {
   // Test that the script, when wrapped into a try-catch, triggers the catch
   // clause due to failed access check throwing an exception.
   // The subsequent try-catch should run without any exception.
   access_check_fail_thrown = false;
   catch_callback_called = false;
   i::ScopedVector<char> source(1024);
-  i::OS::SNPrintF(source, "try { %s; } catch (e) { catcher(e); }", script);
+  i::SNPrintF(source, "try { %s; } catch (e) { catcher(e); }", script);
   CompileRun(source.start());
   CHECK(access_check_fail_thrown);
   CHECK(catch_callback_called);
 
   access_check_fail_thrown = false;
   catch_callback_called = false;
   CompileRun("try { [1, 2, 3].sort(); } catch (e) { catcher(e) };");
   CHECK(!access_check_fail_thrown);
   CHECK(!catch_callback_called);
 }
@@ skipping 693 matching lines @@
         receiver = Local<Object>::Cast(CompileRun(
           "var receiver_subclass = function_receiver;\n"
           "receiver_subclass"));
       }
     }
     // With no signature, the holder is not set.
     if (signature_type == kNoSignature) holder = receiver;
     // build wrap_function
     i::ScopedVector<char> wrap_function(200);
     if (global) {
-      i::OS::SNPrintF(
+      i::SNPrintF(
           wrap_function,
           "function wrap_f_%d() { var f = g_f; return f(); }\n"
           "function wrap_get_%d() { return this.g_acc; }\n"
           "function wrap_set_%d() { return this.g_acc = 1; }\n",
           key, key, key);
     } else {
-      i::OS::SNPrintF(
+      i::SNPrintF(
           wrap_function,
           "function wrap_f_%d() { return receiver_subclass.f(); }\n"
           "function wrap_get_%d() { return receiver_subclass.acc; }\n"
           "function wrap_set_%d() { return receiver_subclass.acc = 1; }\n",
           key, key, key);
     }
     // build source string
     i::ScopedVector<char> source(1000);
-    i::OS::SNPrintF(
+    i::SNPrintF(
         source,
         "%s\n"  // wrap functions
         "function wrap_f() { return wrap_f_%d(); }\n"
         "function wrap_get() { return wrap_get_%d(); }\n"
         "function wrap_set() { return wrap_set_%d(); }\n"
         "check = function(returned) {\n"
         "  if (returned !== 'returned') { throw returned; }\n"
         "}\n"
         "\n"
         "check(wrap_f());\n"
@@ skipping 349 matching lines @@
     call_eval_context = v8::Context::New(isolate);
     v8::Context::Scope scope(call_eval_context);
     call_eval_bound_function =
         Local<Function>::Cast(CompileRun("eval.bind(this, '1')"));
   }
   env->Global()->Set(v8_str("CallEval"),
       v8::FunctionTemplate::New(isolate, CallEval)->GetFunction());
   Local<Value> result = CompileRun("CallEval();");
   CHECK_EQ(result, v8::Integer::New(isolate, 1));
 }