static int allow_long_options(char *arg) { static int result = -1; if (result < 0) { char *env = getenv("MAWK_LONG_OPTIONS"); result = 0; if (env != 0) { switch (*env) { default: case 'e': /* error */ bad_option(arg); break; case 'w': /* warn */ errmsg(0, "ignored option: %s", arg); break; case 'i': /* ignore */ break; case 'a': /* allow */ result = 1; break; } } else { bad_option(arg); } } return result; }
/** Parse the command line, return the index of the first non-option argument. *@throws bad_option if there is a parsing error or unknown option. */ int parse() { int arg = 1; for (; arg < argc_ && argv_[arg][0] == '-'; ++arg) { opts::iterator i = opts_.begin(); while (i != opts_.end() && !(*i)->parse(argc_, argv_, arg)) ++i; if (i == opts_.end()) throw bad_option(std::string("unknown option ") + argv_[arg]); } if (help_) throw bad_option(""); return arg; }
static void rdiff_options(poptContext opcon) { int c; char const *a; while ((c = poptGetNextOpt(opcon)) != -1) { switch (c) { case 'h': help(); exit(RS_DONE); case 'V': rdiff_show_version(); exit(RS_DONE); case 'v': if (!rs_supports_trace()) { rs_error("library does not support trace"); } rs_trace_set_level(RS_LOG_DEBUG); break; case OPT_GZIP: case OPT_BZIP2: if ((a = poptGetOptArg(opcon))) { int l = atoi(a); if (c == OPT_GZIP) gzip_level = l; else bzip2_level = l; } else { if (c == OPT_GZIP) gzip_level = -1; /* library default */ else bzip2_level = 9; /* demand the best */ } rs_error("sorry, compression is not really implemented yet"); exit(RS_UNIMPLEMENTED); default: bad_option(opcon, c); } } }
int eval_options (int argc, char **argv, struct target_opts* defaults, const char** exe_opts) { const char opt_timeout[] = "-t"; const char opt_data_dir[] = "-d"; const char opt_t_flags[] = "-x"; const char opt_compat[] = "--compat"; const char opt_exit[] = "--exit"; const char opt_help[] = "--help"; const char opt_ignore[] = "--ignore"; const char opt_nocompat[] = "--nocompat"; const char opt_signal[] = "--signal"; const char opt_sleep[] = "--sleep"; const char opt_ulimit[] = "--ulimit"; const char opt_verbose[] = "--verbose"; const char opt_warn[] = "--warn"; int i; assert (0 != argv); assert (0 != defaults); memset (defaults, 0, sizeof (target_opts)); /* The chain of preprocesor logic below initializes the defaults->c_warn and defaults->l_warn values. */ #ifdef __GNUG__ parse_warn_opts ("Gcc", defaults); #elif defined (__HP_aCC) parse_warn_opts ("Acc", defaults); #elif defined (__IBMCPP__) parse_warn_opts ("Xlc", defaults); #elif defined (__SUNPRO_CC) parse_warn_opts ("Sunpro", defaults); #elif defined (SNI) parse_warn_opts ("Cds", defaults); #elif defined (__APOGEE__) /* EDG variant that doesn't define __EDG__. */ parse_warn_opts ("Como", defaults); /* The following are EDG variants, that define __EDG__ */ #elif defined (__DECCXX) parse_warn_opts ("Cxx", defaults); #elif defined (_SGI_COMPILER_VERSION) parse_warn_opts ("Mipspro", defaults); #elif defined (__INTEL_COMPILER) parse_warn_opts ("Icc", defaults); /* So we need to check for __EDG__ after we check for them. */ #elif defined (__EDG__) parse_warn_opts ("Eccp", defaults); #endif if (1 == argc || '-' != argv [1][0]) return 1; for (i = 1; i < argc && '-' == argv [i][0]; ++i) { /* the name of the option being processed */ const char* optname = argv [i]; /* the option's argument, if any */ const char* optarg = 0; char* end = 0; switch (argv [i][1]) { case '?': /* display help and exit with status of 0 */ case 'h': show_usage (0); case 'r': ++i; /* Ignore -r option (makefile compat) */ break; case 't': /* executable timeout in seconds */ optname = opt_timeout; optarg = get_short_val (argv, &i); if (optarg) { if (!isdigit (*optarg)) bad_value (optname, optarg); errno = 0; defaults->timeout = strtol (optarg, &end, 10); if (*end || errno) bad_value (optname, optarg); } else missing_value (optname); break; case 'd': /* directory containing example reference files */ optname = opt_data_dir; defaults->data_dir = get_short_val (argv, &i); if (!defaults->data_dir) missing_value (optname); break; case 'v': /* enable verbose mode */ optname = opt_verbose; ++defaults->verbose; break; case 'x': /* command line options to pass to targets */ optname = opt_t_flags; *exe_opts = get_short_val (argv, &i); if (!*exe_opts) missing_value (optname); break; case '-': /* long options */ { const size_t arglen = strlen (argv [i]); /* abort processing on --, eat token */ if ('\0' == argv [i][2]) return i+1; if ( sizeof opt_compat - 1 == arglen && !memcmp (opt_compat, argv [i], sizeof opt_compat)) { /* enter compatibility mode */ defaults->compat = 1; break; } else if ( sizeof opt_nocompat - 1 == arglen && !memcmp (opt_nocompat, argv [i], sizeof opt_nocompat)) { /* exit compatibility mode */ defaults->compat = 0; break; } else if ( sizeof opt_exit - 1 <= arglen && !memcmp (opt_exit, argv [i], sizeof opt_exit - 1)) { /* exit immediately with the specified status */ optname = opt_exit; optarg = get_long_val (argv, &i, sizeof opt_exit - 1); if (optarg && *optarg) { if (!isdigit (*optarg)) bad_value (optname, optarg); errno = 0; const long code = strtol (optarg, &end, 10); if ('\0' == *end && !errno) exit (code); } } else if ( sizeof opt_help - 1 == arglen && !memcmp (opt_help, argv [i], sizeof opt_help - 1)) { /* display help and exit with status of 0 */ optname = opt_help; show_usage (0); break; } else if ( sizeof opt_sleep - 1 <= arglen && !memcmp (opt_sleep, argv [i], sizeof opt_sleep - 1)) { /* sleep for the specified number of seconds */ optname = opt_sleep; optarg = get_long_val (argv, &i, sizeof opt_sleep - 1); if (optarg && *optarg) { if (!isdigit (*optarg)) bad_value (optname, optarg); errno = 0; const long nsec = strtol (optarg, &end, 10); if ('\0' == *end && 0 <= nsec && !errno) { rw_sleep (nsec); break; } } } else if ( sizeof opt_signal - 1 <= arglen && !memcmp (opt_signal, argv [i], sizeof opt_signal - 1)) { /* send ourselves the specified signal */ optname = opt_signal; optarg = get_long_val (argv, &i, sizeof opt_signal - 1); if (optarg && *optarg) { const int signo = get_signo (optarg); if (0 <= signo) { if (0 > raise (signo)) terminate (1, "raise(%s) failed: %s\n", get_signame (signo), strerror (errno)); break; } } } else if ( sizeof opt_ignore - 1 <= arglen && !memcmp (opt_ignore, argv [i], sizeof opt_ignore - 1)) { /* ignore the specified signal */ optname = opt_ignore; optarg = get_long_val (argv, &i, sizeof opt_ignore - 1); if (optarg && *optarg) { const int signo = get_signo (optarg); if (0 <= signo) { if (rw_signal (signo, 0 /* SIG_IGN */)) terminate (1, "rw_signal(%s, ...) failed: %s\n", get_signame (signo), strerror (errno)); break; } } } else if ( sizeof opt_ulimit - 1 <= arglen && !memcmp (opt_ulimit, argv [i], sizeof opt_ulimit - 1)) { /* set child process resource utilization limits */ optname = opt_ulimit; optarg = get_long_val (argv, &i, sizeof opt_ulimit - 1); if (optarg && *optarg) { if (!parse_limit_opts (optarg, defaults)) { break; } } } else if ( sizeof opt_warn - 1 <= arglen && !memcmp (opt_warn, argv [i], sizeof opt_warn - 1)) { /* set compiler warning mode */ optname = opt_warn; optarg = get_long_val (argv, &i, sizeof opt_warn - 1); if (optarg && *optarg) { if (!parse_warn_opts (optarg, defaults)) { break; } } } /* fall through */ } default: if (optarg) { if (*optarg) bad_value (optname, optarg); else missing_value (optname); } if (argv [i]) bad_option (argv [i]); else missing_value (optname); } } return i; }
static void process_cmdline(int argc, char **argv) { int i, j, nextarg; char *optArg; char *optNext; PFILE dummy; /* starts linked list of filenames */ PFILE *tail = &dummy; size_t length; if (argc <= 1) usage(); for (i = 1; i < argc && argv[i][0] == '-'; i = nextarg) { if (argv[i][1] == 0) /* - alone */ { if (!pfile_name) no_program(); break; /* the for loop */ } /* safe to look at argv[i][2] */ /* * Check for "long" options and decide how to handle them. */ if (strlen(argv[i]) > 2 && !strncmp(argv[i], "--", (size_t) 2)) { if (!allow_long_options(argv[i])) { nextarg = i + 1; continue; } } if (argv[i][2] == 0) { if (i == argc - 1 && argv[i][1] != '-') { if (strchr("WFvf", argv[i][1])) { errmsg(0, "option %s lacks argument", argv[i]); mawk_exit(2); } bad_option(argv[i]); } optArg = argv[i + 1]; nextarg = i + 2; } else { /* argument glued to option */ optArg = &argv[i][2]; nextarg = i + 1; } switch (argv[i][1]) { case 'W': for (j = 0; j < (int) strlen(optArg); j = (int) (optNext - optArg)) { switch (parse_w_opt(optArg + j, &optNext)) { case W_VERSION: print_version(); break; #if USE_BINMODE case W_BINMODE: if (haveValue(optNext)) { set_binmode(atoi(optNext + 1)); optNext = skipValue(optNext); } else { errmsg(0, "missing value for -W binmode"); mawk_exit(2); } break; #endif case W_DUMP: dump_code_flag = 1; break; case W_EXEC: if (pfile_name) { errmsg(0, "-W exec is incompatible with -f"); mawk_exit(2); } else if (nextarg == argc) { no_program(); } if (haveValue(optNext)) { pfile_name = optNext + 1; i = nextarg; } else { pfile_name = argv[nextarg]; i = nextarg + 1; } goto no_more_opts; case W_INTERACTIVE: interactive_flag = 1; setbuf(stdout, (char *) 0); break; case W_POSIX_SPACE: posix_space_flag = 1; break; case W_RANDOM: if (haveValue(optNext)) { int x = atoi(optNext + 1); CELL c[2]; memset(c, 0, sizeof(c)); c[1].type = C_DOUBLE; c[1].dval = (double) x; /* c[1] is input, c[0] is output */ bi_srand(c + 1); optNext = skipValue(optNext); } else { errmsg(0, "missing value for -W random"); mawk_exit(2); } break; case W_SPRINTF: if (haveValue(optNext)) { int x = atoi(optNext + 1); if (x > (int) sizeof(string_buff)) { if (sprintf_buff != string_buff && sprintf_buff != 0) { zfree(sprintf_buff, (size_t) (sprintf_limit - sprintf_buff)); } sprintf_buff = (char *) zmalloc((size_t) x); sprintf_limit = sprintf_buff + x; } optNext = skipValue(optNext); } else { errmsg(0, "missing value for -W sprintf"); mawk_exit(2); } break; case W_HELP: /* FALLTHRU */ case W_USAGE: usage(); /* NOTREACHED */ break; case W_UNKNOWN: errmsg(0, "vacuous option: -W %s", optArg + j); break; } while (*optNext == '=') { errmsg(0, "unexpected option value %s", optArg + j); optNext = skipValue(optNext); } } break; case 'v': if (!is_cmdline_assign(optArg)) { errmsg(0, "improper assignment: -v %s", optArg); mawk_exit(2); } break; case 'F': rm_escape(optArg, &length); /* recognize escape sequences */ cell_destroy(FS); FS->type = C_STRING; FS->ptr = (PTR) new_STRING1(optArg, length); cast_for_split(cellcpy(&fs_shadow, FS)); break; case '-': if (argv[i][2] != 0) { bad_option(argv[i]); } i++; goto no_more_opts; case 'f': /* first file goes in pfile_name ; any more go on a list */ if (!pfile_name) pfile_name = optArg; else { tail = tail->link = ZMALLOC(PFILE); tail->fname = optArg; } break; default: bad_option(argv[i]); } } no_more_opts: tail->link = (PFILE *) 0; pfile_list = dummy.link; if (pfile_name) { set_ARGV(argc, argv, i); scan_init((char *) 0); } else { /* program on command line */ if (i == argc) no_program(); set_ARGV(argc, argv, i + 1); #if defined(MSDOS) && ! HAVE_REARGV /* reversed quotes */ { char *p; for (p = argv[i]; *p; p++) if (*p == '\'') *p = '\"'; } #endif scan_init(argv[i]); /* #endif */ } }
void get_options(int argc, char **argv, OPTION *options, char *help) { int i, j, found; /* For each argument in the command line. */ i = 1; while(i < argc) { found = 0, j = 0; /* * Search for the current word in the option list. */ while(!found) { /* * If the option was not found. */ if(strcmp(argv[i], "-help") == 0) { display_options(argv, options, help); } else if(options[j].name == NULL) { bad_option(argv, i); display_options(argv, options, help); } /* * If the word is found in the option list. */ else if(strcmp(argv[i], options[j].name) == 0) { /* * Check the type, make sure we have another arg * coming if needed, eat up the next arg, set * the value of the parameter, and display help * if needed. */ found = 1; switch(options[j].type) { case OPT_INT: if(i + 1 >= argc) { bad_option(argv, i); display_options(argv, options, help); } *(int *)options[j].ptr = atoi(argv[i + 1]); i += 2; break; case OPT_DOUBLE: if(i + 1 >= argc) { bad_option(argv, i); display_options(argv, options, help); } *(double *)options[j].ptr = atof(argv[i + 1]); i += 2; break; case OPT_STRING: if(i + 1 >= argc) { bad_option(argv, i); display_options(argv, options, help); } *(char **)options[j].ptr = argv[i + 1]; i += 2; break; case OPT_SWITCH: *(int *)options[j].ptr = !*(int *)options[j].ptr; i += 1; break; case OPT_OTHER: if(((int (*)())options[j].ptr)(argv, argc, options, &i, j)) { bad_option(argv, i); display_options(argv, options, help); } break; default: break; } } j++; } } }
void setupRtsFlags(int *argc, char *argv[], int *rts_argc, char *rts_argv[]) { rtsBool error = rtsFalse; I_ mode; I_ arg, total_arg; setProgName (argv); total_arg = *argc; arg = 1; *argc = 1; *rts_argc = 0; // process arguments from the ghc_rts_opts global variable first. // (arguments from the GHCRTS environment variable and the command // line override these). { if (ghc_rts_opts != NULL) { splitRtsFlags(ghc_rts_opts, rts_argc, rts_argv); } } // process arguments from the GHCRTS environment variable next // (arguments from the command line override these). { char *ghc_rts = getenv("GHCRTS"); if (ghc_rts != NULL) { if (rtsOptsEnabled != rtsOptsNone) { splitRtsFlags(ghc_rts, rts_argc, rts_argv); } else { errorBelch("Warning: Ignoring GHCRTS variable as RTS options are disabled.\n Link with -rtsopts to enable them."); // We don't actually exit, just warn } } } // Split arguments (argv) into PGM (argv) and RTS (rts_argv) parts // argv[0] must be PGM argument -- leave in argv for (mode = PGM; arg < total_arg; arg++) { // The '--RTS' argument disables all future +RTS ... -RTS processing. if (strequal("--RTS", argv[arg])) { arg++; break; } // The '--' argument is passed through to the program, but // disables all further +RTS ... -RTS processing. else if (strequal("--", argv[arg])) { break; } else if (strequal("+RTS", argv[arg])) { if (rtsOptsEnabled != rtsOptsNone) { mode = RTS; } else { errorBelch("RTS options are disabled. Link with -rtsopts to enable them."); stg_exit(EXIT_FAILURE); } } else if (strequal("-RTS", argv[arg])) { mode = PGM; } else if (mode == RTS && *rts_argc < MAX_RTS_ARGS-1) { rts_argv[(*rts_argc)++] = argv[arg]; } else if (mode == PGM) { argv[(*argc)++] = argv[arg]; } else { barf("too many RTS arguments (max %d)", MAX_RTS_ARGS-1); } } // process remaining program arguments for (; arg < total_arg; arg++) { argv[(*argc)++] = argv[arg]; } argv[*argc] = (char *) 0; rts_argv[*rts_argc] = (char *) 0; // Process RTS (rts_argv) part: mainly to determine statsfile for (arg = 0; arg < *rts_argc; arg++) { if (rts_argv[arg][0] != '-') { fflush(stdout); errorBelch("unexpected RTS argument: %s", rts_argv[arg]); error = rtsTrue; } else { switch(rts_argv[arg][1]) { case '-': if (strequal("info", &rts_argv[arg][2])) { printRtsInfo(); stg_exit(0); } break; default: break; } if (rtsOptsEnabled != rtsOptsAll) { errorBelch("Most RTS options are disabled. Link with -rtsopts to enable them."); stg_exit(EXIT_FAILURE); } switch(rts_argv[arg][1]) { /* process: general args, then PROFILING-only ones, then CONCURRENT-only, TICKY-only (same order as defined in RtsFlags.lh); within those groups, mostly in case-insensitive alphabetical order. Final group is x*, which allows for more options. */ #ifdef TICKY_TICKY # define TICKY_BUILD_ONLY(x) x #else # define TICKY_BUILD_ONLY(x) \ errorBelch("the flag %s requires the program to be built with -ticky", rts_argv[arg]); \ error = rtsTrue; #endif #ifdef PROFILING # define PROFILING_BUILD_ONLY(x) x #else # define PROFILING_BUILD_ONLY(x) \ errorBelch("the flag %s requires the program to be built with -prof", rts_argv[arg]); \ error = rtsTrue; #endif #ifdef TRACING # define TRACING_BUILD_ONLY(x) x #else # define TRACING_BUILD_ONLY(x) \ errorBelch("the flag %s requires the program to be built with -eventlog or -debug", rts_argv[arg]); \ error = rtsTrue; #endif #ifdef THREADED_RTS # define THREADED_BUILD_ONLY(x) x #else # define THREADED_BUILD_ONLY(x) \ errorBelch("the flag %s requires the program to be built with -threaded", rts_argv[arg]); \ error = rtsTrue; #endif #ifdef DEBUG # define DEBUG_BUILD_ONLY(x) x #else # define DEBUG_BUILD_ONLY(x) \ errorBelch("the flag %s requires the program to be built with -debug", rts_argv[arg]); \ error = rtsTrue; #endif /* =========== GENERAL ========================== */ case '?': error = rtsTrue; break; /* This isn't going to allow us to keep related options together as we add more --* flags. We really need a proper options parser. */ case '-': if (strequal("install-signal-handlers=yes", &rts_argv[arg][2])) { RtsFlags.MiscFlags.install_signal_handlers = rtsTrue; } else if (strequal("install-signal-handlers=no", &rts_argv[arg][2])) { RtsFlags.MiscFlags.install_signal_handlers = rtsFalse; } else if (strequal("machine-readable", &rts_argv[arg][2])) { RtsFlags.MiscFlags.machineReadable = rtsTrue; } else if (strequal("info", &rts_argv[arg][2])) { printRtsInfo(); stg_exit(0); } else { errorBelch("unknown RTS option: %s",rts_argv[arg]); error = rtsTrue; } break; case 'A': RtsFlags.GcFlags.minAllocAreaSize = decodeSize(rts_argv[arg], 2, BLOCK_SIZE, HS_INT_MAX) / BLOCK_SIZE; break; #ifdef USE_PAPI case 'a': switch(rts_argv[arg][2]) { case '1': RtsFlags.PapiFlags.eventType = PAPI_FLAG_CACHE_L1; break; case '2': RtsFlags.PapiFlags.eventType = PAPI_FLAG_CACHE_L2; break; case 'b': RtsFlags.PapiFlags.eventType = PAPI_FLAG_BRANCH; break; case 's': RtsFlags.PapiFlags.eventType = PAPI_FLAG_STALLS; break; case 'e': RtsFlags.PapiFlags.eventType = PAPI_FLAG_CB_EVENTS; break; case '+': case '#': if (RtsFlags.PapiFlags.numUserEvents >= MAX_PAPI_USER_EVENTS) { errorBelch("maximum number of PAPI events reached"); stg_exit(EXIT_FAILURE); } nat eventNum = RtsFlags.PapiFlags.numUserEvents++; char kind = rts_argv[arg][2]; nat eventKind = kind == '+' ? PAPI_PRESET_EVENT_KIND : PAPI_NATIVE_EVENT_KIND; RtsFlags.PapiFlags.userEvents[eventNum] = rts_argv[arg] + 3; RtsFlags.PapiFlags.eventType = PAPI_USER_EVENTS; RtsFlags.PapiFlags.userEventsKind[eventNum] = eventKind; break; default: bad_option( rts_argv[arg] ); } break; #endif case 'B': RtsFlags.GcFlags.ringBell = rtsTrue; break; case 'c': if (rts_argv[arg][2] != '\0') { RtsFlags.GcFlags.compactThreshold = atof(rts_argv[arg]+2); } else { RtsFlags.GcFlags.compact = rtsTrue; } break; case 'w': RtsFlags.GcFlags.sweep = rtsTrue; break; case 'F': RtsFlags.GcFlags.oldGenFactor = atof(rts_argv[arg]+2); if (RtsFlags.GcFlags.oldGenFactor < 0) bad_option( rts_argv[arg] ); break; case 'D': DEBUG_BUILD_ONLY( { char *c; for (c = rts_argv[arg] + 2; *c != '\0'; c++) { switch (*c) { case 's': RtsFlags.DebugFlags.scheduler = rtsTrue; break; case 'i': RtsFlags.DebugFlags.interpreter = rtsTrue; break; case 'w': RtsFlags.DebugFlags.weak = rtsTrue; break; case 'G': RtsFlags.DebugFlags.gccafs = rtsTrue; break; case 'g': RtsFlags.DebugFlags.gc = rtsTrue; break; case 'b': RtsFlags.DebugFlags.block_alloc = rtsTrue; break; case 'S': RtsFlags.DebugFlags.sanity = rtsTrue; break; case 't': RtsFlags.DebugFlags.stable = rtsTrue; break; case 'p': RtsFlags.DebugFlags.prof = rtsTrue; break; case 'l': RtsFlags.DebugFlags.linker = rtsTrue; break; case 'a': RtsFlags.DebugFlags.apply = rtsTrue; break; case 'm': RtsFlags.DebugFlags.stm = rtsTrue; break; case 'z': RtsFlags.DebugFlags.squeeze = rtsTrue; break; case 'c': RtsFlags.DebugFlags.hpc = rtsTrue; break; case 'r': RtsFlags.DebugFlags.sparks = rtsTrue; break; default: bad_option( rts_argv[arg] ); } } // -Dx also turns on -v. Use -l to direct trace // events to the .eventlog file instead. RtsFlags.TraceFlags.tracing = TRACE_STDERR; }) break; case 'K': RtsFlags.GcFlags.maxStkSize = decodeSize(rts_argv[arg], 2, sizeof(W_), HS_WORD_MAX) / sizeof(W_); break; case 'k': switch(rts_argv[arg][2]) { case 'c': RtsFlags.GcFlags.stkChunkSize = decodeSize(rts_argv[arg], 3, sizeof(W_), HS_WORD_MAX) / sizeof(W_); break; case 'b': RtsFlags.GcFlags.stkChunkBufferSize = decodeSize(rts_argv[arg], 3, sizeof(W_), HS_WORD_MAX) / sizeof(W_); break; case 'i': RtsFlags.GcFlags.initialStkSize = decodeSize(rts_argv[arg], 3, sizeof(W_), HS_WORD_MAX) / sizeof(W_); break; default: RtsFlags.GcFlags.initialStkSize = decodeSize(rts_argv[arg], 2, sizeof(W_), HS_WORD_MAX) / sizeof(W_); break; } break; case 'M': RtsFlags.GcFlags.maxHeapSize = decodeSize(rts_argv[arg], 2, BLOCK_SIZE, HS_WORD_MAX) / BLOCK_SIZE; /* user give size in *bytes* but "maxHeapSize" is in *blocks* */ break; case 'm': RtsFlags.GcFlags.pcFreeHeap = atof(rts_argv[arg]+2); if (RtsFlags.GcFlags.pcFreeHeap < 0 || RtsFlags.GcFlags.pcFreeHeap > 100) bad_option( rts_argv[arg] ); break; case 'G': RtsFlags.GcFlags.generations = decodeSize(rts_argv[arg], 2, 1, HS_INT_MAX); break; case 'H': if (rts_argv[arg][2] == '\0') { RtsFlags.GcFlags.heapSizeSuggestionAuto = rtsTrue; } else { RtsFlags.GcFlags.heapSizeSuggestion = (nat)(decodeSize(rts_argv[arg], 2, BLOCK_SIZE, HS_WORD_MAX) / BLOCK_SIZE); } break; #ifdef RTS_GTK_FRONTPANEL case 'f': RtsFlags.GcFlags.frontpanel = rtsTrue; break; #endif case 'I': /* idle GC delay */ if (rts_argv[arg][2] == '\0') { /* use default */ } else { I_ cst; /* tmp */ /* Convert to millisecs */ cst = (I_) ((atof(rts_argv[arg]+2) * 1000)); RtsFlags.GcFlags.idleGCDelayTime = cst; } break; case 'S': RtsFlags.GcFlags.giveStats = VERBOSE_GC_STATS; goto stats; case 's': RtsFlags.GcFlags.giveStats = SUMMARY_GC_STATS; goto stats; case 't': RtsFlags.GcFlags.giveStats = ONELINE_GC_STATS; goto stats; stats: { int r; r = open_stats_file(arg, *argc, argv, *rts_argc, rts_argv, NULL, &RtsFlags.GcFlags.statsFile); if (r == -1) { error = rtsTrue; } } break; case 'Z': RtsFlags.GcFlags.squeezeUpdFrames = rtsFalse; break; /* =========== PROFILING ========================== */ case 'P': /* detailed cost centre profiling (time/alloc) */ case 'p': /* cost centre profiling (time/alloc) */ PROFILING_BUILD_ONLY( switch (rts_argv[arg][2]) { case 'x': RtsFlags.CcFlags.doCostCentres = COST_CENTRES_XML; break; case 'a': RtsFlags.CcFlags.doCostCentres = COST_CENTRES_ALL; break; default: if (rts_argv[arg][1] == 'P') { RtsFlags.CcFlags.doCostCentres = COST_CENTRES_VERBOSE; } else { RtsFlags.CcFlags.doCostCentres = COST_CENTRES_SUMMARY; } break; } ) break; case 'R': PROFILING_BUILD_ONLY( RtsFlags.ProfFlags.maxRetainerSetSize = atof(rts_argv[arg]+2); ) break; case 'L': PROFILING_BUILD_ONLY( RtsFlags.ProfFlags.ccsLength = atof(rts_argv[arg]+2); if(RtsFlags.ProfFlags.ccsLength <= 0) { bad_option(rts_argv[arg]); } ) break;
bool EZPlot::do_cmd (int lx) { char str [1024]; char strIn [1024]; int n; double f; switch (lx) { case S_TEXTSIZE: if (m_pol.readFloat (&f, POL::TT_REAL, FALSE, 0.0, 0.0) == TRUE) { if (f >= 0.0 && f <= 1.0) { v_textsize = f; s_textsize = TRUE; } else s_textsize = FALSE; } break; case S_REPLOT: plot (m_pSGP); break; case S_CLEAR: clearCurves (); break; case S_TITLE: m_pol.readText (strIn, sizeof(strIn)); c_title = strIn; break; case S_LEGEND: m_pol.readText (strIn, sizeof(strIn)); if (m_iCurrentCurve >= 0) setLegend (m_iCurrentCurve, strIn); break; case S_XLABEL: m_pol.readText (strIn, sizeof(strIn)); c_xlabel = strIn; break; case S_YLABEL: m_pol.readText (strIn, sizeof(strIn)); c_ylabel = strIn; break; case S_XCROSS: if (m_pol.readFloat (&f, POL::TT_REAL, FALSE, 0.0, 0.0) == TRUE) { v_xcross = f; s_xcross = TRUE; } else s_xcross = FALSE; break; case S_YCROSS: if (m_pol.readFloat (&f, POL::TT_REAL, FALSE, 0.0, 0.0) == TRUE) { v_ycross = f; s_ycross = TRUE; } else s_ycross = FALSE; break; case S_NOXAXIS: o_xaxis = NOAXIS; break; case S_NOYAXIS: o_yaxis = NOAXIS; break; case S_XLIN: o_xaxis = LINEAR; break; case S_YLIN: o_yaxis = LINEAR; break; case S_XLOG: o_xaxis = LOG; break; case S_YLOG: o_yaxis = LOG; break; case S_XAUTOSCALE: s_xmin = FALSE; s_xmax = FALSE; break; case S_YAUTOSCALE: s_ymin = FALSE; s_ymax = FALSE; break; case S_XMIN: if (m_pol.readFloat (&f, POL::TT_REAL, FALSE, 0.0, 0.0) == TRUE) { v_xmin = f; s_xmin = TRUE; } break; case S_XMAX: if (m_pol.readFloat (&f, POL::TT_REAL, FALSE, 0.0, 0.0) == TRUE) { v_xmax = f; s_xmax = TRUE; } break; case S_YMIN: if (m_pol.readFloat (&f, POL::TT_REAL, FALSE, 0.0, 0.0) == TRUE) { v_ymin = f; s_ymin = TRUE; } break; case S_YMAX: if (m_pol.readFloat (&f, POL::TT_REAL, FALSE, 0.0, 0.0) == TRUE) { v_ymax = f; s_ymax = TRUE; } break; case S_SOLID: o_linestyle = SGP::LS_SOLID; break; case S_DASH: int ls; ls = SGP::LS_DASH1; if (m_pol.readInteger (&n, POL::TT_REAL, FALSE, 0, 0) == TRUE) { if (n == 1) ls = SGP::LS_DASH1; else if (n == 2) ls = SGP::LS_DASH2; else if (n == 3) ls = SGP::LS_DASH3; else if (n == 4) ls = SGP::LS_DASH4; else if (n == 5) ls = SGP::LS_DOTTED; } if (m_iCurrentCurve < 0) o_linestyle = ls; else setLinestyle (m_iCurrentCurve, ls); break; case S_NOLINE: o_linestyle = SGP::LS_NOLINE; break; case S_PEN: case S_COLOR: if (m_pol.readInteger (&n, POL::TT_REAL, FALSE, 0, 0) == TRUE) { if (n >= 0) { if (m_iCurrentCurve < 0) o_color = n; else setColor (m_iCurrentCurve, n); } else bad_option("The color you picked"); } break; case S_BOX: o_box = TRUE; break; case S_NOBOX: o_box = FALSE; break; case S_GRID: o_grid = TRUE; break; case S_NOGRID: o_grid = FALSE; break; case S_XLENGTH: if (m_pol.readFloat (&f, POL::TT_REAL, FALSE, 0.0, 0.0) == TRUE) if (f > 0.0 && f <= 1.0) o_xlength = f; break; case S_YLENGTH: if (m_pol.readFloat (&f, POL::TT_REAL, FALSE, 0.0, 0.0) == TRUE) if (f > 0.0 && f <= 1.0) o_ylength = f; break; case S_XPORIGIN: if (m_pol.readFloat (&f, POL::TT_REAL, FALSE, 0.0, 0.0) == TRUE) if (f >= 0.0 && f < 1.0) o_xporigin = f; break; case S_YPORIGIN: if (m_pol.readFloat (&f, POL::TT_REAL, FALSE, 0.0, 0.0) == TRUE) if (f >= 0.0 && f < 1.0) o_yporigin = f; break; case S_TAG: if (m_pol.readWord("no", 2) == TRUE) o_tag = FALSE; else if (m_pol.readWord("off", 2) == TRUE) o_tag = FALSE; else o_tag = TRUE; break; case S_LEGENDBOX: if (m_pol.readWord("inside", 2) == TRUE) o_legendbox = INSIDE; else if (m_pol.readWord("outside", 3) == TRUE) o_legendbox = OUTSIDE; else if (m_pol.readWord("none",2) == TRUE) o_legendbox = NOLEGEND; else { m_pol.readText (str, POL::MAXTOK); bad_option(str); } break; case S_XLEGEND: if (m_pol.readFloat (&f, POL::TT_REAL, FALSE, 0.0, 0.0) == TRUE) { if (f >= 0.0 && f < 1.0) { v_xlegend = f; s_xlegend = TRUE; } else s_xlegend = FALSE; } break; case S_YLEGEND: if (m_pol.readFloat (&f, POL::TT_REAL, FALSE, 0.0, 0.0) == TRUE) { if (f >= 0.0 && f < 1.0) { v_ylegend = f; s_ylegend = TRUE; } else s_ylegend = FALSE; } break; case S_SYMBOL: if (m_pol.readInteger (&n, POL::TT_REAL, FALSE, 0, 0) == TRUE) { if (n > 0 && n <= MAXSYMBOL) { if (m_iCurrentCurve < 0) o_symbol = n; else setSymbol (m_iCurrentCurve, n); } } else { if (m_pol.readWord("every",5) == TRUE) { if (m_pol.readInteger (&n, POL::TT_REAL, FALSE, 0, 0) == TRUE) { int sym = 1; if (n > 0) sym = n; if (m_iCurrentCurve < 0) o_symfreq = sym; else setSymbolFreq (m_iCurrentCurve, sym); } } else if (m_pol.readWord ("none",4) == TRUE) { o_symbol = -1; } } break; case S_CURVE: if (m_pol.readInteger (&n, POL::TT_REAL, FALSE, 0, 0) == TRUE) { if (n > 0) m_iCurrentCurve = n - 1; } else { if (m_pol.readWord ("all",3) == TRUE) m_iCurrentCurve = -1; } break; case S_XTICKS: if (m_pol.readUserToken(str,&lx) == FALSE) break; if (lx == S_ABOVE) o_xticks = ABOVE; else if (lx == S_BELOW) o_xticks = BELOW; else if (lx == S_NOLABEL) o_xtlabel = FALSE; else if (lx == S_LABEL) o_xtlabel = TRUE; else if (lx == S_MAJOR) { if (m_pol.readInteger (&n, POL::TT_REAL, FALSE, 0, 0) == TRUE) if (n > 1 && n < 100) o_xmajortick = n; } else if (lx == S_MINOR) if (m_pol.readInteger (&n, POL::TT_REAL, FALSE, 0, 0) == TRUE) if (n >= 0 && n < 100) o_xminortick = n; break; case S_YTICKS: if (m_pol.readUserToken(str,&lx) == FALSE) break; if (lx == S_RIGHT) o_yticks = RIGHT; else if (lx == S_LEFT) o_yticks = LEFT; else if (lx == S_NOLABEL) o_ytlabel = FALSE; else if (lx == S_LABEL) o_ytlabel = TRUE; else if (lx == S_MAJOR) { if (m_pol.readInteger (&n, POL::TT_REAL, FALSE, 0, 0) == TRUE) if (n > 1 && n < 100) o_ymajortick = n; } else if (lx == S_MINOR) if (m_pol.readInteger (&n, POL::TT_REAL, FALSE, 0, 0) == TRUE) if (n >= 0 && n < 100) o_yminortick = n; break; case S_LXFRAC: if (m_pol.readInteger (&n, POL::TT_REAL, FALSE, 0, 0) == TRUE) { if (n >= 0) { v_lxfrac = n; s_lxfrac = TRUE; } } else s_lxfrac = FALSE; break; case S_LYFRAC: if (m_pol.readInteger (&n, POL::TT_REAL, FALSE, 0, 0) == TRUE) { if (n >= 0) { v_lyfrac = n; s_lyfrac = TRUE; } } else s_lyfrac = FALSE; break; break; default: fprintf (stderr, "Unimplemented EZPLOT command\n"); break; } m_pol.reader (); return (true); }
int main(int argc, char *argv[]) { const char *path; const char *attr_name = XATTR_NAME_LMA; size_t val_buf_size = XATTR_SIZE_MAX; char *val_buf = NULL; ssize_t val_len = 0; struct lustre_mdt_attrs *lma; struct option opts[] = { { "help", 0, NULL, 'h' }, { "raw", 0, NULL, 'r' }, { "hex", 0, NULL, 'x' }, { NULL } }; int c; while ((c = getopt_long(argc, argv, "hrx", opts, 0)) != -1) { switch (c) { case 'h': usage(stdout, EXIT_SUCCESS); break; case 'r': want_raw = 1; break; case 'x': want_hex = 1; break; case '?': bad_option(); break; } } if (argc - optind != 1) usage(stderr, EXIT_FAILURE); path = argv[optind]; while (1) { char *buf = realloc(val_buf, val_buf_size); if (buf == NULL) FATAL("cannot allocate buffer for xattr '%s' of '%s':" " %s\n", attr_name, path, strerror(errno)); val_buf = buf; val_len = getxattr(path, attr_name, val_buf, val_buf_size); if (val_len >= 0) break; if (errno != ERANGE) FATAL("cannot retrieve xattr '%s' of '%s': %s\n", attr_name, path, strerror(errno)); val_buf_size *= 2; } if (want_raw) { fwrite(val_buf, 1, val_len, stdout); exit(EXIT_SUCCESS); } if (val_len != sizeof(*lma)) FATAL("size (%zd) for xattr '%s' of '%s' does not match " "size (%zu) of lustre_mdt_attrs\n", val_len, attr_name, path, sizeof(*lma)); lma = (struct lustre_mdt_attrs *) val_buf; #define X(w, m) \ printf("%-20s %24"PRIx##w"\n", #m, lma->m) X(32, lma_compat); /* * Bitfield for supported data in this structure. From enum * lma_compat. lma_self_fid and lma_flags are always available. */ X(32, lma_incompat); /* * Per-file incompat feature list. Lustre version should support all * flags set in this field. The supported feature mask is available * in LMA_INCOMPAT_SUPP. */ char self_fid_buf[PRI_FID_LEN + 1]; snprintf(self_fid_buf, sizeof(self_fid_buf), PRI_FID, PRI_FID_ARGS(&lma->lma_self_fid)); printf("%-20s %24s\n", "lma_self_fid", self_fid_buf); #undef X free(val_buf); return 0; }