String v8NonStringValueToWebCoreString(v8::Handle<v8::Value> object)
{
ASSERT(!object->IsString());
if (object->IsInt32()) {
int value = object->Int32Value();
// Most numbers used are <= 100. Even if they aren't used there's very little in using the space.
const int kLowNumbers = 100;
static AtomicString lowNumbers[kLowNumbers + 1];
String webCoreString;
if (0 <= value && value <= kLowNumbers) {
webCoreString = lowNumbers[value];
if (!webCoreString) {
AtomicString valueString = AtomicString(String::number(value));
lowNumbers[value] = valueString;
webCoreString = valueString;
}
} else
webCoreString = String::number(value);
return webCoreString;
}
v8::TryCatch block;
v8::Handle<v8::String> v8String = object->ToString();
// Handle the case where an exception is thrown as part of invoking toString on the object.
if (block.HasCaught()) {
throwError(block.Exception());
return StringImpl::empty();
}
return v8StringToWebCoreString<String>(v8String, DoNotExternalize);
}
static PassRefPtr<IDBKey> createIDBKeyFromValue(v8::Handle<v8::Value> value, Vector<v8::Handle<v8::Array> >& stack, v8::Isolate* isolate)
{
if (value->IsNumber() && !std::isnan(value->NumberValue()))
return IDBKey::createNumber(value->NumberValue());
if (value->IsString())
return IDBKey::createString(toCoreString(value.As<v8::String>()));
if (value->IsDate() && !std::isnan(value->NumberValue()))
return IDBKey::createDate(value->NumberValue());
if (value->IsArray()) {
v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(value);
if (stack.contains(array))
return 0;
if (stack.size() >= maximumDepth)
return 0;
stack.append(array);
IDBKey::KeyArray subkeys;
uint32_t length = array->Length();
for (uint32_t i = 0; i < length; ++i) {
v8::Local<v8::Value> item = array->Get(v8::Int32::New(i, isolate));
RefPtr<IDBKey> subkey = createIDBKeyFromValue(item, stack, isolate);
if (!subkey)
subkeys.append(IDBKey::createInvalid());
else
subkeys.append(subkey);
}
stack.removeLast();
return IDBKey::createArray(subkeys);
}
return 0;
}
static std::string toString(v8::Handle<v8::Value> str)
{
if (!str->IsString())
return "";
v8::String::Utf8Value value(str);
return *value;
}
AtomicString v8ValueToAtomicWebCoreString(v8::Handle<v8::Value> v8Value)
{
if (v8Value->IsString())
return v8StringToAtomicWebCoreString(v8::Handle<v8::String>::Cast(v8Value));
String string = v8ValueToWebCoreString(v8Value);
return AtomicString(string);
}
bool Util::isArgumentNull(const v8::Handle<v8::Value> value) {
if (value->IsString() && value->ToString()->Length() > 0) {
return false;
} else {
return true;
}
}
std::string jsHistory::go(v8::Handle<v8::Value> pos)
{
string retval = "";
if (pos->IsInt32()) {
// process offset
int offs = pos->Int32Value();
offs += index;
if (offs > 0 && offs < (int)history.size()) {
index = offs;
retval = history[index];
if (window != NULL) {
window->load(retval);
}
}
} else if (pos->IsString()) {
// search for substring
string srch = value_to_string(Local<Value>::New(pos));
for( size_t i = 0 ; i < history.size(); ++i) {
if (history[i].find(srch) != string::npos) {
index = i;
retval = history[index];
if (window != NULL) {
window->load(retval);
}
break;
}
}
}
return retval;
}
enum encoding ParseEncoding(v8::Handle<v8::Value> encoding_v, enum encoding _default) {
v8::HandleScope scope;
if (!encoding_v->IsString()) return _default;
v8::String::Utf8Value encoding(encoding_v->ToString());
if (strcasecmp(*encoding, "utf8") == 0) {
return UTF8;
} else if (strcasecmp(*encoding, "utf-8") == 0) {
return UTF8;
} else if (strcasecmp(*encoding, "ascii") == 0) {
return ASCII;
} else if (strcasecmp(*encoding, "binary") == 0) {
return BINARY;
} else if (strcasecmp(*encoding, "raw") == 0) {
fprintf(stderr, "'raw' (array of integers) has been removed. "
"Use 'binary'.\n");
return BINARY;
} else if (strcasecmp(*encoding, "raws") == 0) {
fprintf(stderr, "'raws' encoding has been renamed to 'binary'. "
"Please update your code.\n");
return BINARY;
} else {
return _default;
}
}
static std::string jsvalToString(const v8::Handle<v8::Value>& str)
{
if (!str->IsString())
return "";
v8::String::Utf8Value value(str);
return *value;
}
std::string SBController::jsValToString(const v8::Handle<v8::Value>& str)
{
if (!str->IsString())
return "";
v8::String::Utf8Value value(str);
return *value;
}
static bool get(v8::Handle<v8::Value>& object, const String& keyPathElement, v8::Handle<v8::Value>& result, v8::Isolate* isolate)
{
if (object->IsString() && keyPathElement == "length") {
int32_t length = v8::Handle<v8::String>::Cast(object)->Length();
result = v8::Number::New(isolate, length);
return true;
}
return object->IsObject() && getValueFrom(v8String(isolate, keyPathElement), result);
}
PassRefPtr<IDBKey> createIDBKeyFromValue(v8::Handle<v8::Value> value)
{
if (value->IsNull())
return IDBKey::create();
if (value->IsInt32())
return IDBKey::create(value->Int32Value());
if (value->IsString())
return IDBKey::create(v8ValueToWebCoreString(value));
// FIXME: Implement dates.
return 0;
}
static PassRefPtr<JSONValue> v8ToJSONValue(v8::Handle<v8::Value> value, int maxDepth, v8::Isolate* isolate)
{
if (value.IsEmpty()) {
ASSERT_NOT_REACHED();
return 0;
}
if (!maxDepth)
return 0;
maxDepth--;
if (value->IsNull() || value->IsUndefined())
return JSONValue::null();
if (value->IsBoolean())
return JSONBasicValue::create(value->BooleanValue());
if (value->IsNumber())
return JSONBasicValue::create(value->NumberValue());
if (value->IsString())
return JSONString::create(toCoreString(value.As<v8::String>()));
if (value->IsArray()) {
v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(value);
RefPtr<JSONArray> inspectorArray = JSONArray::create();
uint32_t length = array->Length();
for (uint32_t i = 0; i < length; i++) {
v8::Local<v8::Value> value = array->Get(v8::Int32::New(isolate, i));
RefPtr<JSONValue> element = v8ToJSONValue(value, maxDepth, isolate);
if (!element)
return 0;
inspectorArray->pushValue(element);
}
return inspectorArray;
}
if (value->IsObject()) {
RefPtr<JSONObject> jsonObject = JSONObject::create();
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(value);
v8::Local<v8::Array> propertyNames = object->GetPropertyNames();
uint32_t length = propertyNames->Length();
for (uint32_t i = 0; i < length; i++) {
v8::Local<v8::Value> name = propertyNames->Get(v8::Int32::New(isolate, i));
// FIXME(yurys): v8::Object should support GetOwnPropertyNames
if (name->IsString() && !object->HasRealNamedProperty(v8::Handle<v8::String>::Cast(name)))
continue;
RefPtr<JSONValue> propertyValue = v8ToJSONValue(object->Get(name), maxDepth, isolate);
if (!propertyValue)
return 0;
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<WithNullCheck>, nameString, name, 0);
jsonObject->setValue(nameString, propertyValue);
}
return jsonObject;
}
ASSERT_NOT_REACHED();
return 0;
}
static PassRefPtr<InspectorValue> v8ToInspectorValue(v8::Handle<v8::Value> value, int maxDepth)
{
if (value.IsEmpty()) {
ASSERT_NOT_REACHED();
return 0;
}
if (!maxDepth)
return 0;
maxDepth--;
if (value->IsNull() || value->IsUndefined())
return InspectorValue::null();
if (value->IsBoolean())
return InspectorBasicValue::create(value->BooleanValue());
if (value->IsNumber())
return InspectorBasicValue::create(value->NumberValue());
if (value->IsString())
return InspectorString::create(toWebCoreString(value));
if (value->IsArray()) {
v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(value);
RefPtr<InspectorArray> inspectorArray = InspectorArray::create();
uint32_t length = array->Length();
for (uint32_t i = 0; i < length; i++) {
v8::Local<v8::Value> value = array->Get(v8::Int32::New(i));
RefPtr<InspectorValue> element = v8ToInspectorValue(value, maxDepth);
if (!element)
return 0;
inspectorArray->pushValue(element);
}
return inspectorArray;
}
if (value->IsObject()) {
RefPtr<InspectorObject> inspectorObject = InspectorObject::create();
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(value);
v8::Local<v8::Array> propertyNames = object->GetPropertyNames();
uint32_t length = propertyNames->Length();
for (uint32_t i = 0; i < length; i++) {
v8::Local<v8::Value> name = propertyNames->Get(v8::Int32::New(i));
// FIXME(yurys): v8::Object should support GetOwnPropertyNames
if (name->IsString() && !object->HasRealNamedProperty(v8::Handle<v8::String>::Cast(name)))
continue;
RefPtr<InspectorValue> propertyValue = v8ToInspectorValue(object->Get(name), maxDepth);
if (!propertyValue)
return 0;
inspectorObject->setValue(toWebCoreStringWithNullCheck(name), propertyValue);
}
return inspectorObject;
}
ASSERT_NOT_REACHED();
return 0;
}
static PassRefPtr<CanvasStyle> toCanvasStyle(v8::Handle<v8::Value> value)
{
if (value->IsString())
return CanvasStyle::create(toWebCoreString(value));
if (V8CanvasGradient::HasInstance(value))
return CanvasStyle::create(V8CanvasGradient::toNative(v8::Handle<v8::Object>::Cast(value)));
if (V8CanvasPattern::HasInstance(value))
return CanvasStyle::create(V8CanvasPattern::toNative(v8::Handle<v8::Object>::Cast(value)));
return 0;
}
static PassRefPtr<CanvasStyle> toCanvasStyle(v8::Handle<v8::Value> value)
{
if (value->IsString())
return CanvasStyle::create(toWebCoreString(value));
if (V8CanvasGradient::HasInstance(value))
return CanvasStyle::create(V8Proxy::DOMWrapperToNative<CanvasGradient>(value));
if (V8CanvasPattern::HasInstance(value))
return CanvasStyle::create(V8Proxy::DOMWrapperToNative<CanvasPattern>(value));
return 0;
}
PassRefPtr<IDBKey> createIDBKeyFromValue(v8::Handle<v8::Value> value)
{
if (value->IsNull())
return IDBKey::createNull();
if (value->IsNumber())
return IDBKey::createNumber(value->NumberValue());
if (value->IsString())
return IDBKey::createString(v8ValueToWebCoreString(value));
if (value->IsDate())
return IDBKey::createDate(value->NumberValue());
return 0; // Signals type error.
}
String v8NonStringValueToWebCoreString(v8::Handle<v8::Value> object)
{
ASSERT(!object->IsString());
if (object->IsInt32())
return int32ToWebCoreString(object->Int32Value());
v8::TryCatch block;
v8::Handle<v8::String> v8String = object->ToString();
// Handle the case where an exception is thrown as part of invoking toString on the object.
if (block.HasCaught()) {
throwError(block.Exception());
return StringImpl::empty();
}
return v8StringToWebCoreString<String>(v8String, DoNotExternalize);
}
v8::Handle<Value> ReadFile(v8::Handle<Value> file)
{
HandleScope handleScope;
string fileContents = "";
if(file->IsString()) {
String::Utf8Value filePathUTF(Handle<String>::Cast(file));
std::stringstream ss;
ss << currentScriptPath << "/" << string(*filePathUTF, filePathUTF.length());
string filePath = ss.str();
fileContents = ReadFileContents(filePath.c_str());
}
return handleScope.Close(String::New(fileContents.c_str()));
}
char TRI_ObjectToCharacter (v8::Handle<v8::Value> value, bool& error) {
error = false;
if (! value->IsString() && ! value->IsStringObject()) {
error = true;
return '\0';
}
TRI_Utf8ValueNFC sep(TRI_UNKNOWN_MEM_ZONE, value->ToString());
if (*sep == 0 || sep.length() != 1) {
error = true;
return '\0';
}
return (*sep)[0];
}
jobject wrapJSObject(JNIEnv *pEnv, v8::Handle<v8::Value> value)
{
v8::HandleScope handle_scope;
if (value.IsEmpty() || value->IsNull() || value->IsUndefined()) return NULL;
if (value->IsTrue()) return NewBoolean(pEnv, JNI_TRUE);
if (value->IsFalse()) return NewBoolean(pEnv, JNI_FALSE);
if (value->IsInt32()) return NewInt(pEnv, value->Int32Value());
if (value->IsUint32()) return NewLong(pEnv, value->IntegerValue());
if (value->IsString()) return NewString(pEnv, v8::Handle<v8::String>::Cast(value));
if (value->IsDate()) return NewDate(pEnv, v8::Handle<v8::Date>::Cast(value));
if (value->IsNumber()) return NewDouble(pEnv, value->NumberValue());
// return wrap(value->ToObject());
return NULL;
}
Object^ V8Interop::FromV8(v8::Handle<v8::Value> value)
{
if (value->IsString())
{
return FromV8String(value);
}
else if (value->IsBoolean())
{
return FromV8Boolean(value);
}
else if (value->IsInt32())
{
return FromV8Int32(value);
}
else if (value->IsArray())
{
return FromV8Array(value);
}
else if (value->IsDate())
{
return FromV8Date(value);
}
else if (value->IsNumber())
{
return FromV8Double(value);
}
else if (value->IsFunction())
{
return FromV8Function(value);
}
else if (value->IsExternal())
{
return FromV8External(value);
}
else if (value->IsObject())
{
return FromV8Object(value);
}
else if (value->IsUndefined() || value->IsNull())
{
return nullptr;
}
return nullptr;
}
uint64_t TRI_ObjectToUInt64 (v8::Handle<v8::Value> value,
const bool allowStringConversion) {
if (value->IsNumber()) {
return (uint64_t) value->ToNumber()->Value();
}
if (value->IsNumberObject()) {
v8::Handle<v8::NumberObject> no = v8::Handle<v8::NumberObject>::Cast(value);
return (uint64_t) no->NumberValue();
}
if (allowStringConversion && value->IsString()) {
v8::String::Utf8Value str(value);
return StringUtils::uint64(string(*str, str.length()));
}
return 0;
}
QJsonValue QV8JsonWrapper::toJsonValue(v8::Handle<v8::Value> value,
V8ObjectSet &visitedObjects)
{
if (value->IsString())
return QJsonValue(QJSConverter::toString(value.As<v8::String>()));
else if (value->IsNumber())
return QJsonValue(value->NumberValue());
else if (value->IsBoolean())
return QJsonValue(value->BooleanValue());
else if (value->IsArray())
return toJsonArray(value.As<v8::Array>(), visitedObjects);
else if (value->IsObject())
return toJsonObject(value.As<v8::Object>(), visitedObjects);
else if (value->IsNull())
return QJsonValue(QJsonValue::Null);
else
return QJsonValue(QJsonValue::Undefined);
}
uint64 TNodeJsUtil::GetTmMSecs(v8::Handle<v8::Value>& Value) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
if (Value->IsDate()) {
v8::Local<v8::Date> Date = v8::Handle<v8::Date>::Cast(Value);
return GetTmMSecs(Date);
}
else if (Value->IsString()) {
v8::String::Utf8Value Utf8(Value);
TTm Tm = TTm::GetTmFromWebLogDateTimeStr(TStr(*Utf8), '-', ':', '.', 'T');
return TTm::GetMSecsFromTm(Tm);
}
else {
EAssertR(Value->IsNumber(), "Date is not in a representation of a string, date or number!");
return GetCppTimestamp(int64(Value->NumberValue()));
}
}
static Value v8ValueToValue(v8::Handle<v8::Value> v8Value)
{
v8::HandleScope scope;
if (v8Value->IsArray()) {
List<Value> value;
const v8::Handle<v8::Array> v8Array = v8::Handle<v8::Array>::Cast(v8Value);
const uint32_t size = v8Array->Length();
for (uint32_t i = 0; i < size; ++i) {
if (v8Array->Has(i))
value.append(v8ValueToValue(v8Array->Get(i)));
else
value.append(Value());
}
return Value(value);
} else if (v8Value->IsObject()) {
Map<String, Value> value;
const v8::Handle<v8::Object> v8Object = v8Value->ToObject();
const v8::Handle<v8::Array> props = v8Object->GetPropertyNames();
const uint32_t size = props->Length();
for (uint32_t i = 0; i < size; ++i) {
assert(props->Has(i));
const v8::Handle<v8::Value> name = props->Get(i);
value[String(*v8::String::Utf8Value(name))] = v8ValueToValue(v8Object->Get(name));
}
return Value(value);
} else if (v8Value->IsBoolean()) {
return Value(v8Value->BooleanValue());
} else if (v8Value->IsInt32() || v8Value->IsUint32()) {
return Value(v8Value->Int32Value());
} else if (v8Value->IsNumber()) {
return Value(v8Value->NumberValue());
} else if (v8Value->IsString()) {
return Value(String(*v8::String::Utf8Value(v8Value)));
} else {
error() << "Unexpected v8 value type in JSONParser";
}
// undefined or null?
return Value();
}
static String v8NonStringValueToWebCoreString(v8::Handle<v8::Value> object)
{
ASSERT(!object->IsString());
if (object->IsInt32())
return int32ToWebCoreString(object->Int32Value());
v8::TryCatch block;
v8::Handle<v8::String> v8String = object->ToString();
// Handle the case where an exception is thrown as part of invoking toString on the object.
if (block.HasCaught()) {
throwError(block.Exception());
return StringImpl::empty();
}
// This path is unexpected. However there is hypothesis that it
// might be combination of v8 and v8 bindings bugs. For now
// just bailout as we'll crash if attempt to convert empty handle into a string.
if (v8String.IsEmpty()) {
ASSERT_NOT_REACHED();
return StringImpl::empty();
}
return v8StringToWebCoreString<String>(v8String, DoNotExternalize);
}
bool CJavaFunction::CanConvert(jclass clazz, v8::Handle<v8::Value> value)
{
jni::V8Env env(m_pEnv);
if (value->IsTrue() || value->IsFalse() || value->IsBoolean())
{
return env.IsAssignableFrom(env.buildins.java.lang.Boolean, clazz);
}
else if (value->IsInt32() || value->IsUint32())
{
return env.IsAssignableFrom(env.buildins.java.lang.Long, clazz) ||
env.IsAssignableFrom(env.buildins.java.lang.Integer, clazz) ||
env.IsAssignableFrom(env.buildins.java.lang.Short, clazz) ||
env.IsAssignableFrom(env.buildins.java.lang.Byte, clazz);
}
else if (value->IsNumber())
{
return env.IsAssignableFrom(env.buildins.java.lang.Double, clazz) ||
env.IsAssignableFrom(env.buildins.java.lang.Float, clazz);
}
else if (value->IsString())
{
return env.IsAssignableFrom(env.buildins.java.lang.String, clazz);
}
else if (value->IsDate())
{
return env.IsAssignableFrom(env.buildins.java.util.Date, clazz);
}
else if (value->IsArray())
{
return env.IsAssignableFrom(env.buildins.lu.flier.script.V8Array, clazz);
}
else if (value.IsEmpty() || value->IsNull() || value->IsUndefined() || value->IsObject())
{
return true;
}
return false;
}
inline Value InterpreterData::v8ValueToValue(const v8::Handle<v8::Value>& value)
{
if (value.IsEmpty() || value->IsNull() || value->IsUndefined())
return Value();
else if (value->IsTrue())
return Value(true);
else if (value->IsFalse())
return Value(false);
else if (value->IsInt32())
return Value(value->ToInt32()->Value());
else if (value->IsNumber())
return Value(value->ToNumber()->Value());
else if (value->IsString()) {
const v8::String::Utf8Value str(value);
return Value(ToCString(str));
} else if (value->IsObject()) {
const v8::String::Utf8Value str(toJSON(value));
return Value::fromJSON(ToCString(str));
} else {
error() << "Unknown v8 value in Interpreter::v8ValueToValue";
}
return Value();
}
AtomicString toWebCoreAtomicString(v8::Handle<v8::Value> value)
{
if (value->IsString())
return v8StringToWebCoreString<AtomicString>(v8::Handle<v8::String>::Cast(value), Externalize);
return v8NonStringValueToAtomicWebCoreString(value);
}
static AtomicString v8NonStringValueToAtomicWebCoreString(v8::Handle<v8::Value> object)
{
ASSERT(!object->IsString());
return AtomicString(v8NonStringValueToWebCoreString(object));
}
