summaryrefslogtreecommitdiff
path: root/fpdfsdk/javascript/global.cpp
diff options
context:
space:
mode:
authorDan Sinclair <dsinclair@chromium.org>2016-03-14 13:51:24 -0400
committerDan Sinclair <dsinclair@chromium.org>2016-03-14 13:51:24 -0400
commitf766ad219f66543654520f6a1955836f519e26d1 (patch)
tree2edf8bc93b89503a3669f7add5b6c2a407b8a78c /fpdfsdk/javascript/global.cpp
parent54b0abed08048008498471e39b7c72b034474090 (diff)
downloadpdfium-f766ad219f66543654520f6a1955836f519e26d1.tar.xz
Move fpdfsdk/src up to fpdfsdk/.
This CL moves the files in fpdfsdk/src/ up one level to fpdfsdk/ and fixes up the include paths, include guards and build files. R=tsepez@chromium.org Review URL: https://codereview.chromium.org/1799773002 .
Diffstat (limited to 'fpdfsdk/javascript/global.cpp')
-rw-r--r--fpdfsdk/javascript/global.cpp516
1 files changed, 516 insertions, 0 deletions
diff --git a/fpdfsdk/javascript/global.cpp b/fpdfsdk/javascript/global.cpp
new file mode 100644
index 0000000000..c22c05d1db
--- /dev/null
+++ b/fpdfsdk/javascript/global.cpp
@@ -0,0 +1,516 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include "fpdfsdk/javascript/global.h"
+
+#include <vector>
+
+#include "core/include/fxcrt/fx_ext.h"
+#include "fpdfsdk/include/javascript/IJavaScript.h"
+#include "fpdfsdk/javascript/JS_Context.h"
+#include "fpdfsdk/javascript/JS_Define.h"
+#include "fpdfsdk/javascript/JS_EventHandler.h"
+#include "fpdfsdk/javascript/JS_GlobalData.h"
+#include "fpdfsdk/javascript/JS_Object.h"
+#include "fpdfsdk/javascript/JS_Value.h"
+#include "fpdfsdk/javascript/resource.h"
+
+/* ---------------------------- global ---------------------------- */
+
+// Helper class for compile-time calculation of hash values in order to
+// avoid having global object initializers.
+template <unsigned ACC, wchar_t... Ns>
+struct CHash;
+
+// Only needed to hash single-character strings.
+template <wchar_t N>
+struct CHash<N> {
+ static const unsigned value = N;
+};
+
+template <unsigned ACC, wchar_t N>
+struct CHash<ACC, N> {
+ static const unsigned value = (ACC * 1313LLU + N) & 0xFFFFFFFF;
+};
+
+template <unsigned ACC, wchar_t N, wchar_t... Ns>
+struct CHash<ACC, N, Ns...> {
+ static const unsigned value = CHash<CHash<ACC, N>::value, Ns...>::value;
+};
+
+const unsigned int JSCONST_nStringHash =
+ CHash<'s', 't', 'r', 'i', 'n', 'g'>::value;
+const unsigned int JSCONST_nNumberHash =
+ CHash<'n', 'u', 'm', 'b', 'e', 'r'>::value;
+const unsigned int JSCONST_nBoolHash =
+ CHash<'b', 'o', 'o', 'l', 'e', 'a', 'n'>::value;
+const unsigned int JSCONST_nDateHash = CHash<'d', 'a', 't', 'e'>::value;
+const unsigned int JSCONST_nObjectHash =
+ CHash<'o', 'b', 'j', 'e', 'c', 't'>::value;
+const unsigned int JSCONST_nFXobjHash = CHash<'f', 'x', 'o', 'b', 'j'>::value;
+const unsigned int JSCONST_nNullHash = CHash<'n', 'u', 'l', 'l'>::value;
+const unsigned int JSCONST_nUndefHash =
+ CHash<'u', 'n', 'd', 'e', 'f', 'i', 'n', 'e', 'd'>::value;
+
+static unsigned JS_CalcHash(const wchar_t* main) {
+ return (unsigned)FX_HashCode_String_GetW(main, FXSYS_wcslen(main));
+}
+
+#ifndef NDEBUG
+class HashVerify {
+ public:
+ HashVerify();
+} g_hashVerify;
+
+HashVerify::HashVerify() {
+ ASSERT(JSCONST_nStringHash == JS_CalcHash(kFXJSValueNameString));
+ ASSERT(JSCONST_nNumberHash == JS_CalcHash(kFXJSValueNameNumber));
+ ASSERT(JSCONST_nBoolHash == JS_CalcHash(kFXJSValueNameBoolean));
+ ASSERT(JSCONST_nDateHash == JS_CalcHash(kFXJSValueNameDate));
+ ASSERT(JSCONST_nObjectHash == JS_CalcHash(kFXJSValueNameObject));
+ ASSERT(JSCONST_nFXobjHash == JS_CalcHash(kFXJSValueNameFxobj));
+ ASSERT(JSCONST_nNullHash == JS_CalcHash(kFXJSValueNameNull));
+ ASSERT(JSCONST_nUndefHash == JS_CalcHash(kFXJSValueNameUndefined));
+}
+#endif
+
+BEGIN_JS_STATIC_CONST(CJS_Global)
+END_JS_STATIC_CONST()
+
+BEGIN_JS_STATIC_PROP(CJS_Global)
+END_JS_STATIC_PROP()
+
+BEGIN_JS_STATIC_METHOD(CJS_Global)
+JS_STATIC_METHOD_ENTRY(setPersistent)
+END_JS_STATIC_METHOD()
+
+IMPLEMENT_SPECIAL_JS_CLASS(CJS_Global, JSGlobalAlternate, global);
+
+void CJS_Global::InitInstance(IJS_Runtime* pIRuntime) {
+ CJS_Runtime* pRuntime = static_cast<CJS_Runtime*>(pIRuntime);
+ JSGlobalAlternate* pGlobal =
+ static_cast<JSGlobalAlternate*>(GetEmbedObject());
+ pGlobal->Initial(pRuntime->GetReaderApp());
+}
+
+JSGlobalAlternate::JSGlobalAlternate(CJS_Object* pJSObject)
+ : CJS_EmbedObj(pJSObject), m_pApp(NULL) {}
+
+JSGlobalAlternate::~JSGlobalAlternate() {
+ DestroyGlobalPersisitentVariables();
+ m_pGlobalData->Release();
+}
+
+void JSGlobalAlternate::Initial(CPDFDoc_Environment* pApp) {
+ m_pApp = pApp;
+ m_pGlobalData = CJS_GlobalData::GetRetainedInstance(pApp);
+ UpdateGlobalPersistentVariables();
+}
+
+FX_BOOL JSGlobalAlternate::QueryProperty(const FX_WCHAR* propname) {
+ return CFX_WideString(propname) != L"setPersistent";
+}
+
+FX_BOOL JSGlobalAlternate::DelProperty(IJS_Context* cc,
+ const FX_WCHAR* propname,
+ CFX_WideString& sError) {
+ auto it = m_mapGlobal.find(CFX_ByteString::FromUnicode(propname));
+ if (it == m_mapGlobal.end())
+ return FALSE;
+
+ it->second->bDeleted = TRUE;
+ return TRUE;
+}
+
+FX_BOOL JSGlobalAlternate::DoProperty(IJS_Context* cc,
+ const FX_WCHAR* propname,
+ CJS_PropValue& vp,
+ CFX_WideString& sError) {
+ if (vp.IsSetting()) {
+ CFX_ByteString sPropName = CFX_ByteString::FromUnicode(propname);
+ switch (vp.GetType()) {
+ case CJS_Value::VT_number: {
+ double dData;
+ vp >> dData;
+ return SetGlobalVariables(sPropName, JS_GLOBALDATA_TYPE_NUMBER, dData,
+ false, "", v8::Local<v8::Object>(), FALSE);
+ }
+ case CJS_Value::VT_boolean: {
+ bool bData;
+ vp >> bData;
+ return SetGlobalVariables(sPropName, JS_GLOBALDATA_TYPE_BOOLEAN, 0,
+ bData, "", v8::Local<v8::Object>(), FALSE);
+ }
+ case CJS_Value::VT_string: {
+ CFX_ByteString sData;
+ vp >> sData;
+ return SetGlobalVariables(sPropName, JS_GLOBALDATA_TYPE_STRING, 0,
+ false, sData, v8::Local<v8::Object>(), FALSE);
+ }
+ case CJS_Value::VT_object: {
+ v8::Local<v8::Object> pData;
+ vp >> pData;
+ return SetGlobalVariables(sPropName, JS_GLOBALDATA_TYPE_OBJECT, 0,
+ false, "", pData, FALSE);
+ }
+ case CJS_Value::VT_null: {
+ return SetGlobalVariables(sPropName, JS_GLOBALDATA_TYPE_NULL, 0, false,
+ "", v8::Local<v8::Object>(), FALSE);
+ }
+ case CJS_Value::VT_undefined: {
+ DelProperty(cc, propname, sError);
+ return TRUE;
+ }
+ default:
+ break;
+ }
+ } else {
+ auto it = m_mapGlobal.find(CFX_ByteString::FromUnicode(propname));
+ if (it == m_mapGlobal.end()) {
+ vp.SetNull();
+ return TRUE;
+ }
+ JSGlobalData* pData = it->second;
+ if (pData->bDeleted) {
+ vp.SetNull();
+ return TRUE;
+ }
+ switch (pData->nType) {
+ case JS_GLOBALDATA_TYPE_NUMBER:
+ vp << pData->dData;
+ return TRUE;
+ case JS_GLOBALDATA_TYPE_BOOLEAN:
+ vp << pData->bData;
+ return TRUE;
+ case JS_GLOBALDATA_TYPE_STRING:
+ vp << pData->sData;
+ return TRUE;
+ case JS_GLOBALDATA_TYPE_OBJECT: {
+ v8::Local<v8::Object> obj = v8::Local<v8::Object>::New(
+ vp.GetJSRuntime()->GetIsolate(), pData->pData);
+ vp << obj;
+ return TRUE;
+ }
+ case JS_GLOBALDATA_TYPE_NULL:
+ vp.SetNull();
+ return TRUE;
+ default:
+ break;
+ }
+ }
+ return FALSE;
+}
+
+FX_BOOL JSGlobalAlternate::setPersistent(IJS_Context* cc,
+ const std::vector<CJS_Value>& params,
+ CJS_Value& vRet,
+ CFX_WideString& sError) {
+ CJS_Context* pContext = static_cast<CJS_Context*>(cc);
+ if (params.size() != 2) {
+ sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
+ return FALSE;
+ }
+
+ auto it = m_mapGlobal.find(params[0].ToCFXByteString());
+ if (it != m_mapGlobal.end()) {
+ JSGlobalData* pData = it->second;
+ if (!pData->bDeleted) {
+ pData->bPersistent = params[1].ToBool();
+ return TRUE;
+ }
+ }
+
+ sError = JSGetStringFromID(pContext, IDS_STRING_JSNOGLOBAL);
+ return FALSE;
+}
+
+void JSGlobalAlternate::UpdateGlobalPersistentVariables() {
+ for (int i = 0, sz = m_pGlobalData->GetSize(); i < sz; i++) {
+ CJS_GlobalData_Element* pData = m_pGlobalData->GetAt(i);
+ switch (pData->data.nType) {
+ case JS_GLOBALDATA_TYPE_NUMBER:
+ SetGlobalVariables(pData->data.sKey, JS_GLOBALDATA_TYPE_NUMBER,
+ pData->data.dData, false, "",
+ v8::Local<v8::Object>(), pData->bPersistent == 1);
+ FXJS_PutObjectNumber(NULL, m_pJSObject->ToV8Object(),
+ pData->data.sKey.UTF8Decode().c_str(),
+ pData->data.dData);
+ break;
+ case JS_GLOBALDATA_TYPE_BOOLEAN:
+ SetGlobalVariables(pData->data.sKey, JS_GLOBALDATA_TYPE_BOOLEAN, 0,
+ (bool)(pData->data.bData == 1), "",
+ v8::Local<v8::Object>(), pData->bPersistent == 1);
+ FXJS_PutObjectBoolean(NULL, m_pJSObject->ToV8Object(),
+ pData->data.sKey.UTF8Decode().c_str(),
+ (bool)(pData->data.bData == 1));
+ break;
+ case JS_GLOBALDATA_TYPE_STRING:
+ SetGlobalVariables(pData->data.sKey, JS_GLOBALDATA_TYPE_STRING, 0,
+ false, pData->data.sData, v8::Local<v8::Object>(),
+ pData->bPersistent == 1);
+ FXJS_PutObjectString(NULL, m_pJSObject->ToV8Object(),
+ pData->data.sKey.UTF8Decode().c_str(),
+ pData->data.sData.UTF8Decode().c_str());
+ break;
+ case JS_GLOBALDATA_TYPE_OBJECT: {
+ v8::Isolate* pRuntime = m_pJSObject->ToV8Object()->GetIsolate();
+ v8::Local<v8::Object> pObj = FXJS_NewFxDynamicObj(pRuntime, NULL, -1);
+
+ PutObjectProperty(pObj, &pData->data);
+
+ SetGlobalVariables(pData->data.sKey, JS_GLOBALDATA_TYPE_OBJECT, 0,
+ false, "", pObj, pData->bPersistent == 1);
+ FXJS_PutObjectObject(NULL, m_pJSObject->ToV8Object(),
+ pData->data.sKey.UTF8Decode().c_str(), pObj);
+ } break;
+ case JS_GLOBALDATA_TYPE_NULL:
+ SetGlobalVariables(pData->data.sKey, JS_GLOBALDATA_TYPE_NULL, 0, false,
+ "", v8::Local<v8::Object>(),
+ pData->bPersistent == 1);
+ FXJS_PutObjectNull(NULL, m_pJSObject->ToV8Object(),
+ pData->data.sKey.UTF8Decode().c_str());
+ break;
+ }
+ }
+}
+
+void JSGlobalAlternate::CommitGlobalPersisitentVariables(IJS_Context* cc) {
+ for (auto it = m_mapGlobal.begin(); it != m_mapGlobal.end(); ++it) {
+ CFX_ByteString name = it->first;
+ JSGlobalData* pData = it->second;
+ if (pData->bDeleted) {
+ m_pGlobalData->DeleteGlobalVariable(name);
+ } else {
+ switch (pData->nType) {
+ case JS_GLOBALDATA_TYPE_NUMBER:
+ m_pGlobalData->SetGlobalVariableNumber(name, pData->dData);
+ m_pGlobalData->SetGlobalVariablePersistent(name, pData->bPersistent);
+ break;
+ case JS_GLOBALDATA_TYPE_BOOLEAN:
+ m_pGlobalData->SetGlobalVariableBoolean(name, pData->bData);
+ m_pGlobalData->SetGlobalVariablePersistent(name, pData->bPersistent);
+ break;
+ case JS_GLOBALDATA_TYPE_STRING:
+ m_pGlobalData->SetGlobalVariableString(name, pData->sData);
+ m_pGlobalData->SetGlobalVariablePersistent(name, pData->bPersistent);
+ break;
+ case JS_GLOBALDATA_TYPE_OBJECT: {
+ CJS_GlobalVariableArray array;
+ v8::Local<v8::Object> obj = v8::Local<v8::Object>::New(
+ GetJSObject()->GetIsolate(), pData->pData);
+ ObjectToArray(cc, obj, array);
+ m_pGlobalData->SetGlobalVariableObject(name, array);
+ m_pGlobalData->SetGlobalVariablePersistent(name, pData->bPersistent);
+ } break;
+ case JS_GLOBALDATA_TYPE_NULL:
+ m_pGlobalData->SetGlobalVariableNull(name);
+ m_pGlobalData->SetGlobalVariablePersistent(name, pData->bPersistent);
+ break;
+ }
+ }
+ }
+}
+
+void JSGlobalAlternate::ObjectToArray(IJS_Context* cc,
+ v8::Local<v8::Object> pObj,
+ CJS_GlobalVariableArray& array) {
+ v8::Isolate* isolate = pObj->GetIsolate();
+ CJS_Runtime* pRuntime = CJS_Runtime::FromContext(cc);
+
+ v8::Local<v8::Array> pKeyList = FXJS_GetObjectElementNames(isolate, pObj);
+ int nObjElements = pKeyList->Length();
+ for (int i = 0; i < nObjElements; i++) {
+ CFX_WideString ws =
+ FXJS_ToString(isolate, FXJS_GetArrayElement(isolate, pKeyList, i));
+ CFX_ByteString sKey = ws.UTF8Encode();
+
+ v8::Local<v8::Value> v = FXJS_GetObjectElement(isolate, pObj, ws.c_str());
+ switch (GET_VALUE_TYPE(v)) {
+ case CJS_Value::VT_number: {
+ CJS_KeyValue* pObjElement = new CJS_KeyValue;
+ pObjElement->nType = JS_GLOBALDATA_TYPE_NUMBER;
+ pObjElement->sKey = sKey;
+ pObjElement->dData = FXJS_ToNumber(isolate, v);
+ array.Add(pObjElement);
+ } break;
+ case CJS_Value::VT_boolean: {
+ CJS_KeyValue* pObjElement = new CJS_KeyValue;
+ pObjElement->nType = JS_GLOBALDATA_TYPE_BOOLEAN;
+ pObjElement->sKey = sKey;
+ pObjElement->dData = FXJS_ToBoolean(isolate, v);
+ array.Add(pObjElement);
+ } break;
+ case CJS_Value::VT_string: {
+ CFX_ByteString sValue =
+ CJS_Value(pRuntime, v, CJS_Value::VT_string).ToCFXByteString();
+ CJS_KeyValue* pObjElement = new CJS_KeyValue;
+ pObjElement->nType = JS_GLOBALDATA_TYPE_STRING;
+ pObjElement->sKey = sKey;
+ pObjElement->sData = sValue;
+ array.Add(pObjElement);
+ } break;
+ case CJS_Value::VT_object: {
+ CJS_KeyValue* pObjElement = new CJS_KeyValue;
+ pObjElement->nType = JS_GLOBALDATA_TYPE_OBJECT;
+ pObjElement->sKey = sKey;
+ ObjectToArray(cc, FXJS_ToObject(isolate, v), pObjElement->objData);
+ array.Add(pObjElement);
+ } break;
+ case CJS_Value::VT_null: {
+ CJS_KeyValue* pObjElement = new CJS_KeyValue;
+ pObjElement->nType = JS_GLOBALDATA_TYPE_NULL;
+ pObjElement->sKey = sKey;
+ array.Add(pObjElement);
+ } break;
+ default:
+ break;
+ }
+ }
+}
+
+void JSGlobalAlternate::PutObjectProperty(v8::Local<v8::Object> pObj,
+ CJS_KeyValue* pData) {
+ for (int i = 0, sz = pData->objData.Count(); i < sz; i++) {
+ CJS_KeyValue* pObjData = pData->objData.GetAt(i);
+ switch (pObjData->nType) {
+ case JS_GLOBALDATA_TYPE_NUMBER:
+ FXJS_PutObjectNumber(NULL, pObj, pObjData->sKey.UTF8Decode().c_str(),
+ pObjData->dData);
+ break;
+ case JS_GLOBALDATA_TYPE_BOOLEAN:
+ FXJS_PutObjectBoolean(NULL, pObj, pObjData->sKey.UTF8Decode().c_str(),
+ pObjData->bData == 1);
+ break;
+ case JS_GLOBALDATA_TYPE_STRING:
+ FXJS_PutObjectString(NULL, pObj, pObjData->sKey.UTF8Decode().c_str(),
+ pObjData->sData.UTF8Decode().c_str());
+ break;
+ case JS_GLOBALDATA_TYPE_OBJECT: {
+ v8::Isolate* pRuntime = m_pJSObject->ToV8Object()->GetIsolate();
+ v8::Local<v8::Object> pNewObj =
+ FXJS_NewFxDynamicObj(pRuntime, NULL, -1);
+ PutObjectProperty(pNewObj, pObjData);
+ FXJS_PutObjectObject(NULL, pObj, pObjData->sKey.UTF8Decode().c_str(),
+ pNewObj);
+ } break;
+ case JS_GLOBALDATA_TYPE_NULL:
+ FXJS_PutObjectNull(NULL, pObj, pObjData->sKey.UTF8Decode().c_str());
+ break;
+ }
+ }
+}
+
+void JSGlobalAlternate::DestroyGlobalPersisitentVariables() {
+ for (const auto& pair : m_mapGlobal) {
+ delete pair.second;
+ }
+ m_mapGlobal.clear();
+}
+
+FX_BOOL JSGlobalAlternate::SetGlobalVariables(const FX_CHAR* propname,
+ int nType,
+ double dData,
+ bool bData,
+ const CFX_ByteString& sData,
+ v8::Local<v8::Object> pData,
+ bool bDefaultPersistent) {
+ if (!propname)
+ return FALSE;
+
+ auto it = m_mapGlobal.find(propname);
+ if (it != m_mapGlobal.end()) {
+ JSGlobalData* pTemp = it->second;
+ if (pTemp->bDeleted || pTemp->nType != nType) {
+ pTemp->dData = 0;
+ pTemp->bData = 0;
+ pTemp->sData = "";
+ pTemp->nType = nType;
+ }
+
+ pTemp->bDeleted = FALSE;
+ switch (nType) {
+ case JS_GLOBALDATA_TYPE_NUMBER: {
+ pTemp->dData = dData;
+ } break;
+ case JS_GLOBALDATA_TYPE_BOOLEAN: {
+ pTemp->bData = bData;
+ } break;
+ case JS_GLOBALDATA_TYPE_STRING: {
+ pTemp->sData = sData;
+ } break;
+ case JS_GLOBALDATA_TYPE_OBJECT: {
+ pTemp->pData.Reset(pData->GetIsolate(), pData);
+ } break;
+ case JS_GLOBALDATA_TYPE_NULL:
+ break;
+ default:
+ return FALSE;
+ }
+ return TRUE;
+ }
+
+ JSGlobalData* pNewData = NULL;
+
+ switch (nType) {
+ case JS_GLOBALDATA_TYPE_NUMBER: {
+ pNewData = new JSGlobalData;
+ pNewData->nType = JS_GLOBALDATA_TYPE_NUMBER;
+ pNewData->dData = dData;
+ pNewData->bPersistent = bDefaultPersistent;
+ } break;
+ case JS_GLOBALDATA_TYPE_BOOLEAN: {
+ pNewData = new JSGlobalData;
+ pNewData->nType = JS_GLOBALDATA_TYPE_BOOLEAN;
+ pNewData->bData = bData;
+ pNewData->bPersistent = bDefaultPersistent;
+ } break;
+ case JS_GLOBALDATA_TYPE_STRING: {
+ pNewData = new JSGlobalData;
+ pNewData->nType = JS_GLOBALDATA_TYPE_STRING;
+ pNewData->sData = sData;
+ pNewData->bPersistent = bDefaultPersistent;
+ } break;
+ case JS_GLOBALDATA_TYPE_OBJECT: {
+ pNewData = new JSGlobalData;
+ pNewData->nType = JS_GLOBALDATA_TYPE_OBJECT;
+ pNewData->pData.Reset(pData->GetIsolate(), pData);
+ pNewData->bPersistent = bDefaultPersistent;
+ } break;
+ case JS_GLOBALDATA_TYPE_NULL: {
+ pNewData = new JSGlobalData;
+ pNewData->nType = JS_GLOBALDATA_TYPE_NULL;
+ pNewData->bPersistent = bDefaultPersistent;
+ } break;
+ default:
+ return FALSE;
+ }
+
+ m_mapGlobal[propname] = pNewData;
+ return TRUE;
+}
+
+CJS_Value::Type GET_VALUE_TYPE(v8::Local<v8::Value> p) {
+ const unsigned int nHash = JS_CalcHash(FXJS_GetTypeof(p));
+
+ if (nHash == JSCONST_nUndefHash)
+ return CJS_Value::VT_undefined;
+ if (nHash == JSCONST_nNullHash)
+ return CJS_Value::VT_null;
+ if (nHash == JSCONST_nStringHash)
+ return CJS_Value::VT_string;
+ if (nHash == JSCONST_nNumberHash)
+ return CJS_Value::VT_number;
+ if (nHash == JSCONST_nBoolHash)
+ return CJS_Value::VT_boolean;
+ if (nHash == JSCONST_nDateHash)
+ return CJS_Value::VT_date;
+ if (nHash == JSCONST_nObjectHash)
+ return CJS_Value::VT_object;
+ if (nHash == JSCONST_nFXobjHash)
+ return CJS_Value::VT_fxobject;
+
+ return CJS_Value::VT_unknown;
+}