{

ec1=1,

ec2

{

int value;

friend std::ostream & operator<<( std::ostream & os, e_lua_pcall_error const & x )

{

os << "Lua error code = " << x.value;

switch( x.value )

{

case LUA_ERRRUN: return os << " (LUA_ERRRUN)";

case LUA_ERRMEM: return os << " (LUA_ERRMEM)";

case LUA_ERRERR: return os << " (LUA_ERRERR)";

default: return os << " (unknown)";

}

}

{

bool success = rand() % 2; // "Sometimes" do_work fails.

if( success )

{

lua_pushnumber(L, 42); // Success, push the result on the Lua stack, return to Lua.

return 1;

}

else

{

(void) leaf::new_error(ec1);

return luaL_error(L,"do_work_error"); // luaL_error does not return (longjmp).

}

{

// Create a new lua_State, we'll use std::shared_ptr for automatic cleanup.

std::shared_ptr<lua_State> L(lua_open(), &lua_close);

// Register the do_work function (above) as a C callback, under the global

// Lua name "do_work". With this, calls from Lua programs to do_work will

// land in the do_work C function we've registered.

lua_register( &*L, "do_work", &do_work );

// Pass some Lua code as a C string literal to Lua. This creates a global

// Lua function called "call_do_work", which we will later ask Lua to

// execute.

luaL_dostring( &*L, "\

\n end" );

return L;

{

leaf::error_monitor cur_err;

// Ask the Lua interpreter to call the global Lua function call_do_work.

lua_getfield( L, LUA_GLOBALSINDEX, "call_do_work" );

if( int err = lua_pcall(L, 0, 1, 0) ) // Ask Lua to call the global function call_do_work.

{

std::string msg = lua_tostring(L, 1);

lua_pop(L, 1);

// We got a Lua error which may be the error we're reporting from

// do_work, or some other error. If it is another error,

// cur_err.assigned_error_id() will return a new leaf::error_id,

// otherwise we'll be working with the original value returned by

// leaf::new_error in do_work.

return cur_err.assigned_error_id().load( e_lua_pcall_error{err}, e_lua_error_message{std::move(msg)} );

}

else

{

// Success! Just return the int answer.

int answer = lua_tonumber(L, -1);

lua_pop(L, 1);

return answer;

}

{

std::shared_ptr<lua_State> L=init_lua_state();

for( int i=0; i!=10; ++i )

{

leaf::try_handle_all(

[&]() -> leaf::result<void>

{

BOOST_LEAF_AUTO(answer, call_lua(&*L));

std::cout << "do_work succeeded, answer=" << answer << '\n';

return { };

},

[]( do_work_error_code e, e_lua_error_message const & msg )

{

std::cout << "Got do_work_error_code = " << e << ", " << msg.value << "\n";

},

[]( e_lua_pcall_error const & err, e_lua_error_message const & msg )

{

std::cout << "Got e_lua_pcall_error, " << err << ", " << msg.value << "\n";

},

[]( leaf::error_info const & unmatched )

{

std::cerr <<

"Unknown failure detected" << std::endl <<

"Cryptic diagnostic information follows" << std::endl <<

unmatched;

} );

}

return 0;

{

std::cerr << "Terminating due to a C++ exception under BOOST_LEAF_NO_EXCEPTIONS: " << e.what();

std::terminate();