////////////////////////////////////////////////////////////////////////// // // Skips spaces, tabs, newlines, and comments // void Tokenizer::SkipWhiteSpace() { while (isspace(CurrentCh) && CurrentCh ) { GetCh(); } if( '/' == CurrentCh ) // Look for comments { GetCh(); if( '/' == CurrentCh ) { // Throw out everything until the end of the line while( '\n' != CurrentCh ) { GetCh(); } } else if ( '*' == CurrentCh ) { int startLine = CurLine(); while( true ) { GetCh(); if( '*' == CurrentCh ) { GetCh(); if( CondReadCh( '/' ) ) break; else if ( buffer.isEOF() ) { std::ostringstream ost; ost << "Unterminated comment in line "; ost << startLine; throw SyntaxErrorException( ost.str(), *this ); } } else if ( buffer.isEOF() ) { std::ostringstream ost; ost << "Unterminated comment in line "; ost << startLine; throw SyntaxErrorException( ost.str(), *this ); } } } else { std::ostringstream ost; ost << "unexpected character: '" << CurrentCh << "'"; throw SyntaxErrorException( ost.str(), *this ); } SkipWhiteSpace(); // We may need to throw out // more white space/comments // This is admittedly tail recursion... } }
auto_ptr<Token> Tokenizer::Read(SYMBOL kind) { auto_ptr<Token> T( Get() ); if (T->kind() != kind) { string msg( getNameForToken( kind ) ); msg.append( " expected, " ); msg.append(getNameForToken( T->kind() )); msg.append(" found instead!"); throw SyntaxErrorException(msg, *this); } return T; }
Token* Tokenizer::GetQuotedIdent() { GetCh(); // Throw out beginning '"' std::ostringstream ident; while ( '"' != CurrentCh ) { if( '\n' == CurrentCh ) throw SyntaxErrorException( "Unterminated string constant", *this ); ident << CurrentCh; GetCh(); } GetCh(); return new IdentToken( ident.str() ); }
void AmqpException::Throw(const amqp_connection_close_t& reply) { std::ostringstream what; const char* method_name = amqp_method_name(((reply.class_id << 16) | reply.method_id)); std::string reply_text; if (reply.reply_text.bytes != NULL) { reply_text = std::string((char*)reply.reply_text.bytes, reply.reply_text.len); } if (method_name != NULL) { what << "connection error: " << reply.reply_code << ": " << method_name << " caused: " << reply_text; } else { what << "connection error: " << reply.reply_code << ": " << reply_text; } switch (reply.reply_code) { case ConnectionForcedException::REPLY_CODE: throw ConnectionForcedException(what.str(), reply_text, reply.class_id, reply.method_id); case InvalidPathException::REPLY_CODE: throw InvalidPathException(what.str(), reply_text, reply.class_id, reply.method_id); case FrameErrorException::REPLY_CODE: throw FrameErrorException(what.str(), reply_text, reply.class_id, reply.method_id); case SyntaxErrorException::REPLY_CODE: throw SyntaxErrorException(what.str(), reply_text, reply.class_id, reply.method_id); case CommandInvalidException::REPLY_CODE: throw CommandInvalidException(what.str(), reply_text, reply.class_id, reply.method_id); case ChannelErrorException::REPLY_CODE: throw ChannelErrorException(what.str(), reply_text, reply.class_id, reply.method_id); case UnexpectedFrameException::REPLY_CODE: throw UnexpectedFrameException(what.str(), reply_text, reply.class_id, reply.method_id); case ResourceErrorException::REPLY_CODE: throw ResourceErrorException(what.str(), reply_text, reply.class_id, reply.method_id); case NotAllowedException::REPLY_CODE: throw NotAllowedException(what.str(), reply_text, reply.class_id, reply.method_id); case NotImplementedException::REPLY_CODE: throw NotImplementedException(what.str(), reply_text, reply.class_id, reply.method_id); case InternalErrorException::REPLY_CODE: throw InternalErrorException(what.str(), reply_text, reply.class_id, reply.method_id); default: throw std::logic_error(std::string("Programming error: unknown connection reply code: ").append(boost::lexical_cast<std::string>(reply.reply_code))); } }
/** Load Lua string. * Loads the Lua string and places it as a function on top of the stack. * @param s string to load */ void LuaContext::load_string(const char *s) { int err; if ( (err = luaL_loadstring(__L, s)) != 0 ) { std::string errmsg = lua_tostring(__L, -1); lua_pop(__L, 1); switch (err) { case LUA_ERRSYNTAX: throw SyntaxErrorException("Lua syntax error in string '%s': %s", s, errmsg.c_str()); case LUA_ERRMEM: throw OutOfMemoryException("Could not load Lua string '%s'", s); } } }
/** Execute file on a specific Lua state. * @param L Lua state to execute the file in. * @param filename filet to load and excute. */ void LuaContext::do_file(lua_State *L, const char *filename) { // Load initialization code int err = 0; std::string errmsg; if ( (err = luaL_loadfile(L, filename)) != 0) { errmsg = lua_tostring(L, -1); lua_pop(L, 1); switch (err) { case LUA_ERRSYNTAX: throw SyntaxErrorException("Lua syntax error in file %s: %s", filename, errmsg.c_str()); case LUA_ERRMEM: throw OutOfMemoryException("Could not load Lua file %s", filename); case LUA_ERRFILE: throw CouldNotOpenFileException(filename, errmsg.c_str()); } } int errfunc = __enable_tracebacks ? 1 : 0; if ( (err = lua_pcall(L, 0, LUA_MULTRET, errfunc)) != 0 ) { // There was an error while executing the initialization file errmsg = lua_tostring(L, -1); lua_pop(L, 1); switch (err) { case LUA_ERRRUN: throw LuaRuntimeException("do_file", errmsg.c_str()); case LUA_ERRMEM: throw OutOfMemoryException("Could not execute Lua file %s", filename); case LUA_ERRERR: throw LuaErrorException("do_file", errmsg.c_str()); default: throw LuaErrorException("do_file/unknown error", errmsg.c_str()); } } }
Token* Tokenizer::GetPunct() { Token* T; switch (CurrentCh) { case '(': GetCh(); T = new Token(LPAREN); break; case ')': GetCh(); T = new Token(RPAREN); break; case '{': GetCh(); T = new Token(LBRACE); break; case '}': GetCh(); T = new Token(RBRACE); break; case ',': GetCh(); T = new Token(COMMA); break; case '=': GetCh(); T = new Token(EQUALS); break; case ';': GetCh(); T = new Token(SEMICOLON); break; default: std::ostringstream ost; ost << "unexpected character: '" << CurrentCh << "'"; throw SyntaxErrorException(ost.str(), *this); } return T; }
void neo::LuaContext::executeCode(std::istream& code) { std::lock_guard<std::mutex> stateLock(_stateMutex); // since the lua_load function requires a static function, we use this structure // the Reader structure is at the same time an object storing an istream and a buffer, // and a static function provider struct Reader { Reader(std::istream& str) : stream(str) {} std::istream& stream; char buffer[512]; // read function ; "data" must be an instance of Reader static const char* read(lua_State* l, void* data, size_t* size) { assert(size != nullptr); assert(data != nullptr); Reader& me = *((Reader*)data); if (me.stream.eof()) { *size = 0; return nullptr; } me.stream.read(me.buffer, sizeof(me.buffer)); *size = size_t(me.stream.gcount()); // gcount could return a value larger than a size_t, but its maximum is sizeof(me.buffer) so there's no problem return me.buffer; } }; // we create an instance of Reader, and we call lua_load std::unique_ptr<Reader> reader(new Reader(code)); auto loadReturnValue = lua_load(_state, &Reader::read, reader.get(), "chunk"); // now we have to check return value if (loadReturnValue != 0) { // there was an error during loading, an error message was pushed on the stack const char* errorMsg = lua_tostring(_state, -1); lua_pop(_state, 1); if (loadReturnValue == LUA_ERRMEM) throw(std::bad_alloc()); else if (loadReturnValue == LUA_ERRSYNTAX) throw(SyntaxErrorException(std::string(errorMsg))); } else { // calling the loaded function _call<std::tuple<>>(std::tuple<>()); } }