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;
}
