1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
|
<HTML>
<HEAD>
<!-- This HTML file has been created by texi2html 1.51
from gperf.texi on 31 March 2007 -->
<TITLE>Perfect Hash Function Generator - 4 Invoking gperf</TITLE>
</HEAD>
<BODY>
Go to the <A HREF="gperf_1.html">first</A>, <A HREF="gperf_5.html">previous</A>, <A HREF="gperf_7.html">next</A>, <A HREF="gperf_10.html">last</A> section, <A HREF="gperf_toc.html">table of contents</A>.
<P><HR><P>
<H1><A NAME="SEC18" HREF="gperf_toc.html#TOC18">4 Invoking <CODE>gperf</CODE></A></H1>
<P>
There are <EM>many</EM> options to <CODE>gperf</CODE>. They were added to make
the program more convenient for use with real applications. "On-line"
help is readily available via the <SAMP>`--help'</SAMP> option. Here is the
complete list of options.
</P>
<H2><A NAME="SEC19" HREF="gperf_toc.html#TOC19">4.1 Specifying the Location of the Output File</A></H2>
<DL COMPACT>
<DT><SAMP>`--output-file=<VAR>file</VAR>'</SAMP>
<DD>
Allows you to specify the name of the file to which the output is written to.
</DL>
<P>
The results are written to standard output if no output file is specified
or if it is <SAMP>`-'</SAMP>.
</P>
<H2><A NAME="SEC20" HREF="gperf_toc.html#TOC20">4.2 Options that affect Interpretation of the Input File</A></H2>
<P>
These options are also available as declarations in the input file
(see section <A HREF="gperf_5.html#SEC11">3.1.1.2 Gperf Declarations</A>).
</P>
<DL COMPACT>
<DT><SAMP>`-e <VAR>keyword-delimiter-list</VAR>'</SAMP>
<DD>
<DT><SAMP>`--delimiters=<VAR>keyword-delimiter-list</VAR>'</SAMP>
<DD>
<A NAME="IDX39"></A>
Allows you to provide a string containing delimiters used to
separate keywords from their attributes. The default is ",". This
option is essential if you want to use keywords that have embedded
commas or newlines. One useful trick is to use -e'TAB', where TAB is
the literal tab character.
<DT><SAMP>`-t'</SAMP>
<DD>
<DT><SAMP>`--struct-type'</SAMP>
<DD>
Allows you to include a <CODE>struct</CODE> type declaration for generated
code. Any text before a pair of consecutive <SAMP>`%%'</SAMP> is considered
part of the type declaration. Keywords and additional fields may follow
this, one group of fields per line. A set of examples for generating
perfect hash tables and functions for Ada, C, C++, Pascal, Modula 2,
Modula 3 and JavaScript reserved words are distributed with this release.
<DT><SAMP>`--ignore-case'</SAMP>
<DD>
Consider upper and lower case ASCII characters as equivalent. The string
comparison will use a case insignificant character comparison. Note that
locale dependent case mappings are ignored. This option is therefore not
suitable if a properly internationalized or locale aware case mapping
should be used. (For example, in a Turkish locale, the upper case equivalent
of the lowercase ASCII letter <SAMP>`i'</SAMP> is the non-ASCII character
<SAMP>`capital i with dot above'</SAMP>.) For this case, it is better to apply
an uppercase or lowercase conversion on the string before passing it to
the <CODE>gperf</CODE> generated function.
</DL>
<H2><A NAME="SEC21" HREF="gperf_toc.html#TOC21">4.3 Options to specify the Language for the Output Code</A></H2>
<P>
These options are also available as declarations in the input file
(see section <A HREF="gperf_5.html#SEC11">3.1.1.2 Gperf Declarations</A>).
</P>
<DL COMPACT>
<DT><SAMP>`-L <VAR>generated-language-name</VAR>'</SAMP>
<DD>
<DT><SAMP>`--language=<VAR>generated-language-name</VAR>'</SAMP>
<DD>
Instructs <CODE>gperf</CODE> to generate code in the language specified by the
option's argument. Languages handled are currently:
<DL COMPACT>
<DT><SAMP>`KR-C'</SAMP>
<DD>
Old-style K&R C. This language is understood by old-style C compilers and
ANSI C compilers, but ANSI C compilers may flag warnings (or even errors)
because of lacking <SAMP>`const'</SAMP>.
<DT><SAMP>`C'</SAMP>
<DD>
Common C. This language is understood by ANSI C compilers, and also by
old-style C compilers, provided that you <CODE>#define const</CODE> to empty
for compilers which don't know about this keyword.
<DT><SAMP>`ANSI-C'</SAMP>
<DD>
ANSI C. This language is understood by ANSI C compilers and C++ compilers.
<DT><SAMP>`C++'</SAMP>
<DD>
C++. This language is understood by C++ compilers.
</DL>
The default is C.
<DT><SAMP>`-a'</SAMP>
<DD>
This option is supported for compatibility with previous releases of
<CODE>gperf</CODE>. It does not do anything.
<DT><SAMP>`-g'</SAMP>
<DD>
This option is supported for compatibility with previous releases of
<CODE>gperf</CODE>. It does not do anything.
</DL>
<H2><A NAME="SEC22" HREF="gperf_toc.html#TOC22">4.4 Options for fine tuning Details in the Output Code</A></H2>
<P>
Most of these options are also available as declarations in the input file
(see section <A HREF="gperf_5.html#SEC11">3.1.1.2 Gperf Declarations</A>).
</P>
<DL COMPACT>
<DT><SAMP>`-K <VAR>slot-name</VAR>'</SAMP>
<DD>
<DT><SAMP>`--slot-name=<VAR>slot-name</VAR>'</SAMP>
<DD>
<A NAME="IDX40"></A>
This option is only useful when option <SAMP>`-t'</SAMP> (or, equivalently, the
<SAMP>`%struct-type'</SAMP> declaration) has been given.
By default, the program assumes the structure component identifier for
the keyword is <SAMP>`name'</SAMP>. This option allows an arbitrary choice of
identifier for this component, although it still must occur as the first
field in your supplied <CODE>struct</CODE>.
<DT><SAMP>`-F <VAR>initializers</VAR>'</SAMP>
<DD>
<DT><SAMP>`--initializer-suffix=<VAR>initializers</VAR>'</SAMP>
<DD>
<A NAME="IDX41"></A>
This option is only useful when option <SAMP>`-t'</SAMP> (or, equivalently, the
<SAMP>`%struct-type'</SAMP> declaration) has been given.
It permits to specify initializers for the structure members following
<VAR>slot-name</VAR> in empty hash table entries. The list of initializers
should start with a comma. By default, the emitted code will
zero-initialize structure members following <VAR>slot-name</VAR>.
<DT><SAMP>`-H <VAR>hash-function-name</VAR>'</SAMP>
<DD>
<DT><SAMP>`--hash-function-name=<VAR>hash-function-name</VAR>'</SAMP>
<DD>
Allows you to specify the name for the generated hash function. Default
name is <SAMP>`hash'</SAMP>. This option permits the use of two hash tables in
the same file.
<DT><SAMP>`-N <VAR>lookup-function-name</VAR>'</SAMP>
<DD>
<DT><SAMP>`--lookup-function-name=<VAR>lookup-function-name</VAR>'</SAMP>
<DD>
Allows you to specify the name for the generated lookup function.
Default name is <SAMP>`in_word_set'</SAMP>. This option permits multiple
generated hash functions to be used in the same application.
<DT><SAMP>`-Z <VAR>class-name</VAR>'</SAMP>
<DD>
<DT><SAMP>`--class-name=<VAR>class-name</VAR>'</SAMP>
<DD>
<A NAME="IDX42"></A>
This option is only useful when option <SAMP>`-L C++'</SAMP> (or, equivalently,
the <SAMP>`%language=C++'</SAMP> declaration) has been given. It
allows you to specify the name of generated C++ class. Default name is
<CODE>Perfect_Hash</CODE>.
<DT><SAMP>`-7'</SAMP>
<DD>
<DT><SAMP>`--seven-bit'</SAMP>
<DD>
This option specifies that all strings that will be passed as arguments
to the generated hash function and the generated lookup function will
solely consist of 7-bit ASCII characters (bytes in the range 0..127).
(Note that the ANSI C functions <CODE>isalnum</CODE> and <CODE>isgraph</CODE> do
<EM>not</EM> guarantee that a byte is in this range. Only an explicit
test like <SAMP>`c >= 'A' && c <= 'Z''</SAMP> guarantees this.) This was the
default in versions of <CODE>gperf</CODE> earlier than 2.7; now the default is
to support 8-bit and multibyte characters.
<DT><SAMP>`-l'</SAMP>
<DD>
<DT><SAMP>`--compare-lengths'</SAMP>
<DD>
Compare keyword lengths before trying a string comparison. This option
is mandatory for binary comparisons (see section <A HREF="gperf_5.html#SEC17">3.3 Use of NUL bytes</A>). It also might
cut down on the number of string comparisons made during the lookup, since
keywords with different lengths are never compared via <CODE>strcmp</CODE>.
However, using <SAMP>`-l'</SAMP> might greatly increase the size of the
generated C code if the lookup table range is large (which implies that
the switch option <SAMP>`-S'</SAMP> or <SAMP>`%switch'</SAMP> is not enabled), since the length
table contains as many elements as there are entries in the lookup table.
<DT><SAMP>`-c'</SAMP>
<DD>
<DT><SAMP>`--compare-strncmp'</SAMP>
<DD>
Generates C code that uses the <CODE>strncmp</CODE> function to perform
string comparisons. The default action is to use <CODE>strcmp</CODE>.
<DT><SAMP>`-C'</SAMP>
<DD>
<DT><SAMP>`--readonly-tables'</SAMP>
<DD>
Makes the contents of all generated lookup tables constant, i.e.,
"readonly". Many compilers can generate more efficient code for this
by putting the tables in readonly memory.
<DT><SAMP>`-E'</SAMP>
<DD>
<DT><SAMP>`--enum'</SAMP>
<DD>
Define constant values using an enum local to the lookup function rather
than with #defines. This also means that different lookup functions can
reside in the same file. Thanks to James Clark <CODE><jjc@ai.mit.edu></CODE>.
<DT><SAMP>`-I'</SAMP>
<DD>
<DT><SAMP>`--includes'</SAMP>
<DD>
Include the necessary system include file, <CODE><string.h></CODE>, at the
beginning of the code. By default, this is not done; the user must
include this header file himself to allow compilation of the code.
<DT><SAMP>`-G'</SAMP>
<DD>
<DT><SAMP>`--global-table'</SAMP>
<DD>
Generate the static table of keywords as a static global variable,
rather than hiding it inside of the lookup function (which is the
default behavior).
<DT><SAMP>`-P'</SAMP>
<DD>
<DT><SAMP>`--pic'</SAMP>
<DD>
Optimize the generated table for inclusion in shared libraries. This
reduces the startup time of programs using a shared library containing
the generated code. If the option <SAMP>`-t'</SAMP> (or, equivalently, the
<SAMP>`%struct-type'</SAMP> declaration) is also given, the first field of the
user-defined struct must be of type <SAMP>`int'</SAMP>, not <SAMP>`char *'</SAMP>, because
it will contain offsets into the string pool instead of actual strings.
To convert such an offset to a string, you can use the expression
<SAMP>`stringpool + <VAR>o</VAR>'</SAMP>, where <VAR>o</VAR> is the offset. The string pool
name can be changed through the option <SAMP>`--string-pool-name'</SAMP>.
<DT><SAMP>`-Q <VAR>string-pool-name</VAR>'</SAMP>
<DD>
<DT><SAMP>`--string-pool-name=<VAR>string-pool-name</VAR>'</SAMP>
<DD>
Allows you to specify the name of the generated string pool created by
option <SAMP>`-P'</SAMP>. The default name is <SAMP>`stringpool'</SAMP>. This option
permits the use of two hash tables in the same file, with <SAMP>`-P'</SAMP> and
even when the option <SAMP>`-G'</SAMP> (or, equivalently, the <SAMP>`%global-table'</SAMP>
declaration) is given.
<DT><SAMP>`--null-strings'</SAMP>
<DD>
Use NULL strings instead of empty strings for empty keyword table entries.
This reduces the startup time of programs using a shared library containing
the generated code (but not as much as option <SAMP>`-P'</SAMP>), at the expense
of one more test-and-branch instruction at run time.
<DT><SAMP>`-W <VAR>hash-table-array-name</VAR>'</SAMP>
<DD>
<DT><SAMP>`--word-array-name=<VAR>hash-table-array-name</VAR>'</SAMP>
<DD>
<A NAME="IDX43"></A>
Allows you to specify the name for the generated array containing the
hash table. Default name is <SAMP>`wordlist'</SAMP>. This option permits the
use of two hash tables in the same file, even when the option <SAMP>`-G'</SAMP>
(or, equivalently, the <SAMP>`%global-table'</SAMP> declaration) is given.
<DT><SAMP>`--length-table-name=<VAR>length-table-array-name</VAR>'</SAMP>
<DD>
<A NAME="IDX44"></A>
Allows you to specify the name for the generated array containing the
length table. Default name is <SAMP>`lengthtable'</SAMP>. This option permits the
use of two length tables in the same file, even when the option <SAMP>`-G'</SAMP>
(or, equivalently, the <SAMP>`%global-table'</SAMP> declaration) is given.
<DT><SAMP>`-S <VAR>total-switch-statements</VAR>'</SAMP>
<DD>
<DT><SAMP>`--switch=<VAR>total-switch-statements</VAR>'</SAMP>
<DD>
<A NAME="IDX45"></A>
Causes the generated C code to use a <CODE>switch</CODE> statement scheme,
rather than an array lookup table. This can lead to a reduction in both
time and space requirements for some input files. The argument to this
option determines how many <CODE>switch</CODE> statements are generated. A
value of 1 generates 1 <CODE>switch</CODE> containing all the elements, a
value of 2 generates 2 tables with 1/2 the elements in each
<CODE>switch</CODE>, etc. This is useful since many C compilers cannot
correctly generate code for large <CODE>switch</CODE> statements. This option
was inspired in part by Keith Bostic's original C program.
<DT><SAMP>`-T'</SAMP>
<DD>
<DT><SAMP>`--omit-struct-type'</SAMP>
<DD>
Prevents the transfer of the type declaration to the output file. Use
this option if the type is already defined elsewhere.
<DT><SAMP>`-p'</SAMP>
<DD>
This option is supported for compatibility with previous releases of
<CODE>gperf</CODE>. It does not do anything.
</DL>
<H2><A NAME="SEC23" HREF="gperf_toc.html#TOC23">4.5 Options for changing the Algorithms employed by <CODE>gperf</CODE></A></H2>
<DL COMPACT>
<DT><SAMP>`-k <VAR>selected-byte-positions</VAR>'</SAMP>
<DD>
<DT><SAMP>`--key-positions=<VAR>selected-byte-positions</VAR>'</SAMP>
<DD>
Allows selection of the byte positions used in the keywords'
hash function. The allowable choices range between 1-255, inclusive.
The positions are separated by commas, e.g., <SAMP>`-k 9,4,13,14'</SAMP>;
ranges may be used, e.g., <SAMP>`-k 2-7'</SAMP>; and positions may occur
in any order. Furthermore, the wildcard '*' causes the generated
hash function to consider <STRONG>all</STRONG> byte positions in each keyword,
whereas '$' instructs the hash function to use the "final byte"
of a keyword (this is the only way to use a byte position greater than
255, incidentally).
For instance, the option <SAMP>`-k 1,2,4,6-10,'$''</SAMP> generates a hash
function that considers positions 1,2,4,6,7,8,9,10, plus the last
byte in each keyword (which may be at a different position for each
keyword, obviously). Keywords
with length less than the indicated byte positions work properly, since
selected byte positions exceeding the keyword length are simply not
referenced in the hash function.
This option is not normally needed since version 2.8 of <CODE>gperf</CODE>;
the default byte positions are computed depending on the keyword set,
through a search that minimizes the number of byte positions.
<DT><SAMP>`-D'</SAMP>
<DD>
<DT><SAMP>`--duplicates'</SAMP>
<DD>
<A NAME="IDX46"></A>
Handle keywords whose selected byte sets hash to duplicate values.
Duplicate hash values can occur if a set of keywords has the same names, but
possesses different attributes, or if the selected byte positions are not well
chosen. With the -D option <CODE>gperf</CODE> treats all these keywords as
part of an equivalence class and generates a perfect hash function with
multiple comparisons for duplicate keywords. It is up to you to completely
disambiguate the keywords by modifying the generated C code. However,
<CODE>gperf</CODE> helps you out by organizing the output.
Using this option usually means that the generated hash function is no
longer perfect. On the other hand, it permits <CODE>gperf</CODE> to work on
keyword sets that it otherwise could not handle.
<DT><SAMP>`-m <VAR>iterations</VAR>'</SAMP>
<DD>
<DT><SAMP>`--multiple-iterations=<VAR>iterations</VAR>'</SAMP>
<DD>
Perform multiple choices of the <SAMP>`-i'</SAMP> and <SAMP>`-j'</SAMP> values, and
choose the best results. This increases the running time by a factor of
<VAR>iterations</VAR> but does a good job minimizing the generated table size.
<DT><SAMP>`-i <VAR>initial-value</VAR>'</SAMP>
<DD>
<DT><SAMP>`--initial-asso=<VAR>initial-value</VAR>'</SAMP>
<DD>
Provides an initial <VAR>value</VAR> for the associate values array. Default
is 0. Increasing the initial value helps inflate the final table size,
possibly leading to more time efficient keyword lookups. Note that this
option is not particularly useful when <SAMP>`-S'</SAMP> (or, equivalently,
<SAMP>`%switch'</SAMP>) is used. Also,
<SAMP>`-i'</SAMP> is overridden when the <SAMP>`-r'</SAMP> option is used.
<DT><SAMP>`-j <VAR>jump-value</VAR>'</SAMP>
<DD>
<DT><SAMP>`--jump=<VAR>jump-value</VAR>'</SAMP>
<DD>
<A NAME="IDX47"></A>
Affects the "jump value", i.e., how far to advance the associated
byte value upon collisions. <VAR>Jump-value</VAR> is rounded up to an
odd number, the default is 5. If the <VAR>jump-value</VAR> is 0 <CODE>gperf</CODE>
jumps by random amounts.
<DT><SAMP>`-n'</SAMP>
<DD>
<DT><SAMP>`--no-strlen'</SAMP>
<DD>
Instructs the generator not to include the length of a keyword when
computing its hash value. This may save a few assembly instructions in
the generated lookup table.
<DT><SAMP>`-r'</SAMP>
<DD>
<DT><SAMP>`--random'</SAMP>
<DD>
Utilizes randomness to initialize the associated values table. This
frequently generates solutions faster than using deterministic
initialization (which starts all associated values at 0). Furthermore,
using the randomization option generally increases the size of the
table.
<DT><SAMP>`-s <VAR>size-multiple</VAR>'</SAMP>
<DD>
<DT><SAMP>`--size-multiple=<VAR>size-multiple</VAR>'</SAMP>
<DD>
Affects the size of the generated hash table. The numeric argument for
this option indicates "how many times larger or smaller" the maximum
associated value range should be, in relationship to the number of keywords.
It can be written as an integer, a floating-point number or a fraction.
For example, a value of 3 means "allow the maximum associated value to be
about 3 times larger than the number of input keywords".
Conversely, a value of 1/3 means "allow the maximum associated value to
be about 3 times smaller than the number of input keywords". Values
smaller than 1 are useful for limiting the overall size of the generated hash
table, though the option <SAMP>`-m'</SAMP> is better at this purpose.
If `generate switch' option <SAMP>`-S'</SAMP> (or, equivalently, <SAMP>`%switch'</SAMP>) is
<EM>not</EM> enabled, the maximum
associated value influences the static array table size, and a larger
table should decrease the time required for an unsuccessful search, at
the expense of extra table space.
The default value is 1, thus the default maximum associated value about
the same size as the number of keywords (for efficiency, the maximum
associated value is always rounded up to a power of 2). The actual
table size may vary somewhat, since this technique is essentially a
heuristic.
</DL>
<H2><A NAME="SEC24" HREF="gperf_toc.html#TOC24">4.6 Informative Output</A></H2>
<DL COMPACT>
<DT><SAMP>`-h'</SAMP>
<DD>
<DT><SAMP>`--help'</SAMP>
<DD>
Prints a short summary on the meaning of each program option. Aborts
further program execution.
<DT><SAMP>`-v'</SAMP>
<DD>
<DT><SAMP>`--version'</SAMP>
<DD>
Prints out the current version number.
<DT><SAMP>`-d'</SAMP>
<DD>
<DT><SAMP>`--debug'</SAMP>
<DD>
Enables the debugging option. This produces verbose diagnostics to
"standard error" when <CODE>gperf</CODE> is executing. It is useful both for
maintaining the program and for determining whether a given set of
options is actually speeding up the search for a solution. Some useful
information is dumped at the end of the program when the <SAMP>`-d'</SAMP>
option is enabled.
</DL>
<P><HR><P>
Go to the <A HREF="gperf_1.html">first</A>, <A HREF="gperf_5.html">previous</A>, <A HREF="gperf_7.html">next</A>, <A HREF="gperf_10.html">last</A> section, <A HREF="gperf_toc.html">table of contents</A>.
</BODY>
</HTML>
|
