void mono_invoke_unhandled_exception_hook (MonoObject *exc) { if (unhandled_exception_hook) { unhandled_exception_hook (exc, unhandled_exception_hook_data); } else { ERROR_DECL (inner_error); MonoObject *other = NULL; MonoString *str = mono_object_try_to_string (exc, &other, inner_error); char *msg = NULL; if (str && is_ok (inner_error)) { msg = mono_string_to_utf8_checked_internal (str, inner_error); if (!is_ok (inner_error)) { msg = g_strdup_printf ("Nested exception while formatting original exception"); mono_error_cleanup (inner_error); } } else if (other) { char *original_backtrace = mono_exception_get_managed_backtrace ((MonoException*)exc); char *nested_backtrace = mono_exception_get_managed_backtrace ((MonoException*)other); msg = g_strdup_printf ("Nested exception detected.\nOriginal Exception: %s\nNested exception:%s\n", original_backtrace, nested_backtrace); g_free (original_backtrace); g_free (nested_backtrace); } else { msg = g_strdup ("Nested exception trying to figure out what went wrong"); } mono_runtime_printf_err ("[ERROR] FATAL UNHANDLED EXCEPTION: %s", msg); g_free (msg); #if defined(HOST_IOS) g_assertion_message ("Terminating runtime due to unhandled exception"); #else exit (mono_environment_exitcode_get ()); #endif } g_assert_not_reached (); }
/* http://www.dotnet247.com/247reference/msgs/39/195403.aspx // internal static string[] WindowsIdentity._GetRoles (IntPtr token) */ MonoArray* ves_icall_System_Security_Principal_WindowsIdentity_GetRoles (gpointer token) { MonoError error; MonoArray *array = NULL; MonoDomain *domain = mono_domain_get (); #ifdef HOST_WIN32 gint32 size = 0; GetTokenInformation (token, TokenGroups, NULL, size, (PDWORD)&size); if (size > 0) { TOKEN_GROUPS *tg = g_malloc0 (size); if (GetTokenInformation (token, TokenGroups, tg, size, (PDWORD)&size)) { int i=0; int num = tg->GroupCount; array = mono_array_new_checked (domain, mono_get_string_class (), num, &error); if (mono_error_set_pending_exception (&error)) { g_free (tg); return NULL; } for (i=0; i < num; i++) { gint32 size = 0; gunichar2 *uniname = GetSidName (NULL, tg->Groups [i].Sid, &size); if (uniname) { MonoString *str = mono_string_new_utf16_checked (domain, uniname, size, &error); if (!is_ok (&error)) { g_free (uniname); g_free (tg); mono_error_set_pending_exception (&error); return NULL; } mono_array_setref (array, i, str); g_free (uniname); } } } g_free (tg); } #else /* POSIX-compliant systems should use IsMemberOfGroupId or IsMemberOfGroupName */ g_warning ("WindowsIdentity._GetRoles should never be called on POSIX"); #endif if (!array) { /* return empty array of string, i.e. string [0] */ array = mono_array_new_checked (domain, mono_get_string_class (), 0, &error); mono_error_set_pending_exception (&error); } return array; }
void move_result::do_execute() { LOG_AI_ACTIONS << "start of execution of: "<< *this << std::endl; assert(is_success()); move_spectator_.set_unit(resources::units->find(from_)); if (from_ != to_) { size_t num_steps = ::actions::move_unit_and_record( /*std::vector<map_location> steps*/ route_->steps, /*::actions::undo_list* undo_stack*/ NULL, /*bool continue_move*/ true, ///@todo 1.9 set to false after implemeting interrupt awareness /*bool show_move*/ preferences::show_ai_moves(), /*bool* interrupted*/ NULL, /*::actions::move_unit_spectator* move_spectator*/ &move_spectator_); if ( num_steps > 0 ) { set_gamestate_changed(); } else if ( move_spectator_.get_ambusher().valid() ) { // Unlikely, but some types of strange WML (or bad pathfinding) // could cause an ambusher to be found without moving. set_gamestate_changed(); } } else { assert(remove_movement_); } if (move_spectator_.get_unit().valid()){ unit_location_ = move_spectator_.get_unit()->get_location(); if (remove_movement_ && move_spectator_.get_unit()->movement_left() > 0 && unit_location_ == to_) { stopunit_result_ptr stopunit_res = actions::execute_stopunit_action(get_side(),true,unit_location_,true,false); if (!stopunit_res->is_ok()) { set_error(stopunit_res->get_status()); } if (stopunit_res->is_gamestate_changed()) { set_gamestate_changed(); } } } else { unit_location_ = map_location(); } if (is_gamestate_changed()) { try { manager::raise_gamestate_changed(); } catch (...) { is_ok(); //Silences "unchecked result" warning throw; } } }
int binary(int l,int r){ int tmin=-1; while(l<=r){ int mid=(l+r)>>1; // printf("%d~~",mid); if(is_ok(mid)){ tmin=mid; r=mid-1; } else l=mid+1; } return tmin; }
/** * mono_get_exception_type_initialization: * \param type_name the name of the type that failed to initialize. * \param inner the inner exception. * \returns a new instance of the \c System.TypeInitializationException */ MonoException * mono_get_exception_type_initialization (const gchar *type_name, MonoException* inner_raw) { HANDLE_FUNCTION_ENTER (); MONO_HANDLE_DCL (MonoException, inner); ERROR_DECL (error); MonoExceptionHandle ret = mono_get_exception_type_initialization_handle (type_name, inner, error); if (!is_ok (error)) { ret = MONO_HANDLE_CAST (MonoException, mono_new_null ()); mono_error_cleanup (error); } HANDLE_FUNCTION_RETURN_OBJ (ret); }
/** * mono_get_exception_runtime_wrapped: */ MonoException * mono_get_exception_runtime_wrapped (MonoObject *wrapped_exception_raw) { HANDLE_FUNCTION_ENTER (); ERROR_DECL (error); MONO_HANDLE_DCL (MonoObject, wrapped_exception); MonoExceptionHandle ret = mono_get_exception_runtime_wrapped_handle (wrapped_exception, error); if (!is_ok (error)) { mono_error_cleanup (error); ret = MONO_HANDLE_CAST (MonoException, mono_new_null ()); } HANDLE_FUNCTION_RETURN_OBJ (ret); }
/** * mono_get_exception_reflection_type_load: * \param types an array of types that were defined in the moduled loaded. * \param exceptions an array of exceptions that were thrown during the type loading. * \returns a new instance of the \c System.Reflection.ReflectionTypeLoadException */ MonoException * mono_get_exception_reflection_type_load (MonoArray *types_raw, MonoArray *exceptions_raw) { HANDLE_FUNCTION_ENTER (); ERROR_DECL (error); MONO_HANDLE_DCL (MonoArray, types); MONO_HANDLE_DCL (MonoArray, exceptions); MonoExceptionHandle ret = mono_get_exception_reflection_type_load_checked (types, exceptions, error); if (!is_ok (error)) ret = MONO_HANDLE_CAST (MonoException, mono_new_null ()); mono_error_cleanup (error); HANDLE_FUNCTION_RETURN_OBJ (ret); }
void shopping_list(char *arg, struct char_data *ch, struct char_data * keeper, int shop_nr) { char buf[MAX_STRING_LENGTH], name[MAX_INPUT_LENGTH]; struct obj_data *obj, *last_obj = 0; int cnt = 0, index = 0; bool found = FALSE; if (!(is_ok(keeper, ch, shop_nr))) return; if (SHOP_SORT(shop_nr) < IS_CARRYING_N(keeper)) sort_keeper_objs(keeper, shop_nr); one_argument(arg, name); strcpy(buf, " ## Available Item Cost\n\r"); strcat(buf, "-------------------------------------------------------------------------\n\r"); if (keeper->carrying) for (obj = keeper->carrying; obj; obj = obj->next_content) if (CAN_SEE_OBJ(ch, obj) && (obj->obj_flags.cost > 0)) { if (!last_obj) { last_obj = obj; cnt = 1; } else if (same_obj(last_obj, obj)) cnt++; else { index++; if (!(*name) || isname(name, last_obj->name)) { strcat(buf, list_object(ch, last_obj, cnt, index, shop_nr)); found = TRUE; } cnt = 1; last_obj = obj; } } index++; if (!last_obj) stc("Currently, there is nothing for sale.\r\n", ch); else if (*name && !found) stc("Presently, none of those are for sale.\r\n", ch); else { if (!(*name) || isname(name, last_obj->name)) strcat(buf, list_object(ch, last_obj, cnt, index, shop_nr)); page_string(ch->desc, buf, 1); } }
int process(char **args) { int return_val = 0; if (args[0] == NULL) { return_val = 0; } else if (is_control(args[0])) { return_val = do_control(args); } else if (is_ok()) { if (!internal(args, &return_val)) { return_val = execute(args); } } return return_val; }
bool dfs (vector <vector<char> >& maze, int r, int c){ if (c == 9) return dfs (maze, r+1, 0); if (r == 9) return true; if (maze[r][c] != '.') return dfs (maze, r,c +1); for (int i=1;i<=9;i++){ if (is_ok (r,c,i)){ maze[r][c] = i + '0'; if (dfs (maze, r,c+1)) return true; er[r][i-1] = ec[c][i-1] = eb[r/3][c/3][i-1] = false; } } maze[r][c] = '.'; return false; }
virtual bool wait_ready() { bool rtn = is_ok(); if ( rtn ) { if ( !ready ) { _error_code = pthread_mutex_lock( &ready_mutex ); ready = true; rtn = ready; _error_code = pthread_mutex_unlock( &ready_mutex ); } } return rtn; }
// For efficiency, call mono_error_set_pending_exception instead of mono_error_set_pending_exception_slow. gboolean mono_error_set_pending_exception_slow (MonoError *error) { if (is_ok (error)) return FALSE; HANDLE_FUNCTION_ENTER (); MonoExceptionHandle ex = mono_error_convert_to_exception_handle (error); gboolean const result = !MONO_HANDLE_IS_NULL (ex); if (result) mono_set_pending_exception_handle (ex); HANDLE_FUNCTION_RETURN_VAL (result); }
err generic_bus< PBus >::init() { if (m_state & bus_inited) { return err::ok; } m_bus.set_handler(platform_handler); auto rc = m_bus.init(); if (is_ok(rc)) { m_state |= bus_inited; } return rc; }
int up_1(int mm[][X], int x, int y, int k, const char *board) { int i, j; int n = 0; int _mm[Y][X]; for (i = 0; i < Y; i++) { for (j = 0; j < X; j++) { _mm[i][j] = mm[i][j]; } } for (x = (x-1); is_ok(x, y, board) && _mm[x][y] != 1; --x) { _mm[x][y] = 1; ++k; } x++; if (k == sum) { strcat(path, "U"); return 1; } if ((y-1) >= 0 && board[x][y-1] != 'X' && _mm[x][y-1] != 1) { n = (left(_mm, x, y, k)); if (n == 1) { strcat(path, "U"); return 1; } } if ((y+1) < X && board[x][y+1] != 'X' && _mm[x][y+1] != 1) { n = (right(_mm, x, y, k)); if (n == 1) { strcat(path, "U"); return 1; } } return 0; }
/* This is an icall */ void * mono_mmap_open_file (MonoString *path, int mode, MonoString *mapName, gint64 *capacity, int access, int options, int *ioerror) { MonoError error; MmapHandle *handle = NULL; g_assert (path || mapName); if (!mapName) { char * c_path = mono_string_to_utf8_checked (path, &error); if (mono_error_set_pending_exception (&error)) return NULL; handle = open_file_map (c_path, -1, mode, capacity, access, options, ioerror); g_free (c_path); return handle; } char *c_mapName = mono_string_to_utf8_checked (mapName, &error); if (mono_error_set_pending_exception (&error)) return NULL; if (path) { named_regions_lock (); handle = (MmapHandle*)g_hash_table_lookup (named_regions, c_mapName); if (handle) { *ioerror = FILE_ALREADY_EXISTS; handle = NULL; } else { char *c_path = mono_string_to_utf8_checked (path, &error); if (is_ok (&error)) { handle = (MmapHandle *)open_file_map (c_path, -1, mode, capacity, access, options, ioerror); if (handle) { handle->name = g_strdup (c_mapName); g_hash_table_insert (named_regions, handle->name, handle); } } else { handle = NULL; } g_free (c_path); } named_regions_unlock (); } else handle = open_memory_map (c_mapName, mode, capacity, access, options, ioerror); g_free (c_mapName); return handle; }
void action_result::execute() { is_execution_ = true; init_for_execution(); check_before(); if (is_success()){ try { do_execute(); } catch (return_to_play_side_exception&) { if (!is_ok()) { DBG_AI_ACTIONS << "Return value of AI ACTION was not checked." << std::endl; } //Demotes to DBG "unchecked result" warning throw; } } if (is_success()){ check_after(); } is_execution_ = false; }
void cps_db::response::dump() { std::cout << "Resp type is : " << static_cast<redisReply*>(_reply)->type << std::endl; if(is_int()) { std::cout << "Int : " << get_int() << std::endl; } if (is_ok()) std::cout << "OK Resp..." << std::endl; if (is_str()) { std::cout << get_str() << std::endl; } if (has_elements()) { for (size_t ix =0,mx=this->elements(); ix < mx ; ++ix ) { redisReply * data = (redisReply *)this->element_at(ix); std::cout << "IX:" << ix << " Type:" << data->type << " " << cps_string::tostring(data->str,data->len) << std::endl; } } }
int main() { int i; init(); if(is_ok(st) == 0) { printf("unsolvable\n"); return 0; } found = 0; while(found == 0) { top = 0; ida_star(st, 0, max_deep); max_deep++; } return 0; }
void shopping_list( char *arg, struct char_data *ch, struct char_data *keeper, int shop_nr) { char buf[MAX_STRING_LENGTH], buf2[100],buf3[100]; struct obj_data *temp1; extern char *drinks[]; int found_obj; if(!(is_ok(keeper,ch,shop_nr))) return; strcpy(buf,"You can buy:\n\r"); found_obj = FALSE; if(keeper->carrying) for(temp1=keeper->carrying; temp1; temp1 = temp1->next_content) if((CAN_SEE_OBJ(ch,temp1)) && (temp1->obj_flags.cost>0)) { found_obj = TRUE; if(temp1->obj_flags.type_flag != ITEM_DRINKCON) sprintf(buf2,"%s for %d gold coins.\n\r" ,(temp1->short_description) ,(int)(temp1->obj_flags.cost* shop_index[shop_nr].profit_buy)); else { if (temp1->obj_flags.value[1]) sprintf(buf3,"%s of %s",(temp1->short_description) ,drinks[temp1->obj_flags.value[2]]); else sprintf(buf3,"%s",(temp1->short_description)); sprintf(buf2,"%s for %d gold coins.\n\r",buf3, (int)(temp1->obj_flags.cost*shop_index[shop_nr].profit_buy)); } strcat(buf,CAP(buf2)); }; if(!found_obj) strcat(buf,"Nothing!\n\r"); send_to_char(buf,ch); return; }
void shopping_value( char *arg, struct char_data *ch, struct char_data *keeper, int shop_nr) { char argm[100], buf[MAX_STRING_LENGTH]; struct obj_data *temp1; if(!(is_ok(keeper,ch,shop_nr))) return; one_argument(arg, argm); if(!(*argm)) { sprintf(buf,"%s What do you want me to valuate??", GET_NAME(ch)); do_tell(keeper,buf,19); return; } if(!( temp1 = get_obj_in_list_vis(ch,argm,ch->carrying))) { sprintf(buf,shop_index[shop_nr].no_such_item2, GET_NAME(ch)); do_tell(keeper,buf,19); return; } if(!(trade_with(temp1,shop_nr))) { sprintf(buf, shop_index[shop_nr].do_not_buy, GET_NAME(ch)); do_tell(keeper,buf,19); return; } sprintf(buf,"%s I'll give you %d gold coins for that!", GET_NAME(ch),(int) (temp1->obj_flags.cost* shop_index[shop_nr].profit_sell)); do_tell(keeper,buf,19); return; }
void attack_result::do_execute() { LOG_AI_ACTIONS << "start of execution of: "<< *this << std::endl; // Stop the user from issuing any commands while the unit is attacking const events::command_disabler disable_commands; //@note: yes, this is a decision done here. It's that way because we want to allow a simpler attack 'with whatever weapon is considered best', and because we want to allow the defender to pick it's weapon. That's why aggression is needed. a cleaner solution is needed. battle_context bc(*resources::units, attacker_loc_, defender_loc_, attacker_weapon_, -1, aggression_); int attacker_weapon = bc.get_attacker_stats().attack_num; int defender_weapon = bc.get_defender_stats().attack_num; if(attacker_weapon < 0) { set_error(E_UNABLE_TO_CHOOSE_ATTACKER_WEAPON); return; } const unit_map::const_iterator a_ = resources::units->find(attacker_loc_); const unit_map::const_iterator d_ = resources::units->find(defender_loc_); //to get rid of an unused member varuiable warning, FIXME: find a way to 'ask' the ai wich advancement should be chosen from synced_commands.cpp . if(true) //RAII block for set_scontext_synced { //we don't use synced_context::run_in_synced_context because that wouldn't allow us to pass advancements_ recorder.add_synced_command("attack", replay_helper::get_attack(attacker_loc_, defender_loc_, attacker_weapon, defender_weapon, a_->type_id(), d_->type_id(), a_->level(), d_->level(), resources::tod_manager->turn(), resources::tod_manager->get_time_of_day())); set_scontext_synced sync; attack_unit_and_advance(attacker_loc_, defender_loc_, attacker_weapon, defender_weapon, true, advancements_); } set_gamestate_changed(); //start of ugly hack. @todo 1.9 rework that via extended event system //until event system is reworked, we note the attack this way get_info().recent_attacks.insert(defender_loc_); //end of ugly hack try { manager::raise_gamestate_changed(); } catch (...) { is_ok(); //Silences "unchecked result" warning throw; } }
void action_result::execute() { is_execution_ = true; init_for_execution(); check_before(); if (is_success()){ do_execute(); try { resources::controller->check_victory(); } catch (...) { is_ok(); //Silences "unchecked result" warning throw; } } if (is_success()){ check_after(); } is_execution_ = false; }
void recall_result::do_execute() { LOG_AI_ACTIONS << "start of execution of: " << *this << std::endl; assert(is_success()); game_info& info = get_info(); team& my_team = get_my_team(info); const events::command_disabler disable_commands; std::vector<unit>::iterator rec = std::find_if(my_team.recall_list().begin(), my_team.recall_list().end(), boost::bind(&unit::matches_id, _1, unit_id_)); assert(rec != my_team.recall_list().end()); const std::string &err = find_recruit_location(get_side(), recall_location_); if(!err.empty()) { set_error(AI_ACTION_FAILURE); return; } else { unit &un = *rec; recorder.add_recall(un.id(), recall_location_); un.set_game_context(&info.units); place_recruit(un, recall_location_, true, true); statistics::recall_unit(un); my_team.spend_gold(game_config::recall_cost); my_team.recall_list().erase(rec); if (resources::screen!=NULL) { resources::screen->invalidate_game_status(); resources::screen->invalidate_all(); } recorder.add_checksum_check(recall_location_); set_gamestate_changed(); try { manager::raise_gamestate_changed(); } catch (...) { is_ok(); //Silences "unchecked result" warning throw; } } }
Error my_stack_dtor(Stack_t* stack) { Error *err_temp = NULL; err_temp = my_error_ctor(err_temp); if (is_ok(stack) == 1) { err_temp->code = STACK_NOT_WORK; err_temp->message = "STACK NOT WORK\n"; return *err_temp; } else { free(stack->data); stack->data = NULL; stack->len = 0; stack->pos = 0; my_error_dtor(err_temp); return *err_temp; } }
void stopunit_result::do_execute() { LOG_AI_ACTIONS << "start of execution of: " << *this << std::endl; assert(is_success()); unit_map::iterator un = resources::units->find(unit_location_); try { if (remove_movement_){ un->remove_movement_ai(); set_gamestate_changed(); manager::raise_gamestate_changed(); } if (remove_attacks_){ un->remove_attacks_ai(); set_gamestate_changed(); manager::raise_gamestate_changed();//to be on the safe side } } catch (...) { is_ok(); //Silences "unchecked result" warning throw; } }
void synced_command_result::do_execute() { LOG_AI_ACTIONS << "start of execution of: " << *this << std::endl; assert(is_success()); std::stringstream s; if (location_ != map_location::null_location){ s << "local x1 = " << location_.x << " local y1 = " << location_.y << " "; } s << lua_code_; synced_context::run_in_synced_context("lua_ai", replay_helper::get_lua_ai(s.str())); try { set_gamestate_changed(); manager::raise_gamestate_changed(); } catch (...) { is_ok(); //Silences "unchecked result" warning throw; } }
static void do_console_cancel_event (void) { static MonoClassField *cancel_handler_field; MonoError error; MonoDomain *domain = mono_domain_get (); MonoClass *klass; MonoDelegate *load_value; MonoMethod *method; MonoVTable *vtable; /* FIXME: this should likely iterate all the domains, instead */ if (!domain->domain) return; klass = mono_class_try_load_from_name (mono_defaults.corlib, "System", "Console"); if (klass == NULL) return; if (cancel_handler_field == NULL) { cancel_handler_field = mono_class_get_field_from_name (klass, "cancel_handler"); g_assert (cancel_handler_field); } vtable = mono_class_vtable_full (domain, klass, &error); if (vtable == NULL || !is_ok (&error)) { mono_error_cleanup (&error); return; } mono_field_static_get_value (vtable, cancel_handler_field, &load_value); if (load_value == NULL) return; klass = load_value->object.vtable->klass; method = mono_class_get_method_from_name (klass, "BeginInvoke", -1); g_assert (method != NULL); mono_threadpool_ms_begin_invoke (domain, (MonoObject*) load_value, method, NULL); }
void *receive_messages(void *threadarg) { /** * Void que roda em paralelo para receber mensagens do servidor */ int sockfd; int ok; struct addrinfo *p; struct thread_data_params *data; Message recmsg; // extrai os parametros da estrutura da thread data = (struct thread_data_params *) threadarg; p = data->p; sockfd = data->sockfd; while (1) { recmsg = receive(sockfd, "Error ocurred while trying to receive messages!", 0); ok = is_ok(recmsg); ISOK = ok; // seta a variavel para 1 ou 0 dependendo se a mensagem recebida foi OK } pthread_exit(NULL); }
static MonoExceptionHandle create_exception_two_strings (MonoClass *klass, MonoStringHandle a1, MonoStringHandle a2, MonoError *error) { HANDLE_FUNCTION_ENTER (); MonoMethod *method = NULL; int const count = 1 + !MONO_HANDLE_IS_NULL (a2); gpointer iter; MonoMethod *m; MonoObjectHandle o = mono_object_new_handle (mono_domain_get (), klass, error); mono_error_assert_ok (error); iter = NULL; while ((m = mono_class_get_methods (klass, &iter))) { MonoMethodSignature *sig; if (strcmp (".ctor", mono_method_get_name (m))) continue; sig = mono_method_signature_internal (m); if (sig->param_count != count) continue; if (sig->params [0]->type != MONO_TYPE_STRING) continue; if (count == 2 && sig->params [1]->type != MONO_TYPE_STRING) continue; method = m; break; } gpointer args [ ] = { MONO_HANDLE_RAW (a1), MONO_HANDLE_RAW (a2) }; mono_runtime_invoke_handle (method, o, args, error); if (!is_ok (error)) o = mono_new_null (); HANDLE_FUNCTION_RETURN_REF (MonoException, MONO_HANDLE_CAST (MonoException, o)); }
static int back_track(t_tetab tetrimini, t_i const length, t_i const side, t_i const i) { t_tet *const current = tetrimini[i]; if (i == length) return (1); current->pos.coord.y = 0; while (current->pos.coord.y <= side - current->dim.height) { current->pos.coord.x = 0; while (current->pos.coord.x <= side - current->dim.width) { if (is_ok(tetrimini, i) && back_track(tetrimini, length, side, i + 1)) return (1); current->pos.coord.x += 1; } current->pos.coord.y += 1; } return (0); }