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 /* This is the second argument to eq_HASHNODE. */
107 unsigned short length;
110 static unsigned int hash_HASHNODE PARAMS ((const void *));
111 static int eq_HASHNODE PARAMS ((const void *, const void *));
112 static void del_HASHNODE PARAMS ((void *));
113 static HASHNODE *make_HASHNODE PARAMS ((const U_CHAR *, size_t,
114 enum node_type, unsigned int));
116 static void dump_funlike_macro PARAMS ((cpp_reader *,
117 const struct funct_defn *));
118 static int dump_hash_helper PARAMS ((void **, void *));
120 static void push_macro_expansion PARAMS ((cpp_reader *, const U_CHAR *,
122 static int unsafe_chars PARAMS ((cpp_reader *, int, int));
123 static enum cpp_ttype macarg PARAMS ((cpp_reader *, int));
124 static void special_symbol PARAMS ((cpp_reader *, HASHNODE *));
125 static int compare_defs PARAMS ((cpp_reader *,
126 const struct funct_defn *,
127 const struct funct_defn *));
129 /* Initial hash table size. (It can grow if necessary - see hashtab.c.) */
132 /* The arglist structure is built by collect_params to tell
133 collect_funlike_expansion where the argument names begin. That is,
134 for a define like "#define f(x,y,z) foo+x-bar*y", the arglist would
135 contain pointers to the strings x, y, and z.
136 collect_funlike_expansion would then build a funct_defn node, with
137 reflist nodes pointing to the places x, y, and z had appeared.
139 The arglist is just convenience data passed between these two
140 routines. It is not kept around after the current #define has been
141 processed and entered into the hash table. */
153 const struct arg *argv;
157 static struct object_defn *
158 collect_objlike_expansion PARAMS ((cpp_reader *, cpp_toklist *));
159 static struct funct_defn *
160 collect_funlike_expansion PARAMS ((cpp_reader *, cpp_toklist *,
161 struct arglist *, unsigned int));
162 static unsigned int collect_params PARAMS ((cpp_reader *, cpp_toklist *,
165 static void warn_trad_stringify PARAMS ((cpp_reader *, U_CHAR *, size_t,
166 unsigned int, const struct arg *));
167 static unsigned int trad_stringify PARAMS ((cpp_reader *, U_CHAR *, size_t,
168 unsigned int, const struct arg *,
170 struct reflist **, unsigned int));
171 static int duplicate_arg_p PARAMS ((U_CHAR *, U_CHAR *));
172 static void add_pat PARAMS ((struct reflist **, struct reflist **,
173 unsigned int, unsigned int, int, int, int, int));
175 /* This structure represents one parsed argument in a macro call.
176 `raw' points to the argument text as written (`raw_length' is its length).
177 `expanded' points to the argument's macro-expansion
178 (its length is `expand_length').
179 `stringified_length' is the length the argument would have
182 /* raw and expanded are relative to ARG_BASE */
183 #define ARG_BASE ((pfile)->token_buffer)
187 /* Strings relative to pfile->token_buffer */
188 long raw, expanded, stringified;
189 int raw_length, expand_length;
190 int stringified_length;
193 static void scan_arguments PARAMS ((cpp_reader *,
194 const struct funct_defn *,
195 struct argdata *, const U_CHAR *));
196 static void stringify PARAMS ((cpp_reader *, struct argdata *));
197 static void funlike_macroexpand PARAMS ((cpp_reader *, HASHNODE *,
200 /* Calculate hash of a string of length LEN. */
202 _cpp_calc_hash (str, len)
210 r = r * 67 + (*str++ - 113);
215 /* Calculate hash of a HASHNODE structure. */
220 const HASHNODE *h = (const HASHNODE *)x;
224 /* Compare a HASHNODE structure (already in the table) with a
225 hashdummy structure (not yet in the table). This relies on the
226 rule that the existing entry is the first argument, the potential
227 entry the second. It also relies on the comparison function never
228 being called except as a direct consequence of a call to
229 htab_find(_slot)_with_hash. */
235 const HASHNODE *a = (const HASHNODE *)x;
236 const struct hashdummy *b = (const struct hashdummy *)y;
238 return (a->length == b->length
239 && !ustrncmp (a->name, b->name, a->length));
242 /* Destroy a HASHNODE. */
247 HASHNODE *h = (HASHNODE *)x;
249 _cpp_free_definition (h);
253 /* Allocate and initialize a HASHNODE structure.
254 Caller must fill in the value field. */
257 make_HASHNODE (name, len, type, hash)
263 HASHNODE *hp = (HASHNODE *) xmalloc (sizeof (HASHNODE) + len);
264 U_CHAR *p = (U_CHAR *)hp + offsetof (HASHNODE, name);
271 memcpy (p, name, len);
277 /* Find the hash node for name "name", of length LEN. */
280 _cpp_lookup (pfile, name, len)
285 struct hashdummy dummy;
286 HASHNODE *new, **slot;
291 hash = _cpp_calc_hash (name, len);
294 htab_find_slot_with_hash (pfile->hashtab, (void *)&dummy, hash, INSERT);
298 new = make_HASHNODE (name, len, T_VOID, hash);
299 new->value.cpval = NULL;
304 /* Init the hash table. In here so it can see the hash and eq functions. */
306 _cpp_init_macro_hash (pfile)
309 pfile->hashtab = htab_create (HASHSIZE, hash_HASHNODE,
310 eq_HASHNODE, del_HASHNODE);
313 /* Free the definition of macro H. */
316 _cpp_free_definition (h)
319 if (h->type == T_XCONST)
320 free ((PTR) h->value.cpval);
321 else if (h->type == T_MACRO)
323 if (h->value.odefn->expansion)
324 free ((PTR) h->value.odefn->expansion);
325 free ((PTR) h->value.odefn);
327 else if (h->type == T_FMACRO)
329 const struct funct_defn *d = h->value.fdefn;
330 const struct reflist *ap, *nextap;
332 for (ap = d->pattern; ap != NULL; ap = nextap)
338 free ((PTR) d->argnames);
341 h->value.cpval = NULL;
344 /* Create pat nodes. */
347 add_pat (pat, endpat, nchars, argno, raw_before, raw_after, strize, rest)
348 struct reflist **pat, **endpat;
351 int raw_before, raw_after, strize, rest;
353 struct reflist *tpat;
354 tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
356 tpat->raw_before = raw_before;
357 tpat->raw_after = raw_after;
358 tpat->stringify = strize;
359 tpat->rest_args = rest;
361 tpat->nchars = nchars;
366 (*endpat)->next = tpat;
370 /* Issue warnings for macro argument names seen inside strings. */
372 warn_trad_stringify (pfile, p, len, argc, argv)
377 const struct arg *argv;
385 while (p < limit && !is_idstart (*p)) p++;
389 for (i = 0; i < argc; i++)
390 if (!ustrncmp (p, argv[i].name, argv[i].len)
391 && ! is_idchar (p[argv[i].len]))
394 "macro argument \"%s\" would be stringified in traditional C",
399 while (p < limit && is_idchar (*p)) p++;
405 /* Generate pat nodes for macro arguments seen inside strings. */
407 trad_stringify (pfile, base, len, argc, argv, pat, endpat, last)
412 const struct arg *argv;
413 struct reflist **pat, **endpat;
424 while (p < limit && !is_idstart (*p)) p++;
428 for (i = 0; i < argc; i++)
429 if (!ustrncmp (p, argv[i].name, argv[i].len)
430 && ! is_idchar (p[argv[i].len]))
432 if (CPP_WTRADITIONAL (pfile))
433 cpp_warning (pfile, "macro argument \"%s\" is stringified",
435 /* Write out the string up to this point, and add a pat
436 node for the argument. Note that the argument is NOT
438 CPP_PUTS (pfile, base, p - base);
439 add_pat (pat, endpat, CPP_WRITTEN (pfile) - last, i /* argno */,
440 !is_hspace (p[-1]) /* raw_before */,
441 !is_hspace (p[argv[i].len]) /* raw_after */,
444 last = CPP_WRITTEN (pfile);
445 base = p + argv[i].len;
450 while (p < limit && is_idchar (*p)) p++;
454 CPP_PUTS (pfile, base, p - base);
458 /* Read a replacement list for an object-like macro, and build the
459 object_defn structure. LIST contains the replacement list,
461 static struct object_defn *
462 collect_objlike_expansion (pfile, list)
466 struct object_defn *defn;
469 int last_was_paste = 0;
473 /* We copy the expansion text into the token_buffer, then out to
475 start = CPP_WRITTEN (pfile);
476 CPP_PUTS (pfile, "\r ", 2);
478 for (i = 1; i < list->tokens_used; i++)
480 switch (TOK_TYPE (list, i))
483 cpp_ice (pfile, "EOF in collect_expansion");
489 /* ## is not special if it appears right after another ##;
490 nor is it special if -traditional. */
491 if (last_was_paste || CPP_TRADITIONAL (pfile))
494 cpp_error (pfile, "`##' at start of macro definition");
502 if (i > 1 && !last_was_paste && TOK_PREV_WHITE (list, i))
503 CPP_PUTC (pfile, ' ');
505 CPP_PUTS (pfile, TOK_NAME (list, i), TOK_LEN (list, i));
511 cpp_error (pfile, "`##' at end of macro definition");
513 CPP_PUTS (pfile, "\r ", 2);
514 len = CPP_WRITTEN (pfile) - start;
515 CPP_SET_WRITTEN (pfile, start);
518 cpp_ice (pfile, "empty object-like macro went through full #define");
520 exp = (U_CHAR *) xmalloc (len + 1);
521 memcpy (exp, pfile->token_buffer + start, len);
524 defn = (struct object_defn *) xmalloc (sizeof (struct object_defn));
526 defn->expansion = exp;
531 /* Read a replacement list for a function-like macro, and build the
532 funct_defn structure. LIST contains the replacement list,
533 beginning at REPLACEMENT. ARGLIST specifies the formal parameters
534 to look for in the text of the definition. */
536 static struct funct_defn *
537 collect_funlike_expansion (pfile, list, arglist, replacement)
540 struct arglist *arglist;
541 unsigned int replacement;
543 struct funct_defn *defn;
544 struct reflist *pat = 0, *endpat = 0;
545 enum cpp_ttype token;
546 unsigned int start, last;
550 const struct arg *argv;
552 enum { START = 0, NORM, ARG, STRIZE, PASTE } last_token = START;
554 argv = arglist->argv;
555 argc = arglist->argc;
557 /* We copy the expansion text into the token_buffer, then out to
559 last = start = CPP_WRITTEN (pfile);
560 CPP_PUTS (pfile, "\r ", 2);
562 for (i = replacement; i < list->tokens_used; i++)
564 token = TOK_TYPE (list, i);
565 tok = TOK_NAME (list, i);
566 len = TOK_LEN (list, i);
570 cpp_ice (pfile, "EOF in collect_expansion");
576 /* # is special in function-like macros with no args.
577 (6.10.3.2 para 1.) However, it is not special after
578 PASTE. (Implied by 6.10.3.3 para 4.) Nor is it special
580 if (last_token == PASTE || CPP_TRADITIONAL (pfile))
586 /* ## is not special if it appears right after another ##;
587 nor is it special if -traditional. */
588 if (last_token == PASTE || CPP_TRADITIONAL (pfile))
591 if (last_token == START)
592 cpp_error (pfile, "`##' at start of macro definition");
593 else if (last_token == ARG)
594 /* If the last token was an argument, mark it raw_after. */
595 endpat->raw_after = 1;
596 else if (last_token == STRIZE)
597 /* Oops - that wasn't a stringify operator. */
598 CPP_PUTC (pfile, '#');
606 if (last_token != PASTE && last_token != START
607 && TOK_PREV_WHITE (list, i))
608 CPP_PUTC (pfile, ' ');
609 if (last_token == ARG && CPP_TRADITIONAL (pfile)
610 && !TOK_PREV_WHITE (list, i))
611 endpat->raw_after = 1;
619 if (CPP_TRADITIONAL (pfile))
621 last = trad_stringify (pfile, tok, len, argc, argv,
622 &pat, &endpat, last);
627 if (CPP_WTRADITIONAL (pfile))
628 warn_trad_stringify (pfile, tok, len, argc, argv);
633 for (j = 0; j < argc; j++)
634 if (argv[j].len == len
635 && !ustrncmp (tok, argv[j].name, argv[j].len))
641 if (last_token == STRIZE)
643 /* This is a mandatory diagnostic (6.10.3.2 para 1), but
644 in assembly language # may have some other
645 significance we don't know about, so suppress the
647 if (! CPP_OPTION (pfile, lang_asm))
649 "# is not followed by a macro argument name");
650 if (TOK_PREV_WHITE (list, i))
651 CPP_ADJUST_WRITTEN (pfile, -1);
652 if (TOK_PREV_WHITE (list, i-1))
653 CPP_PUTC (pfile, ' ');
654 CPP_PUTC (pfile, '#');
655 if (TOK_PREV_WHITE (list, i))
656 CPP_PUTC (pfile, ' ');
658 CPP_PUTS (pfile, tok, len);
665 int raw_before = (last_token == PASTE
666 || (CPP_TRADITIONAL (pfile)
667 && ! TOK_PREV_WHITE (list, j)));
669 add_pat (&pat, &endpat,
670 CPP_WRITTEN (pfile) - last /* nchars */, j /* argno */,
671 raw_before, 0 /* raw_after */,
672 (last_token == STRIZE), argv[j].rest_arg);
674 last = CPP_WRITTEN (pfile);
680 if (last_token == STRIZE)
681 cpp_error (pfile, "`#' is not followed by a macro argument name");
682 else if (last_token == PASTE)
683 cpp_error (pfile, "`##' at end of macro definition");
685 CPP_PUTS (pfile, "\r ", 2);
686 len = CPP_WRITTEN (pfile) - start;
687 CPP_SET_WRITTEN (pfile, start);
689 exp = (U_CHAR *) xmalloc (len + 1);
690 memcpy (exp, pfile->token_buffer + start, len);
693 defn = (struct funct_defn *) xmalloc (sizeof (struct funct_defn));
695 defn->expansion = exp;
697 defn->rest_args = argc && argv[argc - 1].rest_arg;
699 defn->argnames = arglist->namebuf;
705 /* Is argument NEW, which has just been added to the argument list,
706 a duplicate of a previous argument name? */
708 duplicate_arg_p (args, new)
711 size_t newlen = ustrlen (new) + 1;
716 oldlen = ustrlen (args) + 1;
717 if (!memcmp (args, new, MIN (oldlen, newlen)))
725 collect_params (pfile, list, arglist)
728 struct arglist *arglist;
730 struct arg *argv = 0;
731 U_CHAR *namebuf, *p, *tok;
732 unsigned int len, argslen;
733 unsigned int argc, a, i, j;
735 /* The formal parameters list starts at token 1. */
736 if (TOK_TYPE (list, 1) != CPP_OPEN_PAREN)
738 cpp_ice (pfile, "first token = %d not %d in collect_formal_parameters",
739 TOK_TYPE (list, 1), CPP_OPEN_PAREN);
743 /* Scan once and count the number of parameters; also check for
744 syntax errors here. */
747 for (i = 2; i < list->tokens_used; i++)
748 switch (TOK_TYPE (list, i))
751 argslen += TOK_LEN (list, i) + 1;
756 case CPP_CLOSE_PAREN:
759 cpp_error_with_line (pfile, list->line, TOK_COL (list, i),
760 "missing right paren in macro argument list");
764 cpp_error_with_line (pfile, list->line, TOK_COL (list, i),
765 "illegal token in macro argument list");
769 if (TOK_TYPE (list, i-1) != CPP_NAME)
771 argslen += sizeof "__VA_ARGS__";
775 if (TOK_TYPE (list, i) != CPP_CLOSE_PAREN)
777 cpp_error_with_line (pfile, list->line, TOK_COL (list, i),
778 "another parameter follows \"...\"");
784 cpp_ice (pfile, "collect_params: unreachable - i=%d, ntokens=%d, type=%d",
785 i, list->tokens_used, TOK_TYPE (list, i-1));
789 if (argc == 0) /* function-like macro, no arguments */
793 arglist->namebuf = 0;
798 cpp_ice (pfile, "collect_params: argc=%d argslen=0", argc);
802 /* Now allocate space and copy the suckers. */
803 argv = (struct arg *) xmalloc (argc * sizeof (struct arg));
804 namebuf = (U_CHAR *) xmalloc (argslen);
807 for (j = 2; j < i; j++)
808 switch (TOK_TYPE (list, j))
811 tok = TOK_NAME (list, j);
812 len = TOK_LEN (list, j);
813 memcpy (p, tok, len);
815 if (duplicate_arg_p (namebuf, p))
817 cpp_error (pfile, "duplicate macro argument name \"%s\"", tok);
821 if (CPP_PEDANTIC (pfile) && CPP_OPTION (pfile, c99)
822 && len == sizeof "__VA_ARGS__" - 1
823 && !ustrcmp (p, U"__VA_ARGS__"))
825 "C99 does not permit use of __VA_ARGS__ as a macro argument name");
828 argv[a].rest_arg = 0;
837 if (TOK_TYPE (list, j-1) != CPP_NAME)
839 if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, c99))
840 cpp_pedwarn (pfile, "C89 does not permit varargs macros");
842 argv[a].len = sizeof "__VA_ARGS__" - 1;
844 argv[a].rest_arg = 1;
845 strcpy ((char *)p, "__VA_ARGS__");
849 if (CPP_PEDANTIC (pfile))
851 "ISO C does not permit named varargs macros");
852 argv[a-1].rest_arg = 1;
857 cpp_ice (pfile, "collect_params: impossible token type %d",
861 arglist->argc = argc;
862 arglist->argv = argv;
863 arglist->namebuf = namebuf;
867 /* Create a definition for a macro. The replacement text (including
868 formal parameters if present) is in LIST. If FUNLIKE is true, this
869 is a function-like macro. */
872 _cpp_create_definition (pfile, list, hp)
877 struct funct_defn *fdefn = 0;
878 struct object_defn *odefn = 0;
879 enum node_type ntype;
882 /* Special-case a few simple and common idioms:
883 #define TOKEN // nothing
886 Might also be good to special-case these:
888 #define FUNC() // nothing
889 #define FUNC(a, b, ...) // nothing
890 #define FUNC(a, b, c) FUNC(a, b, c) */
892 if (list->tokens_used == 2)
893 ntype = T_EMPTY; /* Empty definition of object-like macro. */
894 else if (list->tokens_used == 3 && TOK_TYPE (list, 1) == CPP_NAME
895 && TOK_LEN (list, 0) == TOK_LEN (list, 1)
896 && !ustrncmp (TOK_NAME (list, 0), TOK_NAME (list, 1),
898 ntype = T_IDENTITY; /* Object like macro defined to itself. */
900 /* The macro is function-like only if the next character,
901 with no intervening whitespace, is '('. */
902 else if (TOK_TYPE (list, 1) == CPP_OPEN_PAREN
903 && ! TOK_PREV_WHITE (list, 1))
908 replacement = collect_params (pfile, list, &args);
909 if (replacement == 0)
911 fdefn = collect_funlike_expansion (pfile, list, &args, replacement);
918 /* Otherwise it is an object-like macro, and C99 requires
919 whitespace after the name (6.10.3 para 3). */
922 if (! TOK_PREV_WHITE (list, 1))
924 "The C standard requires whitespace after #define %s",
927 odefn = collect_objlike_expansion (pfile, list);
934 if (ntype == T_EMPTY || ntype == T_IDENTITY)
936 odefn = xmalloc (sizeof (struct object_defn));
938 odefn->expansion = 0;
941 /* Check for a redefinition, and its legality. Redefining a macro
942 of whatever stripe is ok if the definitions are the same.
943 Redefining a built-in _constant_ (T_CONST or T_XCONST) is ok only
944 with -D. Otherwise a redefinition is not ok. */
948 case T_VOID: ok = 1; break;
949 default: ok = 0; break;
952 ok = (ntype == hp->type
953 && odefn->length == hp->value.odefn->length
954 && !ustrncmp (odefn->expansion, hp->value.odefn->expansion,
958 ok = (ntype == hp->type
959 && !compare_defs (pfile, fdefn, hp->value.fdefn));
963 ok = (ntype == hp->type);
967 ok = ! pfile->done_initializing;
971 /* Print the warning or error if it's not ok. */
974 cpp_pedwarn (pfile, "\"%s\" redefined", hp->name);
975 if (pfile->done_initializing)
978 unsigned int line, col;
979 if (hp->type == T_FMACRO)
981 file = hp->value.fdefn->file;
982 line = hp->value.fdefn->line;
983 col = hp->value.fdefn->col;
987 file = hp->value.odefn->file;
988 line = hp->value.odefn->line;
989 col = hp->value.odefn->col;
991 cpp_pedwarn_with_file_and_line (pfile, file, line, col,
992 "this is the location of the previous definition");
996 /* And replace the old definition (if any). */
998 _cpp_free_definition (hp);
1001 if (ntype == T_FMACRO)
1003 fdefn->file = CPP_BUFFER (pfile)->nominal_fname;
1004 fdefn->line = list->line;
1005 fdefn->col = TOK_COL (list, 0);
1006 hp->value.fdefn = fdefn;
1010 odefn->file = CPP_BUFFER (pfile)->nominal_fname;
1011 odefn->line = list->line;
1012 odefn->col = TOK_COL (list, 0);
1013 hp->value.odefn = odefn;
1019 * Parse a macro argument and append the info on PFILE's token_buffer.
1020 * REST_ARGS means to absorb the rest of the args.
1021 * Return nonzero to indicate a syntax error.
1024 static enum cpp_ttype
1025 macarg (pfile, rest_args)
1030 enum cpp_ttype token;
1032 /* Try to parse as much of the argument as exists at this
1033 input stack level. */
1036 token = cpp_get_token (pfile);
1040 /* We've hit end of file; this is an error.
1041 Caller will report it. */
1043 case CPP_OPEN_PAREN:
1046 case CPP_CLOSE_PAREN:
1051 /* if we've returned to lowest level and
1052 we aren't absorbing all args */
1053 if (paren == 0 && rest_args == 0)
1057 /* Remove ',' or ')' from argument buffer. */
1058 CPP_ADJUST_WRITTEN (pfile, -1);
1066 static const char * const monthnames[] =
1068 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
1069 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
1072 /* Place into PFILE a quoted string representing the string SRC.
1073 Caller must reserve enough space in pfile->token_buffer. */
1076 _cpp_quote_string (pfile, src)
1082 CPP_PUTC_Q (pfile, '\"');
1084 switch ((c = *src++))
1088 CPP_PUTC_Q (pfile, c);
1091 sprintf ((char *)CPP_PWRITTEN (pfile), "\\%03o", c);
1092 CPP_ADJUST_WRITTEN (pfile, 4);
1098 CPP_PUTC_Q (pfile, '\\');
1099 CPP_PUTC_Q (pfile, c);
1103 CPP_PUTC_Q (pfile, '\"');
1109 * expand things like __FILE__. Place the expansion into the output
1110 * buffer *without* rescanning.
1113 #define DSC(str) (const U_CHAR *)str, sizeof str - 1
1115 special_symbol (pfile, hp)
1127 ip = cpp_file_buffer (pfile);
1130 CPP_PUTS (pfile, "\"\"", 2);
1133 if (hp->type == T_BASE_FILE)
1134 while (CPP_PREV_BUFFER (ip) != NULL)
1135 ip = CPP_PREV_BUFFER (ip);
1137 buf = (const U_CHAR *) ip->nominal_fname;
1138 len = ustrlen (buf);
1139 CPP_RESERVE (pfile, 3 + 4 * len);
1140 _cpp_quote_string (pfile, buf);
1143 case T_INCLUDE_LEVEL:
1145 int true_indepth = 0;
1146 ip = cpp_file_buffer (pfile);
1150 ip = CPP_PREV_BUFFER (ip);
1153 CPP_RESERVE (pfile, 10);
1154 sprintf ((char *)CPP_PWRITTEN (pfile), "%d", true_indepth);
1155 len = ustrlen (CPP_PWRITTEN (pfile));
1156 CPP_ADJUST_WRITTEN (pfile, len);
1161 #ifdef STDC_0_IN_SYSTEM_HEADERS
1162 ip = cpp_file_buffer (pfile);
1163 if (ip && ip->system_header_p
1164 && !cpp_defined (pfile, DSC("__STRICT_ANSI__")))
1166 CPP_PUTC (pfile, '0');
1171 buf = hp->value.cpval;
1172 if (!buf || *buf == '\0')
1175 len = ustrlen (buf);
1176 CPP_PUTS (pfile, buf, len);
1180 ip = cpp_file_buffer (pfile);
1183 CPP_PUTC (pfile, '0');
1186 CPP_RESERVE (pfile, 10);
1187 sprintf ((char *)CPP_PWRITTEN (pfile), "%u", CPP_BUF_LINE (ip));
1188 len = ustrlen (CPP_PWRITTEN (pfile));
1189 CPP_ADJUST_WRITTEN (pfile, len);
1194 /* Generate both __DATE__ and __TIME__, stuff them into their
1195 respective hash nodes, and mark the nodes T_XCONST so we
1196 don't have to do this again. We don't generate these strings
1197 at init time because time() and localtime() are very slow on
1200 time_t tt = time (NULL);
1201 struct tm *tb = localtime (&tt);
1204 if (hp->type == T_DATE)
1205 d = hp, t = _cpp_lookup (pfile, DSC("__TIME__"));
1207 t = hp, d = _cpp_lookup (pfile, DSC("__DATE__"));
1209 d->value.cpval = xmalloc (sizeof "'Oct 11 1347'");
1210 sprintf ((char *)d->value.cpval, "\"%s %2d %4d\"",
1211 monthnames[tb->tm_mon], tb->tm_mday, tb->tm_year + 1900);
1214 t->value.cpval = xmalloc (sizeof "'12:34:56'");
1215 sprintf ((char *)t->value.cpval, "\"%02d:%02d:%02d\"",
1216 tb->tm_hour, tb->tm_min, tb->tm_sec);
1222 cpp_error (pfile, "attempt to use poisoned `%s'.", hp->name);
1223 CPP_PUTC (pfile, '0');
1227 cpp_ice (pfile, "invalid special hash type");
1233 /* Expand a macro call.
1234 HP points to the symbol that is the macro being called.
1235 Put the result of expansion onto the input stack
1236 so that subsequent input by our caller will use it.
1238 If macro wants arguments, caller has already verified that
1239 an argument list follows; arguments come from the input stack. */
1242 _cpp_macroexpand (pfile, hp)
1246 const struct funct_defn *defn;
1247 struct argdata *args;
1248 unsigned int old_written;
1251 /* Object like macro - most common case. */
1252 if (hp->type == T_MACRO)
1254 push_macro_expansion (pfile, hp->value.odefn->expansion,
1255 hp->value.odefn->length, hp);
1259 /* Or might it be a constant string? */
1260 if (hp->type == T_CONST || hp->type == T_XCONST)
1262 const U_CHAR *cpval = hp->value.cpval;
1263 if (cpval && *cpval != '\0')
1264 push_macro_expansion (pfile, cpval, ustrlen (cpval), hp);
1268 /* Or a special symbol? */
1269 if (hp->type != T_FMACRO)
1274 old_written = CPP_WRITTEN (pfile);
1275 special_symbol (pfile, hp);
1276 len = CPP_WRITTEN (pfile) - old_written;
1277 CPP_SET_WRITTEN (pfile, old_written);
1281 xbuf = (U_CHAR *) xmalloc (len + 1);
1282 memcpy (xbuf, CPP_PWRITTEN (pfile), len);
1284 push_macro_expansion (pfile, xbuf, len, hp);
1288 /* Okay, it's a full-on function-like macro... */
1289 old_written = CPP_WRITTEN (pfile);
1290 defn = hp->value.fdefn;
1292 args = alloca (MAX (defn->nargs, 1) * sizeof (struct argdata));
1293 for (i = 0; i < MAX (defn->nargs, 1); i++)
1295 args[i].raw = args[i].expanded = 0;
1296 args[i].raw_length = 0;
1297 args[i].expand_length = args[i].stringified_length = -1;
1300 pfile->output_escapes++;
1301 scan_arguments (pfile, defn, args, hp->name);
1303 /* If macro wants zero args, we parsed the arglist for checking only.
1304 Read directly from the macro definition. */
1305 if (defn->nargs == 0 || defn->pattern == 0)
1307 /* If the defn is the empty string, don't bother pushing it. */
1308 if (defn->length > 4)
1309 push_macro_expansion (pfile, defn->expansion, defn->length, hp);
1312 funlike_macroexpand (pfile, hp, args);
1314 CPP_SET_WRITTEN (pfile, old_written);
1315 pfile->output_escapes--;
1319 scan_arguments (pfile, defn, args, name)
1321 const struct funct_defn *defn;
1322 struct argdata *args;
1325 enum cpp_ttype token;
1326 unsigned int start_line, start_column;
1327 unsigned int nargs = defn->nargs;
1330 cpp_buffer *ip = cpp_file_buffer (pfile);
1333 start_line = CPP_BUF_LINE (ip);
1334 start_column = CPP_BUF_COL (ip);
1337 start_line = start_column = 0;
1339 /* Parse all the macro args that are supplied. I counts them. The
1340 first NARGS args are stored in ARGS. The rest are discarded. If
1341 rest_args is set then we assume macarg absorbed the rest of the
1345 /* Skip over the opening parenthesis. */
1346 CPP_OPTION (pfile, discard_comments)++;
1347 pfile->no_macro_expand++;
1348 pfile->no_directives++;
1350 token = cpp_get_non_space_token (pfile);
1351 if (token != CPP_OPEN_PAREN)
1352 cpp_ice (pfile, "macroexpand: unexpected token %d (wanted LPAREN)",
1354 CPP_ADJUST_WRITTEN (pfile, -1);
1359 if (i < MAX (nargs, 1))
1361 args[i].raw = CPP_WRITTEN (pfile);
1362 token = macarg (pfile, (i == nargs - 1 && defn->rest_args));
1363 args[i].raw_length = CPP_WRITTEN (pfile) - args[i].raw;
1366 token = macarg (pfile, 0);
1367 if (token == CPP_EOF)
1368 cpp_error_with_line (pfile, start_line, start_column,
1369 "unterminated macro call");
1372 while (token == CPP_COMMA);
1373 CPP_OPTION (pfile, discard_comments)--;
1374 pfile->no_macro_expand--;
1375 pfile->no_directives--;
1376 if (token != CPP_CLOSE_PAREN)
1379 /* foo ( ) is equivalent to foo () unless foo takes exactly one
1380 argument, in which case the former is allowed and the latter
1381 is not. XXX C99 is silent on this rule, but it seems
1382 inconsistent to me. */
1383 if (i == 1 && nargs == 0)
1385 register U_CHAR *bp = ARG_BASE + args[0].raw;
1386 register U_CHAR *lim = bp + args[0].raw_length;
1387 while (bp != lim && is_space(*bp))
1393 /* Don't output an error message if we have already output one for
1394 a parse error above. */
1395 if (nargs == 0 && i > 0)
1397 cpp_error (pfile, "arguments given to macro `%s'", name);
1401 /* traditional C allows foo() if foo wants one argument. */
1402 if (nargs == 1 && i == 0 && CPP_TRADITIONAL (pfile))
1404 /* the rest args token is allowed to absorb 0 tokens */
1405 else if (i == nargs - 1 && defn->rest_args)
1408 cpp_error (pfile, "macro `%s' used without args", name);
1410 cpp_error (pfile, "macro `%s' used with just one arg", name);
1412 cpp_error (pfile, "macro `%s' used with only %d args", name, i);
1416 cpp_error (pfile, "macro `%s' used with too many (%d) args", name, i);
1421 stringify (pfile, arg)
1423 struct argdata *arg;
1425 int arglen = arg->raw_length;
1430 /* Initially need_space is -1. Otherwise, 1 means the previous
1431 character was a space, but we suppressed it; 0 means the previous
1432 character was a non-space. */
1433 int need_space = -1;
1435 arg->stringified = CPP_WRITTEN (pfile);
1436 CPP_PUTC (pfile, '\"'); /* insert beginning quote */
1437 for (; i < arglen; i++)
1439 c = (ARG_BASE + arg->raw)[i];
1443 /* Delete "\r " and "\r-" escapes. */
1449 /* Internal sequences of whitespace are replaced by one
1450 space except within a string or char token. */
1451 else if (is_space(c))
1453 if (need_space == 0)
1457 else if (need_space > 0)
1458 CPP_PUTC (pfile, ' ');
1473 else if (c == '\"' || c == '\'')
1477 /* Escape these chars */
1478 if (c == '\"' || (in_string && c == '\\'))
1479 CPP_PUTC (pfile, '\\');
1481 CPP_PUTC (pfile, c);
1484 CPP_RESERVE (pfile, 4);
1485 sprintf ((char *) CPP_PWRITTEN (pfile), "\\%03o", (unsigned int) c);
1486 CPP_ADJUST_WRITTEN (pfile, 4);
1489 CPP_PUTC (pfile, '\"'); /* insert ending quote */
1490 arg->stringified_length = CPP_WRITTEN (pfile) - arg->stringified;
1494 funlike_macroexpand (pfile, hp, args)
1497 struct argdata *args;
1499 const struct funct_defn *defn = hp->value.fdefn;
1500 register U_CHAR *xbuf;
1502 const U_CHAR *exp = defn->expansion;
1503 int offset; /* offset in expansion, copied a piece at a time */
1504 int totlen; /* total amount of exp buffer filled so far */
1505 const struct reflist *ap, *last_ap;
1508 /* Compute length in characters of the macro's expansion.
1509 Also count number of times each arg is used. */
1510 xbuf_len = defn->length;
1511 for (ap = defn->pattern; ap != NULL; ap = ap->next)
1515 /* Stringify if it hasn't already been */
1516 if (args[ap->argno].stringified_length < 0)
1517 stringify (pfile, &args[ap->argno]);
1518 xbuf_len += args[ap->argno].stringified_length;
1520 else if (ap->raw_before || ap->raw_after)
1521 /* Add 4 for two \r-space markers to prevent
1522 token concatenation. */
1523 xbuf_len += args[ap->argno].raw_length + 4;
1526 /* We have an ordinary (expanded) occurrence of the arg.
1527 So compute its expansion, if we have not already. */
1528 if (args[ap->argno].expand_length < 0)
1530 args[ap->argno].expanded = CPP_WRITTEN (pfile);
1531 _cpp_expand_to_buffer (pfile, ARG_BASE + args[ap->argno].raw,
1532 args[ap->argno].raw_length);
1534 args[ap->argno].expand_length
1535 = CPP_WRITTEN (pfile) - args[ap->argno].expanded;
1538 /* Add 4 for two \r-space markers to prevent
1539 token concatenation. */
1540 xbuf_len += args[ap->argno].expand_length + 4;
1544 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
1546 /* Generate in XBUF the complete expansion with arguments
1547 substituted in. TOTLEN is the total size generated so far.
1548 OFFSET is the index in the definition of where we are copying
1550 offset = totlen = 0;
1551 for (last_ap = NULL, ap = defn->pattern; ap != NULL;
1552 last_ap = ap, ap = ap->next)
1554 register struct argdata *arg = &args[ap->argno];
1555 int count_before = totlen;
1557 /* Add chars to XBUF. */
1559 memcpy (&xbuf[totlen], &exp[offset], i);
1563 /* If followed by an empty rest arg with concatenation,
1564 delete the last run of nonwhite chars. */
1565 if (arg->raw_length == 0 && totlen > count_before
1566 && ((ap->rest_args && ap->raw_before)
1567 || (last_ap != NULL && last_ap->rest_args
1568 && last_ap->raw_after)))
1570 /* Delete final whitespace. */
1571 while (totlen > count_before && is_space(xbuf[totlen - 1]))
1574 /* Delete the nonwhites before them. */
1575 while (totlen > count_before && !is_space(xbuf[totlen - 1]))
1579 if (ap->stringify != 0)
1581 memcpy (xbuf + totlen, ARG_BASE + arg->stringified,
1582 arg->stringified_length);
1583 totlen += arg->stringified_length;
1585 else if (ap->raw_before || ap->raw_after)
1587 U_CHAR *p1 = ARG_BASE + arg->raw;
1588 U_CHAR *l1 = p1 + arg->raw_length;
1591 /* Arg is concatenated before: delete leading whitespace,
1592 whitespace markers, and no-reexpansion markers. */
1595 if (is_space(p1[0]))
1597 else if (p1[0] == '\r')
1605 /* Arg is concatenated after: delete trailing whitespace,
1606 whitespace markers, and no-reexpansion markers. */
1609 if (is_space(l1[-1]))
1611 else if (l1[-1] == '\r')
1613 else if (l1[-1] == '-')
1615 if (l1 != p1 + 1 && l1[-2] == '\r')
1625 /* Delete any no-reexpansion marker that precedes
1626 an identifier at the beginning of the argument. */
1627 if (p1[0] == '\r' && p1[1] == '-')
1630 memcpy (xbuf + totlen, p1, l1 - p1);
1635 U_CHAR *expanded = ARG_BASE + arg->expanded;
1636 if (!ap->raw_before && totlen > 0 && arg->expand_length
1637 && unsafe_chars (pfile, xbuf[totlen - 1], expanded[0]))
1639 xbuf[totlen++] = '\r';
1640 xbuf[totlen++] = ' ';
1643 memcpy (xbuf + totlen, expanded, arg->expand_length);
1644 totlen += arg->expand_length;
1646 if (!ap->raw_after && totlen > 0 && offset < defn->length
1647 && unsafe_chars (pfile, xbuf[totlen - 1], exp[offset]))
1649 xbuf[totlen++] = '\r';
1650 xbuf[totlen++] = ' ';
1655 /* if there is anything left of the definition
1656 after handling the arg list, copy that in too. */
1658 for (i = offset; i < defn->length; i++)
1659 xbuf[totlen++] = exp[i];
1662 if (totlen > xbuf_len)
1663 /* Just die - we've trashed the heap at this point. */
1666 /* Now put the expansion on the input stack
1667 so our caller will commence reading from it. */
1668 push_macro_expansion (pfile, xbuf, totlen, hp);
1670 /* Overload buffer->mapped to indicate that xbuf needs to be freed. */
1671 CPP_BUFFER (pfile)->mapped = 1;
1674 /* Return 1 iff a token ending in C1 followed directly by a token C2
1675 could cause mis-tokenization. */
1678 unsafe_chars (pfile, c1, c2)
1682 /* If c2 is EOF, that's always safe. */
1689 /* We don't know what the previous character was. We do know
1690 that it can't have been an idchar (or else it would have been
1691 pasted with the idchars of the macro name), and there are a
1692 number of second characters for which it doesn't matter what
1694 if (is_idchar (c2) || c2 == '\'' || c2 == '\"'
1695 || c2 == '(' || c2 == '[' || c2 == '{'
1696 || c2 == ')' || c2 == ']' || c2 == '}')
1701 if (c2 == c1 || c2 == '=')
1705 case 'e': case 'E': case 'p': case 'P':
1706 if (c2 == '-' || c2 == '+')
1707 return 1; /* could extend a pre-processing number */
1711 if (CPP_OPTION (pfile, dollars_in_ident))
1716 if (c2 == '\'' || c2 == '\"')
1717 return 1; /* Could turn into L"xxx" or L'xxx'. */
1720 case '.': case '0': case '1': case '2': case '3':
1721 case '4': case '5': case '6': case '7': case '8': case '9':
1722 case '_': case 'a': case 'b': case 'c': case 'd': case 'f':
1723 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
1724 case 'm': case 'n': case 'o': case 'q': case 'r': case 's':
1725 case 't': case 'u': case 'v': case 'w': case 'x': case 'y':
1726 case 'z': case 'A': case 'B': case 'C': case 'D': case 'F':
1727 case 'G': case 'H': case 'I': case 'J': case 'K': case 'M':
1728 case 'N': case 'O': case 'Q': case 'R': case 'S': case 'T':
1729 case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z':
1731 /* We're in the middle of either a name or a pre-processing number. */
1732 return (is_idchar(c2) || c2 == '.');
1734 case '<': case '>': case '!': case '%': case '#': case ':':
1735 case '^': case '&': case '|': case '*': case '/': case '=':
1736 return (c2 == c1 || c2 == '=');
1742 push_macro_expansion (pfile, xbuf, len, hp)
1749 int advance_cur = 0;
1751 /* The first chars of the expansion should be a "\r " added by
1752 collect_expansion. This is to prevent accidental token-pasting
1753 between the text preceding the macro invocation, and the macro
1756 We would like to avoid adding unneeded spaces (for the sake of
1757 tools that use cpp, such as imake). In some common cases we can
1758 tell that it is safe to omit the space. */
1760 if (xbuf[0] == '\r' && xbuf[1] == ' '
1761 && !unsafe_chars (pfile, EOF, xbuf[2]))
1764 /* Likewise, avoid the extra space at the end of the macro expansion
1765 if this is safe. We can do a better job here since we can know
1766 what the next char will be. */
1767 if (len >= 3 && xbuf[len-2] == '\r' && xbuf[len-1] == ' '
1768 && !unsafe_chars (pfile, xbuf[len-3], CPP_BUF_PEEK (CPP_BUFFER (pfile))))
1771 /* If the total expansion is "\r \r ", we must not trim both escapes. */
1772 if (len == 2 && advance_cur)
1775 mbuf = cpp_push_buffer (pfile, xbuf, len);
1781 mbuf->has_escapes = 1;
1783 /* In C89, a macro cannot be expanded recursively. Traditional C
1784 permits it, but any use in an object-like macro must lead to
1785 infinite recursion, so always follow C89 in object-like macros.
1786 Likewise, in a function-like macro it must cause infinite
1787 recursion unless we are actually doing something with the
1790 Even that criterion is too weak. The only example known where
1791 macro recursion isn't infinite is:
1792 #define bar(x,y) foo(x(y, 0))
1794 which expands to foo(bar(baz, 0)) in C89 and
1795 foo(foo(baz(0, 0)) in K+R. This looks pathological to me.
1796 If someone has a real-world example I would love to see it. */
1797 if (hp->type != T_FMACRO
1798 || hp->value.fdefn->nargs == 0
1799 || hp->value.fdefn->pattern == 0
1800 || !CPP_TRADITIONAL (pfile))
1804 /* Return zero if two funct_defns are isomorphic. */
1807 compare_defs (pfile, d1, d2)
1809 const struct funct_defn *d1, *d2;
1811 const struct reflist *a1, *a2;
1813 if (d1->nargs != d2->nargs)
1815 if (ustrcmp (d1->expansion, d2->expansion))
1817 if (CPP_PEDANTIC (pfile)
1818 && d1->argnames && d2->argnames)
1820 U_CHAR *arg1 = d1->argnames;
1821 U_CHAR *arg2 = d2->argnames;
1826 len = ustrlen (arg1) + 1;
1827 if (ustrcmp (arg1, arg2))
1833 for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
1834 a1 = a1->next, a2 = a2->next)
1836 if (a1->nchars != a2->nchars
1837 || a1->argno != a2->argno
1838 || a1->stringify != a2->stringify
1839 || a1->raw_before != a2->raw_before
1840 || a1->raw_after != a2->raw_after)
1849 /* Dump the definition of macro MACRO on stdout. The format is suitable
1850 to be read back in again. */
1853 _cpp_dump_definition (pfile, hp)
1857 CPP_RESERVE (pfile, hp->length + sizeof "#define ");
1858 CPP_PUTS_Q (pfile, "#define ", sizeof "#define " - 1);
1859 CPP_PUTS_Q (pfile, hp->name, hp->length);
1861 if (hp->type == T_EMPTY)
1863 else if (hp->type == T_FMACRO)
1864 dump_funlike_macro (pfile, hp->value.fdefn);
1867 CPP_PUTC_Q (pfile, ' ');
1869 if (hp->type == T_IDENTITY)
1870 CPP_PUTS (pfile, hp->name, hp->length);
1871 else if (hp->type == T_MACRO)
1873 /* The first and last two characters of a macro expansion are
1874 always "\r "; this needs to be trimmed out.
1875 So we need length-4 chars of space, plus one for the NUL. */
1876 CPP_RESERVE (pfile, hp->value.odefn->length - 4 + 1);
1877 CPP_PUTS_Q (pfile, hp->value.odefn->expansion + 2,
1878 hp->value.odefn->length - 4);
1881 cpp_ice (pfile, "invalid hash type %d in dump_definition", hp->type);
1883 if (CPP_BUFFER (pfile) == 0 || ! pfile->done_initializing)
1884 CPP_PUTC (pfile, '\n');
1888 dump_funlike_macro (pfile, defn)
1890 const struct funct_defn *defn;
1892 const struct reflist *r;
1893 const U_CHAR **argv = (const U_CHAR **) alloca (defn->nargs *
1894 sizeof(const U_CHAR *));
1895 int *argl = (int *) alloca (defn->nargs * sizeof(int));
1899 /* First extract the argument list. */
1901 for (i = 0; i < defn->nargs; i++)
1904 argl[i] = ustrlen (x);
1908 /* Now print out the argument list. */
1909 CPP_PUTC_Q (pfile, '(');
1910 for (i = 0; i < defn->nargs; i++)
1912 CPP_RESERVE (pfile, argl[i] + 2);
1913 if (!(i == defn->nargs-1 && defn->rest_args
1914 && !ustrcmp (argv[i], U"__VA_ARGS__")))
1915 CPP_PUTS_Q (pfile, argv[i], argl[i]);
1916 if (i < defn->nargs-1)
1917 CPP_PUTS_Q (pfile, ", ", 2);
1919 if (defn->rest_args)
1920 CPP_PUTS (pfile, "...", 3);
1921 CPP_PUTS (pfile, ") ", 2);
1923 /* Now the definition. */
1924 x = defn->expansion;
1925 for (r = defn->pattern; r; r = r->next)
1928 if (*x == '\r') x += 2, i -= 2;
1929 /* i chars for macro text, plus the length of the macro
1930 argument name, plus one for a stringify marker, plus two for
1931 each concatenation marker. */
1933 i + argl[r->argno] + r->stringify
1934 + (r->raw_before + r->raw_after) * 2);
1936 if (i > 0) CPP_PUTS_Q (pfile, x, i);
1938 CPP_PUTS_Q (pfile, "##", 2);
1940 CPP_PUTC_Q (pfile, '#');
1941 CPP_PUTS_Q (pfile, argv[r->argno], argl[r->argno]);
1942 if (r->raw_after && !(r->next && r->next->nchars == 0
1943 && r->next->raw_before))
1944 CPP_PUTS_Q (pfile, "##", 2);
1949 i = defn->length - (x - defn->expansion) - 2;
1950 if (*x == '\r') x += 2, i -= 2;
1951 if (i > 0) CPP_PUTS (pfile, x, i);
1954 /* Dump out the hash table. */
1956 dump_hash_helper (h, p)
1960 HASHNODE *hp = (HASHNODE *)*h;
1961 cpp_reader *pfile = (cpp_reader *)p;
1963 if (hp->type == T_MACRO || hp->type == T_FMACRO
1964 || hp->type == T_IDENTITY || hp->type == T_EMPTY)
1965 _cpp_dump_definition (pfile, hp);
1970 _cpp_dump_macro_hash (pfile)
1973 htab_traverse (pfile->hashtab, dump_hash_helper, pfile);