fdwalk should return 0 on an empty directory
[kopensolaris-gnu/glibc.git] / sunrpc / rpc_util.c
1 /*
2  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
3  * unrestricted use provided that this legend is included on all tape
4  * media and as a part of the software program in whole or part.  Users
5  * may copy or modify Sun RPC without charge, but are not authorized
6  * to license or distribute it to anyone else except as part of a product or
7  * program developed by the user or with the express written consent of
8  * Sun Microsystems, Inc.
9  *
10  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
11  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
12  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
13  *
14  * Sun RPC is provided with no support and without any obligation on the
15  * part of Sun Microsystems, Inc. to assist in its use, correction,
16  * modification or enhancement.
17  *
18  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
19  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
20  * OR ANY PART THEREOF.
21  *
22  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
23  * or profits or other special, indirect and consequential damages, even if
24  * Sun has been advised of the possibility of such damages.
25  *
26  * Sun Microsystems, Inc.
27  * 2550 Garcia Avenue
28  * Mountain View, California  94043
29  */
30
31 /*
32  * From: @(#)rpc_util.c 1.11 89/02/22 (C) 1987 SMI
33  */
34
35 /*
36  * rpc_util.c, Utility routines for the RPC protocol compiler
37  */
38 #include <stdio.h>
39 #include <ctype.h>
40 #include <string.h>
41 #include <unistd.h>
42 #include "rpc_scan.h"
43 #include "rpc_parse.h"
44 #include "rpc_util.h"
45 #include "proto.h"
46
47 #define ARGEXT "argument"
48
49 char curline[MAXLINESIZE];      /* current read line */
50 const char *where = curline;    /* current point in line */
51 int linenum = 0;                /* current line number */
52
53 const char *infilename;         /* input filename */
54
55 #define NFILES 7
56 const char *outfiles[NFILES];   /* output file names */
57 int nfiles;
58
59 FILE *fout;                     /* file pointer of current output */
60 FILE *fin;                      /* file pointer of current input */
61
62 list *defined;                  /* list of defined things */
63
64 static int findit (const definition * def, const char *type);
65 static const char *fixit (const char *type, const char *orig);
66 static int typedefed (const definition * def, const char *type);
67 static const char *toktostr (tok_kind kind);
68 static void printbuf (void);
69 static void printwhere (void);
70
71 /*
72  * Reinitialize the world
73  */
74 void
75 reinitialize (void)
76 {
77   memset (curline, 0, MAXLINESIZE);
78   where = curline;
79   linenum = 0;
80   defined = NULL;
81 }
82
83 /*
84  * string equality
85  */
86 int
87 streq (const char *a, const char *b)
88 {
89   return strcmp (a, b) == 0;
90 }
91
92 /*
93  * find a value in a list
94  */
95 definition *
96 findval (list *lst, const char *val,
97          int (*cmp) (const definition *, const char *))
98 {
99
100   for (; lst != NULL; lst = lst->next)
101     {
102       if (cmp (lst->val, val))
103         {
104           return lst->val;
105         }
106     }
107   return NULL;
108 }
109
110 /*
111  * store a value in a list
112  */
113 void
114 storeval (list **lstp, definition *val)
115 {
116   list **l;
117   list *lst;
118
119
120   for (l = lstp; *l != NULL; l = (list **) & (*l)->next);
121   lst = ALLOC (list);
122   lst->val = val;
123   lst->next = NULL;
124   *l = lst;
125 }
126
127 static int
128 findit (const definition * def, const char *type)
129 {
130   return streq (def->def_name, type);
131 }
132
133 static const char *
134 fixit (const char *type, const char *orig)
135 {
136   definition *def;
137
138   def = findval (defined, type, findit);
139   if (def == NULL || def->def_kind != DEF_TYPEDEF)
140     {
141       return orig;
142     }
143   switch (def->def.ty.rel)
144     {
145     case REL_VECTOR:
146       if (streq (def->def.ty.old_type, "opaque"))
147         return ("char");
148       else
149         return (def->def.ty.old_type);
150     case REL_ALIAS:
151       return (fixit (def->def.ty.old_type, orig));
152     default:
153       return orig;
154     }
155 }
156
157 const char *
158 fixtype (const char *type)
159 {
160   return fixit (type, type);
161 }
162
163 const char *
164 stringfix (const char *type)
165 {
166   if (streq (type, "string"))
167     {
168       return "wrapstring";
169     }
170   else
171     {
172       return type;
173     }
174 }
175
176 void
177 ptype (const char *prefix, const char *type, int follow)
178 {
179   if (prefix != NULL)
180     {
181       if (streq (prefix, "enum"))
182         {
183           f_print (fout, "enum ");
184         }
185       else
186         {
187           f_print (fout, "struct ");
188         }
189     }
190   if (streq (type, "bool"))
191     {
192       f_print (fout, "bool_t ");
193     }
194   else if (streq (type, "string"))
195     {
196       f_print (fout, "char *");
197     }
198   else
199     {
200       f_print (fout, "%s ", follow ? fixtype (type) : type);
201     }
202 }
203
204 static int
205 typedefed (const definition * def, const char *type)
206 {
207   if (def->def_kind != DEF_TYPEDEF || def->def.ty.old_prefix != NULL)
208     {
209       return 0;
210     }
211   else
212     {
213       return streq (def->def_name, type);
214     }
215 }
216
217 int
218 isvectordef (const char *type, relation rel)
219 {
220   definition *def;
221
222   for (;;)
223     {
224       switch (rel)
225         {
226         case REL_VECTOR:
227           return !streq (type, "string");
228         case REL_ARRAY:
229           return 0;
230         case REL_POINTER:
231           return 0;
232         case REL_ALIAS:
233           def = findval (defined, type, typedefed);
234           if (def == NULL)
235             {
236               return 0;
237             }
238           type = def->def.ty.old_type;
239           rel = def->def.ty.rel;
240         }
241     }
242 }
243
244 char *
245 locase (const char *str)
246 {
247   char c;
248   static char buf[100];
249   char *p = buf;
250
251   while ((c = *str++) != 0)
252     {
253       *p++ = (c >= 'A' && c <= 'Z') ? (c - 'A' + 'a') : c;
254     }
255   *p = 0;
256   return buf;
257 }
258
259 void
260 pvname_svc (const char *pname, const char *vnum)
261 {
262   f_print (fout, "%s_%s_svc", locase (pname), vnum);
263 }
264
265 void
266 pvname (const char *pname, const char *vnum)
267 {
268   f_print (fout, "%s_%s", locase (pname), vnum);
269 }
270
271 /*
272  * print a useful (?) error message, and then die
273  */
274 void
275 error (const char *msg)
276 {
277   printwhere ();
278   f_print (stderr, "%s, line %d: ", infilename, linenum);
279   f_print (stderr, "%s\n", msg);
280   crash ();
281 }
282
283 /*
284  * Something went wrong, unlink any files that we may have created and then
285  * die.
286  */
287 void
288 crash (void)
289 {
290   int i;
291
292   for (i = 0; i < nfiles; i++)
293     {
294       unlink (outfiles[i]);
295     }
296   exit (1);
297 }
298
299 void
300 record_open (const char *file)
301 {
302   if (nfiles < NFILES)
303     {
304       outfiles[nfiles++] = file;
305     }
306   else
307     {
308       f_print (stderr, "too many files!\n");
309       crash ();
310     }
311 }
312
313 static char expectbuf[100];
314
315 /*
316  * error, token encountered was not the expected one
317  */
318 void
319 expected1 (tok_kind exp1)
320 {
321   s_print (expectbuf, "expected '%s'",
322            toktostr (exp1));
323   error (expectbuf);
324 }
325
326 /*
327  * error, token encountered was not one of two expected ones
328  */
329 void
330 expected2 (tok_kind exp1, tok_kind exp2)
331 {
332   s_print (expectbuf, "expected '%s' or '%s'",
333            toktostr (exp1),
334            toktostr (exp2));
335   error (expectbuf);
336 }
337
338 /*
339  * error, token encountered was not one of 3 expected ones
340  */
341 void
342 expected3 (tok_kind exp1, tok_kind exp2, tok_kind exp3)
343 {
344   s_print (expectbuf, "expected '%s', '%s' or '%s'",
345            toktostr (exp1),
346            toktostr (exp2),
347            toktostr (exp3));
348   error (expectbuf);
349 }
350
351 void
352 tabify (FILE * f, int tab)
353 {
354   while (tab--)
355     {
356       (void) fputc ('\t', f);
357     }
358 }
359
360
361 static const token tokstrings[] =
362 {
363   {TOK_IDENT, "identifier"},
364   {TOK_CONST, "const"},
365   {TOK_RPAREN, ")"},
366   {TOK_LPAREN, "("},
367   {TOK_RBRACE, "}"},
368   {TOK_LBRACE, "{"},
369   {TOK_LBRACKET, "["},
370   {TOK_RBRACKET, "]"},
371   {TOK_STAR, "*"},
372   {TOK_COMMA, ","},
373   {TOK_EQUAL, "="},
374   {TOK_COLON, ":"},
375   {TOK_SEMICOLON, ";"},
376   {TOK_UNION, "union"},
377   {TOK_STRUCT, "struct"},
378   {TOK_SWITCH, "switch"},
379   {TOK_CASE, "case"},
380   {TOK_DEFAULT, "default"},
381   {TOK_ENUM, "enum"},
382   {TOK_TYPEDEF, "typedef"},
383   {TOK_INT, "int"},
384   {TOK_SHORT, "short"},
385   {TOK_LONG, "long"},
386   {TOK_UNSIGNED, "unsigned"},
387   {TOK_DOUBLE, "double"},
388   {TOK_FLOAT, "float"},
389   {TOK_CHAR, "char"},
390   {TOK_STRING, "string"},
391   {TOK_OPAQUE, "opaque"},
392   {TOK_BOOL, "bool"},
393   {TOK_VOID, "void"},
394   {TOK_PROGRAM, "program"},
395   {TOK_VERSION, "version"},
396   {TOK_EOF, "??????"}
397 };
398
399 static const char *
400 toktostr (tok_kind kind)
401 {
402   const token *sp;
403
404   for (sp = tokstrings; sp->kind != TOK_EOF && sp->kind != kind; sp++);
405   return sp->str;
406 }
407
408 static void
409 printbuf (void)
410 {
411   char c;
412   int i;
413   int cnt;
414
415 #define TABSIZE 4
416
417   for (i = 0; (c = curline[i]) != 0; i++)
418     {
419       if (c == '\t')
420         {
421           cnt = 8 - (i % TABSIZE);
422           c = ' ';
423         }
424       else
425         {
426           cnt = 1;
427         }
428       while (cnt--)
429         {
430           (void) fputc (c, stderr);
431         }
432     }
433 }
434
435 static void
436 printwhere (void)
437 {
438   int i;
439   char c;
440   int cnt;
441
442   printbuf ();
443   for (i = 0; i < where - curline; i++)
444     {
445       c = curline[i];
446       if (c == '\t')
447         {
448           cnt = 8 - (i % TABSIZE);
449         }
450       else
451         {
452           cnt = 1;
453         }
454       while (cnt--)
455         {
456           (void) fputc ('^', stderr);
457         }
458     }
459   (void) fputc ('\n', stderr);
460 }
461
462 char *
463 make_argname (const char *pname, const char *vname)
464 {
465   char *name;
466
467   name = malloc (strlen (pname) + strlen (vname) + strlen (ARGEXT) + 3);
468   if (!name)
469     {
470       fprintf (stderr, "failed in malloc");
471       exit (1);
472     }
473   sprintf (name, "%s_%s_%s", locase (pname), vname, ARGEXT);
474   return name;
475 }
476
477 bas_type *typ_list_h;
478 bas_type *typ_list_t;
479
480 void
481 add_type (int len, const char *type)
482 {
483   bas_type *ptr;
484
485
486   if ((ptr = malloc (sizeof (bas_type))) == NULL)
487     {
488       fprintf (stderr, "failed in malloc");
489       exit (1);
490     }
491
492   ptr->name = type;
493   ptr->length = len;
494   ptr->next = NULL;
495   if (typ_list_t == NULL)
496     {
497
498       typ_list_t = ptr;
499       typ_list_h = ptr;
500     }
501   else
502     {
503
504       typ_list_t->next = ptr;
505       typ_list_t = ptr;
506     }
507
508 }
509
510
511 bas_type *
512 find_type (const char *type)
513 {
514   bas_type *ptr;
515
516   ptr = typ_list_h;
517
518
519   while (ptr != NULL)
520     {
521       if (strcmp (ptr->name, type) == 0)
522         return ptr;
523       else
524         ptr = ptr->next;
525     };
526   return NULL;
527 }