for (int i = 0; host->h_addr_list[i]; ++i) {
uv_inet_ntop(host->h_addrtype, host->h_addr_list[i], ip, sizeof(ip));
- Local<String> address = String::New(ip);
+ Local<String> address = OneByteString(node_isolate, ip);
addresses->Set(Integer::New(i, node_isolate), address);
}
Local<Array> names = Array::New();
for (int i = 0; host->h_aliases[i]; ++i) {
- Local<String> address = String::New(host->h_aliases[i]);
+ Local<String> address = OneByteString(node_isolate, host->h_aliases[i]);
names->Set(Integer::New(i, node_isolate), address);
}
// A cname lookup always returns a single record but we follow the
// common API here.
Local<Array> result = Array::New(1);
- result->Set(0, String::New(host->h_name));
+ result->Set(0, OneByteString(node_isolate, host->h_name));
ares_free_hostent(host);
this->CallOnComplete(result);
}
Local<Array> mx_records = Array::New();
- Local<String> exchange_symbol = String::NewSymbol("exchange");
- Local<String> priority_symbol = String::NewSymbol("priority");
+ Local<String> exchange_symbol =
+ FIXED_ONE_BYTE_STRING(node_isolate, "exchange");
+ Local<String> priority_symbol =
+ FIXED_ONE_BYTE_STRING(node_isolate, "priority");
+
int i = 0;
for (struct ares_mx_reply* mx_current = mx_start;
mx_current;
mx_current = mx_current->next) {
Local<Object> mx_record = Object::New();
- mx_record->Set(exchange_symbol, String::New(mx_current->host));
+ mx_record->Set(exchange_symbol,
+ OneByteString(node_isolate, mx_current->host));
mx_record->Set(priority_symbol,
Integer::New(mx_current->priority, node_isolate));
mx_records->Set(Integer::New(i++, node_isolate), mx_record);
struct ares_txt_reply *current = txt_out;
for (int i = 0; current; ++i, current = current->next) {
- Local<String> txt = String::New(reinterpret_cast<char*>(current->txt));
+ Local<String> txt = OneByteString(node_isolate, current->txt);
txt_records->Set(Integer::New(i, node_isolate), txt);
}
}
Local<Array> srv_records = Array::New();
- Local<String> name_symbol = String::NewSymbol("name");
- Local<String> port_symbol = String::NewSymbol("port");
- Local<String> priority_symbol = String::NewSymbol("priority");
- Local<String> weight_symbol = String::NewSymbol("weight");
+ Local<String> name_symbol =
+ FIXED_ONE_BYTE_STRING(node_isolate, "name");
+ Local<String> port_symbol =
+ FIXED_ONE_BYTE_STRING(node_isolate, "port");
+ Local<String> priority_symbol =
+ FIXED_ONE_BYTE_STRING(node_isolate, "priority");
+ Local<String> weight_symbol =
+ FIXED_ONE_BYTE_STRING(node_isolate, "weight");
+
int i = 0;
for (struct ares_srv_reply* srv_current = srv_start;
srv_current;
srv_current = srv_current->next) {
Local<Object> srv_record = Object::New();
- srv_record->Set(name_symbol, String::New(srv_current->host));
+ srv_record->Set(name_symbol,
+ OneByteString(node_isolate, srv_current->host));
srv_record->Set(port_symbol,
Integer::New(srv_current->port, node_isolate));
srv_record->Set(priority_symbol,
}
Local<Array> naptr_records = Array::New();
- Local<String> flags_symbol = String::NewSymbol("flags");
- Local<String> service_symbol = String::NewSymbol("service");
- Local<String> regexp_symbol = String::NewSymbol("regexp");
- Local<String> replacement_symbol = String::NewSymbol("replacement");
- Local<String> order_symbol = String::NewSymbol("order");
- Local<String> preference_symbol = String::NewSymbol("preference");
+ Local<String> flags_symbol =
+ FIXED_ONE_BYTE_STRING(node_isolate, "flags");
+ Local<String> service_symbol =
+ FIXED_ONE_BYTE_STRING(node_isolate, "service");
+ Local<String> regexp_symbol =
+ FIXED_ONE_BYTE_STRING(node_isolate, "regexp");
+ Local<String> replacement_symbol =
+ FIXED_ONE_BYTE_STRING(node_isolate, "replacement");
+ Local<String> order_symbol =
+ FIXED_ONE_BYTE_STRING(node_isolate, "order");
+ Local<String> preference_symbol =
+ FIXED_ONE_BYTE_STRING(node_isolate, "preference");
int i = 0;
for (ares_naptr_reply* naptr_current = naptr_start;
Local<Object> naptr_record = Object::New();
naptr_record->Set(flags_symbol,
- String::New(reinterpret_cast<char*>(naptr_current->flags)));
+ OneByteString(node_isolate, naptr_current->flags));
naptr_record->Set(service_symbol,
- String::New(reinterpret_cast<char*>(naptr_current->service)));
+ OneByteString(node_isolate, naptr_current->service));
naptr_record->Set(regexp_symbol,
- String::New(reinterpret_cast<char*>(naptr_current->regexp)));
+ OneByteString(node_isolate, naptr_current->regexp));
naptr_record->Set(replacement_symbol,
- String::New(naptr_current->replacement));
+ OneByteString(node_isolate,
+ naptr_current->replacement));
naptr_record->Set(order_symbol, Integer::New(naptr_current->order,
node_isolate));
naptr_record->Set(preference_symbol,
continue;
// Create JavaScript string
- Local<String> s = String::New(ip);
+ Local<String> s = OneByteString(node_isolate, ip);
results->Set(n, s);
n++;
}
continue;
// Create JavaScript string
- Local<String> s = String::New(ip);
+ Local<String> s = OneByteString(node_isolate, ip);
results->Set(n, s);
n++;
}
int err = uv_inet_ntop(cur->family, caddr, ip, sizeof(ip));
assert(err == 0);
- Local<String> addr = String::New(ip);
+ Local<String> addr = OneByteString(node_isolate, ip);
server_array->Set(i, addr);
}
static void StrError(const FunctionCallbackInfo<Value>& args) {
HandleScope scope(node_isolate);
const char* errmsg = ares_strerror(args[0]->Int32Value());
- args.GetReturnValue().Set(String::New(errmsg));
+ args.GetReturnValue().Set(OneByteString(node_isolate, errmsg));
}
NODE_SET_METHOD(target, "getServers", GetServers);
NODE_SET_METHOD(target, "setServers", SetServers);
- target->Set(String::NewSymbol("AF_INET"),
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "AF_INET"),
Integer::New(AF_INET, node_isolate));
- target->Set(String::NewSymbol("AF_INET6"),
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "AF_INET6"),
Integer::New(AF_INET6, node_isolate));
- target->Set(String::NewSymbol("AF_UNSPEC"),
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "AF_UNSPEC"),
Integer::New(AF_UNSPEC, node_isolate));
- oncomplete_sym = String::New("oncomplete");
+ oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
}
} // namespace cares_wrap
Local<FunctionTemplate> t = FunctionTemplate::New(New);
t->InstanceTemplate()->SetInternalFieldCount(1);
- t->SetClassName(String::NewSymbol("FSEvent"));
+ t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "FSEvent"));
NODE_SET_PROTOTYPE_METHOD(t, "start", Start);
NODE_SET_PROTOTYPE_METHOD(t, "close", Close);
- target->Set(String::New("FSEvent"), t->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "FSEvent"), t->GetFunction());
- change_sym = String::New("change");
- onchange_sym = String::New("onchange");
- rename_sym = String::New("rename");
+ change_sym = FIXED_ONE_BYTE_STRING(node_isolate, "change");
+ onchange_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onchange");
+ rename_sym = FIXED_ONE_BYTE_STRING(node_isolate, "rename");
}
};
if (filename != NULL) {
- argv[2] = String::New(filename);
+ argv[2] = OneByteString(node_isolate, filename);
}
MakeCallback(wrap->object(), onchange_sym, ARRAY_SIZE(argv), argv);
wrap->handle__ = NULL;
if (args[0]->IsFunction()) {
- if (close_sym.IsEmpty() == true) close_sym = String::New("close");
+ if (close_sym.IsEmpty() == true) {
+ close_sym = FIXED_ONE_BYTE_STRING(node_isolate, "close");
+ }
wrap->object()->Set(close_sym, args[0]);
wrap->flags_ |= kCloseCallback;
}
HandleScope scope(node_isolate);
if (immediate_callback_sym.IsEmpty()) {
- immediate_callback_sym = String::New("_immediateCallback");
+ immediate_callback_sym =
+ FIXED_ONE_BYTE_STRING(node_isolate, "_immediateCallback");
}
MakeCallback(process_p, immediate_callback_sym, 0, NULL);
const char *msg,
const char *path) {
Local<Value> e;
- Local<String> estring = String::NewSymbol(errno_string(errorno));
+ Local<String> estring = OneByteString(node_isolate, errno_string(errorno));
if (msg == NULL || msg[0] == '\0') {
msg = strerror(errorno);
}
- Local<String> message = String::NewSymbol(msg);
+ Local<String> message = OneByteString(node_isolate, msg);
- Local<String> cons1 = String::Concat(estring, String::NewSymbol(", "));
+ Local<String> cons1 =
+ String::Concat(estring, FIXED_ONE_BYTE_STRING(node_isolate, ", "));
Local<String> cons2 = String::Concat(cons1, message);
if (syscall_symbol.IsEmpty()) {
- syscall_symbol = String::New("syscall");
- errno_symbol = String::New("errno");
- errpath_symbol = String::New("path");
- code_symbol = String::New("code");
+ syscall_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "syscall");
+ errno_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "errno");
+ errpath_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "path");
+ code_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "code");
}
if (path) {
- Local<String> cons3 = String::Concat(cons2, String::NewSymbol(" '"));
- Local<String> cons4 = String::Concat(cons3, String::New(path));
- Local<String> cons5 = String::Concat(cons4, String::NewSymbol("'"));
+ Local<String> cons3 =
+ String::Concat(cons2, FIXED_ONE_BYTE_STRING(node_isolate, " '"));
+ Local<String> cons4 =
+ String::Concat(cons3, String::NewFromUtf8(node_isolate, path));
+ Local<String> cons5 =
+ String::Concat(cons4, FIXED_ONE_BYTE_STRING(node_isolate, "'"));
e = Exception::Error(cons5);
} else {
e = Exception::Error(cons2);
obj->Set(errno_symbol, Integer::New(errorno, node_isolate));
obj->Set(code_symbol, estring);
- if (path) obj->Set(errpath_symbol, String::New(path));
- if (syscall) obj->Set(syscall_symbol, String::NewSymbol(syscall));
+ if (path) obj->Set(errpath_symbol, String::NewFromUtf8(node_isolate, path));
+ if (syscall) obj->Set(syscall_symbol, OneByteString(node_isolate, syscall));
return e;
}
const char *msg,
const char *path) {
if (syscall_symbol.IsEmpty()) {
- syscall_symbol = String::New("syscall");
- errno_symbol = String::New("errno");
- errpath_symbol = String::New("path");
- code_symbol = String::New("code");
+ syscall_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "syscall");
+ errno_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "errno");
+ errpath_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "path");
+ code_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "code");
}
if (!msg || !msg[0])
msg = uv_strerror(errorno);
- Local<String> estring = String::NewSymbol(uv_err_name(errorno));
- Local<String> message = String::NewSymbol(msg);
- Local<String> cons1 = String::Concat(estring, String::NewSymbol(", "));
+ Local<String> estring = OneByteString(node_isolate, uv_err_name(errorno));
+ Local<String> message = OneByteString(node_isolate, msg);
+ Local<String> cons1 =
+ String::Concat(estring, FIXED_ONE_BYTE_STRING(node_isolate, ", "));
Local<String> cons2 = String::Concat(cons1, message);
Local<Value> e;
if (path) {
#ifdef _WIN32
if (strncmp(path, "\\\\?\\UNC\\", 8) == 0) {
- path_str = String::Concat(String::New("\\\\"), String::New(path + 8));
+ path_str = String::Concat(FIXED_ONE_BYTE_STRING(node_isolate, "\\\\"),
+ String::NewFromUtf8(node_isolate, path + 8));
} else if (strncmp(path, "\\\\?\\", 4) == 0) {
- path_str = String::New(path + 4);
+ path_str = String::NewFromUtf8(node_isolate, path + 4);
} else {
- path_str = String::New(path);
+ path_str = String::NewFromUtf8(node_isolate, path);
}
#else
- path_str = String::New(path);
+ path_str = String::NewFromUtf8(node_isolate, path);
#endif
- Local<String> cons3 = String::Concat(cons2, String::NewSymbol(" '"));
- Local<String> cons4 = String::Concat(cons3, path_str);
- Local<String> cons5 = String::Concat(cons4, String::NewSymbol("'"));
+ Local<String> cons3 =
+ String::Concat(cons2, FIXED_ONE_BYTE_STRING(node_isolate, " '"));
+ Local<String> cons4 =
+ String::Concat(cons3, path_str);
+ Local<String> cons5 =
+ String::Concat(cons4, FIXED_ONE_BYTE_STRING(node_isolate, "'"));
e = Exception::Error(cons5);
} else {
e = Exception::Error(cons2);
obj->Set(errno_symbol, Integer::New(errorno, node_isolate));
obj->Set(code_symbol, estring);
if (path) obj->Set(errpath_symbol, path_str);
- if (syscall) obj->Set(syscall_symbol, String::NewSymbol(syscall));
+ if (syscall) obj->Set(syscall_symbol, OneByteString(node_isolate, syscall));
return e;
}
if (!msg || !msg[0]) {
msg = winapi_strerror(errorno);
}
- Local<String> message = String::NewSymbol(msg);
+ Local<String> message = OneByteString(node_isolate, msg);
if (syscall_symbol.IsEmpty()) {
- syscall_symbol = String::New("syscall");
- errno_symbol = String::New("errno");
- errpath_symbol = String::New("path");
- code_symbol = String::New("code");
+ syscall_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "syscall");
+ errno_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "errno");
+ errpath_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "path");
+ code_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "code");
}
if (path) {
- Local<String> cons1 = String::Concat(message, String::NewSymbol(" '"));
- Local<String> cons2 = String::Concat(cons1, String::New(path));
- Local<String> cons3 = String::Concat(cons2, String::NewSymbol("'"));
+ Local<String> cons1 =
+ String::Concat(message, FIXED_ONE_BYTE_STRING(node_isolate, " '"));
+ Local<String> cons2 =
+ String::Concat(cons1, String::NewFromUtf8(node_isolate, path));
+ Local<String> cons3 =
+ String::Concat(cons2, FIXED_ONE_BYTE_STRING(node_isolate, "'"));
e = Exception::Error(cons3);
} else {
e = Exception::Error(message);
Local<Object> obj = e->ToObject();
obj->Set(errno_symbol, Integer::New(errorno, node_isolate));
- if (path) obj->Set(errpath_symbol, String::New(path));
- if (syscall) obj->Set(syscall_symbol, String::NewSymbol(syscall));
+ if (path) obj->Set(errpath_symbol, String::NewFromUtf8(node_isolate, path));
+ if (syscall) obj->Set(syscall_symbol, OneByteString(node_isolate, syscall));
return e;
}
#endif
HandleScope scope(node_isolate);
using_domains = true;
Local<Object> process = PersistentToLocal(node_isolate, process_p);
- Local<Value> tdc_v = process->Get(String::New("_tickDomainCallback"));
- Local<Value> ndt_v = process->Get(String::New("_nextDomainTick"));
+ Local<Value> tdc_v =
+ process->Get(FIXED_ONE_BYTE_STRING(node_isolate, "_tickDomainCallback"));
+ Local<Value> ndt_v =
+ process->Get(FIXED_ONE_BYTE_STRING(node_isolate, "_nextDomainTick"));
if (!tdc_v->IsFunction()) {
fprintf(stderr, "process._tickDomainCallback assigned to non-function\n");
abort();
}
Local<Function> tdc = tdc_v.As<Function>();
Local<Function> ndt = ndt_v.As<Function>();
- process->Set(String::New("_tickCallback"), tdc);
- process->Set(String::New("nextTick"), ndt);
+ process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "_tickCallback"), tdc);
+ process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "nextTick"), ndt);
process_tickCallback.Reset(node_isolate, tdc);
}
// lazy load domain specific symbols
if (enter_symbol.IsEmpty()) {
- enter_symbol = String::New("enter");
- exit_symbol = String::New("exit");
- disposed_symbol = String::New("_disposed");
+ enter_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "enter");
+ exit_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "exit");
+ disposed_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "_disposed");
}
Local<Value> domain_v = object->Get(domain_symbol);
// lazy load no domain next tick callbacks
if (process_tickCallback.IsEmpty()) {
- Local<Value> cb_v = process->Get(String::New("_tickCallback"));
+ Local<Value> cb_v =
+ process->Get(FIXED_ONE_BYTE_STRING(node_isolate, "_tickCallback"));
if (!cb_v->IsFunction()) {
fprintf(stderr, "process._tickCallback assigned to non-function\n");
abort();
Handle<Value> argv[]) {
HandleScope scope(node_isolate);
- Handle<Value> ret =
- MakeCallback(object, String::NewSymbol(method), argc, argv);
+ Local<String> method_string = OneByteString(node_isolate, method);
+ Handle<Value> ret = MakeCallback(object, method_string, argc, argv);
return scope.Close(ret);
}
DisplayExceptionLine(message);
- Local<Value> trace_value(er->ToObject()->Get(String::New("stack")));
+ Local<Value> trace_value(
+ er->ToObject()->Get(FIXED_ONE_BYTE_STRING(node_isolate, "stack")));
String::Utf8Value trace(trace_value);
// range errors have a trace member set to undefined
// this really only happens for RangeErrors, since they're the only
// kind that won't have all this info in the trace, or when non-Error
// objects are thrown manually.
- bool isErrorObject = er->IsObject() &&
- !(er->ToObject()->Get(String::New("message"))->IsUndefined()) &&
- !(er->ToObject()->Get(String::New("name"))->IsUndefined());
+ Local<Value> message;
+ Local<Value> name;
- if (isErrorObject) {
- String::Utf8Value name(er->ToObject()->Get(String::New("name")));
- fprintf(stderr, "%s: ", *name);
+ if (er->IsObject()) {
+ Local<Object> err_obj = er.As<Object>();
+ message = err_obj->Get(FIXED_ONE_BYTE_STRING(node_isolate, "message"));
+ name = err_obj->Get(FIXED_ONE_BYTE_STRING(node_isolate, "name"));
}
- String::Utf8Value msg(!isErrorObject ? er
- : er->ToObject()->Get(String::New("message")));
- fprintf(stderr, "%s\n", *msg);
+ if (message.IsEmpty() ||
+ message->IsUndefined() ||
+ name.IsEmpty() ||
+ name->IsUndefined()) {
+ // Not an error object. Just print as-is.
+ String::Utf8Value message(er);
+ fprintf(stderr, "%s\n", *message);
+ } else {
+ String::Utf8Value name_string(name);
+ String::Utf8Value message_string(message);
+ fprintf(stderr, "%s: %s\n", *name_string, *message_string);
+ }
}
fflush(stderr);
QUEUE* q = NULL;
int i = 0;
- Local<String> owner_sym = String::New("owner");
+ Local<String> owner_sym = FIXED_ONE_BYTE_STRING(node_isolate, "owner");
QUEUE_FOREACH(q, &handle_wrap_queue) {
HandleWrap* w = container_of(q, HandleWrap, handle_wrap_queue_);
}
buf[ARRAY_SIZE(buf) - 1] = '\0';
- Local<String> cwd = String::New(buf);
+ Local<String> cwd = String::NewFromUtf8(node_isolate, buf);
args.GetReturnValue().Set(cwd);
}
Local<Object> info = Object::New();
if (rss_symbol.IsEmpty()) {
- rss_symbol = String::New("rss");
- heap_total_symbol = String::New("heapTotal");
- heap_used_symbol = String::New("heapUsed");
+ rss_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "rss");
+ heap_total_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "heapTotal");
+ heap_used_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "heapUsed");
}
info->Set(rss_symbol, Number::New(rss));
String::Utf8Value filename(args[1]); // Cast
if (exports_symbol.IsEmpty()) {
- exports_symbol = String::New("exports");
+ exports_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "exports");
}
Local<Object> exports = module->Get(exports_symbol)->ToObject();
if (uv_dlopen(*filename, &lib)) {
- Local<String> errmsg = String::New(uv_dlerror(&lib));
+ Local<String> errmsg = OneByteString(node_isolate, uv_dlerror(&lib));
#ifdef _WIN32
// Windows needs to add the filename into the error message
errmsg = String::Concat(errmsg, args[1]->ToString());
void FatalException(Handle<Value> error, Handle<Message> message) {
HandleScope scope(node_isolate);
- if (fatal_exception_symbol.IsEmpty())
- fatal_exception_symbol = String::New("_fatalException");
+ if (fatal_exception_symbol.IsEmpty()) {
+ fatal_exception_symbol =
+ FIXED_ONE_BYTE_STRING(node_isolate, "_fatalException");
+ }
Local<Object> process = PersistentToLocal(node_isolate, process_p);
Local<Value> fatal_v = process->Get(fatal_exception_symbol);
Local<Array> modules = PersistentToLocal(node_isolate, module_load_list);
uint32_t l = modules->Length();
- modules->Set(l, String::New(buf));
+ modules->Set(l, OneByteString(node_isolate, buf));
if ((modp = get_builtin_module(*module_v)) != NULL) {
exports = Object::New();
HandleScope scope(node_isolate);
char buffer[512];
uv_get_process_title(buffer, sizeof(buffer));
- info.GetReturnValue().Set(String::New(buffer));
+ info.GetReturnValue().Set(String::NewFromUtf8(node_isolate, buffer));
}
String::Utf8Value key(property);
const char* val = getenv(*key);
if (val) {
- return info.GetReturnValue().Set(String::New(val));
+ return info.GetReturnValue().Set(String::NewFromUtf8(node_isolate, val));
}
#else // _WIN32
String::Value key(property);
// not found.
if ((result > 0 || GetLastError() == ERROR_SUCCESS) &&
result < ARRAY_SIZE(buffer)) {
- return info.GetReturnValue().Set(
- String::New(reinterpret_cast<uint16_t*>(buffer), result));
+ const uint16_t* two_byte_buffer = reinterpret_cast<const uint16_t*>(buffer);
+ Local<String> rc = String::NewFromTwoByte(node_isolate, two_byte_buffer);
+ return info.GetReturnValue().Set(rc);
}
#endif
// Not found. Fetch from prototype.
const char* var = environ[i];
const char* s = strchr(var, '=');
const int length = s ? s - var : strlen(var);
- env->Set(i, String::New(var, length));
+ Local<String> name = String::NewFromUtf8(node_isolate,
+ var,
+ String::kNormalString,
+ length);
+ env->Set(i, name);
}
#else // _WIN32
WCHAR* environment = GetEnvironmentStringsW();
if (!s) {
s = p + wcslen(p);
}
- env->Set(i++, String::New(reinterpret_cast<uint16_t*>(p), s - p));
+ const uint16_t* two_byte_buffer = reinterpret_cast<const uint16_t*>(p);
+ env->Set(i++, TWO_BYTE_STRING(node_isolate, two_byte_buffer, s - p));
p = s + wcslen(s) + 1;
}
FreeEnvironmentStringsW(environment);
Local<Value> debug = False(node_isolate);
#endif // defined(DEBUG) && DEBUG
- obj->Set(String::NewSymbol("debug"), debug);
+ obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "debug"), debug);
- obj->Set(String::NewSymbol("uv"), True(node_isolate));
+ obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "uv"), True(node_isolate));
// TODO(bnoordhuis) ping libuv
- obj->Set(String::NewSymbol("ipv6"), True(node_isolate));
- obj->Set(String::NewSymbol("tls_npn"), Boolean::New(use_npn));
- obj->Set(String::NewSymbol("tls_sni"), Boolean::New(use_sni));
- obj->Set(String::NewSymbol("tls"),
- Boolean::New(get_builtin_module("crypto") != NULL));
+ obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "ipv6"), True(node_isolate));
+
+ obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "tls_npn"),
+ Boolean::New(use_npn));
+ obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "tls_sni"),
+ Boolean::New(use_sni));
+ obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "tls"),
+ Boolean::New(get_builtin_module("crypto") != NULL));
return scope.Close(obj);
}
#define READONLY_PROPERTY(obj, str, var) \
do { \
- obj->Set(String::New(str), var, v8::ReadOnly); \
+ obj->Set(OneByteString(node_isolate, str), var, v8::ReadOnly); \
} while (0)
int i, j;
Local<FunctionTemplate> process_template = FunctionTemplate::New();
- process_template->SetClassName(String::New("process"));
+ process_template->SetClassName(
+ FIXED_ONE_BYTE_STRING(node_isolate, "process"));
Local<Object> process = process_template->GetFunction()->NewInstance();
assert(process.IsEmpty() == false);
process_p.Reset(node_isolate, process);
- process->SetAccessor(String::New("title"),
+ process->SetAccessor(FIXED_ONE_BYTE_STRING(node_isolate, "title"),
ProcessTitleGetter,
ProcessTitleSetter);
// process.version
- READONLY_PROPERTY(process, "version", String::New(NODE_VERSION));
+ READONLY_PROPERTY(process,
+ "version",
+ FIXED_ONE_BYTE_STRING(node_isolate, NODE_VERSION));
// process.moduleLoadList
Local<Array> modules = Array::New();
// process.versions
Local<Object> versions = Object::New();
READONLY_PROPERTY(process, "versions", versions);
- READONLY_PROPERTY(versions, "http_parser", String::New(
- NODE_STRINGIFY(HTTP_PARSER_VERSION_MAJOR) "."
- NODE_STRINGIFY(HTTP_PARSER_VERSION_MINOR)));
+
+ const char http_parser_version[] = NODE_STRINGIFY(HTTP_PARSER_VERSION_MAJOR)
+ "."
+ NODE_STRINGIFY(HTTP_PARSER_VERSION_MINOR);
+ READONLY_PROPERTY(versions,
+ "http_parser",
+ FIXED_ONE_BYTE_STRING(node_isolate, http_parser_version));
+
// +1 to get rid of the leading 'v'
- READONLY_PROPERTY(versions, "node", String::New(NODE_VERSION+1));
- READONLY_PROPERTY(versions, "v8", String::New(V8::GetVersion()));
- READONLY_PROPERTY(versions, "uv", String::New(uv_version_string()));
- READONLY_PROPERTY(versions, "zlib", String::New(ZLIB_VERSION));
+ READONLY_PROPERTY(versions,
+ "node",
+ OneByteString(node_isolate, NODE_VERSION + 1));
+ READONLY_PROPERTY(versions,
+ "v8",
+ OneByteString(node_isolate, V8::GetVersion()));
+ READONLY_PROPERTY(versions,
+ "uv",
+ OneByteString(node_isolate, uv_version_string()));
+ READONLY_PROPERTY(versions,
+ "zlib",
+ FIXED_ONE_BYTE_STRING(node_isolate, ZLIB_VERSION));
+
+ const char node_modules_version[] = NODE_STRINGIFY(NODE_MODULE_VERSION);
READONLY_PROPERTY(versions,
"modules",
- String::New(NODE_STRINGIFY(NODE_MODULE_VERSION)));
+ FIXED_ONE_BYTE_STRING(node_isolate, node_modules_version));
+
#if HAVE_OPENSSL
// Stupid code to slice out the version string.
int c, l = strlen(OPENSSL_VERSION_TEXT);
break;
}
}
- READONLY_PROPERTY(versions,
- "openssl",
- String::New(&OPENSSL_VERSION_TEXT[i], j - i));
+ READONLY_PROPERTY(
+ versions,
+ "openssl",
+ OneByteString(node_isolate, &OPENSSL_VERSION_TEXT[i], j - i));
#endif
// process.arch
- READONLY_PROPERTY(process, "arch", String::New(ARCH));
+ READONLY_PROPERTY(process, "arch", OneByteString(node_isolate, ARCH));
// process.platform
- READONLY_PROPERTY(process, "platform", String::New(PLATFORM));
+ READONLY_PROPERTY(process,
+ "platform",
+ OneByteString(node_isolate, PLATFORM));
// process.argv
Local<Array> arguments = Array::New(argc - option_end_index + 1);
- arguments->Set(Integer::New(0, node_isolate), String::New(argv[0]));
+ arguments->Set(0, String::NewFromUtf8(node_isolate, argv[0]));
for (j = 1, i = option_end_index; i < argc; j++, i++) {
- Local<String> arg = String::New(argv[i]);
- arguments->Set(Integer::New(j, node_isolate), arg);
+ arguments->Set(j, String::NewFromUtf8(node_isolate, argv[i]));
}
- // assign it
- process->Set(String::NewSymbol("argv"), arguments);
+ process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "argv"), arguments);
// process.execArgv
- Local<Array> execArgv = Array::New(option_end_index - 1);
+ Local<Array> exec_argv = Array::New(option_end_index - 1);
for (j = 1, i = 0; j < option_end_index; j++, i++) {
- execArgv->Set(Integer::New(i, node_isolate), String::New(argv[j]));
+ exec_argv->Set(i, String::NewFromUtf8(node_isolate, argv[j]));
}
- // assign it
- process->Set(String::NewSymbol("execArgv"), execArgv);
-
+ process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "execArgv"), exec_argv);
// create process.env
Local<ObjectTemplate> envTemplate = ObjectTemplate::New();
EnvEnumerator,
Object::New());
Local<Object> env = envTemplate->NewInstance();
- process->Set(String::NewSymbol("env"), env);
+ process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "env"), env);
READONLY_PROPERTY(process, "pid", Integer::New(getpid(), node_isolate));
READONLY_PROPERTY(process, "features", GetFeatures());
- process->SetAccessor(String::New("_needImmediateCallback"),
- NeedImmediateCallbackGetter,
- NeedImmediateCallbackSetter);
+ process->SetAccessor(
+ FIXED_ONE_BYTE_STRING(node_isolate, "_needImmediateCallback"),
+ NeedImmediateCallbackGetter,
+ NeedImmediateCallbackSetter);
// -e, --eval
if (eval_string) {
- READONLY_PROPERTY(process, "_eval", String::New(eval_string));
+ READONLY_PROPERTY(process,
+ "_eval",
+ String::NewFromUtf8(node_isolate, eval_string));
}
// -p, --print
READONLY_PROPERTY(process, "traceDeprecation", True(node_isolate));
}
- size_t size = 2*PATH_MAX;
- char* execPath = new char[size];
- if (uv_exepath(execPath, &size) != 0) {
- // as a last ditch effort, fallback on argv[0] ?
- process->Set(String::NewSymbol("execPath"), String::New(argv[0]));
+ size_t exec_path_len = 2 * PATH_MAX;
+ char* exec_path = new char[exec_path_len];
+ Local<String> exec_path_value;
+ if (uv_exepath(exec_path, &exec_path_len) == 0) {
+ exec_path_value = String::NewFromUtf8(node_isolate,
+ exec_path,
+ String::kNormalString,
+ exec_path_len);
} else {
- process->Set(String::NewSymbol("execPath"), String::New(execPath, size));
+ exec_path_value = String::NewFromUtf8(node_isolate, argv[0]);
}
- delete [] execPath;
+ process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "execPath"),
+ exec_path_value);
+ delete[] exec_path;
- process->SetAccessor(String::New("debugPort"),
+ process->SetAccessor(FIXED_ONE_BYTE_STRING(node_isolate, "debugPort"),
DebugPortGetter,
DebugPortSetter);
-
// define various internal methods
NODE_SET_METHOD(process, "_getActiveRequests", GetActiveRequests);
NODE_SET_METHOD(process, "_getActiveHandles", GetActiveHandles);
info_box->SetIndexedPropertiesToExternalArrayData(&tick_infobox,
kExternalUnsignedIntArray,
4);
- process->Set(String::NewSymbol("_tickInfoBox"), info_box);
+ process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "_tickInfoBox"), info_box);
// pre-set _events object for faster emit checks
- process->Set(String::NewSymbol("_events"), Object::New());
+ process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "_events"), Object::New());
return scope.Close(process);
}
void Load(Handle<Object> process_l) {
HandleScope handle_scope(node_isolate);
- process_symbol = String::New("process");
- domain_symbol = String::New("domain");
+ process_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "process");
+ domain_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "domain");
// Compile, execute the src/node.js file. (Which was included as static C
// string in node_natives.h. 'natve_node' is the string containing that
// are not safe to ignore.
try_catch.SetVerbose(false);
- Local<Value> f_value = ExecuteString(MainSource(), String::New("node.js"));
+ Local<String> script_name = FIXED_ONE_BYTE_STRING(node_isolate, "node.js");
+ Local<Value> f_value = ExecuteString(MainSource(), script_name);
if (try_catch.HasCaught()) {
ReportException(try_catch);
exit(10);
static void EmitDebugEnabledAsyncCallback(uv_async_t* handle, int status) {
HandleScope handle_scope(node_isolate);
Local<Object> obj = Object::New();
- obj->Set(String::New("cmd"), String::New("NODE_DEBUG_ENABLED"));
- Local<Value> args[] = { String::New("internalMessage"), obj };
+ obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "cmd"),
+ FIXED_ONE_BYTE_STRING(node_isolate, "NODE_DEBUG_ENABLED"));
+ Local<Value> args[] = {
+ FIXED_ONE_BYTE_STRING(node_isolate, "internalMessage"),
+ obj
+ };
MakeCallback(process_p, "emit", ARRAY_SIZE(args), args);
}
void EmitExit(v8::Handle<v8::Object> process_l) {
// process.emit('exit')
- process_l->Set(String::NewSymbol("_exiting"), True(node_isolate));
- Local<Value> args[] = { String::New("exit"), Integer::New(0, node_isolate) };
+ process_l->Set(FIXED_ONE_BYTE_STRING(node_isolate, "_exiting"),
+ True(node_isolate));
+ Local<Value> args[] = {
+ FIXED_ONE_BYTE_STRING(node_isolate, "exit"),
+ Integer::New(0, node_isolate)
+ };
MakeCallback(process_l, "emit", ARRAY_SIZE(args), args);
}
#define NODE_UNIXTIME_V8(t) v8::Date::New(1000*static_cast<double>(t))
#define NODE_V8_UNIXTIME(v) (static_cast<double>((v)->NumberValue())/1000.0);
-#define NODE_DEFINE_CONSTANT(target, constant) \
- (target)->Set(v8::String::NewSymbol(#constant), \
- v8::Number::New(constant), \
- static_cast<v8::PropertyAttribute>( \
- v8::ReadOnly|v8::DontDelete))
+// Used to be a macro, hence the uppercase name.
+#define NODE_DEFINE_CONSTANT(target, constant) \
+ do { \
+ v8::Isolate* isolate = v8::Isolate::GetCurrent(); \
+ v8::Local<v8::String> constant_name = \
+ v8::String::NewFromUtf8(isolate, #constant); \
+ v8::Local<v8::Number> constant_value = \
+ v8::Number::New(isolate, static_cast<double>(constant)); \
+ v8::PropertyAttribute constant_attributes = \
+ static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete); \
+ (target)->Set(constant_name, constant_value, constant_attributes); \
+ } \
+ while (0)
// Used to be a macro, hence the uppercase name.
template <typename TypeName>
inline void NODE_SET_METHOD(const TypeName& recv,
const char* name,
v8::FunctionCallback callback) {
+ v8::Isolate* isolate = v8::Isolate::GetCurrent();
+ v8::HandleScope handle_scope(isolate);
v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(callback);
v8::Local<v8::Function> fn = t->GetFunction();
- v8::Local<v8::String> fn_name = v8::String::New(name);
+ v8::Local<v8::String> fn_name = v8::String::NewFromUtf8(isolate, name);
fn->SetName(fn_name);
recv->Set(fn_name, fn);
}
inline void NODE_SET_PROTOTYPE_METHOD(v8::Handle<v8::FunctionTemplate> recv,
const char* name,
v8::FunctionCallback callback) {
+ v8::Isolate* isolate = v8::Isolate::GetCurrent();
+ v8::HandleScope handle_scope(isolate);
v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(callback);
- recv->PrototypeTemplate()->Set(v8::String::New(name), t->GetFunction());
+ recv->PrototypeTemplate()->Set(v8::String::NewFromUtf8(isolate, name),
+ t->GetFunction());
}
#define NODE_SET_PROTOTYPE_METHOD node::NODE_SET_PROTOTYPE_METHOD
Local<Function> bv = args[0].As<Function>();
p_buffer_fn.Reset(node_isolate, bv);
- Local<Value> proto_v = bv->Get(String::New("prototype"));
+ Local<Value> proto_v =
+ bv->Get(FIXED_ONE_BYTE_STRING(node_isolate, "prototype"));
assert(proto_v->IsObject());
Local<Object> proto = proto_v.As<Object>();
- bv->Set(String::New("byteLength"),
+ bv->Set(FIXED_ONE_BYTE_STRING(node_isolate, "byteLength"),
FunctionTemplate::New(ByteLength)->GetFunction());
NODE_SET_METHOD(proto, "asciiSlice", AsciiSlice);
NODE_SET_METHOD(proto, "fill", Fill);
// for backwards compatibility
- proto->Set(String::New("offset"), Uint32::New(0, node_isolate), v8::ReadOnly);
+ proto->Set(FIXED_ONE_BYTE_STRING(node_isolate, "offset"),
+ Uint32::New(0, node_isolate),
+ v8::ReadOnly);
}
void Initialize(Handle<Object> target) {
HandleScope scope(node_isolate);
- target->Set(String::New("setupBufferJS"),
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "setupBufferJS"),
FunctionTemplate::New(SetupBufferJS)->GetFunction());
}
};
for (int i = 0; i < ARRAY_SIZE(tab); i++) {
- Local<String> key = String::New(tab[i].name);
+ Local<String> key = OneByteString(node_isolate, tab[i].name);
Local<Value> val = FunctionTemplate::New(tab[i].func)->GetFunction();
target->Set(key, val);
}
secure_context_constructor.Reset(node_isolate, t);
t->InstanceTemplate()->SetInternalFieldCount(1);
- t->SetClassName(String::NewSymbol("SecureContext"));
+ t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "SecureContext"));
NODE_SET_PROTOTYPE_METHOD(t, "init", SecureContext::Init);
NODE_SET_PROTOTYPE_METHOD(t, "setKey", SecureContext::SetKey);
NODE_SET_PROTOTYPE_METHOD(t, "getTicketKeys", SecureContext::GetTicketKeys);
NODE_SET_PROTOTYPE_METHOD(t, "setTicketKeys", SecureContext::SetTicketKeys);
- target->Set(String::NewSymbol("SecureContext"), t->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "SecureContext"),
+ t->GetFunction());
}
};
if (onnewsession_sym.IsEmpty()) {
- onnewsession_sym = String::New("onnewsession");
+ onnewsession_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onnewsession");
}
MakeCallback(p->handle(node_isolate),
bio = BIO_new(BIO_s_mem());
if (bio == NULL) {
- message = String::New("SSL_CTX_set_session_id_context error");
+ message = FIXED_ONE_BYTE_STRING(node_isolate,
+ "SSL_CTX_set_session_id_context error");
} else {
ERR_print_errors(bio);
BIO_get_mem_ptr(bio, &mem);
- message = String::New(mem->data, mem->length);
+ message = OneByteString(node_isolate, mem->data, mem->length);
BIO_free_all(bio);
}
Connection* c = static_cast<Connection*>(arg);
if (onclienthello_sym.IsEmpty())
- onclienthello_sym = String::New("onclienthello");
+ onclienthello_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onclienthello");
if (sessionid_sym.IsEmpty())
- sessionid_sym = String::New("sessionId");
+ sessionid_sym = FIXED_ONE_BYTE_STRING(node_isolate, "sessionId");
Local<Object> obj = Object::New();
obj->Set(sessionid_sym,
ERR_error_string_n(rv, ssl_error_buf, sizeof(ssl_error_buf));
HandleScope scope(node_isolate);
- Local<Value> e = Exception::Error(String::New(ssl_error_buf));
- handle(node_isolate)->Set(String::New("error"), e);
+ Local<Value> exception =
+ Exception::Error(OneByteString(node_isolate, ssl_error_buf));
+ handle(node_isolate)->Set(
+ FIXED_ONE_BYTE_STRING(node_isolate, "error"), exception);
DEBUG_PRINT("[%p] BIO: %s failed: (%d) %s\n",
ssl_,
return 0;
} else if (err == SSL_ERROR_ZERO_RETURN) {
- handle(node_isolate)->Set(String::New("error"),
- Exception::Error(String::New("ZERO_RETURN")));
+ Local<Value> exception =
+ Exception::Error(FIXED_ONE_BYTE_STRING(node_isolate, "ZERO_RETURN"));
+ handle(node_isolate)->Set(
+ FIXED_ONE_BYTE_STRING(node_isolate, "error"), exception);
return rv;
} else if ((err == SSL_ERROR_SYSCALL) && (ss == kIgnoreSyscall)) {
if ((bio = BIO_new(BIO_s_mem()))) {
ERR_print_errors(bio);
BIO_get_mem_ptr(bio, &mem);
- Local<Value> e = Exception::Error(String::New(mem->data, mem->length));
- handle(node_isolate)->Set(String::New("error"), e);
+ Local<Value> exception =
+ Exception::Error(OneByteString(node_isolate, mem->data, mem->length));
+ handle(node_isolate)->Set(
+ FIXED_ONE_BYTE_STRING(node_isolate, "error"), exception);
BIO_free_all(bio);
}
HandleScope scope(node_isolate);
// We should clear the error in JS-land
- assert(
- handle(node_isolate)->Get(String::New("error"))->BooleanValue() == false);
+ Local<String> error_key = FIXED_ONE_BYTE_STRING(node_isolate, "error");
+ Local<Value> error = handle(node_isolate)->Get(error_key);
+ assert(error->BooleanValue() == false);
#endif // NDEBUG
}
int flags = SSL_get_shutdown(ssl_);
if (flags & SSL_SENT_SHUTDOWN) {
- handle(node_isolate)->Set(String::New("sentShutdown"), True(node_isolate));
+ Local<String> sent_shutdown_key =
+ FIXED_ONE_BYTE_STRING(node_isolate, "sentShutdown");
+ handle(node_isolate)->Set(sent_shutdown_key, True(node_isolate));
}
if (flags & SSL_RECEIVED_SHUTDOWN) {
- handle(node_isolate)->Set(String::New("receivedShutdown"),
- True(node_isolate));
+ Local<String> received_shutdown_key =
+ FIXED_ONE_BYTE_STRING(node_isolate, "receivedShutdown");
+ handle(node_isolate)->Set(received_shutdown_key, True(node_isolate));
}
}
Local<FunctionTemplate> t = FunctionTemplate::New(Connection::New);
t->InstanceTemplate()->SetInternalFieldCount(1);
- t->SetClassName(String::NewSymbol("Connection"));
+ t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Connection"));
NODE_SET_PROTOTYPE_METHOD(t, "encIn", Connection::EncIn);
NODE_SET_PROTOTYPE_METHOD(t, "clearOut", Connection::ClearOut);
NODE_SET_PROTOTYPE_METHOD(t, "setSNICallback", Connection::SetSNICallback);
#endif
- target->Set(String::NewSymbol("Connection"), t->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Connection"),
+ t->GetFunction());
}
p->selectedNPNProto_.Reset(node_isolate, Null(node_isolate));
break;
case OPENSSL_NPN_NEGOTIATED:
- p->selectedNPNProto_.Reset(
- node_isolate,
- String::New(reinterpret_cast<const char*>(*out), *outlen));
- break;
+ {
+ Local<String> string = OneByteString(node_isolate, *out, *outlen);
+ p->selectedNPNProto_.Reset(node_isolate, string);
+ break;
+ }
case OPENSSL_NPN_NO_OVERLAP:
p->selectedNPNProto_.Reset(node_isolate, False(node_isolate));
break;
const char* servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
if (servername) {
- p->servername_.Reset(node_isolate, String::New(servername));
+ p->servername_.Reset(node_isolate,
+ OneByteString(node_isolate, servername));
// Call the SNI callback and use its return value as context
if (!p->sniObject_.IsEmpty()) {
HandleScope scope(node_isolate);
Connection* c = static_cast<Connection*>(SSL_get_app_data(ssl));
if (onhandshakestart_sym.IsEmpty()) {
- onhandshakestart_sym = String::New("onhandshakestart");
+ onhandshakestart_sym =
+ FIXED_ONE_BYTE_STRING(node_isolate, "onhandshakestart");
}
MakeCallback(c->handle(node_isolate), onhandshakestart_sym, 0, NULL);
}
HandleScope scope(node_isolate);
Connection* c = static_cast<Connection*>(SSL_get_app_data(ssl));
if (onhandshakedone_sym.IsEmpty()) {
- onhandshakedone_sym = String::New("onhandshakedone");
+ onhandshakedone_sym =
+ FIXED_ONE_BYTE_STRING(node_isolate, "onhandshakedone");
}
MakeCallback(c->handle(node_isolate), onhandshakedone_sym, 0, NULL);
}
if (X509_NAME_print_ex(bio, X509_get_subject_name(peer_cert), 0,
X509_NAME_FLAGS) > 0) {
BIO_get_mem_ptr(bio, &mem);
- info->Set(subject_symbol, String::New(mem->data, mem->length));
+ info->Set(subject_symbol,
+ OneByteString(node_isolate, mem->data, mem->length));
}
(void) BIO_reset(bio);
if (X509_NAME_print_ex(bio, X509_get_issuer_name(peer_cert), 0,
X509_NAME_FLAGS) > 0) {
BIO_get_mem_ptr(bio, &mem);
- info->Set(issuer_symbol, String::New(mem->data, mem->length));
+ info->Set(issuer_symbol,
+ OneByteString(node_isolate, mem->data, mem->length));
}
(void) BIO_reset(bio);
assert(rv == 1);
BIO_get_mem_ptr(bio, &mem);
- info->Set(subjectaltname_symbol, String::New(mem->data, mem->length));
+ info->Set(subjectaltname_symbol,
+ OneByteString(node_isolate, mem->data, mem->length));
(void) BIO_reset(bio);
}
NULL != (rsa = EVP_PKEY_get1_RSA(pkey))) {
BN_print(bio, rsa->n);
BIO_get_mem_ptr(bio, &mem);
- info->Set(modulus_symbol, String::New(mem->data, mem->length) );
+ info->Set(modulus_symbol,
+ OneByteString(node_isolate, mem->data, mem->length));
(void) BIO_reset(bio);
BN_print(bio, rsa->e);
BIO_get_mem_ptr(bio, &mem);
- info->Set(exponent_symbol, String::New(mem->data, mem->length) );
+ info->Set(exponent_symbol,
+ OneByteString(node_isolate, mem->data, mem->length));
(void) BIO_reset(bio);
}
ASN1_TIME_print(bio, X509_get_notBefore(peer_cert));
BIO_get_mem_ptr(bio, &mem);
- info->Set(valid_from_symbol, String::New(mem->data, mem->length));
+ info->Set(valid_from_symbol,
+ OneByteString(node_isolate, mem->data, mem->length));
(void) BIO_reset(bio);
ASN1_TIME_print(bio, X509_get_notAfter(peer_cert));
BIO_get_mem_ptr(bio, &mem);
- info->Set(valid_to_symbol, String::New(mem->data, mem->length));
+ info->Set(valid_to_symbol,
+ OneByteString(node_isolate, mem->data, mem->length));
BIO_free_all(bio);
unsigned int md_size, i;
fingerprint[0] = '\0';
}
- info->Set(fingerprint_symbol, String::New(fingerprint));
+ info->Set(fingerprint_symbol, OneByteString(node_isolate, fingerprint));
}
STACK_OF(ASN1_OBJECT) *eku = (STACK_OF(ASN1_OBJECT) *)X509_get_ext_d2i(
for (int i = 0; i < sk_ASN1_OBJECT_num(eku); i++) {
memset(buf, 0, sizeof(buf));
OBJ_obj2txt(buf, sizeof(buf) - 1, sk_ASN1_OBJECT_value(eku, i), 1);
- ext_key_usage->Set(Integer::New(i, node_isolate), String::New(buf));
+ ext_key_usage->Set(Integer::New(i, node_isolate),
+ OneByteString(node_isolate, buf));
}
sk_ASN1_OBJECT_pop_free(eku, ASN1_OBJECT_free);
// We requested a certificate and they did not send us one.
// Definitely an error.
// XXX is this the right error message?
- return args.GetReturnValue().Set(
- Exception::Error(String::New("UNABLE_TO_GET_ISSUER_CERT")));
+ Local<String> error_message =
+ FIXED_ONE_BYTE_STRING(node_isolate, "UNABLE_TO_GET_ISSUER_CERT");
+ Local<Value> exception = Exception::Error(error_message);
+ return args.GetReturnValue().Set(exception);
}
X509_free(peer_cert);
break;
case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
- s = String::New("UNABLE_TO_GET_ISSUER_CERT");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "UNABLE_TO_GET_ISSUER_CERT");
break;
case X509_V_ERR_UNABLE_TO_GET_CRL:
- s = String::New("UNABLE_TO_GET_CRL");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "UNABLE_TO_GET_CRL");
break;
case X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE:
- s = String::New("UNABLE_TO_DECRYPT_CERT_SIGNATURE");
+ s = FIXED_ONE_BYTE_STRING(node_isolate,
+ "UNABLE_TO_DECRYPT_CERT_SIGNATURE");
break;
case X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE:
- s = String::New("UNABLE_TO_DECRYPT_CRL_SIGNATURE");
+ s = FIXED_ONE_BYTE_STRING(node_isolate,
+ "UNABLE_TO_DECRYPT_CRL_SIGNATURE");
break;
case X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY:
- s = String::New("UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY");
+ s = FIXED_ONE_BYTE_STRING(node_isolate,
+ "UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY");
break;
case X509_V_ERR_CERT_SIGNATURE_FAILURE:
- s = String::New("CERT_SIGNATURE_FAILURE");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_SIGNATURE_FAILURE");
break;
case X509_V_ERR_CRL_SIGNATURE_FAILURE:
- s = String::New("CRL_SIGNATURE_FAILURE");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "CRL_SIGNATURE_FAILURE");
break;
case X509_V_ERR_CERT_NOT_YET_VALID:
- s = String::New("CERT_NOT_YET_VALID");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_NOT_YET_VALID");
break;
case X509_V_ERR_CERT_HAS_EXPIRED:
- s = String::New("CERT_HAS_EXPIRED");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_HAS_EXPIRED");
break;
case X509_V_ERR_CRL_NOT_YET_VALID:
- s = String::New("CRL_NOT_YET_VALID");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "CRL_NOT_YET_VALID");
break;
case X509_V_ERR_CRL_HAS_EXPIRED:
- s = String::New("CRL_HAS_EXPIRED");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "CRL_HAS_EXPIRED");
break;
case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD:
- s = String::New("ERROR_IN_CERT_NOT_BEFORE_FIELD");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "ERROR_IN_CERT_NOT_BEFORE_FIELD");
break;
case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD:
- s = String::New("ERROR_IN_CERT_NOT_AFTER_FIELD");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "ERROR_IN_CERT_NOT_AFTER_FIELD");
break;
case X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD:
- s = String::New("ERROR_IN_CRL_LAST_UPDATE_FIELD");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "ERROR_IN_CRL_LAST_UPDATE_FIELD");
break;
case X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD:
- s = String::New("ERROR_IN_CRL_NEXT_UPDATE_FIELD");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "ERROR_IN_CRL_NEXT_UPDATE_FIELD");
break;
case X509_V_ERR_OUT_OF_MEM:
- s = String::New("OUT_OF_MEM");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "OUT_OF_MEM");
break;
case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
- s = String::New("DEPTH_ZERO_SELF_SIGNED_CERT");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "DEPTH_ZERO_SELF_SIGNED_CERT");
break;
case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
- s = String::New("SELF_SIGNED_CERT_IN_CHAIN");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "SELF_SIGNED_CERT_IN_CHAIN");
break;
case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
- s = String::New("UNABLE_TO_GET_ISSUER_CERT_LOCALLY");
+ s = FIXED_ONE_BYTE_STRING(node_isolate,
+ "UNABLE_TO_GET_ISSUER_CERT_LOCALLY");
break;
case X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
- s = String::New("UNABLE_TO_VERIFY_LEAF_SIGNATURE");
+ s = FIXED_ONE_BYTE_STRING(node_isolate,
+ "UNABLE_TO_VERIFY_LEAF_SIGNATURE");
break;
case X509_V_ERR_CERT_CHAIN_TOO_LONG:
- s = String::New("CERT_CHAIN_TOO_LONG");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_CHAIN_TOO_LONG");
break;
case X509_V_ERR_CERT_REVOKED:
- s = String::New("CERT_REVOKED");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_REVOKED");
break;
case X509_V_ERR_INVALID_CA:
- s = String::New("INVALID_CA");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "INVALID_CA");
break;
case X509_V_ERR_PATH_LENGTH_EXCEEDED:
- s = String::New("PATH_LENGTH_EXCEEDED");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "PATH_LENGTH_EXCEEDED");
break;
case X509_V_ERR_INVALID_PURPOSE:
- s = String::New("INVALID_PURPOSE");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "INVALID_PURPOSE");
break;
case X509_V_ERR_CERT_UNTRUSTED:
- s = String::New("CERT_UNTRUSTED");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_UNTRUSTED");
break;
case X509_V_ERR_CERT_REJECTED:
- s = String::New("CERT_REJECTED");
+ s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_REJECTED");
break;
default:
- s = String::New(X509_verify_cert_error_string(x509_verify_error));
+ s = OneByteString(node_isolate,
+ X509_verify_cert_error_string(x509_verify_error));
break;
}
if (c == NULL) return;
Local<Object> info = Object::New();
const char* cipher_name = SSL_CIPHER_get_name(c);
- info->Set(name_symbol, String::New(cipher_name));
+ info->Set(name_symbol, OneByteString(node_isolate, cipher_name));
const char* cipher_version = SSL_CIPHER_get_version(c);
- info->Set(version_symbol, String::New(cipher_version));
+ info->Set(version_symbol, OneByteString(node_isolate, cipher_version));
args.GetReturnValue().Set(info);
}
}
args.GetReturnValue().Set(
- String::New(reinterpret_cast<const char*>(npn_proto), npn_proto_len));
+ OneByteString(node_isolate, npn_proto, npn_proto_len));
} else {
args.GetReturnValue().Set(ss->selectedNPNProto_);
}
}
Local<Object> obj = Object::New();
- obj->Set(String::New("onselect"), args[0]);
+ obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "onselect"), args[0]);
ss->sniObject_.Reset(node_isolate, obj);
}
#endif
NODE_SET_PROTOTYPE_METHOD(t, "final", Final);
NODE_SET_PROTOTYPE_METHOD(t, "setAutoPadding", SetAutoPadding);
- target->Set(String::NewSymbol("CipherBase"), t->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "CipherBase"),
+ t->GetFunction());
}
NODE_SET_PROTOTYPE_METHOD(t, "update", HmacUpdate);
NODE_SET_PROTOTYPE_METHOD(t, "digest", HmacDigest);
- target->Set(String::NewSymbol("Hmac"), t->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Hmac"), t->GetFunction());
}
NODE_SET_PROTOTYPE_METHOD(t, "update", HashUpdate);
NODE_SET_PROTOTYPE_METHOD(t, "digest", HashDigest);
- target->Set(String::NewSymbol("Hash"), t->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Hash"), t->GetFunction());
}
NODE_SET_PROTOTYPE_METHOD(t, "update", SignUpdate);
NODE_SET_PROTOTYPE_METHOD(t, "sign", SignFinal);
- target->Set(String::NewSymbol("Sign"), t->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Sign"), t->GetFunction());
}
NODE_SET_PROTOTYPE_METHOD(t, "update", VerifyUpdate);
NODE_SET_PROTOTYPE_METHOD(t, "verify", VerifyFinal);
- target->Set(String::NewSymbol("Verify"), t->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Verify"), t->GetFunction());
}
NODE_SET_PROTOTYPE_METHOD(t, "setPublicKey", SetPublicKey);
NODE_SET_PROTOTYPE_METHOD(t, "setPrivateKey", SetPrivateKey);
- target->Set(String::NewSymbol("DiffieHellman"), t->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "DiffieHellman"),
+ t->GetFunction());
Local<FunctionTemplate> t2 = FunctionTemplate::New(DiffieHellmanGroup);
t2->InstanceTemplate()->SetInternalFieldCount(1);
NODE_SET_PROTOTYPE_METHOD(t2, "getPublicKey", GetPublicKey);
NODE_SET_PROTOTYPE_METHOD(t2, "getPrivateKey", GetPrivateKey);
- target->Set(String::NewSymbol("DiffieHellmanGroup"), t2->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "DiffieHellmanGroup"),
+ t2->GetFunction());
}
argv[1] = Encode(req->key, req->keylen, BUFFER);
memset(req->key, 0, req->keylen);
} else {
- argv[0] = Exception::Error(String::New("PBKDF2 error"));
+ argv[0] = Exception::Error(
+ FIXED_ONE_BYTE_STRING(node_isolate, "PBKDF2 error"));
argv[1] = Undefined(node_isolate);
}
if (args[4]->IsFunction()) {
Local<Object> obj = Object::New();
- obj->Set(String::New("ondone"), args[4]);
+ obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "ondone"), args[4]);
req->obj.Reset(node_isolate, obj);
uv_queue_work(uv_default_loop(),
&req->work_req,
if (req->error_ != (unsigned long) -1)
ERR_error_string_n(req->error_, errmsg, sizeof errmsg);
- argv[0] = Exception::Error(String::New(errmsg));
+ argv[0] = Exception::Error(OneByteString(node_isolate, errmsg));
argv[1] = Null(node_isolate);
} else {
argv[0] = Null(node_isolate);
if (args[1]->IsFunction()) {
Local<Object> obj = Object::New();
- obj->Set(String::New("ondone"), args[1]);
+ obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "ondone"), args[1]);
req->obj_.Reset(node_isolate, obj);
uv_queue_work(uv_default_loop(),
for (int i = 0; i < sk_SSL_CIPHER_num(ciphers); ++i) {
SSL_CIPHER* cipher = sk_SSL_CIPHER_value(ciphers, i);
- arr->Set(i, String::New(SSL_CIPHER_get_name(cipher)));
+ arr->Set(i, OneByteString(node_isolate, SSL_CIPHER_get_name(cipher)));
}
SSL_free(ssl);
const char* to,
void* arg) {
Local<Array>& arr = *static_cast<Local<Array>*>(arg);
- arr->Set(arr->Length(), String::New(from));
+ arr->Set(arr->Length(), OneByteString(node_isolate, from));
}
NODE_SET_METHOD(target, "getCiphers", GetCiphers);
NODE_SET_METHOD(target, "getHashes", GetHashes);
- subject_symbol = String::New("subject");
- issuer_symbol = String::New("issuer");
- valid_from_symbol = String::New("valid_from");
- valid_to_symbol = String::New("valid_to");
- subjectaltname_symbol = String::New("subjectaltname");
- modulus_symbol = String::New("modulus");
- exponent_symbol = String::New("exponent");
- fingerprint_symbol = String::New("fingerprint");
- name_symbol = String::New("name");
- version_symbol = String::New("version");
- ext_key_usage_symbol = String::New("ext_key_usage");
+ subject_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "subject");
+ issuer_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "issuer");
+ valid_from_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "valid_from");
+ valid_to_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "valid_to");
+ subjectaltname_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "subjectaltname");
+ modulus_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "modulus");
+ exponent_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "exponent");
+ fingerprint_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "fingerprint");
+ name_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "name");
+ version_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "version");
+ ext_key_usage_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "ext_key_usage");
}
} // namespace crypto
return ThrowError( \
"expected object for " #obj " to contain string member " #member); \
} \
- String::Utf8Value _##member(obj->Get(String::New(#member))); \
+ String::Utf8Value _##member(obj->Get(OneByteString(node_isolate, #member))); \
if ((*(const char **)valp = *_##member) == NULL) \
*(const char **)valp = "<unknown>";
return ThrowError( \
"expected object for " #obj " to contain integer member " #member); \
} \
- *valp = obj->Get(String::New(#member))->ToInteger()->Value();
+ *valp = obj->Get(OneByteString(node_isolate, #member))->ToInteger()->Value();
#define SLURP_OBJECT(obj, member, valp) \
if (!(obj)->IsObject()) { \
return ThrowError( \
"expected object for " #obj " to contain object member " #member); \
} \
- *valp = Local<Object>::Cast(obj->Get(String::New(#member)));
+ *valp = Local<Object>::Cast(obj->Get(OneByteString(node_isolate, #member)));
#define SLURP_CONNECTION(arg, conn) \
if (!(arg)->IsObject()) { \
} \
node_dtrace_connection_t conn; \
Local<Object> _##conn = Local<Object>::Cast(arg); \
- Local<Value> _handle = (_##conn)->Get(String::New("_handle")); \
+ Local<Value> _handle = (_##conn)->Get(FIXED_ONE_BYTE_STRING(node_isolate, "_handle")); \
if (_handle->IsObject()) { \
SLURP_INT(_handle.As<Object>(), fd, &conn.fd); \
} else { \
"expected object for request to contain string member headers");
}
- Local<Value> strfwdfor = headers->Get(String::New("x-forwarded-for"));
+ Local<Value> strfwdfor = headers->Get(FIXED_ONE_BYTE_STRING(node_isolate, "x-forwarded-for"));
String::Utf8Value fwdfor(strfwdfor);
if (!strfwdfor->IsString() || (req.forwardedFor = *fwdfor) == NULL)
};
for (unsigned int i = 0; i < ARRAY_SIZE(tab); i++) {
- Local<String> key = String::New(tab[i].name);
+ Local<String> key = OneByteString(node_isolate, tab[i].name);
Local<Value> val = FunctionTemplate::New(tab[i].func)->GetFunction();
target->Set(key, val);
}
break;
case UV_FS_READLINK:
- argv[1] = String::New(static_cast<char*>(req->ptr));
+ argv[1] = String::NewFromUtf8(node_isolate,
+ static_cast<const char*>(req->ptr));
break;
case UV_FS_READ:
Local<Array> names = Array::New(nnames);
for (int i = 0; i < nnames; i++) {
- Local<String> name = String::New(namebuf);
+ Local<String> name = String::NewFromUtf8(node_isolate, namebuf);
names->Set(Integer::New(i, node_isolate), name);
#ifndef NDEBUG
namebuf += strlen(namebuf);
}
if (oncomplete_sym.IsEmpty()) {
- oncomplete_sym = String::New("oncomplete");
+ oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
}
MakeCallback(req_wrap->object(), oncomplete_sym, argc, argv);
HandleScope scope(node_isolate);
if (dev_symbol.IsEmpty()) {
- dev_symbol = String::New("dev");
- ino_symbol = String::New("ino");
- mode_symbol = String::New("mode");
- nlink_symbol = String::New("nlink");
- uid_symbol = String::New("uid");
- gid_symbol = String::New("gid");
- rdev_symbol = String::New("rdev");
- size_symbol = String::New("size");
- blksize_symbol = String::New("blksize");
- blocks_symbol = String::New("blocks");
- atime_symbol = String::New("atime");
- mtime_symbol = String::New("mtime");
- ctime_symbol = String::New("ctime");
+ dev_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "dev");
+ ino_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "ino");
+ mode_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "mode");
+ nlink_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "nlink");
+ uid_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "uid");
+ gid_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "gid");
+ rdev_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "rdev");
+ size_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "size");
+ blksize_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "blksize");
+ blocks_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "blocks");
+ atime_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "atime");
+ mtime_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "mtime");
+ ctime_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "ctime");
}
Local<Function> constructor =
ASYNC_CALL(readlink, args[1], *path)
} else {
SYNC_CALL(readlink, *path, *path)
- args.GetReturnValue().Set(
- String::New(static_cast<const char*>(SYNC_REQ.ptr)));
+ const char* link_path = static_cast<const char*>(SYNC_REQ.ptr);
+ Local<String> rc = String::NewFromUtf8(node_isolate, link_path);
+ args.GetReturnValue().Set(rc);
}
}
Local<Array> names = Array::New(nnames);
for (int i = 0; i < nnames; i++) {
- Local<String> name = String::New(namebuf);
+ Local<String> name = String::NewFromUtf8(node_isolate, namebuf);
names->Set(Integer::New(i, node_isolate), name);
#ifndef NDEBUG
namebuf += strlen(namebuf);
// Initialize the stats object
Local<Function> constructor = FunctionTemplate::New()->GetFunction();
- target->Set(String::NewSymbol("Stats"), constructor);
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Stats"), constructor);
stats_constructor.Reset(node_isolate, constructor);
File::Initialize(target);
- oncomplete_sym = String::New("oncomplete");
+ oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
StatWatcher::Initialize(target);
}
Local<String> ToString() const {
if (str_)
- return String::New(str_, size_);
+ return OneByteString(node_isolate, str_, size_);
else
return String::Empty(node_isolate);
}
if (!parser->parser_.upgrade && nparsed != buffer_len) {
enum http_errno err = HTTP_PARSER_ERRNO(&parser->parser_);
- Local<Value> e = Exception::Error(String::NewSymbol("Parse Error"));
+ Local<Value> e = Exception::Error(
+ FIXED_ONE_BYTE_STRING(node_isolate, "Parse Error"));
Local<Object> obj = e->ToObject();
- obj->Set(String::NewSymbol("bytesParsed"), nparsed_obj);
- obj->Set(String::NewSymbol("code"), String::New(http_errno_name(err)));
+ obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "bytesParsed"), nparsed_obj);
+ obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "code"),
+ OneByteString(node_isolate, http_errno_name(err)));
args.GetReturnValue().Set(e);
} else {
args.GetReturnValue().Set(nparsed_obj);
if (rv != 0) {
enum http_errno err = HTTP_PARSER_ERRNO(&parser->parser_);
- Local<Value> e = Exception::Error(String::NewSymbol("Parse Error"));
+ Local<Value> e = Exception::Error(
+ FIXED_ONE_BYTE_STRING(node_isolate, "Parse Error"));
Local<Object> obj = e->ToObject();
- obj->Set(String::NewSymbol("bytesParsed"), Integer::New(0, node_isolate));
- obj->Set(String::NewSymbol("code"), String::New(http_errno_name(err)));
+ obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "bytesParsed"),
+ Integer::New(0, node_isolate));
+ obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "code"),
+ OneByteString(node_isolate, http_errno_name(err)));
args.GetReturnValue().Set(e);
}
}
Local<FunctionTemplate> t = FunctionTemplate::New(Parser::New);
t->InstanceTemplate()->SetInternalFieldCount(1);
- t->SetClassName(String::NewSymbol("HTTPParser"));
+ t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "HTTPParser"));
- t->Set(String::NewSymbol("REQUEST"),
+ t->Set(FIXED_ONE_BYTE_STRING(node_isolate, "REQUEST"),
Integer::New(HTTP_REQUEST, node_isolate));
- t->Set(String::NewSymbol("RESPONSE"),
+ t->Set(FIXED_ONE_BYTE_STRING(node_isolate, "RESPONSE"),
Integer::New(HTTP_RESPONSE, node_isolate));
NODE_SET_PROTOTYPE_METHOD(t, "execute", Parser::Execute);
NODE_SET_PROTOTYPE_METHOD(t, "finish", Parser::Finish);
NODE_SET_PROTOTYPE_METHOD(t, "reinitialize", Parser::Reinitialize);
- target->Set(String::NewSymbol("HTTPParser"), t->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "HTTPParser"),
+ t->GetFunction());
- on_headers_sym = String::New("onHeaders");
- on_headers_complete_sym = String::New("onHeadersComplete");
- on_body_sym = String::New("onBody");
- on_message_complete_sym = String::New("onMessageComplete");
+ on_headers_sym =
+ FIXED_ONE_BYTE_STRING(node_isolate, "onHeaders");
+ on_headers_complete_sym =
+ FIXED_ONE_BYTE_STRING(node_isolate, "onHeadersComplete");
+ on_body_sym =
+ FIXED_ONE_BYTE_STRING(node_isolate, "onBody");
+ on_message_complete_sym =
+ FIXED_ONE_BYTE_STRING(node_isolate, "onMessageComplete");
-#define X(num, name, string) name##_sym = String::New(#string);
+#define X(num, name, string) \
+ name ## _sym = OneByteString(node_isolate, #string);
HTTP_METHOD_MAP(X)
#undef X
- unknown_method_sym = String::New("UNKNOWN_METHOD");
-
- method_sym = String::New("method");
- status_code_sym = String::New("statusCode");
- http_version_sym = String::New("httpVersion");
- version_major_sym = String::New("versionMajor");
- version_minor_sym = String::New("versionMinor");
- should_keep_alive_sym = String::New("shouldKeepAlive");
- upgrade_sym = String::New("upgrade");
- headers_sym = String::New("headers");
- url_sym = String::New("url");
+ unknown_method_sym = FIXED_ONE_BYTE_STRING(node_isolate, "UNKNOWN_METHOD");
+
+ method_sym = FIXED_ONE_BYTE_STRING(node_isolate, "method");
+ status_code_sym = FIXED_ONE_BYTE_STRING(node_isolate, "statusCode");
+ http_version_sym = FIXED_ONE_BYTE_STRING(node_isolate, "httpVersion");
+ version_major_sym = FIXED_ONE_BYTE_STRING(node_isolate, "versionMajor");
+ version_minor_sym = FIXED_ONE_BYTE_STRING(node_isolate, "versionMinor");
+ should_keep_alive_sym =
+ FIXED_ONE_BYTE_STRING(node_isolate, "shouldKeepAlive");
+ upgrade_sym = FIXED_ONE_BYTE_STRING(node_isolate, "upgrade");
+ headers_sym = FIXED_ONE_BYTE_STRING(node_isolate, "headers");
+ url_sym = FIXED_ONE_BYTE_STRING(node_isolate, "url");
settings.on_message_begin = Parser::on_message_begin;
settings.on_url = Parser::on_url;
#include "v8.h"
#include <assert.h>
+#include <stdint.h>
#include <stdlib.h>
+#define FIXED_ONE_BYTE_STRING(isolate, string) \
+ (node::OneByteString((isolate), (string), sizeof(string) - 1))
+
struct sockaddr;
namespace node {
int argc = 0,
v8::Handle<v8::Value>* argv = NULL);
+// Convenience wrapper around v8::String::NewFromOneByte().
+inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
+ const char* data,
+ int length = -1);
+
+// For the people that compile with -funsigned-char.
+inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
+ const signed char* data,
+ int length = -1);
+
+inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
+ const unsigned char* data,
+ int length = -1);
+
// Convert a struct sockaddr to a { address: '1.2.3.4', port: 1234 } JS object.
// Sets address and port properties on the info object and returns it.
// If |info| is omitted, a new object is returned.
#define THROW_ERROR(fun) \
do { \
v8::HandleScope scope(node_isolate); \
- v8::ThrowException(fun(v8::String::New(errmsg))); \
+ v8::ThrowException(fun(OneByteString(node_isolate, errmsg))); \
} \
while (0)
return constructor_handle->NewInstance(argc, argv);
}
+inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
+ const char* data,
+ int length) {
+ return v8::String::NewFromOneByte(isolate,
+ reinterpret_cast<const uint8_t*>(data),
+ v8::String::kNormalString,
+ length);
+}
+
+inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
+ const signed char* data,
+ int length) {
+ return v8::String::NewFromOneByte(isolate,
+ reinterpret_cast<const uint8_t*>(data),
+ v8::String::kNormalString,
+ length);
+}
+
+inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
+ const unsigned char* data,
+ int length) {
+ return v8::String::NewFromOneByte(isolate,
+ reinterpret_cast<const uint8_t*>(data),
+ v8::String::kNormalString,
+ length);
+}
+
} // namespace node
#endif // SRC_NODE_INTERNALS_H_
using v8::String;
Handle<String> MainSource() {
- return String::New(node_native, sizeof(node_native) - 1);
+ return OneByteString(node_isolate, node_native, sizeof(node_native) - 1);
}
void DefineJavaScript(Handle<Object> target) {
for (int i = 0; natives[i].name; i++) {
if (natives[i].source != node_native) {
- Local<String> name = String::New(natives[i].name);
- Handle<String> source = String::New(natives[i].source,
- natives[i].source_len);
+ Local<String> name = String::NewFromUtf8(node_isolate, natives[i].name);
+ Handle<String> source = String::NewFromUtf8(node_isolate,
+ natives[i].source,
+ String::kNormalString,
+ natives[i].source_len);
target->Set(name, source);
}
}
static void GetEndianness(const FunctionCallbackInfo<Value>& args) {
HandleScope scope(node_isolate);
const char* rval = IsBigEndian() ? "BE" : "LE";
- args.GetReturnValue().Set(String::New(rval));
+ args.GetReturnValue().Set(OneByteString(node_isolate, rval));
}
}
buf[sizeof(buf) - 1] = '\0';
- args.GetReturnValue().Set(String::New(buf));
+ args.GetReturnValue().Set(OneByteString(node_isolate, buf));
}
rval ="Windows_NT";
#endif // __POSIX__
- args.GetReturnValue().Set(String::New(rval));
+ args.GetReturnValue().Set(OneByteString(node_isolate, rval));
}
rval = release;
#endif // __POSIX__
- args.GetReturnValue().Set(String::New(rval));
+ args.GetReturnValue().Set(OneByteString(node_isolate, rval));
}
uv_cpu_info_t* ci = cpu_infos + i;
Local<Object> times_info = Object::New();
- times_info->Set(String::New("user"),
+ times_info->Set(FIXED_ONE_BYTE_STRING(node_isolate, "user"),
Number::New(node_isolate, ci->cpu_times.user));
- times_info->Set(String::New("nice"),
+ times_info->Set(FIXED_ONE_BYTE_STRING(node_isolate, "nice"),
Number::New(node_isolate, ci->cpu_times.nice));
- times_info->Set(String::New("sys"),
+ times_info->Set(FIXED_ONE_BYTE_STRING(node_isolate, "sys"),
Number::New(node_isolate, ci->cpu_times.sys));
- times_info->Set(String::New("idle"),
+ times_info->Set(FIXED_ONE_BYTE_STRING(node_isolate, "idle"),
Number::New(node_isolate, ci->cpu_times.idle));
- times_info->Set(String::New("irq"),
+ times_info->Set(FIXED_ONE_BYTE_STRING(node_isolate, "irq"),
Number::New(node_isolate, ci->cpu_times.irq));
Local<Object> cpu_info = Object::New();
- cpu_info->Set(String::New("model"), String::New(ci->model));
- cpu_info->Set(String::New("speed"), Number::New(node_isolate, ci->speed));
- cpu_info->Set(String::New("times"), times_info);
+ cpu_info->Set(FIXED_ONE_BYTE_STRING(node_isolate, "model"),
+ OneByteString(node_isolate, ci->model));
+ cpu_info->Set(FIXED_ONE_BYTE_STRING(node_isolate, "speed"),
+ Number::New(node_isolate, ci->speed));
+ cpu_info->Set(FIXED_ONE_BYTE_STRING(node_isolate, "times"), times_info);
(*cpus)->Set(i, cpu_info);
}
ret = Object::New();
for (i = 0; i < count; i++) {
- name = String::New(interfaces[i].name);
+ name = OneByteString(node_isolate, interfaces[i].name);
if (ret->Has(name)) {
ifarr = Local<Array>::Cast(ret->Get(name));
} else {
if (interfaces[i].address.address4.sin_family == AF_INET) {
uv_ip4_name(&interfaces[i].address.address4, ip, sizeof(ip));
uv_ip4_name(&interfaces[i].netmask.netmask4, netmask, sizeof(netmask));
- family = String::New("IPv4");
+ family = FIXED_ONE_BYTE_STRING(node_isolate, "IPv4");
} else if (interfaces[i].address.address4.sin_family == AF_INET6) {
uv_ip6_name(&interfaces[i].address.address6, ip, sizeof(ip));
uv_ip6_name(&interfaces[i].netmask.netmask6, netmask, sizeof(netmask));
- family = String::New("IPv6");
+ family = FIXED_ONE_BYTE_STRING(node_isolate, "IPv6");
} else {
strncpy(ip, "<unknown sa family>", INET6_ADDRSTRLEN);
- family = String::New("<unknown>");
+ family = FIXED_ONE_BYTE_STRING(node_isolate, "<unknown>");
}
o = Object::New();
- o->Set(String::New("address"), String::New(ip));
- o->Set(String::New("netmask"), String::New(netmask));
- o->Set(String::New("family"), family);
- o->Set(String::New("mac"), String::New(mac));
+ o->Set(FIXED_ONE_BYTE_STRING(node_isolate, "address"),
+ OneByteString(node_isolate, ip));
+ o->Set(FIXED_ONE_BYTE_STRING(node_isolate, "netmask"),
+ OneByteString(node_isolate, netmask));
+ o->Set(FIXED_ONE_BYTE_STRING(node_isolate, "family"), family);
+ o->Set(FIXED_ONE_BYTE_STRING(node_isolate, "mac"),
+ FIXED_ONE_BYTE_STRING(node_isolate, mac));
const bool internal = interfaces[i].is_internal;
- o->Set(String::New("internal"),
+ o->Set(FIXED_ONE_BYTE_STRING(node_isolate, "internal"),
internal ? True(node_isolate) : False(node_isolate));
ifarr->Set(ifarr->Length(), o);
"}); \n";
Local<String> script_source =
- String::New(raw_script_source, sizeof(raw_script_source) - 1);
- Local<Script> script =
- Script::Compile(script_source, String::New("binding:script"));
+ FIXED_ONE_BYTE_STRING(node_isolate, raw_script_source);
+ Local<String> script_name =
+ FIXED_ONE_BYTE_STRING(node_isolate, "binding:script");
+ Local<Script> script = Script::Compile(script_source, script_name);
Local<Function> fun = script->Run().As<Function>();
assert(fun.IsEmpty() == false);
Local<FunctionTemplate> t = FunctionTemplate::New(WrappedContext::New);
t->InstanceTemplate()->SetInternalFieldCount(1);
- t->SetClassName(String::NewSymbol("Context"));
+ t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Context"));
- target->Set(String::NewSymbol("Context"), t->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Context"), t->GetFunction());
constructor_template.Reset(node_isolate, t);
}
// Note: We use 'NodeScript' instead of 'Script' so that we do not
// conflict with V8's Script class defined in v8/src/messages.js
// See GH-203 https://github.com/joyent/node/issues/203
- t->SetClassName(String::NewSymbol("NodeScript"));
+ t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "NodeScript"));
NODE_SET_PROTOTYPE_METHOD(t,
"createContext",
"runInNewContext",
WrappedScript::CompileRunInNewContext);
- target->Set(String::NewSymbol("NodeScript"), t->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "NodeScript"),
+ t->GetFunction());
}
const int filename_index = sandbox_index +
(context_flag == thisContext? 0 : 1);
- Local<String> filename = args.Length() > filename_index
- ? args[filename_index]->ToString()
- : String::New("evalmachine.<anonymous>");
+ Local<String> filename;
+ if (args.Length() > filename_index) {
+ filename = args[filename_index]->ToString();
+ } else {
+ filename = FIXED_ONE_BYTE_STRING(node_isolate, "evalmachine.<anonymous>");
+ }
uint64_t timeout = 0;
const int timeout_index = filename_index + 1;
Local<FunctionTemplate> t = FunctionTemplate::New(StatWatcher::New);
t->InstanceTemplate()->SetInternalFieldCount(1);
- t->SetClassName(String::NewSymbol("StatWatcher"));
+ t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "StatWatcher"));
NODE_SET_PROTOTYPE_METHOD(t, "start", StatWatcher::Start);
NODE_SET_PROTOTYPE_METHOD(t, "stop", StatWatcher::Stop);
- target->Set(String::NewSymbol("StatWatcher"), t->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "StatWatcher"),
+ t->GetFunction());
}
argv[1] = BuildStatsObject(prev);
argv[2] = Integer::New(status, node_isolate);
if (onchange_sym.IsEmpty()) {
- onchange_sym = String::New("onchange");
+ onchange_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onchange");
}
MakeCallback(wrap->handle(node_isolate),
onchange_sym,
HandleScope scope(node_isolate);
StatWatcher* wrap = ObjectWrap::Unwrap<StatWatcher>(args.This());
if (onstop_sym.IsEmpty()) {
- onstop_sym = String::New("onstop");
+ onstop_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onstop");
}
MakeCallback(wrap->handle(node_isolate), onstop_sym, 0, NULL);
wrap->Stop();
assert(handle->Get(onerror_sym)->IsFunction() && "Invalid error handler");
HandleScope scope(node_isolate);
Local<Value> args[2] = {
- String::New(msg),
+ OneByteString(node_isolate, msg),
Number::New(ctx->err_)
};
MakeCallback(handle, onerror_sym, ARRAY_SIZE(args), args);
NODE_SET_PROTOTYPE_METHOD(z, "params", ZCtx::Params);
NODE_SET_PROTOTYPE_METHOD(z, "reset", ZCtx::Reset);
- z->SetClassName(String::NewSymbol("Zlib"));
- target->Set(String::NewSymbol("Zlib"), z->GetFunction());
+ z->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Zlib"));
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Zlib"), z->GetFunction());
- callback_sym = String::New("callback");
- onerror_sym = String::New("onerror");
+ callback_sym = FIXED_ONE_BYTE_STRING(node_isolate, "callback");
+ onerror_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onerror");
// valid flush values.
NODE_DEFINE_CONSTANT(target, Z_NO_FLUSH);
NODE_DEFINE_CONSTANT(target, INFLATERAW);
NODE_DEFINE_CONSTANT(target, UNZIP);
- target->Set(String::NewSymbol("ZLIB_VERSION"), String::New(ZLIB_VERSION));
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "ZLIB_VERSION"),
+ FIXED_ONE_BYTE_STRING(node_isolate, ZLIB_VERSION));
}
} // namespace node
HandleScope scope(node_isolate);
Local<FunctionTemplate> t = FunctionTemplate::New(New);
- t->SetClassName(String::NewSymbol("Pipe"));
+ t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Pipe"));
t->InstanceTemplate()->SetInternalFieldCount(1);
enum PropertyAttribute attributes =
static_cast<PropertyAttribute>(v8::ReadOnly | v8::DontDelete);
- t->InstanceTemplate()->SetAccessor(String::New("fd"),
+ t->InstanceTemplate()->SetAccessor(FIXED_ONE_BYTE_STRING(node_isolate, "fd"),
StreamWrap::GetFD,
NULL,
Handle<Value>(),
pipeConstructorTmpl.Reset(node_isolate, t);
pipeConstructor.Reset(node_isolate, t->GetFunction());
- target->Set(String::NewSymbol("Pipe"), t->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Pipe"), t->GetFunction());
}
// Successful accept. Call the onconnection callback in JavaScript land.
argv[1] = client_obj;
if (onconnection_sym.IsEmpty()) {
- onconnection_sym = String::New("onconnection");
+ onconnection_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onconnection");
}
MakeCallback(wrap->object(), onconnection_sym, ARRAY_SIZE(argv), argv);
}
};
if (oncomplete_sym.IsEmpty()) {
- oncomplete_sym = String::New("oncomplete");
+ oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
}
MakeCallback(req_wrap_obj, oncomplete_sym, ARRAY_SIZE(argv), argv);
Local<FunctionTemplate> constructor = FunctionTemplate::New(New);
constructor->InstanceTemplate()->SetInternalFieldCount(1);
- constructor->SetClassName(String::NewSymbol("Process"));
+ constructor->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Process"));
NODE_SET_PROTOTYPE_METHOD(constructor, "close", HandleWrap::Close);
NODE_SET_PROTOTYPE_METHOD(constructor, "ref", HandleWrap::Ref);
NODE_SET_PROTOTYPE_METHOD(constructor, "unref", HandleWrap::Unref);
- target->Set(String::NewSymbol("Process"), constructor->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Process"),
+ constructor->GetFunction());
}
private:
static void ParseStdioOptions(Local<Object> js_options,
uv_process_options_t* options) {
- Local<Array> stdios = js_options
- ->Get(String::NewSymbol("stdio")).As<Array>();
+ Local<String> stdio_key =
+ FIXED_ONE_BYTE_STRING(node_isolate, "stdio");
+ Local<Array> stdios = js_options->Get(stdio_key).As<Array>();
uint32_t len = stdios->Length();
options->stdio = new uv_stdio_container_t[len];
options->stdio_count = len;
for (uint32_t i = 0; i < len; i++) {
Local<Object> stdio = stdios->Get(i).As<Object>();
- Local<Value> type = stdio->Get(String::NewSymbol("type"));
+ Local<Value> type =
+ stdio->Get(FIXED_ONE_BYTE_STRING(node_isolate, "type"));
- if (type->Equals(String::NewSymbol("ignore"))) {
+ if (type->Equals(FIXED_ONE_BYTE_STRING(node_isolate, "ignore"))) {
options->stdio[i].flags = UV_IGNORE;
- } else if (type->Equals(String::NewSymbol("pipe"))) {
+ } else if (type->Equals(FIXED_ONE_BYTE_STRING(node_isolate, "pipe"))) {
options->stdio[i].flags = static_cast<uv_stdio_flags>(
UV_CREATE_PIPE | UV_READABLE_PIPE | UV_WRITABLE_PIPE);
- options->stdio[i].data.stream = reinterpret_cast<uv_stream_t*>(
- PipeWrap::Unwrap(stdio
- ->Get(String::NewSymbol("handle")).As<Object>())->UVHandle());
- } else if (type->Equals(String::NewSymbol("wrap"))) {
- uv_stream_t* stream = HandleToStream(
- stdio->Get(String::NewSymbol("handle")).As<Object>());
+ Local<String> handle_key =
+ FIXED_ONE_BYTE_STRING(node_isolate, "handle");
+ Local<Object> handle = stdio->Get(handle_key).As<Object>();
+ options->stdio[i].data.stream =
+ reinterpret_cast<uv_stream_t*>(
+ PipeWrap::Unwrap(handle)->UVHandle());
+ } else if (type->Equals(FIXED_ONE_BYTE_STRING(node_isolate, "wrap"))) {
+ Local<String> handle_key =
+ FIXED_ONE_BYTE_STRING(node_isolate, "handle");
+ Local<Object> handle = stdio->Get(handle_key).As<Object>();
+ uv_stream_t* stream = HandleToStream(handle);
assert(stream != NULL);
options->stdio[i].flags = UV_INHERIT_STREAM;
options->stdio[i].data.stream = stream;
} else {
- int fd = static_cast<int>(
- stdio->Get(String::NewSymbol("fd"))->IntegerValue());
+ Local<String> fd_key = FIXED_ONE_BYTE_STRING(node_isolate, "fd");
+ int fd = static_cast<int>(stdio->Get(fd_key)->IntegerValue());
options->stdio[i].flags = UV_INHERIT_FD;
options->stdio[i].data.fd = fd;
options.exit_cb = OnExit;
// options.uid
- Local<Value> uid_v = js_options->Get(String::NewSymbol("uid"));
+ Local<Value> uid_v =
+ js_options->Get(FIXED_ONE_BYTE_STRING(node_isolate, "uid"));
if (uid_v->IsInt32()) {
int32_t uid = uid_v->Int32Value();
if (uid & ~((uv_uid_t) ~0)) {
}
// options.gid
- Local<Value> gid_v = js_options->Get(String::NewSymbol("gid"));
+ Local<Value> gid_v =
+ js_options->Get(FIXED_ONE_BYTE_STRING(node_isolate, "gid"));
if (gid_v->IsInt32()) {
int32_t gid = gid_v->Int32Value();
if (gid & ~((uv_gid_t) ~0)) {
// TODO(bnoordhuis) is this possible to do without mallocing ?
// options.file
- Local<Value> file_v = js_options->Get(String::NewSymbol("file"));
+ Local<Value> file_v =
+ js_options->Get(FIXED_ONE_BYTE_STRING(node_isolate, "file"));
String::Utf8Value file(file_v->IsString() ? file_v : Local<Value>());
if (file.length() > 0) {
options.file = *file;
}
// options.args
- Local<Value> argv_v = js_options->Get(String::NewSymbol("args"));
+ Local<Value> argv_v =
+ js_options->Get(FIXED_ONE_BYTE_STRING(node_isolate, "args"));
if (!argv_v.IsEmpty() && argv_v->IsArray()) {
Local<Array> js_argv = Local<Array>::Cast(argv_v);
int argc = js_argv->Length();
}
// options.cwd
- Local<Value> cwd_v = js_options->Get(String::NewSymbol("cwd"));
+ Local<Value> cwd_v =
+ js_options->Get(FIXED_ONE_BYTE_STRING(node_isolate, "cwd"));
String::Utf8Value cwd(cwd_v->IsString() ? cwd_v : Local<Value>());
if (cwd.length() > 0) {
options.cwd = *cwd;
}
// options.env
- Local<Value> env_v = js_options->Get(String::NewSymbol("envPairs"));
+ Local<Value> env_v =
+ js_options->Get(FIXED_ONE_BYTE_STRING(node_isolate, "envPairs"));
if (!env_v.IsEmpty() && env_v->IsArray()) {
Local<Array> env = Local<Array>::Cast(env_v);
int envc = env->Length();
ParseStdioOptions(js_options, &options);
// options.windows_verbatim_arguments
- if (js_options->Get(String::NewSymbol("windowsVerbatimArguments"))->
- IsTrue()) {
+ Local<String> windows_verbatim_arguments_key =
+ FIXED_ONE_BYTE_STRING(node_isolate, "windowsVerbatimArguments");
+ if (js_options->Get(windows_verbatim_arguments_key)->IsTrue()) {
options.flags |= UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS;
}
// options.detached
- if (js_options->Get(String::NewSymbol("detached"))->IsTrue()) {
+ Local<String> detached_key =
+ FIXED_ONE_BYTE_STRING(node_isolate, "detached");
+ if (js_options->Get(detached_key)->IsTrue()) {
options.flags |= UV_PROCESS_DETACHED;
}
if (err == 0) {
assert(wrap->process_.data == wrap);
- wrap->object()->Set(String::New("pid"),
+ wrap->object()->Set(FIXED_ONE_BYTE_STRING(node_isolate, "pid"),
Integer::New(wrap->process_.pid, node_isolate));
}
Local<Value> argv[] = {
Integer::New(exit_status, node_isolate),
- String::New(signo_string(term_signal))
+ OneByteString(node_isolate, signo_string(term_signal))
};
if (onexit_sym.IsEmpty()) {
- onexit_sym = String::New("onexit");
+ onexit_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onexit");
}
MakeCallback(wrap->object(), onexit_sym, ARRAY_SIZE(argv), argv);
Local<FunctionTemplate> constructor = FunctionTemplate::New(New);
constructor->InstanceTemplate()->SetInternalFieldCount(1);
- constructor->SetClassName(String::NewSymbol("Signal"));
+ constructor->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Signal"));
NODE_SET_PROTOTYPE_METHOD(constructor, "close", HandleWrap::Close);
NODE_SET_PROTOTYPE_METHOD(constructor, "ref", HandleWrap::Ref);
NODE_SET_PROTOTYPE_METHOD(constructor, "start", Start);
NODE_SET_PROTOTYPE_METHOD(constructor, "stop", Stop);
- onsignal_sym = String::New("onsignal");
+ onsignal_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onsignal");
- target->Set(String::NewSymbol("Signal"), constructor->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Signal"),
+ constructor->GetFunction());
}
private:
assert(!obj->HasIndexedPropertiesInExternalArrayData());
if (smalloc_sym.IsEmpty()) {
- smalloc_sym = String::New("_smalloc_p");
+ smalloc_sym = FIXED_ONE_BYTE_STRING(node_isolate, "_smalloc_p");
using_alloc_cb = true;
}
NODE_SET_METHOD(exports, "alloc", Alloc);
NODE_SET_METHOD(exports, "dispose", AllocDispose);
- exports->Set(String::New("kMaxLength"),
+ exports->Set(FIXED_ONE_BYTE_STRING(node_isolate, "kMaxLength"),
Uint32::NewFromUnsigned(kMaxLength, node_isolate));
// for performance, begin checking if allocation object may contain
initialized = true;
HandleScope scope(node_isolate);
- buffer_sym = String::New("buffer");
- bytes_sym = String::New("bytes");
- write_queue_size_sym = String::New("writeQueueSize");
- onread_sym = String::New("onread");
- oncomplete_sym = String::New("oncomplete");
+ buffer_sym = FIXED_ONE_BYTE_STRING(node_isolate, "buffer");
+ bytes_sym = FIXED_ONE_BYTE_STRING(node_isolate, "bytes");
+ write_queue_size_sym = FIXED_ONE_BYTE_STRING(node_isolate, "writeQueueSize");
+ onread_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onread");
+ oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
}
// Reference StreamWrap instance to prevent it from being garbage
// collected before `AfterWrite` is called.
if (handle_sym.IsEmpty()) {
- handle_sym = String::New("handle");
+ handle_sym = FIXED_ONE_BYTE_STRING(node_isolate, "handle");
}
assert(!req_wrap->persistent().IsEmpty());
req_wrap->object()->Set(handle_sym, send_handle_obj);
char* out = new char[buflen];
force_ascii(buf, out, buflen);
if (buflen < EXTERN_APEX) {
- val = String::NewFromOneByte(node_isolate,
- reinterpret_cast<const uint8_t*>(out),
- String::kNormalString,
- buflen);
+ val = OneByteString(node_isolate, out, buflen);
delete[] out;
} else {
val = ExternOneByteString::New(out, buflen);
}
} else {
if (buflen < EXTERN_APEX)
- val = String::NewFromOneByte(node_isolate,
- reinterpret_cast<const uint8_t*>(buf),
- String::kNormalString,
- buflen);
+ val = OneByteString(node_isolate, buf, buflen);
else
val = ExternOneByteString::NewFromCopy(buf, buflen);
}
case BINARY:
if (buflen < EXTERN_APEX)
- val = String::NewFromOneByte(node_isolate,
- reinterpret_cast<const uint8_t*>(buf),
- String::kNormalString,
- buflen);
+ val = OneByteString(node_isolate, buf, buflen);
else
val = ExternOneByteString::NewFromCopy(buf, buflen);
break;
assert(written == dlen);
if (dlen < EXTERN_APEX) {
- val = String::NewFromOneByte(node_isolate,
- reinterpret_cast<const uint8_t*>(dst),
- String::kNormalString,
- dlen);
+ val = OneByteString(node_isolate, dst, dlen);
delete[] dst;
} else {
val = ExternOneByteString::New(dst, dlen);
assert(written == dlen);
if (dlen < EXTERN_APEX) {
- val = String::NewFromOneByte(node_isolate,
- reinterpret_cast<const uint8_t*>(dst),
- String::kNormalString,
- dlen);
+ val = OneByteString(node_isolate, dst, dlen);
delete[] dst;
} else {
val = ExternOneByteString::New(dst, dlen);
HandleScope scope(node_isolate);
Local<FunctionTemplate> t = FunctionTemplate::New(New);
- t->SetClassName(String::NewSymbol("TCP"));
+ t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "TCP"));
t->InstanceTemplate()->SetInternalFieldCount(1);
enum PropertyAttribute attributes =
static_cast<PropertyAttribute>(v8::ReadOnly | v8::DontDelete);
- t->InstanceTemplate()->SetAccessor(String::New("fd"),
+ t->InstanceTemplate()->SetAccessor(FIXED_ONE_BYTE_STRING(node_isolate, "fd"),
StreamWrap::GetFD,
NULL,
Handle<Value>(),
SetSimultaneousAccepts);
#endif
- onconnection_sym = String::New("onconnection");
- oncomplete_sym = String::New("oncomplete");
+ onconnection_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onconnection");
+ oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
tcpConstructorTmpl.Reset(node_isolate, t);
tcpConstructor.Reset(node_isolate, t->GetFunction());
- target->Set(String::NewSymbol("TCP"), t->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "TCP"), t->GetFunction());
}
int port;
if (address_sym.IsEmpty()) {
- address_sym = String::New("address");
- family_sym = String::New("family");
- port_sym = String::New("port");
- ipv4_sym = String::New("IPv4");
- ipv6_sym = String::New("IPv6");
+ address_sym = FIXED_ONE_BYTE_STRING(node_isolate, "address");
+ family_sym = FIXED_ONE_BYTE_STRING(node_isolate, "family");
+ port_sym = FIXED_ONE_BYTE_STRING(node_isolate, "port");
+ ipv4_sym = FIXED_ONE_BYTE_STRING(node_isolate, "IPv4");
+ ipv6_sym = FIXED_ONE_BYTE_STRING(node_isolate, "IPv6");
}
if (info.IsEmpty()) info = Object::New();
a6 = reinterpret_cast<const sockaddr_in6*>(addr);
uv_inet_ntop(AF_INET6, &a6->sin6_addr, ip, sizeof ip);
port = ntohs(a6->sin6_port);
- info->Set(address_sym, String::New(ip));
+ info->Set(address_sym, OneByteString(node_isolate, ip));
info->Set(family_sym, ipv6_sym);
info->Set(port_sym, Integer::New(port, node_isolate));
break;
a4 = reinterpret_cast<const sockaddr_in*>(addr);
uv_inet_ntop(AF_INET, &a4->sin_addr, ip, sizeof ip);
port = ntohs(a4->sin_port);
- info->Set(address_sym, String::New(ip));
+ info->Set(address_sym, OneByteString(node_isolate, ip));
info->Set(family_sym, ipv4_sym);
info->Set(port_sym, Integer::New(port, node_isolate));
break;
Local<FunctionTemplate> constructor = FunctionTemplate::New(New);
constructor->InstanceTemplate()->SetInternalFieldCount(1);
- constructor->SetClassName(String::NewSymbol("Timer"));
+ constructor->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Timer"));
NODE_SET_METHOD(constructor, "now", Now);
NODE_SET_PROTOTYPE_METHOD(constructor, "getRepeat", GetRepeat);
NODE_SET_PROTOTYPE_METHOD(constructor, "again", Again);
- ontimeout_sym = String::New("ontimeout");
+ ontimeout_sym = FIXED_ONE_BYTE_STRING(node_isolate, "ontimeout");
- target->Set(String::NewSymbol("Timer"), constructor->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Timer"),
+ constructor->GetFunction());
}
private:
// Notify about error
Local<Value> arg = String::Concat(
- String::New("write cb error, status: "),
+ FIXED_ONE_BYTE_STRING(node_isolate, "write cb error, status: "),
Integer::New(status, node_isolate)->ToString());
MakeCallback(callbacks->object(), onerror_sym, 1, &arg);
callbacks->InvokeQueued(status);
case SSL_ERROR_WANT_WRITE:
break;
case SSL_ERROR_ZERO_RETURN:
- return scope.Close(String::NewSymbol("ZERO_RETURN"));
+ return scope.Close(FIXED_ONE_BYTE_STRING(node_isolate, "ZERO_RETURN"));
break;
default:
{
assert(bio != NULL);
ERR_print_errors(bio);
BIO_get_mem_ptr(bio, &mem);
- Handle<Value> r = Exception::Error(String::New(mem->data, mem->length));
+ Local<String> message =
+ OneByteString(node_isolate, mem->data, mem->length);
+ Local<Value> exception = Exception::Error(message);
BIO_free_all(bio);
- return scope.Close(r);
+ return scope.Close(exception);
}
}
return Handle<Value>();
// We requested a certificate and they did not send us one.
// Definitely an error.
// XXX is this the right error message?
- Local<String> s = String::New("UNABLE_TO_GET_ISSUER_CERT");
+ Local<String> s =
+ FIXED_ONE_BYTE_STRING(node_isolate, "UNABLE_TO_GET_ISSUER_CERT");
return args.GetReturnValue().Set(Exception::Error(s));
}
X509_free(peer_cert);
CASE_X509_ERR(CERT_UNTRUSTED)
CASE_X509_ERR(CERT_REJECTED)
default:
- s = String::New(X509_verify_cert_error_string(x509_verify_error));
+ s = OneByteString(node_isolate,
+ X509_verify_cert_error_string(x509_verify_error));
break;
}
if (s.IsEmpty()) {
- s = String::New(reason);
+ s = OneByteString(node_isolate, reason);
}
args.GetReturnValue().Set(Exception::Error(s));
if (hello.servername() == NULL) {
hello_obj->Set(servername_sym, String::Empty(node_isolate));
} else {
- Local<String> servername = String::New(
- reinterpret_cast<const char*>(hello.servername()),
- hello.servername_size());
+ Local<String> servername = OneByteString(node_isolate,
+ hello.servername(),
+ hello.servername_size());
hello_obj->Set(servername_sym, servername);
}
hello_obj->Set(tls_ticket_sym, Boolean::New(hello.has_ticket()));
0,
X509_NAME_FLAGS) > 0) {
BIO_get_mem_ptr(bio, &mem);
- info->Set(subject_sym, String::New(mem->data, mem->length));
+ info->Set(subject_sym,
+ OneByteString(node_isolate, mem->data, mem->length));
}
(void) BIO_reset(bio);
0,
X509_NAME_FLAGS) > 0) {
BIO_get_mem_ptr(bio, &mem);
- info->Set(issuer_sym, String::New(mem->data, mem->length));
+ info->Set(issuer_sym,
+ OneByteString(node_isolate, mem->data, mem->length));
}
(void) BIO_reset(bio);
assert(rv == 1);
BIO_get_mem_ptr(bio, &mem);
- info->Set(subjectaltname_sym, String::New(mem->data, mem->length));
+ info->Set(subjectaltname_sym,
+ OneByteString(node_isolate, mem->data, mem->length));
(void) BIO_reset(bio);
}
NULL != (rsa = EVP_PKEY_get1_RSA(pkey))) {
BN_print(bio, rsa->n);
BIO_get_mem_ptr(bio, &mem);
- info->Set(modulus_sym, String::New(mem->data, mem->length) );
+ info->Set(modulus_sym,
+ OneByteString(node_isolate, mem->data, mem->length));
(void) BIO_reset(bio);
BN_print(bio, rsa->e);
BIO_get_mem_ptr(bio, &mem);
- info->Set(exponent_sym, String::New(mem->data, mem->length) );
+ info->Set(exponent_sym,
+ OneByteString(node_isolate, mem->data, mem->length));
(void) BIO_reset(bio);
}
ASN1_TIME_print(bio, X509_get_notBefore(peer_cert));
BIO_get_mem_ptr(bio, &mem);
- info->Set(valid_from_sym, String::New(mem->data, mem->length));
+ info->Set(valid_from_sym,
+ OneByteString(node_isolate, mem->data, mem->length));
(void) BIO_reset(bio);
ASN1_TIME_print(bio, X509_get_notAfter(peer_cert));
BIO_get_mem_ptr(bio, &mem);
- info->Set(valid_to_sym, String::New(mem->data, mem->length));
+ info->Set(valid_to_sym,
+ OneByteString(node_isolate, mem->data, mem->length));
BIO_free_all(bio);
unsigned int md_size, i;
else
fingerprint[0] = '\0';
- info->Set(fingerprint_sym, String::New(fingerprint));
+ info->Set(fingerprint_sym, OneByteString(node_isolate, fingerprint));
}
STACK_OF(ASN1_OBJECT)* eku = static_cast<STACK_OF(ASN1_OBJECT)*>(
for (int i = 0; i < sk_ASN1_OBJECT_num(eku); i++) {
memset(buf, 0, sizeof(buf));
OBJ_obj2txt(buf, sizeof(buf) - 1, sk_ASN1_OBJECT_value(eku, i), 1);
- ext_key_usage->Set(Integer::New(i, node_isolate), String::New(buf));
+ ext_key_usage->Set(Integer::New(i, node_isolate),
+ OneByteString(node_isolate, buf));
}
sk_ASN1_OBJECT_pop_free(eku, ASN1_OBJECT_free);
if (sess->tlsext_hostname == NULL) {
info->Set(servername_sym, False(node_isolate));
} else {
- info->Set(servername_sym, String::New(sess->tlsext_hostname));
+ info->Set(servername_sym,
+ OneByteString(node_isolate, sess->tlsext_hostname));
}
#endif
args.GetReturnValue().Set(info);
const char* cipher_version = SSL_CIPHER_get_version(c);
Local<Object> info = Object::New();
- info->Set(name_sym, String::New(cipher_name));
- info->Set(version_sym, String::New(cipher_version));
+ info->Set(name_sym, OneByteString(node_isolate, cipher_name));
+ info->Set(version_sym, OneByteString(node_isolate, cipher_version));
args.GetReturnValue().Set(info);
}
result = Null(node_isolate);
break;
case OPENSSL_NPN_NEGOTIATED:
- result = String::New(reinterpret_cast<const char*>(*out), *outlen);
+ result = OneByteString(node_isolate, *out, *outlen);
break;
case OPENSSL_NPN_NO_OVERLAP:
result = False(node_isolate);
}
args.GetReturnValue().Set(
- String::New(reinterpret_cast<const char*>(npn_proto), npn_proto_len));
+ OneByteString(node_isolate, npn_proto, npn_proto_len));
}
const char* servername = SSL_get_servername(wrap->ssl_,
TLSEXT_NAMETYPE_host_name);
if (servername != NULL) {
- args.GetReturnValue().Set(String::New(servername));
+ args.GetReturnValue().Set(OneByteString(node_isolate, servername));
} else {
args.GetReturnValue().Set(false);
}
Local<FunctionTemplate> t = FunctionTemplate::New();
t->InstanceTemplate()->SetInternalFieldCount(1);
- t->SetClassName(String::NewSymbol("TLSWrap"));
+ t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "TLSWrap"));
NODE_SET_PROTOTYPE_METHOD(t, "start", Start);
NODE_SET_PROTOTYPE_METHOD(t, "getPeerCertificate", GetPeerCertificate);
tlsWrap.Reset(node_isolate, t->GetFunction());
- onread_sym = String::New("onread");
- onerror_sym = String::New("onerror");
- onhandshakestart_sym = String::New("onhandshakestart");
- onhandshakedone_sym = String::New("onhandshakedone");
- onclienthello_sym = String::New("onclienthello");
- onnewsession_sym = String::New("onnewsession");
-
- subject_sym = String::New("subject");
- issuer_sym = String::New("issuer");
- valid_from_sym = String::New("valid_from");
- valid_to_sym = String::New("valid_to");
- subjectaltname_sym = String::New("subjectaltname");
- modulus_sym = String::New("modulus");
- exponent_sym = String::New("exponent");
- fingerprint_sym = String::New("fingerprint");
- name_sym = String::New("name");
- version_sym = String::New("version");
- ext_key_usage_sym = String::New("ext_key_usage");
- sessionid_sym = String::New("sessionId");
- tls_ticket_sym = String::New("tlsTicket");
- servername_sym = String::New("servername");
- sni_context_sym = String::New("sni_context");
+ onread_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onread");
+ onerror_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onerror");
+ onhandshakestart_sym =
+ FIXED_ONE_BYTE_STRING(node_isolate, "onhandshakestart");
+ onhandshakedone_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onhandshakedone");
+ onclienthello_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onclienthello");
+ onnewsession_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onnewsession");
+
+ subject_sym = FIXED_ONE_BYTE_STRING(node_isolate, "subject");
+ issuer_sym = FIXED_ONE_BYTE_STRING(node_isolate, "issuer");
+ valid_from_sym = FIXED_ONE_BYTE_STRING(node_isolate, "valid_from");
+ valid_to_sym = FIXED_ONE_BYTE_STRING(node_isolate, "valid_to");
+ subjectaltname_sym = FIXED_ONE_BYTE_STRING(node_isolate, "subjectaltname");
+ modulus_sym = FIXED_ONE_BYTE_STRING(node_isolate, "modulus");
+ exponent_sym = FIXED_ONE_BYTE_STRING(node_isolate, "exponent");
+ fingerprint_sym = FIXED_ONE_BYTE_STRING(node_isolate, "fingerprint");
+ name_sym = FIXED_ONE_BYTE_STRING(node_isolate, "name");
+ version_sym = FIXED_ONE_BYTE_STRING(node_isolate, "version");
+ ext_key_usage_sym = FIXED_ONE_BYTE_STRING(node_isolate, "ext_key_usage");
+ sessionid_sym = FIXED_ONE_BYTE_STRING(node_isolate, "sessionId");
+ tls_ticket_sym = FIXED_ONE_BYTE_STRING(node_isolate, "tlsTicket");
+ servername_sym = FIXED_ONE_BYTE_STRING(node_isolate, "servername");
+ sni_context_sym = FIXED_ONE_BYTE_STRING(node_isolate, "sni_context");
}
} // namespace node
HandleScope scope(node_isolate);
Local<FunctionTemplate> t = FunctionTemplate::New(New);
- t->SetClassName(String::NewSymbol("TTY"));
+ t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "TTY"));
t->InstanceTemplate()->SetInternalFieldCount(1);
enum PropertyAttribute attributes =
static_cast<PropertyAttribute>(v8::ReadOnly | v8::DontDelete);
- t->InstanceTemplate()->SetAccessor(String::New("fd"),
+ t->InstanceTemplate()->SetAccessor(FIXED_ONE_BYTE_STRING(node_isolate, "fd"),
StreamWrap::GetFD,
NULL,
Handle<Value>(),
NODE_SET_METHOD(target, "guessHandleType", GuessHandleType);
ttyConstructorTmpl.Reset(node_isolate, t);
- target->Set(String::NewSymbol("TTY"), t->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "TTY"), t->GetFunction());
}
abort();
}
- args.GetReturnValue().Set(String::New(type));
+ args.GetReturnValue().Set(OneByteString(node_isolate, type));
}
void UDPWrap::Initialize(Handle<Object> target) {
HandleScope scope(node_isolate);
- buffer_sym = String::New("buffer");
- oncomplete_sym = String::New("oncomplete");
- onmessage_sym = String::New("onmessage");
+ buffer_sym = FIXED_ONE_BYTE_STRING(node_isolate, "buffer");
+ oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
+ onmessage_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onmessage");
Local<FunctionTemplate> t = FunctionTemplate::New(New);
t->InstanceTemplate()->SetInternalFieldCount(1);
- t->SetClassName(String::NewSymbol("UDP"));
+ t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "UDP"));
enum PropertyAttribute attributes =
static_cast<PropertyAttribute>(v8::ReadOnly | v8::DontDelete);
- t->InstanceTemplate()->SetAccessor(String::New("fd"),
+ t->InstanceTemplate()->SetAccessor(FIXED_ONE_BYTE_STRING(node_isolate, "fd"),
UDPWrap::GetFD,
NULL,
Handle<Value>(),
NODE_SET_PROTOTYPE_METHOD(t, "unref", HandleWrap::Unref);
constructor.Reset(node_isolate, t->GetFunction());
- target->Set(String::NewSymbol("UDP"), t->GetFunction());
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "UDP"), t->GetFunction());
}
int err = args[0]->Int32Value();
if (err >= 0) return ThrowError("err >= 0");
const char* name = uv_err_name(err);
- args.GetReturnValue().Set(String::New(name));
+ args.GetReturnValue().Set(OneByteString(node_isolate, name));
}
void Initialize(Handle<Object> target) {
v8::HandleScope handle_scope(node_isolate);
- target->Set(String::New("errname"),
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "errname"),
FunctionTemplate::New(ErrName)->GetFunction());
-#define V(name, _) target->Set(String::New("UV_" # name), \
- Integer::New(UV_ ## name, node_isolate));
+#define V(name, _) \
+ target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "UV_" # name), \
+ Integer::New(UV_ ## name, node_isolate));
UV_ERRNO_MAP(V)
#undef V
}
projects / platform / upstream / nodejs.git / commitdiff