/* Dispatch actions according to program flags (NOT commands or * command options). */ static void cli_context_flag_dispatch (cli_context_t *ctx, gint in_argc, gchar **in_argv) { command_t *cmd; gboolean check; GOptionEntry flagdefs[] = { { "help", 'h', 0, G_OPTION_ARG_NONE, NULL, _("Display this help and exit."), NULL }, { "version", 'v', 0, G_OPTION_ARG_NONE, NULL, _("Output version information and exit."), NULL }, { NULL } }; /* Include one command token as a workaround for the bug that * the option parser does not parse commands starting with a * flag properly (e.g. "-p foo arg1"). Will be skipped by the * command utils. */ cmd = command_new (flagdefs, in_argc + 1, in_argv - 1); if (!cmd) { /* An error message has already been printed, so we just return. */ return; } if (command_flag_boolean_get (cmd, "help", &check) && check) { if (command_arg_count (cmd) >= 1) { help_command (ctx, cli_context_command_names (ctx), command_argv_get (cmd), command_arg_count (cmd), CMD_TYPE_COMMAND); } else { /* FIXME: explain -h and -v flags here (reuse help_command code?) */ g_printf (_("usage: xmms2 [<command> [args]]\n\n")); g_printf (_("XMMS2 CLI, the awesome command-line XMMS2 client from the future, " "v" XMMS_VERSION ".\n\n")); g_printf (_("If given a command, runs it inline and exit.\n")); g_printf (_("If not, enters a shell-like interface to execute commands.\n\n")); g_printf (_("Type 'help <command>' for detailed help about a command.\n")); } } else if (command_flag_boolean_get (cmd, "version", &check) && check) { g_printf (_("XMMS2 CLI version " XMMS_VERSION "\n")); g_printf (_("Copyright (C) 2008-2014 XMMS2 Team\n")); g_printf (_("This is free software; see the source for copying conditions.\n")); g_printf (_("There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A\n" "PARTICULAR PURPOSE.\n")); /* FIXME: compiled against? use RL_READLINE_VERSION? */ g_printf (_(" Using readline version %s\n"), rl_library_version); } else { /* Call help to print the "no such command" error */ /* FIXME: Could be a more helpful "invalid flag"?*/ help_command (ctx, cli_context_command_names (ctx), in_argv, in_argc, CMD_TYPE_COMMAND); } command_free (cmd); }
static void cli_context_command_dispatch (cli_context_t *ctx, gint in_argc, gchar **in_argv) { command_action_t *action; command_trie_match_type_t match; gint argc; gchar *tmp_argv[in_argc+1]; gchar **argv; /* The arguments will be updated by command_trie_find and * init_context_from_args, so we make a copy. */ memcpy (tmp_argv, in_argv, in_argc * sizeof (gchar *)); tmp_argv[in_argc] = NULL; argc = in_argc; argv = tmp_argv; /* This updates argv and argc so that they start at the first non-command * token. */ match = cli_context_find_command (ctx, &argv, &argc, &action); if (match == COMMAND_TRIE_MATCH_ACTION) { gboolean help; gboolean need_io; command_t *cmd; /* Include one command token as a workaround for the bug that * the option parser does not parse commands starting with a * flag properly (e.g. "-p foo arg1"). Will be skipped by the * command utils. */ cmd = command_new (action->argdefs, argc + 1, argv - 1); if (cmd) { if (command_flag_boolean_get (cmd, "help", &help) && help) { /* Help flag passed, bypass action and show help */ /* FIXME(g): select aliasnames list if it's an alias */ help_command (ctx, cli_context_command_names (ctx), in_argv, in_argc, CMD_TYPE_COMMAND); } else if (cli_context_command_runnable (ctx, action)) { /* All fine, run the command */ command_name_set (cmd, action->name); cli_context_loop_suspend (ctx); need_io = action->callback (ctx, cmd); if (!need_io) { cli_context_loop_resume (ctx); } } command_free (cmd); } } else { /* Call help to print the "no such command" error */ help_command (ctx, cli_context_command_names (ctx), in_argv, in_argc, CMD_TYPE_COMMAND); } }
void command_dispatch (cli_infos_t *infos, gint in_argc, gchar **in_argv) { command_action_t *action; command_trie_match_type_t match; gint argc; gchar **argv; gboolean auto_complete; /* The arguments will be updated by command_trie_find. */ argc = in_argc; argv = in_argv; auto_complete = configuration_get_boolean (infos->config, "AUTO_UNIQUE_COMPLETE"); match = command_trie_find (infos->commands, &argv, &argc, auto_complete, &action); if (match == COMMAND_TRIE_MATCH_ACTION) { gboolean help; gboolean need_io; command_context_t *ctx; /* Include one command token as a workaround for the bug that * the option parser does not parse commands starting with a * flag properly (e.g. "-p foo arg1"). Will be skipped by the * command utils. */ ctx = init_context_from_args (action->argdefs, argc + 1, argv - 1); ctx->name = g_strdup (action->name); if (command_flag_boolean_get (ctx, "help", &help) && help) { /* Help flag passed, bypass action and show help */ /* FIXME(g): select aliasnames list if it's an alias */ help_command (infos, infos->cmdnames, in_argv, in_argc, CMD_TYPE_COMMAND); } else if (command_runnable (infos, action)) { /* All fine, run the command */ cli_infos_loop_suspend (infos); need_io = action->callback (infos, ctx); if (!need_io) { cli_infos_loop_resume (infos); } } command_context_free (ctx); } else { /* Call help to print the "no such command" error */ help_command (infos, infos->cmdnames, in_argv, in_argc, CMD_TYPE_COMMAND); } }
void xbox_base_state::xbox_debug_commands(int ref, int params, const char **param) { if (params < 1) return; if (strcmp("dump_string", param[0]) == 0) dump_string_command(ref, params - 1, param + 1); else if (strcmp("dump_process", param[0]) == 0) dump_process_command(ref, params - 1, param + 1); else if (strcmp("dump_list", param[0]) == 0) dump_list_command(ref, params - 1, param + 1); else if (strcmp("dump_dpc", param[0]) == 0) dump_dpc_command(ref, params - 1, param + 1); else if (strcmp("dump_timer", param[0]) == 0) dump_timer_command(ref, params - 1, param + 1); else if (strcmp("curthread", param[0]) == 0) curthread_command(ref, params - 1, param + 1); else if (strcmp("irq", param[0]) == 0) generate_irq_command(ref, params - 1, param + 1); else if (strcmp("nv2a_combiners", param[0]) == 0) nv2a_combiners_command(ref, params - 1, param + 1); else if (strcmp("waitvblank", param[0]) == 0) waitvblank_command(ref, params - 1, param + 1); else if (strcmp("grab_texture", param[0]) == 0) grab_texture_command(ref, params - 1, param + 1); else if (strcmp("grab_vprog", param[0]) == 0) grab_vprog_command(ref, params - 1, param + 1); else if (strcmp("vprogdis", param[0]) == 0) vprogdis_command(ref, params - 1, param + 1); else help_command(ref, params - 1, param + 1); }
void options_parse(int argc, char *argv[]) { int option_index= 0; int option_rv; memcached_programs_help_st help_options[]= { {0}, }; static struct option long_options[]= { {(OPTIONSTRING)"version", no_argument, NULL, OPT_VERSION}, {(OPTIONSTRING)"help", no_argument, NULL, OPT_HELP}, {(OPTIONSTRING)"verbose", no_argument, &opt_verbose, OPT_VERBOSE}, {(OPTIONSTRING)"debug", no_argument, &opt_verbose, OPT_DEBUG}, {(OPTIONSTRING)"servers", required_argument, NULL, OPT_SERVERS}, {(OPTIONSTRING)"flag", no_argument, &opt_displayflag, OPT_FLAG}, {(OPTIONSTRING)"hash", required_argument, NULL, OPT_HASH}, {(OPTIONSTRING)"binary", no_argument, NULL, OPT_BINARY}, {0, 0, 0, 0}, }; while (1) { option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index); if (option_rv == -1) break; switch (option_rv) { case 0: break; case OPT_BINARY: opt_binary = 1; break; case OPT_VERBOSE: /* --verbose or -v */ opt_verbose = OPT_VERBOSE; break; case OPT_DEBUG: /* --debug or -d */ opt_verbose = OPT_DEBUG; break; case OPT_VERSION: /* --version or -V */ version_command(PROGRAM_NAME); break; case OPT_HELP: /* --help or -h */ help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options); break; case OPT_SERVERS: /* --servers or -s */ opt_servers= strdup(optarg); break; case OPT_HASH: opt_hash= strdup(optarg); break; case '?': /* getopt_long already printed an error message. */ exit(1); default: abort(); } } }
void help() { //print command-specific help if available, otherwise list commands if (help_command(get_arg(1))) { return; } std::stringstream ss; bool show_unavail = show_unavailable_ || get_arg(1) == "all"; for (typename command_map::value_type i : command_map_) { if (show_unavail || is_enabled(i.second)) { ss << i.first; //if (!i.second.usage.empty()) { // ss << " " << i.second.usage; //} //uncomment the above to display usage information in command list //which might clutter it somewhat if (!i.second.flags.empty()) { ss << " (" << i.second.flags << ") "; } ss << "; "; } } utils::string_map symbols; symbols["flags_description"] = get_flags_description(); symbols["list_of_commands"] = ss.str(); symbols["help_command"] = cmd_prefix_ + "help"; print(_("help"), VGETTEXT("Available commands $flags_description:\n$list_of_commands", symbols)); print(_("help"), VGETTEXT("Type $help_command <command> for more info.", symbols)); }
gboolean cli_help (cli_context_t *ctx, command_t *cmd) { cmd_type_t cmdtype; GList *names; gint num_args; gboolean alias; num_args = command_arg_count (cmd); if (command_flag_boolean_get (cmd, "alias", &alias) && alias) { names = cli_context_alias_names (ctx); cmdtype = CMD_TYPE_ALIAS; } else { names = cli_context_command_names (ctx); cmdtype = CMD_TYPE_COMMAND; } /* No argument, display the list of commands */ if (num_args == 0) { help_list (names, NULL, cmdtype); } else { help_command (ctx, names, command_argv_get (cmd), num_args, cmdtype); } /* No data pending */ return FALSE; }
int Reader(CommandBase* commands [], int num_commands, int argc, const char** argv) { std::vector<const char*> inputs; CommandBase* last_command = NULL; CommandHelp help_command(commands,num_commands); int command_count = 0; bool command_chosen = false; for(int i=1; i<argc; i++) { double tmp; if(argv[i][0] == '-' && !string_is_double(argv[i],tmp)) { //command if(string_is_double(argv[i],tmp)) command_chosen = false; //check for help queries first if(0 == strcmp("help",&argv[i][1])) { if(last_command != NULL) { int res = DoCommand(last_command,inputs); if(res <= 0) return res; } last_command = &help_command; command_count++; command_chosen = true; } //search through rest of commands for(int k=0; k<num_commands && !command_chosen; k++) { if(0 == strcmp(commands[k]->Name(),&argv[i][1])) { //we've found a command if(last_command != NULL) { int res = DoCommand(last_command,inputs); if(res <= 0) return res; } last_command = commands[k]; command_chosen = true; command_count++; } } if(!command_chosen) { printf("Unknown command %s\n", argv[i]); PrintCommands(commands, num_commands); return -1; } } else { //add an argument inputs.push_back(argv[i]); command_chosen = false; } } if(command_count == 0) { if(inputs.size() > 0) cout<<"Some stray elements were given on the command line"<<endl; PrintCommands(commands, num_commands); } else { assert(last_command != NULL); int res = DoCommand(last_command,inputs); if(res <= 0) return res; } return 0; }
static int_fast8_t help_cmd() { if((data.cmdargtoken[1].type == 3)||(data.cmdargtoken[1].type == 4)||(data.cmdargtoken[1].type == 5)) help_command(data.cmdargtoken[1].val.string); else list_commands(); return 0; }
/*! * @brief IRQハンドラ * @param[in] なし * @param[out] なし * @return なし * @note UART関連のレジスタであるIIRレジスタから割込みタイプの取得 * (IIRレジスタは下位5ビットで割込みタイプを保持している) * シリアル受信割込み : 0x2 * タイムアウト割込み(シリアル受信割込みを有効化すると同時に有効化される) : 0x6 */ void uart_handler(void) { unsigned char c; static char buf[32]; static int len; int it_type; it_type = (REG8_READ(UIIR) & 0x3E) >> 1; if (it_type == 2 || it_type == 6) { c = getc(); /* 受信FIFOからデータを読み出す事によって,割込み要因をクリア */ if (c != '\n') { buf[len++] = c; } else { buf[len++] = '\0'; /* echoコマンドの場合 */ if (!strncmp(buf, "echo ", 5)) { echo_command(buf); /* echoコマンド(標準出力にテキストを出力する)呼び出し */ } /* helpコマンドの場合 */ else if (!strncmp(buf, "help", 4)) { help_command(&buf[4]); /* helpコマンド呼び出し */ } #ifdef TSK_LIBRARY /* runコマンドの場合 */ else if (!strncmp(buf, "run", 3)) { run_command(&buf[3]); /* runコマンド(タスクセットの起動)呼び出し */ } #endif /* sendlogの場合 */ else if (!strncmp(buf, "sendlog", 7)) { sendlog_command(); /* sendlogコマンド(xmodem送信モード)呼び出し */ } /* 本システムに存在しないコマンド */ else { puts("command unknown.\n"); } puts("> "); len = 0; } } else { DEBUG_LEVEL1_OUTMSG(" not uart3 handler : uart_handler().\n"); } }
void options_parse(int argc, char *argv[]) { int option_index= 0; int option_rv; memcached_programs_help_st help_options[]= { {0}, }; static struct option long_options[]= { {"version", no_argument, NULL, OPT_VERSION}, {"help", no_argument, NULL, OPT_HELP}, {"verbose", no_argument, &opt_verbose, OPT_VERBOSE}, {"debug", no_argument, &opt_verbose, OPT_DEBUG}, {0, 0, 0, 0}, }; while (1) { option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index); if (option_rv == -1) break; switch (option_rv) { case 0: break; case OPT_VERBOSE: /* --verbose or -v */ opt_verbose = OPT_VERBOSE; break; case OPT_DEBUG: /* --debug or -d */ opt_verbose = OPT_DEBUG; break; case OPT_VERSION: /* --version or -V */ version_command(PROGRAM_NAME); break; case OPT_HELP: /* --help or -h */ help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options); break; case '?': /* getopt_long already printed an error message. */ exit(1); default: abort(); } } }
static void options_parse(int argc, char *argv[]) { memcached_programs_help_st help_options[]= { {0}, }; int option_index= 0; int option_rv; while (1) { option_rv= getopt_long(argc, argv, "Vhvds:a", long_options, &option_index); if (option_rv == -1) break; switch (option_rv) { case 0: break; case OPT_VERBOSE: /* --verbose or -v */ opt_verbose = OPT_VERBOSE; break; case OPT_DEBUG: /* --debug or -d */ opt_verbose = OPT_DEBUG; break; case OPT_VERSION: /* --version or -V */ version_command(PROGRAM_NAME); break; case OPT_HELP: /* --help or -h */ help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options); break; case OPT_SERVERS: /* --servers or -s */ opt_servers= strdup(optarg); break; case OPT_ANALYZE: /* --analyze or -a */ opt_analyze= OPT_ANALYZE; break; case '?': /* getopt_long already printed an error message. */ exit(1); default: abort(); } } }
void options_parse(int argc, char *argv[]) { int option_index= 0; int option_rv; memcached_programs_help_st help_options[]= { {0}, }; static struct option long_options[]= { {"version", no_argument, NULL, OPT_VERSION}, {"help", no_argument, NULL, OPT_HELP}, {"verbose", no_argument, &opt_verbose, OPT_VERBOSE}, {"debug", no_argument, &opt_verbose, OPT_DEBUG}, {"servers", required_argument, NULL, OPT_SERVERS}, {"flag", required_argument, NULL, OPT_FLAG}, {"expire", required_argument, NULL, OPT_EXPIRE}, {"set", no_argument, NULL, OPT_SET}, {"add", no_argument, NULL, OPT_ADD}, {"replace", no_argument, NULL, OPT_REPLACE}, {"hash", required_argument, NULL, OPT_HASH}, {"binary", no_argument, NULL, OPT_BINARY}, {0, 0, 0, 0}, }; while (1) { option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index); if (option_rv == -1) break; switch (option_rv) { case 0: break; case OPT_BINARY: opt_binary = 1; break; case OPT_VERBOSE: /* --verbose or -v */ opt_verbose = OPT_VERBOSE; break; case OPT_DEBUG: /* --debug or -d */ opt_verbose = OPT_DEBUG; break; case OPT_VERSION: /* --version or -V */ version_command(PROGRAM_NAME); break; case OPT_HELP: /* --help or -h */ help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options); break; case OPT_SERVERS: /* --servers or -s */ opt_servers= strdup(optarg); break; case OPT_FLAG: /* --flag */ opt_flags= (uint32_t)strtol(optarg, (char **)NULL, 16); break; case OPT_EXPIRE: /* --expire */ opt_expires= (time_t)strtoll(optarg, (char **)NULL, 10); break; case OPT_SET: opt_method= OPT_SET; break; case OPT_REPLACE: opt_method= OPT_REPLACE; break; case OPT_ADD: opt_method= OPT_ADD; case OPT_HASH: opt_hash= strdup(optarg); break; case '?': /* getopt_long already printed an error message. */ exit(1); default: abort(); } } }
int main(int argc, char *argv[]) { memcached_return rc; memcached_st *memc; memcached_stat_st *stat; memcached_server_st *servers; memcached_server_st *server_list; memcached_analysis_st *report; options_parse(argc, argv); if (!opt_servers) { char *temp; if ((temp= getenv("MEMCACHED_SERVERS"))) opt_servers= strdup(temp); else { fprintf(stderr, "No Servers provided\n\n"); help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, 0); exit(1); } } memc= memcached_create(NULL); servers= memcached_servers_parse(opt_servers); memcached_server_push(memc, servers); memcached_server_list_free(servers); stat= memcached_stat(memc, NULL, &rc); if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_SOME_ERRORS) { printf("Failure to communicate with servers (%s)\n", memcached_strerror(memc, rc)); exit(1); } server_list= memcached_server_list(memc); if (opt_analyze) { report= memcached_analyze(memc, stat, &rc); if (rc != MEMCACHED_SUCCESS || report == NULL) { printf("Failure to analyze servers (%s)\n", memcached_strerror(memc, rc)); exit(1); } print_analysis_report(memc, report, server_list); free(report); } else print_server_listing(memc, stat, server_list); free(stat); free(opt_servers); memcached_free(memc); return 0; }
/** * \brief Main method */ int main(int argc, char *argv[]) { debug(LOG_DEBUG, DEBUG_LOG, 0, "mount utility"); int c; int longindex; putenv((char *)"POSIXLY_CORRECT=1"); // cast to silence compiler while (EOF != (c = getopt_long(argc, argv, "c:dh", longopts, &longindex))) { switch (c) { case 'c': Configuration::set_default(std::string(optarg)); break; case 'd': debuglevel = LOG_DEBUG; break; case 'h': usage(argv[0]); return EXIT_SUCCESS; case 'n': dryrun = true; break; case 'f': decimal = true; break; case 'w': await_completion = true; break; case 1: switch (longindex) { } break; } } // next argument must be the command if (argc <= optind) { throw std::runtime_error("missing command argument"); } std::string command(argv[optind++]); // call the command specific functions if (command == "help") { return help_command(); } // the other commands need a repository astro::module::Repository repository; astro::module::Devices devices(repository); // list command if (command == "list") { return list_command(devices); } // other commands need a mount url if (argc <= optind) { throw std::runtime_error("missing mount URL"); } DeviceName mountname(argv[optind++]); if (!mountname.hasType(DeviceName::Mount)) { throw std::runtime_error("not a mount device name"); } debug(LOG_DEBUG, DEBUG_LOG, 0, "mount device name: %s", mountname.toString().c_str()); // use the Devices class to get the mount associated with this name MountPtr mount = devices.getMount(mountname); if (command == "get") { return get_command(mount); } if (command == "cancel") { return cancel_command(mount); } if (command == "wait") { return wait_command(mount, true); } if (command == "set") { if (argc < optind + 2) { throw std::runtime_error("two angle arguments missing"); } RaDec radec; radec.ra() = Angle::hms_to_angle(argv[optind++]); radec.dec() = Angle::dms_to_angle(argv[optind++]); return set_command(mount, radec); } throw std::runtime_error("unknown command"); }
void print_usage() { help_command(get_cmd()); }
static void options_parse(int argc, char *argv[]) { int option_index= 0; int option_rv; memcached_programs_help_st help_options[]= { {0}, }; static struct option long_options[]= { {(OPTIONSTRING)"version", no_argument, NULL, OPT_VERSION}, {(OPTIONSTRING)"help", no_argument, NULL, OPT_HELP}, {(OPTIONSTRING)"verbose", no_argument, &opt_verbose, OPT_VERBOSE}, {(OPTIONSTRING)"debug", no_argument, &opt_verbose, OPT_DEBUG}, {(OPTIONSTRING)"servers", required_argument, NULL, OPT_SERVERS}, {(OPTIONSTRING)"flag", required_argument, NULL, OPT_FLAG}, {(OPTIONSTRING)"expire", required_argument, NULL, OPT_EXPIRE}, {(OPTIONSTRING)"set", no_argument, NULL, OPT_SET}, {(OPTIONSTRING)"add", no_argument, NULL, OPT_ADD}, {(OPTIONSTRING)"replace", no_argument, NULL, OPT_REPLACE}, {(OPTIONSTRING)"hash", required_argument, NULL, OPT_HASH}, {(OPTIONSTRING)"binary", no_argument, NULL, OPT_BINARY}, {(OPTIONSTRING)"username", required_argument, NULL, OPT_USERNAME}, {(OPTIONSTRING)"password", required_argument, NULL, OPT_PASSWD}, {0, 0, 0, 0}, }; while (1) { option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index); if (option_rv == -1) break; switch (option_rv) { case 0: break; case OPT_BINARY: opt_binary = 1; break; case OPT_VERBOSE: /* --verbose or -v */ opt_verbose = OPT_VERBOSE; break; case OPT_DEBUG: /* --debug or -d */ opt_verbose = OPT_DEBUG; break; case OPT_VERSION: /* --version or -V */ version_command(PROGRAM_NAME); break; case OPT_HELP: /* --help or -h */ help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options); break; case OPT_SERVERS: /* --servers or -s */ opt_servers= strdup(optarg); break; case OPT_FLAG: /* --flag */ { bool strtol_error; opt_flags= (uint32_t)strtol_wrapper(optarg, 16, &strtol_error); if (strtol_error == true) { fprintf(stderr, "Bad value passed via --flag\n"); exit(1); } break; } case OPT_EXPIRE: /* --expire */ { bool strtol_error; opt_expires= (time_t)strtol_wrapper(optarg, 16, &strtol_error); if (strtol_error == true) { fprintf(stderr, "Bad value passed via --flag\n"); exit(1); } } case OPT_SET: opt_method= OPT_SET; break; case OPT_REPLACE: opt_method= OPT_REPLACE; break; case OPT_ADD: opt_method= OPT_ADD; break; case OPT_HASH: opt_hash= strdup(optarg); break; case OPT_USERNAME: opt_username= optarg; break; case OPT_PASSWD: opt_passwd= optarg; break; case '?': /* getopt_long already printed an error message. */ exit(1); default: abort(); } } }
void options_parse(int argc, char *argv[]) { memcached_programs_help_st help_options[]= { {0}, }; static struct option long_options[]= { {(OPTIONSTRING)"version", no_argument, NULL, OPT_VERSION}, {(OPTIONSTRING)"help", no_argument, NULL, OPT_HELP}, {(OPTIONSTRING)"verbose", no_argument, &opt_verbose, OPT_VERBOSE}, {(OPTIONSTRING)"debug", no_argument, &opt_verbose, OPT_DEBUG}, {(OPTIONSTRING)"servers", required_argument, NULL, OPT_SERVERS}, {(OPTIONSTRING)"expire", required_argument, NULL, OPT_EXPIRE}, {(OPTIONSTRING)"binary", no_argument, NULL, OPT_BINARY}, {(OPTIONSTRING)"username", required_argument, NULL, OPT_USERNAME}, {(OPTIONSTRING)"password", required_argument, NULL, OPT_PASSWD}, {0, 0, 0, 0}, }; int option_index= 0; int option_rv; while (1) { option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index); if (option_rv == -1) break; switch (option_rv) { case 0: break; case OPT_BINARY: opt_binary = 1; break; case OPT_VERBOSE: /* --verbose or -v */ opt_verbose = OPT_VERBOSE; break; case OPT_DEBUG: /* --debug or -d */ opt_verbose = OPT_DEBUG; break; case OPT_VERSION: /* --version or -V */ version_command(PROGRAM_NAME); break; case OPT_HELP: /* --help or -h */ help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options); break; case OPT_SERVERS: /* --servers or -s */ opt_servers= strdup(optarg); break; case OPT_EXPIRE: /* --expire */ opt_expire= (time_t)strtoll(optarg, (char **)NULL, 10); break; case OPT_USERNAME: opt_username= optarg; break; case OPT_PASSWD: opt_passwd= optarg; break; case '?': /* getopt_long already printed an error message. */ exit(1); default: abort(); } } }
void options_parse(int argc, char *argv[]) { memcached_programs_help_st help_options[]= { {0}, }; static struct option long_options[]= { {"concurrency", required_argument, NULL, OPT_SLAP_CONCURRENCY}, {"debug", no_argument, &opt_verbose, OPT_DEBUG}, {"execute-number", required_argument, NULL, OPT_SLAP_EXECUTE_NUMBER}, {"flag", no_argument, &opt_displayflag, OPT_FLAG}, {"flush", no_argument, &opt_flush, OPT_FLUSH}, {"help", no_argument, NULL, OPT_HELP}, {"initial-load", required_argument, NULL, OPT_SLAP_INITIAL_LOAD}, /* Number to load initially */ {"non-blocking", no_argument, &opt_non_blocking_io, OPT_SLAP_NON_BLOCK}, {"servers", required_argument, NULL, OPT_SERVERS}, {"tcp-nodelay", no_argument, &opt_tcp_nodelay, OPT_SLAP_TCP_NODELAY}, {"test", required_argument, NULL, OPT_SLAP_TEST}, {"verbose", no_argument, &opt_verbose, OPT_VERBOSE}, {"version", no_argument, NULL, OPT_VERSION}, {"binary", no_argument, NULL, OPT_BINARY}, {0, 0, 0, 0}, }; int option_index= 0; int option_rv; while (1) { option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index); if (option_rv == -1) break; switch (option_rv) { case 0: break; case OPT_BINARY: opt_binary = 1; break; case OPT_VERBOSE: /* --verbose or -v */ opt_verbose = OPT_VERBOSE; break; case OPT_DEBUG: /* --debug or -d */ opt_verbose = OPT_DEBUG; break; case OPT_VERSION: /* --version or -V */ version_command(PROGRAM_NAME); break; case OPT_HELP: /* --help or -h */ help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options); break; case OPT_SERVERS: /* --servers or -s */ opt_servers= strdup(optarg); break; case OPT_SLAP_TEST: if (!strcmp(optarg, "get")) opt_test= GET_TEST ; else if (!strcmp(optarg, "set")) opt_test= SET_TEST; else { fprintf(stderr, "Your test, %s, is not a known test\n", optarg); exit(1); } break; case OPT_SLAP_CONCURRENCY: opt_concurrency= strtol(optarg, (char **)NULL, 10); case OPT_SLAP_EXECUTE_NUMBER: opt_execute_number= strtol(optarg, (char **)NULL, 10); break; case OPT_SLAP_INITIAL_LOAD: opt_createial_load= strtol(optarg, (char **)NULL, 10); break; case '?': /* getopt_long already printed an error message. */ exit(1); default: abort(); } } if (opt_test == GET_TEST && opt_createial_load == 0) opt_createial_load= DEFAULT_INITIAL_LOAD; if (opt_execute_number == 0) opt_execute_number= DEFAULT_EXECUTE_NUMBER; if (opt_concurrency == 0) opt_concurrency= DEFAULT_CONCURRENCY; }
/* * void execute_commands() * * Processes commands until the QUIT command is entered * */ void execute_commands() { char buffer[MAX_INPUT_STRING]; int num_chars = 0; while ( TRUE ) { printf( PROMPT ); scanf("%s", buffer); num_chars = strlen(buffer); if ( is_valid_number( buffer ) ) { push( atoi(buffer) ); continue; } if ( num_chars > 1 ) { printf( BAD_INPUT_MSG ); continue; } if ( tolower( buffer[0] ) == QUIT ) return; /* Remove the TODO_MSG as you implement and test commands */ switch( tolower( buffer[0] ) ){ case ADD: add_command(); break; case SUB: sub_command(); break; case MULT: mult_command(); break; case DIV: div_command(); break; case MOD: mod_command(); break; case AND: and_command(); break; case OR: or_command(); break; case XOR: xor_command(); break; case NOT: not_command(); break; case FACTORIAL: factorial_command(); break; case TOGGLE_HEX: toggle_hex(); break; case TOGGLE_BUG: toggle_bug(); break; case PRINT_STACK: print_stack(); break; case PRINT_TOP: print_top(); break; case CLEAR: clear_command(); break; case EXCHANGE: exchange_command(); break; case POP: pop(); break; case HELP: help_command(); break; default: printf( BAD_INPUT_MSG ); } } }