home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / GCC / GERLIB_DEV08B.LHA / gerlib / libg++ / gperf / src / options.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-12  |  9.3 KB  |  257 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. #ifndef options_h
  33. #define options_h 1
  34.  
  35. #include "std-err.h"
  36. #include "trace.h"
  37.  
  38. /* Enumerate the potential debugging Options. */
  39.  
  40. enum Option_Type
  41. {
  42.   DEBUG        = 01,            /* Enable debugging (prints diagnostics to Std_Err). */
  43.   ORDER        = 02,            /* Apply ordering heuristic to speed-up search time. */
  44.   ANSI         = 04,            /* Generate ANSI prototypes. */
  45.   ALLCHARS     = 010,           /* Use all characters in hash function. */
  46.   GNU          = 020,           /* Assume GNU extensions (primarily function inline). */
  47.   TYPE         = 040,           /* Handle user-defined type structured keyword input. */
  48.   RANDOM       = 0100,          /* Randomly initialize the associated values table. */
  49.   DEFAULTCHARS = 0200,          /* Make default char positions be 1,$ (end of keyword). */
  50.   SWITCH       = 0400,          /* Generate switch output to save space. */
  51.   POINTER      = 01000,         /* Have in_word_set function return pointer, not boolean. */
  52.   NOLENGTH     = 02000,         /* Don't include keyword length in hash computations. */
  53.   LENTABLE     = 04000,         /* Generate a length table for string comparison. */
  54.   DUP          = 010000,        /* Handle duplicate hash values for keywords. */
  55.   FAST         = 020000,        /* Generate the hash function ``fast.'' */
  56.   NOTYPE       = 040000,        /* Don't include user-defined type definition in output -- it's already defined elsewhere. */
  57.   COMP         = 0100000,       /* Generate strncmp rather than strcmp. */
  58.   GLOBAL       = 0200000,       /* Make the keyword table a global variable. */
  59.   CONST        = 0400000,       /* Make the generated tables readonly (const). */
  60.   CPLUSPLUS    = 01000000,      /* Generate C++ code. */
  61.   C            = 02000000,      /* Generate C code. */
  62.   ENUM           = 04000000,    /* Use enum for constants. */
  63. };
  64.  
  65. /* Define some useful constants (these don't really belong here, but I'm
  66.    not sure where else to put them!).  These should be consts, but g++
  67.    doesn't seem to do the right thing with them at the moment... ;-( */
  68.  
  69. enum 
  70. {
  71.   MAX_KEY_POS = 128 - 1,    /* Max size of each word's key set. */
  72.   WORD_START = 1,           /* Signals the start of a word. */
  73.   WORD_END = 0,             /* Signals the end of a word. */
  74.   EOS = MAX_KEY_POS,        /* Signals end of the key list. */
  75. };
  76.  
  77. /* Class manager for gperf program Options. */
  78.  
  79. class Options : private Std_Err
  80. {
  81. public:
  82.                       Options (void);
  83.                      ~Options (void);
  84.   int                 operator[] (Option_Type option);
  85.   void                operator() (int argc, char *argv[]);
  86.   void                operator= (enum Option_Type);
  87.   void                operator!= (enum Option_Type);
  88.   static void         print_options (void);
  89.   static void         set_asso_max (int r);
  90.   static int          get_asso_max (void);
  91.   static void         reset (void);
  92.   static int          get (void);
  93.   static int          get_iterations (void);
  94.   static int          get_max_keysig_size (void);
  95.   static void         set_keysig_size (int);
  96.   static int          get_jump (void);
  97.   static int          initial_value (void);
  98.   static int          get_total_switches (void);
  99.   static const char  *get_function_name (void);
  100.   static const char  *get_key_name (void);
  101.   static const char  *get_class_name (void);
  102.   static const char  *get_hash_name (void);
  103.   static const char  *get_delimiter (void);
  104.  
  105. private:
  106.   static int          option_word;                        /* Holds the user-specified Options. */
  107.   static int          total_switches;                     /* Number of switch statements to generate. */     
  108.   static int          total_keysig_size;                 /* Total number of distinct key_positions. */
  109.   static int          size;                               /* Range of the hash table. */
  110.   static int          key_pos;                            /* Tracks current key position for Iterator. */
  111.   static int          jump;                               /* Jump length when trying alternative values. */
  112.   static int          initial_asso_value;                 /* Initial value for asso_values table. */
  113.   static int          argument_count;                     /* Records count of command-line arguments. */
  114.   static int          iterations;                         /* Amount to iterate when a collision occurs. */
  115.   static char       **argument_vector;                    /* Stores a pointer to command-line vector. */
  116.   static const char  *function_name;                      /* Names used for generated lookup function. */
  117.   static const char  *key_name;                           /* Name used for keyword key. */
  118.   static const char  *class_name;                         /* Name used for generated C++ class. */
  119.   static const char  *hash_name;                          /* Name used for generated hash function. */
  120.   static const char  *delimiters;                         /* Separates keywords from other attributes. */
  121.   static char         key_positions[MAX_KEY_POS];         /* Contains user-specified key choices. */
  122.   static int          key_sort (char *base, int len);     /* Sorts key positions in REVERSE order. */
  123.   static void         usage (void);                       /* Prints proper program usage. */
  124. };
  125.  
  126. /* Global option coordinator for the entire program. */
  127. extern Options option;       
  128.  
  129. #ifdef __OPTIMIZE__
  130.  
  131. inline int  
  132. Options::operator[] (Option_Type option) /* True if option enable, else false. */
  133. { 
  134.   T (Trace t ("Options::operator[]");)
  135.   return option_word & option;
  136. }
  137.  
  138. inline void
  139. Options::operator = (enum Option_Type opt) /* Enables option OPT. */
  140. {
  141.   option_word |= opt;
  142. }
  143.  
  144. inline void
  145. Options::operator != (enum Option_Type opt) /* Disables option OPT. */
  146. {
  147.   option_word &= ~opt;
  148. }
  149.  
  150. inline void 
  151. Options::reset (void) /* Initializes the key Iterator. */
  152. { 
  153.   T (Trace t ("Options::reset");)
  154.   key_pos = 0;
  155. }
  156.  
  157. inline int 
  158. Options::get (void) /* Returns current key_position and advanced index. */
  159. { 
  160.   T (Trace t ("Options::get");)
  161.   return key_positions[key_pos++];
  162. }
  163.  
  164. inline void 
  165. Options::set_asso_max (int r) /* Sets the size of the table size. */
  166. { 
  167.   T (Trace t ("Options::set_asso_max");)
  168.   size = r;
  169. }
  170.  
  171. inline int 
  172. Options::get_asso_max (void) /* Returns the size of the table size. */
  173. { 
  174.   T (Trace t ("Options::get_asso_max");)
  175.   return size;
  176. }
  177.  
  178. inline int 
  179. Options::get_max_keysig_size (void) /* Returns total distinct key positions. */
  180. { 
  181.   T (Trace t ("Options::get_max_keysig_size");)
  182.   return total_keysig_size;
  183. }
  184.  
  185. inline void
  186. Options::set_keysig_size (int size) /* Sets total distinct key positions. */
  187. { 
  188.   T (Trace t ("Options::set_keysig_size");)
  189.   total_keysig_size = size;
  190. }
  191.  
  192. inline int 
  193. Options::get_jump (void) /* Returns the jump value. */
  194. { 
  195.   T (Trace t ("Options::get_jump");)
  196.   return jump;
  197. }
  198.  
  199. inline const char *
  200. Options::get_function_name (void) /* Returns the generated function name. */
  201. { 
  202.   T (Trace t ("Options::get_function_name");)
  203.   return function_name;
  204. }
  205.  
  206. inline const char *
  207. Options::get_key_name (void) /* Returns the keyword key name. */
  208. {
  209.   T (Trace t ("Options::get_key_name");)
  210.   return key_name;
  211. }
  212.  
  213. inline const char *
  214. Options::get_hash_name (void) /* Returns the hash function name. */
  215. {
  216.   T (Trace t ("Options::get_hash_name");)
  217.   return hash_name;
  218. }
  219.  
  220. inline const char *
  221. Options::get_class_name (void) /* Returns the generated class name. */
  222. {
  223.   T (Trace t ("Options::get_class_name");)
  224.   return class_name;
  225. }
  226.  
  227. inline int 
  228. Options::initial_value (void) /* Returns the initial associated character value. */
  229. { 
  230.   T (Trace t ("Options::initial_value");)
  231.   return initial_asso_value;
  232. }
  233.  
  234. inline int 
  235. Options::get_iterations (void) /* Returns the iterations value. */
  236. { 
  237.   T (Trace t ("Options::get_iterations");)
  238.   return iterations;
  239. }
  240.  
  241. inline const char *
  242. Options::get_delimiter () /* Returns the string used to delimit keywords from other attributes. */
  243. {
  244.   T (Trace t ("Options::get_delimiter");)
  245.   return delimiters;
  246. }
  247.  
  248. inline int
  249. Options::get_total_switches () /* Gets the total number of switch statements to generate. */
  250. {
  251.   T (Trace t ("Options::get_total_switches");)
  252.   return total_switches;
  253. }
  254. #endif
  255.  
  256. #endif
  257.