B.2 Command-Line Parser [ToC] [Index]     [Skip Back]     [Prev] [Up] [Next]

The option parser in the previous section handles the general form of command-line options. The code in this section applies that option parser to the specific options used by the BST test program. It has helper functions for argument parsing and advice to users. Here is all of it together:

589. <Command line parser 589> =
/* Command line parser. */

/* If a is a prefix for b or vice versa, returns the length of the 
   match. Otherwise, returns 0. */ size_t
match_len (const char *a, const char *b)
{ size_t cnt; for (cnt = 0; *a == *b && *a != '\0'; a++, b++) cnt++; return (*a != *b && *a != '\0' && *b != '\0') ? 0 : cnt; } /* s should point to a decimal representation of an integer. Returns the value of s, if successful, or 0 on failure. */ static int
stoi (const char *s)
{ long x = strtol (s, NULL, 10); return x >= INT_MIN && x <= INT_MAX ? x : 0; } /* Print helpful syntax message and exit. */ static void
usage (void)
{ static const char *help[] =
    { "bsttest, unit test for GNU libavl.\n\n", "Usage: %s [OPTION]...\n\n", "In the option descriptions below, CAPITAL denote arguments.\n", "If a long option shows an argument as mandatory, then it is\n", "mandatory for the equivalent short option also. See the GNU\n", "libavl manual for more information.\n\n", "t, -test=TEST Sets test to perform. TEST is one of:\n", " correctness insert/delete/... (default)\n", " overflow stack overflow test\n", " benchmark benchmark test\n", " null no test\n", "s, -size=TREESIZE Sets tree size in nodes (default 16).\n", "r, -repeat=COUNT Repeats operation COUNT times (default 16).\n", "i, -insert=ORDER Sets the insertion order. ORDER is one of:\n", " random random permutation (default)\n", " ascending ascending order 0...n1\n", " descending descending order n1...0\n", " balanced balanced tree order\n", " zigzag zigzag tree\n", " ascshifted n/2...n1, 0...n/21\n", " custom custom, read from stdin\n", "d, -delete=ORDER Sets the deletion order. ORDER is one of:\n", " random random permutation (default)\n", " reverse reverse order of insertion\n", " same same as insertion order\n", " custom custom, read from stdin\n", "a, -alloc=POLICY Sets allocation policy. POLICY is one of:\n", " track track memory leaks (default)\n", " notrack turn off leak detection\n", " failCNT fail after CNT allocations\n", " fail%%PCT fail random PCT%% of allocations\n", " subB,A divide Bbyte blocks in Abyte units\n", " (Ignored for `benchmark' test.)\n", "A, -incr=INC Fail policies: arg increment per repetition.\n", "S, -seed=SEED Sets initial number seed to SEED.\n", " (default based on system time)\n", "n, -nonstop Don't stop after a single error.\n", "q, -quiet Turns down verbosity level.\n", "v, -verbose Turns up verbosity level.\n", "h, -help Displays this help screen.\n", "V, -version Reports version and copyright information.\n", NULL, }; const char **p; for (p = help; *p != NULL; p++) printf (*p, pgm_name); exit (EXIT_SUCCESS); } /* Parses command-line arguments from null-terminated array args. Sets up options appropriately to correspond. */ static void
parse_command_line (char **args, struct test_options *options)
{ static const struct option option_tab[] =
    { {"test", 't', 1},
      {"insert", 'i', 1},
      {"delete", 'd', 1}, {"alloc", 'a', 1},
      {"incr", 'A', 1},
      {"size", 's', 1}, {"repeat", 'r', 1},
      {"operation", 'o', 1},
      {"seed", 'S', 1}, {"nonstop", 'n', 0},
      {"quiet", 'q', 0},
      {"verbose", 'v', 0}, {"help", 'h', 0},
      {"version", 'V', 0},
      {NULL, 0, 0}, }; struct option_state *state; /* Default options. */ options->test = TST_CORRECTNESS;
  options->insert_order = INS_RANDOM; options->delete_order = DEL_RANDOM;
  options->alloc_policy = MT_TRACK; options->alloc_arg[0] = 0;
  options->alloc_arg[1] = 0; options->alloc_incr = 0;
  options->node_cnt = 15; options->iter_cnt = 15;
  options->seed_given = 0; options->verbosity = 0;
  options->nonstop = 0; if (*args == NULL) return; state = option_init (option_tab, args + 1); for (;;)
    { char *arg; int id = option_get (state, &arg); if (id == -1) break; switch (id)
        { case 't': if (match_len (arg, "correctness") >= 3) options->test = TST_CORRECTNESS; else if (match_len (arg, "overflow") >= 3) options->test = TST_OVERFLOW; else if (match_len (arg, "null") >= 3) options->test = TST_NULL; else fail ("unknown test \"%s\"", arg); break; case 'i':
          { static const char *orders[INS_CNT] =
              { "random", "ascending", "descending", "balanced", "zigzag", "ascshifted", "custom", }; const char **iter; assert (sizeof orders / sizeof *orders == INS_CNT); for (iter = orders; ; iter++) if (iter >= orders + INS_CNT) fail ("unknown order \"%s\"", arg); else if (match_len (*iter, arg) >= 3)
                { options->insert_order = iter - orders; break; } } break; case 'd':
          { static const char *orders[DEL_CNT] =
              { "random", "reverse", "same", "custom", }; const char **iter; assert (sizeof orders / sizeof *orders == DEL_CNT); for (iter = orders; ; iter++) if (iter >= orders + DEL_CNT) fail ("unknown order \"%s\"", arg); else if (match_len (*iter, arg) >= 3)
                { options->delete_order = iter - orders; break; } } break; case 'a': if (match_len (arg, "track") >= 3) options->alloc_policy = MT_TRACK; else if (match_len (arg, "notrack") >= 3) options->alloc_policy = MT_NO_TRACK; else if (!strncmp (arg, "fail", 3))
            { const char *p = arg + strcspn (arg, "%"); if (*p == )
                options->alloc_policy = MT_FAIL_COUNT; else if (*p == '%')
                options->alloc_policy = MT_FAIL_PERCENT; else
                fail ("invalid allocation policy \"%s\"", arg); options->alloc_arg[0] = stoi (p + 1); } else if (!strncmp (arg, "suballoc", 3))
            { const char *p = strchr (arg, ); const char *q = strchr (arg, ','); if (p == NULL || q == NULL) fail ("invalid allocation policy \"%s\"", arg); options->alloc_policy = MT_SUBALLOC; options->alloc_arg[0] = stoi (p + 1); options->alloc_arg[1] = stoi (q + 1); if (options->alloc_arg[MT_BLOCK_SIZE] < 32) fail ("block size too small"); else if (options->alloc_arg[MT_ALIGN] > options->alloc_arg[MT_BLOCK_SIZE]) fail ("alignment cannot be greater than block size"); else if (options->alloc_arg[MT_ALIGN] < 1) fail ("alignment must be at least 1"); } break; case 'A':
          options->alloc_incr = stoi (arg);
          break; case 's': options->node_cnt = stoi (arg); if (options->node_cnt < 1) fail ("bad tree size \"%s\"", arg); break; case 'r': options->iter_cnt = stoi (arg); if (options->iter_cnt < 1) fail ("bad repeat count \"%s\"", arg); break; case 'S': options->seed_given = 1; options->seed = strtoul (arg, NULL, 0); break; case 'n':
          options->nonstop = 1;
          break; case 'q':
          options->verbosity–;
          break; case 'v':
          options->verbosity++;
          break; case 'h':
          usage ();
          break; case 'V': fputs ("GNU libavl 2.0.2\n" "Copyright (C) 19982002, 2004 " "Free Software Foundation, Inc.\n" "This program comes with NO WARRANTY, not even for\n" "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n" "You may redistribute copies under the terms of the\n" "GNU General Public License. For more information on\n" "these matters, see the file named COPYING.\n", stdout); exit (EXIT_SUCCESS); default:
          assert (0); } } }

This code is included in 97.

Prev: B.1 Option Parser Up: Appendix B Supplementary Code Appendix C Glossary Next