'WARNINGFLAGS': ['/W3', '/WX', '/wd4355', '/wd4800'],
'CCFLAGS': ['$DIALECTFLAGS', '$WARNINGFLAGS'],
'CXXFLAGS': ['$CCFLAGS', '/GR-', '/Gy'],
- 'CPPDEFINES': ['WIN32', '_CRT_SECURE_NO_DEPRECATE',
- '_CRT_NONSTDC_NO_DEPRECATE', '_USE_32BIT_TIME_T',
- 'PCRE_STATIC'],
+ 'CPPDEFINES': ['WIN32', '_USE_32BIT_TIME_T', 'PCRE_STATIC'],
'LINKFLAGS': ['/NOLOGO', '/MACHINE:X86', '/INCREMENTAL:NO',
'/NXCOMPAT', '/IGNORE:4221'],
'ARFLAGS': ['/NOLOGO'],
stop_time_(0) { // initialize to avoid compiler complaints
int len = wcslen(name);
// we prepend the name with 'c.' to indicate that it is a counter.
- name_ = NewArray<wchar_t>(len+3);
- wcscpy(name_, L"t:");
- wcscpy(&name_[2], name);
+ name_ = Vector<wchar_t>::New(len+3);
+ OS::WcsCpy(name_, L"t:");
+ OS::WcsCpy(name_ + 2, name);
}
// Start the timer.
id_(id) {
int len = wcslen(name);
// we prepend the name with 'c:' to indicate that it is a counter.
- name_ = NewArray<wchar_t>(len+3);
- wcscpy(name_, L"c:");
- wcscpy(&name_[2], name);
+ name_ = Vector<wchar_t>::New(len+3);
+ OS::WcsCpy(name_, L"c:");
+ OS::WcsCpy(name_ + 2, name);
};
~StatsCounter() {
- DeleteArray(name_);
+ name_.Dispose();
}
// Sets the counter to a specific value.
if (lookup_done_)
return ptr_;
lookup_done_ = true;
- ptr_ = StatsTable::FindLocation(name_);
+ ptr_ = StatsTable::FindLocation(name_.start());
return ptr_;
}
- wchar_t* name_;
+ Vector<wchar_t> name_;
bool lookup_done_;
int* ptr_;
int id_;
// Writes one disassembled instruction into 'buffer' (0-terminated).
// Returns the length of the disassembled machine instruction in bytes.
- int InstructionDecode(char* buffer, const int buffer_size, byte* instruction);
+ int InstructionDecode(v8::internal::Vector<char> buffer, byte* instruction);
private:
const NameConverter& converter_;
- char tmp_buffer_[128];
+ v8::internal::EmbeddedVector<char, 128> tmp_buffer_;
unsigned int tmp_buffer_pos_;
bool abort_on_unimplemented_;
void DisassemblerIA32::AppendToBuffer(const char* format, ...) {
- char* str = tmp_buffer_ + tmp_buffer_pos_;
- int size = (sizeof tmp_buffer_) - tmp_buffer_pos_;
+ v8::internal::Vector<char> buf = tmp_buffer_ + tmp_buffer_pos_;
va_list args;
va_start(args, format);
-#ifdef WIN32
- int result = _vsnprintf(str, size, format, args);
-#else
- int result = vsnprintf(str, size, format, args);
-#endif
+ int result = v8::internal::OS::VSNPrintF(buf, format, args);
va_end(args);
tmp_buffer_pos_ += result;
}
// Disassembled instruction '*instr' and writes it intro 'out_buffer'.
-int DisassemblerIA32::InstructionDecode(char* out_buffer,
- const int out_buffer_size,
+int DisassemblerIA32::InstructionDecode(v8::internal::Vector<char> out_buffer,
byte* instr) {
tmp_buffer_pos_ = 0; // starting to write as position 0
byte* data = instr;
// Instruction bytes.
for (byte* bp = instr; bp < data; bp++) {
outp += v8::internal::OS::SNPrintF(out_buffer + outp,
- out_buffer_size - outp,
"%02x",
*bp);
}
for (int i = 6 - instr_len; i >= 0; i--) {
outp += v8::internal::OS::SNPrintF(out_buffer + outp,
- out_buffer_size - outp,
" ");
}
outp += v8::internal::OS::SNPrintF(out_buffer + outp,
- out_buffer_size - outp,
" %s",
- tmp_buffer_);
+ tmp_buffer_.start());
return instr_len;
}
const char* NameConverter::NameOfAddress(byte* addr) const {
- static char tmp_buffer[32];
-#ifdef WIN32
- _snprintf(tmp_buffer, sizeof tmp_buffer, "%p", addr);
-#else
- snprintf(tmp_buffer, sizeof tmp_buffer, "%p", addr);
-#endif
- return tmp_buffer;
+ v8::internal::EmbeddedVector<char, 32> tmp_buffer;
+ v8::internal::OS::SNPrintF(tmp_buffer, "%p", addr);
+ return tmp_buffer.start();
}
Disassembler::~Disassembler() {}
-int Disassembler::InstructionDecode(char* buffer,
- const int buffer_size,
+int Disassembler::InstructionDecode(v8::internal::Vector<char> buffer,
byte* instruction) {
DisassemblerIA32 d(converter_, false /*do not crash if unimplemented*/);
- return d.InstructionDecode(buffer, buffer_size, instruction);
+ return d.InstructionDecode(buffer, instruction);
}
/*static*/ void Disassembler::Disassemble(FILE* f, byte* begin, byte* end) {
Disassembler d;
for (byte* pc = begin; pc < end;) {
- char buffer[128];
+ v8::internal::EmbeddedVector<char, 128> buffer;
buffer[0] = '\0';
byte* prev_pc = pc;
- pc += d.InstructionDecode(buffer, sizeof buffer, pc);
+ pc += d.InstructionDecode(buffer, pc);
fprintf(f, "%p", prev_pc);
fprintf(f, " ");
for (int i = 6 - (pc - prev_pc); i >= 0; i--) {
fprintf(f, " ");
}
- fprintf(f, " %s\n", buffer);
+ fprintf(f, " %s\n", buffer.start());
}
}
// Writes one disassembled instruction into 'buffer' (0-terminated).
// Returns the length of the disassembled machine instruction in bytes.
- int InstructionDecode(char* buffer, const int buffer_size, byte* instruction);
+ int InstructionDecode(v8::internal::Vector<char> buffer, byte* instruction);
// Returns -1 if instruction does not mark the beginning of a constant pool,
// or the number of entries in the constant pool beginning here.
const char* V8NameConverter::NameOfAddress(byte* pc) const {
- static char buffer[128];
+ static v8::internal::EmbeddedVector<char, 128> buffer;
const char* name = Builtins::Lookup(pc);
if (name != NULL) {
- OS::SNPrintF(buffer, sizeof buffer, "%s (%p)", name, pc);
- return buffer;
+ OS::SNPrintF(buffer, "%s (%p)", name, pc);
+ return buffer.start();
}
if (code_ != NULL) {
int offs = pc - code_->instruction_start();
// print as code offset, if it seems reasonable
if (0 <= offs && offs < code_->instruction_size()) {
- OS::SNPrintF(buffer, sizeof buffer, "%d (%p)", offs, pc);
- return buffer;
+ OS::SNPrintF(buffer, "%d (%p)", offs, pc);
+ return buffer.start();
}
}
AssertNoAllocation no_alloc;
ExternalReferenceEncoder ref_encoder;
- char decode_buffer[128];
- char out_buffer[kOutBufferSize];
+ v8::internal::EmbeddedVector<char, 128> decode_buffer;
+ v8::internal::EmbeddedVector<char, kOutBufferSize> out_buffer;
byte* pc = begin;
disasm::Disassembler d(converter);
RelocIterator* it = NULL;
byte* prev_pc = pc;
if (constants > 0) {
OS::SNPrintF(decode_buffer,
- sizeof(decode_buffer),
"%08x constant",
*reinterpret_cast<int32_t*>(pc));
constants--;
int num_const = d.ConstantPoolSizeAt(pc);
if (num_const >= 0) {
OS::SNPrintF(decode_buffer,
- sizeof(decode_buffer),
"%08x constant pool begin",
*reinterpret_cast<int32_t*>(pc));
constants = num_const;
pc += 4;
} else {
decode_buffer[0] = '\0';
- pc += d.InstructionDecode(decode_buffer, sizeof decode_buffer, pc);
+ pc += d.InstructionDecode(decode_buffer, pc);
}
}
}
}
- StringBuilder out(out_buffer, sizeof(out_buffer));
+ StringBuilder out(out_buffer.start(), out_buffer.length());
// Comments.
for (int i = 0; i < comments.length(); i++) {
out.AddFormatted("%p %4d ", prev_pc, prev_pc - begin);
// Instruction.
- out.AddFormatted("%s", decode_buffer);
+ out.AddFormatted("%s", decode_buffer.start());
// Print all the reloc info for this instruction which are not comments.
for (int i = 0; i < pcs.length(); i++) {
static const size_t kErrorPrefixLength = 25; // strlen is not constant
ASSERT(strlen(kErrorPrefix) == kErrorPrefixLength);
static const int kMaxErrorLength = kMaxPathLength + kErrorPrefixLength;
- char error_buffer[kMaxErrorLength + 1];
- OS::SNPrintF(error_buffer, kMaxErrorLength, "%s%s",
- kErrorPrefix, file_name_buffer);
- v8::Handle<v8::String> error = v8::String::New(error_buffer);
+ EmbeddedVector<char, kMaxErrorLength + 1> error_buffer;
+ OS::SNPrintF(error_buffer, "%s%s", kErrorPrefix, file_name_buffer);
+ v8::Handle<v8::String> error =
+ v8::String::New(error_buffer.start(), error_buffer.length());
v8::ThrowException(v8::Exception::Error(error));
return result;
}
static char* ToString(Flag::Type type, FlagValue* variable) {
- char* value = NULL;
+ Vector<char> value;
switch (type) {
case Flag::BOOL:
- value = NewArray<char>(6);
- OS::SNPrintF(value, 6, "%s", (variable->b ? "true" : "false"));
+ value = Vector<char>::New(6);
+ OS::SNPrintF(value, "%s", (variable->b ? "true" : "false"));
break;
case Flag::INT:
- value = NewArray<char>(12);
- OS::SNPrintF(value, 12, "%d", variable->i);
+ value = Vector<char>::New(12);
+ OS::SNPrintF(value, "%d", variable->i);
break;
case Flag::FLOAT:
- value = NewArray<char>(20);
- OS::SNPrintF(value, 20, "%f", variable->f);
+ value = Vector<char>::New(20);
+ OS::SNPrintF(value, "%f", variable->f);
break;
case Flag::STRING:
if (variable->s) {
int length = strlen(variable->s) + 1;
- value = NewArray<char>(length);
- OS::SNPrintF(value, length, "%s", variable->s);
+ value = Vector<char>::New(length);
+ OS::SNPrintF(value, "%s", variable->s);
} else {
- value = NewArray<char>(5);
- OS::SNPrintF(value, 5, "NULL");
+ value = Vector<char>::New(5);
+ OS::SNPrintF(value, "NULL");
}
break;
}
- ASSERT(value != NULL);
- return value;
+ ASSERT(!value.is_empty());
+ return value.start();
}
List<char *>* args = new List<char*>(8);
for (Flag* f = list_; f != NULL; f = f->next()) {
if (!f->IsDefault()) {
- char* cmdline_flag;
+ Vector<char> cmdline_flag;
if (f->type() != Flag::BOOL || *(f->bool_variable())) {
int length = strlen(f->name()) + 2 + 1;
- cmdline_flag = NewArray<char>(length);
- OS::SNPrintF(cmdline_flag, length, "--%s", f->name());
+ cmdline_flag = Vector<char>::New(length);
+ OS::SNPrintF(cmdline_flag, "--%s", f->name());
} else {
int length = strlen(f->name()) + 4 + 1;
- cmdline_flag = NewArray<char>(length);
- OS::SNPrintF(cmdline_flag, length, "--no%s", f->name());
+ cmdline_flag = Vector<char>::New(length);
+ OS::SNPrintF(cmdline_flag, "--no%s", f->name());
}
- args->Add(cmdline_flag);
+ args->Add(cmdline_flag.start());
if (f->type() != Flag::BOOL) {
args->Add(f->StringValue());
}
if (strcmp(FLAG_logfile, "-") == 0) {
logfile_ = stdout;
} else {
- logfile_ = fopen(FLAG_logfile, "w");
+ logfile_ = OS::FOpen(FLAG_logfile, "w");
}
mutex_ = OS::CreateMutex();
}
// buffer that is plenty big enough for any floating point number, then
// print that using vsnprintf (which may truncate but never allocate if
// there is no more space in the buffer).
- char buffer[100];
- OS::SNPrintF(buffer, sizeof(buffer), "%.16g", Number());
- accumulator->Add("%s", buffer);
+ EmbeddedVector<char, 100> buffer;
+ OS::SNPrintF(buffer, "%.16g", Number());
+ accumulator->Add("%s", buffer.start());
}
}
+FILE* OS::FOpen(const char* path, const char* mode) {
+ return fopen(path, mode);
+}
+
+
void OS::Print(const char* format, ...) {
va_list args;
va_start(args, format);
}
-int OS::SNPrintF(char* str, size_t size, const char* format, ...) {
+int OS::SNPrintF(Vector<char> str, const char* format, ...) {
va_list args;
va_start(args, format);
- int result = VSNPrintF(str, size, format, args);
+ int result = VSNPrintF(str, format, args);
va_end(args);
return result;
}
-int OS::VSNPrintF(char* str, size_t size, const char* format, va_list args) {
- int n = vsnprintf(str, size, format, args); // forward to linux.
- if (n < 0 || static_cast<size_t>(n) >= size) {
- str[size - 1] = '\0';
+int OS::VSNPrintF(Vector<char> str,
+ const char* format,
+ va_list args) {
+ int n = vsnprintf(str.start(), str.length(), format, args);
+ if (n < 0 || n >= str.length()) {
+ str[str.length() - 1] = '\0';
return -1;
} else {
return n;
}
+void OS::StrNCpy(Vector<char> dest, const char* src, size_t n) {
+ strncpy(dest.start(), src, n);
+}
+
+
+void OS::WcsCpy(Vector<wchar_t> dest, const wchar_t* src) {
+ wcscpy(dest.start(), src);
+}
+
+
+char *OS::StrDup(const char* str) {
+ return strdup(str);
+}
+
+
double OS::nan_value() { return NAN; }
// We keep the lowest and highest addresses mapped as a quick way of
frames[i].address = addresses[i];
// Format a text representation of the frame based on the information
// available.
- SNPrintF(frames[i].text, kStackWalkMaxTextLen, "%s", symbols[i]);
+ SNPrintF(MutableCStrVector(frames[i].text, kStackWalkMaxTextLen),
+ "%s",
+ symbols[i]);
// Make sure line termination is in place.
frames[i].text[kStackWalkMaxTextLen - 1] = '\0';
}
// Case-insensitive string comparisons. Use stricmp() on Win32. Usually defined
// in strings.h.
int strcasecmp(const char* s1, const char* s2) {
- return stricmp(s1, s2);
+ return _stricmp(s1, s2);
}
// Case-insensitive bounded string comparisons. Use stricmp() on Win32. Usually
// defined in strings.h.
int strncasecmp(const char* s1, const char* s2, int n) {
- return strnicmp(s1, s2, n);
+ return _strnicmp(s1, s2, n);
}
namespace v8 { namespace internal {
}
// Make standard and DST timezone names.
- _snprintf(std_tz_name_, kTzNameSize, "%S", tzinfo_.StandardName);
+ OS::SNPrintF(Vector<char>(std_tz_name_, kTzNameSize),
+ "%S",
+ tzinfo_.StandardName);
std_tz_name_[kTzNameSize - 1] = '\0';
- _snprintf(dst_tz_name_, kTzNameSize, "%S", tzinfo_.DaylightName);
+ OS::SNPrintF(Vector<char>(dst_tz_name_, kTzNameSize),
+ "%S",
+ tzinfo_.DaylightName);
dst_tz_name_[kTzNameSize - 1] = '\0';
// If OS returned empty string or resource id (like "@tzres.dll,-211")
// To properly resolve the resource identifier requires a library load,
// which is not possible in a sandbox.
if (std_tz_name_[0] == '\0' || std_tz_name_[0] == '@') {
- _snprintf(std_tz_name_, kTzNameSize - 1, "%s Standard Time",
- GuessTimezoneNameFromBias(tzinfo_.Bias));
+ OS::SNPrintF(Vector<char>(std_tz_name_, kTzNameSize - 1),
+ "%s Standard Time",
+ GuessTimezoneNameFromBias(tzinfo_.Bias));
}
if (dst_tz_name_[0] == '\0' || dst_tz_name_[0] == '@') {
- _snprintf(dst_tz_name_, kTzNameSize - 1, "%s Daylight Time",
- GuessTimezoneNameFromBias(tzinfo_.Bias));
+ OS::SNPrintF(Vector<char>(dst_tz_name_, kTzNameSize - 1),
+ "%s Daylight Time",
+ GuessTimezoneNameFromBias(tzinfo_.Bias));
}
// Timezone information initialized.
// It is important to use safe print here in order to avoid
// overflowing the buffer. We might truncate the output, but this
// does not crash.
- static const int kBufferSize = 4096;
- char buffer[kBufferSize];
- OS::VSNPrintF(buffer, kBufferSize, format, args);
- OutputDebugStringA(buffer);
+ EmbeddedVector<char, 4096> buffer;
+ OS::VSNPrintF(buffer, format, args);
+ OutputDebugStringA(buffer.start());
+ }
+}
+
+
+FILE* OS::FOpen(const char* path, const char* mode) {
+ FILE* result;
+ if (fopen_s(&result, path, mode) == 0) {
+ return result;
+ } else {
+ return NULL;
}
}
}
-int OS::SNPrintF(char* str, size_t size, const char* format, ...) {
+int OS::SNPrintF(Vector<char> str, const char* format, ...) {
va_list args;
va_start(args, format);
- int result = VSNPrintF(str, size, format, args);
+ int result = VSNPrintF(str, format, args);
va_end(args);
return result;
}
-int OS::VSNPrintF(char* str, size_t size, const char* format, va_list args) {
- // Print formated output to string. The _vsnprintf function has been
- // deprecated in MSVC. We need to define _CRT_NONSTDC_NO_DEPRECATE
- // during compilation to use it anyway. Usually defined in stdio.h.
- int n = _vsnprintf(str, size, format, args);
+int OS::VSNPrintF(Vector<char> str, const char* format, va_list args) {
+ int n = _vsnprintf_s(str.start(), str.length(), str.length(), format, args);
// Make sure to zero-terminate the string if the output was
// truncated or if there was an error.
- if (n < 0 || static_cast<size_t>(n) >= size) {
- str[size - 1] = '\0';
+ if (n < 0 || n >= str.length()) {
+ str[str.length() - 1] = '\0';
return -1;
} else {
return n;
}
+void OS::StrNCpy(Vector<char> dest, const char* src, size_t n) {
+ int result = strncpy_s(dest.start(), dest.length(), src, n);
+ USE(result); ASSERT(result == 0);
+}
+
+
+void OS::WcsCpy(Vector<wchar_t> dest, const wchar_t* src) {
+ int result = wcscpy_s(dest.start(), dest.length(), src);
+ USE(result); ASSERT(result == 0);
+}
+
+
+char *OS::StrDup(const char* str) {
+ return _strdup(str);
+}
+
+
// We keep the lowest and highest addresses mapped as a quick way of
// determining that pointers are outside the heap (used mostly in assertions
// and verification). The estimate is conservative, ie, not all addresses in
// Format a text representation of the frame based on the information
// available.
if (ok) {
- SNPrintF(frames[frames_count].text, kStackWalkMaxTextLen, "%s %s:%d:%d",
+ SNPrintF(MutableCStrVector(frames[frames_count].text,
+ kStackWalkMaxTextLen),
+ "%s %s:%d:%d",
symbol->Name, Line.FileName, Line.LineNumber,
line_displacement);
} else {
- SNPrintF(frames[frames_count].text, kStackWalkMaxTextLen, "%s",
+ SNPrintF(MutableCStrVector(frames[frames_count].text,
+ kStackWalkMaxTextLen),
+ "%s",
symbol->Name);
}
// Make sure line termination is in place.
// Returns the daylight savings offset for the given time.
static double DaylightSavingsOffset(double time);
+ static FILE* FOpen(const char* path, const char* mode);
+
// Print output to console. This is mostly used for debugging output.
// On platforms that has standard terminal output, the output
// should go to stdout.
// Safe formatting print. Ensures that str is always null-terminated.
// Returns the number of chars written, or -1 if output was truncated.
- static int SNPrintF(char* str, size_t size, const char* format, ...);
- static int VSNPrintF(char* str,
- size_t size,
+ static int SNPrintF(Vector<char> str, const char* format, ...);
+ static int VSNPrintF(Vector<char> str,
const char* format,
va_list args);
+ static void StrNCpy(Vector<char> dest, const char* src, size_t n);
+ static void WcsCpy(Vector<wchar_t> dest, const wchar_t* src);
+ static char* StrDup(const char* str);
+
// Support for profiler. Can do nothing, in which case ticks
// occuring in shared libraries will not be properly accounted
// for.
for (;;) {
va_list arguments;
va_start(arguments, format);
- int available = size_ - pos_;
- int n = OS::VSNPrintF(output_ + pos_, available, format, arguments);
+ int n = OS::VSNPrintF(Vector<char>(output_, size_) + pos_,
+ format,
+ arguments);
va_end(arguments);
if (n >= 0) {
if (var == NULL) {
PrintLiteralIndented(info, value, true);
} else {
- char buf[256];
- OS::SNPrintF(buf, sizeof(buf), "%s (mode = %s)", info,
+ EmbeddedVector<char, 256> buf;
+ OS::SNPrintF(buf, "%s (mode = %s)", info,
Variable::Mode2String(var->mode()));
- PrintLiteralIndented(buf, value, true);
+ PrintLiteralIndented(buf.start(), value, true);
}
}
void AstPrinter::VisitCountOperation(CountOperation* node) {
- char buf[128];
- OS::SNPrintF(buf, sizeof(buf), "%s %s", (node->is_prefix() ? "PRE" : "POST"),
+ EmbeddedVector<char, 128> buf;
+ OS::SNPrintF(buf, "%s %s", (node->is_prefix() ? "PRE" : "POST"),
Token::Name(node->op()));
- PrintIndentedVisit(buf, node->expression());
+ PrintIndentedVisit(buf.start(), node->expression());
}
const char* debug_register_format = "Debug::register_address(%i)";
size_t dr_format_length = strlen(debug_register_format);
for (int i = 0; i < kNumJSCallerSaved; ++i) {
- char* name = NewArray<char>(dr_format_length + 1);
- OS::SNPrintF(name, dr_format_length, debug_register_format, i);
+ Vector<char> name = Vector<char>::New(dr_format_length + 1);
+ OS::SNPrintF(name, debug_register_format, i);
Add(Debug_Address(Debug::k_register_address, i).address(),
DEBUG_ADDRESS,
Debug::k_register_address << kDebugIdShift | i,
- name);
+ name.start());
}
// Stat counters
const char* top_address_format = "Top::get_address_from_id(%i)";
size_t top_format_length = strlen(top_address_format);
for (uint16_t i = 0; i < Top::k_top_address_count; ++i) {
- char* name = NewArray<char>(top_format_length + 1);
- OS::SNPrintF(name, top_format_length, top_address_format, i);
- Add(Top::get_address_from_id((Top::AddressId)i), TOP_ADDRESS, i, name);
+ Vector<char> name = Vector<char>::New(top_format_length + 1);
+ const char* chars = name.start();
+ OS::SNPrintF(name, top_address_format, i);
+ Add(Top::get_address_from_id((Top::AddressId)i), TOP_ADDRESS, i, chars);
}
// Extensions
continue;
}
// Read this formatting directive into a temporary buffer
- const int kTempSize = 24;
- char temp_buffer[kTempSize];
- // Wrap temp buffer in a vector to get bounds checking in debug
- // mode
- Vector<char> temp(temp_buffer, kTempSize);
+ EmbeddedVector<char, 24> temp;
int format_length = 0;
// Skip over the whole control character sequence until the
// format element type
}
case 'i': case 'd': case 'u': case 'x': case 'c': case 'p': {
int value = current.data_.u_int_;
- char formatted[kTempSize];
-#ifdef WIN32
- // This is not my idea of a good time.
- _snprintf(formatted, kTempSize, temp.start(), value);
-#else
- snprintf(formatted, kTempSize, temp.start(), value);
-#endif
- Add(formatted);
+ EmbeddedVector<char, 24> formatted;
+ OS::SNPrintF(formatted, temp.start(), value);
+ Add(formatted.start());
break;
}
default:
// When the thread starts running it will allocate a fixed number of bytes
// on the stack and publish the location of this memory for others to use.
void Run() {
- char local_buffer[16 * 1024];
+ EmbeddedVector<char, 16 * 1024> local_buffer;
// Initialize the buffer with a known good value.
- strncpy(local_buffer, "Trace data was not generated.\n",
- sizeof(local_buffer));
+ OS::StrNCpy(local_buffer, "Trace data was not generated.\n",
+ local_buffer.length());
// Publish the local buffer and signal its availability.
data_ = &local_buffer[0];
// Make sure we access the buffer after the wait to remove all possibility
// of it being optimized away.
- strncpy(local_buffer, "PreallocatedMemoryThread shutting down.\n",
- sizeof(local_buffer));
+ OS::StrNCpy(local_buffer, "PreallocatedMemoryThread shutting down.\n",
+ local_buffer.length());
}
static char* data() {
int* size,
int extra_space,
bool verbose) {
- FILE* file = fopen(filename, "rb");
+ FILE* file = OS::FOpen(filename, "rb");
if (file == NULL || fseek(file, 0, SEEK_END) != 0) {
if (verbose) {
OS::PrintError("Cannot read from file %s.\n", filename);
const char* str,
int size,
bool verbose) {
- FILE* f = fopen(filename, "wb");
+ FILE* f = OS::FOpen(filename, "wb");
if (f == NULL) {
if (verbose) {
OS::PrintError("Cannot open file %s for reading.\n", filename);
StringBuilder::StringBuilder(int size) {
- buffer_ = NewArray<char>(size);
- size_ = size;
+ buffer_ = Vector<char>::New(size);
position_ = 0;
}
void StringBuilder::AddSubstring(const char* s, int n) {
- ASSERT(!is_finalized() && position_ + n < size_);
+ ASSERT(!is_finalized() && position_ + n < buffer_.length());
ASSERT(static_cast<size_t>(n) <= strlen(s));
memcpy(&buffer_[position_], s, n * kCharSize);
position_ += n;
void StringBuilder::AddFormatted(const char* format, ...) {
- ASSERT(!is_finalized() && position_ < size_);
+ ASSERT(!is_finalized() && position_ < buffer_.length());
va_list args;
va_start(args, format);
- int remaining = size_ - position_;
- int n = OS::VSNPrintF(&buffer_[position_], remaining, format, args);
+ int n = OS::VSNPrintF(buffer_ + position_, format, args);
va_end(args);
- if (n < 0 || n >= remaining) {
- position_ = size_;
+ if (n < 0 || n >= (buffer_.length() - position_)) {
+ position_ = buffer_.length();
} else {
position_ += n;
}
char* StringBuilder::Finalize() {
- ASSERT(!is_finalized() && position_ < size_);
+ ASSERT(!is_finalized() && position_ < buffer_.length());
buffer_[position_] = '\0';
// Make sure nobody managed to add a 0-character to the
// buffer while building the string.
- ASSERT(strlen(buffer_) == static_cast<size_t>(position_));
+ ASSERT(strlen(buffer_.start()) == static_cast<size_t>(position_));
position_ = -1;
ASSERT(is_finalized());
- return buffer_;
+ return buffer_.start();
}
} } // namespace v8::internal
ASSERT(length == 0 || (length > 0 && data != NULL));
}
+ static Vector<T> New(int length) {
+ return Vector<T>(NewArray<T>(length), length);
+ }
+
// Returns the length of the vector.
int length() const { return length_; }
length_ = 0;
}
+ inline Vector<T> operator+(int offset) {
+ ASSERT(offset < length_);
+ return Vector<T>(start_ + offset, length_ - offset);
+ }
+
// Factory method for creating empty vectors.
static Vector<T> empty() { return Vector<T>(NULL, 0); }
};
+template <typename T, int size>
+class EmbeddedVector : public Vector<T> {
+ public:
+ EmbeddedVector() : Vector<T>(buffer_, size) { }
+ private:
+ T buffer_[size];
+};
+
+
inline Vector<const char> CStrVector(const char* data) {
return Vector<const char>(data, strlen(data));
}
return Vector<char>(data, strlen(data));
}
+inline Vector<char> MutableCStrVector(char* data, int max) {
+ int length = strlen(data);
+ return Vector<char>(data, (length < max) ? length : max);
+}
+
template <typename T>
inline Vector< Handle<Object> > HandleVector(v8::internal::Handle<T>* elms,
int length) {
explicit StringBuilder(int size);
StringBuilder(char* buffer, int size)
- : buffer_(buffer), size_(size), position_(0) { }
+ : buffer_(buffer, size), position_(0) { }
~StringBuilder() { if (!is_finalized()) Finalize(); }
- int size() const { return size_; }
+ int size() const { return buffer_.length(); }
// Get the current position in the builder.
int position() const {
// instead.
void AddCharacter(char c) {
ASSERT(c != '\0');
- ASSERT(!is_finalized() && position_ < size_);
+ ASSERT(!is_finalized() && position_ < buffer_.length());
buffer_[position_++] = c;
}
char* Finalize();
private:
- char* buffer_;
- int size_;
+ Vector<char> buffer_;
int position_;
bool is_finalized() const { return position_ < 0; }
basename = strrchr(const_cast<char *>(file), '\\');
}
if (!basename) {
- basename = strdup(file);
+ basename = v8::internal::OS::StrDup(file);
} else {
- basename = strdup(basename + 1);
+ basename = v8::internal::OS::StrDup(basename + 1);
}
// Drop the extension, if there is one.
char *extension = strrchr(basename, '.');
print_run_count = false;
} else {
- char* arg_copy = strdup(arg);
+ char* arg_copy = v8::internal::OS::StrDup(arg);
char* testname = strchr(arg_copy, '/');
if (testname) {
// Split the string in two by nulling the slash and then run
static double Inc(int x) {
const char* source = "result = %d + 1;";
- char buffer[512];
- OS::SNPrintF(buffer, sizeof(buffer), source, x);
+ EmbeddedVector<char, 512> buffer;
+ OS::SNPrintF(buffer, source, x);
- Handle<JSFunction> fun = Compile(buffer);
+ Handle<JSFunction> fun = Compile(buffer.start());
if (fun.is_null()) return -1;
bool has_pending_exception;
#include "stub-cache.h"
#include "cctest.h"
+
+using ::v8::internal::EmbeddedVector;
using ::v8::internal::Object;
using ::v8::internal::OS;
using ::v8::internal::Handle;
// associated break point number.
static int SetBreakPointFromJS(const char* function_name,
int line, int position) {
- char buffer[SMALL_STRING_BUFFER_SIZE];
- OS::SNPrintF(buffer, SMALL_STRING_BUFFER_SIZE,
+ EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
+ OS::SNPrintF(buffer,
"debug.Debug.setBreakPoint(%s,%d,%d)",
function_name, line, position);
buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
- return v8::Script::Compile(v8::String::New(buffer))->Run()->Int32Value();
+ v8::Handle<v8::String> str = v8::String::New(buffer.start());
+ return v8::Script::Compile(str)->Run()->Int32Value();
}
// Set a break point in a script using the global Debug object.
static int SetScriptBreakPointFromJS(const char* script_data,
int line, int column) {
- char buffer[SMALL_STRING_BUFFER_SIZE];
+ EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
if (column >= 0) {
// Column specified set script break point on precise location.
- OS::SNPrintF(buffer, SMALL_STRING_BUFFER_SIZE,
+ OS::SNPrintF(buffer,
"debug.Debug.setScriptBreakPoint(\"%s\",%d,%d)",
script_data, line, column);
} else {
// Column not specified set script break point on line.
- OS::SNPrintF(buffer, SMALL_STRING_BUFFER_SIZE,
+ OS::SNPrintF(buffer,
"debug.Debug.setScriptBreakPoint(\"%s\",%d)",
script_data, line);
}
buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
-
- return v8::Script::Compile(v8::String::New(buffer))->Run()->Int32Value();
+ v8::Handle<v8::String> str = v8::String::New(buffer.start());
+ return v8::Script::Compile(str)->Run()->Int32Value();
}
// Clear a break point using the global Debug object.
static void ClearBreakPointFromJS(int break_point_number) {
- char buffer[SMALL_STRING_BUFFER_SIZE];
- OS::SNPrintF(buffer, SMALL_STRING_BUFFER_SIZE,
+ EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
+ OS::SNPrintF(buffer,
"debug.Debug.clearBreakPoint(%d)",
break_point_number);
buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
- v8::Script::Compile(v8::String::New(buffer))->Run();
+ v8::Script::Compile(v8::String::New(buffer.start()))->Run();
}
static void EnableScriptBreakPointFromJS(int break_point_number) {
- char buffer[SMALL_STRING_BUFFER_SIZE];
- OS::SNPrintF(buffer, SMALL_STRING_BUFFER_SIZE,
+ EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
+ OS::SNPrintF(buffer,
"debug.Debug.enableScriptBreakPoint(%d)",
break_point_number);
buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
- v8::Script::Compile(v8::String::New(buffer))->Run();
+ v8::Script::Compile(v8::String::New(buffer.start()))->Run();
}
static void DisableScriptBreakPointFromJS(int break_point_number) {
- char buffer[SMALL_STRING_BUFFER_SIZE];
- OS::SNPrintF(buffer, SMALL_STRING_BUFFER_SIZE,
+ EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
+ OS::SNPrintF(buffer,
"debug.Debug.disableScriptBreakPoint(%d)",
break_point_number);
buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
- v8::Script::Compile(v8::String::New(buffer))->Run();
+ v8::Script::Compile(v8::String::New(buffer.start()))->Run();
}
static void ChangeScriptBreakPointConditionFromJS(int break_point_number,
const char* condition) {
- char buffer[SMALL_STRING_BUFFER_SIZE];
- OS::SNPrintF(buffer, SMALL_STRING_BUFFER_SIZE,
+ EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
+ OS::SNPrintF(buffer,
"debug.Debug.changeScriptBreakPointCondition(%d, \"%s\")",
break_point_number, condition);
buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
- v8::Script::Compile(v8::String::New(buffer))->Run();
+ v8::Script::Compile(v8::String::New(buffer.start()))->Run();
}
static void ChangeScriptBreakPointIgnoreCountFromJS(int break_point_number,
int ignoreCount) {
- char buffer[SMALL_STRING_BUFFER_SIZE];
- OS::SNPrintF(buffer, SMALL_STRING_BUFFER_SIZE,
+ EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
+ OS::SNPrintF(buffer,
"debug.Debug.changeScriptBreakPointIgnoreCount(%d, %d)",
break_point_number, ignoreCount);
buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
- v8::Script::Compile(v8::String::New(buffer))->Run();
+ v8::Script::Compile(v8::String::New(buffer.start()))->Run();
}
int length = strlen(s);
for (int i = 1; i < length * 2; i++) {
static const char kMarker = static_cast<char>(42);
- char* buffer = NewArray<char>(i + 1);
+ Vector<char> buffer = Vector<char>::New(i + 1);
buffer[i] = kMarker;
- int n = OS::SNPrintF(buffer, i, "%s", s);
+ int n = OS::SNPrintF(Vector<char>(buffer.start(), i), "%s", s);
CHECK(n <= i);
CHECK(n == length || n == -1);
- CHECK_EQ(0, strncmp(buffer, s, i - 1));
+ CHECK_EQ(0, strncmp(buffer.start(), s, i - 1));
CHECK_EQ(kMarker, buffer[i]);
if (i <= length) {
- CHECK_EQ(i - 1, strlen(buffer));
+ CHECK_EQ(i - 1, strlen(buffer.start()));
} else {
- CHECK_EQ(length, strlen(buffer));
+ CHECK_EQ(length, strlen(buffer.start()));
}
}
}
projects / platform / upstream / v8.git / commitdiff