1 /* Part of CPP library. (Macro handling.)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1998,
3 1999, 2000 Free Software Foundation, Inc.
4 Written by Per Bothner, 1994.
5 Based on CCCP program by Paul Rubin, June 1986
6 Adapted to ANSI C, Richard Stallman, Jan 1987
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 In other words, you are welcome to use, share and improve this program.
23 You are forbidden to forbid anyone else to use, share and improve
24 what you give them. Help stamp out software-hoarding! */
34 /* Structure allocated for every #define. For a simple replacement
38 we allocate an object_defn structure; the expansion field points
39 to the replacement text. For a function-like macro we allocate a
40 funct_defn structure; nargs is the number of arguments - it can be zero,
42 #define getchar() getc (stdin)
44 When there are args, the expansion is the replacement text with the
45 args squashed out, and the reflist is a list describing how to
46 build the output from the input: e.g., "3 chars, then the 1st arg,
47 then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
48 The chars here come from the expansion. Whatever is left of the
49 expansion after the last arg-occurrence is copied after that arg.
50 Note that the reflist can be arbitrarily long---
51 its length depends on the number of times the arguments appear in
52 the replacement text, not how many args there are. Example:
53 #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
55 { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
56 where (x, y) means (nchars, argno).
58 Note that EMPTY and IDENTITY macros have object_defn structures too,
59 but they're just used to hold the file, line, and column. The
60 expansion field will be NULL. */
64 const U_CHAR *expansion;
67 const char *file; /* File, line, column of definition */
74 const struct reflist *next;
75 char stringify; /* nonzero if this arg was preceded by a
77 char raw_before; /* Nonzero if a ## operator before arg. */
78 char raw_after; /* Nonzero if a ## operator after arg. */
79 char rest_args; /* Nonzero if this arg. absorbs the rest */
80 int nchars; /* Number of literal chars to copy before
81 this arg occurrence. */
82 int argno; /* Number of arg to substitute (origin-0) */
88 int length; /* length of expansion string */
89 const U_CHAR *expansion;
90 char rest_args; /* Nonzero if last arg. absorbs the rest */
91 const struct reflist *pattern;
93 /* Names of macro args, concatenated in order with \0 between
94 them. The only use of this is that we warn on redefinition if
95 this differs between the old and new definitions. */
98 const char *file; /* File, line, column of definition */
103 static unsigned int hash_HASHNODE PARAMS ((const void *));
104 static int eq_HASHNODE PARAMS ((const void *, const void *));
105 static void del_HASHNODE PARAMS ((void *));
106 static void dump_funlike_macro PARAMS ((cpp_reader *,
107 const struct funct_defn *));
108 static int dump_hash_helper PARAMS ((void **, void *));
110 static void push_macro_expansion PARAMS ((cpp_reader *, const U_CHAR *,
112 static int unsafe_chars PARAMS ((cpp_reader *, int, int));
113 static int macro_cleanup PARAMS ((cpp_buffer *, cpp_reader *));
114 static enum cpp_ttype macarg PARAMS ((cpp_reader *, int));
115 static void special_symbol PARAMS ((cpp_reader *, HASHNODE *));
116 static int compare_defs PARAMS ((cpp_reader *,
117 const struct funct_defn *,
118 const struct funct_defn *));
120 /* Initial hash table size. (It can grow if necessary - see hashtab.c.) */
123 /* The arglist structure is built by collect_params to tell
124 collect_funlike_expansion where the argument names begin. That is,
125 for a define like "#define f(x,y,z) foo+x-bar*y", the arglist would
126 contain pointers to the strings x, y, and z.
127 collect_funlike_expansion would then build a funct_defn node, with
128 reflist nodes pointing to the places x, y, and z had appeared.
130 The arglist is just convenience data passed between these two
131 routines. It is not kept around after the current #define has been
132 processed and entered into the hash table. */
144 const struct arg *argv;
149 static struct object_defn *
150 collect_objlike_expansion PARAMS ((cpp_reader *, cpp_toklist *));
151 static struct funct_defn *
152 collect_funlike_expansion PARAMS ((cpp_reader *, cpp_toklist *,
153 struct arglist *, unsigned int));
154 static unsigned int collect_params PARAMS ((cpp_reader *, cpp_toklist *,
157 static void warn_trad_stringify PARAMS ((cpp_reader *, U_CHAR *, size_t,
158 unsigned int, const struct arg *));
159 static unsigned int trad_stringify PARAMS ((cpp_reader *, U_CHAR *, size_t,
160 unsigned int, const struct arg *,
162 struct reflist **, unsigned int));
163 static int duplicate_arg_p PARAMS ((U_CHAR *, U_CHAR *));
164 static void add_pat PARAMS ((struct reflist **, struct reflist **,
165 unsigned int, unsigned int, int, int, int, int));
167 /* This structure represents one parsed argument in a macro call.
168 `raw' points to the argument text as written (`raw_length' is its length).
169 `expanded' points to the argument's macro-expansion
170 (its length is `expand_length').
171 `stringified_length' is the length the argument would have
174 /* raw and expanded are relative to ARG_BASE */
175 #define ARG_BASE ((pfile)->token_buffer)
179 /* Strings relative to pfile->token_buffer */
180 long raw, expanded, stringified;
181 int raw_length, expand_length;
182 int stringified_length;
185 static void scan_arguments PARAMS ((cpp_reader *,
186 const struct funct_defn *,
187 struct argdata *, const U_CHAR *));
188 static void stringify PARAMS ((cpp_reader *, struct argdata *));
189 static void funlike_macroexpand PARAMS ((cpp_reader *, HASHNODE *,
192 /* Calculate hash of a string of length LEN. */
194 _cpp_calc_hash (str, len)
202 r = r * 67 + (*str++ - 113);
207 /* Calculate hash of a HASHNODE structure. */
212 const HASHNODE *h = (const HASHNODE *)x;
216 /* Compare two HASHNODE structures. */
222 const HASHNODE *a = (const HASHNODE *)x;
223 const HASHNODE *b = (const HASHNODE *)y;
225 return (a->length == b->length
226 && !strncmp (a->name, b->name, a->length));
229 /* Destroy a HASHNODE. */
234 HASHNODE *h = (HASHNODE *)x;
236 _cpp_free_definition (h);
237 free ((void *) h->name);
241 /* Allocate and initialize a HASHNODE structure.
242 Caller must fill in the value field. */
245 _cpp_make_hashnode (name, len, type, hash)
251 HASHNODE *hp = (HASHNODE *) xmalloc (sizeof (HASHNODE));
252 U_CHAR *p = xmalloc (len + 1);
260 memcpy (p, name, len);
266 /* Find the hash node for name "name", which ends at the first
269 If LEN is >= 0, it is the length of the name.
270 Otherwise, compute the length now. */
273 _cpp_lookup (pfile, name, len)
283 for (bp = name; is_idchar (*bp); bp++);
289 dummy.hash = _cpp_calc_hash (name, len);
291 return (HASHNODE *) htab_find_with_hash (pfile->hashtab,
292 (void *)&dummy, dummy.hash);
295 /* Find the hashtable slot for name "name". Used to insert or delete. */
298 _cpp_lookup_slot (pfile, name, len, insert, hash)
302 enum insert_option insert;
311 for (bp = name; is_idchar (*bp); bp++)
319 dummy.hash = _cpp_calc_hash (name, len);
321 slot = (HASHNODE **) htab_find_slot_with_hash (pfile->hashtab,
329 /* Init the hash table. In here so it can see the hash and eq functions. */
331 _cpp_init_macro_hash (pfile)
334 pfile->hashtab = htab_create (HASHSIZE, hash_HASHNODE,
335 eq_HASHNODE, del_HASHNODE);
338 /* Free the definition of macro H. */
341 _cpp_free_definition (h)
344 if (h->type == T_XCONST)
345 free ((PTR) h->value.cpval);
346 else if (h->type == T_MACRO)
348 if (h->value.odefn->expansion)
349 free ((PTR) h->value.odefn->expansion);
350 free ((PTR) h->value.odefn);
352 else if (h->type == T_FMACRO)
354 const struct funct_defn *d = h->value.fdefn;
355 const struct reflist *ap, *nextap;
357 for (ap = d->pattern; ap != NULL; ap = nextap)
363 free ((PTR) d->argnames);
366 h->value.cpval = NULL;
370 macro_cleanup (pbuf, pfile)
372 cpp_reader *pfile ATTRIBUTE_UNUSED;
374 HASHNODE *m = pbuf->macro;
377 if ((m->type == T_FMACRO && pbuf->buf != m->value.fdefn->expansion)
378 || m->type == T_SPECLINE || m->type == T_FILE
379 || m->type == T_BASE_FILE || m->type == T_INCLUDE_LEVEL
380 || m->type == T_STDC)
381 free ((PTR) pbuf->buf);
385 /* Create pat nodes. */
388 add_pat (pat, endpat, nchars, argno, raw_before, raw_after, strize, rest)
389 struct reflist **pat, **endpat;
392 int raw_before, raw_after, strize, rest;
394 struct reflist *tpat;
395 tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
397 tpat->raw_before = raw_before;
398 tpat->raw_after = raw_after;
399 tpat->stringify = strize;
400 tpat->rest_args = rest;
402 tpat->nchars = nchars;
407 (*endpat)->next = tpat;
411 /* Issue warnings for macro argument names seen inside strings. */
413 warn_trad_stringify (pfile, p, len, argc, argv)
418 const struct arg *argv;
426 while (p < limit && !is_idstart (*p)) p++;
430 for (i = 0; i < argc; i++)
431 if (!strncmp (p, argv[i].name, argv[i].len)
432 && ! is_idchar (p[argv[i].len]))
435 "macro argument \"%s\" would be stringified in traditional C",
440 while (p < limit && is_idchar (*p)) p++;
446 /* Generate pat nodes for macro arguments seen inside strings. */
448 trad_stringify (pfile, base, len, argc, argv, pat, endpat, last)
453 const struct arg *argv;
454 struct reflist **pat, **endpat;
465 while (p < limit && !is_idstart (*p)) p++;
469 for (i = 0; i < argc; i++)
470 if (!strncmp (p, argv[i].name, argv[i].len)
471 && ! is_idchar (p[argv[i].len]))
473 if (CPP_WTRADITIONAL (pfile))
474 cpp_warning (pfile, "macro argument \"%s\" is stringified",
476 /* Write out the string up to this point, and add a pat
477 node for the argument. Note that the argument is NOT
479 CPP_PUTS (pfile, base, p - base);
480 add_pat (pat, endpat, CPP_WRITTEN (pfile) - last, i /* argno */,
481 !is_hspace (p[-1]) /* raw_before */,
482 !is_hspace (p[argv[i].len]) /* raw_after */,
485 last = CPP_WRITTEN (pfile);
486 base = p + argv[i].len;
490 while (p < limit && is_idchar (*p)) p++;
494 CPP_PUTS (pfile, base, p - base);
498 /* Read a replacement list for an object-like macro, and build the
499 object_defn structure. LIST contains the replacement list,
501 static struct object_defn *
502 collect_objlike_expansion (pfile, list)
506 struct object_defn *defn;
509 int last_was_paste = 0;
513 /* We copy the expansion text into the token_buffer, then out to
515 start = CPP_WRITTEN (pfile);
516 CPP_PUTS (pfile, "\r ", 2);
518 for (i = 1; i < list->tokens_used; i++)
520 switch (list->tokens[i].type)
524 cpp_ice (pfile, "EOF in collect_expansion");
530 /* ## is not special if it appears right after another ##;
531 nor is it special if -traditional. */
532 if (last_was_paste || CPP_TRADITIONAL (pfile))
535 cpp_error (pfile, "`##' at start of macro definition");
543 if (i > 1 && !last_was_paste
544 && (list->tokens[i].flags & PREV_WHITESPACE))
545 CPP_PUTC (pfile, ' ');
548 list->tokens[i].val.name.offset + list->namebuf,
549 list->tokens[i].val.name.len);
555 cpp_error (pfile, "`##' at end of macro definition");
557 CPP_PUTS (pfile, "\r ", 2);
558 len = CPP_WRITTEN (pfile) - start;
559 CPP_SET_WRITTEN (pfile, start);
562 cpp_ice (pfile, "empty object-like macro went through full #define");
564 exp = (U_CHAR *) xmalloc (len + 1);
565 memcpy (exp, pfile->token_buffer + start, len);
568 defn = (struct object_defn *) xmalloc (sizeof (struct object_defn));
570 defn->expansion = exp;
575 /* Read a replacement list for a function-like macro, and build the
576 funct_defn structure. LIST contains the replacement list,
577 beginning at REPLACEMENT. ARGLIST specifies the formal parameters
578 to look for in the text of the definition. */
580 static struct funct_defn *
581 collect_funlike_expansion (pfile, list, arglist, replacement)
584 struct arglist *arglist;
585 unsigned int replacement;
587 struct funct_defn *defn;
588 struct reflist *pat = 0, *endpat = 0;
589 enum cpp_ttype token;
590 unsigned int start, last;
594 const struct arg *argv;
596 enum { START = 0, NORM, ARG, STRIZE, PASTE } last_token = START;
598 argv = arglist->argv;
599 argc = arglist->argc;
601 /* We copy the expansion text into the token_buffer, then out to
603 last = start = CPP_WRITTEN (pfile);
604 CPP_PUTS (pfile, "\r ", 2);
606 for (i = replacement; i < list->tokens_used; i++)
608 token = list->tokens[i].type;
609 tok = list->tokens[i].val.name.offset + list->namebuf;
610 len = list->tokens[i].val.name.len;
615 cpp_ice (pfile, "EOF in collect_expansion");
621 /* # is special in function-like macros with no args.
622 (6.10.3.2 para 1.) However, it is not special after
623 PASTE. (Implied by 6.10.3.3 para 4.) Nor is it special
625 if (last_token == PASTE || CPP_TRADITIONAL (pfile))
631 /* ## is not special if it appears right after another ##;
632 nor is it special if -traditional. */
633 if (last_token == PASTE || CPP_TRADITIONAL (pfile))
636 if (last_token == START)
637 cpp_error (pfile, "`##' at start of macro definition");
638 else if (last_token == ARG)
639 /* If the last token was an argument, mark it raw_after. */
640 endpat->raw_after = 1;
641 else if (last_token == STRIZE)
642 /* Oops - that wasn't a stringify operator. */
643 CPP_PUTC (pfile, '#');
651 if (last_token != PASTE && last_token != START
652 && (list->tokens[i].flags & PREV_WHITESPACE))
653 CPP_PUTC (pfile, ' ');
654 if (last_token == ARG && CPP_TRADITIONAL (pfile)
655 && !(list->tokens[i].flags & PREV_WHITESPACE))
656 endpat->raw_after = 1;
664 if (CPP_TRADITIONAL (pfile))
666 last = trad_stringify (pfile, tok, len, argc, argv,
667 &pat, &endpat, last);
672 if (CPP_WTRADITIONAL (pfile))
673 warn_trad_stringify (pfile, tok, len, argc, argv);
678 for (j = 0; j < argc; j++)
679 if (argv[j].len == len
680 && !strncmp (tok, argv[j].name, argv[j].len))
686 if (last_token == STRIZE)
687 cpp_error (pfile, "# is not followed by a macro argument name");
688 CPP_PUTS (pfile, tok, len);
695 int raw_before = (last_token == PASTE
696 || (CPP_TRADITIONAL (pfile)
697 && !(list->tokens[i].flags & PREV_WHITESPACE)));
699 add_pat (&pat, &endpat,
700 CPP_WRITTEN (pfile) - last /* nchars */, j /* argno */,
701 raw_before, 0 /* raw_after */,
702 (last_token == STRIZE), argv[j].rest_arg);
704 last = CPP_WRITTEN (pfile);
710 if (last_token == STRIZE)
711 cpp_error (pfile, "`#' is not followed by a macro argument name");
712 else if (last_token == PASTE)
713 cpp_error (pfile, "`##' at end of macro definition");
715 CPP_PUTS (pfile, "\r ", 2);
716 len = CPP_WRITTEN (pfile) - start;
717 CPP_SET_WRITTEN (pfile, start);
719 exp = (U_CHAR *) xmalloc (len + 1);
720 memcpy (exp, pfile->token_buffer + start, len);
723 defn = (struct funct_defn *) xmalloc (sizeof (struct funct_defn));
725 defn->expansion = exp;
727 defn->rest_args = argc && argv[argc - 1].rest_arg;
729 defn->argnames = arglist->namebuf;
735 /* Is argument NEW, which has just been added to the argument list,
736 a duplicate of a previous argument name? */
738 duplicate_arg_p (args, new)
741 size_t newlen = strlen (new) + 1;
746 oldlen = strlen (args) + 1;
747 if (!memcmp (args, new, MIN (oldlen, newlen)))
755 collect_params (pfile, list, arglist)
758 struct arglist *arglist;
760 struct arg *argv = 0;
761 U_CHAR *namebuf, *p, *tok;
762 unsigned int len, argslen;
763 unsigned int argc, a, i, j;
765 /* The formal parameters list starts at token 1. */
766 if (list->tokens[1].type != CPP_OPEN_PAREN)
768 cpp_ice (pfile, "first token = %d not %d in collect_formal_parameters",
769 list->tokens[1].type, CPP_OPEN_PAREN);
773 /* Scan once and count the number of parameters; also check for
774 syntax errors here. */
777 for (i = 2; i < list->tokens_used; i++)
778 switch (list->tokens[i].type)
781 argslen += list->tokens[i].val.name.len + 1;
786 case CPP_CLOSE_PAREN:
789 cpp_error_with_line (pfile, list->line, list->tokens[i].col,
790 "missing right paren in macro argument list");
794 cpp_error_with_line (pfile, list->line, list->tokens[i].col,
795 "syntax error in #define");
799 if (list->tokens[i-1].type != CPP_NAME)
801 argslen += sizeof "__VA_ARGS__";
805 if (list->tokens[i].type != CPP_CLOSE_PAREN)
807 cpp_error_with_line (pfile, list->line, list->tokens[i].col,
808 "another parameter follows \"...\"");
814 cpp_ice (pfile, "collect_params: unreachable - i=%d, ntokens=%d, type=%d",
815 i, list->tokens_used, list->tokens[i-1].type);
819 if (argc == 0) /* function-like macro, no arguments */
823 arglist->namebuf = 0;
828 cpp_ice (pfile, "collect_params: argc=%d argslen=0", argc);
832 /* Now allocate space and copy the suckers. */
833 argv = (struct arg *) xmalloc (argc * sizeof (struct arg));
834 namebuf = (U_CHAR *) xmalloc (argslen);
837 for (j = 2; j < i; j++)
838 switch (list->tokens[j].type)
841 tok = list->tokens[j].val.name.offset + list->namebuf;
842 len = list->tokens[j].val.name.len;
843 memcpy (p, tok, len);
845 if (duplicate_arg_p (namebuf, p))
847 cpp_error (pfile, "duplicate macro argument name \"%s\"", tok);
851 if (CPP_PEDANTIC (pfile) && CPP_OPTION (pfile, c99)
852 && len == sizeof "__VA_ARGS__" - 1
853 && !strcmp (p, "__VA_ARGS__"))
855 "C99 does not permit use of __VA_ARGS__ as a macro argument name");
858 argv[a].rest_arg = 0;
867 if (list->tokens[j-1].type != CPP_NAME)
869 if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, c99))
870 cpp_pedwarn (pfile, "C89 does not permit varargs macros");
872 argv[a].len = sizeof "__VA_ARGS__" - 1;
874 argv[a].rest_arg = 1;
875 strcpy (p, "__VA_ARGS__");
879 if (CPP_PEDANTIC (pfile))
881 "ISO C does not permit named varargs macros");
882 argv[a-1].rest_arg = 1;
887 cpp_ice (pfile, "collect_params: impossible token type %d",
888 list->tokens[j].type);
891 arglist->argc = argc;
892 arglist->argv = argv;
893 arglist->namebuf = namebuf;
897 /* Create a definition for a macro. The replacement text (including
898 formal parameters if present) is in LIST. If FUNLIKE is true, this
899 is a function-like macro. */
902 _cpp_create_definition (pfile, list, hp)
907 struct funct_defn *fdefn = 0;
908 struct object_defn *odefn = 0;
909 enum node_type ntype;
912 /* Special-case a few simple and common idioms:
913 #define TOKEN // nothing
916 Might also be good to special-case these:
918 #define FUNC() // nothing
919 #define FUNC(a, b, ...) // nothing
920 #define FUNC(a, b, c) FUNC(a, b, c) */
922 if (list->tokens_used == 2)
923 ntype = T_EMPTY; /* Empty definition of object-like macro. */
924 else if (list->tokens_used == 3 && list->tokens[1].type == CPP_NAME
925 && list->tokens[0].val.name.len == list->tokens[1].val.name.len
926 && !strncmp (list->tokens[0].val.name.offset + list->namebuf,
927 list->tokens[1].val.name.offset + list->namebuf,
928 list->tokens[0].val.name.len))
929 ntype = T_IDENTITY; /* Object like macro defined to itself. */
931 /* The macro is function-like only if the next character,
932 with no intervening whitespace, is '('. */
933 else if (list->tokens[1].type == CPP_OPEN_PAREN
934 && ! (list->tokens[1].flags & PREV_WHITESPACE))
939 replacement = collect_params (pfile, list, &args);
940 if (replacement == 0)
942 fdefn = collect_funlike_expansion (pfile, list, &args, replacement);
949 /* Otherwise it is an object-like macro, and C99 requires
950 whitespace after the name (6.10.3 para 3). */
953 if (! (list->tokens[1].flags & PREV_WHITESPACE))
955 "The C standard requires whitespace after #define %s",
958 odefn = collect_objlike_expansion (pfile, list);
965 if (ntype == T_EMPTY || ntype == T_IDENTITY)
967 odefn = xmalloc (sizeof (struct object_defn));
969 odefn->expansion = 0;
972 /* Check for a redefinition, and its legality. Redefining a macro
973 of whatever stripe is ok if the definitions are the same.
974 Redefining a built-in _constant_ (T_CONST or T_XCONST) is ok only
975 with -D. Otherwise a redefinition is not ok. */
979 case T_VOID: ok = 1; break;
980 default: ok = 0; break;
983 ok = (ntype == hp->type
984 && odefn->length == hp->value.odefn->length
985 && !strncmp (odefn->expansion, hp->value.odefn->expansion,
989 ok = (ntype == hp->type
990 && !compare_defs (pfile, fdefn, hp->value.fdefn));
994 ok = (ntype == hp->type);
998 ok = ! pfile->done_initializing;
1002 /* Print the warning or error if it's not ok. */
1005 cpp_pedwarn (pfile, "\"%s\" redefined", hp->name);
1006 if (pfile->done_initializing)
1009 unsigned int line, col;
1010 if (hp->type == T_FMACRO)
1012 file = hp->value.fdefn->file;
1013 line = hp->value.fdefn->line;
1014 col = hp->value.fdefn->col;
1018 file = hp->value.odefn->file;
1019 line = hp->value.odefn->line;
1020 col = hp->value.odefn->col;
1022 cpp_pedwarn_with_file_and_line (pfile, file, line, col,
1023 "this is the location of the previous definition");
1027 /* And replace the old definition (if any). */
1029 _cpp_free_definition (hp);
1032 if (ntype == T_FMACRO)
1034 fdefn->file = CPP_BUFFER (pfile)->nominal_fname;
1035 fdefn->line = list->line;
1036 fdefn->col = list->tokens[0].col;
1037 hp->value.fdefn = fdefn;
1041 odefn->file = CPP_BUFFER (pfile)->nominal_fname;
1042 odefn->line = list->line;
1043 odefn->col = list->tokens[0].col;
1044 hp->value.odefn = odefn;
1050 * Parse a macro argument and append the info on PFILE's token_buffer.
1051 * REST_ARGS means to absorb the rest of the args.
1052 * Return nonzero to indicate a syntax error.
1055 static enum cpp_ttype
1056 macarg (pfile, rest_args)
1061 enum cpp_ttype token;
1063 /* Try to parse as much of the argument as exists at this
1064 input stack level. */
1067 token = cpp_get_token (pfile);
1073 /* If we've hit end of file, it's an error (reported by caller).
1074 Ditto if it's the end of cpp_expand_to_buffer text.
1075 If we've hit end of macro, just continue. */
1076 if (!CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
1079 case CPP_OPEN_PAREN:
1082 case CPP_CLOSE_PAREN:
1087 /* if we've returned to lowest level and
1088 we aren't absorbing all args */
1089 if (paren == 0 && rest_args == 0)
1093 /* Remove ',' or ')' from argument buffer. */
1094 CPP_ADJUST_WRITTEN (pfile, -1);
1102 static const char * const monthnames[] =
1104 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
1105 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
1108 /* Place into PFILE a quoted string representing the string SRC.
1109 Caller must reserve enough space in pfile->token_buffer. */
1112 _cpp_quote_string (pfile, src)
1118 CPP_PUTC_Q (pfile, '\"');
1120 switch ((c = *src++))
1124 CPP_PUTC_Q (pfile, c);
1127 sprintf ((char *)CPP_PWRITTEN (pfile), "\\%03o", c);
1128 CPP_ADJUST_WRITTEN (pfile, 4);
1134 CPP_PUTC_Q (pfile, '\\');
1135 CPP_PUTC_Q (pfile, c);
1139 CPP_PUTC_Q (pfile, '\"');
1145 * expand things like __FILE__. Place the expansion into the output
1146 * buffer *without* rescanning.
1149 #define DSC(str) (const U_CHAR *)str, sizeof str - 1
1151 special_symbol (pfile, hp)
1162 ip = cpp_file_buffer (pfile);
1165 CPP_PUTS (pfile, "\"\"", 2);
1168 if (hp->type == T_BASE_FILE)
1169 while (CPP_PREV_BUFFER (ip) != NULL)
1170 ip = CPP_PREV_BUFFER (ip);
1172 buf = ip->nominal_fname;
1173 CPP_RESERVE (pfile, 3 + 4 * strlen (buf));
1174 _cpp_quote_string (pfile, buf);
1177 case T_INCLUDE_LEVEL:
1179 int true_indepth = 0;
1180 ip = cpp_file_buffer (pfile);
1184 ip = CPP_PREV_BUFFER (ip);
1187 CPP_RESERVE (pfile, 10);
1188 sprintf (CPP_PWRITTEN (pfile), "%d", true_indepth);
1189 CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
1194 #ifdef STDC_0_IN_SYSTEM_HEADERS
1195 ip = cpp_file_buffer (pfile);
1196 if (ip && ip->system_header_p
1197 && !cpp_defined (pfile, DSC("__STRICT_ANSI__")))
1199 CPP_PUTC (pfile, '0');
1204 buf = hp->value.cpval;
1205 if (!buf || *buf == '\0')
1208 CPP_PUTS (pfile, buf, strlen (buf));
1212 ip = cpp_file_buffer (pfile);
1215 CPP_PUTC (pfile, '0');
1218 CPP_RESERVE (pfile, 10);
1219 sprintf (CPP_PWRITTEN (pfile), "%u", CPP_BUF_LINE (ip));
1220 CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
1225 /* Generate both __DATE__ and __TIME__, stuff them into their
1226 respective hash nodes, and mark the nodes T_XCONST so we
1227 don't have to do this again. We don't generate these strings
1228 at init time because time() and localtime() are very slow on
1231 time_t tt = time (NULL);
1232 struct tm *tb = localtime (&tt);
1235 if (hp->type == T_DATE)
1236 d = hp, t = _cpp_lookup (pfile, DSC("__TIME__"));
1238 t = hp, d = _cpp_lookup (pfile, DSC("__DATE__"));
1240 d->value.cpval = xmalloc (sizeof "'Oct 11 1347'");
1241 sprintf ((char *)d->value.cpval, "\"%s %2d %4d\"",
1242 monthnames[tb->tm_mon], tb->tm_mday, tb->tm_year + 1900);
1245 t->value.cpval = xmalloc (sizeof "'12:34:56'");
1246 sprintf ((char *)t->value.cpval, "\"%02d:%02d:%02d\"",
1247 tb->tm_hour, tb->tm_min, tb->tm_sec);
1253 cpp_error (pfile, "attempt to use poisoned `%s'.", hp->name);
1254 CPP_PUTC (pfile, '0');
1258 cpp_ice (pfile, "invalid special hash type");
1264 /* Expand a macro call.
1265 HP points to the symbol that is the macro being called.
1266 Put the result of expansion onto the input stack
1267 so that subsequent input by our caller will use it.
1269 If macro wants arguments, caller has already verified that
1270 an argument list follows; arguments come from the input stack. */
1273 _cpp_macroexpand (pfile, hp)
1277 const struct funct_defn *defn;
1278 struct argdata *args;
1279 unsigned int old_written;
1282 /* Object like macro - most common case. */
1283 if (hp->type == T_MACRO)
1285 push_macro_expansion (pfile, hp->value.odefn->expansion,
1286 hp->value.odefn->length, hp);
1290 /* Or might it be a constant string? */
1291 if (hp->type == T_CONST || hp->type == T_XCONST)
1293 const U_CHAR *cpval = hp->value.cpval;
1294 if (cpval && *cpval != '\0')
1295 push_macro_expansion (pfile, cpval, strlen (cpval), hp);
1299 /* Or a special symbol? */
1300 if (hp->type != T_FMACRO)
1305 old_written = CPP_WRITTEN (pfile);
1306 special_symbol (pfile, hp);
1307 len = CPP_WRITTEN (pfile) - old_written;
1308 CPP_SET_WRITTEN (pfile, old_written);
1312 xbuf = (U_CHAR *) xmalloc (len + 1);
1313 memcpy (xbuf, CPP_PWRITTEN (pfile), len);
1315 push_macro_expansion (pfile, xbuf, len, hp);
1319 /* Okay, it's a full-on function-like macro... */
1320 old_written = CPP_WRITTEN (pfile);
1321 defn = hp->value.fdefn;
1323 args = alloca (MAX (defn->nargs, 1) * sizeof (struct argdata));
1324 for (i = 0; i < MAX (defn->nargs, 1); i++)
1326 args[i].raw = args[i].expanded = 0;
1327 args[i].raw_length = 0;
1328 args[i].expand_length = args[i].stringified_length = -1;
1331 pfile->output_escapes++;
1332 scan_arguments (pfile, defn, args, hp->name);
1334 /* If macro wants zero args, we parsed the arglist for checking only.
1335 Read directly from the macro definition. */
1336 if (defn->nargs == 0 || defn->pattern == 0)
1338 /* If the defn is the empty string, don't bother pushing it. */
1339 if (defn->length > 4)
1340 push_macro_expansion (pfile, defn->expansion, defn->length, hp);
1343 funlike_macroexpand (pfile, hp, args);
1345 CPP_SET_WRITTEN (pfile, old_written);
1346 pfile->output_escapes--;
1350 scan_arguments (pfile, defn, args, name)
1352 const struct funct_defn *defn;
1353 struct argdata *args;
1356 enum cpp_ttype token;
1357 unsigned int start_line, start_column;
1358 unsigned int nargs = defn->nargs;
1361 cpp_buffer *ip = cpp_file_buffer (pfile);
1364 start_line = CPP_BUF_LINE (ip);
1365 start_column = CPP_BUF_COL (ip);
1368 start_line = start_column = 0;
1370 /* Parse all the macro args that are supplied. I counts them. The
1371 first NARGS args are stored in ARGS. The rest are discarded. If
1372 rest_args is set then we assume macarg absorbed the rest of the
1376 /* Skip over the opening parenthesis. */
1377 CPP_OPTION (pfile, discard_comments)++;
1378 pfile->no_macro_expand++;
1379 pfile->no_directives++;
1381 token = cpp_get_non_space_token (pfile);
1382 if (token != CPP_OPEN_PAREN)
1383 cpp_ice (pfile, "macroexpand: unexpected token %d (wanted LPAREN)",
1385 CPP_ADJUST_WRITTEN (pfile, -1);
1390 if (i < MAX (nargs, 1))
1392 args[i].raw = CPP_WRITTEN (pfile);
1393 token = macarg (pfile, (i == nargs - 1 && defn->rest_args));
1394 args[i].raw_length = CPP_WRITTEN (pfile) - args[i].raw;
1397 token = macarg (pfile, 0);
1398 if (token == CPP_EOF || token == CPP_POP)
1399 cpp_error_with_line (pfile, start_line, start_column,
1400 "unterminated macro call");
1403 while (token == CPP_COMMA);
1404 CPP_OPTION (pfile, discard_comments)--;
1405 pfile->no_macro_expand--;
1406 pfile->no_directives--;
1407 if (token != CPP_CLOSE_PAREN)
1410 /* foo ( ) is equivalent to foo () unless foo takes exactly one
1411 argument, in which case the former is allowed and the latter
1412 is not. XXX C99 is silent on this rule, but it seems
1413 inconsistent to me. */
1414 if (i == 1 && nargs == 0)
1416 register U_CHAR *bp = ARG_BASE + args[0].raw;
1417 register U_CHAR *lim = bp + args[0].raw_length;
1418 while (bp != lim && is_space(*bp))
1424 /* Don't output an error message if we have already output one for
1425 a parse error above. */
1426 if (nargs == 0 && i > 0)
1428 cpp_error (pfile, "arguments given to macro `%s'", name);
1432 /* traditional C allows foo() if foo wants one argument. */
1433 if (nargs == 1 && i == 0 && CPP_TRADITIONAL (pfile))
1435 /* the rest args token is allowed to absorb 0 tokens */
1436 else if (i == nargs - 1 && defn->rest_args)
1439 cpp_error (pfile, "macro `%s' used without args", name);
1441 cpp_error (pfile, "macro `%s' used with just one arg", name);
1443 cpp_error (pfile, "macro `%s' used with only %d args", name, i);
1447 cpp_error (pfile, "macro `%s' used with too many (%d) args", name, i);
1452 stringify (pfile, arg)
1454 struct argdata *arg;
1456 int arglen = arg->raw_length;
1461 /* Initially need_space is -1. Otherwise, 1 means the previous
1462 character was a space, but we suppressed it; 0 means the previous
1463 character was a non-space. */
1464 int need_space = -1;
1466 arg->stringified = CPP_WRITTEN (pfile);
1467 CPP_PUTC (pfile, '\"'); /* insert beginning quote */
1468 for (; i < arglen; i++)
1470 c = (ARG_BASE + arg->raw)[i];
1474 /* Delete "\r " and "\r-" escapes. */
1480 /* Internal sequences of whitespace are replaced by one
1481 space except within a string or char token. */
1482 else if (is_space(c))
1484 if (need_space == 0)
1488 else if (need_space > 0)
1489 CPP_PUTC (pfile, ' ');
1504 else if (c == '\"' || c == '\'')
1508 /* Escape these chars */
1509 if (c == '\"' || (in_string && c == '\\'))
1510 CPP_PUTC (pfile, '\\');
1512 CPP_PUTC (pfile, c);
1515 CPP_RESERVE (pfile, 4);
1516 sprintf ((char *) CPP_PWRITTEN (pfile), "\\%03o", (unsigned int) c);
1517 CPP_ADJUST_WRITTEN (pfile, 4);
1520 CPP_PUTC (pfile, '\"'); /* insert ending quote */
1521 arg->stringified_length = CPP_WRITTEN (pfile) - arg->stringified;
1525 funlike_macroexpand (pfile, hp, args)
1528 struct argdata *args;
1530 const struct funct_defn *defn = hp->value.fdefn;
1531 register U_CHAR *xbuf;
1533 const U_CHAR *exp = defn->expansion;
1534 int offset; /* offset in expansion, copied a piece at a time */
1535 int totlen; /* total amount of exp buffer filled so far */
1536 const struct reflist *ap, *last_ap;
1539 /* Compute length in characters of the macro's expansion.
1540 Also count number of times each arg is used. */
1541 xbuf_len = defn->length;
1542 for (ap = defn->pattern; ap != NULL; ap = ap->next)
1546 /* Stringify if it hasn't already been */
1547 if (args[ap->argno].stringified_length < 0)
1548 stringify (pfile, &args[ap->argno]);
1549 xbuf_len += args[ap->argno].stringified_length;
1551 else if (ap->raw_before || ap->raw_after)
1552 /* Add 4 for two \r-space markers to prevent
1553 token concatenation. */
1554 xbuf_len += args[ap->argno].raw_length + 4;
1557 /* We have an ordinary (expanded) occurrence of the arg.
1558 So compute its expansion, if we have not already. */
1559 if (args[ap->argno].expand_length < 0)
1561 args[ap->argno].expanded = CPP_WRITTEN (pfile);
1562 _cpp_expand_to_buffer (pfile, ARG_BASE + args[ap->argno].raw,
1563 args[ap->argno].raw_length);
1565 args[ap->argno].expand_length
1566 = CPP_WRITTEN (pfile) - args[ap->argno].expanded;
1569 /* Add 4 for two \r-space markers to prevent
1570 token concatenation. */
1571 xbuf_len += args[ap->argno].expand_length + 4;
1575 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
1577 /* Generate in XBUF the complete expansion with arguments
1578 substituted in. TOTLEN is the total size generated so far.
1579 OFFSET is the index in the definition of where we are copying
1581 offset = totlen = 0;
1582 for (last_ap = NULL, ap = defn->pattern; ap != NULL;
1583 last_ap = ap, ap = ap->next)
1585 register struct argdata *arg = &args[ap->argno];
1586 int count_before = totlen;
1588 /* Add chars to XBUF. */
1590 memcpy (&xbuf[totlen], &exp[offset], i);
1594 /* If followed by an empty rest arg with concatenation,
1595 delete the last run of nonwhite chars. */
1596 if (arg->raw_length == 0 && totlen > count_before
1597 && ((ap->rest_args && ap->raw_before)
1598 || (last_ap != NULL && last_ap->rest_args
1599 && last_ap->raw_after)))
1601 /* Delete final whitespace. */
1602 while (totlen > count_before && is_space(xbuf[totlen - 1]))
1605 /* Delete the nonwhites before them. */
1606 while (totlen > count_before && !is_space(xbuf[totlen - 1]))
1610 if (ap->stringify != 0)
1612 memcpy (xbuf + totlen, ARG_BASE + arg->stringified,
1613 arg->stringified_length);
1614 totlen += arg->stringified_length;
1616 else if (ap->raw_before || ap->raw_after)
1618 U_CHAR *p1 = ARG_BASE + arg->raw;
1619 U_CHAR *l1 = p1 + arg->raw_length;
1622 /* Arg is concatenated before: delete leading whitespace,
1623 whitespace markers, and no-reexpansion markers. */
1626 if (is_space(p1[0]))
1628 else if (p1[0] == '\r')
1636 /* Arg is concatenated after: delete trailing whitespace,
1637 whitespace markers, and no-reexpansion markers. */
1640 if (is_space(l1[-1]))
1642 else if (l1[-1] == '\r')
1644 else if (l1[-1] == '-')
1646 if (l1 != p1 + 1 && l1[-2] == '\r')
1656 /* Delete any no-reexpansion marker that precedes
1657 an identifier at the beginning of the argument. */
1658 if (p1[0] == '\r' && p1[1] == '-')
1661 memcpy (xbuf + totlen, p1, l1 - p1);
1666 U_CHAR *expanded = ARG_BASE + arg->expanded;
1667 if (!ap->raw_before && totlen > 0 && arg->expand_length
1668 && unsafe_chars (pfile, xbuf[totlen - 1], expanded[0]))
1670 xbuf[totlen++] = '\r';
1671 xbuf[totlen++] = ' ';
1674 memcpy (xbuf + totlen, expanded, arg->expand_length);
1675 totlen += arg->expand_length;
1677 if (!ap->raw_after && totlen > 0 && offset < defn->length
1678 && unsafe_chars (pfile, xbuf[totlen - 1], exp[offset]))
1680 xbuf[totlen++] = '\r';
1681 xbuf[totlen++] = ' ';
1686 /* if there is anything left of the definition
1687 after handling the arg list, copy that in too. */
1689 for (i = offset; i < defn->length; i++)
1690 xbuf[totlen++] = exp[i];
1693 if (totlen > xbuf_len)
1694 /* Just die - we've trashed the heap at this point. */
1697 /* Now put the expansion on the input stack
1698 so our caller will commence reading from it. */
1699 push_macro_expansion (pfile, xbuf, totlen, hp);
1702 /* Return 1 iff a token ending in C1 followed directly by a token C2
1703 could cause mis-tokenization. */
1706 unsafe_chars (pfile, c1, c2)
1710 /* If c2 is EOF, that's always safe. */
1717 /* We don't know what the previous character was. We do know
1718 that it can't have been an idchar (or else it would have been
1719 pasted with the idchars of the macro name), and there are a
1720 number of second characters for which it doesn't matter what
1722 if (is_idchar (c2) || c2 == '\'' || c2 == '\"'
1723 || c2 == '(' || c2 == '[' || c2 == '{'
1724 || c2 == ')' || c2 == ']' || c2 == '}')
1729 if (c2 == c1 || c2 == '=')
1733 case 'e': case 'E': case 'p': case 'P':
1734 if (c2 == '-' || c2 == '+')
1735 return 1; /* could extend a pre-processing number */
1739 if (CPP_OPTION (pfile, dollars_in_ident))
1744 if (c2 == '\'' || c2 == '\"')
1745 return 1; /* Could turn into L"xxx" or L'xxx'. */
1748 case '.': case '0': case '1': case '2': case '3':
1749 case '4': case '5': case '6': case '7': case '8': case '9':
1750 case '_': case 'a': case 'b': case 'c': case 'd': case 'f':
1751 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
1752 case 'm': case 'n': case 'o': case 'q': case 'r': case 's':
1753 case 't': case 'u': case 'v': case 'w': case 'x': case 'y':
1754 case 'z': case 'A': case 'B': case 'C': case 'D': case 'F':
1755 case 'G': case 'H': case 'I': case 'J': case 'K': case 'M':
1756 case 'N': case 'O': case 'Q': case 'R': case 'S': case 'T':
1757 case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z':
1759 /* We're in the middle of either a name or a pre-processing number. */
1760 return (is_idchar(c2) || c2 == '.');
1762 case '<': case '>': case '!': case '%': case '#': case ':':
1763 case '^': case '&': case '|': case '*': case '/': case '=':
1764 return (c2 == c1 || c2 == '=');
1770 push_macro_expansion (pfile, xbuf, len, hp)
1777 int advance_cur = 0;
1779 /* The first chars of the expansion should be a "\r " added by
1780 collect_expansion. This is to prevent accidental token-pasting
1781 between the text preceding the macro invocation, and the macro
1784 We would like to avoid adding unneeded spaces (for the sake of
1785 tools that use cpp, such as imake). In some common cases we can
1786 tell that it is safe to omit the space. */
1788 if (xbuf[0] == '\r' && xbuf[1] == ' '
1789 && !unsafe_chars (pfile, EOF, xbuf[2]))
1792 /* Likewise, avoid the extra space at the end of the macro expansion
1793 if this is safe. We can do a better job here since we can know
1794 what the next char will be. */
1795 if (len >= 3 && xbuf[len-2] == '\r' && xbuf[len-1] == ' '
1796 && !unsafe_chars (pfile, xbuf[len-3], CPP_BUF_PEEK (CPP_BUFFER (pfile))))
1799 /* If the total expansion is "\r \r ", we must not trim both escapes. */
1800 if (len == 2 && advance_cur)
1803 mbuf = cpp_push_buffer (pfile, xbuf, len);
1808 mbuf->cleanup = macro_cleanup;
1810 mbuf->has_escapes = 1;
1812 /* In C89, a macro cannot be expanded recursively. Traditional C
1813 permits it, but any use in an object-like macro must lead to
1814 infinite recursion, so always follow C89 in object-like macros.
1815 Likewise, in a function-like macro it must cause infinite
1816 recursion unless we are actually doing something with the
1819 Even that criterion is too weak. The only example known where
1820 macro recursion isn't infinite is:
1821 #define bar(x,y) foo(x(y, 0))
1823 which expands to foo(bar(baz, 0)) in C89 and
1824 foo(foo(baz(0, 0)) in K+R. This looks pathological to me.
1825 If someone has a real-world example I would love to see it. */
1826 if (hp->type != T_FMACRO
1827 || hp->value.fdefn->nargs == 0
1828 || hp->value.fdefn->pattern == 0
1829 || !CPP_TRADITIONAL (pfile))
1833 /* Return zero if two funct_defns are isomorphic. */
1836 compare_defs (pfile, d1, d2)
1838 const struct funct_defn *d1, *d2;
1840 const struct reflist *a1, *a2;
1842 if (d1->nargs != d2->nargs)
1844 if (strcmp (d1->expansion, d2->expansion))
1846 if (CPP_PEDANTIC (pfile)
1847 && d1->argnames && d2->argnames)
1849 U_CHAR *arg1 = d1->argnames;
1850 U_CHAR *arg2 = d2->argnames;
1855 len = strlen (arg1) + 1;
1856 if (strcmp (arg1, arg2))
1862 for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
1863 a1 = a1->next, a2 = a2->next)
1865 if (a1->nchars != a2->nchars
1866 || a1->argno != a2->argno
1867 || a1->stringify != a2->stringify
1868 || a1->raw_before != a2->raw_before
1869 || a1->raw_after != a2->raw_after)
1878 /* Dump the definition of macro MACRO on stdout. The format is suitable
1879 to be read back in again. */
1882 _cpp_dump_definition (pfile, hp)
1886 CPP_RESERVE (pfile, hp->length + sizeof "#define ");
1887 CPP_PUTS_Q (pfile, "#define ", sizeof "#define " - 1);
1888 CPP_PUTS_Q (pfile, hp->name, hp->length);
1890 if (hp->type == T_EMPTY)
1892 else if (hp->type == T_FMACRO)
1893 dump_funlike_macro (pfile, hp->value.fdefn);
1896 CPP_PUTC_Q (pfile, ' ');
1898 if (hp->type == T_IDENTITY)
1899 CPP_PUTS (pfile, hp->name, hp->length);
1900 else if (hp->type == T_MACRO)
1902 /* The first and last two characters of a macro expansion are
1903 always "\r "; this needs to be trimmed out.
1904 So we need length-4 chars of space, plus one for the NUL. */
1905 CPP_RESERVE (pfile, hp->value.odefn->length - 4 + 1);
1906 CPP_PUTS_Q (pfile, hp->value.odefn->expansion + 2,
1907 hp->value.odefn->length - 4);
1910 cpp_ice (pfile, "invalid hash type %d in dump_definition", hp->type);
1912 if (CPP_BUFFER (pfile) == 0 || ! pfile->done_initializing)
1913 CPP_PUTC (pfile, '\n');
1917 dump_funlike_macro (pfile, defn)
1919 const struct funct_defn *defn;
1921 const struct reflist *r;
1922 const U_CHAR **argv = (const U_CHAR **) alloca (defn->nargs *
1923 sizeof(const U_CHAR *));
1924 int *argl = (int *) alloca (defn->nargs * sizeof(int));
1928 /* First extract the argument list. */
1930 for (i = 0; i < defn->nargs; i++)
1933 argl[i] = strlen (x);
1937 /* Now print out the argument list. */
1938 CPP_PUTC_Q (pfile, '(');
1939 for (i = 0; i < defn->nargs; i++)
1941 CPP_RESERVE (pfile, argl[i] + 2);
1942 if (!(i == defn->nargs-1 && defn->rest_args
1943 && !strcmp (argv[i], "__VA_ARGS__")))
1944 CPP_PUTS_Q (pfile, argv[i], argl[i]);
1945 if (i < defn->nargs-1)
1946 CPP_PUTS_Q (pfile, ", ", 2);
1948 if (defn->rest_args)
1949 CPP_PUTS (pfile, "...", 3);
1950 CPP_PUTS (pfile, ") ", 2);
1952 /* Now the definition. */
1953 x = defn->expansion;
1954 for (r = defn->pattern; r; r = r->next)
1957 if (*x == '\r') x += 2, i -= 2;
1958 /* i chars for macro text, plus the length of the macro
1959 argument name, plus one for a stringify marker, plus two for
1960 each concatenation marker. */
1962 i + argl[r->argno] + r->stringify
1963 + (r->raw_before + r->raw_after) * 2);
1965 if (i > 0) CPP_PUTS_Q (pfile, x, i);
1967 CPP_PUTS_Q (pfile, "##", 2);
1969 CPP_PUTC_Q (pfile, '#');
1970 CPP_PUTS_Q (pfile, argv[r->argno], argl[r->argno]);
1971 if (r->raw_after && !(r->next && r->next->nchars == 0
1972 && r->next->raw_before))
1973 CPP_PUTS_Q (pfile, "##", 2);
1978 i = defn->length - (x - defn->expansion) - 2;
1979 if (*x == '\r') x += 2, i -= 2;
1980 if (i > 0) CPP_PUTS (pfile, x, i);
1983 /* Dump out the hash table. */
1985 dump_hash_helper (h, p)
1989 HASHNODE *hp = (HASHNODE *)*h;
1990 cpp_reader *pfile = (cpp_reader *)p;
1992 if (hp->type == T_MACRO)
1993 _cpp_dump_definition (pfile, hp);
1998 _cpp_dump_macro_hash (pfile)
2001 htab_traverse (pfile->hashtab, dump_hash_helper, pfile);