tools/wrc/preproc.c

   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
  18 extern void set_pp_ignore(int); /* From parser.l */
  19
  20 #define HASHKEY         2039
  21 static pp_entry_t *pp_defines[HASHKEY];
  22
  23 #define MAXIFSTACK      64
  24 static if_state_t if_stack[MAXIFSTACK];
  25 static int if_stack_idx = 0;
  26
  27 #if 0
  28 void pp_status(void) __attribute__((destructor));
  29 void 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... */
  50 int pphash(char *str)
  51 {
  52         int sum = 0;
  53         while(*str)
  54                 sum += *str++;
  55         return sum % HASHKEY;
  56 }
  57
  58 pp_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
  71 void 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
 123 pp_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
 166 pp_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
 175 pp_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
 182 pp_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
 244 static char **includepath;
 245 static int nincludepath = 0;
 246
 247 void 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
 279 FILE *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, "rt");
 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, "rt");
 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  */
 387 static char *if_state_str[] = {
 388         "if_false",
 389         "if_true",
 390         "if_elif",
 391         "if_elsefalse",
 392         "if_elsetrue",
 393         "if_ignore"
 394 };
 395
 396 void 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
 420 if_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
 450 if_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
 459 void 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
 478 int get_if_depth(void)
 479 {
 480         return if_stack_idx;
 481 }
 482