vendor/gperf/3.0.3vendor/gperf

1 files changed, 732 insertions, 386 deletions

diff --git a/src/options.cc b/src/options.cc
index d15e21cee8ce..a86432ea65ed 100644
--- a/src/options.cc
+++ b/src/options.cc
@@ -1,151 +1,192 @@
 /* Handles parsing the Options provided to the user.
-   Copyright (C) 1989-1998, 2000 Free Software Foundation, Inc.
-   written by Douglas C. Schmidt (schmidt@ics.uci.edu)
+   Copyright (C) 1989-1998, 2000, 2002-2004, 2006-2007 Free Software Foundation, Inc.
+   Written by Douglas C. Schmidt <schmidt@ics.uci.edu>
+   and Bruno Haible <bruno@clisp.org>.
 
-This file is part of GNU GPERF.
+   This file is part of GNU GPERF.
 
-GNU GPERF is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
-any later version.
+   GNU GPERF is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
 
-GNU GPERF is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   GNU GPERF is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License
-along with GNU GPERF; see the file COPYING.  If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with this program; see the file COPYING.
+   If not, write to the Free Software Foundation, Inc.,
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
+
+/* Specification. */
+#include "options.h"
 
 #include <stdio.h>
 #include <stdlib.h> /* declares atoi(), abs(), exit() */
 #include <string.h> /* declares strcmp() */
+#include <ctype.h>  /* declares isdigit() */
+#include <limits.h> /* defines CHAR_MAX */
 #include "getopt.h"
-#include "options.h"
-#include "iterator.h"
-#include "trace.h"
-#include "vectors.h"
 #include "version.h"
 
-/* Global option coordinator for the entire program. */
+/* Global option coordinator for the entire program.  */
 Options option;
 
-/* Records the program name. */
+/* Records the program name.  */
 const char *program_name;
 
-/* Size to jump on a collision. */
+/* Size to jump on a collision.  */
 static const int DEFAULT_JUMP_VALUE = 5;
 
-/* Default name for generated lookup function. */
-static const char *const DEFAULT_NAME = "in_word_set";
+/* Default name for generated lookup function.  */
+static const char *const DEFAULT_FUNCTION_NAME = "in_word_set";
 
-/* Default name for the key component. */
-static const char *const DEFAULT_KEY = "name";
+/* Default name for the key component.  */
+static const char *const DEFAULT_SLOT_NAME = "name";
 
-/* Default struct initializer suffix. */
+/* Default struct initializer suffix.  */
 static const char *const DEFAULT_INITIALIZER_SUFFIX = "";
 
-/* Default name for the generated class. */
+/* Default name for the generated class.  */
 static const char *const DEFAULT_CLASS_NAME = "Perfect_Hash";
 
-/* Default name for generated hash function. */
+/* Default name for generated hash function.  */
 static const char *const DEFAULT_HASH_NAME = "hash";
 
-/* Default name for generated hash table array. */
+/* Default name for generated hash table array.  */
 static const char *const DEFAULT_WORDLIST_NAME = "wordlist";
 
-/* Default delimiters that separate keywords from their attributes. */
-static const char *const DEFAULT_DELIMITERS = ",\n";
-
-int Options::option_word;
-int Options::total_switches;
-int Options::total_keysig_size;
-int Options::size;
-int Options::key_pos;
-int Options::jump;
-int Options::initial_asso_value;
-int Options::argument_count;
-int Options::iterations;
-char **Options::argument_vector;
-const char *Options::function_name;
-const char *Options::key_name;
-const char *Options::initializer_suffix;
-const char *Options::class_name;
-const char *Options::hash_name;
-const char *Options::wordlist_name;
-const char *Options::delimiters;
-char Options::key_positions[MAX_KEY_POS];
-
-/* Prints program usage to given stream. */
+/* Default name for generated length table array.  */
+static const char *const DEFAULT_LENGTHTABLE_NAME = "lengthtable";
+
+/* Default name for string pool.  */
+static const char *const DEFAULT_STRINGPOOL_NAME = "stringpool";
+
+/* Default delimiters that separate keywords from their attributes.  */
+static const char *const DEFAULT_DELIMITERS = ",";
+
+/* Prints program usage to given stream.  */
 
 void
-Options::short_usage (FILE * strm)
+Options::short_usage (FILE * stream)
 {
-  T (Trace t ("Options::short_usage");)
-  fprintf (strm, "Usage: %s [-cCdDef[num]F<initializers>GhH<hashname>i<init>Ijk<keys>K<keyname>lL<language>nN<function name>ors<size>S<switches>tTvW<wordlistname>Z<class name>7] [input-file]\n"
-                 "Try `%s --help' for more information.\n",
-                 program_name, program_name);
+  fprintf (stream,
+           "Try '%s --help' for more information.\n", program_name);
 }
 
 void
-Options::long_usage (FILE * strm)
+Options::long_usage (FILE * stream)
 {
-  T (Trace t ("Options::long_usage");)
-  fprintf (strm,
-           "GNU `gperf' generates perfect hash functions.\n"
-           "\n"
-           "Usage: %s [OPTION]... [INPUT-FILE]\n"
-           "\n"
+  fprintf (stream,
+           "GNU 'gperf' generates perfect hash functions.\n");
+  fprintf (stream, "\n");
+  fprintf (stream,
+           "Usage: %s [OPTION]... [INPUT-FILE]\n",
+           program_name);
+  fprintf (stream, "\n");
+  fprintf (stream,
            "If a long option shows an argument as mandatory, then it is mandatory\n"
-           "for the equivalent short option also.\n"
-           "\n"
-           "Input file interpretation:\n"
+           "for the equivalent short option also.\n");
+  fprintf (stream, "\n");
+  fprintf (stream,
+           "Output file location:\n");
+  fprintf (stream,
+           "      --output-file=FILE Write output to specified file.\n");
+  fprintf (stream,
+           "The results are written to standard output if no output file is specified\n"
+           "or if it is -.\n");
+  fprintf (stream, "\n");
+  fprintf (stream,
+           "Input file interpretation:\n");
+  fprintf (stream,
            "  -e, --delimiters=DELIMITER-LIST\n"
            "                         Allow user to provide a string containing delimiters\n"
            "                         used to separate keywords from their attributes.\n"
-           "                         Default is \",\\n\".\n"
+           "                         Default is \",\".\n");
+  fprintf (stream,
            "  -t, --struct-type      Allows the user to include a structured type\n"
            "                         declaration for generated code. Any text before %%%%\n"
            "                         is considered part of the type declaration. Key\n"
            "                         words and additional fields may follow this, one\n"
-           "                         group of fields per line.\n"
-           "\n"
-           "Language for the output code:\n"
+           "                         group of fields per line.\n");
+  fprintf (stream,
+           "      --ignore-case      Consider upper and lower case ASCII characters as\n"
+           "                         equivalent. Note that locale dependent case mappings\n"
+           "                         are ignored.\n");
+  fprintf (stream, "\n");
+  fprintf (stream,
+           "Language for the output code:\n");
+  fprintf (stream,
            "  -L, --language=LANGUAGE-NAME\n"
            "                         Generates code in the specified language. Languages\n"
            "                         handled are currently C++, ANSI-C, C, and KR-C. The\n"
-           "                         default is C.\n"
-           "\n"
-           "Details in the output code:\n"
+           "                         default is C.\n");
+  fprintf (stream, "\n");
+  fprintf (stream,
+           "Details in the output code:\n");
+  fprintf (stream,
            "  -K, --slot-name=NAME   Select name of the keyword component in the keyword\n"
-           "                         structure.\n"
+           "                         structure.\n");
+  fprintf (stream,
            "  -F, --initializer-suffix=INITIALIZERS\n"
            "                         Initializers for additional components in the keyword\n"
-           "                         structure.\n"
-           "  -H, --hash-fn-name=NAME\n"
+           "                         structure.\n");
+  fprintf (stream,
+           "  -H, --hash-function-name=NAME\n"
            "                         Specify name of generated hash function. Default is\n"
-           "                         `hash'.\n"
-           "  -N, --lookup-fn-name=NAME\n"
+           "                         'hash'.\n");
+  fprintf (stream,
+           "  -N, --lookup-function-name=NAME\n"
            "                         Specify name of generated lookup function. Default\n"
-           "                         name is `in_word_set'.\n"
+           "                         name is 'in_word_set'.\n");
+  fprintf (stream,
            "  -Z, --class-name=NAME  Specify name of generated C++ class. Default name is\n"
-           "                         `Perfect_Hash'.\n"
-           "  -7, --seven-bit        Assume 7-bit characters.\n"
+           "                         'Perfect_Hash'.\n");
+  fprintf (stream,
+           "  -7, --seven-bit        Assume 7-bit characters.\n");
+  fprintf (stream,
+           "  -l, --compare-lengths  Compare key lengths before trying a string\n"
+           "                         comparison. This is necessary if the keywords\n"
+           "                         contain NUL bytes. It also helps cut down on the\n"
+           "                         number of string comparisons made during the lookup.\n");
+  fprintf (stream,
            "  -c, --compare-strncmp  Generate comparison code using strncmp rather than\n"
-           "                         strcmp.\n"
+           "                         strcmp.\n");
+  fprintf (stream,
            "  -C, --readonly-tables  Make the contents of generated lookup tables\n"
-           "                         constant, i.e., readonly.\n"
+           "                         constant, i.e., readonly.\n");
+  fprintf (stream,
            "  -E, --enum             Define constant values using an enum local to the\n"
-           "                         lookup function rather than with defines.\n"
+           "                         lookup function rather than with defines.\n");
+  fprintf (stream,
            "  -I, --includes         Include the necessary system include file <string.h>\n"
-           "                         at the beginning of the code.\n"
-           "  -G, --global           Generate the static table of keywords as a static\n"
+           "                         at the beginning of the code.\n");
+  fprintf (stream,
+           "  -G, --global-table     Generate the static table of keywords as a static\n"
            "                         global variable, rather than hiding it inside of the\n"
-           "                         lookup function (which is the default behavior).\n"
+           "                         lookup function (which is the default behavior).\n");
+  fprintf (stream,
+           "  -P, --pic              Optimize the generated table for inclusion in shared\n"
+           "                         libraries.  This reduces the startup time of programs\n"
+           "                         using a shared library containing the generated code.\n");
+  fprintf (stream,
+           "  -Q, --string-pool-name=NAME\n"
+           "                         Specify name of string pool generated by option --pic.\n"
+           "                         Default name is 'stringpool'.\n");
+  fprintf (stream,
+           "      --null-strings     Use NULL strings instead of empty strings for empty\n"
+           "                         keyword table entries.\n");
+  fprintf (stream,
            "  -W, --word-array-name=NAME\n"
            "                         Specify name of word list array. Default name is\n"
-           "                         `wordlist'.\n"
+           "                         'wordlist'.\n");
+  fprintf (stream,
+           "      --length-table-name=NAME\n"
+           "                         Specify name of length table array. Default name is\n"
+           "                         'lengthtable'.\n");
+  fprintf (stream,
            "  -S, --switch=COUNT     Causes the generated C code to use a switch\n"
            "                         statement scheme, rather than an array lookup table.\n"
            "                         This can lead to a reduction in both time and space\n"
@@ -155,13 +196,16 @@ Options::long_usage (FILE * strm)
            "                         elements, a value of 2 generates 2 tables with 1/2\n"
            "                         the elements in each table, etc. If COUNT is very\n"
            "                         large, say 1000000, the generated C code does a\n"
-           "                         binary search.\n"
+           "                         binary search.\n");
+  fprintf (stream,
            "  -T, --omit-struct-type\n"
            "                         Prevents the transfer of the type declaration to the\n"
            "                         output file. Use this option if the type is already\n"
-           "                         defined elsewhere.\n"
-           "\n"
-           "Algorithm employed by gperf:\n"
+           "                         defined elsewhere.\n");
+  fprintf (stream, "\n");
+  fprintf (stream,
+           "Algorithm employed by gperf:\n");
+  fprintf (stream,
            "  -k, --key-positions=KEYS\n"
            "                         Select the key positions used in the hash function.\n"
            "                         The allowable choices range between 1-%d, inclusive.\n"
@@ -169,70 +213,70 @@ Options::long_usage (FILE * strm)
            "                         used, and key positions may occur in any order.\n"
            "                         Also, the meta-character '*' causes the generated\n"
            "                         hash function to consider ALL key positions, and $\n"
-           "                         indicates the ``final character'' of a key, e.g.,\n"
-           "                         $,1,2,4,6-10.\n"
-           "  -l, --compare-strlen   Compare key lengths before trying a string\n"
-           "                         comparison. This helps cut down on the number of\n"
-           "                         string comparisons made during the lookup.\n"
+           "                         indicates the \"final character\" of a key, e.g.,\n"
+           "                         $,1,2,4,6-10.\n",
+           Positions::MAX_KEY_POS);
+  fprintf (stream,
            "  -D, --duplicates       Handle keywords that hash to duplicate values. This\n"
-           "                         is useful for certain highly redundant keyword sets.\n"
-           "  -f, --fast=ITERATIONS  Generate the gen-perf.hash function ``fast''. This\n"
-           "                         decreases gperf's running time at the cost of\n"
-           "                         minimizing generated table size. The numeric\n"
-           "                         argument represents the number of times to iterate\n"
-           "                         when resolving a collision. `0' means ``iterate by\n"
-           "                         the number of keywords''.\n"
+           "                         is useful for certain highly redundant keyword sets.\n");
+  fprintf (stream,
+           "  -m, --multiple-iterations=ITERATIONS\n"
+           "                         Perform multiple choices of the -i and -j values,\n"
+           "                         and choose the best results. This increases the\n"
+           "                         running time by a factor of ITERATIONS but does a\n"
+           "                         good job minimizing the generated table size.\n");
+  fprintf (stream,
            "  -i, --initial-asso=N   Provide an initial value for the associate values\n"
            "                         array. Default is 0. Setting this value larger helps\n"
-           "                         inflate the size of the final table.\n"
-           "  -j, --jump=JUMP-VALUE  Affects the ``jump value'', i.e., how far to advance\n"
+           "                         inflate the size of the final table.\n");
+  fprintf (stream,
+           "  -j, --jump=JUMP-VALUE  Affects the \"jump value\", i.e., how far to advance\n"
            "                         the associated character value upon collisions. Must\n"
-           "                         be an odd number, default is %d.\n"
+           "                         be an odd number, default is %d.\n",
+           DEFAULT_JUMP_VALUE);
+  fprintf (stream,
            "  -n, --no-strlen        Do not include the length of the keyword when\n"
-           "                         computing the hash function.\n"
-           "  -o, --occurrence-sort  Reorders input keys by frequency of occurrence of\n"
-           "                         the key sets. This should decrease the search time\n"
-           "                         dramatically.\n"
+           "                         computing the hash function.\n");
+  fprintf (stream,
            "  -r, --random           Utilizes randomness to initialize the associated\n"
-           "                         values table.\n"
+           "                         values table.\n");
+  fprintf (stream,
            "  -s, --size-multiple=N  Affects the size of the generated hash table. The\n"
-           "                         numeric argument N indicates ``how many times larger\n"
-           "                         or smaller'' the associated value range should be,\n"
+           "                         numeric argument N indicates \"how many times larger\n"
+           "                         or smaller\" the associated value range should be,\n"
            "                         in relationship to the number of keys, e.g. a value\n"
-           "                         of 3 means ``allow the maximum associated value to\n"
+           "                         of 3 means \"allow the maximum associated value to\n"
            "                         be about 3 times larger than the number of input\n"
-           "                         keys.'' Conversely, a value of -3 means ``make the\n"
+           "                         keys\". Conversely, a value of 1/3 means \"make the\n"
            "                         maximum associated value about 3 times smaller than\n"
-           "                         the number of input keys. A larger table should\n"
+           "                         the number of input keys\". A larger table should\n"
            "                         decrease the time required for an unsuccessful\n"
            "                         search, at the expense of extra table space. Default\n"
-           "                         value is 1.\n"
-           "\n"
+           "                         value is 1.\n");
+  fprintf (stream, "\n");
+  fprintf (stream,
            "Informative output:\n"
            "  -h, --help             Print this message.\n"
            "  -v, --version          Print the gperf version number.\n"
            "  -d, --debug            Enables the debugging option (produces verbose\n"
-           "                         output to the standard error).\n"
-           "\n"
-           "Report bugs to <bug-gnu-utils@gnu.org>.\n"
-           , program_name, MAX_KEY_POS - 1, DEFAULT_JUMP_VALUE);
+           "                         output to the standard error).\n");
+  fprintf (stream, "\n");
+  fprintf (stream,
+           "Report bugs to <bug-gnu-gperf@gnu.org>.\n");
 }
 
-/* Output command-line Options. */
+/* Prints the given options.  */
 
 void
-Options::print_options (void)
+Options::print_options () const
 {
-  T (Trace t ("Options::print_options");)
-  int i;
-
   printf ("/* Command-line: ");
 
-  for (i = 0; i < argument_count; i++)
+  for (int i = 0; i < _argument_count; i++)
     {
-      const char *arg = argument_vector[i];
+      const char *arg = _argument_vector[i];
 
-      /* Escape arg if it contains shell metacharacters. */
+      /* Escape arg if it contains shell metacharacters.  */
       if (*arg == '-')
         {
           putchar (*arg);
@@ -242,6 +286,20 @@ Options::print_options (void)
               putchar (*arg);
               arg++;
             }
+          else if (*arg == '-')
+            {
+              do
+                {
+                  putchar (*arg);
+                  arg++;
+                }
+              while (*arg >= 'A' && *arg <= 'Z' || *arg >= 'a' && *arg <= 'z' || *arg == '-');
+              if (*arg == '=')
+                {
+                  putchar (*arg);
+                  arg++;
+                }
+            }
         }
       if (strpbrk (arg, "\t\n !\"#$&'()*;<>?[\\]`{|}~") != NULL)
         {
@@ -250,7 +308,7 @@ Options::print_options (void)
               putchar ('"');
               for (; *arg; arg++)
                 {
-                  if (*arg == '\"' || *arg == '\\' || *arg == '$')
+                  if (*arg == '\"' || *arg == '\\' || *arg == '$' || *arg == '`')
                     putchar ('\\');
                   putchar (*arg);
                 }
@@ -277,389 +335,653 @@ Options::print_options (void)
   printf (" */");
 }
 
-/* Sorts the key positions *IN REVERSE ORDER!!*
-   This makes further routines more efficient.  Especially when generating code.
-   Uses a simple Insertion Sort since the set is probably ordered.
-   Returns 1 if there are no duplicates, 0 otherwise. */
+/* ------------------------------------------------------------------------- */
 
-inline int
-Options::key_sort (char *base, int len)
+/* Parses a string denoting key positions.  */
+
+class PositionStringParser
 {
-  T (Trace t ("Options::key_sort");)
-  int i, j;
+public:
+  /* Initializes a key position string parser for string STR.  */
+                        PositionStringParser (const char *str,
+                                              int low_bound, int high_bound,
+                                              int end_word_marker, int error_value, int end_marker);
+  /* Returns the next key position from the given string.  */
+  int                   nextPosition ();
+private:
+  /* A pointer to the string provided by the user.  */
+  const char *          _str;
+  /* Smallest possible value, inclusive.  */
+  int const             _low_bound;
+  /* Greatest possible value, inclusive.  */
+  int const             _high_bound;
+  /* A value marking the abstract "end of word" ( usually '$').  */
+  int const             _end_word_marker;
+  /* Error value returned when input is syntactically erroneous.  */
+  int const             _error_value;
+  /* Value returned after last key is processed.  */
+  int const             _end_marker;
+  /* Intermediate state for producing a range of positions.  */
+  bool                  _in_range;           /* True while producing a range of positions.  */
+  int                   _range_upper_bound;  /* Upper bound (inclusive) of the range.  */
+  int                   _range_curr_value;   /* Last value returned.  */
+};
+
+/* Initializes a key position strng parser for string STR.  */
+PositionStringParser::PositionStringParser (const char *str,
+                                            int low_bound, int high_bound,
+                                            int end_word_marker, int error_value, int end_marker)
+  : _str (str),
+    _low_bound (low_bound),
+    _high_bound (high_bound),
+    _end_word_marker (end_word_marker),
+    _error_value (error_value),
+    _end_marker (end_marker),
+    _in_range (false)
+{
+}
 
-  for (i = 0, j = len - 1; i < j; i++)
+/* Returns the next key position from the given string.  */
+int
+PositionStringParser::nextPosition ()
+{
+  if (_in_range)
+    {
+      /* We are inside a range.  Return the next value from the range.  */
+      if (++_range_curr_value >= _range_upper_bound)
+        _in_range = false;
+      return _range_curr_value;
+    }
+  else
     {
-      int curr, tmp;
+      /* Continue parsing the given string.  */
+      while (*_str)
+        switch (*_str)
+          {
+          case ',':
+            /* Skip the comma.  */
+            _str++;
+            break;
+          case '$':
+            /* Valid key position.  */
+            _str++;
+            return _end_word_marker;
+          case '0': case '1': case '2': case '3': case '4':
+          case '5': case '6': case '7': case '8': case '9':
+            /* Valid key position.  */
+            {
+              int curr_value;
+              for (curr_value = 0; isdigit (static_cast<unsigned char>(*_str)); _str++)
+                curr_value = curr_value * 10 + (*_str - '0');
 
-      for (curr = i + 1,tmp = base[curr]; curr > 0 && tmp >= base[curr - 1]; curr--)
-        if ((base[curr] = base[curr - 1]) == tmp) /* oh no, a duplicate!!! */
-          return 0;
+              if (*_str == '-')
+                {
+                  _str++;
+                  /* Starting a range of key positions.  */
+                  _in_range = true;
 
-      base[curr] = tmp;
-    }
+                  for (_range_upper_bound = 0;
+                       isdigit (static_cast<unsigned char>(*_str));
+                       _str++)
+                    _range_upper_bound = _range_upper_bound * 10 + (*_str - '0');
+
+                  /* Verify range's upper bound.  */
+                  if (!(_range_upper_bound > curr_value && _range_upper_bound <= _high_bound))
+                    return _error_value;
+                  _range_curr_value = curr_value;
+                }
 
-  return 1;
+              /* Verify range's lower bound.  */
+              if (!(curr_value >= _low_bound && curr_value <= _high_bound))
+                return _error_value;
+              return curr_value;
+            }
+          default:
+            /* Invalid syntax.  */
+            return _error_value;
+          }
+
+      return _end_marker;
+    }
 }
 
-/* Sets the default Options. */
+/* ------------------------------------------------------------------------- */
+
+/* Sets the default Options.  */
 
-Options::Options (void)
+Options::Options ()
+  : _option_word (C),
+    _input_file_name (NULL),
+    _output_file_name (NULL),
+    _language (NULL),
+    _jump (DEFAULT_JUMP_VALUE),
+    _initial_asso_value (0),
+    _asso_iterations (0),
+    _total_switches (1),
+    _size_multiple (1),
+    _function_name (DEFAULT_FUNCTION_NAME),
+    _slot_name (DEFAULT_SLOT_NAME),
+    _initializer_suffix (DEFAULT_INITIALIZER_SUFFIX),
+    _class_name (DEFAULT_CLASS_NAME),
+    _hash_name (DEFAULT_HASH_NAME),
+    _wordlist_name (DEFAULT_WORDLIST_NAME),
+    _lengthtable_name (DEFAULT_LENGTHTABLE_NAME),
+    _stringpool_name (DEFAULT_STRINGPOOL_NAME),
+    _delimiters (DEFAULT_DELIMITERS),
+    _key_positions ()
 {
-  T (Trace t ("Options::Options");)
-  key_positions[0]    = WORD_START;
-  key_positions[1]    = WORD_END;
-  key_positions[2]    = EOS;
-  total_keysig_size  = 2;
-  delimiters          = DEFAULT_DELIMITERS;
-  jump                = DEFAULT_JUMP_VALUE;
-  option_word         = DEFAULTCHARS | C;
-  function_name       = DEFAULT_NAME;
-  key_name            = DEFAULT_KEY;
-  initializer_suffix  = DEFAULT_INITIALIZER_SUFFIX;
-  hash_name           = DEFAULT_HASH_NAME;
-  wordlist_name       = DEFAULT_WORDLIST_NAME;
-  class_name          = DEFAULT_CLASS_NAME;
-  total_switches      = size = 1;
-  initial_asso_value  = iterations = 0;
 }
 
-/* Dumps option status when debug is set. */
+/* Dumps option status when debugging is enabled.  */
 
-Options::~Options (void)
+Options::~Options ()
 {
-  T (Trace t ("Options::~Options");)
-  if (option_word & DEBUG)
+  if (_option_word & DEBUG)
     {
-      char *ptr;
-
       fprintf (stderr, "\ndumping Options:"
-               "\nDEBUG is.......: %s"
-               "\nORDER is.......: %s"
                "\nTYPE is........: %s"
-               "\nRANDOM is......: %s"
-               "\nDEFAULTCHARS is: %s"
-               "\nSWITCH is......: %s"
-               "\nNOLENGTH is....: %s"
-               "\nLENTABLE is....: %s"
-               "\nDUP is.........: %s"
-               "\nFAST is........: %s"
-               "\nCOMP is........: %s"
-               "\nNOTYPE is......: %s"
-               "\nGLOBAL is......: %s"
-               "\nCONST is.......: %s"
+               "\nUPPERLOWER is..: %s"
                "\nKRC is.........: %s"
                "\nC is...........: %s"
                "\nANSIC is.......: %s"
                "\nCPLUSPLUS is...: %s"
+               "\nSEVENBIT is....: %s"
+               "\nLENTABLE is....: %s"
+               "\nCOMP is........: %s"
+               "\nCONST is.......: %s"
                "\nENUM is........: %s"
                "\nINCLUDE is.....: %s"
-               "\nSEVENBIT is....: %s"
-               "\niterations = %d"
+               "\nGLOBAL is......: %s"
+               "\nNULLSTRINGS is.: %s"
+               "\nSHAREDLIB is...: %s"
+               "\nSWITCH is......: %s"
+               "\nNOTYPE is......: %s"
+               "\nDUP is.........: %s"
+               "\nNOLENGTH is....: %s"
+               "\nRANDOM is......: %s"
+               "\nDEBUG is.......: %s"
                "\nlookup function name = %s"
                "\nhash function name = %s"
                "\nword list name = %s"
-               "\nkey name = %s"
+               "\nlength table name = %s"
+               "\nstring pool name = %s"
+               "\nslot name = %s"
                "\ninitializer suffix = %s"
+               "\nasso_values iterations = %d"
                "\njump value = %d"
-               "\nmax associated value = %d"
+               "\nhash table size multiplier = %g"
                "\ninitial associated value = %d"
                "\ndelimiters = %s"
                "\nnumber of switch statements = %d\n",
-               option_word & DEBUG ? "enabled" : "disabled",
-               option_word & ORDER ? "enabled" : "disabled",
-               option_word & TYPE ? "enabled" : "disabled",
-               option_word & RANDOM ? "enabled" : "disabled",
-               option_word & DEFAULTCHARS ? "enabled" : "disabled",
-               option_word & SWITCH ? "enabled" : "disabled",
-               option_word & NOLENGTH ? "enabled" : "disabled",
-               option_word & LENTABLE ? "enabled" : "disabled",
-               option_word & DUP ? "enabled" : "disabled",
-               option_word & FAST ? "enabled" : "disabled",
-               option_word & COMP ? "enabled" : "disabled",
-               option_word & NOTYPE ? "enabled" : "disabled",
-               option_word & GLOBAL ? "enabled" : "disabled",
-               option_word & CONST ? "enabled" : "disabled",
-               option_word & KRC ? "enabled" : "disabled",
-               option_word & C ? "enabled" : "disabled",
-               option_word & ANSIC ? "enabled" : "disabled",
-               option_word & CPLUSPLUS ? "enabled" : "disabled",
-               option_word & ENUM ? "enabled" : "disabled",
-               option_word & INCLUDE ? "enabled" : "disabled",
-               option_word & SEVENBIT ? "enabled" : "disabled",
-               iterations,
-               function_name, hash_name, wordlist_name, key_name,
-               initializer_suffix, jump, size - 1, initial_asso_value,
-               delimiters, total_switches);
-      if (option_word & ALLCHARS)
+               _option_word & TYPE ? "enabled" : "disabled",
+               _option_word & UPPERLOWER ? "enabled" : "disabled",
+               _option_word & KRC ? "enabled" : "disabled",
+               _option_word & C ? "enabled" : "disabled",
+               _option_word & ANSIC ? "enabled" : "disabled",
+               _option_word & CPLUSPLUS ? "enabled" : "disabled",
+               _option_word & SEVENBIT ? "enabled" : "disabled",
+               _option_word & LENTABLE ? "enabled" : "disabled",
+               _option_word & COMP ? "enabled" : "disabled",
+               _option_word & CONST ? "enabled" : "disabled",
+               _option_word & ENUM ? "enabled" : "disabled",
+               _option_word & INCLUDE ? "enabled" : "disabled",
+               _option_word & GLOBAL ? "enabled" : "disabled",
+               _option_word & NULLSTRINGS ? "enabled" : "disabled",
+               _option_word & SHAREDLIB ? "enabled" : "disabled",
+               _option_word & SWITCH ? "enabled" : "disabled",
+               _option_word & NOTYPE ? "enabled" : "disabled",
+               _option_word & DUP ? "enabled" : "disabled",
+               _option_word & NOLENGTH ? "enabled" : "disabled",
+               _option_word & RANDOM ? "enabled" : "disabled",
+               _option_word & DEBUG ? "enabled" : "disabled",
+               _function_name, _hash_name, _wordlist_name, _lengthtable_name,
+               _stringpool_name, _slot_name, _initializer_suffix,
+               _asso_iterations, _jump, _size_multiple, _initial_asso_value,
+               _delimiters, _total_switches);
+      if (_key_positions.is_useall())
         fprintf (stderr, "all characters are used in the hash function\n");
+      else
+        {
+          fprintf (stderr, "maximum keysig size = %d\nkey positions are: \n",
+                   _key_positions.get_size());
 
-      fprintf (stderr, "maximum keysig size = %d\nkey positions are: \n",
-               total_keysig_size);
-
-      for (ptr = key_positions; *ptr != EOS; ptr++)
-        if (*ptr == WORD_END)
-          fprintf (stderr, "$\n");
-        else
-          fprintf (stderr, "%d\n", *ptr);
+          PositionIterator iter = _key_positions.iterator();
+          for (int pos; (pos = iter.next()) != PositionIterator::EOS; )
+            if (pos == Positions::LASTCHAR)
+              fprintf (stderr, "$\n");
+            else
+              fprintf (stderr, "%d\n", pos + 1);
+        }
 
       fprintf (stderr, "finished dumping Options\n");
     }
 }
 
 
-/* Parses the command line Options and sets appropriate flags in option_word. */
+/* Sets the output language, if not already set.  */
+void
+Options::set_language (const char *language)
+{
+  if (_language == NULL)
+    {
+      _language = language;
+      _option_word &= ~(KRC | C | ANSIC | CPLUSPLUS);
+      if (!strcmp (language, "KR-C"))
+        _option_word |= KRC;
+      else if (!strcmp (language, "C"))
+        _option_word |= C;
+      else if (!strcmp (language, "ANSI-C"))
+        _option_word |= ANSIC;
+      else if (!strcmp (language, "C++"))
+        _option_word |= CPLUSPLUS;
+      else
+        {
+          fprintf (stderr, "unsupported language option %s, defaulting to C\n",
+                   language);
+          _option_word |= C;
+        }
+    }
+}
+
+/* Sets the total number of switch statements, if not already set.  */
+void
+Options::set_total_switches (int total_switches)
+{
+  if (!(_option_word & SWITCH))
+    {
+      _option_word |= SWITCH;
+      _total_switches = total_switches;
+    }
+}
+
+/* Sets the generated function name, if not already set.  */
+void
+Options::set_function_name (const char *name)
+{
+  if (_function_name == DEFAULT_FUNCTION_NAME)
+    _function_name = name;
+}
+
+/* Sets the keyword key name, if not already set.  */
+void
+Options::set_slot_name (const char *name)
+{
+  if (_slot_name == DEFAULT_SLOT_NAME)
+    _slot_name = name;
+}
+
+/* Sets the struct initializer suffix, if not already set.  */
+void
+Options::set_initializer_suffix (const char *initializers)
+{
+  if (_initializer_suffix == DEFAULT_INITIALIZER_SUFFIX)
+    _initializer_suffix = initializers;
+}
+
+/* Sets the generated class name, if not already set.  */
+void
+Options::set_class_name (const char *name)
+{
+  if (_class_name == DEFAULT_CLASS_NAME)
+    _class_name = name;
+}
+
+/* Sets the hash function name, if not already set.  */
+void
+Options::set_hash_name (const char *name)
+{
+  if (_hash_name == DEFAULT_HASH_NAME)
+    _hash_name = name;
+}
+
+/* Sets the hash table array name, if not already set.  */
+void
+Options::set_wordlist_name (const char *name)
+{
+  if (_wordlist_name == DEFAULT_WORDLIST_NAME)
+    _wordlist_name = name;
+}
+
+/* Sets the length table array name, if not already set.  */
+void
+Options::set_lengthtable_name (const char *name)
+{
+  if (_lengthtable_name == DEFAULT_LENGTHTABLE_NAME)
+    _lengthtable_name = name;
+}
+
+/* Sets the string pool name, if not already set.  */
+void
+Options::set_stringpool_name (const char *name)
+{
+  if (_stringpool_name == DEFAULT_STRINGPOOL_NAME)
+    _stringpool_name = name;
+}
+
+/* Sets the delimiters string, if not already set.  */
+void
+Options::set_delimiters (const char *delimiters)
+{
+  if (_delimiters == DEFAULT_DELIMITERS)
+    _delimiters = delimiters;
+}
+
+
+/* Parses the command line Options and sets appropriate flags in option_word.  */
 
 static const struct option long_options[] =
 {
-  { "delimiters", required_argument, 0, 'e' },
-  { "struct-type", no_argument, 0, 't' },
-  { "language", required_argument, 0, 'L' },
-  { "slot-name", required_argument, 0, 'K' },
-  { "initializer-suffix", required_argument, 0, 'F' },
-  { "hash-fn-name", required_argument, 0, 'H' },
-  { "lookup-fn-name", required_argument, 0, 'N' },
-  { "class-name", required_argument, 0, 'Z' },
-  { "seven-bit", no_argument, 0, '7' },
-  { "compare-strncmp", no_argument, 0, 'c' },
-  { "readonly-tables", no_argument, 0, 'C' },
-  { "enum", no_argument, 0, 'E' },
-  { "includes", no_argument, 0, 'I' },
-  { "global", no_argument, 0, 'G' },
-  { "word-array-name", required_argument, 0, 'W' },
-  { "switch", required_argument, 0, 'S' },
-  { "omit-struct-type", no_argument, 0, 'T' },
-  { "key-positions", required_argument, 0, 'k' },
-  { "compare-strlen", no_argument, 0, 'l' },
-  { "duplicates", no_argument, 0, 'D' },
-  { "fast", required_argument, 0, 'f' },
-  { "initial-asso", required_argument, 0, 'i' },
-  { "jump", required_argument, 0, 'j' },
-  { "no-strlen", no_argument, 0, 'n' },
-  { "occurrence-sort", no_argument, 0, 'o' },
-  { "random", no_argument, 0, 'r' },
-  { "size-multiple", required_argument, 0, 's' },
-  { "help", no_argument, 0, 'h' },
-  { "version", no_argument, 0, 'v' },
-  { "debug", no_argument, 0, 'd' },
-  { 0, no_argument, 0, 0 }
+  { "output-file", required_argument, NULL, CHAR_MAX + 1 },
+  { "ignore-case", no_argument, NULL, CHAR_MAX + 2 },
+  { "delimiters", required_argument, NULL, 'e' },
+  { "struct-type", no_argument, NULL, 't' },
+  { "language", required_argument, NULL, 'L' },
+  { "slot-name", required_argument, NULL, 'K' },
+  { "initializer-suffix", required_argument, NULL, 'F' },
+  { "hash-fn-name", required_argument, NULL, 'H' }, /* backward compatibility */
+  { "hash-function-name", required_argument, NULL, 'H' },
+  { "lookup-fn-name", required_argument, NULL, 'N' }, /* backward compatibility */
+  { "lookup-function-name", required_argument, NULL, 'N' },
+  { "class-name", required_argument, NULL, 'Z' },
+  { "seven-bit", no_argument, NULL, '7' },
+  { "compare-strncmp", no_argument, NULL, 'c' },
+  { "readonly-tables", no_argument, NULL, 'C' },
+  { "enum", no_argument, NULL, 'E' },
+  { "includes", no_argument, NULL, 'I' },
+  { "global-table", no_argument, NULL, 'G' },
+  { "word-array-name", required_argument, NULL, 'W' },
+  { "length-table-name", required_argument, NULL, CHAR_MAX + 4 },
+  { "switch", required_argument, NULL, 'S' },
+  { "omit-struct-type", no_argument, NULL, 'T' },
+  { "key-positions", required_argument, NULL, 'k' },
+  { "compare-strlen", no_argument, NULL, 'l' }, /* backward compatibility */
+  { "compare-lengths", no_argument, NULL, 'l' },
+  { "duplicates", no_argument, NULL, 'D' },
+  { "fast", required_argument, NULL, 'f' },
+  { "initial-asso", required_argument, NULL, 'i' },
+  { "jump", required_argument, NULL, 'j' },
+  { "multiple-iterations", required_argument, NULL, 'm' },
+  { "no-strlen", no_argument, NULL, 'n' },
+  { "occurrence-sort", no_argument, NULL, 'o' },
+  { "optimized-collision-resolution", no_argument, NULL, 'O' },
+  { "pic", no_argument, NULL, 'P' },
+  { "string-pool-name", required_argument, NULL, 'Q' },
+  { "null-strings", no_argument, NULL, CHAR_MAX + 3 },
+  { "random", no_argument, NULL, 'r' },
+  { "size-multiple", required_argument, NULL, 's' },
+  { "help", no_argument, NULL, 'h' },
+  { "version", no_argument, NULL, 'v' },
+  { "debug", no_argument, NULL, 'd' },
+  { NULL, no_argument, NULL, 0 }
 };
 
 void
-Options::operator() (int argc, char *argv[])
+Options::parse_options (int argc, char *argv[])
 {
-  T (Trace t ("Options::operator()");)
-  int    option_char;
+  int option_char;
 
   program_name = argv[0];
-  argument_count  = argc;
-  argument_vector = argv;
+  _argument_count  = argc;
+  _argument_vector = argv;
 
   while ((option_char =
-            getopt_long (argument_count, argument_vector,
-                         "adcCDe:Ef:F:gGhH:i:Ij:k:K:lL:nN:oprs:S:tTvW:Z:7",
-                         long_options, (int *)0))
+            getopt_long (_argument_count, _argument_vector,
+                         "acCdDe:Ef:F:gGhH:i:Ij:k:K:lL:m:nN:oOpPQ:rs:S:tTvW:Z:7",
+                         long_options, NULL))
          != -1)
     {
       switch (option_char)
         {
-        case 'a':               /* Generated code uses the ANSI prototype format. */
-          break;                /* This is now the default. */
-        case 'c':               /* Generate strncmp rather than strcmp. */
+        case 'a':               /* Generated code uses the ANSI prototype format.  */
+          break;                /* This is now the default.  */
+        case 'c':               /* Generate strncmp rather than strcmp.  */
           {
-            option_word |= COMP;
+            _option_word |= COMP;
             break;
           }
-        case 'C':               /* Make the generated tables readonly (const). */
+        case 'C':               /* Make the generated tables readonly (const).  */
           {
-            option_word |= CONST;
+            _option_word |= CONST;
             break;
           }
-        case 'd':               /* Enable debugging option. */
+        case 'd':               /* Enable debugging option.  */
           {
-            option_word |= DEBUG;
+            _option_word |= DEBUG;
             fprintf (stderr, "Starting program %s, version %s, with debugging on.\n",
                              program_name, version_string);
             break;
           }
-        case 'D':               /* Enable duplicate option. */
+        case 'D':               /* Enable duplicate option.  */
           {
-            option_word |= DUP;
+            _option_word |= DUP;
             break;
           }
-        case 'e': /* Allows user to provide keyword/attribute separator */
+        case 'e':               /* Specify keyword/attribute separator */
           {
-            option.delimiters = /*getopt*/optarg;
+            _delimiters = /*getopt*/optarg;
             break;
           }
         case 'E':
           {
-            option_word |= ENUM;
-            break;
-          }
-        case 'f':               /* Generate the hash table ``fast.'' */
-          {
-            option_word |= FAST;
-            if ((iterations = atoi (/*getopt*/optarg)) < 0)
-              {
-                fprintf (stderr, "iterations value must not be negative, assuming 0\n");
-                iterations = 0;
-              }
+            _option_word |= ENUM;
             break;
           }
+        case 'f':               /* Generate the hash table "fast".  */
+          break;                /* Not needed any more.  */
         case 'F':
           {
-            initializer_suffix = /*getopt*/optarg;
+            _initializer_suffix = /*getopt*/optarg;
             break;
           }
-        case 'g':               /* Use the ``inline'' keyword for generated sub-routines, ifdef __GNUC__. */
-          break;                /* This is now the default. */
-        case 'G':               /* Make the keyword table a global variable. */
+        case 'g':               /* Use the 'inline' keyword for generated sub-routines, ifdef __GNUC__.  */
+          break;                /* This is now the default.  */
+        case 'G':               /* Make the keyword table a global variable.  */
           {
-            option_word |= GLOBAL;
+            _option_word |= GLOBAL;
             break;
           }
-        case 'h':               /* Displays a list of helpful Options to the user. */
+        case 'h':               /* Displays a list of helpful Options to the user.  */
           {
             long_usage (stdout);
             exit (0);
           }
-        case 'H':               /* Sets the name for the hash function */
+        case 'H':               /* Sets the name for the hash function.  */
           {
-            hash_name = /*getopt*/optarg;
+            _hash_name = /*getopt*/optarg;
             break;
           }
-        case 'i':               /* Sets the initial value for the associated values array. */
+        case 'i':               /* Sets the initial value for the associated values array.  */
           {
-            if ((initial_asso_value = atoi (/*getopt*/optarg)) < 0)
-              fprintf (stderr, "Initial value %d should be non-zero, ignoring and continuing.\n", initial_asso_value);
+            if ((_initial_asso_value = atoi (/*getopt*/optarg)) < 0)
+              fprintf (stderr, "Initial value %d should be non-zero, ignoring and continuing.\n", _initial_asso_value);
             if (option[RANDOM])
               fprintf (stderr, "warning, -r option superceeds -i, ignoring -i option and continuing\n");
             break;
           }
-        case 'I':               /* Enable #include statements. */
+        case 'I':               /* Enable #include statements.  */
           {
-            option_word |= INCLUDE;
+            _option_word |= INCLUDE;
             break;
           }
-        case 'j':               /* Sets the jump value, must be odd for later algorithms. */
+        case 'j':               /* Sets the jump value, must be odd for later algorithms.  */
           {
-            if ((jump = atoi (/*getopt*/optarg)) < 0)
+            if ((_jump = atoi (/*getopt*/optarg)) < 0)
               {
-                fprintf (stderr, "Jump value %d must be a positive number.\n", jump);
+                fprintf (stderr, "Jump value %d must be a positive number.\n", _jump);
                 short_usage (stderr);
                 exit (1);
               }
-            else if (jump && ((jump % 2) == 0))
-              fprintf (stderr, "Jump value %d should be odd, adding 1 and continuing...\n", jump++);
+            else if (_jump && ((_jump % 2) == 0))
+              fprintf (stderr, "Jump value %d should be odd, adding 1 and continuing...\n", _jump++);
             break;
           }
-        case 'k':               /* Sets key positions used for hash function. */
+        case 'k':               /* Sets key positions used for hash function.  */
           {
-            const int BAD_VALUE = -1;
+            _option_word |= POSITIONS;
+            const int BAD_VALUE = -3;
+            const int EOS = PositionIterator::EOS;
             int       value;
-            Iterator  expand (/*getopt*/optarg, 1, MAX_KEY_POS - 1, WORD_END, BAD_VALUE, EOS);
+            PositionStringParser sparser (/*getopt*/optarg, 1, Positions::MAX_KEY_POS, Positions::LASTCHAR, BAD_VALUE, EOS);
 
             if (/*getopt*/optarg [0] == '*') /* Use all the characters for hashing!!!! */
-              option_word = (option_word & ~DEFAULTCHARS) | ALLCHARS;
+              _key_positions.set_useall(true);
             else
               {
-                char *key_pos;
-
-                for (key_pos = key_positions; (value = expand ()) != EOS; key_pos++)
-                  if (value == BAD_VALUE)
-                    {
-                      fprintf (stderr, "Illegal key value or range, use 1,2,3-%d,'$' or '*'.\n",
-                                       MAX_KEY_POS - 1);
-                      short_usage (stderr);
-                      exit (1);
-                    }
-                  else
-                    *key_pos = value;;
-
-                *key_pos = EOS;
-
-                if (! (total_keysig_size = (key_pos - key_positions)))
+                _key_positions.set_useall(false);
+                int *key_positions = _key_positions.pointer();
+                int *key_pos;
+
+                for (key_pos = key_positions; (value = sparser.nextPosition()) != EOS; key_pos++)
                   {
-                    fprintf (stderr, "No keys selected.\n");
+                    if (value == BAD_VALUE)
+                      {
+                        fprintf (stderr, "Invalid position value or range, use 1,2,3-%d,'$' or '*'.\n",
+                                         Positions::MAX_KEY_POS);
+                        short_usage (stderr);
+                        exit (1);
+                      }
+                    if (key_pos - key_positions == Positions::MAX_SIZE)
+                      {
+                        /* More than Positions::MAX_SIZE key positions.
+                           Since all key positions are in the range
+                           0..Positions::MAX_KEY_POS-1 or == Positions::LASTCHAR,
+                           there must be duplicates.  */
+                        fprintf (stderr, "Duplicate key positions selected\n");
+                        short_usage (stderr);
+                        exit (1);
+                      }
+                    if (value != Positions::LASTCHAR)
+                      /* We use 0-based indices in the class Positions.  */
+                      value = value - 1;
+                    *key_pos = value;
+                  }
+
+                unsigned int total_keysig_size = key_pos - key_positions;
+                if (total_keysig_size == 0)
+                  {
+                    fprintf (stderr, "No key positions selected.\n");
                     short_usage (stderr);
                     exit (1);
                   }
-                else if (! key_sort (key_positions, total_keysig_size))
+                _key_positions.set_size (total_keysig_size);
+
+                /* Sorts the key positions *IN REVERSE ORDER!!*
+                   This makes further routines more efficient.  Especially
+                   when generating code.  */
+                if (! _key_positions.sort())
                   {
-                    fprintf (stderr, "Duplicate keys selected\n");
+                    fprintf (stderr, "Duplicate key positions selected\n");
                     short_usage (stderr);
                     exit (1);
                   }
-
-                if (total_keysig_size != 2
-                    || (key_positions[0] != 1 || key_positions[1] != WORD_END))
-                  option_word &= ~DEFAULTCHARS;
               }
             break;
           }
-        case 'K':               /* Make this the keyname for the keyword component field. */
+        case 'K':               /* Make this the keyname for the keyword component field.  */
           {
-            key_name = /*getopt*/optarg;
+            _slot_name = /*getopt*/optarg;
             break;
           }
-        case 'l':               /* Create length table to avoid extra string compares. */
+        case 'l':               /* Create length table to avoid extra string compares.  */
           {
-            option_word |= LENTABLE;
+            _option_word |= LENTABLE;
             break;
           }
-        case 'L':               /* Deal with different generated languages. */
+        case 'L':               /* Deal with different generated languages.  */
           {
-            option_word &= ~(KRC | C | ANSIC | CPLUSPLUS);
-            if (!strcmp (/*getopt*/optarg, "KR-C"))
-              option_word |= KRC;
-            else if (!strcmp (/*getopt*/optarg, "C"))
-              option_word |= C;
-            else if (!strcmp (/*getopt*/optarg, "ANSI-C"))
-              option_word |= ANSIC;
-            else if (!strcmp (/*getopt*/optarg, "C++"))
-              option_word |= CPLUSPLUS;
-            else
+            _language = NULL;
+            set_language (/*getopt*/optarg);
+            break;
+          }
+        case 'm':               /* Multiple iterations for finding good asso_values.  */
+          {
+            if ((_asso_iterations = atoi (/*getopt*/optarg)) < 0)
               {
-                fprintf (stderr, "unsupported language option %s, defaulting to C\n", /*getopt*/optarg);
-                option_word |= C;
+                fprintf (stderr, "asso_iterations value must not be negative, assuming 0\n");
+                _asso_iterations = 0;
               }
             break;
           }
-        case 'n':               /* Don't include the length when computing hash function. */
+        case 'n':               /* Don't include the length when computing hash function.  */
           {
-            option_word |= NOLENGTH;
+            _option_word |= NOLENGTH;
             break;
           }
-        case 'N':               /* Make generated lookup function name be optarg */
+        case 'N':               /* Make generated lookup function name be optarg.  */
           {
-            function_name = /*getopt*/optarg;
+            _function_name = /*getopt*/optarg;
             break;
           }
-        case 'o':               /* Order input by frequency of key set occurrence. */
+        case 'o':               /* Order input by frequency of key set occurrence.  */
+          break;                /* Not needed any more.  */
+        case 'O':               /* Optimized choice during collision resolution.  */
+          break;                /* Not needed any more.  */
+        case 'p':               /* Generated lookup function a pointer instead of int.  */
+          break;                /* This is now the default.  */
+        case 'P':               /* Optimize for position-independent code.  */
           {
-            option_word |= ORDER;
+            _option_word |= SHAREDLIB;
             break;
           }
-        case 'p':               /* Generated lookup function a pointer instead of int. */
-          break;                /* This is now the default. */
-        case 'r':               /* Utilize randomness to initialize the associated values table. */
+        case 'Q':               /* Sets the name for the string pool.  */
           {
-            option_word |= RANDOM;
-            if (option.initial_asso_value != 0)
-              fprintf (stderr, "warning, -r option superceeds -i, disabling -i option and continuing\n");
+            _stringpool_name = /*getopt*/optarg;
             break;
           }
-        case 's':               /* Range of associated values, determines size of final table. */
+        case 'r':               /* Utilize randomness to initialize the associated values table.  */
           {
-            if (abs (size = atoi (/*getopt*/optarg)) > 50)
-              fprintf (stderr, "%d is excessive, did you really mean this?! (try `%s --help' for help)\n", size, program_name);
+            _option_word |= RANDOM;
+            if (_initial_asso_value != 0)
+              fprintf (stderr, "warning, -r option supersedes -i, disabling -i option and continuing\n");
             break;
           }
-        case 'S':               /* Generate switch statement output, rather than lookup table. */
+        case 's':               /* Range of associated values, determines size of final table.  */
           {
-            option_word |= SWITCH;
-            if ((option.total_switches = atoi (/*getopt*/optarg)) <= 0)
+            float numerator;
+            float denominator = 1;
+            bool invalid = false;
+            char *endptr;
+
+            numerator = strtod (/*getopt*/optarg, &endptr);
+            if (endptr == /*getopt*/optarg)
+              invalid = true;
+            else if (*endptr != '\0')
+              {
+                if (*endptr == '/')
+                  {
+                    char *denomptr = endptr + 1;
+                    denominator = strtod (denomptr, &endptr);
+                    if (endptr == denomptr || *endptr != '\0')
+                      invalid = true;
+                  }
+                else
+                  invalid = true;
+              }
+            if (invalid)
+              {
+                fprintf (stderr, "Invalid value for option -s.\n");
+                short_usage (stderr);
+                exit (1);
+              }
+            _size_multiple = numerator / denominator;
+            /* Backward compatibility: -3 means 1/3.  */
+            if (_size_multiple < 0)
+              _size_multiple = 1 / (-_size_multiple);
+            /* Catch stupid users.  */
+            if (_size_multiple == 0)
+              _size_multiple = 1;
+            /* Warnings.  */
+            if (_size_multiple > 50)
+              fprintf (stderr, "Size multiple %g is excessive, did you really mean this?! (try '%s --help' for help)\n", _size_multiple, program_name);
+            else if (_size_multiple < 0.01f)
+              fprintf (stderr, "Size multiple %g is extremely small, did you really mean this?! (try '%s --help' for help)\n", _size_multiple, program_name);
+            break;
+          }
+        case 'S':               /* Generate switch statement output, rather than lookup table.  */
+          {
+            _option_word |= SWITCH;
+            _total_switches = atoi (/*getopt*/optarg);
+            if (_total_switches <= 0)
               {
                 fprintf (stderr, "number of switches %s must be a positive number\n", /*getopt*/optarg);
                 short_usage (stderr);
@@ -667,33 +989,59 @@ Options::operator() (int argc, char *argv[])
               }
             break;
           }
-        case 't':               /* Enable the TYPE mode, allowing arbitrary user structures. */
+        case 't':               /* Enable the TYPE mode, allowing arbitrary user structures.  */
           {
-            option_word |= TYPE;
+            _option_word |= TYPE;
             break;
           }
-        case 'T':   /* Don't print structure definition. */
+        case 'T':               /* Don't print structure definition.  */
           {
-            option_word |= NOTYPE;
+            _option_word |= NOTYPE;
             break;
           }
-        case 'v':               /* Print out the version and quit. */
+        case 'v':               /* Print out the version and quit.  */
           fprintf (stdout, "GNU gperf %s\n", version_string);
+          fprintf (stdout, "Copyright (C) %s Free Software Foundation, Inc.\n\
+This is free software; see the source for copying conditions.  There is NO\n\
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
+",
+                   "1989-1998, 2000-2004, 2006-2007");
+          fprintf (stdout, "Written by %s and %s.\n",
+                   "Douglas C. Schmidt", "Bruno Haible");
           exit (0);
-        case 'W':               /* Sets the name for the hash table array */
+        case 'W':               /* Sets the name for the hash table array.  */
+          {
+            _wordlist_name = /*getopt*/optarg;
+            break;
+          }
+        case 'Z':               /* Set the class name.  */
           {
-            wordlist_name = /*getopt*/optarg;
+            _class_name = /*getopt*/optarg;
             break;
           }
-        case 'Z':               /* Set the class name. */
+        case '7':               /* Assume 7-bit characters.  */
           {
-            class_name = /*getopt*/optarg;
+            _option_word |= SEVENBIT;
             break;
           }
-        case '7':               /* Assume 7-bit characters. */
+        case CHAR_MAX + 1:      /* Set the output file name.  */
           {
-            option_word |= SEVENBIT;
-            Vectors::ALPHA_SIZE = 128;
+            _output_file_name = /*getopt*/optarg;
+            break;
+          }
+        case CHAR_MAX + 2:      /* Case insignificant.  */
+          {
+            _option_word |= UPPERLOWER;
+            break;
+          }
+        case CHAR_MAX + 3:      /* Use NULL instead of "".  */
+          {
+            _option_word |= NULLSTRINGS;
+            break;
+          }
+        case CHAR_MAX + 4:      /* Sets the name for the length table array.  */
+          {
+            _lengthtable_name = /*getopt*/optarg;
             break;
           }
         default:
@@ -703,14 +1051,10 @@ Options::operator() (int argc, char *argv[])
 
     }
 
-  if (argv[/*getopt*/optind] && ! freopen (argv[/*getopt*/optind], "r", stdin))
-    {
-      fprintf (stderr, "Cannot open keyword file `%s'\n", argv[/*getopt*/optind]);
-      short_usage (stderr);
-      exit (1);
-    }
+  if (/*getopt*/optind < argc)
+    _input_file_name = argv[/*getopt*/optind++];
 
-  if (++/*getopt*/optind < argc)
+  if (/*getopt*/optind < argc)
     {
       fprintf (stderr, "Extra trailing arguments to %s.\n", program_name);
       short_usage (stderr);
@@ -718,6 +1062,8 @@ Options::operator() (int argc, char *argv[])
     }
 }
 
+/* ------------------------------------------------------------------------- */
+
 #ifndef __OPTIMIZE__
 
 #define INLINE /* not inline */