2 Copyright (C) 1989-1998, 2000, 2002-2004, 2006-2007 Free Software Foundation, Inc.
3 Written by Douglas C. Schmidt <schmidt@ics.uci.edu>
4 and Bruno Haible <bruno@clisp.org>.
6 This file is part of GNU GPERF.
8 GNU GPERF is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU GPERF is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; see the file COPYING.
20 If not, write to the Free Software Foundation, Inc.,
21 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
27 #include <string.h> /* declares strncpy(), strchr() */
28 #include <ctype.h> /* declares isprint() */
29 #include <assert.h> /* defines assert() */
30 #include <limits.h> /* defines SCHAR_MAX etc. */
34 /* The "const " qualifier. */
35 static const char *const_always;
37 /* The "const " qualifier, for read-only arrays. */
38 static const char *const_readonly_array;
40 /* The "const " qualifier, for the array type. */
41 static const char *const_for_struct;
43 /* Returns the smallest unsigned C type capable of holding integers
47 smallest_integral_type (int n)
49 if (n <= UCHAR_MAX) return "unsigned char";
50 if (n <= USHRT_MAX) return "unsigned short";
51 return "unsigned int";
54 /* Returns the smallest signed C type capable of holding integers
58 smallest_integral_type (int min, int max)
60 if (option[ANSIC] | option[CPLUSPLUS])
61 if (min >= SCHAR_MIN && max <= SCHAR_MAX) return "signed char";
62 if (min >= SHRT_MIN && max <= SHRT_MAX) return "short";
66 /* ------------------------------------------------------------------------- */
69 Note about the keyword list starting at head:
70 - The list is ordered by increasing _hash_value. This has been achieved
72 - Duplicates, i.e. keywords with the same _selchars set, are chained
73 through the _duplicate_link pointer. Only one representative per
74 duplicate equivalence class remains on the linear keyword list.
75 - Accidental duplicates, i.e. keywords for which the _asso_values[] search
76 couldn't achieve different hash values, cannot occur on the linear
77 keyword list. Search::optimize would catch this mistake.
79 Output::Output (KeywordExt_List *head, const char *struct_decl,
80 unsigned int struct_decl_lineno, const char *return_type,
81 const char *struct_tag, const char *verbatim_declarations,
82 const char *verbatim_declarations_end,
83 unsigned int verbatim_declarations_lineno,
84 const char *verbatim_code, const char *verbatim_code_end,
85 unsigned int verbatim_code_lineno, bool charset_dependent,
86 int total_keys, int max_key_len, int min_key_len,
87 const Positions& positions, const unsigned int *alpha_inc,
88 int total_duplicates, unsigned int alpha_size,
89 const int *asso_values)
90 : _head (head), _struct_decl (struct_decl),
91 _struct_decl_lineno (struct_decl_lineno), _return_type (return_type),
92 _struct_tag (struct_tag),
93 _verbatim_declarations (verbatim_declarations),
94 _verbatim_declarations_end (verbatim_declarations_end),
95 _verbatim_declarations_lineno (verbatim_declarations_lineno),
96 _verbatim_code (verbatim_code),
97 _verbatim_code_end (verbatim_code_end),
98 _verbatim_code_lineno (verbatim_code_lineno),
99 _charset_dependent (charset_dependent),
100 _total_keys (total_keys),
101 _max_key_len (max_key_len), _min_key_len (min_key_len),
102 _key_positions (positions), _alpha_inc (alpha_inc),
103 _total_duplicates (total_duplicates), _alpha_size (alpha_size),
104 _asso_values (asso_values)
108 /* ------------------------------------------------------------------------- */
110 /* Computes the minimum and maximum hash values, and stores them
111 in _min_hash_value and _max_hash_value. */
114 Output::compute_min_max ()
116 /* Since the list is already sorted by hash value all we need to do is
117 to look at the first and the last element of the list. */
119 _min_hash_value = _head->first()->_hash_value;
121 KeywordExt_List *temp;
122 for (temp = _head; temp->rest(); temp = temp->rest())
124 _max_hash_value = temp->first()->_hash_value;
127 /* ------------------------------------------------------------------------- */
129 /* Returns the number of different hash values. */
132 Output::num_hash_values () const
134 /* Since the list is already sorted by hash value and doesn't contain
135 duplicates, we can simply count the number of keywords on the list. */
137 for (KeywordExt_List *temp = _head; temp; temp = temp->rest())
142 /* -------------------- Output_Constants and subclasses -------------------- */
144 /* This class outputs an enumeration defining some constants. */
146 struct Output_Constants
148 virtual void output_start () = 0;
149 virtual void output_item (const char *name, int value) = 0;
150 virtual void output_end () = 0;
151 Output_Constants () {}
152 virtual ~Output_Constants () {}
155 /* This class outputs an enumeration in #define syntax. */
157 struct Output_Defines : public Output_Constants
159 virtual void output_start ();
160 virtual void output_item (const char *name, int value);
161 virtual void output_end ();
163 virtual ~Output_Defines () {}
166 void Output_Defines::output_start ()
171 void Output_Defines::output_item (const char *name, int value)
173 printf ("#define %s %d\n", name, value);
176 void Output_Defines::output_end ()
180 /* This class outputs an enumeration using 'enum'. */
182 struct Output_Enum : public Output_Constants
184 virtual void output_start ();
185 virtual void output_item (const char *name, int value);
186 virtual void output_end ();
187 Output_Enum (const char *indent)
188 : _indentation (indent) {}
189 virtual ~Output_Enum () {}
191 const char *_indentation;
195 void Output_Enum::output_start ()
199 _indentation, _indentation);
200 _pending_comma = false;
203 void Output_Enum::output_item (const char *name, int value)
207 printf ("%s %s = %d", _indentation, name, value);
208 _pending_comma = true;
211 void Output_Enum::output_end ()
215 printf ("%s };\n\n", _indentation);
218 /* Outputs the maximum and minimum hash values etc. */
221 Output::output_constants (struct Output_Constants& style) const
223 style.output_start ();
224 style.output_item ("TOTAL_KEYWORDS", _total_keys);
225 style.output_item ("MIN_WORD_LENGTH", _min_key_len);
226 style.output_item ("MAX_WORD_LENGTH", _max_key_len);
227 style.output_item ("MIN_HASH_VALUE", _min_hash_value);
228 style.output_item ("MAX_HASH_VALUE", _max_hash_value);
232 /* ------------------------------------------------------------------------- */
234 /* We use a downcase table because when called repeatedly, the code
237 if (c >= 'A' && c <= 'Z')
240 #define USE_DOWNCASE_TABLE 1
242 #if USE_DOWNCASE_TABLE
244 /* Output gperf's ASCII-downcase table. */
247 output_upperlower_table ()
251 printf ("#ifndef GPERF_DOWNCASE\n"
252 "#define GPERF_DOWNCASE 1\n"
253 "static unsigned char gperf_downcase[256] =\n"
255 for (c = 0; c < 256; c++)
259 printf (" %3d", c >= 'A' && c <= 'Z' ? c + 'a' - 'A' : c);
270 /* Output gperf's ASCII-case insensitive strcmp replacement. */
273 output_upperlower_strcmp ()
275 printf ("#ifndef GPERF_CASE_STRCMP\n"
276 "#define GPERF_CASE_STRCMP 1\n"
278 "gperf_case_strcmp ");
279 printf (option[KRC] ?
281 " register char *s1;\n"
282 " register char *s2;\n" :
285 " register const char *s1;\n"
286 " register const char *s2;\n" :
287 option[ANSIC] | option[CPLUSPLUS] ?
288 "(register const char *s1, register const char *s2)\n" :
290 #if USE_DOWNCASE_TABLE
294 " unsigned char c1 = gperf_downcase[(unsigned char)*s1++];\n"
295 " unsigned char c2 = gperf_downcase[(unsigned char)*s2++];\n"
296 " if (c1 != 0 && c1 == c2)\n"
298 " return (int)c1 - (int)c2;\n"
305 " unsigned char c1 = *s1++;\n"
306 " unsigned char c2 = *s2++;\n"
307 " if (c1 >= 'A' && c1 <= 'Z')\n"
308 " c1 += 'a' - 'A';\n"
309 " if (c2 >= 'A' && c2 <= 'Z')\n"
310 " c2 += 'a' - 'A';\n"
311 " if (c1 != 0 && c1 == c2)\n"
313 " return (int)c1 - (int)c2;\n"
317 printf ("#endif\n\n");
320 /* Output gperf's ASCII-case insensitive strncmp replacement. */
323 output_upperlower_strncmp ()
325 printf ("#ifndef GPERF_CASE_STRNCMP\n"
326 "#define GPERF_CASE_STRNCMP 1\n"
328 "gperf_case_strncmp ");
329 printf (option[KRC] ?
331 " register char *s1;\n"
332 " register char *s2;\n"
333 " register unsigned int n;\n" :
336 " register const char *s1;\n"
337 " register const char *s2;\n"
338 " register unsigned int n;\n" :
339 option[ANSIC] | option[CPLUSPLUS] ?
340 "(register const char *s1, register const char *s2, register unsigned int n)\n" :
342 #if USE_DOWNCASE_TABLE
346 " unsigned char c1 = gperf_downcase[(unsigned char)*s1++];\n"
347 " unsigned char c2 = gperf_downcase[(unsigned char)*s2++];\n"
348 " if (c1 != 0 && c1 == c2)\n"
353 " return (int)c1 - (int)c2;\n"
361 " unsigned char c1 = *s1++;\n"
362 " unsigned char c2 = *s2++;\n"
363 " if (c1 >= 'A' && c1 <= 'Z')\n"
364 " c1 += 'a' - 'A';\n"
365 " if (c2 >= 'A' && c2 <= 'Z')\n"
366 " c2 += 'a' - 'A';\n"
367 " if (c1 != 0 && c1 == c2)\n"
372 " return (int)c1 - (int)c2;\n"
377 printf ("#endif\n\n");
380 /* Output gperf's ASCII-case insensitive memcmp replacement. */
383 output_upperlower_memcmp ()
385 printf ("#ifndef GPERF_CASE_MEMCMP\n"
386 "#define GPERF_CASE_MEMCMP 1\n"
388 "gperf_case_memcmp ");
389 printf (option[KRC] ?
391 " register char *s1;\n"
392 " register char *s2;\n"
393 " register unsigned int n;\n" :
396 " register const char *s1;\n"
397 " register const char *s2;\n"
398 " register unsigned int n;\n" :
399 option[ANSIC] | option[CPLUSPLUS] ?
400 "(register const char *s1, register const char *s2, register unsigned int n)\n" :
402 #if USE_DOWNCASE_TABLE
406 " unsigned char c1 = gperf_downcase[(unsigned char)*s1++];\n"
407 " unsigned char c2 = gperf_downcase[(unsigned char)*s2++];\n"
413 " return (int)c1 - (int)c2;\n"
421 " unsigned char c1 = *s1++;\n"
422 " unsigned char c2 = *s2++;\n"
423 " if (c1 >= 'A' && c1 <= 'Z')\n"
424 " c1 += 'a' - 'A';\n"
425 " if (c2 >= 'A' && c2 <= 'Z')\n"
426 " c2 += 'a' - 'A';\n"
432 " return (int)c1 - (int)c2;\n"
437 printf ("#endif\n\n");
440 /* ------------------------------------------------------------------------- */
442 /* Outputs a keyword, as a string: enclosed in double quotes, escaping
443 backslashes, double quote and unprintable characters. */
446 output_string (const char *key, int len)
449 for (; len > 0; len--)
451 unsigned char c = static_cast<unsigned char>(*key++);
454 if (c == '"' || c == '\\')
460 /* Use octal escapes, not hexadecimal escapes, because some old
461 C compilers didn't understand hexadecimal escapes, and because
462 hexadecimal escapes are not limited to 2 digits, thus needing
463 special care if the following character happens to be a digit. */
465 putchar ('0' + ((c >> 6) & 7));
466 putchar ('0' + ((c >> 3) & 7));
467 putchar ('0' + (c & 7));
473 /* ------------------------------------------------------------------------- */
475 /* Outputs a #line directive, referring to the given line number. */
478 output_line_directive (unsigned int lineno)
480 const char *file_name = option.get_input_file_name ();
481 if (file_name != NULL)
483 printf ("#line %u ", lineno);
484 output_string (file_name, strlen (file_name));
489 /* ------------------------------------------------------------------------- */
491 /* Outputs a type and a const specifier (i.e. "const " or "").
492 The output is terminated with a space. */
495 output_const_type (const char *const_string, const char *type_string)
497 if (type_string[strlen(type_string)-1] == '*')
498 /* For pointer types, put the 'const' after the type. */
499 printf ("%s %s", type_string, const_string);
501 /* For scalar or struct types, put the 'const' before the type. */
502 printf ("%s%s ", const_string, type_string);
505 /* ----------------------- Output_Expr and subclasses ----------------------- */
507 /* This class outputs a general expression. */
511 virtual void output_expr () const = 0;
513 virtual ~Output_Expr () {}
516 /* This class outputs an expression formed by a single string. */
518 struct Output_Expr1 : public Output_Expr
520 virtual void output_expr () const;
521 Output_Expr1 (const char *piece1) : _p1 (piece1) {}
522 virtual ~Output_Expr1 () {}
527 void Output_Expr1::output_expr () const
534 /* This class outputs an expression formed by the concatenation of two
537 struct Output_Expr2 : public Output_Expr
539 virtual void output_expr () const;
540 Output_Expr2 (const char *piece1, const char *piece2)
541 : _p1 (piece1), _p2 (piece2) {}
542 virtual ~Output_Expr2 () {}
548 void Output_Expr2::output_expr () const
550 printf ("%s%s", _p1, _p2);
555 /* --------------------- Output_Compare and subclasses --------------------- */
557 /* This class outputs a comparison expression. */
559 struct Output_Compare
561 /* Outputs the comparison expression.
562 expr1 outputs a simple expression of type 'const char *' referring to
563 the string being looked up. expr2 outputs a simple expression of type
564 'const char *' referring to the constant string stored in the gperf
565 generated hash table. */
566 virtual void output_comparison (const Output_Expr& expr1,
567 const Output_Expr& expr2) const = 0;
568 /* Outputs the comparison expression for the first byte.
569 Returns true if the this comparison is complete. */
570 bool output_firstchar_comparison (const Output_Expr& expr1,
571 const Output_Expr& expr2) const;
573 virtual ~Output_Compare () {}
576 bool Output_Compare::output_firstchar_comparison (const Output_Expr& expr1,
577 const Output_Expr& expr2) const
579 /* First, we emit a comparison of the first byte of the two strings.
580 This catches most cases where the string being looked up is not in the
581 hash table but happens to have the same hash code as an element of the
583 if (option[UPPERLOWER])
585 /* Incomplete comparison, just for speedup. */
586 printf ("(((unsigned char)*");
587 expr1.output_expr ();
588 printf (" ^ (unsigned char)*");
589 expr2.output_expr ();
590 printf (") & ~32) == 0");
595 /* Complete comparison. */
597 expr1.output_expr ();
599 expr2.output_expr ();
604 /* This class outputs a comparison using strcmp. */
606 struct Output_Compare_Strcmp : public Output_Compare
608 virtual void output_comparison (const Output_Expr& expr1,
609 const Output_Expr& expr2) const;
610 Output_Compare_Strcmp () {}
611 virtual ~Output_Compare_Strcmp () {}
614 void Output_Compare_Strcmp::output_comparison (const Output_Expr& expr1,
615 const Output_Expr& expr2) const
617 bool firstchar_done = output_firstchar_comparison (expr1, expr2);
619 if (option[UPPERLOWER])
620 printf ("gperf_case_");
624 expr1.output_expr ();
626 expr2.output_expr ();
631 expr1.output_expr ();
633 expr2.output_expr ();
638 /* This class outputs a comparison using strncmp.
639 Note that the length of expr1 will be available through the local variable
642 struct Output_Compare_Strncmp : public Output_Compare
644 virtual void output_comparison (const Output_Expr& expr1,
645 const Output_Expr& expr2) const;
646 Output_Compare_Strncmp () {}
647 virtual ~Output_Compare_Strncmp () {}
650 void Output_Compare_Strncmp::output_comparison (const Output_Expr& expr1,
651 const Output_Expr& expr2) const
653 bool firstchar_done = output_firstchar_comparison (expr1, expr2);
655 if (option[UPPERLOWER])
656 printf ("gperf_case_");
657 printf ("strncmp (");
660 expr1.output_expr ();
662 expr2.output_expr ();
663 printf (" + 1, len - 1");
667 expr1.output_expr ();
669 expr2.output_expr ();
673 expr2.output_expr ();
674 printf ("[len] == '\\0'");
677 /* This class outputs a comparison using memcmp.
678 Note that the length of expr1 (available through the local variable 'len')
679 must be verified to be equal to the length of expr2 prior to this
682 struct Output_Compare_Memcmp : public Output_Compare
684 virtual void output_comparison (const Output_Expr& expr1,
685 const Output_Expr& expr2) const;
686 Output_Compare_Memcmp () {}
687 virtual ~Output_Compare_Memcmp () {}
690 void Output_Compare_Memcmp::output_comparison (const Output_Expr& expr1,
691 const Output_Expr& expr2) const
693 bool firstchar_done = output_firstchar_comparison (expr1, expr2);
695 if (option[UPPERLOWER])
696 printf ("gperf_case_");
700 expr1.output_expr ();
702 expr2.output_expr ();
703 printf (" + 1, len - 1");
707 expr1.output_expr ();
709 expr2.output_expr ();
715 /* ------------------------------------------------------------------------- */
717 /* Generates a C expression for an asso_values[] reference. */
720 Output::output_asso_values_ref (int pos) const
722 printf ("asso_values[");
723 /* Always cast to unsigned char. This is necessary when the alpha_inc
724 is nonzero, and also avoids a gcc warning "subscript has type 'char'". */
725 printf ("(unsigned char)");
726 if (pos == Positions::LASTCHAR)
727 printf ("str[len - 1]");
730 printf ("str[%d]", pos);
732 printf ("+%u", _alpha_inc[pos]);
737 /* Generates C code for the hash function that returns the
738 proper encoding for each keyword.
739 The hash function has the signature
740 unsigned int <hash> (const char *str, unsigned int len). */
743 Output::output_hash_function () const
745 /* Output the function's head. */
746 if (option[CPLUSPLUS])
748 else if (option[KRC] | option[C] | option[ANSIC])
749 printf ("#ifdef __GNUC__\n"
752 "#ifdef __cplusplus\n"
757 if (/* The function does not use the 'str' argument? */
758 _key_positions.get_size() == 0
759 || /* The function uses 'str', but not the 'len' argument? */
761 && _key_positions[0] < _min_key_len
762 && _key_positions[_key_positions.get_size() - 1] != Positions::LASTCHAR))
764 printf ("/*ARGSUSED*/\n");
766 if (option[KRC] | option[C] | option[ANSIC])
768 printf ("unsigned int\n");
769 if (option[CPLUSPLUS])
770 printf ("%s::", option.get_class_name ());
771 printf ("%s ", option.get_hash_name ());
772 printf (option[KRC] ?
774 " register char *str;\n"
775 " register unsigned int len;\n" :
778 " register const char *str;\n"
779 " register unsigned int len;\n" :
780 option[ANSIC] | option[CPLUSPLUS] ?
781 "(register const char *str, register unsigned int len)\n" :
784 /* Note that when the hash function is called, it has already been verified
785 that min_key_len <= len <= max_key_len. */
787 /* Output the function's body. */
790 /* First the asso_values array. */
791 if (_key_positions.get_size() > 0)
793 printf (" static %s%s asso_values[] =\n"
795 const_readonly_array,
796 smallest_integral_type (_max_hash_value + 1));
798 const int columns = 10;
800 /* Calculate maximum number of digits required for MAX_HASH_VALUE. */
802 for (int trunc = _max_hash_value; (trunc /= 10) > 0;)
805 for (unsigned int count = 0; count < _alpha_size; count++)
809 if ((count % columns) == 0)
811 printf ("%*d", field_width, _asso_values[count]);
818 if (_key_positions.get_size() == 0)
820 /* Trivial case: No key positions at all. */
821 printf (" return %s;\n",
822 option[NOLENGTH] ? "0" : "len");
826 /* Iterate through the key positions. Remember that Positions::sort()
827 has sorted them in decreasing order, with Positions::LASTCHAR coming
829 PositionIterator iter = _key_positions.iterator(_max_key_len);
832 /* Get the highest key position. */
833 key_pos = iter.next ();
835 if (key_pos == Positions::LASTCHAR || key_pos < _min_key_len)
837 /* We can perform additional optimizations here:
838 Write it out as a single expression. Note that the values
839 are added as 'int's even though the asso_values array may
840 contain 'unsigned char's or 'unsigned short's. */
842 printf (" return %s",
843 option[NOLENGTH] ? "" : "len + ");
845 if (_key_positions.get_size() == 2
846 && _key_positions[0] == 0
847 && _key_positions[1] == Positions::LASTCHAR)
848 /* Optimize special case of "-k 1,$". */
850 output_asso_values_ref (Positions::LASTCHAR);
852 output_asso_values_ref (0);
856 for (; key_pos != Positions::LASTCHAR; )
858 output_asso_values_ref (key_pos);
859 if ((key_pos = iter.next ()) != PositionIterator::EOS)
865 if (key_pos == Positions::LASTCHAR)
866 output_asso_values_ref (Positions::LASTCHAR);
873 /* We've got to use the correct, but brute force, technique. */
874 printf (" register int hval = %s;\n\n"
878 option[NOLENGTH] ? "0" : "len",
879 option[NOLENGTH] ? "len" : "hval");
881 while (key_pos != Positions::LASTCHAR && key_pos >= _max_key_len)
882 if ((key_pos = iter.next ()) == PositionIterator::EOS)
885 if (key_pos != PositionIterator::EOS && key_pos != Positions::LASTCHAR)
891 printf (" /*FALLTHROUGH*/\n"); /* Pacify lint. */
892 for ( ; i > key_pos; i--)
893 printf (" case %d:\n", i);
895 printf (" hval += ");
896 output_asso_values_ref (key_pos);
899 key_pos = iter.next ();
901 while (key_pos != PositionIterator::EOS && key_pos != Positions::LASTCHAR);
903 if (i >= _min_key_len)
904 printf (" /*FALLTHROUGH*/\n"); /* Pacify lint. */
905 for ( ; i >= _min_key_len; i--)
906 printf (" case %d:\n", i);
912 if (key_pos == Positions::LASTCHAR)
915 output_asso_values_ref (Positions::LASTCHAR);
923 /* ------------------------------------------------------------------------- */
925 /* Prints out a table of keyword lengths, for use with the
926 comparison code in generated function 'in_word_set'.
927 Only called if option[LENTABLE]. */
930 Output::output_keylength_table () const
932 const int columns = 14;
933 const char * const indent = option[GLOBAL] ? "" : " ";
935 printf ("%sstatic %s%s %s[] =\n"
937 indent, const_readonly_array,
938 smallest_integral_type (_max_key_len),
939 option.get_lengthtable_name (),
942 /* Generate an array of lengths, similar to output_keyword_table. */
945 KeywordExt_List *temp;
948 for (temp = _head, index = 0; temp; temp = temp->rest())
950 KeywordExt *keyword = temp->first();
952 /* If generating a switch statement, and there is no user defined type,
953 we generate non-duplicates directly in the code. Only duplicates go
955 if (option[SWITCH] && !option[TYPE] && !keyword->_duplicate_link)
958 if (index < keyword->_hash_value && !option[SWITCH] && !option[DUP])
960 /* Some blank entries. */
961 for ( ; index < keyword->_hash_value; index++)
965 if ((column++ % columns) == 0)
966 printf ("\n%s ", indent);
973 if ((column++ % columns) == 0)
974 printf("\n%s ", indent);
975 printf ("%3d", keyword->_allchars_length);
978 /* Deal with duplicates specially. */
979 if (keyword->_duplicate_link) // implies option[DUP]
980 for (KeywordExt *links = keyword->_duplicate_link; links; links = links->_duplicate_link)
983 if ((column++ % columns) == 0)
984 printf("\n%s ", indent);
985 printf ("%3d", links->_allchars_length);
990 printf ("\n%s };\n", indent);
995 /* ------------------------------------------------------------------------- */
997 /* Prints out the string pool, containing the strings of the keyword table.
998 Only called if option[SHAREDLIB]. */
1001 Output::output_string_pool () const
1003 const char * const indent = option[TYPE] || option[GLOBAL] ? "" : " ";
1005 KeywordExt_List *temp;
1007 printf ("%sstruct %s_t\n"
1009 indent, option.get_stringpool_name (), indent);
1010 for (temp = _head, index = 0; temp; temp = temp->rest())
1012 KeywordExt *keyword = temp->first();
1014 /* If generating a switch statement, and there is no user defined type,
1015 we generate non-duplicates directly in the code. Only duplicates go
1017 if (option[SWITCH] && !option[TYPE] && !keyword->_duplicate_link)
1020 if (!option[SWITCH] && !option[DUP])
1021 index = keyword->_hash_value;
1023 printf ("%s char %s_str%d[sizeof(",
1024 indent, option.get_stringpool_name (), index);
1025 output_string (keyword->_allchars, keyword->_allchars_length);
1028 /* Deal with duplicates specially. */
1029 if (keyword->_duplicate_link) // implies option[DUP]
1030 for (KeywordExt *links = keyword->_duplicate_link; links; links = links->_duplicate_link)
1031 if (!(links->_allchars_length == keyword->_allchars_length
1032 && memcmp (links->_allchars, keyword->_allchars,
1033 keyword->_allchars_length) == 0))
1036 printf ("%s char %s_str%d[sizeof(",
1037 indent, option.get_stringpool_name (), index);
1038 output_string (links->_allchars, links->_allchars_length);
1047 printf ("%sstatic %sstruct %s_t %s_contents =\n"
1049 indent, const_readonly_array, option.get_stringpool_name (),
1050 option.get_stringpool_name (), indent);
1051 for (temp = _head, index = 0; temp; temp = temp->rest())
1053 KeywordExt *keyword = temp->first();
1055 /* If generating a switch statement, and there is no user defined type,
1056 we generate non-duplicates directly in the code. Only duplicates go
1058 if (option[SWITCH] && !option[TYPE] && !keyword->_duplicate_link)
1064 if (!option[SWITCH] && !option[DUP])
1065 index = keyword->_hash_value;
1069 output_string (keyword->_allchars, keyword->_allchars_length);
1071 /* Deal with duplicates specially. */
1072 if (keyword->_duplicate_link) // implies option[DUP]
1073 for (KeywordExt *links = keyword->_duplicate_link; links; links = links->_duplicate_link)
1074 if (!(links->_allchars_length == keyword->_allchars_length
1075 && memcmp (links->_allchars, keyword->_allchars,
1076 keyword->_allchars_length) == 0))
1082 output_string (links->_allchars, links->_allchars_length);
1091 printf ("%s#define %s ((%schar *) &%s_contents)\n",
1092 indent, option.get_stringpool_name (), const_always,
1093 option.get_stringpool_name ());
1098 /* ------------------------------------------------------------------------- */
1101 output_keyword_entry (KeywordExt *temp, int stringpool_index, const char *indent)
1104 output_line_directive (temp->_lineno);
1105 printf ("%s ", indent);
1108 if (option[SHAREDLIB])
1109 printf ("(int)(long)&((struct %s_t *)0)->%s_str%d",
1110 option.get_stringpool_name (), option.get_stringpool_name (),
1113 output_string (temp->_allchars, temp->_allchars_length);
1116 if (strlen (temp->_rest) > 0)
1117 printf (",%s", temp->_rest);
1121 printf (" /* hash value = %d, index = %d */",
1122 temp->_hash_value, temp->_final_index);
1126 output_keyword_blank_entries (int count, const char *indent)
1131 columns = 58 / (4 + (option[SHAREDLIB] ? 2 : option[NULLSTRINGS] ? 8 : 2)
1132 + strlen (option.get_initializer_suffix()));
1138 columns = (option[SHAREDLIB] ? 9 : option[NULLSTRINGS] ? 4 : 9);
1141 for (int i = 0; i < count; i++)
1143 if ((column % columns) == 0)
1147 printf ("%s ", indent);
1156 if (option[SHAREDLIB])
1160 if (option[NULLSTRINGS])
1161 printf ("(char*)0");
1166 printf ("%s}", option.get_initializer_suffix());
1171 /* Prints out the array containing the keywords for the hash function. */
1174 Output::output_keyword_table () const
1176 const char *indent = option[GLOBAL] ? "" : " ";
1178 KeywordExt_List *temp;
1180 printf ("%sstatic ",
1182 output_const_type (const_readonly_array, _wordlist_eltype);
1185 option.get_wordlist_name (),
1188 /* Generate an array of reserved words at appropriate locations. */
1190 for (temp = _head, index = 0; temp; temp = temp->rest())
1192 KeywordExt *keyword = temp->first();
1194 /* If generating a switch statement, and there is no user defined type,
1195 we generate non-duplicates directly in the code. Only duplicates go
1197 if (option[SWITCH] && !option[TYPE] && !keyword->_duplicate_link)
1203 if (index < keyword->_hash_value && !option[SWITCH] && !option[DUP])
1205 /* Some blank entries. */
1206 output_keyword_blank_entries (keyword->_hash_value - index, indent);
1208 index = keyword->_hash_value;
1211 keyword->_final_index = index;
1213 output_keyword_entry (keyword, index, indent);
1215 /* Deal with duplicates specially. */
1216 if (keyword->_duplicate_link) // implies option[DUP]
1217 for (KeywordExt *links = keyword->_duplicate_link; links; links = links->_duplicate_link)
1219 links->_final_index = ++index;
1221 int stringpool_index =
1222 (links->_allchars_length == keyword->_allchars_length
1223 && memcmp (links->_allchars, keyword->_allchars,
1224 keyword->_allchars_length) == 0
1225 ? keyword->_final_index
1226 : links->_final_index);
1227 output_keyword_entry (links, stringpool_index, indent);
1235 printf ("%s };\n\n", indent);
1238 /* ------------------------------------------------------------------------- */
1240 /* Generates the large, sparse table that maps hash values into
1241 the smaller, contiguous range of the keyword table. */
1244 Output::output_lookup_array () const
1248 const int DEFAULT_VALUE = -1;
1250 /* Because of the way output_keyword_table works, every duplicate set is
1251 stored contiguously in the wordlist array. */
1252 struct duplicate_entry
1254 int hash_value; /* Hash value for this particular duplicate set. */
1255 int index; /* Index into the main keyword storage array. */
1256 int count; /* Number of consecutive duplicates at this index. */
1259 duplicate_entry *duplicates = new duplicate_entry[_total_duplicates];
1260 int *lookup_array = new int[_max_hash_value + 1 + 2*_total_duplicates];
1261 int lookup_array_size = _max_hash_value + 1;
1262 duplicate_entry *dup_ptr = &duplicates[0];
1263 int *lookup_ptr = &lookup_array[_max_hash_value + 1 + 2*_total_duplicates];
1265 while (lookup_ptr > lookup_array)
1266 *--lookup_ptr = DEFAULT_VALUE;
1268 /* Now dup_ptr = &duplicates[0] and lookup_ptr = &lookup_array[0]. */
1270 for (KeywordExt_List *temp = _head; temp; temp = temp->rest())
1272 int hash_value = temp->first()->_hash_value;
1273 lookup_array[hash_value] = temp->first()->_final_index;
1275 fprintf (stderr, "keyword = %.*s, index = %d\n",
1276 temp->first()->_allchars_length, temp->first()->_allchars, temp->first()->_final_index);
1277 if (temp->first()->_duplicate_link)
1279 /* Start a duplicate entry. */
1280 dup_ptr->hash_value = hash_value;
1281 dup_ptr->index = temp->first()->_final_index;
1284 for (KeywordExt *ptr = temp->first()->_duplicate_link; ptr; ptr = ptr->_duplicate_link)
1289 "static linked keyword = %.*s, index = %d\n",
1290 ptr->_allchars_length, ptr->_allchars, ptr->_final_index);
1292 assert (dup_ptr->count >= 2);
1297 while (dup_ptr > duplicates)
1303 "dup_ptr[%td]: hash_value = %d, index = %d, count = %d\n",
1304 dup_ptr - duplicates,
1305 dup_ptr->hash_value, dup_ptr->index, dup_ptr->count);
1308 /* Start searching for available space towards the right part
1309 of the lookup array. */
1310 for (i = dup_ptr->hash_value; i < lookup_array_size-1; i++)
1311 if (lookup_array[i] == DEFAULT_VALUE
1312 && lookup_array[i + 1] == DEFAULT_VALUE)
1314 /* If we didn't find it to the right look to the left instead... */
1315 for (i = dup_ptr->hash_value-1; i >= 0; i--)
1316 if (lookup_array[i] == DEFAULT_VALUE
1317 && lookup_array[i + 1] == DEFAULT_VALUE)
1319 /* Append to the end of lookup_array. */
1320 i = lookup_array_size;
1321 lookup_array_size += 2;
1323 /* Put in an indirection from dup_ptr->_hash_value to i.
1324 At i and i+1 store dup_ptr->_final_index and dup_ptr->count. */
1325 assert (lookup_array[dup_ptr->hash_value] == dup_ptr->index);
1326 lookup_array[dup_ptr->hash_value] = - 1 - _total_keys - i;
1327 lookup_array[i] = - _total_keys + dup_ptr->index;
1328 lookup_array[i + 1] = - dup_ptr->count;
1329 /* All these three values are <= -2, distinct from DEFAULT_VALUE. */
1332 /* The values of the lookup array are now known. */
1336 lookup_ptr = lookup_array + lookup_array_size;
1337 while (lookup_ptr > lookup_array)
1339 int val = *--lookup_ptr;
1346 const char *indent = option[GLOBAL] ? "" : " ";
1347 printf ("%sstatic %s%s lookup[] =\n"
1349 indent, const_readonly_array, smallest_integral_type (min, max),
1353 /* Calculate maximum number of digits required for MIN..MAX. */
1356 for (int trunc = max; (trunc /= 10) > 0;)
1361 int neg_field_width = 2;
1362 for (int trunc = -min; (trunc /= 10) > 0;)
1364 neg_field_width++; /* account for the minus sign */
1365 if (field_width < neg_field_width)
1366 field_width = neg_field_width;
1369 const int columns = 42 / field_width;
1373 for (int i = 0; i < lookup_array_size; i++)
1377 if ((column++ % columns) == 0)
1378 printf("\n%s ", indent);
1379 printf ("%*d", field_width, lookup_array[i]);
1381 printf ("\n%s };\n\n", indent);
1383 delete[] duplicates;
1384 delete[] lookup_array;
1388 /* ------------------------------------------------------------------------- */
1390 /* Generate all pools needed for the lookup function. */
1393 Output::output_lookup_pools () const
1397 if (option[TYPE] || (option[DUP] && _total_duplicates > 0))
1398 output_string_pool ();
1402 output_string_pool ();
1406 /* Generate all the tables needed for the lookup function. */
1409 Output::output_lookup_tables () const
1413 /* Use the switch in place of lookup table. */
1414 if (option[LENTABLE] && (option[DUP] && _total_duplicates > 0))
1415 output_keylength_table ();
1416 if (option[TYPE] || (option[DUP] && _total_duplicates > 0))
1417 output_keyword_table ();
1421 /* Use the lookup table, in place of switch. */
1422 if (option[LENTABLE])
1423 output_keylength_table ();
1424 output_keyword_table ();
1425 output_lookup_array ();
1429 /* ------------------------------------------------------------------------- */
1431 /* Output a single switch case (including duplicates). Advance list. */
1433 static KeywordExt_List *
1434 output_switch_case (KeywordExt_List *list, int indent, int *jumps_away)
1437 printf ("%*s/* hash value = %4d, keyword = \"%.*s\" */\n",
1438 indent, "", list->first()->_hash_value, list->first()->_allchars_length, list->first()->_allchars);
1440 if (option[DUP] && list->first()->_duplicate_link)
1442 if (option[LENTABLE])
1443 printf ("%*slengthptr = &%s[%d];\n",
1444 indent, "", option.get_lengthtable_name (), list->first()->_final_index);
1445 printf ("%*swordptr = &%s[%d];\n",
1446 indent, "", option.get_wordlist_name (), list->first()->_final_index);
1449 for (KeywordExt *links = list->first(); links; links = links->_duplicate_link)
1452 printf ("%*swordendptr = wordptr + %d;\n"
1453 "%*sgoto multicompare;\n",
1460 if (option[LENTABLE])
1462 printf ("%*sif (len == %d)\n"
1464 indent, "", list->first()->_allchars_length,
1468 printf ("%*sresword = ",
1471 printf ("&%s[%d]", option.get_wordlist_name (), list->first()->_final_index);
1473 output_string (list->first()->_allchars, list->first()->_allchars_length);
1475 printf ("%*sgoto compare;\n",
1477 if (option[LENTABLE])
1487 return list->rest();
1490 /* Output a total of size cases, grouped into num_switches switch statements,
1491 where 0 < num_switches <= size. */
1494 output_switches (KeywordExt_List *list, int num_switches, int size, int min_hash_value, int max_hash_value, int indent)
1497 printf ("%*s/* know %d <= key <= %d, contains %d cases */\n",
1498 indent, "", min_hash_value, max_hash_value, size);
1500 if (num_switches > 1)
1502 int part1 = num_switches / 2;
1503 int part2 = num_switches - part1;
1504 int size1 = static_cast<int>(static_cast<double>(size) / static_cast<double>(num_switches) * static_cast<double>(part1) + 0.5);
1505 int size2 = size - size1;
1507 KeywordExt_List *temp = list;
1508 for (int count = size1; count > 0; count--)
1509 temp = temp->rest();
1511 printf ("%*sif (key < %d)\n"
1513 indent, "", temp->first()->_hash_value,
1516 output_switches (list, part1, size1, min_hash_value, temp->first()->_hash_value-1, indent+4);
1521 indent, "", indent, "", indent, "");
1523 output_switches (temp, part2, size2, temp->first()->_hash_value, max_hash_value, indent+4);
1530 /* Output a single switch. */
1531 int lowest_case_value = list->first()->_hash_value;
1535 assert (min_hash_value <= lowest_case_value);
1536 assert (lowest_case_value <= max_hash_value);
1537 if (min_hash_value == max_hash_value)
1538 output_switch_case (list, indent, &jumps_away);
1541 printf ("%*sif (key == %d)\n"
1543 indent, "", lowest_case_value,
1545 output_switch_case (list, indent+4, &jumps_away);
1552 if (lowest_case_value == 0)
1553 printf ("%*sswitch (key)\n", indent, "");
1555 printf ("%*sswitch (key - %d)\n", indent, "", lowest_case_value);
1558 for (; size > 0; size--)
1561 printf ("%*s case %d:\n",
1562 indent, "", list->first()->_hash_value - lowest_case_value);
1563 list = output_switch_case (list, indent+6, &jumps_away);
1565 printf ("%*s break;\n",
1574 /* Generates C code to perform the keyword lookup. */
1577 Output::output_lookup_function_body (const Output_Compare& comparison) const
1579 printf (" if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)\n"
1581 " register int key = %s (str, len);\n\n",
1582 option.get_hash_name ());
1586 int switch_size = num_hash_values ();
1587 int num_switches = option.get_total_switches ();
1588 if (num_switches > switch_size)
1589 num_switches = switch_size;
1591 printf (" if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)\n"
1593 if (option[DUP] && _total_duplicates > 0)
1595 if (option[LENTABLE])
1596 printf (" register %s%s *lengthptr;\n",
1597 const_always, smallest_integral_type (_max_key_len));
1598 printf (" register ");
1599 output_const_type (const_readonly_array, _wordlist_eltype);
1600 printf ("*wordptr;\n");
1601 printf (" register ");
1602 output_const_type (const_readonly_array, _wordlist_eltype);
1603 printf ("*wordendptr;\n");
1607 printf (" register ");
1608 output_const_type (const_readonly_array, _struct_tag);
1609 printf ("*resword;\n\n");
1612 printf (" register %sresword;\n\n",
1615 output_switches (_head, num_switches, switch_size, _min_hash_value, _max_hash_value, 10);
1617 printf (" return 0;\n");
1618 if (option[DUP] && _total_duplicates > 0)
1621 printf ("%*smulticompare:\n"
1622 "%*s while (wordptr < wordendptr)\n"
1624 indent, "", indent, "", indent, "");
1625 if (option[LENTABLE])
1627 printf ("%*s if (len == *lengthptr)\n"
1629 indent, "", indent, "");
1632 printf ("%*s register %schar *s = ",
1633 indent, "", const_always);
1635 printf ("wordptr->%s", option.get_slot_name ());
1637 printf ("*wordptr");
1638 if (option[SHAREDLIB])
1640 option.get_stringpool_name ());
1644 comparison.output_comparison (Output_Expr1 ("str"), Output_Expr1 ("s"));
1648 option[TYPE] ? "wordptr" : "s");
1649 if (option[LENTABLE])
1655 if (option[LENTABLE])
1656 printf ("%*s lengthptr++;\n",
1658 printf ("%*s wordptr++;\n"
1661 indent, "", indent, "", indent, "");
1663 printf (" compare:\n");
1667 " register %schar *s = resword->%s",
1668 const_always, option.get_slot_name ());
1669 if (option[SHAREDLIB])
1671 option.get_stringpool_name ());
1674 comparison.output_comparison (Output_Expr1 ("str"), Output_Expr1 ("s"));
1676 " return resword;\n"
1682 comparison.output_comparison (Output_Expr1 ("str"), Output_Expr1 ("resword"));
1684 " return resword;\n");
1690 printf (" if (key <= MAX_HASH_VALUE && key >= 0)\n");
1696 "%*s register int index = lookup[key];\n\n"
1697 "%*s if (index >= 0)\n",
1698 indent, "", indent, "", indent, "");
1699 if (option[LENTABLE])
1702 "%*s if (len == %s[index])\n",
1703 indent, "", indent, "", option.get_lengthtable_name ());
1707 "%*s register %schar *s = %s[index]",
1709 indent, "", const_always, option.get_wordlist_name ());
1711 printf (".%s", option.get_slot_name ());
1712 if (option[SHAREDLIB])
1714 option.get_stringpool_name ());
1718 comparison.output_comparison (Output_Expr1 ("str"), Output_Expr1 ("s"));
1723 printf ("&%s[index]", option.get_wordlist_name ());
1729 if (option[LENTABLE])
1732 printf ("%*s }\n", indent, "");
1734 if (_total_duplicates > 0)
1736 printf ("%*s else if (index < -TOTAL_KEYWORDS)\n"
1738 "%*s register int offset = - 1 - TOTAL_KEYWORDS - index;\n",
1739 indent, "", indent, "", indent, "");
1740 if (option[LENTABLE])
1741 printf ("%*s register %s%s *lengthptr = &%s[TOTAL_KEYWORDS + lookup[offset]];\n",
1742 indent, "", const_always, smallest_integral_type (_max_key_len),
1743 option.get_lengthtable_name ());
1744 printf ("%*s register ",
1746 output_const_type (const_readonly_array, _wordlist_eltype);
1747 printf ("*wordptr = &%s[TOTAL_KEYWORDS + lookup[offset]];\n",
1748 option.get_wordlist_name ());
1749 printf ("%*s register ",
1751 output_const_type (const_readonly_array, _wordlist_eltype);
1752 printf ("*wordendptr = wordptr + -lookup[offset + 1];\n\n");
1753 printf ("%*s while (wordptr < wordendptr)\n"
1755 indent, "", indent, "");
1756 if (option[LENTABLE])
1758 printf ("%*s if (len == *lengthptr)\n"
1760 indent, "", indent, "");
1763 printf ("%*s register %schar *s = ",
1764 indent, "", const_always);
1766 printf ("wordptr->%s", option.get_slot_name ());
1768 printf ("*wordptr");
1769 if (option[SHAREDLIB])
1771 option.get_stringpool_name ());
1775 comparison.output_comparison (Output_Expr1 ("str"), Output_Expr1 ("s"));
1779 option[TYPE] ? "wordptr" : "s");
1780 if (option[LENTABLE])
1786 if (option[LENTABLE])
1787 printf ("%*s lengthptr++;\n",
1789 printf ("%*s wordptr++;\n"
1792 indent, "", indent, "", indent, "");
1800 if (option[LENTABLE])
1802 printf ("%*sif (len == %s[key])\n",
1803 indent, "", option.get_lengthtable_name ());
1807 if (option[SHAREDLIB])
1809 if (!option[LENTABLE])
1812 "%*s register int o = %s[key]",
1814 indent, "", option.get_wordlist_name ());
1816 printf (".%s", option.get_slot_name ());
1823 printf ("%*s register %schar *s = o",
1824 indent, "", const_always);
1828 /* No need for the (o >= 0) test, because the
1829 (len == lengthtable[key]) test already guarantees that
1830 key points to nonempty table entry. */
1832 "%*s register %schar *s = %s[key]",
1834 indent, "", const_always,
1835 option.get_wordlist_name ());
1837 printf (".%s", option.get_slot_name ());
1840 option.get_stringpool_name ());
1845 "%*s register %schar *s = %s[key]",
1847 indent, "", const_always, option.get_wordlist_name ());
1849 printf (".%s", option.get_slot_name ());
1855 if (!option[SHAREDLIB] && option[NULLSTRINGS])
1857 comparison.output_comparison (Output_Expr1 ("str"), Output_Expr1 ("s"));
1862 printf ("&%s[key]", option.get_wordlist_name ());
1866 if (option[SHAREDLIB] && !option[LENTABLE])
1880 /* Generates C code for the lookup function. */
1883 Output::output_lookup_function () const
1885 /* Output the function's head. */
1886 if (option[KRC] | option[C] | option[ANSIC])
1887 /* GCC 4.3 and above with -std=c99 or -std=gnu99 implements ISO C99
1888 inline semantics, unless -fgnu89-inline is used. It defines a macro
1889 __GNUC_STDC_INLINE__ to indicate this situation. */
1890 printf ("#ifdef __GNUC__\n"
1892 "#ifdef __GNUC_STDC_INLINE__\n"
1893 "__attribute__ ((__gnu_inline__))\n"
1898 const_for_struct, _return_type);
1899 if (option[CPLUSPLUS])
1900 printf ("%s::", option.get_class_name ());
1901 printf ("%s ", option.get_function_name ());
1902 printf (option[KRC] ?
1904 " register char *str;\n"
1905 " register unsigned int len;\n" :
1908 " register const char *str;\n"
1909 " register unsigned int len;\n" :
1910 option[ANSIC] | option[CPLUSPLUS] ?
1911 "(register const char *str, register unsigned int len)\n" :
1914 /* Output the function's body. */
1917 if (option[ENUM] && !option[GLOBAL])
1919 Output_Enum style (" ");
1920 output_constants (style);
1923 if (option[SHAREDLIB] && !(option[GLOBAL] || option[TYPE]))
1924 output_lookup_pools ();
1925 if (!option[GLOBAL])
1926 output_lookup_tables ();
1928 if (option[LENTABLE])
1929 output_lookup_function_body (Output_Compare_Memcmp ());
1933 output_lookup_function_body (Output_Compare_Strncmp ());
1935 output_lookup_function_body (Output_Compare_Strcmp ());
1941 /* ------------------------------------------------------------------------- */
1943 /* Generates the hash function and the key word recognizer function
1944 based upon the user's Options. */
1951 if (option[C] | option[ANSIC] | option[CPLUSPLUS])
1953 const_always = "const ";
1954 const_readonly_array = (option[CONST] ? "const " : "");
1955 const_for_struct = ((option[CONST] && option[TYPE]) ? "const " : "");
1960 const_readonly_array = "";
1961 const_for_struct = "";
1966 _return_type = (const_always[0] ? "const char *" : "char *");
1967 _struct_tag = (const_always[0] ? "const char *" : "char *");
1970 _wordlist_eltype = (option[SHAREDLIB] && !option[TYPE] ? "int" : _struct_tag);
1977 else if (option[ANSIC])
1979 else if (option[CPLUSPLUS])
1981 printf (" code produced by gperf version %s */\n", version_string);
1982 option.print_options ();
1984 if (!option[POSITIONS])
1986 printf ("/* Computed positions: -k'");
1987 _key_positions.print();
1992 if (_charset_dependent
1993 && (_key_positions.get_size() > 0 || option[UPPERLOWER]))
1995 /* The generated tables assume that the execution character set is
1996 based on ISO-646, not EBCDIC. */
1997 printf ("#if !((' ' == 32) && ('!' == 33) && ('\"' == 34) && ('#' == 35) \\\n"
1998 " && ('%%' == 37) && ('&' == 38) && ('\\'' == 39) && ('(' == 40) \\\n"
1999 " && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \\\n"
2000 " && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \\\n"
2001 " && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \\\n"
2002 " && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \\\n"
2003 " && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \\\n"
2004 " && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \\\n"
2005 " && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \\\n"
2006 " && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \\\n"
2007 " && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \\\n"
2008 " && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \\\n"
2009 " && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \\\n"
2010 " && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \\\n"
2011 " && ('Z' == 90) && ('[' == 91) && ('\\\\' == 92) && (']' == 93) \\\n"
2012 " && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \\\n"
2013 " && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \\\n"
2014 " && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \\\n"
2015 " && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \\\n"
2016 " && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \\\n"
2017 " && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \\\n"
2018 " && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \\\n"
2019 " && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126))\n"
2020 "/* The character set is not based on ISO-646. */\n");
2021 printf ("%s \"gperf generated tables don't work with this execution character set. Please report a bug to <bug-gnu-gperf@gnu.org>.\"\n", option[KRC] || option[C] ? "error" : "#error");
2022 printf ("#endif\n\n");
2025 if (_verbatim_declarations < _verbatim_declarations_end)
2027 output_line_directive (_verbatim_declarations_lineno);
2028 fwrite (_verbatim_declarations, 1,
2029 _verbatim_declarations_end - _verbatim_declarations, stdout);
2032 if (option[TYPE] && !option[NOTYPE]) /* Output type declaration now, reference it later on.... */
2034 output_line_directive (_struct_decl_lineno);
2035 printf ("%s\n", _struct_decl);
2038 if (option[INCLUDE])
2039 printf ("#include <string.h>\n"); /* Declare strlen(), strcmp(), strncmp(). */
2043 Output_Defines style;
2044 output_constants (style);
2046 else if (option[GLOBAL])
2048 Output_Enum style ("");
2049 output_constants (style);
2052 printf ("/* maximum key range = %d, duplicates = %d */\n\n",
2053 _max_hash_value - _min_hash_value + 1, _total_duplicates);
2055 if (option[UPPERLOWER])
2057 #if USE_DOWNCASE_TABLE
2058 output_upperlower_table ();
2061 if (option[LENTABLE])
2062 output_upperlower_memcmp ();
2066 output_upperlower_strncmp ();
2068 output_upperlower_strcmp ();
2072 if (option[CPLUSPLUS])
2073 printf ("class %s\n"
2076 " static inline unsigned int %s (const char *str, unsigned int len);\n"
2078 " static %s%s%s (const char *str, unsigned int len);\n"
2081 option.get_class_name (), option.get_hash_name (),
2082 const_for_struct, _return_type, option.get_function_name ());
2084 output_hash_function ();
2086 if (option[SHAREDLIB] && (option[GLOBAL] || option[TYPE]))
2087 output_lookup_pools ();
2089 output_lookup_tables ();
2091 output_lookup_function ();
2093 if (_verbatim_code < _verbatim_code_end)
2095 output_line_directive (_verbatim_code_lineno);
2096 fwrite (_verbatim_code, 1, _verbatim_code_end - _verbatim_code, stdout);