void FileSystemDevice::FileState::complete_readbuf(PacketHeader *packet_) { Packet<uint8,Sys::AsyncFile::ReadBufExt,ReadExt> packet=packet_; auto ext=packet.getExt(); auto ext2=packet.getDeepExt<1>(); if( ext->isOk() ) { if( ext->off==ext2->off ) { if( ext->data.len==ext2->len ) { ext2->setData(ext->data.ptr); } else { ext2->setError(FileError_ReadLenMismatch); } } else { ext2->setError(FileError_BadPosition); } } else { ext2->setError(MakeError(ext,FileError_ReadFault)); } packet.popExt().complete(); }
void close() { error=MakeError(FileError_OpenFault); Win32::CloseHandle(handle); // ignore unprobable error handle=Win32::InvalidFileHandle; }
TValueOrError<TArray<FCompiledToken>, FExpressionError> Compile() { auto Error = CompileGroup(nullptr, nullptr); if (Error.IsSet()) { return MakeError(Error.GetValue()); } return MakeValue(MoveTemp(Commands)); }
SMCResult CPluginInfoDatabase::ReadSMC_NewSection(const SMCStates *states, const char *name) { if (!in_plugins) { /* If we're not in the main Plugins section, and we don't get it for the name, error out */ if (strcmp(name, "Plugins") != 0) { return MakeError("Unknown root section: \"%s\"", name); } else { /* Otherwise set our states */ in_plugins = true; cur_plugin = -1; in_options = false; } } else { if (cur_plugin == -1) { /* If we get a plugin node and we don't have a current plugin, create a new one */ PluginSettings *plugin; int i_name = m_strtab->AddString(name); cur_plugin = m_strtab->GetMemTable()->CreateMem(sizeof(PluginSettings), (void **)&plugin); plugin->Init(); plugin->name = i_name; in_options = false; } else { if (!in_options && strcmp(name, "Options") == 0) { in_options = true; } else { return MakeError("Unknown plugin sub-section: \"%s\"", name); } } } return SMCResult_Continue; }
CompileResultType Compile(const TCHAR* InExpression, const FTokenDefinitions& InTokenDefinitions, const FExpressionGrammar& InGrammar) { TValueOrError<TArray<FExpressionToken>, FExpressionError> Result = Lex(InExpression, InTokenDefinitions); if (!Result.IsValid()) { return MakeError(Result.GetError()); } return Compile(MoveTemp(Result.GetValue()), InGrammar); }
FExpressionResult Evaluate(const TCHAR* InExpression, const FTokenDefinitions& InTokenDefinitions, const FExpressionGrammar& InGrammar, const IOperatorEvaluationEnvironment& InEnvironment) { TValueOrError<TArray<FCompiledToken>, FExpressionError> CompilationResult = Compile(InExpression, InTokenDefinitions, InGrammar); if (!CompilationResult.IsValid()) { return MakeError(CompilationResult.GetError()); } return Evaluate(CompilationResult.GetValue(), InEnvironment); }
LexResultType Lex(const TCHAR* InExpression, const FTokenDefinitions& TokenDefinitions) { FExpressionTokenConsumer TokenConsumer(InExpression); TOptional<FExpressionError> Error = TokenDefinitions.ConsumeTokens(TokenConsumer); if (Error.IsSet()) { return MakeError(Error.GetValue()); } return MakeValue(TokenConsumer.Extract()); }
bool set(Win32::handle_t h_file) { handle=h_file; if( h_file==Win32::InvalidFileHandle ) { error=MakeError(FileError_OpenFault); return false; } else { error=FileError_Ok; return true; } }
void FileSystemDevice::complete_getFileList(PacketHeader *packet_) { Packet<uint8,Sys::AsyncFileSystem::FileExt,GetFileListExt> packet=packet_; auto ext=packet.getExt(); auto ext2=packet.getDeepExt<1>(); if( ext->isOk() ) { CompleteFile(ext2,ext->file_id,ext->file_len); } else { CompleteFile(ext2,MakeError(ext,FileError_OpFault)); } packet.popExt().complete(); }
void FileSystemDevice::FileState::complete_write(PacketHeader *packet_) { Packet<uint8,Sys::AsyncFile::WriteExt,WriteExt> packet=packet_; auto ext=packet.getExt(); auto ext2=packet.getDeepExt<1>(); if( ext->isOk() ) { ext2->setFileLen(ext->file_len); } else { ext2->setError(MakeError(ext,FileError_WriteFault)); } packet.popExt().complete(); }
void FileSystemDevice::complete_getFileUpdateTime(PacketHeader *packet_) { Packet<uint8,Sys::AsyncFileSystem::CmpFileTimeExt,GetFileUpdateTimeExt> packet=packet_; auto ext=packet.getExt(); auto ext2=packet.getDeepExt<1>(); if( ext->isOk() ) { ext2->setFileTime(ext->file_time); } else { ext2->setError(MakeError(ext,FileError_OpFault)); } packet.popExt().complete(); }
void FileSystemDevice::FileState::complete_close(PacketHeader *packet_) { Packet<uint8,Sys::AsyncFile::CloseExt,CloseExt> packet=packet_; auto ext=packet.getExt(); auto ext2=packet.getDeepExt<1>(); if( ext->isOk() ) { ext2->noError(); } else { ext2->setError(MakeError(ext,FileError_CloseFault)); } packet.popExt().complete(); }
void Web::main(std::string url) { struct timeval start, end; gettimeofday(&start, NULL); long mtime, seconds, useconds; std::string lock = GetFromConfig<std::string>("setup.lockfile"); if (!Generic::FileSystem::Check(lock).ExistFile()) { if (url != "/setup"){ response().set_redirect_header("/setup"); return; } } if (!dispatcher().dispatch(url)) { MakeError("html",404,"Url " + url + " was not found"); } gettimeofday(&end, NULL); seconds = end.tv_sec - start.tv_sec; useconds = end.tv_usec - start.tv_usec; mtime = ((seconds) * 1000 + useconds/1000.0) + 0.5; printf("Elapsed time: %ld milliseconds\n", mtime); }
void FTextFormatData::Compile_NoLock() { LexedExpression.Reset(); if (SourceType == ESourceType::Text) { SourceExpression = SourceText.ToString(); CompiledTextSnapshot = FTextSnapshot(SourceText); } CompiledExpressionType = FTextFormat::EExpressionType::Simple; BaseFormatStringLength = 0; FormatArgumentEstimateMultiplier = 1; TValueOrError<TArray<FExpressionToken>, FExpressionError> Result = ExpressionParser::Lex(*SourceExpression, FTextFormatter::Get().GetTextFormatDefinitions()); bool bValidExpression = Result.IsValid(); if (bValidExpression) { LexedExpression = Result.StealValue(); // Quickly make sure the tokens are valid (argument modifiers may only follow an argument token) for (int32 TokenIndex = 0; TokenIndex < LexedExpression.Num(); ++TokenIndex) { const FExpressionToken& Token = LexedExpression[TokenIndex]; if (const auto* Literal = Token.Node.Cast<TextFormatTokens::FStringLiteral>()) { BaseFormatStringLength += Literal->StringLen; } else if (auto* Escaped = Token.Node.Cast<TextFormatTokens::FEscapedCharacter>()) { BaseFormatStringLength += 1; } else if (const auto* ArgumentToken = Token.Node.Cast<TextFormatTokens::FArgumentTokenSpecifier>()) { CompiledExpressionType = FTextFormat::EExpressionType::Complex; if (LexedExpression.IsValidIndex(TokenIndex + 1)) { const FExpressionToken& NextToken = LexedExpression[TokenIndex + 1]; // Peek to see if the next token is an argument modifier if (const auto* ArgumentModifierToken = NextToken.Node.Cast<TextFormatTokens::FArgumentModifierTokenSpecifier>()) { int32 ArgModLength = 0; bool ArgModUsesFormatArgs = false; ArgumentModifierToken->TextFormatArgumentModifier->EstimateLength(ArgModLength, ArgModUsesFormatArgs); BaseFormatStringLength += ArgModLength; FormatArgumentEstimateMultiplier += (ArgModUsesFormatArgs) ? 1 : 0; ++TokenIndex; // walk over the argument token so that the next iteration will skip over the argument modifier continue; } } } else if (Token.Node.Cast<TextFormatTokens::FArgumentModifierTokenSpecifier>()) { // Unexpected argument modifier token! const FText ErrorSourceText = FText::FromString(Token.Context.GetString()); Result = MakeError(FExpressionError(FText::Format(LOCTEXT("UnexpectedArgumentModifierToken", "Unexpected 'argument modifier' token: {0} (token started at index {1})"), ErrorSourceText, Token.Context.GetCharacterIndex()))); bValidExpression = false; break; } } } if (!bValidExpression) { LexedExpression.Reset(); CompiledExpressionType = FTextFormat::EExpressionType::Invalid; UE_LOG(LogTextFormatter, Warning, TEXT("Failed to compile text format string '%s': %s"), *SourceExpression, *Result.GetError().Text.ToString()); } }
Type* Type::Read(Buffer *buf) { uint32_t kind = 0; uint32_t width = 0; uint32_t count = 0; bool sign = false; bool varargs = false; String *name = NULL; Type *target_type = NULL; TypeCSU *csu_type = NULL; Vector<Type*> argument_types; Try(ReadOpenTag(buf, TAG_Type)); while (!ReadCloseTag(buf, TAG_Type)) { switch (PeekOpenTag(buf)) { case TAG_Kind: { Try(!kind); Try(ReadTagUInt32(buf, TAG_Kind, &kind)); break; } case TAG_Width: { Try(ReadTagUInt32(buf, TAG_Width, &width)); break; } case TAG_Sign: { Try(ReadTagEmpty(buf, TAG_Sign)); sign = true; break; } case TAG_Name: { Try(!name); Try(kind == YK_CSU); name = String::ReadWithTag(buf, TAG_Name); break; } case TAG_Type: { Try(!target_type); Try(kind == YK_Pointer || kind == YK_Array || kind == YK_Function); target_type = Type::Read(buf); break; } case TAG_Count: { Try(kind == YK_Array); Try(ReadTagUInt32(buf, TAG_Count, &count)); break; } case TAG_TypeFunctionCSU: { Try(!csu_type); Try(ReadOpenTag(buf, TAG_TypeFunctionCSU)); csu_type = Type::Read(buf)->AsCSU(); Try(ReadCloseTag(buf, TAG_TypeFunctionCSU)); break; } case TAG_TypeFunctionVarArgs: { Try(kind == YK_Function); Try(ReadTagEmpty(buf, TAG_TypeFunctionVarArgs)); varargs = true; break; } case TAG_TypeFunctionArguments: { Try(kind == YK_Function); Try(argument_types.Empty()); Try(ReadOpenTag(buf, TAG_TypeFunctionArguments)); while (!ReadCloseTag(buf, TAG_TypeFunctionArguments)) { Type *ntype = Type::Read(buf); argument_types.PushBack(ntype); } break; } default: Try(false); } } switch ((TypeKind)kind) { case YK_Error: return MakeError(); case YK_Void: return MakeVoid(); case YK_Int: return MakeInt(width, sign); case YK_Float: return MakeFloat(width); case YK_Pointer: Try(target_type); return MakePointer(target_type, width); case YK_Array: Try(target_type); return MakeArray(target_type, count); case YK_CSU: Try(name); return MakeCSU(name); case YK_Function: Try(target_type); return MakeFunction(target_type, csu_type, varargs, argument_types); default: Try(false); } }
SMCResult CPluginInfoDatabase::ReadSMC_KeyValue(const SMCStates *states, const char *key, const char *value) { if (cur_plugin != -1) { PluginSettings *plugin = (PluginSettings *)m_strtab->GetMemTable()->GetAddress(cur_plugin); if (!in_options) { if (strcmp(key, "pause") == 0) { if (strcasecmp(value, "yes") == 0) { plugin->pause_val = true; } else { plugin->pause_val = false; } } else if (strcmp(key, "lifetime") == 0) { if (strcasecmp(value, "private") == 0) { plugin->type_val = PluginType_Private; } else if (strcasecmp(value, "mapsync") == 0) { plugin->type_val = PluginType_MapUpdated; } else if (strcasecmp(value, "maponly") == 0) { plugin->type_val = PluginType_MapOnly; } else if (strcasecmp(value, "global") == 0) { plugin->type_val = PluginType_Global; } else { return MakeError("Unknown value for key \"lifetime\": \"%s\"", value); } } else if (strcmp(key, "blockload") == 0) { plugin->blockload_val = true; } else { return MakeError("Unknown property key: \"%s\"", key); } } else { /* Cache every option, valid or not */ int keyidx = m_strtab->AddString(key); int validx = m_strtab->AddString(value); PluginOpts *table; BaseMemTable *memtab = m_strtab->GetMemTable(); plugin = (PluginSettings *)memtab->GetAddress(cur_plugin); if (plugin->opts_num + 1 > plugin->opts_size) { unsigned int oldsize = plugin->opts_size; if (oldsize == 0) { //right now we don't have many plugin->opts_size = 2; } else { plugin->opts_size *= 2; } int newidx = memtab->CreateMem(plugin->opts_size * sizeof(PluginOpts), (void **)&table); /* in case it resized */ plugin = (PluginSettings *)memtab->GetAddress(cur_plugin); if (plugin->optarray != -1) { void *oldtable = memtab->GetAddress(plugin->optarray); memcpy(table, oldtable, oldsize * sizeof(PluginOpts)); } plugin->optarray = newidx; } else { table = (PluginOpts *)memtab->GetAddress(plugin->optarray); } PluginOpts *opt = &table[plugin->opts_num++]; opt->key = keyidx; opt->val = validx; } } else if (in_plugins) { return MakeError("Unknown property key: \"%s\"", key); } else { /* Ignore anything we don't know about! */ } return SMCResult_Continue; }
FExpressionResult Evaluate(const TArray<FCompiledToken>& CompiledTokens, const IOperatorEvaluationEnvironment& InEnvironment) { // Evaluation strategy: the supplied compiled tokens are const. To avoid copying the whole array, we store a separate array of // any tokens that are generated at runtime by the evaluator. The operand stack will consist of indices into either the CompiledTokens // array, or the RuntimeGeneratedTokens (where Index >= CompiledTokens.Num()) TArray<FExpressionToken> RuntimeGeneratedTokens; TArray<int32> OperandStack; /** Get the token pertaining to the specified operand index */ auto GetToken = [&](int32 Index) -> const FExpressionToken& { if (Index < CompiledTokens.Num()) { return CompiledTokens[Index]; } return RuntimeGeneratedTokens[Index - CompiledTokens.Num()]; }; /** Add a new token to the runtime generated array */ auto AddToken = [&](FExpressionToken&& In) -> int32 { auto Index = CompiledTokens.Num() + RuntimeGeneratedTokens.Num(); RuntimeGeneratedTokens.Emplace(MoveTemp(In)); return Index; }; for (int32 Index = 0; Index < CompiledTokens.Num(); ++Index) { const auto& Token = CompiledTokens[Index]; switch(Token.Type) { case FCompiledToken::Benign: continue; case FCompiledToken::Operand: OperandStack.Push(Index); continue; case FCompiledToken::BinaryOperator: if (OperandStack.Num() >= 2) { // Binary const auto& R = GetToken(OperandStack.Pop()); const auto& L = GetToken(OperandStack.Pop()); auto OpResult = InEnvironment.ExecBinary(Token, L, R); if (OpResult.IsValid()) { // Inherit the LHS context OperandStack.Push(AddToken(FExpressionToken(L.Context, MoveTemp(OpResult.GetValue())))); } else { return MakeError(OpResult.GetError()); } } else { FFormatOrderedArguments Args; Args.Add(FText::FromString(Token.Context.GetString())); return MakeError(FText::Format(LOCTEXT("SyntaxError_NotEnoughOperandsBinary", "Not enough operands for binary operator {0}"), Args)); } break; case FCompiledToken::PostUnaryOperator: case FCompiledToken::PreUnaryOperator: if (OperandStack.Num() >= 1) { const auto& Operand = GetToken(OperandStack.Pop()); FExpressionResult OpResult = (Token.Type == FCompiledToken::PreUnaryOperator) ? InEnvironment.ExecPreUnary(Token, Operand) : InEnvironment.ExecPostUnary(Token, Operand); if (OpResult.IsValid()) { // Inherit the LHS context OperandStack.Push(AddToken(FExpressionToken(Operand.Context, MoveTemp(OpResult.GetValue())))); } else { return MakeError(OpResult.GetError()); } } else { FFormatOrderedArguments Args; Args.Add(FText::FromString(Token.Context.GetString())); return MakeError(FText::Format(LOCTEXT("SyntaxError_NoUnaryOperand", "No operand for unary operator {0}"), Args)); } break; } } if (OperandStack.Num() == 1) { return MakeValue(GetToken(OperandStack[0]).Node.Copy()); } return MakeError(LOCTEXT("SyntaxError_InvalidExpression", "Could not evaluate expression")); }