05f524bffe47d435139d29da774d8cf9a3642d38
[openafs.git] / src / comerr / error_table.y
1 %{
2 #include <afsconfig.h>
3 #include <afs/param.h>
4 #include <roken.h>
5
6 /*
7  *
8  * Copyright 1986, 1987 by the MIT Student Information Processing Board
9  *
10  * For copyright info, see mit-sipb-cr.h.
11  */
12 #ifndef AFS_NT40_ENV
13 #include <unistd.h>
14 #endif
15 #include <string.h>
16 #include <assert.h>
17 #include <ctype.h>
18 #ifdef AFS_NT40_ENV
19 #include <sys/types.h>
20 #include <afs/afsutil.h>
21 #else
22 #include <sys/time.h>
23 #endif
24 #include "error_table.h"
25 #include "mit-sipb-cr.h"
26
27 /*
28  * If __STDC__ is defined, function prototypes in the SunOS 5.5.1 lex
29  * and yacc templates are visible.  We turn this on explicitly on
30  * NT because the prototypes help supress certain warning from the
31  * Microsoft C compiler.
32  */
33
34 #ifdef AFS_NT40_ENV
35 #include <malloc.h>
36 # ifndef __STDC__
37 #  define __STDC__ 1
38 # endif
39 #endif
40
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44
45 #include "internal.h"
46
47 int char_to_num(char c);
48 char *gensym(const char *x);
49 char *current_token = NULL;
50 extern char *table_name;
51
52 char *quote(const char *string);
53 void set_table_1num(char *string);
54 int char_to_1num(char c);
55 void add_ec(const char *name, const char *description);
56 void add_ec_val(const char *name, const char *val, const char *description);
57 void put_ecs(void);
58 void set_table_num(char *string);
59 void set_table_fun(char *astring);
60
61 extern int yylex (void);
62
63 %}
64 %union {
65         char *dynstr;
66 }
67
68 %token ERROR_TABLE ERROR_CODE_ENTRY END
69 %token <dynstr> STRING QUOTED_STRING
70 %type <dynstr> ec_name description table_id table_fun header
71 %{
72 %}
73 %start error_table
74 %%
75
76 error_table     :       ERROR_TABLE header error_codes END
77                         { table_name = strdup($2);
78                           current_token = table_name;
79                           put_ecs(); }
80                 ;
81
82 header          :       table_fun table_id
83                         { current_token = $1;
84                           $$ = $2; }
85                 |       table_id
86                         { current_token = $1;
87                           set_table_fun(strdup("1"));
88                           $$ = $1;
89                         }
90                 ;
91
92 table_fun       :       STRING
93                         { current_token = $1;
94                           set_table_fun($1);
95                           $$ = $1; }
96                 ;
97
98
99 table_id        :       STRING
100                         { current_token = $1;
101                           set_table_num($1);
102                           $$ = $1; }
103                 ;
104
105 error_codes     :       error_codes ec_entry
106                 |       ec_entry
107                 ;
108
109 ec_entry        :       ERROR_CODE_ENTRY ec_name ',' description
110                         { add_ec($2, $4);
111                           free($2);
112                           free($4); }
113                 |       ERROR_CODE_ENTRY ec_name '=' STRING ',' description
114                         { add_ec_val($2, $4, $6);
115                           free($2);
116                           free($4);
117                           free($6);
118                         }
119                 ;
120
121 ec_name         :       STRING
122                         { $$ = strdup($1);
123                           current_token = $$; }
124                 ;
125
126 description     :       QUOTED_STRING
127                         { $$ = strdup($1);
128                           current_token = $$; }
129                 ;
130
131 %%
132
133 /* 
134  * Copyright 2000, International Business Machines Corporation and others.
135  * All Rights Reserved.
136  * 
137  * This software has been released under the terms of the IBM Public
138  * License.  For details, see the LICENSE file in the top-level source
139  * directory or online at http://www.openafs.org/dl/license10.html
140  */
141
142 extern FILE *hfile, *cfile, *msfile;
143 extern int use_msf;
144
145 static afs_int32 gensym_n = 0;
146
147 char *gensym(const char *x)
148 {
149         char *symbol;
150         if (!gensym_n) {
151                 struct timeval tv;
152                 gettimeofday(&tv, (void *)0);
153                 gensym_n = (tv.tv_sec%10000)*100 + tv.tv_usec/10000;
154         }
155         symbol = malloc(32 * sizeof(char));
156         gensym_n++;
157         sprintf(symbol, "et%ld", (long int) gensym_n);
158         return(symbol);
159 }
160
161 char *
162 quote(const char *string)
163 {
164         char *rv;
165         rv = malloc(strlen(string)+3);
166         strcpy(rv, "\"");
167         strcat(rv, string);
168         strcat(rv, "\"");
169         return(rv);
170 }
171
172 afs_int32 table_number = 0;
173 int current = 0;
174 char **error_codes = NULL;
175
176 void add_ec(const char *name, const char *description)
177 {
178         if (msfile) {
179             if (current > 0)
180 #ifndef sun
181                 fprintf(msfile, "%d\t%s\n", current, description);
182 #else
183                 fprintf(msfile, "%d %s\n", current, description);
184 #endif /* !sun */
185         } else if (cfile){
186             fprintf(cfile, "\t\"%s\",\n", description);
187         }
188         if (error_codes == NULL) {
189                 error_codes = malloc(sizeof(char *));
190                 *error_codes = NULL;
191         }
192         error_codes = (char **)realloc((char *)error_codes,
193                                        (current + 2)*sizeof(char *));
194         error_codes[current++] = strdup(name);
195         error_codes[current] = NULL;
196 }
197
198 void add_ec_val(const char *name, const char *val, const char *description)
199 {
200         const int ncurrent = atoi(val);
201         if (ncurrent < current) {
202                 printf("Error code %s (%d) out of order", name,
203                        current);
204                 return;
205         }
206       
207         while (ncurrent > current) {
208              if (cfile)
209                  fputs("\tNULL,\n", cfile);
210              current++;
211          }
212         if (msfile) {
213             if (current > 0)
214 #ifndef sun
215                 fprintf(msfile, "%d\t%s\n", current, description);
216 #else
217                 fprintf(msfile, "%d %s\n", current, description);
218 #endif /* ! sun */
219         } else if (cfile) {
220             fprintf(cfile, "\t\"%s\",\n", description);
221         }
222         if (error_codes == NULL) {
223                 error_codes = malloc(sizeof(char *));
224                 *error_codes = NULL;
225         }
226         error_codes = (char **)realloc((char *)error_codes,
227                                        (current + 2)*sizeof(char *));
228         error_codes[current++] = strdup(name);
229         error_codes[current] = NULL;
230
231
232 void put_ecs(void)
233 {
234         int i;
235         if (!hfile)
236             return;
237         for (i = 0; i < current; i++) {
238              if (error_codes[i] != NULL)
239                   fprintf(hfile, "#define %-40s (%ldL)\n",
240                           error_codes[i], (long int) table_number + i);
241         }
242 }
243
244 /*
245  * char_to_num -- maps letters and numbers into a small numbering space
246  *      uppercase ->  1-26
247  *      lowercase -> 27-52
248  *      digits    -> 53-62
249  *      underscore-> 63
250  */
251
252 static const char char_set[] =
253         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_";
254
255 int char_to_num(char c)
256 {
257         const char *where;
258         int diff;
259
260         where = strchr (char_set, c);
261         if (where) {
262                 diff = where - char_set + 1;
263                 assert (diff < (1 << ERRCODE_RANGE));
264                 return diff;
265         }
266         else if (isprint (c))
267                 fprintf (stderr,
268                          "Illegal character `%c' in error table name\n",
269                          c);
270         else
271                 fprintf (stderr,
272                          "Illegal character %03o in error table name\n",
273                          c);
274         exit (1);
275 }
276
277 void set_table_num(char *string)
278 {
279         if (use_msf) {
280             set_table_1num(string);
281             return;
282         }
283         if (strlen(string) > 4) {
284                 fprintf(stderr, "Table name %s too long, truncated ",
285                         string);
286                 string[4] = '\0';
287                 fprintf(stderr, "to %s\n", string);
288         }
289         if (char_to_num (string[0]) > char_to_num ('z')) {
290                 fprintf (stderr, "%s%s%s%s",
291                          "First character of error table name must be ",
292                          "a letter; name ``",
293                          string, "'' rejected\n");
294                 exit (1);
295         }
296         while (*string != '\0') {
297                 table_number = (table_number << BITS_PER_CHAR)
298                         + char_to_num(*string);
299                 string++;
300         }
301         table_number = table_number << ERRCODE_RANGE;
302 }
303
304 void set_table_fun(char *astring)
305 {
306     char *tp;
307     unsigned int tc;
308
309     for(tp=astring; (tc = *tp) != 0; tp++) {
310         if (!isdigit(tc)) {
311             fprintf(stderr, "Table function '%s' must be a decimal integer.\n",
312                     astring);
313             exit(1);
314         }
315     }
316     if (use_msf)
317         table_number += (atoi(astring)) << 28;
318 }
319
320 /* for compatibility with old comerr's, we truncate package name to 4
321  * characters, but only store first 3 in the error code.  Note that this
322  * function, as a side effect, truncates the table name down to 4 chars.
323  */
324 void set_table_1num(char *string)
325 {
326         afs_int32 temp;
327         int ctr;
328
329         if ((temp = strlen(string)) > 4) {
330                 fprintf(stderr, "Table name %s too long, truncated ",
331                         string);
332                 string[4] = '\0';
333                 fprintf(stderr, "to %s\n", string);
334         }
335         if (temp == 4) {
336             fprintf(stderr, "Table name %s too long, only 3 characters fit in error code.\n",
337                     string);
338         }
339         if (char_to_1num (string[0]) > char_to_1num ('z')) {
340                 fprintf (stderr, "%s%s%s%s",
341                          "First character of error table name must be ",
342                          "a letter; name ``",
343                          string, "'' rejected\n");
344                 exit (1);
345         }
346         temp = 0;
347         for(ctr=0; ctr < 3; ctr++) {            /* copy at most 3 chars to integer */
348             if (*string == '\0') break;         /* and watch for early end */
349             temp = (temp * 050)                 /* "radix fifty" is base 050 = 40 */
350                 + char_to_1num(*string);
351             string++;
352         }
353         table_number += temp << 12;
354 }
355
356 /*
357  * char_to_num -- maps letters and numbers into very small space
358  *      0-9        -> 0-9
359  *      mixed case -> 10-35
360  *      _          -> 36
361  *      others are reserved
362  */
363
364 static const char char_1set[] =
365         "abcdefghijklmnopqrstuvwxyz_0123456789";
366
367 int char_to_1num(char c)
368 {
369         const char *where;
370         int diff;
371
372         if (isupper(c)) c = tolower(c);
373
374         where = strchr (char_1set, c);
375         if (where) {
376                 /* start at 1 so we can decode */
377                 diff = where - char_1set;
378                 assert (diff < 050);    /* it is radix 50, after all */
379                 return diff;
380         }
381         else if (isprint (c))
382                 fprintf (stderr,
383                          "Illegal character `%c' in error table name\n",
384                          c);
385         else
386                 fprintf (stderr,
387                          "Illegal character %03o in error table name\n",
388                          c);
389         exit (1);
390 }
391
392 #ifdef AFS_NT40_ENV
393 #include "et_lex.lex_nt.c"
394 #else
395 #include "et_lex.lex.c"
396 #endif