char const*
parse_token_to_eol(
char const* p,
char const* last,
char const*& token_last,
error_code& ec)
{
for(;; ++p)
{
if(p >= last)
{
ec = error::need_more;
return p;
}
if(BOOST_UNLIKELY(! is_print(*p)))
if((BOOST_LIKELY(static_cast<
unsigned char>(*p) < '\040') &&
BOOST_LIKELY(*p != '\011')) ||
BOOST_UNLIKELY(*p == '\177'))
goto found_control;
}
found_control:
if(BOOST_LIKELY(*p == '\r'))
{
if(++p >= last)
{
ec = error::need_more;
return last;
}
if(*p++ != '\n')
{
ec = error::bad_line_ending;
return last;
}
token_last = p - 2;
}
#if 0
// VFALCO This allows `\n` by itself
// to terminate a line
else if(*p == '\n')
{
token_last = p;
++p;
}
#endif
else
{
// invalid character
return nullptr;
}
return p;
}
packaged_task & operator=( packaged_task && other) noexcept {
if ( BOOST_LIKELY( this != & other) ) {
packaged_task tmp{ std::move( other) };
swap( tmp);
}
return * this;
}
promise_base & operator=( promise_base && other) noexcept {
if ( BOOST_LIKELY( this != & other) ) {
promise_base tmp{ std::move( other) };
swap( tmp);
}
return * this;
}
std::size_t pool_resource::pool_cached_blocks(std::size_t pool_idx) const
{
if(BOOST_LIKELY((m_pool_data && pool_idx < m_pool_count))){
return m_pool_data[pool_idx].cache_count();
}
else{
return 0u;
}
}
std::size_t pool_resource::pool_next_blocks_per_chunk(std::size_t pool_idx) const
{
if(BOOST_LIKELY((m_pool_data && pool_idx < m_pool_count))){
return m_pool_data[pool_idx].next_blocks_per_chunk;
}
else{
return 1u;
}
}
std::size_t pool_resource::pool_count() const
{
if(BOOST_LIKELY((0 != m_pool_data))){
return m_pool_count;
}
else{
return priv_pool_index(m_options.largest_required_pool_block)+1u;
}
}
void Hook_Shutdown()
{
if (!lockstep_hooked)
{
return;
}
#ifdef _WIN32
Remove_Hook((void *)GetTickCount, Real_GetTickCount, (void *)Fake_GetTickCount);
#else
Remove_Hook((void *)gettimeofday, Real_gettimeofday, (void *)Fake_gettimeofday);
#endif
Remove_Hook((void *)SDL_GetTicks, Real_SDL_GetTicks, (void *)Fake_SDL_GetTicks);
LOCKSTEP_DEBUG("unhooked ticks");
if (BOOST_LIKELY(lockstep_renderer == enabler->renderer))
{
enabler->renderer = lockstep_renderer->real_renderer;
}
LOCKSTEP_DEBUG("deleting df_ai_renderer");
delete lockstep_renderer;
lockstep_renderer = nullptr;
lockstep_hooked = false;
if (lockstep_want_shutdown_now)
{
if (df::viewscreen *screen = Gui::getCurViewscreen(true))
{
screen->breakdown_level = interface_breakdown_types::QUIT;
}
}
else if (disabling_plugin)
{
enabled = false;
disabling_plugin = false;
check_enabled(Core::getInstance().getConsole());
}
}
void interprocess_semaphore::create_or_open(const wchar_t* name, permissions const& perms)
{
#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
boost::detail::winapi::HANDLE_ h = boost::detail::winapi::CreateSemaphoreExW
(
reinterpret_cast< boost::detail::winapi::SECURITY_ATTRIBUTES_* >(perms.get_native()),
0, // initial count
(std::numeric_limits< boost::detail::winapi::LONG_ >::max)(), // max count
name,
0u, // flags
boost::detail::winapi::SYNCHRONIZE_ | boost::detail::winapi::SEMAPHORE_MODIFY_STATE_ | boost::detail::winapi::SEMAPHORE_QUERY_STATE_
);
#else
boost::detail::winapi::HANDLE_ h = boost::detail::winapi::CreateSemaphoreW
(
reinterpret_cast< boost::detail::winapi::SECURITY_ATTRIBUTES_* >(perms.get_native()),
0, // initial count
(std::numeric_limits< boost::detail::winapi::LONG_ >::max)(), // max count
name
);
#endif
if (h == NULL)
{
boost::detail::winapi::DWORD_ err = boost::detail::winapi::GetLastError();
if (BOOST_LIKELY(err == ERROR_ALREADY_EXISTS))
{
open(name);
return;
}
else
{
BOOST_LOG_THROW_DESCR_PARAMS(boost::log::system_error, "Failed to create an interprocess semaphore object", (err));
}
}
m_sem.init(h);
}
void Hook_Update()
{
if (BOOST_LIKELY(SDL_ThreadID() == enabler->renderer_threadid))
{
return;
}
if (lockstep_want_shutdown)
{
while (!lockstep_ready_for_shutdown)
{
tthread::this_thread::yield();
}
LOCKSTEP_DEBUG("trying to unhook");
lockstep_want_shutdown = false;
lockstep_ready_for_shutdown = false;
Hook_Shutdown();
}
else if (!lockstep_hooked && config.lockstep && !Hook_Want_Disable() && !lockstep_want_shutdown_now)
{
LOCKSTEP_DEBUG("trying to hook");
if (init->display.flag.is_set(init_display_flags::TEXT))
{
auto & out = Core::getInstance().getConsole();
out << COLOR_LIGHTRED << "[df-ai] lockstep mode does not work with PRINT_MODE:TEXT. Disabling lockstep in the df-ai config.";
out << COLOR_RESET << std::endl;
config.set(out, config.lockstep, false);
return;
}
if (strict_virtual_cast<df::viewscreen_movieplayerst>(Gui::getCurViewscreen(false)))
{
LOCKSTEP_DEBUG("not hooking while movie player is present");
return;
}
lockstep_hooked = true;
#ifdef _WIN32
lockstep_tick_count = GetTickCount();
LOCKSTEP_DEBUG("initial lockstep_tick_count is " << lockstep_tick_count);
Add_Hook((void *)GetTickCount, Real_GetTickCount, (void *)Fake_GetTickCount);
#else
struct timeval tv;
gettimeofday(&tv, nullptr);
lockstep_tick_count = tv.tv_sec * 1000 + tv.tv_usec / 1000;
LOCKSTEP_DEBUG("initial lockstep_tick_count is " << lockstep_tick_count);
Add_Hook((void *)gettimeofday, Real_gettimeofday, (void *)Fake_gettimeofday);
#endif
LOCKSTEP_DEBUG("hooked time");
Add_Hook((void *)SDL_GetTicks, Real_SDL_GetTicks, (void *)Fake_SDL_GetTicks);
LOCKSTEP_DEBUG("hooked ticks");
enabler->outstanding_gframes = 0;
enabler->outstanding_frames = 0;
lockstep_renderer = new df_ai_renderer(enabler->renderer);
enabler->renderer = lockstep_renderer;
CoreSuspendReleaseMain releaser;
SDL_SemWait(enabler->async_zoom.sem);
enabler->async_zoom.queue.push_back(zoom_commands::zoom_reset);
SDL_SemPost(enabler->async_zoom.sem);
SDL_SemPost(enabler->async_zoom.sem_fill);
while (lockstep_hooked && !lockstep_want_shutdown)
{
while (SDL_SemTryWait(enabler->async_tobox.sem_fill) == 0)
{
SDL_SemWait(enabler->async_tobox.sem);
auto msg = enabler->async_tobox.queue.front();
enabler->async_tobox.queue.pop_front();
switch (msg.cmd)
{
case df::enabler::T_async_tobox::T_queue::pause:
case df::enabler::T_async_tobox::T_queue::render:
{
df::enabler::T_async_frombox::T_queue complete;
complete.msg = df::enabler::T_async_frombox::T_queue::complete;
SDL_SemWait(enabler->async_frombox.sem);
enabler->async_frombox.queue.push_back(complete);
SDL_SemPost(enabler->async_frombox.sem);
SDL_SemPost(enabler->async_frombox.sem_fill);
break;
}
case df::enabler::T_async_tobox::T_queue::start:
case df::enabler::T_async_tobox::T_queue::inc:
case df::enabler::T_async_tobox::T_queue::set_fps:
break;
}
SDL_SemPost(enabler->async_tobox.sem);
}
tthread::this_thread::sleep_for(tthread::chrono::seconds(1));
}
}
}
static void lockstep_loop()
{
CoreSuspendClaimMain claimMain;
while (BOOST_LIKELY(!Hook_Want_Disable()))
{
LOCKSTEP_DEBUG("calling mainloop (A)");
if (BOOST_UNLIKELY(lockstep_mainloop()))
{
LOCKSTEP_DEBUG("want shutdown (A)");
Hook_Shutdown_Now();
break;
}
LOCKSTEP_DEBUG("calling DFHack (A)");
SDL_NumJoysticks();
if (BOOST_UNLIKELY(Hook_Want_Disable()))
{
LOCKSTEP_DEBUG("want disable (A)");
break;
}
lockstep_tick_count += 10;
if (BOOST_LIKELY(!enabler->flag.bits.maxfps && !ui->main.autosave_request))
{
LOCKSTEP_DEBUG("calling mainloop (B)");
if (BOOST_UNLIKELY(lockstep_mainloop()))
{
LOCKSTEP_DEBUG("want shutdown (B)");
Hook_Shutdown_Now();
break;
}
LOCKSTEP_DEBUG("calling DFHack (B)");
SDL_NumJoysticks();
if (BOOST_UNLIKELY(Hook_Want_Disable()))
{
LOCKSTEP_DEBUG("want disable (B)");
break;
}
}
else
{
LOCKSTEP_DEBUG((enabler->flag.bits.maxfps ? "maxfps" : "autosave_request"));
}
lockstep_tick_count += 10;
enabler->last_tick = lockstep_tick_count;
enabler->clock = lockstep_tick_count;
LOCKSTEP_DEBUG("draining events");
if (BOOST_UNLIKELY(lockstep_drain_sdl()))
{
LOCKSTEP_DEBUG("user requested quit");
break;
}
LOCKSTEP_DEBUG("swap_arrays");
lockstep_swap_arrays();
LOCKSTEP_DEBUG("render_things");
lockstep_render_things();
LOCKSTEP_DEBUG("update_all");
enabler->renderer->update_all();
LOCKSTEP_DEBUG("render");
enabler->renderer->render();
}
extern std::unique_ptr<AI> dwarfAI;
if (dwarfAI && dwarfAI->camera.movie_started_in_lockstep)
{
LOCKSTEP_DEBUG("stopping movie started in lockstep to avoid corruption");
// Stop the current CMV so it doesn't get corrupted on the next frame.
lockstep_handlemovie(true);
}
}
static void lockstep_handlemovie(bool flushall)
{
//SAVE A MOVIE FRAME INTO THE CURRENT MOVIE BUFFER
if (gview->supermovie_on == 1)
{
if (BOOST_UNLIKELY(gview->supermovie_delaystep > 0 && !flushall))
{
gview->supermovie_delaystep--;
}
else
{
if (BOOST_LIKELY(!flushall))
{
gview->supermovie_delaystep = gview->supermovie_delayrate;
}
if (!flushall || gview->supermovie_delaystep == 0)
{
extern std::unique_ptr<AI> dwarfAI;
//SAVING CHARACTERS, THEN COLORS
short x2, y2;
for (x2 = 0; x2 < init->display.grid_x; x2++)
{
for (y2 = 0; y2 < init->display.grid_y; y2++)
{
gview->supermoviebuffer[gview->supermovie_pos] = gps->screen[x2 * gps->dimy * 4 + y2 * 4 + 0];
gview->supermovie_pos++;
}
if (BOOST_LIKELY(dwarfAI && dwarfAI->camera.movie_started_in_lockstep))
{
for (y2 = 0; y2 < init->display.grid_y; y2++)
{
gview->supermoviebuffer[gview->supermovie_pos] = x2 < 80 && y2 < 25 ? dwarfAI->lockstep_log_buffer[y2][x2] : ' ';
gview->supermovie_pos++;
}
}
}
char frame_col;
for (x2 = 0; x2 < init->display.grid_x; x2++)
{
for (y2 = 0; y2 < init->display.grid_y; y2++)
{
frame_col = gps->screen[x2 * gps->dimy * 4 + y2 * 4 + 1];
frame_col |= (gps->screen[x2 * gps->dimy * 4 + y2 * 4 + 2] << 3);
if (gps->screen[x2 * gps->dimy * 4 + y2 * 4 + 3])
{
frame_col |= 64;
}
gview->supermoviebuffer[gview->supermovie_pos] = frame_col;
gview->supermovie_pos++;
}
if (BOOST_LIKELY(dwarfAI && dwarfAI->camera.movie_started_in_lockstep))
{
for (y2 = 0; y2 < init->display.grid_y; y2++)
{
gview->supermoviebuffer[gview->supermovie_pos] = 7;
gview->supermovie_pos++;
}
}
}
}
int frame_size = init->display.grid_x * init->display.grid_y * 2;
extern std::unique_ptr<AI> dwarfAI;
if (BOOST_LIKELY(dwarfAI->camera.movie_started_in_lockstep))
{
frame_size *= 2;
}
if (BOOST_UNLIKELY(gview->supermovie_pos + frame_size >= MOVIEBUFFSIZE || flushall || !dwarfAI || !dwarfAI->camera.movie_started_in_lockstep))
{
int length = lockstep_write_movie_chunk();
if (length > 5000000 || dwarfAI == nullptr || !dwarfAI->camera.movie_started_in_lockstep)
{
lockstep_finish_movie();
}
else
{
gview->supermovie_pos = 0;
}
}
}
}
}
static int32_t lockstep_write_movie_chunk()
{
int32_t inputsize = gview->supermovie_pos;
if (BOOST_UNLIKELY(inputsize > MOVIEBUFFSIZE))
{
inputsize = MOVIEBUFFSIZE;
}
//DUMP CURRENT BUFFER INTO A COMPRESSION STREAM
z_stream c_stream;
int err;
c_stream.zalloc = (alloc_func)0;
c_stream.zfree = (free_func)0;
c_stream.opaque = (voidpf)0;
err = deflateInit(&c_stream, Z_BEST_COMPRESSION);
if (CHECK_ERR(err, "deflateInit"))
{
return 5000001;
}
c_stream.next_out = (Bytef*)gview->supermoviebuffer_comp;
c_stream.avail_out = COMPMOVIEBUFFSIZE;
c_stream.next_in = (Bytef*)gview->supermoviebuffer;
c_stream.avail_in = inputsize;
while (int32_t(c_stream.total_in) != inputsize && c_stream.total_out < COMPMOVIEBUFFSIZE)
{
//c_stream.avail_in = c_stream.avail_out = 1; // force small buffers
err = deflate(&c_stream, Z_NO_FLUSH);
if (CHECK_ERR(err, "deflate"))
{
return 5000001;
}
}
// Finish the stream, still forcing small buffers:
for (;;)
{
err = deflate(&c_stream, Z_FINISH);
if (err == Z_STREAM_END)
{
break;
}
if (CHECK_ERR(err, "deflate"))
{
return 5000001;
}
}
err = deflateEnd(&c_stream);
if (CHECK_ERR(err, "deflateEnd"))
{
return 5000001;
}
int length = 0;
if (c_stream.total_out > 0)
{
if (BOOST_UNLIKELY(gview->first_movie_write))
{
//GET RID OF ANY EXISTING MOVIES IF THIS IS THE FIRST TIME THROUGH
unlink(gview->movie_file.c_str());
}
//OPEN UP THE MOVIE FILE AND APPEND
std::ofstream f(gview->movie_file, std::ios::out | std::ios::binary | std::ios::app);
if (BOOST_LIKELY(f.is_open()))
{
//WRITE A HEADER
if (BOOST_UNLIKELY(gview->first_movie_write))
{
const int32_t movie_version = 10000;
f.write((const char *)&movie_version, sizeof(int32_t));
int32_t header[3];
header[0] = init->display.grid_x;
header[1] = init->display.grid_y;
extern std::unique_ptr<AI> dwarfAI;
if (BOOST_LIKELY(dwarfAI->camera.movie_started_in_lockstep))
{
header[1] *= 2;
}
header[2] = gview->supermovie_delayrate;
f.write((const char *)&header, sizeof(header));
}
//WRITE IT
uint32_t compsize = c_stream.total_out;
f.write((const char *)&compsize, sizeof(uint32_t));
f.write((const char *)gview->supermoviebuffer_comp, c_stream.total_out);
f.seekp(0, std::ios::end);
length = f.tellp();
}
else
{
gview->supermovie_on = 0;
}
gview->first_movie_write = 0;
}
return length;
}
processed_transaction database::_apply_transaction(const signed_transaction& trx)
{ try {
uint32_t skip = get_node_properties().skip_flags;
if( true || !(skip&skip_validate) ) /* issue #505 explains why this skip_flag is disabled */
trx.validate();
auto& trx_idx = get_mutable_index_type<transaction_index>();
const chain_id_type& chain_id = get_chain_id();
auto trx_id = trx.id();
FC_ASSERT( (skip & skip_transaction_dupe_check) ||
trx_idx.indices().get<by_trx_id>().find(trx_id) == trx_idx.indices().get<by_trx_id>().end() );
transaction_evaluation_state eval_state(this);
const chain_parameters& chain_parameters = get_global_properties().parameters;
eval_state._trx = &trx;
if( !(skip & (skip_transaction_signatures | skip_authority_check) ) )
{
auto get_active = [&]( account_id_type id ) { return &id(*this).active; };
auto get_owner = [&]( account_id_type id ) { return &id(*this).owner; };
trx.verify_authority( chain_id, get_active, get_owner, get_global_properties().parameters.max_authority_depth );
}
//Skip all manner of expiration and TaPoS checking if we're on block 1; It's impossible that the transaction is
//expired, and TaPoS makes no sense as no blocks exist.
if( BOOST_LIKELY(head_block_num() > 0) )
{
if( !(skip & skip_tapos_check) )
{
const auto& tapos_block_summary = block_summary_id_type( trx.ref_block_num )(*this);
//Verify TaPoS block summary has correct ID prefix, and that this block's time is not past the expiration
FC_ASSERT( trx.ref_block_prefix == tapos_block_summary.block_id._hash[1] );
}
fc::time_point_sec now = head_block_time();
FC_ASSERT( trx.expiration <= now + chain_parameters.maximum_time_until_expiration, "",
("trx.expiration",trx.expiration)("now",now)("max_til_exp",chain_parameters.maximum_time_until_expiration));
FC_ASSERT( now <= trx.expiration, "", ("now",now)("trx.exp",trx.expiration) );
}
//Insert transaction into unique transactions database.
if( !(skip & skip_transaction_dupe_check) )
{
create<transaction_object>([&](transaction_object& transaction) {
transaction.trx_id = trx_id;
transaction.trx = trx;
});
}
eval_state.operation_results.reserve(trx.operations.size());
//Finally process the operations
processed_transaction ptrx(trx);
_current_op_in_trx = 0;
for( const auto& op : ptrx.operations )
{
eval_state.operation_results.emplace_back(apply_operation(eval_state, op));
++_current_op_in_trx;
}
ptrx.operation_results = std::move(eval_state.operation_results);
//Make sure the temp account has no non-zero balances
const auto& index = get_index_type<account_balance_index>().indices().get<by_account_asset>();
auto range = index.equal_range( boost::make_tuple( GRAPHENE_TEMP_ACCOUNT ) );
std::for_each(range.first, range.second, [](const account_balance_object& b) { FC_ASSERT(b.balance == 0); });
return ptrx;
} FC_CAPTURE_AND_RETHROW( (trx) ) }
