/* Handles parsing the Options provided to the user.   Copyright (C) 1989 Free Software Foundation, Inc.   written by Douglas C. Schmidt (schmidt@ics.uci.edu)This file is part of GNU GPERF.GNU GPERF is free software; you can redistribute it and/or modifyit under the terms of the GNU General Public License as published bythe Free Software Foundation; either version 1, 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 ofMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See theGNU General Public License for more details.You should have received a copy of the GNU General Public Licensealong with GNU GPERF; see the file COPYING.  If not, write tothe Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */#include <stdio.h>#include <builtin.h>#include <assert.h>#include <GetOpt.h>#include "options.h"#include "iterator.h"/* Global option coordinator for the entire program. */Options option;       /* Current program version. */extern char *version_string;/* 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 the key component. */static const char *const DEFAULT_KEY = "name";/* Default name for the generated class. */static const char *const DEFAULT_CLASS_NAME = "Perfect_Hash";/* Default name for generated hash function. */static const char *const DEFAULT_HASH_NAME = "hash";/* 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::class_name;const char *Options::hash_name;const char *Options::delimiters;char Options::key_positions[MAX_KEY_POS];/* Prints program usage to standard error stream. */inline void Options::usage (void) {   T (Trace t ("Options::usage");)  report_error ("Usage: %n [-acCdDef[num]gGhH<hashname>i<init>jk<keys>K<keyname>lL<language>nN<function name>oprs<size>S<switches>tTvZ<class name>].\n"                "(type %n -h for help)\n");}/* Output command-line Options. */void Options::print_options (void){   T (Trace t ("Options::print_options");)  int i;  printf ("/* Command-line: ");  for (i = 0; i < argument_count; i++)     printf ("%s ", argument_vector[i]);     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) {  T (Trace t ("Options::key_sort");)  int i, j;  for (i = 0, j = len - 1; i < j; i++)     {      int curr, tmp;            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;      base[curr] = tmp;    }  return 1;}/* Sets the default Options. */Options::Options (void) {   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;  hash_name           = DEFAULT_HASH_NAME;  class_name          = DEFAULT_CLASS_NAME;  total_switches      = size = 1;  initial_asso_value  = iterations = 0;}/* Dumps option status when debug is set. */Options::~Options (void) {   T (Trace t ("Options::~Options");)  if (option_word & DEBUG)    {      char *ptr;      fprintf (stderr, "\ndumping Options:\nDEBUG is.......: %s\nORDER is.......: %s"               "\nANSI is........: %s\nTYPE is........: %s\nGNU is.........: %s"               "\nRANDOM is......: %s\nDEFAULTCHARS is: %s\nSWITCH is......: %s"               "\nPOINTER 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"               "\nCPLUSPLUS is...: %s\nC is...........: %s\nENUM is.....: %s"               "\niterations = %d\nlookup function name = %s\nhash function name = %s"               "\nkey name = %s\njump value = %d\nmax associcated value = %d"               "\ninitial associated value = %d\ndelimiters = %s\nnumber of switch statements = %d\n",               option_word & DEBUG ? "enabled" : "disabled",                option_word & ORDER ? "enabled" : "disabled",               option_word & ANSI ? "enabled" : "disabled",               option_word & TYPE ? "enabled" : "disabled",               option_word & GNU ? "enabled" : "disabled",               option_word & RANDOM ? "enabled" : "disabled",               option_word & DEFAULTCHARS ? "enabled" : "disabled",               option_word & SWITCH ? "enabled" : "disabled",               option_word & POINTER ? "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 & CPLUSPLUS ? "enabled" : "disabled",               option_word & C ? "enabled" : "disabled",               option_word & ENUM ? "enabled" : "disabled",               iterations, function_name, hash_name, key_name, jump, size - 1,               initial_asso_value, delimiters, total_switches);      if (option_word & ALLCHARS)         fprintf (stderr, "all characters are used in the hash function\n");      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);      fprintf (stderr, "finished dumping Options\n");    }}/* Parses the command line Options and sets appropriate flags in option_word. */void Options::operator() (int argc, char *argv[]){   T (Trace t ("Options::operator()");)  GetOpt getopt (argc, argv, "adcCDe:Ef:gGhH:i:j:k:K:lL:nN:oprs:S:tTvZ:");  int    option_char;  set_program_name (argv[0]);  argument_count  = argc;  argument_vector = argv;  while ((option_char = getopt ()) != -1)    {      switch (option_char)        {        case 'a':               /* Generated coded uses the ANSI prototype format. */          {             option_word |= ANSI;            break;          }        case 'c':               /* Generate strncmp rather than strcmp. */          {            option_word |= COMP;            break;          }        case 'C':               /* Make the generated tables readonly (const). */          {            option_word |= CONST;            break;          }        case 'd':               /* Enable debugging option. */          {             option_word |= DEBUG;            report_error ("Starting program %n, version %s, with debuggin on.\n",                          version_string);            break;          }           case 'D':               /* Enable duplicate option. */          {             option_word |= DUP;            break;          }           case 'e': /* Allows user to provide keyword/attribute separator */          {            option.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)               {                report_error ("iterations value must not be negative, assuming 0\n");                iterations = 0;              }            break;          }        case 'g':               /* Use the ``inline'' keyword for generated sub-routines. */          {             option_word |= GNU;            break;          }        case 'G':               /* Make the keyword table a global variable. */          {                                                 option_word |= GLOBAL;            break;          }        case 'h':               /* Displays a list of helpful Options to the user. */          {             report_error (                          "-a\tGenerate ANSI standard C output code, i.e., function prototypes.\n"                          "-c\tGenerate comparison code using strncmp rather than strcmp.\n"                          "-C\tMake the contents of generated lookup tables constant, i.e., readonly.\n"                          "-d\tEnables the debugging option (produces verbose output to the standard error).\n"                          "-D\tHandle keywords that hash to duplicate values.  This is useful\n"                          "\tfor certain highly redundant keyword sets.  It enables the -S option.\n"                          "-e\tAllow user to provide a string containing delimiters used to separate\n"                          "\tkeywords from their attributes.  Default is \",\\n\"\n"                          "-E\tDefine constant values using an enum local to the lookup function\n"                          "\trather than with defines\n"                          "-f\tGenerate the gen-perf.hash function ``fast.''  This decreases GPERF's\n"                          "\trunning time at the cost of minimizing generated table-size.\n"                          "\tThe numeric argument represents the number of times to iterate when\n"                          "\tresolving a collision.  `0' means ``iterate by the number of keywords.''\n"                          "-g\tAssume a GNU compiler, e.g., g++ or gcc.  This makes all generated\n"                          "\troutines use the ``inline'' keyword to remove cost of function calls.\n"                          "-G\tGenerate the static table of keywords as a static global variable,\n"                          "\trather than hiding it inside of the lookup function (which is the\n"                          "\tdefault behavior).\n"                          "-h\tPrints this mesage.\n"                          "-H\tAllow user to specify name of generated hash function. Default\n"                          "\tis `hash'.\n"                          "-i\tProvide an initial value for the associate values array.  Default is 0.\n"                          "\tSetting this value larger helps inflate the size of the final table.\n"                          "-j\tAffects the ``jump value,'' i.e., how far to advance the associated\n"                          "\tcharacter value upon collisions.  Must be an odd number, default is %d.\n"                          "-k\tAllows selection of the key positions used in the hash function.\n"                          "\tThe allowable choices range between 1-%d, inclusive.  The positions\n"                          "\tare separated by commas, ranges may be used, and key positions may\n"                          "\toccur in any order.  Also, the meta-character '*' causes the generated\n"                          "\thash function to consider ALL key positions, and $ indicates the\n"                          "\t``final character'' of a key, e.g., $,1,2,4,6-10.\n"                          "-K\tAllow use to select name of the keyword component in the keyword structure.\n"                          "-l\tCompare key lengths before trying a string comparison.  This helps\n"                          "\tcut down on the number of string comparisons made during the lookup.\n"                          "-L\tGenerates code in the language specified by the option's argument.  Languages\n"                          "\thandled are currently C++ and C.  The default is C.\n"                          "-n\tDo not include the length of the keyword when computing the hash function\n"                          "-N\tAllow user to specify name of generated lookup function.  Default\n"                          "\tname is `in_word_set.'\n"                          "-o\tReorders input keys by frequency of occurrence of the key sets.\n"                          "\tThis should decrease the search time dramatically.\n"                          "-p\tChanges the return value of the generated function ``in_word_set''\n"                          "\tfrom its default boolean value (i.e., 0 or 1), to type ``pointer\n"                          "\tto wordlist array''  This is most useful when the -t option, allowing\n"                          "\tuser-defined structs, is used.\n"                          "-r\tUtilizes randomness to initialize the associated values table.\n"                          "-s\tAffects the size of the generated hash table.  The numeric argument\n"