FX_BOOL CPDF_Object::IsIdentical(CPDF_Object* pOther) const { if (this == pOther) return TRUE; if (!pOther) return FALSE; if (pOther->m_Type != m_Type) { if (IsReference() && GetDirect()) return GetDirect()->IsIdentical(pOther); if (pOther->IsReference()) return IsIdentical(pOther->GetDirect()); return FALSE; } switch (m_Type) { case PDFOBJ_BOOLEAN: return AsBoolean()->Identical(pOther->AsBoolean()); case PDFOBJ_NUMBER: return AsNumber()->Identical(pOther->AsNumber()); case PDFOBJ_STRING: return AsString()->Identical(pOther->AsString()); case PDFOBJ_NAME: return AsName()->Identical(pOther->AsName()); case PDFOBJ_ARRAY: return AsArray()->Identical(pOther->AsArray()); case PDFOBJ_DICTIONARY: return AsDictionary()->Identical(pOther->AsDictionary()); case PDFOBJ_NULL: return TRUE; case PDFOBJ_STREAM: return AsStream()->Identical(pOther->AsStream()); case PDFOBJ_REFERENCE: return AsReference()->Identical(pOther->AsReference()); } return FALSE; }
inline uint64_t Object::Get<uint64_t>(const std::string &key) const { auto value = Find(key); if(!value->IsNumber() && !value->IsString()) throw std::logic_error(std::string("Field was not of type json=type Number of String ") + key); return value->IsNumber() ? static_cast<uint64_t>(value->AsNumber()) : std::stoll(value->AsString()); }
double XPath_Value::AsNumberL () { switch (type) { case XP_VALUE_BOOLEAN: return data.boolean ? 1. : 0.; case XP_VALUE_NUMBER: return data.number; case XP_VALUE_STRING: return AsNumber (data.string); } TempBuffer buffer; ANCHOR (TempBuffer, buffer); return AsNumber (AsStringL (buffer)); }
inline bool Object::Get<bool>(const std::string &key) const { auto value = Find(key); if(value->IsBool()) return value->AsBool(); else if(value->IsNumber()) return value->AsNumber(); else return std::stod(value->AsString()); }
FX_FLOAT CPDF_Object::GetNumber() const { switch (m_Type) { case PDFOBJ_NUMBER: return AsNumber()->GetNumber(); case PDFOBJ_REFERENCE: { const CPDF_Reference* pRef = AsReference(); if (!pRef->m_pObjList) break; CPDF_Object* pObj = pRef->m_pObjList->GetIndirectObject(pRef->GetRefObjNum(), nullptr); return pObj ? pObj->GetNumber() : 0; } } return 0; }
void CPDF_Object::SetString(const CFX_ByteString& str) { switch (m_Type) { case PDFOBJ_BOOLEAN: AsBoolean()->m_bValue = (str == "true"); return; case PDFOBJ_NUMBER: AsNumber()->SetString(str); return; case PDFOBJ_STRING: AsString()->m_String = str; return; case PDFOBJ_NAME: AsName()->m_Name = str; return; } ASSERT(FALSE); }
inline uint64_t Object::GetOpt<uint64_t>(const std::string &key, const uint64_t &defaultValue) const { auto value = FindOpt(key); if(!value || (!value->IsNumber() && !value->IsString())) return defaultValue; if(value->IsString() && value->AsString().empty()) return defaultValue; try { return value->IsNumber() ? static_cast<uint32_t>(value->AsNumber()) : std::stoll(value->AsString()); } catch(std::exception &) { return defaultValue; } }
CFX_ByteString CPDF_Object::GetString() const { switch (m_Type) { case PDFOBJ_BOOLEAN: return AsBoolean()->m_bValue ? "true" : "false"; case PDFOBJ_NUMBER: return AsNumber()->GetString(); case PDFOBJ_STRING: return AsString()->m_String; case PDFOBJ_NAME: return AsName()->m_Name; case PDFOBJ_REFERENCE: { const CPDF_Reference* pRef = AsReference(); if (!pRef->m_pObjList) break; CPDF_Object* pObj = pRef->m_pObjList->GetIndirectObject(pRef->GetRefObjNum(), nullptr); return pObj ? pObj->GetString() : CFX_ByteString(); } } return CFX_ByteString(); }
int CPDF_Object::GetInteger() const { CFX_AutoRestorer<int> restorer(&s_nCurRefDepth); if (++s_nCurRefDepth > kObjectRefMaxDepth) return 0; switch (m_Type) { case PDFOBJ_BOOLEAN: return AsBoolean()->m_bValue; case PDFOBJ_NUMBER: return AsNumber()->GetInteger(); case PDFOBJ_REFERENCE: { const CPDF_Reference* pRef = AsReference(); PARSE_CONTEXT context; FXSYS_memset(&context, 0, sizeof(PARSE_CONTEXT)); if (!pRef->m_pObjList) return 0; CPDF_Object* pObj = pRef->m_pObjList->GetIndirectObject(pRef->GetRefObjNum(), &context); return pObj ? pObj->GetInteger() : 0; } } return 0; }
CPDF_Object* CPDF_Object::CloneInternal(FX_BOOL bDirect, std::set<FX_DWORD>* visited) const { switch (m_Type) { case PDFOBJ_BOOLEAN: return new CPDF_Boolean(AsBoolean()->m_bValue); case PDFOBJ_NUMBER: { const CPDF_Number* pThis = AsNumber(); return new CPDF_Number(pThis->m_bInteger ? pThis->m_Integer : pThis->m_Float); } case PDFOBJ_STRING: { const CPDF_String* pString = AsString(); return new CPDF_String(pString->m_String, pString->IsHex()); } case PDFOBJ_NAME: return new CPDF_Name(AsName()->m_Name); case PDFOBJ_ARRAY: { CPDF_Array* pCopy = new CPDF_Array(); const CPDF_Array* pThis = AsArray(); int n = pThis->GetCount(); for (int i = 0; i < n; i++) { CPDF_Object* value = pThis->m_Objects.GetAt(i); pCopy->m_Objects.Add(value->CloneInternal(bDirect, visited)); } return pCopy; } case PDFOBJ_DICTIONARY: { CPDF_Dictionary* pCopy = new CPDF_Dictionary(); const CPDF_Dictionary* pThis = AsDictionary(); for (const auto& it : *pThis) { pCopy->m_Map.insert(std::make_pair( it.first, it.second->CloneInternal(bDirect, visited))); } return pCopy; } case PDFOBJ_NULL: { return new CPDF_Null; } case PDFOBJ_STREAM: { const CPDF_Stream* pThis = AsStream(); CPDF_StreamAcc acc; acc.LoadAllData(pThis, TRUE); FX_DWORD streamSize = acc.GetSize(); CPDF_Dictionary* pDict = pThis->GetDict(); if (pDict) { pDict = ToDictionary(pDict->CloneInternal(bDirect, visited)); } return new CPDF_Stream(acc.DetachData(), streamSize, pDict); } case PDFOBJ_REFERENCE: { const CPDF_Reference* pRef = AsReference(); FX_DWORD obj_num = pRef->GetRefObjNum(); if (bDirect && !pdfium::ContainsKey(*visited, obj_num)) { visited->insert(obj_num); auto* pDirect = pRef->GetDirect(); return pDirect ? pDirect->CloneInternal(TRUE, visited) : nullptr; } return new CPDF_Reference(pRef->m_pObjList, obj_num); } } return NULL; }
bool USocketIOClientComponent::CallBPFunctionWithResponse(UObject* Target, const FString& FunctionName, TArray<TSharedPtr<FJsonValue>> Response) { if (!Target->IsValidLowLevel()) { UE_LOG(SocketIOLog, Warning, TEXT("CallFunctionByNameWithArguments: Target not found for '%s'"), *FunctionName); return false; } UFunction* Function = Target->FindFunction(FName(*FunctionName)); if (nullptr == Function) { UE_LOG(SocketIOLog, Warning, TEXT("CallFunctionByNameWithArguments: Function not found '%s'"), *FunctionName); return false; } //Check function signature TFieldIterator<UProperty> Iterator(Function); TArray<UProperty*> Properties; while (Iterator && (Iterator->PropertyFlags & CPF_Parm)) { UProperty* Prop = *Iterator; Properties.Add(Prop); ++Iterator; } auto ResponseJsonValue = USIOJConvert::ToSIOJsonValue(Response); bool bResponseNumNotZero = Response.Num() > 0; bool bNoFunctionParams = Properties.Num() == 0; bool bNullResponse = ResponseJsonValue->IsNull(); if (bNullResponse && bNoFunctionParams) { Target->ProcessEvent(Function, nullptr); return true; } else if (bResponseNumNotZero) { //function has too few params if (bNoFunctionParams) { UE_LOG(SocketIOLog, Warning, TEXT("CallFunctionByNameWithArguments: Function '%s' has too few parameters, callback parameters ignored : <%s>"), *FunctionName, *ResponseJsonValue->EncodeJson()); Target->ProcessEvent(Function, nullptr); return true; } struct FDynamicArgs { void* Arg01 = nullptr; USIOJsonValue* Arg02 = nullptr; }; //create the container FDynamicArgs Args = FDynamicArgs(); //add the full response array as second param Args.Arg02 = ResponseJsonValue; const FString& FirstParam = Properties[0]->GetCPPType(); auto FirstFJsonValue = Response[0]; //Is first param... //SIOJsonValue? if (FirstParam.Equals("USIOJsonValue*")) { //convenience wrapper, response is a single object USIOJsonValue* Value = NewObject<USIOJsonValue>(); Value->SetRootValue(FirstFJsonValue); Args.Arg01 = Value; Target->ProcessEvent(Function, &Args); return true; } //SIOJsonObject? else if (FirstParam.Equals("USIOJsonObject*")) { //convenience wrapper, response is a single object USIOJsonObject* ObjectValue = NewObject<USIOJsonObject>(); ObjectValue->SetRootObject(FirstFJsonValue->AsObject()); Args.Arg01 = ObjectValue; Target->ProcessEvent(Function, &Args); return true; } //String? else if (FirstParam.Equals("FString")) { FString StringValue = USIOJConvert::ToJsonString(FirstFJsonValue); Target->ProcessEvent(Function, &StringValue); return true; } //Float? else if (FirstParam.Equals("float")) { float NumberValue = (float)FirstFJsonValue->AsNumber(); Target->ProcessEvent(Function, &NumberValue); return true; } //Int? else if (FirstParam.Equals("int32")) { int NumberValue = (int)FirstFJsonValue->AsNumber(); Target->ProcessEvent(Function, &NumberValue); return true; } //bool? else if (FirstParam.Equals("bool")) { bool BoolValue = FirstFJsonValue->AsBool(); Target->ProcessEvent(Function, &BoolValue); return true; } //array? else if (FirstParam.Equals("TArray")) { UArrayProperty* ArrayProp = Cast<UArrayProperty>(Properties[0]); FString Inner; ArrayProp->GetCPPMacroType(Inner); //byte array is the only supported version if (Inner.Equals("uint8")) { TArray<uint8> Bytes = ResponseJsonValue->AsArray()[0]->AsBinary(); Target->ProcessEvent(Function, &Bytes); return true; } } } UE_LOG(SocketIOLog, Warning, TEXT("CallFunctionByNameWithArguments: Function '%s' signature not supported expected <%s>"), *FunctionName, *ResponseJsonValue->EncodeJson()); return false; }
void CLispEng::Print(ostream& os, CP form) { form &= ~FLAG_Mark; //!!! os << "<" << (void*)form << ">"; os << String(' ', m_printIndent*2); switch (Type(form)) { /*!!! case TS_NIL: os << "NIL"; break;*/ case TS_CHARACTER: { os << "#\\"; wchar_t ch = AsChar(form); switch (ch) { case '\0': os << "NULL"; break; case '\a': os << "BELL"; break; case '\b': os << "BS"; break; case '\t': os << "TAB"; break; case '\n': os << "NL"; break; case '\r': os << "CR"; break; case '\f': os << "FF"; break; case '\x1B': os << "ESC"; break; case '\x7F': os << "RUBOUT"; break; default: os << (char)ch; break; //!!! } } break; case TS_FIXNUM: os << AsNumber(form); break; case TS_FRAME_PTR: os << "#<FRAME " << (DWORD)AsIndex(form) << ">"; break; case TS_FRAMEINFO: os << "#<FRAMEINFO>"; break; case TS_BIGNUM: os << ToBigInteger(form); break; case TS_FLONUM: os << AsFloatVal(form); break; case TS_SYMBOL: { //!!! Print(get_Special(L_S_PACKAGE));//!!!D CSymbolValue *sv = ToSymbol(form); if (sv->HomePackage == m_packKeyword) os << ':'; else if (!sv->HomePackage) os << "#:"; /*!!! else if (!ToPackage(get_Special(L_S_PACKAGE))->IsPresent(form)) { CPackage *pack = ToPackage(sv->HomePackage); os << pack->m_name << ':'; if (pack->m_mapExternalSym.find(sv) == pack->m_mapExternalSym.end()) os << ':'; }*/ #if UCFG_LISP_SPLIT_SYM os << SymNameByIdx(AsIndex(form)); #else os << sv->m_s; #endif } break; case TS_PATHNAME: os << "#P\"" << AsPathname(form)->ToString() << "\""; break; case TS_RATIO: Print(os, AsRatio(form)->m_numerator); os << "/"; Print(os, AsRatio(form)->m_denominator); break;//!!! case TS_MACRO: os << "#<MACRO>"; break; case TS_COMPLEX: os << "#C()"; //!!! break; case TS_CONS: switch (form) { case 0: os << "NIL"; break; case V_U: os << "#<UNBOUND>"; break; default: CSPtr car = Car(form), cdr = Cdr(form); if (car == S(L_QUOTE)) { if (ConsP(cdr)) { os << "\'"; Print(os, Car(cdr)); break; } } if (car == S(L_BACKQUOTE)) { os << "`"; Print(os, Car(cdr)); } else if (car == S(L_UNQUOTE)) { os << ","; Print(os, Car(cdr)); } else if (car == S(L_SPLICE)) { os << ",@"; Print(os, Car(cdr)); } else { os << "("; PrintList(os, form); os << ")"; } } break; case TS_STRUCT: os << "#<STRUCT " << (DWORD)AsIndex(form) << ">"; break; case TS_STREAM: os << "#<STREAM " << (DWORD)AsIndex(form) << ">"; break; case TS_WEAKPOINTER: os << "<#WEAKPOINTER "; Print(os, ToWeakPointer(form)->m_p); os << ">"; break; case TS_SUBR: case TS_INTFUNC: case TS_CCLOSURE: { os << "#\'"; Push(m_r); pair<CP, CP> pp = GetFunctionName(form); Print(os, pp.second); m_r = Pop(); } break; case TS_PACKAGE: os << "#<PACKAGE " << ToPackage(form)->m_name << ">"; break; case TS_READTABLE: os << "#<READTABLE>"; break; case TS_HASHTABLE: { os << "#S(HASH-TABLE <fun>"; CHashMap& m = *Lisp().ToHashTable(form)->m_pMap; for (CHashMap::iterator i=m.begin(); i!=m.end(); ++i) { os << "("; Print(os, i->first); os << " . "; Print(os, i->second); os << ")"; } os << ">"; } break; case TS_ARRAY: if (StringP(form)) os << "\"" << AsString(form) << "\""; else if (VectorP(form)) { os << "#("; CArrayValue *av = ToArray(form); for (size_t i=0; i<av->GetVectorLength(); i++) { if (i) os << " "; Print(os, av->GetElement(i)); } os << ")"; } else { CArrayValue *av = ToArray(form); os << "<ARRAY " << (DWORD)av->TotalSize() << ">"; //!!! /*!!! os << "#("; for (int i=0; i<vv->m_count-1; i++) { Print(vv->m_pData[i]); os << " "; } os << ")";*/ } break; case TS_OBJECT: { os << "#<OBJECT "; //!!! Print(ToObject(form)->m_class); os << " "; //!!! Print(ToObject(form)->m_slots); os << ">"; } break; case TS_SYMBOLMACRO: { os << "#<SYMBOL-MACRO "; CSymbolMacro *sm = ToSymbolMacro(form); Print(os, sm->m_macro); os << ">"; } break; #if UCFG_LISP_FFI case TS_FF_PTR: os << "#<POINTER " << ToPointer(form) << ">"; break; #endif default: os << "#<Bad Form>"; //!!! Ext::Throw(E_FAIL); } }
void CVerifier::Verify(CP p) { CTypeSpec ts = Type(p); if (ts < TS_SYMBOL && (ts!=TS_CONS || p)) return; CObMap::CVal& val = m_obMap.m_arP[g_arTS[ts]][AsIndex(p)]; if (val.Flag) return; val.Flag = true; switch (ts) { case TS_FRAME_PTR: Throw(E_FAIL); case TS_CONS: case TS_RATIO: case TS_COMPLEX: #if UCFG_LISP_BUILTIN_RANDOM_STATE case TS_RANDOMSTATE: #endif { CConsValue *cons = Lisp().AsCons(p); Verify(cons->m_car); Verify(cons->m_cdr); } break; case TS_SYMBOL: { CSymbolValue *sv = ToSymbol(p); Verify(sv->GetFun()); Verify(sv->GetPropList()); Verify(sv->m_dynValue); } break; case TS_INTFUNC: { CIntFuncValue *ifv = Lisp().ToIntFunc(p); Verify(ifv->m_name); Verify(ifv->m_docstring); Verify(ifv->m_body); Verify(ifv->m_vars); Verify(ifv->m_optInits); Verify(ifv->m_keywords); Verify(ifv->m_keyInits); Verify(ifv->m_auxInits); Verify(ifv->m_env.m_varEnv); Verify(ifv->m_env.m_funEnv); Verify(ifv->m_env.m_blockEnv); Verify(ifv->m_env.m_goEnv); Verify(ifv->m_env.m_declEnv); } break; case TS_HASHTABLE: { CHashMap& m = *Lisp().ToHashTable(p)->m_pMap; Verify(m.m_func); for (CHashMap::iterator i=m.begin(); i!=m.end(); ++i) { Verify(i->first); Verify(i->second); } } break; case TS_STRUCT: case TS_OBJECT: case TS_ARRAY: case TS_CCLOSURE: { CArrayValue *av = Lisp().ToArray(p); Verify(av->m_displace); Verify(av->m_fillPointer); Verify(av->m_dims); if (!av->m_displace && av->m_elType == ELTYPE_T) { uintptr_t size = 1; for (CP p1=av->m_dims; p1;) { CConsValue *cons = Lisp().AsCons(p1); size *= AsNumber(cons->m_car); p1 = cons->m_cdr; } for (size_t i=0; i<size; ++i) Verify(av->m_pData[i]); } } break; case TS_PACKAGE: { CPackage *pack = ToPackage(p); Verify(pack->m_useList); //!!! Verify(pack->m_docString); } break; } }