src/v8/src/extensions/externalize-string-extension.cc

   1 // Copyright 2010 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "externalize-string-extension.h"
   6
   7 namespace v8 {
   8 namespace internal {
   9
  10 template <typename Char, typename Base>
  11 class SimpleStringResource : public Base {
  12  public:
  13   // Takes ownership of |data|.
  14   SimpleStringResource(Char* data, size_t length)
  15       : data_(data),
  16         length_(length) {}
  17
  18   virtual ~SimpleStringResource() { delete[] data_; }
  19
  20   virtual const Char* data() const { return data_; }
  21
  22   virtual size_t length() const { return length_; }
  23
  24  private:
  25   Char* const data_;
  26   const size_t length_;
  27 };
  28
  29
  30 typedef SimpleStringResource<char, v8::String::ExternalAsciiStringResource>
  31     SimpleAsciiStringResource;
  32 typedef SimpleStringResource<uc16, v8::String::ExternalStringResource>
  33     SimpleTwoByteStringResource;
  34
  35
  36 const char* const ExternalizeStringExtension::kSource =
  37     "native function externalizeString();"
  38     "native function isAsciiString();";
  39
  40 v8::Handle<v8::FunctionTemplate>
  41 ExternalizeStringExtension::GetNativeFunctionTemplate(
  42     v8::Isolate* isolate, v8::Handle<v8::String> str) {
  43   if (strcmp(*v8::String::Utf8Value(str), "externalizeString") == 0) {
  44     return v8::FunctionTemplate::New(isolate,
  45                                      ExternalizeStringExtension::Externalize);
  46   } else {
  47     ASSERT(strcmp(*v8::String::Utf8Value(str), "isAsciiString") == 0);
  48     return v8::FunctionTemplate::New(isolate,
  49                                      ExternalizeStringExtension::IsAscii);
  50   }
  51 }
  52
  53
  54 void ExternalizeStringExtension::Externalize(
  55     const v8::FunctionCallbackInfo<v8::Value>& args) {
  56   if (args.Length() < 1 || !args[0]->IsString()) {
  57     args.GetIsolate()->ThrowException(v8::String::NewFromUtf8(
  58         args.GetIsolate(),
  59         "First parameter to externalizeString() must be a string."));
  60     return;
  61   }
  62   bool force_two_byte = false;
  63   if (args.Length() >= 2) {
  64     if (args[1]->IsBoolean()) {
  65       force_two_byte = args[1]->BooleanValue();
  66     } else {
  67       args.GetIsolate()->ThrowException(v8::String::NewFromUtf8(
  68         args.GetIsolate(),
  69         "Second parameter to externalizeString() must be a boolean."));
  70       return;
  71     }
  72   }
  73   bool result = false;
  74   Handle<String> string = Utils::OpenHandle(*args[0].As<v8::String>());
  75   if (string->IsExternalString()) {
  76     args.GetIsolate()->ThrowException(v8::String::NewFromUtf8(
  77         args.GetIsolate(),
  78         "externalizeString() can't externalize twice."));
  79     return;
  80   }
  81   if (string->IsOneByteRepresentation() && !force_two_byte) {
  82     uint8_t* data = new uint8_t[string->length()];
  83     String::WriteToFlat(*string, data, 0, string->length());
  84     SimpleAsciiStringResource* resource = new SimpleAsciiStringResource(
  85         reinterpret_cast<char*>(data), string->length());
  86     result = string->MakeExternal(resource);
  87     if (result) {
  88       i::Isolate* isolate = reinterpret_cast<i::Isolate*>(args.GetIsolate());
  89       isolate->heap()->external_string_table()->AddString(*string);
  90     }
  91     if (!result) delete resource;
  92   } else {
  93     uc16* data = new uc16[string->length()];
  94     String::WriteToFlat(*string, data, 0, string->length());
  95     SimpleTwoByteStringResource* resource = new SimpleTwoByteStringResource(
  96         data, string->length());
  97     result = string->MakeExternal(resource);
  98     if (result) {
  99       i::Isolate* isolate = reinterpret_cast<i::Isolate*>(args.GetIsolate());
 100       isolate->heap()->external_string_table()->AddString(*string);
 101     }
 102     if (!result) delete resource;
 103   }
 104   if (!result) {
 105     args.GetIsolate()->ThrowException(v8::String::NewFromUtf8(
 106         args.GetIsolate(), "externalizeString() failed."));
 107     return;
 108   }
 109 }
 110
 111
 112 void ExternalizeStringExtension::IsAscii(
 113     const v8::FunctionCallbackInfo<v8::Value>& args) {
 114   if (args.Length() != 1 || !args[0]->IsString()) {
 115     args.GetIsolate()->ThrowException(v8::String::NewFromUtf8(
 116         args.GetIsolate(),
 117         "isAsciiString() requires a single string argument."));
 118     return;
 119   }
 120   bool is_one_byte =
 121       Utils::OpenHandle(*args[0].As<v8::String>())->IsOneByteRepresentation();
 122   args.GetReturnValue().Set(is_one_byte);
 123 }
 124
 125 } }  // namespace v8::internal