1 /*
   2  * Do C preprocessing, based on a token list gathered by
   3  * the tokenizer.
   4  *
   5  * This may not be the smartest preprocessor on the planet.
   6  *
   7  * Copyright (C) 2003 Transmeta Corp.
   8  *               2003-2004 Linus Torvalds
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  26  * THE SOFTWARE.
  27  */
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <stdarg.h>
  31 #include <stddef.h>
  32 #include <string.h>
  33 #include <ctype.h>
  34 #include <unistd.h>
  35 #include <fcntl.h>
  36 #include <limits.h>
  37 #include <time.h>
  38 #include <dirent.h>
  39 #include <sys/stat.h>
  40 
  41 #include "lib.h"
  42 #include "allocate.h"
  43 #include "parse.h"
  44 #include "token.h"
  45 #include "symbol.h"
  46 #include "expression.h"
  47 #include "scope.h"
  48 
  49 static struct ident_list *macros;       // only needed for -dD
  50 static int false_nesting = 0;
  51 static int counter_macro = 0;           // __COUNTER__ expansion
  52 
  53 #define INCLUDEPATHS 300
  54 const char *includepath[INCLUDEPATHS+1] = {
  55         "",
  56         "/usr/include",
  57         "/usr/local/include",
  58         NULL
  59 };
  60 
  61 static const char **quote_includepath = includepath;
  62 static const char **angle_includepath = includepath + 1;
  63 static const char **isys_includepath   = includepath + 1;
  64 static const char **sys_includepath   = includepath + 1;
  65 static const char **dirafter_includepath = includepath + 3;
  66 
  67 #define dirty_stream(stream)                            \
  68         do {                                            \
  69                 if (!stream->dirty) {                        \
  70                         stream->dirty = 1;           \
  71                         if (!stream->ifndef)         \
  72                                 stream->protect = NULL;      \
  73                 }                                       \
  74         } while(0)
  75 
  76 #define end_group(stream)                                       \
  77         do {                                                    \
  78                 if (stream->ifndef == stream->top_if) {           \
  79                         stream->ifndef = NULL;                       \
  80                         if (!stream->dirty)                  \
  81                                 stream->protect = NULL;              \
  82                         else if (stream->protect)            \
  83                                 stream->dirty = 0;           \
  84                 }                                               \
  85         } while(0)
  86 
  87 #define nesting_error(stream)           \
  88         do {                            \
  89                 stream->dirty = 1;   \
  90                 stream->ifndef = NULL;       \
  91                 stream->protect = NULL;      \
  92         } while(0)
  93 
  94 static struct token *alloc_token(struct position *pos)
  95 {
  96         struct token *token = __alloc_token(0);
  97 
  98         token->pos.stream = pos->stream;
  99         token->pos.line = pos->line;
 100         token->pos.pos = pos->pos;
 101         token->pos.whitespace = 1;
 102         return token;
 103 }
 104 
 105 /* Expand symbol 'sym' at '*list' */
 106 static int expand(struct token **, struct symbol *);
 107 
 108 static void replace_with_string(struct token *token, const char *str)
 109 {
 110         int size = strlen(str) + 1;
 111         struct string *s = __alloc_string(size);
 112 
 113         s->length = size;
 114         memcpy(s->data, str, size);
 115         token_type(token) = TOKEN_STRING;
 116         token->string = s;
 117 }
 118 
 119 static void replace_with_integer(struct token *token, unsigned int val)
 120 {
 121         char *buf = __alloc_bytes(11);
 122         sprintf(buf, "%u", val);
 123         token_type(token) = TOKEN_NUMBER;
 124         token->number = buf;
 125 }
 126 
 127 static struct symbol *lookup_macro(struct ident *ident)
 128 {
 129         struct symbol *sym = lookup_symbol(ident, NS_MACRO | NS_UNDEF);
 130         if (sym && sym->namespace != NS_MACRO)
 131                 sym = NULL;
 132         return sym;
 133 }
 134 
 135 static int token_defined(struct token *token)
 136 {
 137         if (token_type(token) == TOKEN_IDENT) {
 138                 struct symbol *sym = lookup_macro(token->ident);
 139                 if (sym) {
 140                         sym->used_in = file_scope;
 141                         return 1;
 142                 }
 143                 return 0;
 144         }
 145 
 146         sparse_error(token->pos, "expected preprocessor identifier");
 147         return 0;
 148 }
 149 
 150 static void replace_with_defined(struct token *token)
 151 {
 152         static const char *string[] = { "0", "1" };
 153         int defined = token_defined(token);
 154 
 155         token_type(token) = TOKEN_NUMBER;
 156         token->number = string[defined];
 157 }
 158 
 159 static int expand_one_symbol(struct token **list)
 160 {
 161         struct token *token = *list;
 162         struct symbol *sym;
 163         static char buffer[12]; /* __DATE__: 3 + ' ' + 2 + ' ' + 4 + '\0' */
 164         static time_t t = 0;
 165 
 166         if (token->pos.noexpand)
 167                 return 1;
 168 
 169         sym = lookup_macro(token->ident);
 170         if (sym) {
 171                 store_macro_pos(token);
 172                 sym->used_in = file_scope;
 173                 return expand(list, sym);
 174         }
 175         if (token->ident == &__LINE___ident) {
 176                 replace_with_integer(token, token->pos.line);
 177         } else if (token->ident == &__FILE___ident) {
 178                 replace_with_string(token, stream_name(token->pos.stream));
 179         } else if (token->ident == &__DATE___ident) {
 180                 if (!t)
 181                         time(&t);
 182                 strftime(buffer, 12, "%b %e %Y", localtime(&t));
 183                 replace_with_string(token, buffer);
 184         } else if (token->ident == &__TIME___ident) {
 185                 if (!t)
 186                         time(&t);
 187                 strftime(buffer, 9, "%T", localtime(&t));
 188                 replace_with_string(token, buffer);
 189         } else if (token->ident == &__COUNTER___ident) {
 190                 replace_with_integer(token, counter_macro++);
 191         }
 192         return 1;
 193 }
 194 
 195 static inline struct token *scan_next(struct token **where)
 196 {
 197         struct token *token = *where;
 198         if (token_type(token) != TOKEN_UNTAINT)
 199                 return token;
 200         do {
 201                 token->ident->tainted = 0;
 202                 token = token->next;
 203         } while (token_type(token) == TOKEN_UNTAINT);
 204         *where = token;
 205         return token;
 206 }
 207 
 208 static void expand_list(struct token **list)
 209 {
 210         struct token *next;
 211         while (!eof_token(next = scan_next(list))) {
 212                 if (token_type(next) != TOKEN_IDENT || expand_one_symbol(list))
 213                         list = &next->next;
 214         }
 215 }
 216 
 217 static void preprocessor_line(struct stream *stream, struct token **line);
 218 
 219 static struct token *collect_arg(struct token *prev, int vararg, struct position *pos, int count)
 220 {
 221         struct stream *stream = input_streams + prev->pos.stream;
 222         struct token **p = &prev->next;
 223         struct token *next;
 224         int nesting = 0;
 225 
 226         while (!eof_token(next = scan_next(p))) {
 227                 if (next->pos.newline && match_op(next, '#')) {
 228                         if (!next->pos.noexpand) {
 229                                 sparse_error(next->pos,
 230                                              "directive in argument list");
 231                                 preprocessor_line(stream, p);
 232                                 __free_token(next);     /* Free the '#' token */
 233                                 continue;
 234                         }
 235                 }
 236                 switch (token_type(next)) {
 237                 case TOKEN_STREAMEND:
 238                 case TOKEN_STREAMBEGIN:
 239                         *p = &eof_token_entry;
 240                         return next;
 241                 case TOKEN_STRING:
 242                 case TOKEN_WIDE_STRING:
 243                         if (count > 1)
 244                                 next->string->immutable = 1;
 245                         break;
 246                 }
 247                 if (false_nesting) {
 248                         *p = next->next;
 249                         __free_token(next);
 250                         continue;
 251                 }
 252                 if (match_op(next, '(')) {
 253                         nesting++;
 254                 } else if (match_op(next, ')')) {
 255                         if (!nesting--)
 256                                 break;
 257                 } else if (match_op(next, ',') && !nesting && !vararg) {
 258                         break;
 259                 }
 260                 next->pos.stream = pos->stream;
 261                 next->pos.line = pos->line;
 262                 next->pos.pos = pos->pos;
 263                 p = &next->next;
 264         }
 265         *p = &eof_token_entry;
 266         return next;
 267 }
 268 
 269 /*
 270  * We store arglist as <counter> [arg1] <number of uses for arg1> ... eof
 271  */
 272 
 273 struct arg {
 274         struct token *arg;
 275         struct token *expanded;
 276         struct token *str;
 277         int n_normal;
 278         int n_quoted;
 279         int n_str;
 280 };
 281 
 282 static int collect_arguments(struct token *start, struct token *arglist, struct arg *args, struct token *what)
 283 {
 284         int wanted = arglist->count.normal;
 285         struct token *next = NULL;
 286         int count = 0;
 287 
 288         arglist = arglist->next;     /* skip counter */
 289 
 290         if (!wanted) {
 291                 next = collect_arg(start, 0, &what->pos, 0);
 292                 if (eof_token(next))
 293                         goto Eclosing;
 294                 if (!eof_token(start->next) || !match_op(next, ')')) {
 295                         count++;
 296                         goto Emany;
 297                 }
 298         } else {
 299                 for (count = 0; count < wanted; count++) {
 300                         struct argcount *p = &arglist->next->count;
 301                         next = collect_arg(start, p->vararg, &what->pos, p->normal);
 302                         if (eof_token(next))
 303                                 goto Eclosing;
 304                         if (p->vararg && wanted == 1 && eof_token(start->next))
 305                                 break;
 306                         arglist = arglist->next->next;
 307                         args[count].arg = start->next;
 308                         args[count].n_normal = p->normal;
 309                         args[count].n_quoted = p->quoted;
 310                         args[count].n_str = p->str;
 311                         if (match_op(next, ')')) {
 312                                 count++;
 313                                 break;
 314                         }
 315                         start = next;
 316                 }
 317                 if (count == wanted && !match_op(next, ')'))
 318                         goto Emany;
 319                 if (count == wanted - 1) {
 320                         struct argcount *p = &arglist->next->count;
 321                         if (!p->vararg)
 322                                 goto Efew;
 323                         args[count].arg = NULL;
 324                         args[count].n_normal = p->normal;
 325                         args[count].n_quoted = p->quoted;
 326                         args[count].n_str = p->str;
 327                 }
 328                 if (count < wanted - 1)
 329                         goto Efew;
 330         }
 331         what->next = next->next;
 332         return 1;
 333 
 334 Efew:
 335         sparse_error(what->pos, "macro \"%s\" requires %d arguments, but only %d given",
 336                 show_token(what), wanted, count);
 337         goto out;
 338 Emany:
 339         while (match_op(next, ',')) {
 340                 next = collect_arg(next, 0, &what->pos, 0);
 341                 count++;
 342         }
 343         if (eof_token(next))
 344                 goto Eclosing;
 345         sparse_error(what->pos, "macro \"%s\" passed %d arguments, but takes just %d",
 346                 show_token(what), count, wanted);
 347         goto out;
 348 Eclosing:
 349         sparse_error(what->pos, "unterminated argument list invoking macro \"%s\"",
 350                 show_token(what));
 351 out:
 352         what->next = next->next;
 353         return 0;
 354 }
 355 
 356 static struct token *dup_list(struct token *list)
 357 {
 358         struct token *res = NULL;
 359         struct token **p = &res;
 360 
 361         while (!eof_token(list)) {
 362                 struct token *newtok = __alloc_token(0);
 363                 *newtok = *list;
 364                 *p = newtok;
 365                 p = &newtok->next;
 366                 list = list->next;
 367         }
 368         return res;
 369 }
 370 
 371 static const char *show_token_sequence(struct token *token, int quote)
 372 {
 373         static char buffer[MAX_STRING];
 374         char *ptr = buffer;
 375         int whitespace = 0;
 376 
 377         if (!token && !quote)
 378                 return "<none>";
 379         while (!eof_token(token)) {
 380                 const char *val = quote ? quote_token(token) : show_token(token);
 381                 int len = strlen(val);
 382 
 383                 if (ptr + whitespace + len >= buffer + sizeof(buffer)) {
 384                         sparse_error(token->pos, "too long token expansion");
 385                         break;
 386                 }
 387 
 388                 if (whitespace)
 389                         *ptr++ = ' ';
 390                 memcpy(ptr, val, len);
 391                 ptr += len;
 392                 token = token->next;
 393                 whitespace = token->pos.whitespace;
 394         }
 395         *ptr = 0;
 396         return buffer;
 397 }
 398 
 399 static struct token *stringify(struct token *arg)
 400 {
 401         const char *s = show_token_sequence(arg, 1);
 402         int size = strlen(s)+1;
 403         struct token *token = __alloc_token(0);
 404         struct string *string = __alloc_string(size);
 405 
 406         memcpy(string->data, s, size);
 407         string->length = size;
 408         token->pos = arg->pos;
 409         token_type(token) = TOKEN_STRING;
 410         token->string = string;
 411         token->next = &eof_token_entry;
 412         return token;
 413 }
 414 
 415 static void expand_arguments(int count, struct arg *args)
 416 {
 417         int i;
 418         for (i = 0; i < count; i++) {
 419                 struct token *arg = args[i].arg;
 420                 if (!arg)
 421                         arg = &eof_token_entry;
 422                 if (args[i].n_str)
 423                         args[i].str = stringify(arg);
 424                 if (args[i].n_normal) {
 425                         if (!args[i].n_quoted) {
 426                                 args[i].expanded = arg;
 427                                 args[i].arg = NULL;
 428                         } else if (eof_token(arg)) {
 429                                 args[i].expanded = arg;
 430                         } else {
 431                                 args[i].expanded = dup_list(arg);
 432                         }
 433                         expand_list(&args[i].expanded);
 434                 }
 435         }
 436 }
 437 
 438 /*
 439  * Possibly valid combinations:
 440  *  - ident + ident -> ident
 441  *  - ident + number -> ident unless number contains '.', '+' or '-'.
 442  *  - 'L' + char constant -> wide char constant
 443  *  - 'L' + string literal -> wide string literal
 444  *  - number + number -> number
 445  *  - number + ident -> number
 446  *  - number + '.' -> number
 447  *  - number + '+' or '-' -> number, if number used to end on [eEpP].
 448  *  - '.' + number -> number, if number used to start with a digit.
 449  *  - special + special -> either special or an error.
 450  */
 451 static enum token_type combine(struct token *left, struct token *right, char *p)
 452 {
 453         int len;
 454         enum token_type t1 = token_type(left), t2 = token_type(right);
 455 
 456         if (t1 != TOKEN_IDENT && t1 != TOKEN_NUMBER && t1 != TOKEN_SPECIAL)
 457                 return TOKEN_ERROR;
 458 
 459         if (t1 == TOKEN_IDENT && left->ident == &L_ident) {
 460                 if (t2 >= TOKEN_CHAR && t2 < TOKEN_WIDE_CHAR)
 461                         return t2 + TOKEN_WIDE_CHAR - TOKEN_CHAR;
 462                 if (t2 == TOKEN_STRING)
 463                         return TOKEN_WIDE_STRING;
 464         }
 465 
 466         if (t2 != TOKEN_IDENT && t2 != TOKEN_NUMBER && t2 != TOKEN_SPECIAL)
 467                 return TOKEN_ERROR;
 468 
 469         strcpy(p, show_token(left));
 470         strcat(p, show_token(right));
 471         len = strlen(p);
 472 
 473         if (len >= 256)
 474                 return TOKEN_ERROR;
 475 
 476         if (t1 == TOKEN_IDENT) {
 477                 if (t2 == TOKEN_SPECIAL)
 478                         return TOKEN_ERROR;
 479                 if (t2 == TOKEN_NUMBER && strpbrk(p, "+-."))
 480                         return TOKEN_ERROR;
 481                 return TOKEN_IDENT;
 482         }
 483 
 484         if (t1 == TOKEN_NUMBER) {
 485                 if (t2 == TOKEN_SPECIAL) {
 486                         switch (right->special) {
 487                         case '.':
 488                                 break;
 489                         case '+': case '-':
 490                                 if (strchr("eEpP", p[len - 2]))
 491                                         break;
 492                         default:
 493                                 return TOKEN_ERROR;
 494                         }
 495                 }
 496                 return TOKEN_NUMBER;
 497         }
 498 
 499         if (p[0] == '.' && isdigit((unsigned char)p[1]))
 500                 return TOKEN_NUMBER;
 501 
 502         return TOKEN_SPECIAL;
 503 }
 504 
 505 static int merge(struct token *left, struct token *right)
 506 {
 507         static char buffer[512];
 508         enum token_type res = combine(left, right, buffer);
 509         int n;
 510 
 511         switch (res) {
 512         case TOKEN_IDENT:
 513                 left->ident = built_in_ident(buffer);
 514                 left->pos.noexpand = 0;
 515                 return 1;
 516 
 517         case TOKEN_NUMBER: {
 518                 char *number = __alloc_bytes(strlen(buffer) + 1);
 519                 memcpy(number, buffer, strlen(buffer) + 1);
 520                 token_type(left) = TOKEN_NUMBER;        /* could be . + num */
 521                 left->number = number;
 522                 return 1;
 523         }
 524 
 525         case TOKEN_SPECIAL:
 526                 if (buffer[2] && buffer[3])
 527                         break;
 528                 for (n = SPECIAL_BASE; n < SPECIAL_ARG_SEPARATOR; n++) {
 529                         if (!memcmp(buffer, combinations[n-SPECIAL_BASE], 3)) {
 530                                 left->special = n;
 531                                 return 1;
 532                         }
 533                 }
 534                 break;
 535 
 536         case TOKEN_WIDE_CHAR:
 537         case TOKEN_WIDE_STRING:
 538                 token_type(left) = res;
 539                 left->pos.noexpand = 0;
 540                 left->string = right->string;
 541                 return 1;
 542 
 543         case TOKEN_WIDE_CHAR_EMBEDDED_0 ... TOKEN_WIDE_CHAR_EMBEDDED_3:
 544                 token_type(left) = res;
 545                 left->pos.noexpand = 0;
 546                 memcpy(left->embedded, right->embedded, 4);
 547                 return 1;
 548 
 549         default:
 550                 ;
 551         }
 552         sparse_error(left->pos, "'##' failed: concatenation is not a valid token");
 553         return 0;
 554 }
 555 
 556 static struct token *dup_token(struct token *token, struct position *streampos)
 557 {
 558         struct token *alloc = alloc_token(streampos);
 559         token_type(alloc) = token_type(token);
 560         alloc->pos.newline = token->pos.newline;
 561         alloc->pos.whitespace = token->pos.whitespace;
 562         alloc->number = token->number;
 563         alloc->pos.noexpand = token->pos.noexpand;
 564         return alloc;   
 565 }
 566 
 567 static struct token **copy(struct token **where, struct token *list, int *count)
 568 {
 569         int need_copy = --*count;
 570         while (!eof_token(list)) {
 571                 struct token *token;
 572                 if (need_copy)
 573                         token = dup_token(list, &list->pos);
 574                 else
 575                         token = list;
 576                 if (token_type(token) == TOKEN_IDENT && token->ident->tainted)
 577                         token->pos.noexpand = 1;
 578                 *where = token;
 579                 where = &token->next;
 580                 list = list->next;
 581         }
 582         *where = &eof_token_entry;
 583         return where;
 584 }
 585 
 586 static int handle_kludge(struct token **p, struct arg *args)
 587 {
 588         struct token *t = (*p)->next->next;
 589         while (1) {
 590                 struct arg *v = &args[t->argnum];
 591                 if (token_type(t->next) != TOKEN_CONCAT) {
 592                         if (v->arg) {
 593                                 /* ignore the first ## */
 594                                 *p = (*p)->next;
 595                                 return 0;
 596                         }
 597                         /* skip the entire thing */
 598                         *p = t;
 599                         return 1;
 600                 }
 601                 if (v->arg && !eof_token(v->arg))
 602                         return 0; /* no magic */
 603                 t = t->next->next;
 604         }
 605 }
 606 
 607 static struct token **substitute(struct token **list, struct token *body, struct arg *args)
 608 {
 609         struct position *base_pos = &(*list)->pos;
 610         int *count;
 611         enum {Normal, Placeholder, Concat} state = Normal;
 612 
 613         for (; !eof_token(body); body = body->next) {
 614                 struct token *added, *arg;
 615                 struct token **tail;
 616                 struct token *t;
 617 
 618                 switch (token_type(body)) {
 619                 case TOKEN_GNU_KLUDGE:
 620                         /*
 621                          * GNU kludge: if we had <comma>##<vararg>, behaviour
 622                          * depends on whether we had enough arguments to have
 623                          * a vararg.  If we did, ## is just ignored.  Otherwise
 624                          * both , and ## are ignored.  Worse, there can be
 625                          * an arbitrary number of ##<arg> in between; if all of
 626                          * those are empty, we act as if they hadn't been there,
 627                          * otherwise we act as if the kludge didn't exist.
 628                          */
 629                         t = body;
 630                         if (handle_kludge(&body, args)) {
 631                                 if (state == Concat)
 632                                         state = Normal;
 633                                 else
 634                                         state = Placeholder;
 635                                 continue;
 636                         }
 637                         added = dup_token(t, base_pos);
 638                         token_type(added) = TOKEN_SPECIAL;
 639                         tail = &added->next;
 640                         break;
 641 
 642                 case TOKEN_STR_ARGUMENT:
 643                         arg = args[body->argnum].str;
 644                         count = &args[body->argnum].n_str;
 645                         goto copy_arg;
 646 
 647                 case TOKEN_QUOTED_ARGUMENT:
 648                         arg = args[body->argnum].arg;
 649                         count = &args[body->argnum].n_quoted;
 650                         if (!arg || eof_token(arg)) {
 651                                 if (state == Concat)
 652                                         state = Normal;
 653                                 else
 654                                         state = Placeholder;
 655                                 continue;
 656                         }
 657                         goto copy_arg;
 658 
 659                 case TOKEN_MACRO_ARGUMENT:
 660                         arg = args[body->argnum].expanded;
 661                         count = &args[body->argnum].n_normal;
 662                         if (eof_token(arg)) {
 663                                 state = Normal;
 664                                 continue;
 665                         }
 666                 copy_arg:
 667                         tail = copy(&added, arg, count);
 668                         added->pos.newline = body->pos.newline;
 669                         added->pos.whitespace = body->pos.whitespace;
 670                         break;
 671 
 672                 case TOKEN_CONCAT:
 673                         if (state == Placeholder)
 674                                 state = Normal;
 675                         else
 676                                 state = Concat;
 677                         continue;
 678 
 679                 case TOKEN_IDENT:
 680                         added = dup_token(body, base_pos);
 681                         if (added->ident->tainted)
 682                                 added->pos.noexpand = 1;
 683                         tail = &added->next;
 684                         break;
 685 
 686                 default:
 687                         added = dup_token(body, base_pos);
 688                         tail = &added->next;
 689                         break;
 690                 }
 691 
 692                 /*
 693                  * if we got to doing real concatenation, we already have
 694                  * added something into the list, so containing_token() is OK.
 695                  */
 696                 if (state == Concat && merge(containing_token(list), added)) {
 697                         *list = added->next;
 698                         if (tail != &added->next)
 699                                 list = tail;
 700                 } else {
 701                         *list = added;
 702                         list = tail;
 703                 }
 704                 state = Normal;
 705         }
 706         *list = &eof_token_entry;
 707         return list;
 708 }
 709 
 710 static int expand(struct token **list, struct symbol *sym)
 711 {
 712         struct token *last;
 713         struct token *token = *list;
 714         struct ident *expanding = token->ident;
 715         struct token **tail;
 716         int nargs = sym->arglist ? sym->arglist->count.normal : 0;
 717         struct arg args[nargs];
 718 
 719         if (expanding->tainted) {
 720                 token->pos.noexpand = 1;
 721                 return 1;
 722         }
 723 
 724         if (sym->arglist) {
 725                 if (!match_op(scan_next(&token->next), '('))
 726                         return 1;
 727                 if (!collect_arguments(token->next, sym->arglist, args, token))
 728                         return 1;
 729                 expand_arguments(nargs, args);
 730         }
 731 
 732         expanding->tainted = 1;
 733 
 734         last = token->next;
 735         tail = substitute(list, sym->expansion, args);
 736         /*
 737          * Note that it won't be eof - at least TOKEN_UNTAINT will be there.
 738          * We still can lose the newline flag if the sucker expands to nothing,
 739          * but the price of dealing with that is probably too high (we'd need
 740          * to collect the flags during scan_next())
 741          */
 742         (*list)->pos.newline = token->pos.newline;
 743         (*list)->pos.whitespace = token->pos.whitespace;
 744         *tail = last;
 745 
 746         return 0;
 747 }
 748 
 749 static const char *token_name_sequence(struct token *token, int endop, struct token *start)
 750 {
 751         static char buffer[256];
 752         char *ptr = buffer;
 753 
 754         while (!eof_token(token) && !match_op(token, endop)) {
 755                 int len;
 756                 const char *val = token->string->data;
 757                 if (token_type(token) != TOKEN_STRING)
 758                         val = show_token(token);
 759                 len = strlen(val);
 760                 memcpy(ptr, val, len);
 761                 ptr += len;
 762                 token = token->next;
 763         }
 764         *ptr = 0;
 765         if (endop && !match_op(token, endop))
 766                 sparse_error(start->pos, "expected '>' at end of filename");
 767         return buffer;
 768 }
 769 
 770 static int already_tokenized(const char *path)
 771 {
 772         int stream, next;
 773 
 774         for (stream = *hash_stream(path); stream >= 0 ; stream = next) {
 775                 struct stream *s = input_streams + stream;
 776 
 777                 next = s->next_stream;
 778                 if (s->once) {
 779                         if (strcmp(path, s->name))
 780                                 continue;
 781                         return 1;
 782                 }
 783                 if (s->constant != CONSTANT_FILE_YES)
 784                         continue;
 785                 if (strcmp(path, s->name))
 786                         continue;
 787                 if (s->protect && !lookup_macro(s->protect))
 788                         continue;
 789                 return 1;
 790         }
 791         return 0;
 792 }
 793 
 794 /* Handle include of header files.
 795  * The relevant options are made compatible with gcc. The only options that
 796  * are not supported is -withprefix and friends.
 797  *
 798  * Three set of include paths are known:
 799  * quote_includepath:   Path to search when using #include "file.h"
 800  * angle_includepath:   Paths to search when using #include <file.h>
 801  * isys_includepath:    Paths specified with -isystem, come before the
 802  *                      built-in system include paths. Gcc would suppress
 803  *                      warnings from system headers. Here we separate
 804  *                      them from the angle_ ones to keep search ordering.
 805  *
 806  * sys_includepath:     Built-in include paths.
 807  * dirafter_includepath Paths added with -dirafter.
 808  *
 809  * The above is implemented as one array with pointers
 810  *                         +--------------+
 811  * quote_includepath --->  |              |
 812  *                         +--------------+
 813  *                         |              |
 814  *                         +--------------+
 815  * angle_includepath --->  |              |
 816  *                         +--------------+
 817  * isys_includepath  --->  |              |
 818  *                         +--------------+
 819  * sys_includepath   --->  |              |
 820  *                         +--------------+
 821  * dirafter_includepath -> |              |
 822  *                         +--------------+
 823  *
 824  * -I dir insert dir just before isys_includepath and move the rest
 825  * -I- makes all dirs specified with -I before to quote dirs only and
 826  *   angle_includepath is set equal to isys_includepath.
 827  * -nostdinc removes all sys dirs by storing NULL in entry pointed
 828  *   to by * sys_includepath. Note that this will reset all dirs built-in
 829  *   and added before -nostdinc by -isystem and -idirafter.
 830  * -isystem dir adds dir where isys_includepath points adding this dir as
 831  *   first systemdir
 832  * -idirafter dir adds dir to the end of the list
 833  */
 834 
 835 static void set_stream_include_path(struct stream *stream)
 836 {
 837         const char *path = stream->path;
 838         if (!path) {
 839                 const char *p = strrchr(stream->name, '/');
 840                 path = "";
 841                 if (p) {
 842                         int len = p - stream->name + 1;
 843                         char *m = malloc(len+1);
 844                         /* This includes the final "/" */
 845                         memcpy(m, stream->name, len);
 846                         m[len] = 0;
 847                         path = m;
 848                 }
 849                 stream->path = path;
 850         }
 851         includepath[0] = path;
 852 }
 853 
 854 static int try_include(const char *path, const char *filename, int flen, struct token **where, const char **next_path)
 855 {
 856         int fd;
 857         int plen = strlen(path);
 858         static char fullname[PATH_MAX];
 859 
 860         memcpy(fullname, path, plen);
 861         if (plen && path[plen-1] != '/') {
 862                 fullname[plen] = '/';
 863                 plen++;
 864         }
 865         memcpy(fullname+plen, filename, flen);
 866         if (already_tokenized(fullname))
 867                 return 1;
 868         fd = open(fullname, O_RDONLY);
 869         if (fd >= 0) {
 870                 char * streamname = __alloc_bytes(plen + flen);
 871                 memcpy(streamname, fullname, plen + flen);
 872                 *where = tokenize(streamname, fd, *where, next_path);
 873                 close(fd);
 874                 return 1;
 875         }
 876         return 0;
 877 }
 878 
 879 static int do_include_path(const char **pptr, struct token **list, struct token *token, const char *filename, int flen)
 880 {
 881         const char *path;
 882 
 883         while ((path = *pptr++) != NULL) {
 884                 if (!try_include(path, filename, flen, list, pptr))
 885                         continue;
 886                 return 1;
 887         }
 888         return 0;
 889 }
 890 
 891 static int free_preprocessor_line(struct token *token)
 892 {
 893         while (token_type(token) != TOKEN_EOF) {
 894                 struct token *free = token;
 895                 token = token->next;
 896                 __free_token(free);
 897         };
 898         return 1;
 899 }
 900 
 901 const char *find_include(const char *skip, const char *look_for)
 902 {
 903         DIR *dp;
 904         struct dirent *entry;
 905         struct stat statbuf;
 906         const char *ret;
 907         char cwd[PATH_MAX];
 908         static char buf[PATH_MAX + 1];
 909 
 910         dp = opendir(".");
 911         if (!dp)
 912                 return NULL;
 913 
 914         if (!getcwd(cwd, sizeof(cwd)))
 915                 return NULL;
 916 
 917         while ((entry = readdir(dp))) {
 918                 lstat(entry->d_name, &statbuf);
 919 
 920                 if (strcmp(entry->d_name, look_for) == 0) {
 921                         snprintf(buf, sizeof(buf), "%s/%s", cwd, entry->d_name);
 922                         return buf;
 923                 }
 924 
 925                 if (S_ISDIR(statbuf.st_mode)) {
 926                         /* Found a directory, but ignore . and .. */
 927                         if (strcmp(".", entry->d_name) == 0 ||
 928                             strcmp("..", entry->d_name) == 0 ||
 929                             strcmp(skip, entry->d_name) == 0)
 930                                 continue;
 931 
 932                         chdir(entry->d_name);
 933                         ret = find_include("", look_for);
 934                         chdir("..");
 935                         if (ret)
 936                                 return ret;
 937                 }
 938         }
 939         closedir(dp);
 940 
 941         return NULL;
 942 }
 943 
 944 const char *search_dir(const char *stop, const char *look_for)
 945 {
 946         char cwd[PATH_MAX];
 947         int len;
 948         const char *ret;
 949         int cnt = 0;
 950 
 951         if (!getcwd(cwd, sizeof(cwd)))
 952                 return NULL;
 953 
 954         len = strlen(cwd);
 955         while (len >= 0) {
 956                 ret = find_include(cnt++ ? cwd + len + 1 : "", look_for);
 957                 if (ret)
 958                         return ret;
 959 
 960                 if (strcmp(cwd, stop) == 0 ||
 961                     strcmp(cwd, "/usr/include") == 0 ||
 962                     strcmp(cwd, "/usr/local/include") == 0 ||
 963                     strlen(cwd) <= 10 ||  /* heck...  don't search /usr/lib/ */
 964                     strcmp(cwd, "/") == 0)
 965                         return NULL;
 966 
 967                 while (--len >= 0) {
 968                         if (cwd[len] == '/') {
 969                                 cwd[len] = '\0';
 970                                 break;
 971                         }
 972                 }
 973 
 974                 chdir("..");
 975         }
 976         return NULL;
 977 }
 978 
 979 static void use_best_guess_header_file(struct token *token, const char *filename, struct token **list)
 980 {
 981         char cwd[PATH_MAX];
 982         char dir_part[PATH_MAX];
 983         const char *file_part;
 984         const char *include_name;
 985         int len;
 986 
 987         if (!filename || filename[0] == '\0')
 988                 return;
 989 
 990         file_part = filename;
 991         while ((filename = strchr(filename, '/'))) {
 992                 ++filename;
 993                 if (filename[0])
 994                         file_part = filename;
 995         }
 996 
 997         snprintf(dir_part, sizeof(dir_part), "%s", stream_name(token->pos.stream));
 998         len = strlen(dir_part);
 999         while (--len >= 0) {
1000                 if (dir_part[len] == '/') {
1001                         dir_part[len] = '\0';
1002                         break;
1003                 }
1004         }
1005         if (len < 0)
1006                 sprintf(dir_part, ".");
1007 
1008         if (!getcwd(cwd, sizeof(cwd)))
1009                 return;
1010 
1011         chdir(dir_part);
1012         include_name = search_dir(cwd, file_part);
1013         chdir(cwd);
1014         if (!include_name)
1015                 return;
1016         sparse_error(token->pos, "using '%s'", include_name);
1017 
1018         try_include("", include_name, strlen(include_name), list, includepath);
1019 }
1020 
1021 static int handle_include_path(struct stream *stream, struct token **list, struct token *token, int how)
1022 {
1023         const char *filename;
1024         struct token *next;
1025         const char **path;
1026         int expect;
1027         int flen;
1028 
1029         next = token->next;
1030         expect = '>';
1031         if (!match_op(next, '<')) {
1032                 expand_list(&token->next);
1033                 expect = 0;
1034                 next = token;
1035                 if (match_op(token->next, '<')) {
1036                         next = token->next;
1037                         expect = '>';
1038                 }
1039         }
1040 
1041         token = next->next;
1042         filename = token_name_sequence(token, expect, token);
1043         flen = strlen(filename) + 1;
1044 
1045         /* Absolute path? */
1046         if (filename[0] == '/') {
1047                 if (try_include("", filename, flen, list, includepath))
1048                         return 0;
1049                 goto out;
1050         }
1051 
1052         switch (how) {
1053         case 1:
1054                 path = stream->next_path;
1055                 break;
1056         case 2:
1057                 includepath[0] = "";
1058                 path = includepath;
1059                 break;
1060         default:
1061                 /* Dir of input file is first dir to search for quoted includes */
1062                 set_stream_include_path(stream);
1063                 path = expect ? angle_includepath : quote_includepath;
1064                 break;
1065         }
1066         /* Check the standard include paths.. */
1067         if (do_include_path(path, list, token, filename, flen))
1068                 return 0;
1069 out:
1070         sparse_error(token->pos, "unable to open '%s'", filename);
1071         use_best_guess_header_file(token, filename, list);
1072         return 0;
1073 }
1074 
1075 static int handle_include(struct stream *stream, struct token **list, struct token *token)
1076 {
1077         return handle_include_path(stream, list, token, 0);
1078 }
1079 
1080 static int handle_include_next(struct stream *stream, struct token **list, struct token *token)
1081 {
1082         return handle_include_path(stream, list, token, 1);
1083 }
1084 
1085 static int handle_argv_include(struct stream *stream, struct token **list, struct token *token)
1086 {
1087         return handle_include_path(stream, list, token, 2);
1088 }
1089 
1090 static int token_different(struct token *t1, struct token *t2)
1091 {
1092         int different;
1093 
1094         if (token_type(t1) != token_type(t2))
1095                 return 1;
1096 
1097         switch (token_type(t1)) {
1098         case TOKEN_IDENT:
1099                 different = t1->ident != t2->ident;
1100                 break;
1101         case TOKEN_ARG_COUNT:
1102         case TOKEN_UNTAINT:
1103         case TOKEN_CONCAT:
1104         case TOKEN_GNU_KLUDGE:
1105                 different = 0;
1106                 break;
1107         case TOKEN_NUMBER:
1108                 different = strcmp(t1->number, t2->number);
1109                 break;
1110         case TOKEN_SPECIAL:
1111                 different = t1->special != t2->special;
1112                 break;
1113         case TOKEN_MACRO_ARGUMENT:
1114         case TOKEN_QUOTED_ARGUMENT:
1115         case TOKEN_STR_ARGUMENT:
1116                 different = t1->argnum != t2->argnum;
1117                 break;
1118         case TOKEN_CHAR_EMBEDDED_0 ... TOKEN_CHAR_EMBEDDED_3:
1119         case TOKEN_WIDE_CHAR_EMBEDDED_0 ... TOKEN_WIDE_CHAR_EMBEDDED_3:
1120                 different = memcmp(t1->embedded, t2->embedded, 4);
1121                 break;
1122         case TOKEN_CHAR:
1123         case TOKEN_WIDE_CHAR:
1124         case TOKEN_STRING:
1125         case TOKEN_WIDE_STRING: {
1126                 struct string *s1, *s2;
1127 
1128                 s1 = t1->string;
1129                 s2 = t2->string;
1130                 different = 1;
1131                 if (s1->length != s2->length)
1132                         break;
1133                 different = memcmp(s1->data, s2->data, s1->length);
1134                 break;
1135         }
1136         default:
1137                 different = 1;
1138                 break;
1139         }
1140         return different;
1141 }
1142 
1143 static int token_list_different(struct token *list1, struct token *list2)
1144 {
1145         for (;;) {
1146                 if (list1 == list2)
1147                         return 0;
1148                 if (!list1 || !list2)
1149                         return 1;
1150                 if (token_different(list1, list2))
1151                         return 1;
1152                 list1 = list1->next;
1153                 list2 = list2->next;
1154         }
1155 }
1156 
1157 static inline void set_arg_count(struct token *token)
1158 {
1159         token_type(token) = TOKEN_ARG_COUNT;
1160         token->count.normal = token->count.quoted =
1161         token->count.str = token->count.vararg = 0;
1162 }
1163 
1164 static struct token *parse_arguments(struct token *list)
1165 {
1166         struct token *arg = list->next, *next = list;
1167         struct argcount *count = &list->count;
1168 
1169         set_arg_count(list);
1170 
1171         if (match_op(arg, ')')) {
1172                 next = arg->next;
1173                 list->next = &eof_token_entry;
1174                 return next;
1175         }
1176 
1177         while (token_type(arg) == TOKEN_IDENT) {
1178                 if (arg->ident == &__VA_ARGS___ident)
1179                         goto Eva_args;
1180                 if (!++count->normal)
1181                         goto Eargs;
1182                 next = arg->next;
1183 
1184                 if (match_op(next, ',')) {
1185                         set_arg_count(next);
1186                         arg = next->next;
1187                         continue;
1188                 }
1189 
1190                 if (match_op(next, ')')) {
1191                         set_arg_count(next);
1192                         next = next->next;
1193                         arg->next->next = &eof_token_entry;
1194                         return next;
1195                 }
1196 
1197                 /* normal cases are finished here */
1198 
1199                 if (match_op(next, SPECIAL_ELLIPSIS)) {
1200                         if (match_op(next->next, ')')) {
1201                                 set_arg_count(next);
1202                                 next->count.vararg = 1;
1203                                 next = next->next;
1204                                 arg->next->next = &eof_token_entry;
1205                                 return next->next;
1206                         }
1207 
1208                         arg = next;
1209                         goto Enotclosed;
1210                 }
1211 
1212                 if (eof_token(next)) {
1213                         goto Enotclosed;
1214                 } else {
1215                         arg = next;
1216                         goto Ebadstuff;
1217                 }
1218         }
1219 
1220         if (match_op(arg, SPECIAL_ELLIPSIS)) {
1221                 next = arg->next;
1222                 token_type(arg) = TOKEN_IDENT;
1223                 arg->ident = &__VA_ARGS___ident;
1224                 if (!match_op(next, ')'))
1225                         goto Enotclosed;
1226                 if (!++count->normal)
1227                         goto Eargs;
1228                 set_arg_count(next);
1229                 next->count.vararg = 1;
1230                 next = next->next;
1231                 arg->next->next = &eof_token_entry;
1232                 return next;
1233         }
1234 
1235         if (eof_token(arg)) {
1236                 arg = next;
1237                 goto Enotclosed;
1238         }
1239         if (match_op(arg, ','))
1240                 goto Emissing;
1241         else
1242                 goto Ebadstuff;
1243 
1244 
1245 Emissing:
1246         sparse_error(arg->pos, "parameter name missing");
1247         return NULL;
1248 Ebadstuff:
1249         sparse_error(arg->pos, "\"%s\" may not appear in macro parameter list",
1250                 show_token(arg));
1251         return NULL;
1252 Enotclosed:
1253         sparse_error(arg->pos, "missing ')' in macro parameter list");
1254         return NULL;
1255 Eva_args:
1256         sparse_error(arg->pos, "__VA_ARGS__ can only appear in the expansion of a C99 variadic macro");
1257         return NULL;
1258 Eargs:
1259         sparse_error(arg->pos, "too many arguments in macro definition");
1260         return NULL;
1261 }
1262 
1263 static int try_arg(struct token *token, enum token_type type, struct token *arglist)
1264 {
1265         struct ident *ident = token->ident;
1266         int nr;
1267 
1268         if (!arglist || token_type(token) != TOKEN_IDENT)
1269                 return 0;
1270 
1271         arglist = arglist->next;
1272 
1273         for (nr = 0; !eof_token(arglist); nr++, arglist = arglist->next->next) {
1274                 if (arglist->ident == ident) {
1275                         struct argcount *count = &arglist->next->count;
1276                         int n;
1277 
1278                         token->argnum = nr;
1279                         token_type(token) = type;
1280                         switch (type) {
1281                         case TOKEN_MACRO_ARGUMENT:
1282                                 n = ++count->normal;
1283                                 break;
1284                         case TOKEN_QUOTED_ARGUMENT:
1285                                 n = ++count->quoted;
1286                                 break;
1287                         default:
1288                                 n = ++count->str;
1289                         }
1290                         if (n)
1291                                 return count->vararg ? 2 : 1;
1292                         /*
1293                          * XXX - need saner handling of that
1294                          * (>= 1024 instances of argument)
1295                          */
1296                         token_type(token) = TOKEN_ERROR;
1297                         return -1;
1298                 }
1299         }
1300         return 0;
1301 }
1302 
1303 static struct token *handle_hash(struct token **p, struct token *arglist)
1304 {
1305         struct token *token = *p;
1306         if (arglist) {
1307                 struct token *next = token->next;
1308                 if (!try_arg(next, TOKEN_STR_ARGUMENT, arglist))
1309                         goto Equote;
1310                 next->pos.whitespace = token->pos.whitespace;
1311                 __free_token(token);
1312                 token = *p = next;
1313         } else {
1314                 token->pos.noexpand = 1;
1315         }
1316         return token;
1317 
1318 Equote:
1319         sparse_error(token->pos, "'#' is not followed by a macro parameter");
1320         return NULL;
1321 }
1322 
1323 /* token->next is ## */
1324 static struct token *handle_hashhash(struct token *token, struct token *arglist)
1325 {
1326         struct token *last = token;
1327         struct token *concat;
1328         int state = match_op(token, ',');
1329         
1330         try_arg(token, TOKEN_QUOTED_ARGUMENT, arglist);
1331 
1332         while (1) {
1333                 struct token *t;
1334                 int is_arg;
1335 
1336                 /* eat duplicate ## */
1337                 concat = token->next;
1338                 while (match_op(t = concat->next, SPECIAL_HASHHASH)) {
1339                         token->next = t;
1340                         __free_token(concat);
1341                         concat = t;
1342                 }
1343                 token_type(concat) = TOKEN_CONCAT;
1344 
1345                 if (eof_token(t))
1346                         goto Econcat;
1347 
1348                 if (match_op(t, '#')) {
1349                         t = handle_hash(&concat->next, arglist);
1350                         if (!t)
1351                                 return NULL;
1352                 }
1353 
1354                 is_arg = try_arg(t, TOKEN_QUOTED_ARGUMENT, arglist);
1355 
1356                 if (state == 1 && is_arg) {
1357                         state = is_arg;
1358                 } else {
1359                         last = t;
1360                         state = match_op(t, ',');
1361                 }
1362 
1363                 token = t;
1364                 if (!match_op(token->next, SPECIAL_HASHHASH))
1365                         break;
1366         }
1367         /* handle GNU ,##__VA_ARGS__ kludge, in all its weirdness */
1368         if (state == 2)
1369                 token_type(last) = TOKEN_GNU_KLUDGE;
1370         return token;
1371 
1372 Econcat:
1373         sparse_error(concat->pos, "'##' cannot appear at the ends of macro expansion");
1374         return NULL;
1375 }
1376 
1377 static struct token *parse_expansion(struct token *expansion, struct token *arglist, struct ident *name)
1378 {
1379         struct token *token = expansion;
1380         struct token **p;
1381 
1382         if (match_op(token, SPECIAL_HASHHASH))
1383                 goto Econcat;
1384 
1385         for (p = &expansion; !eof_token(token); p = &token->next, token = *p) {
1386                 if (match_op(token, '#')) {
1387                         token = handle_hash(p, arglist);
1388                         if (!token)
1389                                 return NULL;
1390                 }
1391                 if (match_op(token->next, SPECIAL_HASHHASH)) {
1392                         token = handle_hashhash(token, arglist);
1393                         if (!token)
1394                                 return NULL;
1395                 } else {
1396                         try_arg(token, TOKEN_MACRO_ARGUMENT, arglist);
1397                 }
1398                 switch (token_type(token)) {
1399                 case TOKEN_ERROR:
1400                         goto Earg;
1401 
1402                 case TOKEN_STRING:
1403                 case TOKEN_WIDE_STRING:
1404                         token->string->immutable = 1;
1405                         break;
1406                 }
1407         }
1408         token = alloc_token(&expansion->pos);
1409         token_type(token) = TOKEN_UNTAINT;
1410         token->ident = name;
1411         token->next = *p;
1412         *p = token;
1413         return expansion;
1414 
1415 Econcat:
1416         sparse_error(token->pos, "'##' cannot appear at the ends of macro expansion");
1417         return NULL;
1418 Earg:
1419         sparse_error(token->pos, "too many instances of argument in body");
1420         return NULL;
1421 }
1422 
1423 static int do_handle_define(struct stream *stream, struct token **line, struct token *token, int attr)
1424 {
1425         struct token *arglist, *expansion;
1426         struct token *left = token->next;
1427         struct symbol *sym;
1428         struct ident *name;
1429         int ret;
1430 
1431         if (token_type(left) != TOKEN_IDENT) {
1432                 sparse_error(token->pos, "expected identifier to 'define'");
1433                 return 1;
1434         }
1435 
1436         name = left->ident;
1437 
1438         arglist = NULL;
1439         expansion = left->next;
1440         if (!expansion->pos.whitespace) {
1441                 if (match_op(expansion, '(')) {
1442                         arglist = expansion;
1443                         expansion = parse_arguments(expansion);
1444                         if (!expansion)
1445                                 return 1;
1446                 } else if (!eof_token(expansion)) {
1447                         warning(expansion->pos,
1448                                 "no whitespace before object-like macro body");
1449                 }
1450         }
1451 
1452         expansion = parse_expansion(expansion, arglist, name);
1453         if (!expansion)
1454                 return 1;
1455 
1456         ret = 1;
1457         sym = lookup_symbol(name, NS_MACRO | NS_UNDEF);
1458         if (sym) {
1459                 int clean;
1460 
1461                 if (attr < sym->attr)
1462                         goto out;
1463 
1464                 clean = (attr == sym->attr && sym->namespace == NS_MACRO);
1465 
1466                 if (token_list_different(sym->expansion, expansion) ||
1467                     token_list_different(sym->arglist, arglist)) {
1468                         ret = 0;
1469                         if ((clean && attr == SYM_ATTR_NORMAL)
1470                                         || sym->used_in == file_scope) {
1471                                 warning(left->pos, "preprocessor token %.*s redefined",
1472                                                 name->len, name->name);
1473                                 info(sym->pos, "this was the original definition");
1474                         }
1475                 } else if (clean)
1476                         goto out;
1477         }
1478 
1479         if (!sym || sym->scope != file_scope) {
1480                 sym = alloc_symbol(left->pos, SYM_NODE);
1481                 bind_symbol(sym, name, NS_MACRO);
1482                 add_ident(&macros, name);
1483                 ret = 0;
1484         }
1485 
1486         if (!ret) {
1487                 sym->expansion = expansion;
1488                 sym->arglist = arglist;
1489                 __free_token(token);    /* Free the "define" token, but not the rest of the line */
1490         }
1491 
1492         sym->namespace = NS_MACRO;
1493         sym->used_in = NULL;
1494         sym->attr = attr;
1495 out:
1496         return ret;
1497 }
1498 
1499 static int handle_define(struct stream *stream, struct token **line, struct token *token)
1500 {
1501         return do_handle_define(stream, line, token, SYM_ATTR_NORMAL);
1502 }
1503 
1504 static int handle_weak_define(struct stream *stream, struct token **line, struct token *token)
1505 {
1506         return do_handle_define(stream, line, token, SYM_ATTR_WEAK);
1507 }
1508 
1509 static int handle_strong_define(struct stream *stream, struct token **line, struct token *token)
1510 {
1511         return do_handle_define(stream, line, token, SYM_ATTR_STRONG);
1512 }
1513 
1514 static int do_handle_undef(struct stream *stream, struct token **line, struct token *token, int attr)
1515 {
1516         struct token *left = token->next;
1517         struct symbol *sym;
1518 
1519         if (token_type(left) != TOKEN_IDENT) {
1520                 sparse_error(token->pos, "expected identifier to 'undef'");
1521                 return 1;
1522         }
1523 
1524         sym = lookup_symbol(left->ident, NS_MACRO | NS_UNDEF);
1525         if (sym) {
1526                 if (attr < sym->attr)
1527                         return 1;
1528                 if (attr == sym->attr && sym->namespace == NS_UNDEF)
1529                         return 1;
1530         } else if (attr <= SYM_ATTR_NORMAL)
1531                 return 1;
1532 
1533         if (!sym || sym->scope != file_scope) {
1534                 sym = alloc_symbol(left->pos, SYM_NODE);
1535                 bind_symbol(sym, left->ident, NS_MACRO);
1536         }
1537 
1538         sym->namespace = NS_UNDEF;
1539         sym->used_in = NULL;
1540         sym->attr = attr;
1541 
1542         return 1;
1543 }
1544 
1545 static int handle_undef(struct stream *stream, struct token **line, struct token *token)
1546 {
1547         return do_handle_undef(stream, line, token, SYM_ATTR_NORMAL);
1548 }
1549 
1550 static int handle_strong_undef(struct stream *stream, struct token **line, struct token *token)
1551 {
1552         return do_handle_undef(stream, line, token, SYM_ATTR_STRONG);
1553 }
1554 
1555 static int preprocessor_if(struct stream *stream, struct token *token, int true)
1556 {
1557         token_type(token) = false_nesting ? TOKEN_SKIP_GROUPS : TOKEN_IF;
1558         free_preprocessor_line(token->next);
1559         token->next = stream->top_if;
1560         stream->top_if = token;
1561         if (false_nesting || true != 1)
1562                 false_nesting++;
1563         return 0;
1564 }
1565 
1566 static int handle_ifdef(struct stream *stream, struct token **line, struct token *token)
1567 {
1568         struct token *next = token->next;
1569         int arg;
1570         if (token_type(next) == TOKEN_IDENT) {
1571                 arg = token_defined(next);
1572         } else {
1573                 dirty_stream(stream);
1574                 if (!false_nesting)
1575                         sparse_error(token->pos, "expected preprocessor identifier");
1576                 arg = -1;
1577         }
1578         return preprocessor_if(stream, token, arg);
1579 }
1580 
1581 static int handle_ifndef(struct stream *stream, struct token **line, struct token *token)
1582 {
1583         struct token *next = token->next;
1584         int arg;
1585         if (token_type(next) == TOKEN_IDENT) {
1586                 if (!stream->dirty && !stream->ifndef) {
1587                         if (!stream->protect) {
1588                                 stream->ifndef = token;
1589                                 stream->protect = next->ident;
1590                         } else if (stream->protect == next->ident) {
1591                                 stream->ifndef = token;
1592                                 stream->dirty = 1;
1593                         }
1594                 }
1595                 arg = !token_defined(next);
1596         } else {
1597                 dirty_stream(stream);
1598                 if (!false_nesting)
1599                         sparse_error(token->pos, "expected preprocessor identifier");
1600                 arg = -1;
1601         }
1602 
1603         return preprocessor_if(stream, token, arg);
1604 }
1605 
1606 static const char *show_token_sequence(struct token *token, int quote);
1607 
1608 /*
1609  * Expression handling for #if and #elif; it differs from normal expansion
1610  * due to special treatment of "defined".
1611  */
1612 static int expression_value(struct token **where)
1613 {
1614         struct expression *expr;
1615         struct token *p;
1616         struct token **list = where, **beginning = NULL;
1617         long long value;
1618         int state = 0;
1619 
1620         while (!eof_token(p = scan_next(list))) {
1621                 switch (state) {
1622                 case 0:
1623                         if (token_type(p) != TOKEN_IDENT)
1624                                 break;
1625                         if (p->ident == &defined_ident) {
1626                                 state = 1;
1627                                 beginning = list;
1628                                 break;
1629                         }
1630                         if (!expand_one_symbol(list))
1631                                 continue;
1632                         if (token_type(p) != TOKEN_IDENT)
1633                                 break;
1634                         token_type(p) = TOKEN_ZERO_IDENT;
1635                         break;
1636                 case 1:
1637                         if (match_op(p, '(')) {
1638                                 state = 2;
1639                         } else {
1640                                 state = 0;
1641                                 replace_with_defined(p);
1642                                 *beginning = p;
1643                         }
1644                         break;
1645                 case 2:
1646                         if (token_type(p) == TOKEN_IDENT)
1647                                 state = 3;
1648                         else
1649                                 state = 0;
1650                         replace_with_defined(p);
1651                         *beginning = p;
1652                         break;
1653                 case 3:
1654                         state = 0;
1655                         if (!match_op(p, ')'))
1656                                 sparse_error(p->pos, "missing ')' after \"defined\"");
1657                         *list = p->next;
1658                         continue;
1659                 }
1660                 list = &p->next;
1661         }
1662 
1663         p = constant_expression(*where, &expr);
1664         if (!eof_token(p))
1665                 sparse_error(p->pos, "garbage at end: %s", show_token_sequence(p, 0));
1666         value = get_expression_value(expr);
1667         return value != 0;
1668 }
1669 
1670 static int handle_if(struct stream *stream, struct token **line, struct token *token)
1671 {
1672         int value = 0;
1673         if (!false_nesting)
1674                 value = expression_value(&token->next);
1675 
1676         dirty_stream(stream);
1677         return preprocessor_if(stream, token, value);
1678 }
1679 
1680 static int handle_elif(struct stream * stream, struct token **line, struct token *token)
1681 {
1682         struct token *top_if = stream->top_if;
1683         end_group(stream);
1684 
1685         if (!top_if) {
1686                 nesting_error(stream);
1687                 sparse_error(token->pos, "unmatched #elif within stream");
1688                 return 1;
1689         }
1690 
1691         if (token_type(top_if) == TOKEN_ELSE) {
1692                 nesting_error(stream);
1693                 sparse_error(token->pos, "#elif after #else");
1694                 if (!false_nesting)
1695                         false_nesting = 1;
1696                 return 1;
1697         }
1698 
1699         dirty_stream(stream);
1700         if (token_type(top_if) != TOKEN_IF)
1701                 return 1;
1702         if (false_nesting) {
1703                 false_nesting = 0;
1704                 if (!expression_value(&token->next))
1705                         false_nesting = 1;
1706         } else {
1707                 false_nesting = 1;
1708                 token_type(top_if) = TOKEN_SKIP_GROUPS;
1709         }
1710         return 1;
1711 }
1712 
1713 static int handle_else(struct stream *stream, struct token **line, struct token *token)
1714 {
1715         struct token *top_if = stream->top_if;
1716         end_group(stream);
1717 
1718         if (!top_if) {
1719                 nesting_error(stream);
1720                 sparse_error(token->pos, "unmatched #else within stream");
1721                 return 1;
1722         }
1723 
1724         if (token_type(top_if) == TOKEN_ELSE) {
1725                 nesting_error(stream);
1726                 sparse_error(token->pos, "#else after #else");
1727         }
1728         if (false_nesting) {
1729                 if (token_type(top_if) == TOKEN_IF)
1730                         false_nesting = 0;
1731         } else {
1732                 false_nesting = 1;
1733         }
1734         token_type(top_if) = TOKEN_ELSE;
1735         return 1;
1736 }
1737 
1738 static int handle_endif(struct stream *stream, struct token **line, struct token *token)
1739 {
1740         struct token *top_if = stream->top_if;
1741         end_group(stream);
1742         if (!top_if) {
1743                 nesting_error(stream);
1744                 sparse_error(token->pos, "unmatched #endif in stream");
1745                 return 1;
1746         }
1747         if (false_nesting)
1748                 false_nesting--;
1749         stream->top_if = top_if->next;
1750         __free_token(top_if);
1751         return 1;
1752 }
1753 
1754 static int handle_warning(struct stream *stream, struct token **line, struct token *token)
1755 {
1756         warning(token->pos, "%s", show_token_sequence(token->next, 0));
1757         return 1;
1758 }
1759 
1760 static int handle_error(struct stream *stream, struct token **line, struct token *token)
1761 {
1762         sparse_error(token->pos, "%s", show_token_sequence(token->next, 0));
1763         return 1;
1764 }
1765 
1766 static int handle_nostdinc(struct stream *stream, struct token **line, struct token *token)
1767 {
1768         /*
1769          * Do we have any non-system includes?
1770          * Clear them out if so..
1771          */
1772         *sys_includepath = NULL;
1773         return 1;
1774 }
1775 
1776 static inline void update_inc_ptrs(const char ***where)
1777 {
1778 
1779         if (*where <= dirafter_includepath) {
1780                 dirafter_includepath++;
1781                 /* If this was the entry that we prepend, don't
1782                  * rise the lower entries, even if they are at
1783                  * the same level. */
1784                 if (where == &dirafter_includepath)
1785                         return;
1786         }
1787         if (*where <= sys_includepath) {
1788                 sys_includepath++;
1789                 if (where == &sys_includepath)
1790                         return;
1791         }
1792         if (*where <= isys_includepath) {
1793                 isys_includepath++;
1794                 if (where == &isys_includepath)
1795                         return;
1796         }
1797 
1798         /* angle_includepath is actually never updated, since we
1799          * don't suppport -iquote rught now. May change some day. */
1800         if (*where <= angle_includepath) {
1801                 angle_includepath++;
1802                 if (where == &angle_includepath)
1803                         return;
1804         }
1805 }
1806 
1807 /* Add a path before 'where' and update the pointers associated with the
1808  * includepath array */
1809 static void add_path_entry(struct token *token, const char *path,
1810         const char ***where)
1811 {
1812         const char **dst;
1813         const char *next;
1814 
1815         /* Need one free entry.. */
1816         if (includepath[INCLUDEPATHS-2])
1817                 error_die(token->pos, "too many include path entries");
1818 
1819         /* check that this is not a duplicate */
1820         dst = includepath;
1821         while (*dst) {
1822                 if (strcmp(*dst, path) == 0)
1823                         return;
1824                 dst++;
1825         }
1826         next = path;
1827         dst = *where;
1828 
1829         update_inc_ptrs(where);
1830 
1831         /*
1832          * Move them all up starting at dst,
1833          * insert the new entry..
1834          */
1835         do {
1836                 const char *tmp = *dst;
1837                 *dst = next;
1838                 next = tmp;
1839                 dst++;
1840         } while (next);
1841 }
1842 
1843 static int handle_add_include(struct stream *stream, struct token **line, struct token *token)
1844 {
1845         for (;;) {
1846                 token = token->next;
1847                 if (eof_token(token))
1848                         return 1;
1849                 if (token_type(token) != TOKEN_STRING) {
1850                         warning(token->pos, "expected path string");
1851                         return 1;
1852                 }
1853                 add_path_entry(token, token->string->data, &isys_includepath);
1854         }
1855 }
1856 
1857 static int handle_add_isystem(struct stream *stream, struct token **line, struct token *token)
1858 {
1859         for (;;) {
1860                 token = token->next;
1861                 if (eof_token(token))
1862                         return 1;
1863                 if (token_type(token) != TOKEN_STRING) {
1864                         sparse_error(token->pos, "expected path string");
1865                         return 1;
1866                 }
1867                 add_path_entry(token, token->string->data, &sys_includepath);
1868         }
1869 }
1870 
1871 static int handle_add_system(struct stream *stream, struct token **line, struct token *token)
1872 {
1873         for (;;) {
1874                 token = token->next;
1875                 if (eof_token(token))
1876                         return 1;
1877                 if (token_type(token) != TOKEN_STRING) {
1878                         sparse_error(token->pos, "expected path string");
1879                         return 1;
1880                 }
1881                 add_path_entry(token, token->string->data, &dirafter_includepath);
1882         }
1883 }
1884 
1885 /* Add to end on includepath list - no pointer updates */
1886 static void add_dirafter_entry(struct token *token, const char *path)
1887 {
1888         const char **dst = includepath;
1889 
1890         /* Need one free entry.. */
1891         if (includepath[INCLUDEPATHS-2])
1892                 error_die(token->pos, "too many include path entries");
1893 
1894         /* Add to the end */
1895         while (*dst)
1896                 dst++;
1897         *dst = path;
1898         dst++;
1899         *dst = NULL;
1900 }
1901 
1902 static int handle_add_dirafter(struct stream *stream, struct token **line, struct token *token)
1903 {
1904         for (;;) {
1905                 token = token->next;
1906                 if (eof_token(token))
1907                         return 1;
1908                 if (token_type(token) != TOKEN_STRING) {
1909                         sparse_error(token->pos, "expected path string");
1910                         return 1;
1911                 }
1912                 add_dirafter_entry(token, token->string->data);
1913         }
1914 }
1915 
1916 static int handle_split_include(struct stream *stream, struct token **line, struct token *token)
1917 {
1918         /*
1919          * -I-
1920          *  From info gcc:
1921          *  Split the include path.  Any directories specified with `-I'
1922          *  options before `-I-' are searched only for headers requested with
1923          *  `#include "FILE"'; they are not searched for `#include <FILE>'.
1924          *  If additional directories are specified with `-I' options after
1925          *  the `-I-', those directories are searched for all `#include'
1926          *  directives.
1927          *  In addition, `-I-' inhibits the use of the directory of the current
1928          *  file directory as the first search directory for `#include "FILE"'.
1929          */
1930         quote_includepath = includepath+1;
1931         angle_includepath = sys_includepath;
1932         return 1;
1933 }
1934 
1935 /*
1936  * We replace "#pragma xxx" with "__pragma__" in the token
1937  * stream. Just as an example.
1938  *
1939  * We'll just #define that away for now, but the theory here
1940  * is that we can use this to insert arbitrary token sequences
1941  * to turn the pragmas into internal front-end sequences for
1942  * when we actually start caring about them.
1943  *
1944  * So eventually this will turn into some kind of extended
1945  * __attribute__() like thing, except called __pragma__(xxx).
1946  */
1947 static int handle_pragma(struct stream *stream, struct token **line, struct token *token)
1948 {
1949         struct token *next = *line;
1950 
1951         if (match_ident(token->next, &once_ident) && eof_token(token->next->next)) {
1952                 stream->once = 1;
1953                 return 1;
1954         }
1955         token->ident = &pragma_ident;
1956         token->pos.newline = 1;
1957         token->pos.whitespace = 1;
1958         token->pos.pos = 1;
1959         *line = token;
1960         token->next = next;
1961         return 0;
1962 }
1963 
1964 /*
1965  * We ignore #line for now.
1966  */
1967 static int handle_line(struct stream *stream, struct token **line, struct token *token)
1968 {
1969         return 1;
1970 }
1971 
1972 /*
1973  * Ignore "#ident".
1974  */
1975 static int handle_ident(struct stream *stream, struct token **line, struct token *token)
1976 {
1977         return 1;
1978 }
1979 
1980 static int handle_nondirective(struct stream *stream, struct token **line, struct token *token)
1981 {
1982         sparse_error(token->pos, "unrecognized preprocessor line '%s'", show_token_sequence(token, 0));
1983         return 1;
1984 }
1985 
1986 
1987 static void init_preprocessor(void)
1988 {
1989         int i;
1990         int stream = init_stream("preprocessor", -1, includepath);
1991         static struct {
1992                 const char *name;
1993                 int (*handler)(struct stream *, struct token **, struct token *);
1994         } normal[] = {
1995                 { "define",             handle_define },
1996                 { "weak_define",        handle_weak_define },
1997                 { "strong_define",      handle_strong_define },
1998                 { "undef",              handle_undef },
1999                 { "strong_undef",       handle_strong_undef },
2000                 { "warning",            handle_warning },
2001                 { "error",              handle_error },
2002                 { "include",            handle_include },
2003                 { "include_next",       handle_include_next },
2004                 { "pragma",             handle_pragma },
2005                 { "line",               handle_line },
2006                 { "ident",              handle_ident },
2007 
2008                 // our internal preprocessor tokens
2009                 { "nostdinc",      handle_nostdinc },
2010                 { "add_include",   handle_add_include },
2011                 { "add_isystem",   handle_add_isystem },
2012                 { "add_system",    handle_add_system },
2013                 { "add_dirafter",  handle_add_dirafter },
2014                 { "split_include", handle_split_include },
2015                 { "argv_include",  handle_argv_include },
2016         }, special[] = {
2017                 { "ifdef",      handle_ifdef },
2018                 { "ifndef",     handle_ifndef },
2019                 { "else",       handle_else },
2020                 { "endif",      handle_endif },
2021                 { "if",         handle_if },
2022                 { "elif",       handle_elif },
2023         };
2024 
2025         for (i = 0; i < ARRAY_SIZE(normal); i++) {
2026                 struct symbol *sym;
2027                 sym = create_symbol(stream, normal[i].name, SYM_PREPROCESSOR, NS_PREPROCESSOR);
2028                 sym->handler = normal[i].handler;
2029                 sym->normal = 1;
2030         }
2031         for (i = 0; i < ARRAY_SIZE(special); i++) {
2032                 struct symbol *sym;
2033                 sym = create_symbol(stream, special[i].name, SYM_PREPROCESSOR, NS_PREPROCESSOR);
2034                 sym->handler = special[i].handler;
2035                 sym->normal = 0;
2036         }
2037 
2038         counter_macro = 0;
2039 }
2040 
2041 static void handle_preprocessor_line(struct stream *stream, struct token **line, struct token *start)
2042 {
2043         int (*handler)(struct stream *, struct token **, struct token *);
2044         struct token *token = start->next;
2045         int is_normal = 1;
2046 
2047         if (eof_token(token))
2048                 return;
2049 
2050         if (token_type(token) == TOKEN_IDENT) {
2051                 struct symbol *sym = lookup_symbol(token->ident, NS_PREPROCESSOR);
2052                 if (sym) {
2053                         handler = sym->handler;
2054                         is_normal = sym->normal;
2055                 } else {
2056                         handler = handle_nondirective;
2057                 }
2058         } else if (token_type(token) == TOKEN_NUMBER) {
2059                 handler = handle_line;
2060         } else {
2061                 handler = handle_nondirective;
2062         }
2063 
2064         if (is_normal) {
2065                 dirty_stream(stream);
2066                 if (false_nesting)
2067                         goto out;
2068         }
2069         if (!handler(stream, line, token))      /* all set */
2070                 return;
2071 
2072 out:
2073         free_preprocessor_line(token);
2074 }
2075 
2076 static void preprocessor_line(struct stream *stream, struct token **line)
2077 {
2078         struct token *start = *line, *next;
2079         struct token **tp = &start->next;
2080 
2081         for (;;) {
2082                 next = *tp;
2083                 if (next->pos.newline)
2084                         break;
2085                 tp = &next->next;
2086         }
2087         *line = next;
2088         *tp = &eof_token_entry;
2089         handle_preprocessor_line(stream, line, start);
2090 }
2091 
2092 static void do_preprocess(struct token **list)
2093 {
2094         struct token *next;
2095 
2096         while (!eof_token(next = scan_next(list))) {
2097                 struct stream *stream = input_streams + next->pos.stream;
2098 
2099                 if (next->pos.newline && match_op(next, '#')) {
2100                         if (!next->pos.noexpand) {
2101                                 preprocessor_line(stream, list);
2102                                 __free_token(next);     /* Free the '#' token */
2103                                 continue;
2104                         }
2105                 }
2106 
2107                 switch (token_type(next)) {
2108                 case TOKEN_STREAMEND:
2109                         if (stream->top_if) {
2110                                 nesting_error(stream);
2111                                 sparse_error(stream->top_if->pos, "unterminated preprocessor conditional");
2112                                 stream->top_if = NULL;
2113                                 false_nesting = 0;
2114                         }
2115                         if (!stream->dirty)
2116                                 stream->constant = CONSTANT_FILE_YES;
2117                         *list = next->next;
2118                         continue;
2119                 case TOKEN_STREAMBEGIN:
2120                         *list = next->next;
2121                         continue;
2122 
2123                 default:
2124                         dirty_stream(stream);
2125                         if (false_nesting) {
2126                                 *list = next->next;
2127                                 __free_token(next);
2128                                 continue;
2129                         }
2130 
2131                         if (token_type(next) != TOKEN_IDENT ||
2132                             expand_one_symbol(list))
2133                                 list = &next->next;
2134                 }
2135         }
2136 }
2137 
2138 void init_include_path(void)
2139 {
2140         FILE *fp;
2141         char path[256];
2142         char arch[32];
2143         char os[32];
2144 
2145         fp = popen("/bin/uname -m", "r");
2146         if (!fp)
2147                 return;
2148         if (!fgets(arch, sizeof(arch) - 1, fp))
2149                 return;
2150         pclose(fp);
2151         if (arch[strlen(arch) - 1] == '\n')
2152                 arch[strlen(arch) - 1] = '\0';
2153 
2154         fp = popen("/bin/uname -o", "r");
2155         if (!fp)
2156                 return;
2157         fgets(os, sizeof(os) - 1, fp);
2158         pclose(fp);
2159 
2160         if (strcmp(os, "GNU/Linux\n") != 0)
2161                 return;
2162         strcpy(os, "linux-gnu");
2163 
2164         snprintf(path, sizeof(path), "/usr/include/%s-%s/", arch, os);
2165         add_pre_buffer("#add_system \"%s/\"\n", path);
2166 }
2167 
2168 struct token * preprocess(struct token *token)
2169 {
2170         preprocessing = 1;
2171         init_preprocessor();
2172         do_preprocess(&token);
2173 
2174         // Drop all expressions from preprocessing, they're not used any more.
2175         // This is not true when we have multiple files, though ;/
2176         // clear_expression_alloc();
2177         preprocessing = 0;
2178 
2179         return token;
2180 }
2181 
2182 static void dump_macro(struct symbol *sym)
2183 {
2184         int nargs = sym->arglist ? sym->arglist->count.normal : 0;
2185         struct token *args[nargs];
2186         struct token *token;
2187 
2188         printf("#define %s", show_ident(sym->ident));
2189         token = sym->arglist;
2190         if (token) {
2191                 const char *sep = "";
2192                 int narg = 0;
2193                 putchar('(');
2194                 for (; !eof_token(token); token = token->next) {
2195                         if (token_type(token) == TOKEN_ARG_COUNT)
2196                                 continue;
2197                         printf("%s%s", sep, show_token(token));
2198                         args[narg++] = token;
2199                         sep = ", ";
2200                 }
2201                 putchar(')');
2202         }
2203         putchar(' ');
2204 
2205         token = sym->expansion;
2206         while (!eof_token(token)) {
2207                 struct token *next = token->next;
2208                 switch (token_type(token)) {
2209                 case TOKEN_UNTAINT:
2210                         break;
2211                 case TOKEN_MACRO_ARGUMENT:
2212                         token = args[token->argnum];
2213                         /* fall-through */
2214                 default:
2215                         printf("%s", show_token(token));
2216                         if (next->pos.whitespace)
2217                                 putchar(' ');
2218                 }
2219                 token = next;
2220         }
2221         putchar('\n');
2222 }
2223 
2224 void dump_macro_definitions(void)
2225 {
2226         struct ident *name;
2227 
2228         FOR_EACH_PTR(macros, name) {
2229                 struct symbol *sym = lookup_macro(name);
2230                 if (sym)
2231                         dump_macro(sym);
2232         } END_FOR_EACH_PTR(name);
2233 }