home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / zip / gnu / gperf.lzh / GPERF / OPTIONS.H < prev    next >
C/C++ Source or Header  |  1993-07-30  |  10KB  |  259 lines
  1. /* This may look like C code, but it is really -*- C++ -*- */
  2.  
  3. /* Handles parsing the Options provided to the user.
  4.  
  5.    Copyright (C) 1989 Free Software Foundation, Inc.
  6.    written by Douglas C. Schmidt (schmidt@ics.uci.edu)
  7.  
  8. This file is part of GNU GPERF.
  9.  
  10. GNU GPERF is free software; you can redistribute it and/or modify
  11. it under the terms of the GNU General Public License as published by
  12. the Free Software Foundation; either version 1, or (at your option)
  13. any later version.
  14.  
  15. GNU GPERF is distributed in the hope that it will be useful,
  16. but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18. GNU General Public License for more details.
  19.  
  20. You should have received a copy of the GNU General Public License
  21. along with GNU GPERF; see the file COPYING.  If not, write to
  22. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  23.  
  24. /* This module provides a uniform interface to the various options available
  25.    to a user of the gperf hash function generator.  In addition to the
  26.    run-time options, found in the Option_Type below, there is also the
  27.    hash table Size and the Keys to be used in the hashing.
  28.    The overall design of this module was an experiment in using C++
  29.    classes as a mechanism to enhance centralization of option and
  30.    and error handling, which tend to get out of hand in a C program. */
  31.  
  32. #pragma once
  33. #include "std-err.h"
  34. #include "trace.h"
  35.  
  36. /* Enumerate the potential debugging Options. */
  37.  
  38. enum Option_Type
  39. {
  40.   DEBUG        = 01,            /* Enable debugging (prints diagnostics to Std_Err). */
  41.   ORDER        = 02,            /* Apply ordering heuristic to speed-up search time. */
  42.   ANSI         = 04,            /* Generate ANSI prototypes. */
  43.   ALLCHARS     = 010,           /* Use all characters in hash function. */
  44.   GNU          = 020,           /* Assume GNU extensions (primarily function inline). */
  45.   TYPE         = 040,           /* Handle user-defined type structured keyword input. */
  46.   RANDOM       = 0100,          /* Randomly initialize the associated values table. */
  47.   DEFAULTCHARS = 0200,          /* Make default char positions be 1,$ (end of keyword). */
  48.   SWITCH       = 0400,          /* Generate switch output to save space. */
  49.   POINTER      = 01000,         /* Have in_word_set function return pointer, not boolean. */
  50.   NOLENGTH     = 02000,         /* Don't include keyword length in hash computations. */
  51.   LENTABLE     = 04000,         /* Generate a length table for string comparison. */
  52.   DUP          = 010000,        /* Handle duplicate hash values for keywords. */
  53.   FAST         = 020000,        /* Generate the hash function ``fast.'' */
  54.   NOTYPE       = 040000,        /* Don't include user-defined type definition in output -- it's already defined elsewhere. */
  55.   COMP         = 0100000,       /* Generate strncmp rather than strcmp. */
  56.   GLOBAL       = 0200000,       /* Make the keyword table a global variable. */
  57.   CONST        = 0400000,       /* Make the generated tables readonly (const). */
  58.   CPLUSPLUS    = 01000000,      /* Generate C++ code. */
  59.   C            = 02000000,      /* Generate C code. */
  60.   ENUM           = 04000000,    /* Use enum for constants. */
  61. };
  62.  
  63. /* Define some useful constants (these don't really belong here, but I'm
  64.    not sure where else to put them!).  These should be consts, but g++
  65.    doesn't seem to do the right thing with them at the moment... ;-( */
  66.  
  67. enum 
  68. {
  69.   MAX_KEY_POS = 128 - 1,    /* Max size of each word's key set. */
  70.   WORD_START = 1,           /* Signals the start of a word. */
  71.   WORD_END = 0,             /* Signals the end of a word. */
  72.   EOS = MAX_KEY_POS,        /* Signals end of the key list. */
  73. };
  74.  
  75. /* Class manager for gperf program Options. */
  76.  
  77. class Options : private Std_Err
  78. {
  79. public:
  80.                       Options (void);
  81.                      ~Options (void);
  82.   int                 operator[] (Option_Type option);
  83.   void                operator() (int argc, char *argv[]);
  84.   void                operator= (enum Option_Type);
  85.   void                operator!= (enum Option_Type);
  86.   static void         print_options (void);
  87.   static void         set_asso_max (int r);
  88.   static int          get_asso_max (void);
  89.   static void         reset (void);
  90.   static int          get (void);
  91.   static int          get_iterations (void);
  92.   static int          get_max_keysig_size (void);
  93.   static void         set_keysig_size (int);
  94.   static int          get_jump (void);
  95.   static int          initial_value (void);
  96.   static int          get_total_switches (void);
  97.   static const char  *get_function_name (void);
  98.   static const char  *get_key_name (void);
  99.   static const char  *get_class_name (void);
  100.   static const char  *get_hash_name (void);
  101.   static const char  *get_delimiter (void);
  102.  
  103. private:
  104.   const int           DEFAULT_JUMP_VALUE = 5;             /* Size to jump on a collision. */
  105.   const char         *const DEFAULT_NAME = "in_word_set"; /* Default name for generated lookup function. */
  106.   const char         *const DEFAULT_KEY = "name";         /* Default name for the key component. */
  107.   const char         *const DEFAULT_CLASS_NAME = "Perfect_Hash"; /* Default name for the generated class. */
  108.   const char         *const DEFAULT_HASH_NAME = "hash";   /* Default name for generated hash function. */
  109.   const char         *const DEFAULT_DELIMITERS = ",\n";   /* Default delimiters that separate keywords from their attributes. */
  110.   static int          option_word;                        /* Holds the user-specified Options. */
  111.   static int          total_switches;                     /* Number of switch statements to generate. */     
  112.   static int          total_keysig_size;                 /* Total number of distinct key_positions. */
  113.   static int          size;                               /* Range of the hash table. */
  114.   static int          key_pos;                            /* Tracks current key position for Iterator. */
  115.   static int          jump;                               /* Jump length when trying alternative values. */
  116.   static int          initial_asso_value;                 /* Initial value for asso_values table. */
  117.   static int          argument_count;                     /* Records count of command-line arguments. */
  118.   static int          iterations;                         /* Amount to iterate when a collision occurs. */
  119.   static char       **argument_vector;                    /* Stores a pointer to command-line vector. */
  120.   static const char  *function_name;                      /* Names used for generated lookup function. */
  121.   static const char  *key_name;                           /* Name used for keyword key. */
  122.   static const char  *class_name;                         /* Name used for generated C++ class. */
  123.   static const char  *hash_name;                          /* Name used for generated hash function. */
  124.   static const char  *delimiters;                         /* Separates keywords from other attributes. */
  125.   static char         key_positions[MAX_KEY_POS];         /* Contains user-specified key choices. */
  126.   static int          key_sort (char *base, int len);     /* Sorts key positions in REVERSE order. */
  127.   static void         usage (void);                       /* Prints proper program usage. */
  128. };
  129.  
  130. /* Global option coordinator for the entire program. */
  131. extern Options option;       
  132.  
  133. #ifdef __OPTIMIZE__
  134.  
  135. inline int  
  136. Options::operator[] (Option_Type option) /* True if option enable, else false. */
  137. { 
  138.   T (Trace t ("Options::operator[]");)
  139.   return option_word & option;
  140. }
  141.  
  142. inline void
  143. Options::operator = (enum Option_Type opt) /* Enables option OPT. */
  144. {
  145.   option_word |= opt;
  146. }
  147.  
  148. inline void
  149. Options::operator != (enum Option_Type opt) /* Disables option OPT. */
  150. {
  151.   option_word &= ~opt;
  152. }
  153.  
  154. inline void 
  155. Options::reset (void) /* Initializes the key Iterator. */
  156. { 
  157.   T (Trace t ("Options::reset");)
  158.   key_pos = 0;
  159. }
  160.  
  161. inline int 
  162. Options::get (void) /* Returns current key_position and advanced index. */
  163. { 
  164.   T (Trace t ("Options::get");)
  165.   return key_positions[key_pos++];
  166. }
  167.  
  168. inline void 
  169. Options::set_asso_max (int r) /* Sets the size of the table size. */
  170. { 
  171.   T (Trace t ("Options::set_asso_max");)
  172.   size = r;
  173. }
  174.  
  175. inline int 
  176. Options::get_asso_max (void) /* Returns the size of the table size. */
  177. { 
  178.   T (Trace t ("Options::get_asso_max");)
  179.   return size;
  180. }
  181.  
  182. inline int 
  183. Options::get_max_keysig_size (void) /* Returns total distinct key positions. */
  184. { 
  185.   T (Trace t ("Options::get_max_keysig_size");)
  186.   return total_keysig_size;
  187. }
  188.  
  189. inline void
  190. Options::set_keysig_size (int size) /* Sets total distinct key positions. */
  191. { 
  192.   T (Trace t ("Options::set_keysig_size");)
  193.   total_keysig_size = size;
  194. }
  195.  
  196. inline int 
  197. Options::get_jump (void) /* Returns the jump value. */
  198. { 
  199.   T (Trace t ("Options::get_jump");)
  200.   return jump;
  201. }
  202.  
  203. inline const char *
  204. Options::get_function_name (void) /* Returns the generated function name. */
  205. { 
  206.   T (Trace t ("Options::get_function_name");)
  207.   return function_name;
  208. }
  209.  
  210. inline const char *
  211. Options::get_key_name (void) /* Returns the keyword key name. */
  212. {
  213.   T (Trace t ("Options::get_key_name");)
  214.   return key_name;
  215. }
  216.  
  217. inline const char *
  218. Options::get_hash_name (void) /* Returns the hash function name. */
  219. {
  220.   T (Trace t ("Options::get_hash_name");)
  221.   return hash_name;
  222. }
  223.  
  224. inline const char *
  225. Options::get_class_name (void) /* Returns the generated class name. */
  226. {
  227.   T (Trace t ("Options::get_class_name");)
  228.   return class_name;
  229. }
  230.  
  231. inline int 
  232. Options::initial_value (void) /* Returns the initial associated character value. */
  233. { 
  234.   T (Trace t ("Options::initial_value");)
  235.   return initial_asso_value;
  236. }
  237.  
  238. inline int 
  239. Options::get_iterations (void) /* Returns the iterations value. */
  240. { 
  241.   T (Trace t ("Options::get_iterations");)
  242.   return iterations;
  243. }
  244.  
  245. inline const char *
  246. Options::get_delimiter () /* Returns the string used to delimit keywords from other attributes. */
  247. {
  248.   T (Trace t ("Options::get_delimiter");)
  249.   return delimiters;
  250. }
  251.  
  252. inline int
  253. Options::get_total_switches () /* Gets the total number of switch statements to generate. */
  254. {
  255.   T (Trace t ("Options::get_total_switches");)
  256.   return total_switches;
  257. }
  258. #endif
  259.