BOOL ShellNotifyIconEx(DWORD action, HWND wnd, UINT id, UINT callbackmsg, HICON icon, const char * tip, const char * balloon_title, const char * balloon_msg) { NOTIFYICONDATA nid; memset(&nid, 0, sizeof(nid)); nid.cbSize = NOTIFYICONDATA_V2_SIZE; nid.hWnd = wnd; nid.uID = id; if (callbackmsg) { nid.uFlags |= NIF_MESSAGE; nid.uCallbackMessage = callbackmsg; } if (icon) { nid.uFlags |= NIF_ICON; nid.hIcon = icon; } if (tip) { nid.uFlags |= NIF_TIP; _tcsncpy_s(nid.szTip, pfc::stringcvt::string_os_from_utf8(tip), tabsize(nid.szTip) - 1); } nid.dwInfoFlags = NIIF_INFO | NIIF_NOSOUND; //if (balloon_title || balloon_msg) { nid.uFlags |= NIF_INFO; if (balloon_title) _tcsncpy_s(nid.szInfoTitle, pfc::stringcvt::string_os_from_utf8(balloon_title), tabsize(nid.szInfoTitle) - 1); if (balloon_msg) _tcsncpy_s(nid.szInfo, pfc::stringcvt::string_os_from_utf8(balloon_msg), tabsize(nid.szInfo) - 1); } return run_action(action, reinterpret_cast<NOTIFYICONDATA*>(&nid)); }
BOOL ShellNotifyIcon(DWORD action, HWND wnd, UINT id, UINT version, UINT callbackmsg, HICON icon, const char * tip) { NOTIFYICONDATA nid; memset(&nid, 0, sizeof(nid)); nid.cbSize = NOTIFYICONDATA_V2_SIZE; nid.hWnd = wnd; nid.uID = id; nid.uFlags = 0; if (action & NIM_SETVERSION) nid.uVersion = version; if (callbackmsg) { nid.uFlags |= NIF_MESSAGE; nid.uCallbackMessage = callbackmsg; } if (icon) { nid.uFlags |= NIF_ICON; nid.hIcon = icon; } if (tip) { nid.uFlags |= NIF_TIP; _tcsncpy_s(nid.szTip, pfc::stringcvt::string_os_from_utf8(tip), tabsize(nid.szTip) - 1); } return run_action(action, &nid); }
void machine::route(const node* from, sched::base *sched_caller, const node::node_id id, simple_tuple* stpl, const uint_val delay) { assert(sched_caller != NULL); if (api::onLocalVM(id)){ /* Belongs to the same process, does not require MPI */ node *node(vm::All->DATABASE->find_node(id)); sched::base *sched_other(sched_caller->find_scheduler(node)); const predicate *pred(stpl->get_predicate()); if(delay > 0) { work new_work(node, stpl); sched_caller->new_work_delay(sched_caller, from, new_work, delay); } else if(pred->is_action_pred()) { run_action(sched_other, node, stpl->get_tuple(), sched_caller != sched_other); delete stpl; } else if(sched_other == sched_caller) { work new_work(node, stpl); sched_caller->new_work(from, new_work); } else { work new_work(node, stpl); sched_caller->new_work_other(sched_other, new_work); } } else { /* Send to the correct process */ api::sendMessage(from,id,stpl); } }
void do_default_action(fcode_env_t *env) { acf_t a; CHECK_DEPTH(env, 1, "do_default_action"); a = (acf_t)TOS; (void) run_action(env, (a-1), 0); }
void do_set_action(fcode_env_t *env) { acf_t a = (acf_t)TOS; CHECK_DEPTH(env, 1, "do_set_action"); TOS += sizeof (acf_t); (void) run_action(env, a, 1); }
/* Parses wsmouse events. Only button events are picked. */ void action_wsmouse_event(struct wscons_event evt) { if (IS_BUTTON_EVENT(evt.type)) { switch (evt.type) { case WSCONS_EVENT_MOUSE_UP: run_action(evt.value, "up"); break; case WSCONS_EVENT_MOUSE_DOWN: run_action(evt.value, "down"); break; default: log_warnx("unknown button event"); } } }
void try_to_populate(Event *node){ //if the branch is done calculating if(end_calc_branch(node->time, node->total_damage)){ //node->final_breakdown = node->breakdown; return; } //if the children have already been populated if(node->children_populated){ return; } printf("running action...\n"); //run the appropriate action/event-method on the node run_action(node); }
void perform_action(fcode_env_t *env) { int n; acf_t a; CHECK_DEPTH(env, 2, "perform_action"); n = POP(DS); a = (acf_t)POP(DS); PUSH(DS, (fstack_t)ACF_TO_BODY(a)); if (run_action(env, a, n)) { system_message(env, "Bad Object action"); } }
/* scan all robots and run them if necessary - this is a parse.c bit that gets called in timer_function */ void process_robots(void) { robot *rscan; player *rc; if (sys_flags & PANIC) return; for (rscan = robot_start; rscan; rscan = rscan->next) { /* SPANG - MOVE THIS SOMEWHERE ELSE AND DO IT JUST ONCE? */ /* check to make sure robot hasnt fallen off :-) */ if (rscan->counter == 0 && !(rscan->flags & STORED)) { rc = find_player_absolute_quiet(rscan->lower_name); /* check for nightmare crashes/etc ;) */ if (!rc) { rc = create_player(); rc->fd = -1; connect_robot_to_prog(rc, rscan->lower_name); rscan->actual_player = rc; } else if (!(rc->flags & PANIC)) { /* be cheeky here, safetly thing really. set actual_player to rc! this is actually because i --KNOW-- someone will try logging in as a robot and that could conceivably blow it away. */ rscan->actual_player = rc; rscan->counter = rscan->speed; current_player = rscan->actual_player; current_room = rscan->actual_player->location; run_action(rscan); current_player = 0; current_room = 0; } } } }
/*----------------------------------------------------------------------------*/ int match_entry(packet_t* p, entry_t* e){ window_t *w; action_t *a; int target = list_length(e->windows); int actual = 0; if (target == 0) {return 0;} for(w = list_head(e->windows); w != NULL; w = w->next) { actual = actual + match_window(p, status_register, w); } if (actual == target){ PRINTF("[FLT]: Match Found!\n"); for(a = list_head(e->actions); a != NULL; a = a->next) { run_action(p, status_register, a); } e->stats.count++; return 1; } else { return 0; } }
int main(int argc, const char **argv) { static const char *null_action_argv[] = {NULL}; static struct poptOption popt_help_options[] = { { NULL, '\0', POPT_ARG_CALLBACK, help, 0, NULL, NULL }, { "help", '?', POPT_ARG_NONE, NULL, 0, N_("Show this help message"), NULL }, { "usage", '\0', POPT_ARG_NONE, NULL, 0, N_("Display brief usage"), NULL }, POPT_TABLEEND }; static struct poptOption popt_options[] = { { NULL, '\0', POPT_ARG_INCLUDE_TABLE, popt_help_options, 0, N_("Help options:"), NULL }, { "version", '\0', POPT_ARG_NONE, &opt_version_mode, 0, N_("Print package version"), NULL }, { "verbose", 'v', POPT_ARG_NONE, &opt_verbose, 0, N_("Shows more detailed error messages"), NULL }, { "debug", '\0', POPT_ARG_NONE, &opt_debug, 0, N_("Show debug messages"), NULL }, { "batch-mode", 'q', POPT_ARG_NONE, &opt_batch_mode, 0, N_("Do not ask for confirmation"), NULL }, { "progress-frequency", '\0', POPT_ARG_INT, &opt_progress_frequency, 0, N_("Progress line update (in seconds)"), N_("secs") }, { "no-wipe", '\0', POPT_ARG_NONE, &opt_no_wipe, 0, N_("Do not wipe device after format"), NULL }, { "data-device", '\0', POPT_ARG_STRING, &opt_data_device, 0, N_("Path to data device (if separated)"), N_("path") }, { "journal-size", 'j', POPT_ARG_STRING,&opt_journal_size_str, 0, N_("Journal size"), N_("bytes") }, { "interleave-sectors", '\0', POPT_ARG_INT, &opt_interleave_sectors, 0, N_("Interleave sectors"), N_("SECTORS") }, { "journal-watermark", '\0', POPT_ARG_INT, &opt_journal_watermark, 0, N_("Journal watermark"),N_("percent") }, { "journal-commit-time",'\0', POPT_ARG_INT, &opt_journal_commit_time,0, N_("Journal commit time"), N_("ms") }, { "bitmap-sectors-per-bit",'\0', POPT_ARG_INT,&opt_bitmap_sectors_per_bit, 0, N_("Number of 512-byte sectors per bit (bitmap mode)."), NULL }, { "bitmap-flush-time", '\0', POPT_ARG_INT, &opt_bitmap_flush_time, 0, N_("Bitmap mode flush time"), N_("ms") }, { "tag-size", 't', POPT_ARG_INT, &opt_tag_size, 0, N_("Tag size (per-sector)"), N_("bytes") }, { "sector-size", 's', POPT_ARG_INT, &opt_sector_size, 0, N_("Sector size"), N_("bytes") }, { "buffer-sectors", '\0', POPT_ARG_INT, &opt_buffer_sectors, 0, N_("Buffers size"), N_("SECTORS") }, { "integrity", 'I', POPT_ARG_STRING, &opt_integrity, 0, N_("Data integrity algorithm"), NULL }, { "integrity-key-size", '\0', POPT_ARG_INT, &opt_integrity_key_size, 0, N_("The size of the data integrity key"), N_("BITS") }, { "integrity-key-file", '\0', POPT_ARG_STRING, &opt_integrity_key_file, 0, N_("Read the integrity key from a file"), NULL }, { "journal-integrity", '\0', POPT_ARG_STRING, &opt_journal_integrity, 0, N_("Journal integrity algorithm"), NULL }, { "journal-integrity-key-size",'\0', POPT_ARG_INT, &opt_journal_integrity_key_size,0, N_("The size of the journal integrity key"), N_("BITS") }, { "journal-integrity-key-file",'\0', POPT_ARG_STRING, &opt_journal_integrity_key_file,0, N_("Read the journal integrity key from a file"), NULL }, { "journal-crypt", '\0', POPT_ARG_STRING, &opt_journal_crypt, 0, N_("Journal encryption algorithm"), NULL }, { "journal-crypt-key-size", '\0', POPT_ARG_INT, &opt_journal_crypt_key_size, 0, N_("The size of the journal encryption key"), N_("BITS") }, { "journal-crypt-key-file", '\0', POPT_ARG_STRING, &opt_journal_crypt_key_file, 0, N_("Read the journal encryption key from a file"), NULL }, { "integrity-no-journal", 'D', POPT_ARG_NONE, &opt_integrity_nojournal, 0, N_("Disable journal for integrity device"), NULL }, { "integrity-recovery-mode", 'R', POPT_ARG_NONE, &opt_integrity_recovery, 0, N_("Recovery mode (no journal, no tag checking)"), NULL }, { "integrity-bitmap-mode", 'B', POPT_ARG_NONE, &opt_integrity_bitmap, 0, N_("Use bitmap to track changes and disable journal for integrity device"), NULL }, { "integrity-recalculate", '\0', POPT_ARG_NONE, &opt_integrity_recalculate, 0, N_("Recalculate initial tags automatically."), NULL }, POPT_TABLEEND }; poptContext popt_context; struct action_type *action; const char *aname; int r; crypt_set_log_callback(NULL, tool_log, NULL); setlocale(LC_ALL, ""); bindtextdomain(PACKAGE, LOCALEDIR); textdomain(PACKAGE); popt_context = poptGetContext("integrity", argc, argv, popt_options, 0); poptSetOtherOptionHelp(popt_context, _("[OPTION...] <action> <action-specific>")); while ((r = poptGetNextOpt(popt_context)) >= 0) { } if (r < -1) usage(popt_context, EXIT_FAILURE, poptStrerror(r), poptBadOption(popt_context, POPT_BADOPTION_NOALIAS)); if (opt_version_mode) { log_std("%s %s\n", PACKAGE_INTEGRITY, PACKAGE_VERSION); poptFreeContext(popt_context); exit(EXIT_SUCCESS); } if (!(aname = poptGetArg(popt_context))) usage(popt_context, EXIT_FAILURE, _("Argument <action> missing."), poptGetInvocationName(popt_context)); action_argc = 0; action_argv = poptGetArgs(popt_context); /* Make return values of poptGetArgs more consistent in case of remaining argc = 0 */ if (!action_argv) action_argv = null_action_argv; /* Count args, somewhat unnice, change? */ while (action_argv[action_argc] != NULL) action_argc++; /* Handle aliases */ if (!strcmp(aname, "create") && action_argc > 1) { /* create command had historically switched arguments */ if (action_argv[0] && action_argv[1]) { const char *tmp = action_argv[0]; action_argv[0] = action_argv[1]; action_argv[1] = tmp; } aname = "open"; } else if (!strcmp(aname, "remove")) { aname = "close"; } for (action = action_types; action->type; action++) if (strcmp(action->type, aname) == 0) break; if (!action->type) usage(popt_context, EXIT_FAILURE, _("Unknown action."), poptGetInvocationName(popt_context)); if (action_argc < action->required_action_argc) { char buf[128]; snprintf(buf, 128,_("%s: requires %s as arguments"), action->type, action->arg_desc); usage(popt_context, EXIT_FAILURE, buf, poptGetInvocationName(popt_context)); } if (!strcmp(aname, "format") && opt_tag_size == 0) opt_tag_size = DEFAULT_TAG_SIZE; if (opt_integrity_recalculate && strcmp(aname, "open")) usage(popt_context, EXIT_FAILURE, _("Option --integrity-recalculate can be used only for open action."), poptGetInvocationName(popt_context)); if (opt_interleave_sectors < 0 || opt_journal_watermark < 0 || opt_journal_commit_time < 0 || opt_tag_size < 0 || opt_sector_size < 0 || opt_buffer_sectors < 0 || opt_integrity_key_size < 0 || opt_journal_integrity_key_size < 0 || opt_journal_crypt_key_size < 0 || opt_bitmap_flush_time < 0 || opt_bitmap_sectors_per_bit < 0) usage(popt_context, EXIT_FAILURE, _("Negative number for option not permitted."), poptGetInvocationName(popt_context)); if (strcmp(aname, "format") && (opt_journal_size_str || opt_interleave_sectors || opt_sector_size || opt_tag_size || opt_no_wipe )) usage(popt_context, EXIT_FAILURE, _("Options --journal-size, --interleave-sectors, --sector-size, --tag-size" " and --no-wipe can be used only for format action.\n"), poptGetInvocationName(popt_context)); if (opt_journal_size_str && tools_string_to_size(NULL, opt_journal_size_str, &opt_journal_size)) usage(popt_context, EXIT_FAILURE, _("Invalid journal size specification."), poptGetInvocationName(popt_context)); if ((opt_integrity_key_file && !opt_integrity_key_size) || (!opt_integrity_key_file && opt_integrity_key_size)) usage(popt_context, EXIT_FAILURE, _("Both key file and key size options must be specified."), poptGetInvocationName(popt_context)); if (!opt_integrity && opt_integrity_key_file) usage(popt_context, EXIT_FAILURE, _("Integrity algorithm must be specified if integrity key is used."), poptGetInvocationName(popt_context)); if ((opt_journal_integrity_key_file && !opt_journal_integrity_key_size) || (!opt_journal_integrity_key_file && opt_journal_integrity_key_size)) usage(popt_context, EXIT_FAILURE, _("Both journal integrity key file and key size options must be specified."), poptGetInvocationName(popt_context)); if (!opt_journal_integrity && opt_journal_integrity_key_file) usage(popt_context, EXIT_FAILURE, _("Journal integrity algorithm must be specified if journal integrity key is used."), poptGetInvocationName(popt_context)); if ((opt_journal_crypt_key_file && !opt_journal_crypt_key_size) || (!opt_journal_crypt_key_file && opt_journal_crypt_key_size)) usage(popt_context, EXIT_FAILURE, _("Both journal encryption key file and key size options must be specified."), poptGetInvocationName(popt_context)); if (!opt_journal_crypt && opt_journal_crypt_key_file) usage(popt_context, EXIT_FAILURE, _("Journal encryption algorithm must be specified if journal encryption key is used."), poptGetInvocationName(popt_context)); if (opt_integrity_recovery && opt_integrity_bitmap) usage(popt_context, EXIT_FAILURE, _("Recovery and bitmap mode options are mutually exclusive."), poptGetInvocationName(popt_context)); if (opt_integrity_bitmap && (opt_journal_integrity_key_file || opt_journal_crypt || opt_journal_watermark || opt_journal_commit_time)) usage(popt_context, EXIT_FAILURE, _("Journal options cannot be used in bitmap mode."), poptGetInvocationName(popt_context)); if (!opt_integrity_bitmap && (opt_bitmap_flush_time || opt_bitmap_sectors_per_bit)) usage(popt_context, EXIT_FAILURE, _("Bitmap options can be used only in bitmap mode."), poptGetInvocationName(popt_context)); if (opt_debug) { opt_verbose = 1; crypt_set_debug_level(-1); dbg_version_and_cmd(argc, argv); } r = run_action(action); poptFreeContext(popt_context); return r; }
void UnitGroup::exe_assign(int destXLoc, int destYLoc, int targetMobileType, int actionNationRecno) { //---------------------------------------// Unit* unitPtr; int locX, locY; int right = 0; int left = 0; int midX = 0; int top = 0; int bottom = 0; int midY = 0; if(size() == 1) { unitPtr = get_unit(1); unitPtr->set_no_longer_in_formation(); unitPtr->assign(destXLoc, destYLoc, actionNationRecno); return; } Location* locPtr; locPtr = world.get_loc(destXLoc, destYLoc); int baseObjRecno = locPtr->base_obj_recno(targetMobileType); // ###### begin Gilbert 6/5 #######// if( !baseObjRecno ) return; // ###### end Gilbert 6/5 #######// BaseObj* thePlace = base_obj_array[baseObjRecno]; int destWidth = thePlace->obj_loc_width(); int destHeight = thePlace->obj_loc_height(); for(int i = 1; i<=size(); i++) { unitPtr = get_unit(i); unitPtr->set_no_longer_in_formation(); locX = unitPtr->next_x_loc(); locY = unitPtr->next_y_loc(); if(locX < destXLoc) //left left++; else if(locX > destXLoc+destWidth-1) //right right++; else midX++; if(locY < destYLoc) //top top++; else if(locY > destYLoc+destHeight-1) //bottom bottom++; else midY++; } if(!left && !midX) //all at right side { run_action( destXLoc, destYLoc, UNIT_ASSIGN, baseObjRecno ); return; } if(!right && !midX) //all at left side { run_action( destXLoc, destYLoc, UNIT_ASSIGN, baseObjRecno ); return; } if(!top && !midY) //all at bottom side { run_action( destXLoc, destYLoc, UNIT_ASSIGN, baseObjRecno); return; } if(!bottom && !midY) //all at top side { run_action(destXLoc, destYLoc, UNIT_ASSIGN, baseObjRecno); return; } for(i=1; i<=size(); i++) { unitPtr = get_unit(i); unitPtr->assign(destXLoc, destYLoc, actionNationRecno); } }
int main(int argc, char *argv[], char *envp[]) { int action = 0; int verbose = 0; int verbose_tmp; int verbose_custom = 0; int quiet = 0; int veid, ret, skiplock = 0; char buf[256]; vps_param *gparam = NULL, *vps_p = NULL, *cmd_p = NULL; const char *action_nm; struct sigaction act; char *name = NULL, *opt; _proc_title = argv[0]; _proc_title_len = envp[0] - argv[0]; gparam = init_vps_param(); vps_p = init_vps_param(); cmd_p = init_vps_param(); sigemptyset(&act.sa_mask); act.sa_handler = SIG_IGN; act.sa_flags = 0; sigaction(SIGPIPE, &act, NULL); while (argc > 1) { opt = argv[1]; if (!strcmp(opt, "--verbose")) { if (argc > 2 && !parse_int(argv[2], &verbose_tmp)) { verbose += verbose_tmp; argc--; argv++; } else { verbose++; } verbose_custom = 1; } else if (!strncmp(opt, "--verbose=", 10)) { if (parse_int(opt + 10, &verbose_tmp)) { fprintf(stderr, "Invalid value for" " --verbose\n"); exit(VZ_INVALID_PARAMETER_VALUE); } verbose += verbose_tmp; verbose_custom = 1; } else if (!strcmp(opt, "--quiet")) quiet = 1; else if (!strcmp(opt, "--version")) { version(stdout); exit(0); } else if (!strcmp(opt, "--skiplock")) skiplock = YES; else break; argc--; argv++; } if (argc <= 1) usage(VZ_INVALID_PARAMETER_SYNTAX); action_nm = argv[1]; init_log(NULL, 0, 1, verbose, 0, NULL); if (!strcmp(argv[1], "set")) { init_modules(&g_action, "set"); action = ACTION_SET; // status = ST_SET; } else if (!strcmp(argv[1], "create")) { init_modules(&g_action, "create"); action = ACTION_CREATE; // status = ST_CREATE; } else if (!strcmp(argv[1], "start")) { init_modules(&g_action, "set"); action = ACTION_START; // status = ST_START; } else if (!strcmp(argv[1], "stop")) { init_modules(&g_action, "set"); action = ACTION_STOP; // status = ST_STOP; } else if (!strcmp(argv[1], "restart")) { action = ACTION_RESTART; // status = ST_RESTART; } else if (!strcmp(argv[1], "destroy")) { action = ACTION_DESTROY; // status = ST_DESTROY; } else if (!strcmp(argv[1], "mount")) { action = ACTION_MOUNT; // status = ST_MOUNT; } else if (!strcmp(argv[1], "umount")) { action = ACTION_UMOUNT; // status = ST_UMOUNT; } else if (!strcmp(argv[1], "exec3")) { action = ACTION_EXEC3; } else if (!strcmp(argv[1], "exec2")) { action = ACTION_EXEC2; } else if (!strcmp(argv[1], "exec")) { action = ACTION_EXEC; } else if (!strcmp(argv[1], "runscript")) { action = ACTION_RUNSCRIPT; } else if (!strcmp(argv[1], "enter")) { action = ACTION_ENTER; } else if (!strcmp(argv[1], "status")) { action = ACTION_STATUS; quiet = 1; } else if (!strcmp(argv[1], "chkpnt")) { action = ACTION_CHKPNT; } else if (!strcmp(argv[1], "restore")) { action = ACTION_RESTORE; } else if (!strcmp(argv[1], "quotaon")) { action = ACTION_QUOTAON; } else if (!strcmp(argv[1], "quotaoff")) { action = ACTION_QUOTAOFF; } else if (!strcmp(argv[1], "quotainit")) { action = ACTION_QUOTAINIT; } else if (!strcmp(argv[1], "--help")) { usage(0); } else { init_modules(&g_action, action_nm); action = ACTION_CUSTOM; if (!g_action.mod_count) { fprintf(stderr, "Bad command: %s\n", argv[1]); ret = VZ_INVALID_PARAMETER_SYNTAX; goto error; } } if (argc < 3) { fprintf(stderr, "CT ID missing\n"); ret = VZ_INVALID_PARAMETER_VALUE; goto error; } if (parse_int(argv[2], &veid)) { name = strdup(argv[2]); veid = get_veid_by_name(name); if (veid < 0) { fprintf(stderr, "Bad CT ID %s\n", argv[2]); ret = VZ_INVALID_PARAMETER_VALUE; goto error; } } argc -= 2; argv += 2; /* Read global config file */ if (vps_parse_config(veid, GLOBAL_CFG, gparam, &g_action)) { fprintf(stderr, "Global configuration file %s not found\n", GLOBAL_CFG); ret = VZ_NOCONFIG; goto error; } init_log(gparam->log.log_file, veid, gparam->log.enable != NO, gparam->log.level, quiet, "vzctl"); /* Set verbose level from global config if not overwriten by --verbose */ if (!verbose_custom && gparam->log.verbose != NULL) { verbose = *gparam->log.verbose; verbose_custom = 1; } if (verbose < -1) verbose = -1; if (verbose_custom) set_log_verbose(verbose); if ((ret = parse_action_opt(veid, action, argc, argv, cmd_p, action_nm))) { goto error; } if (veid == 0 && action != ACTION_SET) { fprintf(stderr, "Only set actions are allowed for CT0\n"); ret = VZ_INVALID_PARAMETER_VALUE; goto error; } else if (veid < 0) { fprintf(stderr, "Bad CT ID %d\n", veid); ret = VZ_INVALID_PARAMETER_VALUE; goto error; } get_vps_conf_path(veid, buf, sizeof(buf)); if (stat_file(buf)) { if (vps_parse_config(veid, buf, vps_p, &g_action)) { logger(-1, 0, "Error in config file %s", buf); ret = VZ_NOCONFIG; goto error; } if (name != NULL && vps_p->res.name.name != NULL && strcmp(name, vps_p->res.name.name)) { logger(-1, 0, "Unable to find container by name %s", name); ret = VZ_INVALID_PARAMETER_VALUE; goto error; } } else if (action != ACTION_CREATE && action != ACTION_STATUS && action != ACTION_SET) { logger(-1, 0, "Container config file does not exist"); ret = VZ_NOVECONFIG; goto error; } merge_vps_param(gparam, vps_p); merge_global_param(cmd_p, gparam); ret = run_action(veid, action, gparam, vps_p, cmd_p, argc-1, argv+1, skiplock); error: free_modules(&g_action); free_vps_param(gparam); free_vps_param(vps_p); free_vps_param(cmd_p); free_log(); if (name != NULL) free(name); return ret; }
int main(int argc, char *argv[], char *envp[]) { act_t action = -1; int verbose = 0; int verbose_custom = 0; int quiet = 0; int veid, ret, skiplock = 0; char buf[256]; vps_param *gparam = NULL, *vps_p = NULL, *cmd_p = NULL; const char *action_nm; struct sigaction act; char *name = NULL, *opt; _proc_title = argv[0]; _proc_title_len = envp[0] - argv[0]; gparam = init_vps_param(); vps_p = init_vps_param(); cmd_p = init_vps_param(); sigemptyset(&act.sa_mask); act.sa_handler = SIG_IGN; act.sa_flags = 0; sigaction(SIGPIPE, &act, NULL); while (argc > 1) { opt = argv[1]; if (!strcmp(opt, "--verbose")) { verbose++; verbose_custom = 1; } else if (!strcmp(opt, "--quiet")) quiet = 1; else if (!strcmp(opt, "--version")) { version(stdout); exit(0); } else if (!strcmp(opt, "--skiplock")) skiplock = YES; else break; argc--; argv++; } if (argc <= 1) usage(VZ_INVALID_PARAMETER_SYNTAX); action_nm = argv[1]; init_log(NULL, 0, 1, verbose, quiet, NULL); if (!strcmp(argv[1], "set")) { init_modules(&g_action, "set"); action = ACTION_SET; } else if (!strcmp(argv[1], "create")) { init_modules(&g_action, "create"); action = ACTION_CREATE; } else if (!strcmp(argv[1], "start")) { init_modules(&g_action, "set"); action = ACTION_START; } else if (!strcmp(argv[1], "stop")) { init_modules(&g_action, "set"); action = ACTION_STOP; } else if (!strcmp(argv[1], "restart")) { action = ACTION_RESTART; } else if (!strcmp(argv[1], "destroy") || !strcmp(argv[1], "delete")) { action = ACTION_DESTROY; } else if (!strcmp(argv[1], "mount")) { action = ACTION_MOUNT; } else if (!strcmp(argv[1], "umount")) { action = ACTION_UMOUNT; } else if (!strcmp(argv[1], "exec3")) { action = ACTION_EXEC3; } else if (!strcmp(argv[1], "exec2")) { action = ACTION_EXEC2; } else if (!strcmp(argv[1], "exec")) { action = ACTION_EXEC; } else if (!strcmp(argv[1], "runscript")) { action = ACTION_RUNSCRIPT; } else if (!strcmp(argv[1], "enter")) { action = ACTION_ENTER; } else if (!strcmp(argv[1], "console")) { action = ACTION_CONSOLE; #ifdef HAVE_PLOOP } else if (!strcmp(argv[1], "convert")) { action = ACTION_CONVERT; } else if (!strcmp(argv[1], "compact")) { action = ACTION_COMPACT; #endif } else if (!strcmp(argv[1], "status")) { action = ACTION_STATUS; quiet = 1; } else if (!strcmp(argv[1], "suspend") || !strcmp(argv[1], "chkpnt")) { action = ACTION_SUSPEND; } else if (!strcmp(argv[1], "resume") || !strcmp(argv[1], "restore")) { action = ACTION_RESUME; } else if (!strcmp(argv[1], "quotaon")) { action = ACTION_QUOTAON; } else if (!strcmp(argv[1], "quotaoff")) { action = ACTION_QUOTAOFF; } else if (!strcmp(argv[1], "quotainit")) { action = ACTION_QUOTAINIT; #ifdef HAVE_PLOOP } else if (!strcmp(argv[1], "snapshot")) { action = ACTION_SNAPSHOT_CREATE; } else if (!strcmp(argv[1], "snapshot-switch")) { action = ACTION_SNAPSHOT_SWITCH; } else if (!strcmp(argv[1], "snapshot-delete")) { action = ACTION_SNAPSHOT_DELETE; } else if (!strcmp(argv[1], "snapshot-list")) { action = ACTION_SNAPSHOT_LIST; } else if (!strcmp(argv[1], "snapshot-mount")) { action = ACTION_SNAPSHOT_MOUNT; } else if (!strcmp(argv[1], "snapshot-umount")) { action = ACTION_SNAPSHOT_UMOUNT; #endif } else if (!strcmp(argv[1], "--help")) { usage(0); } else { init_modules(&g_action, action_nm); action = ACTION_CUSTOM; if (!g_action.mod_count) { fprintf(stderr, "Bad command: %s\n", argv[1]); ret = VZ_INVALID_PARAMETER_SYNTAX; goto error; } } if (argc < 3) { fprintf(stderr, "CT ID missing\n"); ret = VZ_INVALID_PARAMETER_VALUE; goto error; } if (parse_int(argv[2], &veid)) { name = strdup(argv[2]); veid = get_veid_by_name(name); } if (veid < 0 || veid > VEID_MAX) { fprintf(stderr, "Bad CT ID %s\n", argv[2]); ret = VZ_INVALID_PARAMETER_VALUE; goto error; } argc -= 2; argv += 2; /* getopt_long() prints argv[0] when reporting errors */ argv[0] = _proc_title; /* Read global config file */ if (vps_parse_config(veid, GLOBAL_CFG, gparam, &g_action)) { ret = VZ_NOCONFIG; goto error; } init_log(gparam->log.log_file, veid, gparam->log.enable != NO, gparam->log.level, quiet, "vzctl"); /* Set verbose level from global config if not overwriten by --verbose */ if (!verbose_custom && gparam->log.verbose != NULL) { verbose = *gparam->log.verbose; verbose_custom = 1; } if (verbose < -1) verbose = -1; if (verbose_custom) set_log_verbose(verbose); if ((ret = parse_action_opt(veid, action, argc, argv, cmd_p, action_nm))) { goto error; } if (veid == 0 && action != ACTION_SET) { fprintf(stderr, "Only set actions are allowed for CT0\n"); ret = VZ_INVALID_PARAMETER_VALUE; goto error; } else if (veid < 0) { fprintf(stderr, "Bad CT ID %d\n", veid); ret = VZ_INVALID_PARAMETER_VALUE; goto error; } get_vps_conf_path(veid, buf, sizeof(buf)); if (stat_file(buf) == 1) { if (vps_parse_config(veid, buf, vps_p, &g_action)) { ret = VZ_NOCONFIG; goto error; } if (name != NULL && vps_p->res.name.name != NULL && strcmp(name, vps_p->res.name.name)) { logger(-1, 0, "Unable to find container by name %s", name); ret = VZ_INVALID_PARAMETER_VALUE; goto error; } } else if (action != ACTION_CREATE && action != ACTION_STATUS && action != ACTION_SET) { logger(-1, 0, "Container config file does not exist"); ret = VZ_NOVECONFIG; goto error; } merge_vps_param(gparam, vps_p); merge_global_param(cmd_p, gparam); ret = run_action(veid, action, gparam, vps_p, cmd_p, argc, argv, skiplock); error: free_modules(&g_action); free_vps_param(gparam); free_vps_param(vps_p); free_vps_param(cmd_p); free_log(); free(name); return ret; }
void UnitGroup::exe_move(int destXLoc, int destYLoc, bool forceMoveFlag) { run_action( destXLoc, destYLoc, UNIT_MOVE, 0, forceMoveFlag ); }
int main(int argc, char *argv[]) { return !run_action(NACTIONS, plugin_actions, argc, argv); }
sysdig_table_action sinsp_cursesui::handle_input(int ch) { // // Avoid parsing keys during file load // if((!m_inspector->is_live()) && !is_eof()) { if(ch != KEY_BACKSPACE && ch != 127 && ch != 'q' && ch != KEY_F(10)) { return STA_NONE; } } if(m_mainhelp_page != NULL) { sysdig_table_action actn = m_mainhelp_page->handle_input(ch); if(actn == STA_DESTROY_CHILD) { delete m_mainhelp_page; m_mainhelp_page = NULL; if(m_spy_box) { m_spy_box->render(); } if(m_viz != NULL) { m_viz->render(true); } if(m_viewinfo_page) { m_viewinfo_page->render(); } render(); return STA_NONE; } else if(actn != STA_PARENT_HANDLE) { return actn; } } if(m_view_sidemenu != NULL) { ASSERT(m_action_sidemenu == NULL); sysdig_table_action ta = m_view_sidemenu->handle_input(ch); if(ta == STA_SWITCH_VIEW) { if(m_viewinfo_page) { delete m_viewinfo_page; m_viewinfo_page = NULL; } return ta; } else if(ta != STA_PARENT_HANDLE) { return STA_NONE; } } else { if(m_action_sidemenu != NULL) { sysdig_table_action ta = m_action_sidemenu->handle_input(ch); if(ta == STA_SWITCH_VIEW) { sinsp_view_info* vinfo = get_selected_view(); g_logger.format("running action %d %s", m_selected_action_sidemenu_entry, vinfo->m_name.c_str()); ASSERT(m_selected_action_sidemenu_entry < vinfo->m_actions.size()); run_action(&vinfo->m_actions[m_selected_action_sidemenu_entry]); return ta; } else if(ta == STA_DESTROY_CHILD) { m_viz->set_x_start(0); delete m_action_sidemenu; m_action_sidemenu = NULL; m_viz->set_x_start(0); m_viz->recreate_win(m_screenh - 3); m_viz->render(true); m_viz->render(true); render(); } else if(ta != STA_PARENT_HANDLE) { return STA_NONE; } } } if(m_output_filtering || m_output_searching || m_search_caller_interface != NULL) { ASSERT(m_view_sidemenu == NULL); ASSERT(m_action_sidemenu == NULL); return handle_textbox_input(ch); } if(m_spy_box != NULL) { ASSERT(m_view_sidemenu == NULL); ASSERT(m_action_sidemenu == NULL); ASSERT(m_output_filtering == false); ASSERT(m_output_searching == false); sysdig_table_action actn = m_spy_box->handle_input(ch); if(actn != STA_PARENT_HANDLE) { return actn; } } // // Note: the info page doesn't handle input when the sidemenu is on, because in that // case it's just going to passively show the info for the selected view // if(m_viewinfo_page && m_view_sidemenu == NULL) { ASSERT(m_view_sidemenu == NULL); sysdig_table_action actn = m_viewinfo_page->handle_input(ch); if(actn == STA_DESTROY_CHILD) { delete m_viewinfo_page; m_viewinfo_page = NULL; if(m_viz != NULL) { m_viz->render(true); } render(); return STA_NONE; } return actn; } // // Pass the event to the table viz // if(m_viz) { sysdig_table_action actn = m_viz->handle_input(ch); if(actn != STA_PARENT_HANDLE) { return actn; } } switch(ch) { case '?': case 'h': case KEY_F(1): m_mainhelp_page = new curses_mainhelp_page(this); break; case KEY_F(10): case 'q': return STA_QUIT; case 'p': pause(); break; case KEY_F(2): if(m_action_sidemenu != NULL) { break; } if(m_view_sidemenu == NULL) { m_viz->set_x_start(VIEW_SIDEMENU_WIDTH); m_view_sidemenu = new curses_table_sidemenu(curses_table_sidemenu::ST_VIEWS, this, m_selected_view_sidemenu_entry, VIEW_SIDEMENU_WIDTH); m_view_sidemenu->set_entries(&m_sidemenu_viewlist); m_view_sidemenu->set_title("Select View"); render(); m_viewinfo_page = new curses_viewinfo_page(this, m_selected_view, TABLE_Y_START, VIEW_SIDEMENU_WIDTH, m_screenh - TABLE_Y_START - 1, m_screenw - VIEW_SIDEMENU_WIDTH); } else { if(m_viewinfo_page) { delete m_viewinfo_page; m_viewinfo_page = NULL; } m_viz->set_x_start(0); delete m_view_sidemenu; m_view_sidemenu = NULL; m_viz->recreate_win(m_screenh - 3); render(); } break; case '/': case 6: // CTRL+F m_search_caller_interface = NULL; m_output_searching = true; //m_manual_search_text = ""; m_cursor_pos = 0; curs_set(1); render(); break; //case KEY_F(3): // break; case '\\': case KEY_F(4): m_search_caller_interface = NULL; m_output_filtering = true; m_cursor_pos = 0; curs_set(1); render(); break; case KEY_F(5): case 'e': if(m_datatable == NULL) { // // No F5 for non table displays // return STA_NONE; } else if(m_datatable->m_type == sinsp_table::TT_LIST) { // // No F5 for list tables // return STA_NONE; } if(m_datatable->m_sample_data != NULL && m_datatable->m_sample_data->size() != 0) { m_selected_view_sidemenu_entry = 0; m_selected_action_sidemenu_entry = 0; return STA_SPY; } break; case KEY_F(6): case 'd': if(m_datatable == NULL) { // // No F5 for non table displays // return STA_NONE; } else if(m_datatable->m_type == sinsp_table::TT_LIST) { // // No F5 for list tables // return STA_NONE; } if(m_datatable->m_sample_data != NULL && m_datatable->m_sample_data->size() != 0) { m_selected_view_sidemenu_entry = 0; m_selected_action_sidemenu_entry = 0; return STA_DIG; } break; case KEY_F(7): m_viewinfo_page = new curses_viewinfo_page(this, m_selected_view, 0, 0, m_screenh, m_screenw); break; case KEY_F(8): if(m_view_sidemenu != NULL) { break; } if(m_action_sidemenu == NULL) { m_viz->set_x_start(ACTION_SIDEMENU_WIDTH); m_action_sidemenu = new curses_table_sidemenu(curses_table_sidemenu::ST_ACTIONS, this, m_selected_action_sidemenu_entry, ACTION_SIDEMENU_WIDTH); populate_action_sidemenu(); m_action_sidemenu->set_title("Select Action"); m_viz->set_x_start(ACTION_SIDEMENU_WIDTH); m_viz->recreate_win(m_screenh - 3); render(); m_viewinfo_page = NULL; } else { m_viz->set_x_start(0); delete m_action_sidemenu; m_action_sidemenu = NULL; m_viz->set_x_start(0); m_viz->recreate_win(m_screenh - 3); m_viz->render(true); m_viz->render(true); render(); } break; case KEY_RESIZE: getmaxyx(stdscr, m_screenh, m_screenw); render(); if(m_spy_box) { m_spy_box->render(); m_spy_box->render(); } if(m_viz != NULL) { m_viz->recreate_win(m_screenh - 3); m_viz->render(true); m_viz->render(true); } if(m_viewinfo_page) { m_viewinfo_page->render(); m_viewinfo_page->render(); } render(); break; case KEY_MOUSE: { MEVENT* event = NULL; if(m_view_sidemenu != NULL) { event = &m_view_sidemenu->m_last_mevent; } else if(m_action_sidemenu != NULL) { event = &m_action_sidemenu->m_last_mevent; } else if(m_spy_box != NULL) { event = &m_spy_box->m_last_mevent; } else if(m_viz != NULL) { event = &m_viz->m_last_mevent; } if(event == NULL) { ASSERT(false); break; } if(event->bstate & BUTTON1_CLICKED || event->bstate & BUTTON1_DOUBLE_CLICKED) { if((uint32_t)event->y == m_screenh - 1) { int keyc = m_mouse_to_key_list.get_key_from_coordinates(event->x, event->y); if(keyc != -1) { return handle_input(keyc); } } else if((uint32_t)event->y == 1 && (uint32_t)event->x >= m_filterstring_start_x && (uint32_t)event->x <= m_filterstring_end_x) { m_search_caller_interface = NULL; m_is_filter_sysdig = true; m_output_filtering = true; m_manual_filter = m_complete_filter; m_cursor_pos = 0; curs_set(1); render(); } } } break; default: break; } return STA_NONE; }
int main(int argc, char **argv) { const char *query = NULL; int c, bits = 0, actions_done = 0, actions = 0, action = ACTION_UNK; char *homeplugindir = r_str_home (R2_HOMEDIR"/plugins"); char *ptr, *arch = NULL, *arch_name = NULL; const char *op = NULL; RCoreBinFilter filter; RCore core; RCoreFile *cf = NULL; int xtr_idx = 0; // load all files if extraction is necessary. int fd = -1; int rawstr = 0; r_core_init (&core); bin = core.bin; l = r_lib_new ("radare_plugin"); r_lib_add_handler (l, R_LIB_TYPE_BIN, "bin plugins", &__lib_bin_cb, &__lib_bin_dt, NULL); r_lib_add_handler (l, R_LIB_TYPE_BIN_XTR, "bin xtr plugins", &__lib_bin_xtr_cb, &__lib_bin_xtr_dt, NULL); /* load plugins everywhere */ r_lib_opendir (l, getenv ("LIBR_PLUGINS")); r_lib_opendir (l, homeplugindir); r_lib_opendir (l, LIBDIR"/radare2/"R2_VERSION); #define is_active(x) (action&x) #define set_action(x) actions++; action |=x while ((c = getopt (argc, argv, "jgqAf:a:B:b:c:Ck:dMm:n:N:@:isSIHelRwO:o:rvLhxzZ")) != -1) { switch (c) { case 'g': set_action (ACTION_CLASSES); set_action (ACTION_IMPORTS); set_action (ACTION_SYMBOLS); set_action (ACTION_SECTIONS); set_action (ACTION_STRINGS); set_action (ACTION_SIZE); set_action (ACTION_INFO); set_action (ACTION_FIELDS); set_action (ACTION_DWARF); set_action (ACTION_ENTRIES); set_action (ACTION_MAIN); set_action (ACTION_LIBS); set_action (ACTION_RELOCS); set_action (ACTION_EXTRACT); break; case 'q': rad = R_CORE_BIN_SIMPLE; break; case 'j': rad = R_CORE_BIN_JSON; break; case 'A': set_action (ACTION_LISTARCHS); break; case 'a': if (optarg) arch = optarg; break; case 'c': if (!optarg) { eprintf ("Missing argument for -c"); return 1; } set_action (ACTION_CREATE); create = strdup (optarg); break; case 'k': query = optarg; break; case 'C': set_action (ACTION_CLASSES); break; case 'f': if (optarg) arch_name = strdup (optarg); break; case 'b': bits = r_num_math (NULL, optarg); break; case 'm': at = r_num_math (NULL, optarg); set_action (ACTION_SRCLINE); break; case 'i': set_action (ACTION_IMPORTS); break; case 's': set_action (ACTION_SYMBOLS); break; case 'S': set_action (ACTION_SECTIONS); break; case 'z': if (is_active (ACTION_STRINGS)) { rawstr = R_TRUE; } else set_action (ACTION_STRINGS); break; case 'Z': set_action (ACTION_SIZE); break; case 'I': set_action (ACTION_INFO); break; case 'H': set_action (ACTION_FIELDS); break; case 'd': set_action (ACTION_DWARF); break; case 'e': set_action (ACTION_ENTRIES); break; case 'M': set_action (ACTION_MAIN); break; case 'l': set_action (ACTION_LIBS); break; case 'R': set_action (ACTION_RELOCS); break; case 'x': set_action (ACTION_EXTRACT); break; case 'w': rw = R_TRUE; break; case 'O': op = optarg; set_action (ACTION_OPERATION); if (op && !strcmp (op, "help")) { printf ("Operation string:\n" " Dump symbols: d/s/1024\n" " Dump section: d/S/.text\n" " Resize section: r/.data/1024\n"); return 0; } if (optind==argc) { eprintf ("Missing filename\n"); return 1; } break; case 'o': output = optarg; break; case 'r': rad = R_TRUE; break; case 'v': va = R_TRUE; break; case 'L': r_bin_list (bin); return 1; case 'B': baddr = r_num_math (NULL, optarg); break; case '@': at = r_num_math (NULL, optarg); break; case 'n': name = optarg; break; case 'N': bin->minstrlen = r_num_math (NULL, optarg); break; //case 'V': return blob_version ("rabin2"); case 'h': return rabin_show_help (1); default: action |= ACTION_HELP; } } file = argv[optind]; if (!query) if (action & ACTION_HELP || action == ACTION_UNK || file == NULL) { if (va) return blob_version ("rabin2"); return rabin_show_help (0); } if (arch) { ptr = strchr (arch, '_'); if (ptr) { *ptr = '\0'; bits = r_num_math (NULL, ptr+1); } } if (action & ACTION_CREATE) { // TODO: move in a function outside RBuffer *b; int datalen, codelen; ut8 *data = NULL, *code = NULL; char *p2, *p = strchr (create, ':'); if (!p) { eprintf ("Invalid format for -c flag. Use 'format:codehexpair:datahexpair'\n"); return 1; } *p++ = 0; p2 = strchr (p, ':'); if (p2) { // has data *p2++ = 0; data = malloc (strlen (p2)+1); datalen = r_hex_str2bin (p2, data); } else { data = NULL; datalen = 0; } code = malloc (strlen (p)+1); if (!code) { return 1; } codelen = r_hex_str2bin (p, code); if (!arch) arch = "x86"; if (!bits) bits = 32; if (!r_bin_use_arch (bin, arch, bits, create)) { eprintf ("Cannot set arch\n"); return 1; } b = r_bin_create (bin, code, codelen, data, datalen); if (b) { if (r_file_dump (file, b->buf, b->length)) { eprintf ("dumped %d bytes in '%s'\n", b->length, file); r_file_chmod (file, "+x", 0); } else eprintf ("error dumping into a.out\n"); r_buf_free (b); } else eprintf ("Cannot create binary for this format '%s'.\n", create); r_bin_free (bin); return 0; } r_config_set_i (core.config, "bin.rawstr", rawstr); cf = r_core_file_open (&core, file, R_IO_READ, 0); fd = cf ? r_core_file_cur_fd (&core) : -1; if (!cf || fd == -1) { eprintf ("r_core: Cannot open file\n"); return 1; } if (!r_bin_load (bin, file, baddr, 0, xtr_idx, fd, rawstr)) { if (!r_bin_load (bin, file, baddr, 0, xtr_idx, fd, rawstr)) { eprintf ("r_bin: Cannot open file\n"); return 1; } } if (query) { if (!strcmp (query, "-")) { __sdb_prompt (bin->cur->sdb); } else sdb_query (bin->cur->sdb, query); return 0; } // XXX: TODO move this to libr/core/bin.c if (action & ACTION_LISTARCHS || ((arch || bits || arch_name) && !r_bin_select (bin, arch, bits, arch_name))) { if (rad == R_CORE_BIN_JSON) { int i; printf ("["); for (i = 0; i < bin->narch; i++) { if (r_bin_select_idx (bin, bin->file, i)) { RBinObject *o = r_bin_cur_object (bin); RBinInfo *info = o ? o->info : NULL; printf ("%s{\"arch\":\"%s\",\"bits\":%d," "\"offset\":%"PFMT64d",\"machine\":\"%s\"}", i?",":"",info->arch, info->bits, bin->cur->offset, info->machine); } } printf ("]"); } else r_bin_list_archs (bin, 1); free (arch_name); } if (baddr != 0LL) { r_bin_set_baddr (bin, baddr); bin->cur->o->baddr = baddr; } core.bin = bin; filter.offset = at; filter.name = name; r_cons_new ()->is_interactive = R_FALSE; #define isradjson (rad==R_CORE_BIN_JSON&&actions>0) #define run_action(n,x,y) {\ if (action&x) {\ if (isradjson) r_cons_printf ("\"%s\":",n);\ if (!r_core_bin_info (&core, y, rad, va, &filter, 0)) {\ if (isradjson) r_cons_printf("false");\ };\ actions_done++;\ if (isradjson) r_cons_printf (actions==actions_done? "":",");\ }\ } if (isradjson) r_cons_printf ("{"); run_action ("sections", ACTION_SECTIONS, R_CORE_BIN_ACC_SECTIONS); run_action ("entries", ACTION_ENTRIES, R_CORE_BIN_ACC_ENTRIES); run_action ("main", ACTION_MAIN, R_CORE_BIN_ACC_MAIN); run_action ("imports", ACTION_IMPORTS, R_CORE_BIN_ACC_IMPORTS); run_action ("classes", ACTION_CLASSES, R_CORE_BIN_ACC_CLASSES); run_action ("symbols", ACTION_SYMBOLS, R_CORE_BIN_ACC_SYMBOLS); run_action ("strings", ACTION_STRINGS, R_CORE_BIN_ACC_STRINGS); run_action ("info", ACTION_INFO, R_CORE_BIN_ACC_INFO); run_action ("fields", ACTION_FIELDS, R_CORE_BIN_ACC_FIELDS); run_action ("libs", ACTION_LIBS, R_CORE_BIN_ACC_LIBS); run_action ("relocs", ACTION_RELOCS, R_CORE_BIN_ACC_RELOCS); run_action ("dwarf", ACTION_DWARF, R_CORE_BIN_ACC_DWARF); run_action ("size", ACTION_SIZE, R_CORE_BIN_ACC_SIZE); if (action&ACTION_SRCLINE) rabin_show_srcline (at); if (action&ACTION_EXTRACT) rabin_extract ((arch==NULL && arch_name==NULL && bits==0)); if (op != NULL && action&ACTION_OPERATION) rabin_do_operation (op); if (isradjson) printf ("}"); r_cons_flush (); r_core_fini (&core); return 0; }
//----------- Begin of function UnitGroup::cluster_units_for_attack----// // // cluster units that are in the same direction of the target to attack // void UnitGroup::cluster_units_for_attack(int targetRecno, int targetLocX, int targetLocY, int targetWidth, int targetHeight) { Unit* unitPtr; int locX, locY; int right = 0; int left = 0; int midX = 0; int top = 0; int bottom = 0; int midY = 0; if(size() == 1) { unitPtr = get_unit(1); if(unitPtr->can_attack()) unitPtr->attack(targetRecno, true); return; } for(int i = 1; i<=size(); i++) { unitPtr = get_unit(i); locX = unitPtr->next_x_loc(); locY = unitPtr->next_y_loc(); if(locX < targetLocX) //left left++; else if(locX > targetLocX+targetWidth-1) //right right++; else midX++; if(locY < targetLocY) //top top++; else if(locY > targetLocY+targetHeight-1) //bottom bottom++; else midY++; } if(!left && !midX) //all at right side { run_action( targetLocX, targetLocY, UNIT_ATTACK, targetRecno ); return; } if(!right && !midX) //all at left side { run_action( targetLocX, targetLocY, UNIT_ATTACK, targetRecno ); return; } if(!top && !midY) //all at bottom side { run_action( targetLocX, targetLocY, UNIT_ATTACK, targetRecno); return; } if(!bottom && !midY) //all at top side { run_action(targetLocX, targetLocY, UNIT_ATTACK, targetRecno); return; } for(i=1; i<=size(); i++) { unitPtr = get_unit(i); if(unitPtr->cur_action == SPRITE_ATTACK && unitPtr->cur_order.para == targetRecno) continue; if(unitPtr->can_attack()) unitPtr->attack(targetRecno, true); } }