home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / cperf-2.1 / src / options.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-11-11  |  18.1 KB  |  445 lines
  1. /* Handles parsing the Options provided to the user.
  2.    Copyright (C) 1989 Free Software Foundation, Inc.
  3.    written by Douglas C. Schmidt (schmidt@ics.uci.edu)
  4.  
  5. This file is part of GNU GPERF.
  6.  
  7. GNU GPERF is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 1, or (at your option)
  10. any later version.
  11.  
  12. GNU GPERF is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with GNU GPERF; see the file COPYING.  If not, write to
  19. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. #include <stdio.h>
  22. #include <assert.h>
  23. #include "options.h"
  24. #include "iterator.h"
  25. #include "stderr.h"
  26.  
  27. /* Current program version. */
  28. extern char *version_string;
  29.  
  30. /* Size to jump on a collision. */
  31. #define DEFAULT_JUMP_VALUE 5
  32.  
  33. /* Default name for generated lookup function. */
  34. #define DEFAULT_NAME "in_word_set"
  35.  
  36. /* Default name for the key component. */
  37. #define DEFAULT_KEY "name"
  38.  
  39. /* Default name for generated hash function. */
  40. #define DEFAULT_HASH_NAME "hash"
  41.  
  42. /* Globally visible OPTIONS object. */
  43. OPTIONS option;
  44.  
  45. /* Default delimiters that separate keywords from their attributes. */
  46. #define DEFAULT_DELIMITERS ",\n"
  47.  
  48. /* Prints program usage to standard error stream. */
  49.  
  50. void 
  51. usage ()
  52. { 
  53.   report_error ("usage: %n [-acCdDef[num]gGhH<hashname>i<init>jk<keys>\
  54. K<keyname>lnN<name>oprs<size>S<switches>tTv].\n(type %n -h for help)\n");
  55. }
  56.  
  57. /* Sorts the key positions *IN REVERSE ORDER!!*
  58.    This makes further routines more efficient.  Especially when generating code.
  59.    Uses a simple Insertion Sort since the set is probably ordered.
  60.    Returns 1 if there are no duplicates, 0 otherwise. */
  61.  
  62. static int 
  63. key_sort (base, len)
  64.      char *base;
  65.      int   len;
  66. {
  67.   int i, j;
  68.  
  69.   for (i = 0, j = len - 1; i < j; i++) 
  70.     {
  71.       int curr, tmp;
  72.       
  73.       for (curr = i + 1,tmp = base[curr]; curr > 0 && tmp >= base[curr - 1]; curr--) 
  74.         if ((base[curr] = base[curr - 1]) == tmp) /* oh no, a duplicate!!! */
  75.           return 0;
  76.  
  77.       base[curr] = tmp;
  78.     }
  79.  
  80.   return 1;
  81. }
  82.  
  83. /* Dumps option status when debug is set. */
  84.  
  85. void
  86. options_destroy ()
  87. { 
  88.   if (OPTION_ENABLED (option, DEBUG))
  89.     {
  90.       char *ptr;
  91.  
  92.       fprintf (stderr, "\ndumping Options:\nDEBUG is.......: %s\nORDER is.......: %s\
  93. \nANSI is........: %s\nTYPE is........: %s\nGNU is.........: %s\nRANDOM is......: %s\
  94. \nDEFAULTCHARS is: %s\nSWITCH is......: %s\nPOINTER is.....: %s\nNOLENGTH is....: %s\
  95. \nLENTABLE is....: %s\nDUP is.........: %s\nCOMP is........: %s\nFAST is........: %s\
  96. \nNOTYPE is......: %s\nGLOBAL is......: %s\nCONST is.......: %s\niterations = %d\
  97. \nlookup function name = %s\nhash function name = %s\nkey name = %s\
  98. \njump value = %d\nmax associcated value = %d\ninitial associated value = %d\
  99. \ndelimiters = %s\nnumber of switch statements = %d\napproximate switch statement size = %d\n",
  100.                OPTION_ENABLED (option, DEBUG) ? "enabled" : "disabled", 
  101.                OPTION_ENABLED (option, ORDER) ? "enabled" : "disabled",
  102.                OPTION_ENABLED (option, ANSI) ? "enabled" : "disabled",
  103.                OPTION_ENABLED (option, TYPE) ? "enabled" : "disabled",
  104.                OPTION_ENABLED (option, GNU) ? "enabled" : "disabled",
  105.                OPTION_ENABLED (option, RANDOM) ? "enabled" : "disabled",
  106.                OPTION_ENABLED (option, DEFAULTCHARS) ? "enabled" : "disabled",
  107.                OPTION_ENABLED (option, SWITCH) ? "enabled" : "disabled",
  108.                OPTION_ENABLED (option, POINTER) ? "enabled" : "disabled",
  109.                OPTION_ENABLED (option, NOLENGTH) ? "enabled" : "disabled",
  110.                OPTION_ENABLED (option, LENTABLE) ? "enabled" : "disabled",
  111.                OPTION_ENABLED (option, DUP) ? "enabled" : "disabled",
  112.                OPTION_ENABLED (option, COMP) ? "enabled" : "disabled",
  113.                OPTION_ENABLED (option, FAST) ? "enabled" : "disabled",
  114.                OPTION_ENABLED (option, NOTYPE) ? "enabled" : "disabled",
  115.                OPTION_ENABLED (option, GLOBAL) ? "enabled" : "disabled",
  116.                OPTION_ENABLED (option, CONST) ? "enabled" : "disabled",
  117.                option.iterations, option.function_name, option.hash_name,
  118.                option.key_name, option.jump, option.size - 1, 
  119.                option.initial_asso_value, option.delimiters, option.total_switches,
  120.                keyword_list_length () / option.total_switches);
  121.  
  122.       if (OPTION_ENABLED (option, ALLCHARS)) 
  123.         fprintf (stderr, "all characters are used in the hash function\n");
  124.       fprintf (stderr, "maximum charset size = %d\nkey positions are: \n", 
  125.                option.total_charset_size);
  126.  
  127.       for (ptr = option.key_positions; *ptr != EOS; ptr++) 
  128.         if (*ptr == WORD_END) 
  129.           fprintf (stderr, "$\n");
  130.         else 
  131.           fprintf (stderr, "%d\n", *ptr);
  132.  
  133.       fprintf (stderr, "finished dumping Options\n");
  134.     }
  135. }
  136.  
  137. /* Parses the command line Options and sets appropriate flags in option.option_word. */
  138.  
  139. void
  140. options_init (argc, argv)
  141.      int argc;
  142.      char *argv[];
  143. { 
  144.   extern int   optind;
  145.   extern char *optarg;
  146.   int   option_char;
  147.   
  148.   option.key_positions[0]   = WORD_START;
  149.   option.key_positions[1]   = WORD_END;
  150.   option.key_positions[2]   = EOS;
  151.   option.total_charset_size = 2;
  152.   option.jump               = DEFAULT_JUMP_VALUE;
  153.   option.option_word        = (int) DEFAULTCHARS;
  154.   option.function_name      = DEFAULT_NAME;
  155.   option.hash_name          = DEFAULT_HASH_NAME;
  156.   option.key_name           = DEFAULT_KEY;
  157.   option.delimiters         = DEFAULT_DELIMITERS;
  158.   option.initial_asso_value = option.size = option.iterations = 0;
  159.   option.total_switches     = 1;
  160.   option.argument_count     = argc;
  161.   option.argument_vector    = argv;
  162.   set_program_name (argv[0]);
  163.   
  164.   while ((option_char = getopt (argc, argv, "adcCDe:f:gGhH:i:j:k:K:lnN:oprs:S:tTv")) != EOF)
  165.     {
  166.       switch (option_char)
  167.         {
  168.         case 'a':               /* Generated coded uses the ANSI prototype format. */
  169.           { 
  170.             SET_OPTION (option, ANSI);
  171.             break;
  172.           }
  173.         case 'c':               /* Generate strncmp rather than strcmp. */
  174.           {
  175.             SET_OPTION (option, COMP);
  176.             break;
  177.           }
  178.         case 'C':               /* Make the generated tables readonly (const). */
  179.           {
  180.             SET_OPTION (option, CONST);
  181.             break;
  182.           }
  183.         case 'd':               /* Enable debugging option. */
  184.           { 
  185.             SET_OPTION (option, DEBUG);
  186.             report_error ("starting program %n, version %s, with debuggin on.\n",
  187.                           version_string);
  188.             break;
  189.           }   
  190.         case 'D':               /* Enable duplicate option. */
  191.           { 
  192.             SET_OPTION (option, DUP);
  193.             break;
  194.           }   
  195.         case 'e': /* Allows user to provide keyword/attribute separator */
  196.           {
  197.             SET_DELIMITERS (option, optarg);
  198.             break;
  199.           }
  200.         case 'f':               /* Generate the hash table ``fast.'' */
  201.           {
  202.             SET_OPTION (option, FAST);
  203.             if ((option.iterations = atoi (optarg)) < 0) 
  204.               {
  205.                 report_error ("iterations value must not be negative, assuming 0\n");
  206.                 option.iterations = 0;
  207.               }
  208.             break;
  209.           }
  210.         case 'g':               /* Use the ``inline'' keyword for generated sub-routines. */
  211.           { 
  212.             SET_OPTION (option, GNU);
  213.             break;
  214.           }
  215.         case 'G':               /* Make the keyword table a global variable. */
  216.           { 
  217.             SET_OPTION (option, GLOBAL);
  218.             break;
  219.           }
  220.         case 'h':               /* Displays a list of helpful Options to the user. */
  221.           { 
  222.             report_error (
  223. "-a\tGenerate ANSI standard C output code, i.e., function prototypes.\n\
  224. -c\tGenerate comparison code using strncmp rather than strcmp.\n\
  225. -C\tMake the contents of generated lookup tables constant, i.e., readonly.\n\
  226. -d\tEnables the debugging option (produces verbose output to Std_Err).\n\
  227. -D\tHandle keywords that hash to duplicate values.  This is useful\n\
  228. \tfor certain highly redundant keyword sets.  It enables the -S option.\n\
  229. -e\tAllow user to provide a string containing delimiters used to separate\n\
  230. \tkeywords from their attributes.  Default is \",\\n\"\n\
  231. -f\tGenerate the perfect hash function ``fast.''  This decreases GPERF's\n\
  232. \trunning time at the cost of minimizing generated table-size.\n\
  233. \tThe numeric argument represents the number of times to iterate when\n\
  234. \tresolving a collision.  `0' means ``iterate by the number of keywords''.\n\
  235. -g\tAssume a GNU compiler, e.g., g++ or gcc.  This makes all generated\n\
  236. \troutines use the ``inline'' keyword to remove cost of function calls.\n\
  237. -G\tGenerate the static table of keywords as a static global variable,\n\
  238. \trather than hiding it inside of the lookup function (which is the\n\
  239. \tdefault behavior).\n\
  240. -h\tPrints this mesage.\n");
  241.               report_error (
  242. "-H\tAllow user to specify name of generated hash function. Default is `hash'.\n\
  243. -i\tProvide an initial value for the associate values array.  Default is 0.\n\
  244. \tSetting this value larger helps inflate the size of the final table.\n\
  245. -j\tAffects the ``jump value,'' i.e., how far to advance the associated\n\
  246. \tcharacter value upon collisions.  Must be an odd number, default is %d.\n\
  247. -k\tAllows selection of the key positions used in the hash function.\n\
  248. \tThe allowable choices range between 1-%d, inclusive.  The positions\n\
  249. \tare separated by commas, ranges may be used, and key positions may\n\
  250. \toccur in any order.  Also, the meta-character '*' causes the generated\n\
  251. \thash function to consider ALL key positions, and $ indicates the\n\
  252. \t``final character'' of a key, e.g., $,1,2,4,6-10.\n\
  253. -K\tAllow user to select name of the keyword component in the keyword structure.\n\
  254. -l\tCompare key lengths before trying a string comparison.  This helps\n\
  255. \tcut down on the number of string comparisons made during the lookup.\n\
  256. -n\tDo not include the length of the keyword when computing the hash function\n\
  257. -N\tAllow user to specify name of generated lookup function.  Default\n\
  258. \tname is `in_word_set.'\n\
  259. -o\tReorders input keys by frequency of occurrence of the key sets.\n\
  260. \tThis should decrease the search time dramatically.\n\
  261. -p\tChanges the return value of the generated function ``in_word_set''\n\
  262. \tfrom its default boolean value (i.e., 0 or 1), to type ``pointer\n\
  263. \tto wordlist array''  This is most useful when the -t option, allowing\n\
  264. \tuser-defined structs, is used.\n",
  265.                           DEFAULT_JUMP_VALUE, MAX_KEY_POS - 1);
  266.             report_error (
  267. "-r\tUtilizes randomness to initialize the associated values table.\n\
  268. -s\tAffects the size of the generated hash table.  The numeric argument\n\
  269. \tfor this option indicates ``how many times larger'' the table range\n\
  270. \tshould be, in relationship to the number of keys, e.g. a value of 3\n\
  271. \tmeans ``make the table about 3 times larger than the number of input\n\
  272. \tkeys.''  A larger table should decrease the time required for an\n\
  273. \tunsuccessful search, at the expense of extra table space.  Default\n\
  274. \tvalue is 1.  This actual table size may vary somewhat.\n\
  275. -S\tCauses the generated C code to use a switch statement scheme, rather\n\
  276. \tthan an array lookup table.  This can lead to a reduction in both\n\
  277. \ttime and space requirements for some keyfiles.  The argument to\n\
  278. \tthis option determines how many switch statements are generated.\n\
  279. \tA value of 1 generates 1 switch containing all the elements, a value of 2\n\
  280. \tgenerates 2 tables with 1/2 the elements in each table, etc.  This\n\
  281. \tis useful since many C compilers cannot correctly generate code for\n\
  282. \tlarge switch statements.\n\
  283. \tthe expense of longer time for each lookup.  Mostly important for\n\
  284. \t*large* input sets, i.e., greater than around 100 items or so.\n\
  285. -t\tAllows the user to include a structured type declaration for \n\
  286. \tgenerated code. Any text before %%%% is consider part of the type\n\
  287. \tdeclaration.  Key words and additional fields may follow this, one\n\
  288. \tgroup of fields per line.\n\
  289. -T\tPrevents the transfer of the type declaration to the output file.\n\
  290. \tUse this option if the type is already defined elsewhere.\n\
  291. -v\tPrints out the current version number\n%e%a\n",
  292.                           usage);
  293.           }
  294.         case 'H':               /* Sets the name for the hash function */
  295.           {
  296.             option.hash_name = optarg;
  297.             break;
  298.           }
  299.         case 'i':               /* Sets the initial value for the associated values array. */
  300.           { 
  301.             if ((option.initial_asso_value = atoi (optarg)) < 0) 
  302.               report_error ("initial value %d must be non-zero, ignoring and continuing\n", 
  303.                             option.initial_asso_value);
  304.             if (OPTION_ENABLED (option, RANDOM))
  305.               report_error ("warning, -r option superceeds -i, ignoring -i option and continuing\n");
  306.             break;
  307.           }
  308.         case 'j':               /* Sets the jump value, must be odd for later algorithms. */
  309.           { 
  310.             if ((option.jump = atoi (optarg)) < 0)
  311.               report_error ("jump value %d must be a positive number\n%e%a", 
  312.               option.jump, usage);
  313.             else if (option.jump && EVEN (option.jump)) 
  314.               report_error ("jump value %d should be odd, adding 1 and continuing...\n", 
  315.               option.jump++);
  316.             break;
  317.           }
  318.         case 'k':               /* Sets key positions used for hash function. */
  319.           { 
  320.             int BAD_VALUE = -1;
  321.             int value;
  322.  
  323.             iterator_init (optarg, 1, MAX_KEY_POS - 1, WORD_END, BAD_VALUE, EOS);
  324.             
  325.             if (*optarg == '*') /* Use all the characters for hashing!!!! */
  326.               {
  327.                 UNSET_OPTION (option, DEFAULTCHARS);
  328.                 SET_OPTION (option, ALLCHARS);
  329.               }
  330.             else 
  331.               {
  332.                 char *key_pos;
  333.  
  334.                 for (key_pos = option.key_positions; (value = next ()) != EOS; key_pos++)
  335.                   if (value == BAD_VALUE) 
  336.                     report_error ("illegal key value or range, use 1,2,3-%d,'$' or '*'.\n%e%a", 
  337.                     (MAX_KEY_POS - 1),usage);
  338.                   else 
  339.                     *key_pos = value;;
  340.  
  341.                 *key_pos = EOS;
  342.  
  343.                 if (! (option.total_charset_size = (key_pos - option.key_positions))) 
  344.                   report_error ("no keys selected\n%e%a", usage);
  345.                 else if (! key_sort (option.key_positions, option.total_charset_size))
  346.                   report_error ("duplicate keys selected\n%e%a", usage);
  347.  
  348.                 if (option.total_charset_size != 2 
  349.                     || (option.key_positions[0] != 1 || option.key_positions[1] != WORD_END))
  350.                   UNSET_OPTION (option, DEFAULTCHARS);
  351.               }
  352.             break;
  353.           }
  354.         case 'K':               /* Make this the keyname for the keyword component field. */
  355.           {
  356.             option.key_name = optarg;
  357.             break;
  358.           }
  359.         case 'l':               /* Create length table to avoid extra string compares. */
  360.           { 
  361.             SET_OPTION (option, LENTABLE);
  362.             break;
  363.           }
  364.         case 'n':               /* Don't include the length when computing hash function. */
  365.           { 
  366.             SET_OPTION (option, NOLENGTH);
  367.             break; 
  368.           }
  369.         case 'N':               /* Make generated lookup function name be optarg */
  370.           { 
  371.             option.function_name = optarg;
  372.             break;
  373.           }
  374.         case 'o':               /* Order input by frequency of key set occurrence. */
  375.           { 
  376.             SET_OPTION (option, ORDER);
  377.             break;
  378.           }   
  379.         case 'p':               /* Generated lookup function now a pointer instead of int. */
  380.           { 
  381.             SET_OPTION (option, POINTER);
  382.             break;
  383.           }
  384.         case 'r':               /* Utilize randomness to initialize the associated values table. */
  385.           { 
  386.             SET_OPTION (option, RANDOM);
  387.             if (option.initial_asso_value != 0)
  388.               report_error ("warning, -r option superceeds -i, disabling -i option and continuing\n");
  389.             break;
  390.           }
  391.         case 's':               /* Range of associated values, determines size of final table. */
  392.           { 
  393.             if ((option.size = atoi (optarg)) <= 0) 
  394.               report_error ("improper range argument %s\n%e%a", optarg, usage);
  395.             else if (option.size > 50) 
  396.               report_error ("%d is excessive, did you really mean this?! (type %n -h for help)\n", 
  397.               option.size);
  398.             break; 
  399.           }       
  400.         case 'S':               /* Generate switch statement output, rather than lookup table. */
  401.           { 
  402.             SET_OPTION (option, SWITCH);
  403.             if ((option.total_switches = atoi (optarg)) <= 0)
  404.               report_error ("number of switches %s must be a positive number\n%e%a", optarg, usage);
  405.             break;
  406.           }
  407.         case 't':               /* Enable the TYPE mode, allowing arbitrary user structures. */
  408.           { 
  409.             SET_OPTION (option, TYPE);
  410.             break;
  411.           }
  412.         case 'T':               /* Don't print structure definition. */
  413.           {
  414.             SET_OPTION (option, NOTYPE);
  415.             break;
  416.           }
  417.         case 'v':               /* Print out the version and quit. */
  418.           report_error ("%n: version %s\n%e%a\n", version_string, usage);
  419.         default: 
  420.           report_error ("%e%a", usage);
  421.         }
  422.     }
  423.  
  424.   if (argv[optind] && ! freopen (argv[optind], "r", stdin))
  425.     report_error ("unable to read key word file %s\n%e%a", argv[optind], usage);
  426.   
  427.   if (++optind < argc) 
  428.     report_error ("extra trailing arguments to %n\n%e%a", usage);
  429. }
  430.  
  431. /* Output command-line Options. */
  432. void 
  433. print_options ()
  434. { 
  435.   int i;
  436.  
  437.   printf ("/* Command-line: ");
  438.  
  439.   for (i = 0; i < option.argument_count; i++) 
  440.     printf ("%s ", option.argument_vector[i]);
  441.    
  442.   printf (" */\n\n");
  443. }
  444.  
  445.