int postfix_len = i::StrLength(postfix);
int buf_len = prefix_len + str_len + postfix_len;
- char* buf = i::NewArray<char>(buf_len);
+ i::ScopedVector<char> buf(buf_len);
// Write prefix.
- char* ptr = buf;
+ char* ptr = buf.start();
memcpy(ptr, prefix, prefix_len * v8::internal::kCharSize);
ptr += prefix_len;
memcpy(ptr, postfix, postfix_len * v8::internal::kCharSize);
// Copy the buffer into a heap-allocated string and return it.
- Local<String> result = v8::String::New(buf, buf_len);
- i::DeleteArray(buf);
+ Local<String> result = v8::String::New(buf.start(), buf_len);
return result;
}
}
name);
ASSERT(js_builtin->IsJSFunction());
Handle<JSFunction> function(Handle<JSFunction>::cast(js_builtin));
- Vector<Object**> argv(Vector<Object**>::New(args.length() - 1));
+ ScopedVector<Object**> argv(args.length() - 1);
int n_args = args.length() - 1;
for (int i = 0; i < n_args; i++) {
argv[i] = args.at<Object>(i + 1).location();
n_args,
argv.start(),
&pending_exception);
- argv.Dispose();
if (pending_exception) return Failure::Exception();
return *result;
}
buf.GetNext();
len++;
}
- int16_t* temp = NewArray<int16_t>(len + 1);
+ ScopedVector<int16_t> temp(len + 1);
buf.Reset(*message, StrLength(*message));
for (int i = 0; i < len; i++) {
temp[i] = buf.GetNext();
}
// Send the request received to the debugger.
- v8::Debug::SendCommand(reinterpret_cast<const uint16_t *>(temp), len);
- DeleteArray(temp);
+ v8::Debug::SendCommand(reinterpret_cast<const uint16_t *>(temp.start()),
+ len);
}
}
#ifdef ENABLE_DEBUGGER_SUPPORT
static void PrintLn(v8::Local<v8::Value> value) {
v8::Local<v8::String> s = value->ToString();
- char* data = NewArray<char>(s->Length() + 1);
- if (data == NULL) {
+ ScopedVector<char> data(s->Length() + 1);
+ if (data.start() == NULL) {
V8::FatalProcessOutOfMemory("PrintLn");
return;
}
- s->WriteAscii(data);
- PrintF("%s\n", data);
- DeleteArray(data);
+ s->WriteAscii(data.start());
+ PrintF("%s\n", data.start());
}
// static
int FlagList::SetFlagsFromString(const char* str, int len) {
// make a 0-terminated copy of str
- char* copy0 = NewArray<char>(len + 1);
- memcpy(copy0, str, len);
+ ScopedVector<char> copy0(len + 1);
+ memcpy(copy0.start(), str, len);
copy0[len] = '\0';
// strip leading white space
- char* copy = SkipWhiteSpace(copy0);
+ char* copy = SkipWhiteSpace(copy0.start());
// count the number of 'arguments'
int argc = 1; // be compatible with SetFlagsFromCommandLine()
}
// allocate argument array
- char** argv = NewArray<char*>(argc);
+ ScopedVector<char*> argv(argc);
// split the flags string into arguments
argc = 1; // be compatible with SetFlagsFromCommandLine()
}
// set the flags
- int result = SetFlagsFromCommandLine(&argc, argv, false);
-
- // cleanup
- DeleteArray(argv);
- DeleteArray(copy0);
+ int result = SetFlagsFromCommandLine(&argc, argv.start(), false);
return result;
}
void Logger::LogCompiledFunctions() {
HandleScope scope;
const int compiled_funcs_count = EnumerateCompiledFunctions(NULL);
- Handle<SharedFunctionInfo>* sfis =
- NewArray< Handle<SharedFunctionInfo> >(compiled_funcs_count);
- EnumerateCompiledFunctions(sfis);
+ ScopedVector< Handle<SharedFunctionInfo> > sfis(compiled_funcs_count);
+ EnumerateCompiledFunctions(sfis.start());
// During iteration, there can be heap allocation due to
// GetScriptLineNumber call.
Logger::LAZY_COMPILE_TAG, shared->code(), *func_name));
}
}
-
- DeleteArray(sfis);
}
if (FLAG_enable_slow_asserts) {
// Assert that the resource and the string are equivalent.
ASSERT(static_cast<size_t>(this->length()) == resource->length());
- SmartPointer<uc16> smart_chars(NewArray<uc16>(this->length()));
- String::WriteToFlat(this, *smart_chars, 0, this->length());
- ASSERT(memcmp(*smart_chars,
+ ScopedVector<uc16> smart_chars(this->length());
+ String::WriteToFlat(this, smart_chars.start(), 0, this->length());
+ ASSERT(memcmp(smart_chars.start(),
resource->data(),
- resource->length() * sizeof(**smart_chars)) == 0);
+ resource->length() * sizeof(smart_chars[0])) == 0);
}
#endif // DEBUG
if (FLAG_enable_slow_asserts) {
// Assert that the resource and the string are equivalent.
ASSERT(static_cast<size_t>(this->length()) == resource->length());
- SmartPointer<char> smart_chars(NewArray<char>(this->length()));
- String::WriteToFlat(this, *smart_chars, 0, this->length());
- ASSERT(memcmp(*smart_chars,
+ ScopedVector<char> smart_chars(this->length());
+ String::WriteToFlat(this, smart_chars.start(), 0, this->length());
+ ASSERT(memcmp(smart_chars.start(),
resource->data(),
- resource->length()*sizeof(**smart_chars)) == 0);
+ resource->length() * sizeof(smart_chars[0])) == 0);
}
#endif // DEBUG
int OS::StackWalk(Vector<OS::StackFrame> frames) {
int frames_size = frames.length();
- void** addresses = NewArray<void*>(frames_size);
+ ScopedVector<void*> addresses(frames_size);
- int frames_count = backtrace(addresses, frames_size);
+ int frames_count = backtrace(addresses.start(), frames_size);
- char** symbols;
- symbols = backtrace_symbols(addresses, frames_count);
+ char** symbols = backtrace_symbols(addresses, frames_count);
if (symbols == NULL) {
- DeleteArray(addresses);
return kStackWalkError;
}
frames[i].text[kStackWalkMaxTextLen - 1] = '\0';
}
- DeleteArray(addresses);
free(symbols);
return frames_count;
// backtrace is a glibc extension.
#ifdef __GLIBC__
int frames_size = frames.length();
- void** addresses = NewArray<void*>(frames_size);
+ ScopedVector<void*> addresses(frames_size);
- int frames_count = backtrace(addresses, frames_size);
+ int frames_count = backtrace(addresses.start(), frames_size);
- char** symbols;
- symbols = backtrace_symbols(addresses, frames_count);
+ char** symbols = backtrace_symbols(addresses.start(), frames_count);
if (symbols == NULL) {
- DeleteArray(addresses);
return kStackWalkError;
}
frames[i].text[kStackWalkMaxTextLen - 1] = '\0';
}
- DeleteArray(addresses);
free(symbols);
return frames_count;
return 0;
int frames_size = frames.length();
- void** addresses = NewArray<void*>(frames_size);
- int frames_count = backtrace(addresses, frames_size);
+ ScopedVector<void*> addresses(frames_size);
- char** symbols;
- symbols = backtrace_symbols(addresses, frames_count);
+ int frames_count = backtrace(addresses.start(), frames_size.start());
+
+ char** symbols = backtrace_symbols(addresses.start(), frames_count);
if (symbols == NULL) {
- DeleteArray(addresses);
return kStackWalkError;
}
frames[i].text[kStackWalkMaxTextLen - 1] = '\0';
}
- DeleteArray(addresses);
free(symbols);
return frames_count;
int OS::StackWalk(Vector<OS::StackFrame> frames) {
int frames_size = frames.length();
- void** addresses = NewArray<void*>(frames_size);
+ ScopedVector<void*> addresses(frames_size);
- int frames_count = backtrace(addresses, frames_size);
+ int frames_count = backtrace(addresses.start(), frames_size);
- char** symbols;
- symbols = backtrace_symbols(addresses, frames_count);
+ char** symbols = backtrace_symbols(addresses.start(), frames_count);
if (symbols == NULL) {
- DeleteArray(addresses);
return kStackWalkError;
}
frames[i].text[kStackWalkMaxTextLen - 1] = '\0';
}
- DeleteArray(addresses);
free(symbols);
return frames_count;
// Try to locate a symbol for this frame.
DWORD64 symbol_displacement;
- IMAGEHLP_SYMBOL64* symbol = NULL;
- symbol = NewArray<IMAGEHLP_SYMBOL64>(kStackWalkMaxNameLen);
+ SmartPointer<IMAGEHLP_SYMBOL64> symbol(
+ NewArray<IMAGEHLP_SYMBOL64>(kStackWalkMaxNameLen));
if (!symbol) return kStackWalkError; // Out of memory.
- memset(symbol, 0, sizeof(IMAGEHLP_SYMBOL64) + kStackWalkMaxNameLen);
+ memset(*symbol, 0, sizeof(IMAGEHLP_SYMBOL64) + kStackWalkMaxNameLen);
symbol->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
symbol->MaxNameLength = kStackWalkMaxNameLen;
ok = _SymGetSymFromAddr64(process_handle, // hProcess
stack_frame.AddrPC.Offset, // Address
&symbol_displacement, // Displacement
- symbol); // Symbol
+ *symbol); // Symbol
if (ok) {
// Try to locate more source information for the symbol.
IMAGEHLP_LINE64 Line;
// module will never be found).
int err = GetLastError();
if (err != ERROR_MOD_NOT_FOUND) {
- DeleteArray(symbol);
break;
}
}
- DeleteArray(symbol);
frames_count++;
}
~ScopedVector() {
DeleteArray(this->start());
}
+
+ private:
+ DISALLOW_IMPLICIT_CONSTRUCTORS(ScopedVector);
};