JSValue JSC_HOST_CALL stringProtoFuncLink(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
{
UString s = thisValue.toThisString(exec);
JSValue a0 = args.at(0);
UString linkText = a0.toString(exec);
unsigned linkTextSize = linkText.size();
unsigned stringSize = s.size();
unsigned bufferSize = 15 + linkTextSize + stringSize;
UChar* buffer = static_cast<UChar*>(tryFastMalloc(bufferSize * sizeof(UChar)));
if (!buffer)
return jsUndefined();
buffer[0] = '<';
buffer[1] = 'a';
buffer[2] = ' ';
buffer[3] = 'h';
buffer[4] = 'r';
buffer[5] = 'e';
buffer[6] = 'f';
buffer[7] = '=';
buffer[8] = '"';
memcpy(&buffer[9], linkText.data(), linkTextSize * sizeof(UChar));
buffer[9 + linkTextSize] = '"';
buffer[10 + linkTextSize] = '>';
memcpy(&buffer[11 + linkTextSize], s.data(), stringSize * sizeof(UChar));
buffer[11 + linkTextSize + stringSize] = '<';
buffer[12 + linkTextSize + stringSize] = '/';
buffer[13 + linkTextSize + stringSize] = 'a';
buffer[14 + linkTextSize + stringSize] = '>';
return jsNontrivialString(exec, UString(buffer, bufferSize, false));
}
static inline char* allocateSegment()
{
char * result;
if (tryFastMalloc(segmentSize).getValue(result))
return result;
return NULL;
}
bool WebGraphicsContext3DDefaultImpl::getActiveUniform(WebGLId program, unsigned long index, ActiveInfo& info)
{
GLint maxNameLength = -1;
glGetProgramiv(program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxNameLength);
if (maxNameLength < 0)
return false;
GLchar* name = 0;
if (!tryFastMalloc(maxNameLength * sizeof(GLchar)).getValue(name)) {
synthesizeGLError(GL_OUT_OF_MEMORY);
return false;
}
GLsizei length = 0;
GLint size = -1;
GLenum type = 0;
glGetActiveUniform(program, index, maxNameLength,
&length, &size, &type, name);
if (size < 0) {
fastFree(name);
return false;
}
info.name = WebString::fromUTF8(name, length);
info.type = type;
info.size = size;
fastFree(name);
return true;
}
void* tryFastZeroedMalloc(size_t n)
{
void* result = tryFastMalloc(n);
if (!result)
return 0;
memset(result, 0, n);
return result;
}
TryMallocReturnValue tryFastZeroedMalloc(size_t n)
{
void* result;
if (!tryFastMalloc(n).getValue(result))
return 0;
memset(result, 0, n);
return result;
}
PassRefPtr<ShareableBitmap> ShareableBitmap::create(const IntSize& size, Flags flags)
{
size_t numBytes = numBytesForSize(size);
void* data = 0;
if (!tryFastMalloc(numBytes).getValue(data))
return 0;
return adoptRef(new ShareableBitmap(size, flags, data));
}
static void* zAlloc(void*, uint32_t count, uint32_t size)
{
CheckedSize allocSize = count;
allocSize *= size;
if (allocSize.hasOverflowed())
return Z_NULL;
void* result = 0;
if (tryFastMalloc(allocSize.unsafeGet()).getValue(result))
return result;
return Z_NULL;
}
// Allocates new storage via tryFastMalloc.
// Returns NULL if array failed to convert for any reason.
static float* jsArrayToFloatArray(v8::Handle<v8::Array> array, uint32_t len)
{
// Convert the data element-by-element.
float* data;
if (!tryFastMalloc(len * sizeof(float)).getValue(data))
return 0;
for (uint32_t i = 0; i < len; i++) {
v8::Local<v8::Value> val = array->Get(v8::Integer::New(i));
if (!val->IsNumber()) {
fastFree(data);
return 0;
}
data[i] = toFloat(val);
}
return data;
}
JSArrayBufferView::ConstructionContext::ConstructionContext(
VM& vm, Structure* structure, uint32_t length, uint32_t elementSize,
InitializationMode mode)
: m_structure(0)
, m_length(length)
, m_butterfly(0)
{
if (length <= fastSizeLimit) {
// Attempt GC allocation.
void* temp = 0;
size_t size = sizeOf(length, elementSize);
// CopiedSpace only allows non-zero size allocations.
if (size && !vm.heap.tryAllocateStorage(0, size, &temp))
return;
m_structure = structure;
m_vector = temp;
m_mode = FastTypedArray;
#if USE(JSVALUE32_64)
if (mode == ZeroFill) {
uint64_t* asWords = static_cast<uint64_t*>(m_vector);
for (unsigned i = size / sizeof(uint64_t); i--;)
asWords[i] = 0;
}
#endif // USE(JSVALUE32_64)
return;
}
// Don't allow a typed array to use more than 2GB.
if (length > static_cast<unsigned>(INT_MAX) / elementSize)
return;
if (mode == ZeroFill) {
if (!tryFastCalloc(length, elementSize).getValue(m_vector))
return;
} else {
if (!tryFastMalloc(length * elementSize).getValue(m_vector))
return;
}
vm.heap.reportExtraMemoryCost(static_cast<size_t>(length) * elementSize);
m_structure = structure;
m_mode = OversizeTypedArray;
}
// Allocates new storage via tryFastMalloc.
// Returns NULL if array failed to convert for any reason.
static float* jsArrayToFloatArray(v8::Handle<v8::Array> array, uint32_t len)
{
// Convert the data element-by-element.
float* data = 0;
if (len > std::numeric_limits<uint32_t>::max() / sizeof(float)
|| !tryFastMalloc(len * sizeof(float)).getValue(data))
return 0;
for (uint32_t i = 0; i < len; i++) {
v8::Local<v8::Value> val = array->Get(i);
if (!val->IsNumber()) {
fastFree(data);
return 0;
}
data[i] = toFloat(val);
}
return data;
}
WebString WebGraphicsContext3DDefaultImpl::getShaderSource(WebGLId shader)
{
makeContextCurrent();
GLint logLength;
glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &logLength);
if (!logLength)
return WebString();
GLchar* log = 0;
if (!tryFastMalloc(logLength * sizeof(GLchar)).getValue(log))
return WebString();
GLsizei returnedLogLength;
glGetShaderSource(shader, logLength, &returnedLogLength, log);
ASSERT(logLength == returnedLogLength + 1);
WebString res = WebString::fromUTF8(log, returnedLogLength);
fastFree(log);
return res;
}
WebString WebGraphicsContext3DDefaultImpl::getProgramInfoLog(WebGLId program)
{
makeContextCurrent();
GLint logLength;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
if (!logLength)
return WebString();
GLchar* log = 0;
if (!tryFastMalloc(logLength * sizeof(GLchar)).getValue(log))
return WebString();
GLsizei returnedLogLength;
glGetProgramInfoLog(program, logLength, &returnedLogLength, log);
ASSERT(logLength == returnedLogLength + 1);
WebString res = WebString::fromUTF8(log, returnedLogLength);
fastFree(log);
return res;
}
// Allocates new storage via tryFastMalloc.
// Returns NULL if array failed to convert for any reason.
static int* jsArrayToIntArray(v8::Handle<v8::Array> array, uint32_t len)
{
// Convert the data element-by-element.
int* data;
if (!tryFastMalloc(len * sizeof(int)).getValue(data))
return 0;
for (uint32_t i = 0; i < len; i++) {
v8::Local<v8::Value> val = array->Get(v8::Integer::New(i));
bool ok;
int ival = toInt32(val, ok);
if (!ok) {
fastFree(data);
return 0;
}
data[i] = ival;
}
return data;
}
// Allocates new storage via tryFastMalloc.
// Returns NULL if array failed to convert for any reason.
static int* jsArrayToIntArray(v8::Handle<v8::Array> array, uint32_t len)
{
// Convert the data element-by-element.
int* data = 0;
if (len > std::numeric_limits<uint32_t>::max() / sizeof(int)
|| !tryFastMalloc(len * sizeof(int)).getValue(data))
return 0;
for (uint32_t i = 0; i < len; i++) {
v8::Local<v8::Value> val = array->Get(i);
bool ok;
int ival = toInt32(val, ok);
if (!ok) {
fastFree(data);
return 0;
}
data[i] = ival;
}
return data;
}
bool WebSocketChannel::appendToBuffer(const char* data, size_t len)
{
size_t newBufferSize = m_bufferSize + len;
if (newBufferSize < m_bufferSize) {
LOG(Network, "WebSocket buffer overflow (%lu+%lu)", static_cast<unsigned long>(m_bufferSize), static_cast<unsigned long>(len));
return false;
}
char* newBuffer = 0;
if (tryFastMalloc(newBufferSize).getValue(newBuffer)) {
if (m_buffer)
memcpy(newBuffer, m_buffer, m_bufferSize);
memcpy(newBuffer + m_bufferSize, data, len);
fastFree(m_buffer);
m_buffer = newBuffer;
m_bufferSize = newBufferSize;
return true;
}
m_context->addMessage(JSMessageSource, LogMessageType, ErrorMessageLevel, makeString("WebSocket frame (at ", String::number(static_cast<unsigned long>(newBufferSize)), " bytes) is too long."), 0, m_handshake.clientOrigin(), 0);
return false;
}
JSValue JSC_HOST_CALL stringProtoFuncFontsize(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
{
UString s = thisValue.toThisString(exec);
JSValue a0 = args.at(0);
uint32_t smallInteger;
if (a0.getUInt32(smallInteger) && smallInteger <= 9) {
unsigned stringSize = s.size();
unsigned bufferSize = 22 + stringSize;
UChar* buffer = static_cast<UChar*>(tryFastMalloc(bufferSize * sizeof(UChar)));
if (!buffer)
return jsUndefined();
buffer[0] = '<';
buffer[1] = 'f';
buffer[2] = 'o';
buffer[3] = 'n';
buffer[4] = 't';
buffer[5] = ' ';
buffer[6] = 's';
buffer[7] = 'i';
buffer[8] = 'z';
buffer[9] = 'e';
buffer[10] = '=';
buffer[11] = '"';
buffer[12] = '0' + smallInteger;
buffer[13] = '"';
buffer[14] = '>';
memcpy(&buffer[15], s.data(), stringSize * sizeof(UChar));
buffer[15 + stringSize] = '<';
buffer[16 + stringSize] = '/';
buffer[17 + stringSize] = 'f';
buffer[18 + stringSize] = 'o';
buffer[19 + stringSize] = 'n';
buffer[20 + stringSize] = 't';
buffer[21 + stringSize] = '>';
return jsNontrivialString(exec, UString(buffer, bufferSize, false));
}
return jsNontrivialString(exec, "<font size=\"" + a0.toString(exec) + "\">" + s + "</font>");
}
void toArray(JSC::ExecState* exec, JSC::JSValue value, T*& array, int& size)
{
array = 0;
if (!value.isObject())
return;
JSC::JSObject* object = asObject(value);
int length = object->get(exec, JSC::Identifier(exec, "length")).toInt32(exec);
void* tempValues;
if (!tryFastMalloc(length * sizeof(T)).getValue(tempValues))
return;
T* values = static_cast<T*>(tempValues);
for (int i = 0; i < length; ++i) {
JSC::JSValue v = object->get(exec, i);
if (exec->hadException())
return;
values[i] = static_cast<T>(v.toNumber(exec));
}
array = values;
size = length;
}
