static int V8ToVPack(BuilderContext& context, v8::Handle<v8::Value> const parameter, std::string const& attributeName, bool inObject) { if (parameter->IsNull() || parameter->IsUndefined()) { AddValue(context, attributeName, inObject, VPackValue(VPackValueType::Null)); return TRI_ERROR_NO_ERROR; } if (parameter->IsBoolean()) { AddValue(context, attributeName, inObject, VPackValue(parameter->ToBoolean()->Value())); return TRI_ERROR_NO_ERROR; } if (parameter->IsNumber()) { if (parameter->IsInt32()) { AddValue(context, attributeName, inObject, VPackValue(parameter->ToInt32()->Value())); return TRI_ERROR_NO_ERROR; } if (parameter->IsUint32()) { AddValue(context, attributeName, inObject, VPackValue(parameter->ToUint32()->Value())); return TRI_ERROR_NO_ERROR; } AddValue(context, attributeName, inObject, VPackValue(parameter->ToNumber()->Value())); return TRI_ERROR_NO_ERROR; } if (parameter->IsString()) { v8::String::Utf8Value str(parameter->ToString()); if (*str == nullptr) { return TRI_ERROR_OUT_OF_MEMORY; } AddValuePair(context, attributeName, inObject, VPackValuePair(*str, str.length(), VPackValueType::String)); return TRI_ERROR_NO_ERROR; } if (parameter->IsArray()) { v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(parameter); AddValue(context, attributeName, inObject, VPackValue(VPackValueType::Array)); uint32_t const n = array->Length(); for (uint32_t i = 0; i < n; ++i) { v8::Handle<v8::Value> value = array->Get(i); if (value->IsUndefined()) { // ignore array values which are undefined continue; } if (++context.level > MaxLevels) { // too much recursion return TRI_ERROR_BAD_PARAMETER; } int res = V8ToVPack<performAllChecks>(context, value, NoAttribute, false); --context.level; if (res != TRI_ERROR_NO_ERROR) { return res; } } if (!context.keepTopLevelOpen || context.level > 0) { context.builder.close(); } return TRI_ERROR_NO_ERROR; } if (parameter->IsObject()) { if (performAllChecks) { if (parameter->IsBooleanObject()) { AddValue(context, attributeName, inObject, VPackValue(v8::Handle<v8::BooleanObject>::Cast(parameter) ->BooleanValue())); return TRI_ERROR_NO_ERROR; } if (parameter->IsNumberObject()) { AddValue(context, attributeName, inObject, VPackValue(v8::Handle<v8::NumberObject>::Cast(parameter) ->NumberValue())); return TRI_ERROR_NO_ERROR; } if (parameter->IsStringObject()) { v8::String::Utf8Value str(parameter->ToString()); if (*str == nullptr) { return TRI_ERROR_OUT_OF_MEMORY; } AddValuePair(context, attributeName, inObject, VPackValuePair(*str, str.length(), VPackValueType::String)); return TRI_ERROR_NO_ERROR; } if (parameter->IsRegExp() || parameter->IsFunction() || parameter->IsExternal()) { return TRI_ERROR_BAD_PARAMETER; } } v8::Handle<v8::Object> o = parameter->ToObject(); if (performAllChecks) { // first check if the object has a "toJSON" function if (o->Has(context.toJsonKey)) { // call it if yes v8::Handle<v8::Value> func = o->Get(context.toJsonKey); if (func->IsFunction()) { v8::Handle<v8::Function> toJson = v8::Handle<v8::Function>::Cast(func); v8::Handle<v8::Value> args; v8::Handle<v8::Value> converted = toJson->Call(o, 0, &args); if (!converted.IsEmpty()) { // return whatever toJSON returned v8::String::Utf8Value str(converted->ToString()); if (*str == nullptr) { return TRI_ERROR_OUT_OF_MEMORY; } // this passes ownership for the utf8 string to the JSON object AddValuePair(context, attributeName, inObject, VPackValuePair(*str, str.length(), VPackValueType::String)); return TRI_ERROR_NO_ERROR; } } // fall-through intentional } } v8::Handle<v8::Array> names = o->GetOwnPropertyNames(); uint32_t const n = names->Length(); AddValue(context, attributeName, inObject, VPackValue(VPackValueType::Object)); for (uint32_t i = 0; i < n; ++i) { // process attribute name v8::Handle<v8::Value> key = names->Get(i); v8::String::Utf8Value str(key); if (*str == nullptr) { return TRI_ERROR_OUT_OF_MEMORY; } v8::Handle<v8::Value> value = o->Get(key); if (value->IsUndefined()) { // ignore object values which are undefined continue; } if (++context.level > MaxLevels) { // too much recursion return TRI_ERROR_BAD_PARAMETER; } int res = V8ToVPack<performAllChecks>(context, value, *str, true); --context.level; if (res != TRI_ERROR_NO_ERROR) { return res; } } if (!context.keepTopLevelOpen || context.level > 0) { context.builder.close(); } return TRI_ERROR_NO_ERROR; } return TRI_ERROR_BAD_PARAMETER; }
void QV8Worker::serialize(QByteArray &data, v8::Handle<v8::Value> v, QV8Engine *engine) { if (v.IsEmpty()) { } else if (v->IsUndefined()) { push(data, valueheader(WorkerUndefined)); } else if (v->IsNull()) { push(data, valueheader(WorkerNull)); } else if (v->IsTrue()) { push(data, valueheader(WorkerTrue)); } else if (v->IsFalse()) { push(data, valueheader(WorkerFalse)); } else if (v->IsString()) { v8::Handle<v8::String> string = v->ToString(); int length = string->Length() + 1; if (length > 0xFFFFFF) { push(data, valueheader(WorkerUndefined)); return; } int utf16size = ALIGN(length * sizeof(uint16_t)); reserve(data, utf16size + sizeof(quint32)); push(data, valueheader(WorkerString, length)); int offset = data.size(); data.resize(data.size() + utf16size); char *buffer = data.data() + offset; string->Write((uint16_t*)buffer); } else if (v->IsFunction()) { // XXX TODO: Implement passing function objects between the main and // worker scripts push(data, valueheader(WorkerUndefined)); } else if (v->IsArray()) { v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(v); uint32_t length = array->Length(); if (length > 0xFFFFFF) { push(data, valueheader(WorkerUndefined)); return; } reserve(data, sizeof(quint32) + length * sizeof(quint32)); push(data, valueheader(WorkerArray, length)); for (uint32_t ii = 0; ii < length; ++ii) serialize(data, array->Get(ii), engine); } else if (v->IsInt32()) { reserve(data, 2 * sizeof(quint32)); push(data, valueheader(WorkerInt32)); push(data, (quint32)v->Int32Value()); } else if (v->IsUint32()) { reserve(data, 2 * sizeof(quint32)); push(data, valueheader(WorkerUint32)); push(data, v->Uint32Value()); } else if (v->IsNumber()) { reserve(data, sizeof(quint32) + sizeof(double)); push(data, valueheader(WorkerNumber)); push(data, v->NumberValue()); } else if (v->IsDate()) { reserve(data, sizeof(quint32) + sizeof(double)); push(data, valueheader(WorkerDate)); push(data, v8::Handle<v8::Date>::Cast(v)->NumberValue()); } else if (v->IsRegExp()) { v8::Handle<v8::RegExp> regexp = v8::Handle<v8::RegExp>::Cast(v); quint32 flags = regexp->GetFlags(); v8::Local<v8::String> source = regexp->GetSource(); int length = source->Length() + 1; if (length > 0xFFFFFF) { push(data, valueheader(WorkerUndefined)); return; } int utf16size = ALIGN(length * sizeof(uint16_t)); reserve(data, sizeof(quint32) + utf16size); push(data, valueheader(WorkerRegexp, flags)); push(data, (quint32)length); int offset = data.size(); data.resize(data.size() + utf16size); char *buffer = data.data() + offset; source->Write((uint16_t*)buffer); } else if (v->IsObject() && !v->ToObject()->GetExternalResource()) { v8::Handle<v8::Object> object = v->ToObject(); v8::Local<v8::Array> properties = engine->getOwnPropertyNames(object); quint32 length = properties->Length(); if (length > 0xFFFFFF) { push(data, valueheader(WorkerUndefined)); return; } push(data, valueheader(WorkerObject, length)); v8::TryCatch tc; for (quint32 ii = 0; ii < length; ++ii) { v8::Local<v8::String> str = properties->Get(ii)->ToString(); serialize(data, str, engine); v8::Local<v8::Value> val = object->Get(str); if (tc.HasCaught()) { serialize(data, v8::Undefined(), engine); tc.Reset(); } else { serialize(data, val, engine); } } } else if (engine->isQObject(v)) { // XXX TODO: Generalize passing objects between the main thread and worker scripts so // that others can trivially plug in their elements. QDeclarativeListModel *lm = qobject_cast<QDeclarativeListModel *>(engine->toQObject(v)); if (lm && lm->agent()) { QDeclarativeListModelWorkerAgent *agent = lm->agent(); agent->addref(); push(data, valueheader(WorkerListModel)); push(data, (void *)agent); return; } // No other QObject's are allowed to be sent push(data, valueheader(WorkerUndefined)); } else { push(data, valueheader(WorkerUndefined)); } }
static int FillShapeValueJson (v8::Isolate* isolate, VocShaper* shaper, TRI_shape_value_t* dst, v8::Handle<v8::Value> const json, size_t level, set<int>& seenHashes, vector<v8::Handle<v8::Object>>& seenObjects, bool create) { v8::HandleScope scope(isolate); if (json->IsRegExp() || json->IsFunction() || json->IsExternal()) { LOG_TRACE("shaper failed because regexp/function/external/date object cannot be converted"); return TRI_ERROR_BAD_PARAMETER; } if (json->IsNull() || json->IsUndefined()) { return FillShapeValueNull(shaper, dst); } if (json->IsBoolean()) { return FillShapeValueBoolean(shaper, dst, json->ToBoolean()); } if (json->IsBooleanObject()) { return FillShapeValueBoolean(shaper, dst, v8::Handle<v8::BooleanObject>::Cast(json)); } if (json->IsNumber()) { return FillShapeValueNumber(shaper, dst, json->ToNumber()); } if (json->IsNumberObject()) { return FillShapeValueNumber(shaper, dst, v8::Handle<v8::NumberObject>::Cast(json)); } if (json->IsString()) { return FillShapeValueString(shaper, dst, json->ToString()); } if (json->IsStringObject()) { return FillShapeValueString(shaper, dst, v8::Handle<v8::StringObject>::Cast(json)->ValueOf()); } else if (json->IsArray()) { return FillShapeValueList(isolate, shaper, dst, v8::Handle<v8::Array>::Cast(json), level, seenHashes, seenObjects, create); } if (json->IsObject()) { v8::Handle<v8::Object> o = json->ToObject(); v8::Handle<v8::String> toJsonString = TRI_V8_PAIR_STRING("toJSON", 6); if (o->Has(toJsonString)) { v8::Handle<v8::Value> func = o->Get(toJsonString); if (func->IsFunction()) { v8::Handle<v8::Function> toJson = v8::Handle<v8::Function>::Cast(func); v8::Handle<v8::Value> args; v8::Handle<v8::Value> result = toJson->Call(o, 0, &args); if (! result.IsEmpty()) { return FillShapeValueString(shaper, dst, result->ToString()); } } } // fall-through intentional // check for cycles int hash = o->GetIdentityHash(); if (seenHashes.find(hash) != seenHashes.end()) { for (auto it = seenObjects.begin(); it != seenObjects.end(); ++it) { if (json->StrictEquals(*it)) { return TRI_ERROR_ARANGO_SHAPER_FAILED; } } } else { seenHashes.insert(hash); } seenObjects.push_back(o); int res = FillShapeValueArray(isolate, shaper, dst, json->ToObject(), level, seenHashes, seenObjects, create); seenObjects.pop_back(); // cannot remove hash value from seenHashes because multiple objects might have the same // hash values (collisions) return res; } LOG_TRACE("shaper failed to convert object"); return TRI_ERROR_BAD_PARAMETER; }
/** * Cast an ecmascript value to a PHP runtime value * * @note The value cannot be const, as retrieving properties * from arrays and objects cannot be done on const values * * @param input the value to cast * @return Php::Value */ Php::Value value(v8::Handle<v8::Value> input) { // if we received an invalid input we simply return an empty PHP value if (input.IsEmpty()) return nullptr; // as is typical in javascript, a value can be of many types // check the type of value that we have received so we can cast if (input->IsBoolean()) return input->BooleanValue(); if (input->IsBooleanObject()) return input->BooleanValue(); if (input->IsInt32()) return input->Int32Value(); if (input->IsNumber()) return input->NumberValue(); if (input->IsNumberObject()) return input->NumberValue(); if (input->IsNull()) return nullptr; if (input->IsUndefined()) return nullptr; // special treatment for string-like types // TODO: javascript dates might possibly be cast to a DateTime object if (input->IsString() || input->IsStringObject() || input->IsRegExp()) { // create the utf8 value (the only way to retrieve the content) v8::String::Utf8Value utf8(input->ToString()); // and create the value to return return {*utf8, utf8.length()}; } // it could be callable too if (input->IsFunction()) { // create the function as a pointer that can be captured auto function = std::make_shared<Stack<v8::Function>>(input.As<v8::Function>()); // the result to return Php::Function result([function](Php::Parameters ¶ms) { // create a "scope", so variables get destructed, retrieve the context and "enter" it v8::HandleScope scope(Isolate::get()); v8::Local<v8::Context> context((*function)->CreationContext()); v8::Context::Scope contextScope(context); // catch any errors that occur while either compiling or running the script v8::TryCatch catcher; // create a new array with parameters std::vector<v8::Local<v8::Value>> array; array.reserve(params.size()); // iterate over all the given parameters and add them to the arrau for (auto ¶m: params) array.push_back(value(param)); // now we can actually call the function v8::Local<v8::Value> result((*function)->Call(context->Global(), array.size(), array.data())); // did we catch an exception? if (catcher.HasCaught()) { // retrieve the message describing the problem v8::Local<v8::Message> message(catcher.Message()); v8::Local<v8::String> description(message->Get()); // convert the description to utf so we can dump it v8::String::Utf8Value string(description); // pass this exception on to PHP userspace throw Php::Exception(std::string(*string, string.length())); } // convert the result to a PHP value and return it return value(result); }); // now return the result return result; } // or perhaps an object if (input->IsObject()) { // retrieve the object and the first internal field auto object = input.As<v8::Object>(); // does the object have internal fields? if (object->InternalFieldCount()) { // retrieve the field auto field = object->GetInternalField(0); // does it have an internal field and is it external? we are converting back // an original PHP object, just retrieve the original thing that came from PHP if (!field.IsEmpty() && field->IsExternal()) { // the PHP value is stored in the first internal field, // retrieve it and create the handle around it Handle handle(field); // dereference and return it return *handle; } } // create a new js object and convert it to userspace return Php::Object("JS\\Object", new JSObject(object)); } // we sadly don't support this type of value return nullptr; }