source: trunk/tools/wrc/preproc.c@ 5522

Last change on this file since 5522 was 5522, checked in by sandervl, 24 years ago

updates
File size: 10.8 KB
Line 
1/*
2 * Copyright 1998 Bertho A. Stultiens (BS)
3 *
4 */
5
6#include "config.h"
7
8#include <stdio.h>
9#include <stdlib.h>
10#include <string.h>
11#include <assert.h>
12
13#include "wrc.h"
14#include "utils.h"
15#include "preproc.h"
16
17
18extern void set_pp_ignore(int); /* From parser.l */
19
20#define HASHKEY 2039
21static pp_entry_t *pp_defines[HASHKEY];
22
23#define MAXIFSTACK 64
24static if_state_t if_stack[MAXIFSTACK];
25static int if_stack_idx = 0;
26
27#if 0
28void pp_status(void) __attribute__((destructor));
29void pp_status(void)
30{
31 int i;
32 int sum;
33 int total = 0;
34 pp_entry_t *ppp;
35
36 fprintf(stderr, "Defines statistics:\n");
37 for(i = 0; i < HASHKEY; i++)
38 {
39 sum = 0;
40 for(ppp = pp_defines[i]; ppp; ppp = ppp->next)
41 sum++;
42 total += sum;
43 fprintf(stderr, "%4d, %3d\n", i, sum);
44 }
45 fprintf(stderr, "Total defines: %d\n", total);
46}
47#endif
48
49/* Don't comment on the hash, its primitive but functional... */
50int pphash(char *str)
51{
52 int sum = 0;
53 while(*str)
54 sum += *str++;
55 return sum % HASHKEY;
56}
57
58pp_entry_t *pplookup(char *ident)
59{
60 int idx = pphash(ident);
61 pp_entry_t *ppp;
62
63 for(ppp = pp_defines[idx]; ppp; ppp = ppp->next)
64 {
65 if(!strcmp(ident, ppp->ident))
66 return ppp;
67 }
68 return NULL;
69}
70
71void del_define(char *name)
72{
73 int idx;
74 pp_entry_t *ppp;
75
76 if((ppp = pplookup(name)) == NULL)
77 {
78 if(pedantic)
79 yywarning("%s was not defined", name);
80 return;
81 }
82
83 if(ppp->iep)
84 {
85 if(debuglevel & DEBUGLEVEL_PPMSG)
86 fprintf(stderr, "del_define: %s:%d: includelogic removed, include_ppp='%s', file=%s\n", input_name, line_number, name, ppp->iep->filename);
87 if(ppp->iep == includelogiclist)
88 {
89 includelogiclist = ppp->iep->next;
90 if(includelogiclist)
91 includelogiclist->prev = NULL;
92 }
93 else
94 {
95 ppp->iep->prev->next = ppp->iep->next;
96 if(ppp->iep->next)
97 ppp->iep->next->prev = ppp->iep->prev;
98 }
99 free(ppp->iep->filename);
100 free(ppp->iep);
101 }
102
103 idx = pphash(name);
104 if(pp_defines[idx] == ppp)
105 {
106 pp_defines[idx] = ppp->next;
107 if(pp_defines[idx])
108 pp_defines[idx]->prev = NULL;
109 }
110 else
111 {
112 ppp->prev->next = ppp->next;
113 if(ppp->next)
114 ppp->next->prev = ppp->prev;
115 }
116
117 free(ppp);
118
119 if(debuglevel & DEBUGLEVEL_PPMSG)
120 printf("Deleted (%s, %d) <%s>\n", input_name, line_number, name);
121}
122
123pp_entry_t *add_define(char *def, char *text)
124{
125 int len;
126 char *cptr;
127 int idx = pphash(def);
128 pp_entry_t *ppp;
129
130 if((ppp = pplookup(def)) != NULL)
131 {
132 if(pedantic)
133 yywarning("Redefinition of %s\n\tPrevious definition: %s:%d", def, ppp->filename, ppp->linenumber);
134 del_define(def);
135 }
136 ppp = (pp_entry_t *)xmalloc(sizeof(pp_entry_t));
137 ppp->ident = def;
138 ppp->type = def_define;
139 ppp->subst.text = text;
140 ppp->filename = input_name ? xstrdup(input_name) : "<internal or cmdline>";
141 ppp->linenumber = input_name ? line_number : 0;
142 ppp->next = pp_defines[idx];
143 pp_defines[idx] = ppp;
144 if(ppp->next)
145 ppp->next->prev = ppp;
146 if(text)
147 {
148 /* Strip trailing white space from subst text */
149 len = strlen(text);
150 while(len && strchr(" \t\r\n", text[len-1]))
151 {
152 text[--len] = '\0';
153 }
154 /* Strip leading white space from subst text */
155 for(cptr = text; *cptr && strchr(" \t\r", *cptr); cptr++)
156 ;
157 if(text != cptr)
158 memmove(text, cptr, strlen(cptr)+1);
159 }
160 if(debuglevel & DEBUGLEVEL_PPMSG)
161 printf("Added define (%s, %d) <%s> to <%s>\n", input_name, line_number, ppp->ident, text ? text : "(null)");
162
163 return ppp;
164}
165
166pp_entry_t *add_cmdline_define(char *set)
167{
168 char *cpy = xstrdup(set); /* Because gcc passes a R/O string */
169 char *cptr = strchr(cpy, '=');
170 if(cptr)
171 *cptr = '\0';
172 return add_define(cpy, xstrdup(cptr ? cptr+1 : ""));
173}
174
175pp_entry_t *add_special_define(char *id)
176{
177 pp_entry_t *ppp = add_define(xstrdup(id), xstrdup(""));
178 ppp->type = def_special;
179 return ppp;
180}
181
182pp_entry_t *add_macro(char *id, marg_t *args[], int nargs, mtext_t *exp)
183{
184 int idx = pphash(id);
185 pp_entry_t *ppp;
186
187 if((ppp = pplookup(id)) != NULL)
188 {
189 if(pedantic)
190 yywarning("Redefinition of %s\n\tPrevious definition: %s:%d", id, ppp->filename, ppp->linenumber);
191 del_define(id);
192 }
193 ppp = (pp_entry_t *)xmalloc(sizeof(pp_entry_t));
194 ppp->ident = id;
195 ppp->type = def_macro;
196 ppp->margs = args;
197 ppp->nargs = nargs;
198 ppp->subst.mtext= exp;
199 ppp->filename = input_name ? xstrdup(input_name) : "<internal or cmdline>";
200 ppp->linenumber = input_name ? line_number : 0;
201 ppp->next = pp_defines[idx];
202 pp_defines[idx] = ppp;
203 if(ppp->next)
204 ppp->next->prev = ppp;
205
206 if(debuglevel & DEBUGLEVEL_PPMSG)
207 {
208 fprintf(stderr, "Added macro (%s, %d) <%s(%d)> to <", input_name, line_number, ppp->ident, nargs);
209 for(; exp; exp = exp->next)
210 {
211 switch(exp->type)
212 {
213 case exp_text:
214 fprintf(stderr, " \"%s\" ", exp->subst.text);
215 break;
216 case exp_stringize:
217 fprintf(stderr, " #(%d) ", exp->subst.argidx);
218 break;
219 case exp_concat:
220 fprintf(stderr, "##");
221 break;
222 case exp_subst:
223 fprintf(stderr, " <%d> ", exp->subst.argidx);
224 break;
225 }
226 }
227 fprintf(stderr, ">\n");
228 }
229 return ppp;
230}
231
232
233/*
234 *-------------------------------------------------------------------------
235 * Include management
236 *-------------------------------------------------------------------------
237 */
238#if defined(_Windows) || defined(__MSDOS__)
239#define INCLUDESEPARATOR ";"
240#else
241#define INCLUDESEPARATOR ":"
242#endif
243
244static char **includepath;
245static int nincludepath = 0;
246
247void add_include_path(char *path)
248{
249 char *tok;
250 char *cpy = xstrdup(path);
251
252 tok = strtok(cpy, INCLUDESEPARATOR);
253 while(tok)
254 {
255 char *dir;
256 char *cptr;
257 if(strlen(tok) == 0)
258 continue;
259 dir = xstrdup(tok);
260 for(cptr = dir; *cptr; cptr++)
261 {
262 /* Convert to forward slash */
263 if(*cptr == '\\')
264 *cptr = '/';
265 }
266 /* Kill eventual trailing '/' */
267 if(*(cptr = dir + strlen(dir)-1) == '/')
268 *cptr = '\0';
269
270 /* Add to list */
271 nincludepath++;
272 includepath = (char **)xrealloc(includepath, nincludepath * sizeof(*includepath));
273 includepath[nincludepath-1] = dir;
274 tok = strtok(NULL, INCLUDESEPARATOR);
275 }
276 free(cpy);
277}
278
279FILE *open_include(const char *name, int search, char **newpath)
280{
281 char *cpy = xstrdup(name);
282 char *cptr;
283 FILE *fp;
284 int i;
285
286 for(cptr = cpy; *cptr; cptr++)
287 {
288 /* kill double backslash */
289 if(*cptr == '\\' && *(cptr+1) == '\\')
290 memmove(cptr, cptr+1, strlen(cptr));
291 /* Convert to forward slash */
292 if(*cptr == '\\')
293 *cptr = '/';
294 }
295
296 if(search)
297 {
298 /* Search current dir and then -I path */
299 fp = fopen(cpy, "rb");
300 if(fp)
301 {
302 if(debuglevel & DEBUGLEVEL_PPMSG)
303 printf("Going to include <%s>\n", name);
304 if(newpath)
305 *newpath = cpy;
306 else
307 free(cpy);
308 return fp;
309 }
310 }
311 /* Search -I path */
312 for(i = 0; i < nincludepath; i++)
313 {
314 char *path;
315 path = (char *)xmalloc(strlen(includepath[i]) + strlen(cpy) + 2);
316 strcpy(path, includepath[i]);
317 strcat(path, "/");
318 strcat(path, cpy);
319 fp = fopen(path, "rb");
320 if(fp && (debuglevel & DEBUGLEVEL_PPMSG))
321 printf("Going to include <%s>\n", path);
322 if(fp)
323 {
324 if(newpath)
325 *newpath = path;
326 else
327 free(path);
328 free(cpy);
329 return fp;
330 }
331 free(path);
332 }
333 free(cpy);
334 if(newpath)
335 *newpath = NULL;
336 return NULL;
337}
338
339/*
340 *-------------------------------------------------------------------------
341 * #if, #ifdef, #ifndef, #else, #elif and #endif state management
342 *
343 * #if state transitions are made on basis of the current TOS and the next
344 * required state. The state transitions are required to housekeep because
345 * #if:s can be nested. The ignore case is activated to prevent output from
346 * within a false clause.
347 * Some special cases come from the fact that the #elif cases are not
348 * binary, but three-state. The problem is that all other elif-cases must
349 * be false when one true one has been found. A second problem is that the
350 * #else clause is a final clause. No extra #else:s may follow.
351 *
352 * The states mean:
353 * if_true Process input to output
354 * if_false Process input but no output
355 * if_ignore Process input but no output
356 * if_elif Process input but no output
357 * if_elsefalse Process input but no output
358 * if_elsettrue Process input to output
359 *
360 * The possible state-sequences are [state(stack depth)] (rest can be deduced):
361 * TOS #if 1 #else #endif
362 * if_true(n) if_true(n+1) if_elsefalse(n+1)
363 * if_false(n) if_ignore(n+1) if_ignore(n+1)
364 * if_elsetrue(n) if_true(n+1) if_elsefalse(n+1)
365 * if_elsefalse(n) if_ignore(n+1) if_ignore(n+1)
366 * if_elif(n) if_ignore(n+1) if_ignore(n+1)
367 * if_ignore(n) if_ignore(n+1) if_ignore(n+1)
368 *
369 * TOS #if 1 #elif 0 #else #endif
370 * if_true(n) if_true(n+1) if_elif(n+1) if_elif(n+1)
371 * if_false(n) if_ignore(n+1) if_ignore(n+1) if_ignore(n+1)
372 * if_elsetrue(n) if_true(n+1) if_elif(n+1) if_elif(n+1)
373 * if_elsefalse(n) if_ignore(n+1) if_ignore(n+1) if_ignore(n+1)
374 * if_elif(n) if_ignore(n+1) if_ignore(n+1) if_ignore(n+1)
375 * if_ignore(n) if_ignore(n+1) if_ignore(n+1) if_ignore(n+1)
376 *
377 * TOS #if 0 #elif 1 #else #endif
378 * if_true(n) if_false(n+1) if_true(n+1) if_elsefalse(n+1)
379 * if_false(n) if_ignore(n+1) if_ignore(n+1) if_ignore(n+1)
380 * if_elsetrue(n) if_false(n+1) if_true(n+1) if_elsefalse(n+1)
381 * if_elsefalse(n) if_ignore(n+1) if_ignore(n+1) if_ignore(n+1)
382 * if_elif(n) if_ignore(n+1) if_ignore(n+1) if_ignore(n+1)
383 * if_ignore(n) if_ignore(n+1) if_ignore(n+1) if_ignore(n+1)
384 *
385 *-------------------------------------------------------------------------
386 */
387static char *if_state_str[] = {
388 "if_false",
389 "if_true",
390 "if_elif",
391 "if_elsefalse",
392 "if_elsetrue",
393 "if_ignore"
394};
395
396void push_if(if_state_t s)
397{
398 if(if_stack_idx >= MAXIFSTACK)
399 internal_error(__FILE__, __LINE__, "#if-stack overflow; #{if,ifdef,ifndef} nested too deeply (> %d)", MAXIFSTACK);
400
401 if(debuglevel & DEBUGLEVEL_PPLEX)
402 fprintf(stderr, "Push if %s:%d: %s(%d) -> %s(%d)\n", input_name, line_number, if_state_str[if_state()], if_stack_idx, if_state_str[s], if_stack_idx+1);
403
404 if_stack[if_stack_idx++] = s;
405
406 switch(s)
407 {
408 case if_true:
409 case if_elsetrue:
410 break;
411 case if_false:
412 case if_elsefalse:
413 case if_elif:
414 case if_ignore:
415 push_ignore_state();
416 break;
417 }
418}
419
420if_state_t pop_if(void)
421{
422 if(if_stack_idx <= 0)
423 yyerror("#{endif,else,elif} without #{if,ifdef,ifndef} (#if-stack underflow)");
424
425 switch(if_state())
426 {
427 case if_true:
428 case if_elsetrue:
429 break;
430 case if_false:
431 case if_elsefalse:
432 case if_elif:
433 case if_ignore:
434 pop_ignore_state();
435 break;
436 }
437
438 if(debuglevel & DEBUGLEVEL_PPLEX)
439 fprintf(stderr, "Pop if %s:%d: %s(%d) -> %s(%d)\n",
440 input_name,
441 line_number,
442 if_state_str[if_state()],
443 if_stack_idx,
444 if_state_str[if_stack[if_stack_idx <= 1 ? if_true : if_stack_idx-2]],
445 if_stack_idx-1);
446
447 return if_stack[--if_stack_idx];
448}
449
450if_state_t if_state(void)
451{
452 if(!if_stack_idx)
453 return if_true;
454 else
455 return if_stack[if_stack_idx-1];
456}
457
458
459void next_if_state(int i)
460{
461 switch(if_state())
462 {
463 case if_true:
464 case if_elsetrue:
465 push_if(i ? if_true : if_false);
466 break;
467 case if_false:
468 case if_elsefalse:
469 case if_elif:
470 case if_ignore:
471 push_if(if_ignore);
472 break;
473 default:
474 internal_error(__FILE__, __LINE__, "Invalid if_state (%d) in #{if,ifdef,ifndef} directive", (int)if_state());
475 }
476}
477
478int get_if_depth(void)
479{
480 return if_stack_idx;
481}
482
Note: See TracBrowser for help on using the repository browser.