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! */
33 static unsigned int hashf PARAMS ((const U_CHAR *, int));
34 static int comp_def_part PARAMS ((int, U_CHAR *, int, U_CHAR *,
36 static void push_macro_expansion PARAMS ((cpp_reader *,
37 U_CHAR *, int, HASHNODE *));
38 static int unsafe_chars PARAMS ((cpp_reader *, int, int));
39 static int macro_cleanup PARAMS ((cpp_buffer *, cpp_reader *));
40 static enum cpp_token macarg PARAMS ((cpp_reader *, int));
41 static struct tm *timestamp PARAMS ((cpp_reader *));
42 static void special_symbol PARAMS ((HASHNODE *, cpp_reader *));
44 #define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->data != NULL)
45 #define FORWARD(N) CPP_FORWARD (CPP_BUFFER (pfile), (N))
46 #define PEEKC() CPP_BUF_PEEK (CPP_BUFFER (pfile))
48 /* The arglist structure is built by create_definition to tell
49 collect_expansion where the argument names begin. That
50 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
51 would contain pointers to the strings x, y, and z.
52 collect_expansion would then build a DEFINITION node,
53 with reflist nodes pointing to the places x, y, and z had
54 appeared. So the arglist is just convenience data passed
55 between these two routines. It is not kept around after
56 the current #define has been processed and entered into the
74 static DEFINITION *collect_expansion PARAMS ((cpp_reader *, struct arglist *));
75 static struct arglist *collect_formal_parameters PARAMS ((cpp_reader *));
77 /* This structure represents one parsed argument in a macro call.
78 `raw' points to the argument text as written (`raw_length' is its length).
79 `expanded' points to the argument's macro-expansion
80 (its length is `expand_length').
81 `stringified_length' is the length the argument would have
84 /* raw and expanded are relative to ARG_BASE */
85 #define ARG_BASE ((pfile)->token_buffer)
89 /* Strings relative to pfile->token_buffer */
90 long raw, expanded, stringified;
91 int raw_length, expand_length;
92 int stringified_length;
96 /* Calculate hash function on a string. */
100 register const U_CHAR *s;
103 unsigned int n = len;
107 r = r * 67 + (*s++ - 113);
112 /* Find the most recent hash node for name "name" (ending with first
113 non-identifier char) installed by cpp_install
115 If LEN is >= 0, it is the length of the name.
116 Otherwise, compute the length by scanning the entire name. */
119 cpp_lookup (pfile, name, len)
124 register const U_CHAR *bp;
125 register HASHNODE *bucket;
126 register unsigned int hash;
130 for (bp = name; is_idchar (*bp); bp++);
134 hash = hashf (name, len) % HASHSIZE;
136 bucket = pfile->hashtab[hash];
139 if (bucket->length == len && strncmp (bucket->name, name, len) == 0)
141 bucket = bucket->next;
143 return (HASHNODE *) 0;
146 /* Free a DEFINITION structure. Used by delete_macro, and by
147 do_define when redefining macros. */
153 struct reflist *ap, *nextap;
155 for (ap = d->pattern; ap != NULL; ap = nextap)
166 * Delete a hash node. Some weirdness to free junk from macros.
167 * More such weirdness will have to be added if you define more hash
168 * types that need it.
175 if (hp->prev != NULL)
176 hp->prev->next = hp->next;
177 if (hp->next != NULL)
178 hp->next->prev = hp->prev;
180 /* make sure that the bucket chain header that
181 the deleted guy was on points to the right thing afterwards. */
182 if (hp == *hp->bucket_hdr)
183 *hp->bucket_hdr = hp->next;
185 if (hp->type == T_MACRO)
186 free_definition (hp->value.defn);
191 /* Install a name in the main hash table, even if it is already there.
192 Name stops with first non alphanumeric, except leading '#'.
193 Caller must check against redefinition if that is desired.
194 delete_macro () removes things installed by cpp_install () in fifo order.
195 this is important because of the `defined' special symbol used
196 in #if, and also if pushdef/popdef directives are ever implemented.
198 If LEN is >= 0, it is the length of the name.
199 Otherwise, compute the length by scanning the entire name.
201 If HASH is >= 0, it is the precomputed hash code.
202 Otherwise, compute the hash code. */
205 cpp_install (pfile, name, len, type, value)
212 register HASHNODE *hp;
213 register int i, bucket;
214 register const U_CHAR *p;
220 while (is_idchar(*p))
225 hash = hashf (name, len) % HASHSIZE;
227 i = sizeof (HASHNODE) + len + 1;
228 hp = (HASHNODE *) xmalloc (i);
230 hp->bucket_hdr = &pfile->hashtab[bucket];
231 hp->next = pfile->hashtab[bucket];
232 pfile->hashtab[bucket] = hp;
234 if (hp->next != NULL)
238 hp->value.cpval = value;
239 hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
240 bcopy (name, hp->name, len);
246 macro_cleanup (pbuf, pfile)
248 cpp_reader *pfile ATTRIBUTE_UNUSED;
250 HASHNODE *macro = (HASHNODE *) pbuf->data;
251 if (macro->type == T_DISABLED)
252 macro->type = T_MACRO;
253 if (macro->type != T_MACRO || pbuf->buf != macro->value.defn->expansion)
259 /* Read a replacement list for a macro, and build the DEFINITION
260 structure. ARGLIST specifies the formal parameters to look for in
261 the text of the definition. If ARGLIST is null, this is an
262 object-like macro; if it points to an empty arglist, this is a
263 function-like macro with no arguments.
265 A good half of this is devoted to supporting -traditional.
269 collect_expansion (pfile, arglist)
271 struct arglist *arglist;
274 struct reflist *pat = 0, *endpat = 0;
275 enum cpp_token token;
276 long start, here, last;
282 enum { START = 0, NORM, ARG, STRIZE, PASTE } last_token = START;
286 argv = arglist->argv;
287 argc = arglist->argc;
295 last = start = CPP_WRITTEN (pfile);
296 last -= 2; /* two extra chars for the leading escape */
299 /* We use cpp_get_token because get_directive_token would
300 discard whitespace and we can't cope with that yet. Macro
301 expansion is off, so we are guaranteed not to see POP or EOF. */
303 while (PEEKC () == '\r')
306 CPP_BUMP_LINE (pfile);
308 if (PEEKC () == '\n')
310 here = CPP_WRITTEN (pfile);
311 token = cpp_get_token (pfile);
312 tok = pfile->token_buffer + here;
318 cpp_ice (pfile, "EOF or VSPACE in collect_expansion");
322 if (last_token == STRIZE || last_token == PASTE
323 || last_token == START)
324 CPP_SET_WRITTEN (pfile, here);
328 if (last_token == PASTE)
329 /* Not really a stringifier. */
332 CPP_SET_WRITTEN (pfile, here); /* delete from replacement text */
336 /* If the last token was an argument, discard this token and
337 any hspace between it and the argument's position. Then
338 mark the arg raw_after. */
339 if (last_token == ARG)
341 endpat->raw_after = 1;
343 CPP_SET_WRITTEN (pfile, last);
346 else if (last_token == PASTE)
347 /* ## ## - the second ## is ordinary. */
350 /* Discard the token and any hspace before it. */
351 while (is_hspace (pfile->token_buffer[here-1]))
353 CPP_SET_WRITTEN (pfile, here);
355 if (last_token == STRIZE)
356 /* Oops - that wasn't a stringify operator. */
357 CPP_PUTC (pfile, '#');
362 /* We must be in -traditional mode. Pretend this was a
363 token paste, but only if there was no leading or
365 CPP_SET_WRITTEN (pfile, here);
366 if (is_hspace (pfile->token_buffer[here-1]))
368 if (is_hspace (PEEKC ()))
370 if (last_token == ARG)
371 endpat->raw_after = 1;
377 if (last_token == STRIZE)
378 cpp_error (pfile, "`#' is not followed by a macro argument name");
380 if (CPP_TRADITIONAL (pfile) || CPP_OPTIONS (pfile)->warn_stringify)
381 goto maybe_trad_stringify;
386 for (i = 0; i < argc; i++)
387 if (!strncmp (tok, argv[i].name, argv[i].len)
388 && ! is_idchar (tok[argv[i].len]))
394 if (last_token == STRIZE)
395 cpp_error (pfile, "`#' is not followed by a macro argument name");
403 struct reflist *tpat;
405 /* Make a pat node for this arg and add it to the pat list */
406 tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
408 tpat->raw_before = (last_token == PASTE);
410 tpat->stringify = (last_token == STRIZE);
411 tpat->rest_args = argv[i].rest_arg;
413 tpat->nchars = here - last;
422 CPP_SET_WRITTEN (pfile, here); /* discard arg name */
426 maybe_trad_stringify:
429 U_CHAR *base, *p, *limit;
430 struct reflist *tpat;
432 base = p = pfile->token_buffer + here;
433 limit = CPP_PWRITTEN (pfile);
439 for (i = 0; i < argc; i++)
440 if (!strncmp (tok, argv[i].name, argv[i].len)
441 && ! is_idchar (tok[argv[i].len]))
446 if (!CPP_TRADITIONAL (pfile))
448 /* Must have got here because of -Wtraditional. */
450 "macro argument `%.*s' would be stringified with -traditional",
451 (int) argv[i].len, argv[i].name);
454 if (CPP_OPTIONS (pfile)->warn_stringify)
455 cpp_warning (pfile, "macro argument `%.*s' is stringified",
456 (int) argv[i].len, argv[i].name);
458 /* Remove the argument from the string. */
459 memmove (p, p + argv[i].len, limit - (p + argv[i].len));
460 limit -= argv[i].len;
462 /* Make a pat node for this arg and add it to the pat list */
463 tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
466 /* Don't attempt to paste this with anything. */
467 tpat->raw_before = 0;
470 tpat->rest_args = argv[i].rest_arg;
472 tpat->nchars = (p - base) + here - last;
479 last = (p - base) + here;
481 CPP_ADJUST_WRITTEN (pfile, CPP_PWRITTEN (pfile) - limit);
486 if (last_token == STRIZE)
487 cpp_error (pfile, "`#' is not followed by a macro argument name");
488 else if (last_token == PASTE)
489 cpp_error (pfile, "`##' at end of macro definition");
491 if (last_token == START)
493 /* Empty macro definition. */
494 exp = xstrdup ("\r \r ");
499 /* Trim trailing white space from definition. */
500 here = CPP_WRITTEN (pfile);
501 while (here > last && is_hspace (pfile->token_buffer [here-1]))
503 CPP_SET_WRITTEN (pfile, here);
505 CPP_NUL_TERMINATE (pfile);
506 len = CPP_WRITTEN (pfile) - start + 1;
507 exp = xmalloc (len + 4); /* space for no-concat markers at either end */
513 memcpy (&exp[2], pfile->token_buffer + start, len - 1);
516 CPP_SET_WRITTEN (pfile, start);
518 defn = (DEFINITION *) xmalloc (sizeof (DEFINITION));
519 defn->length = len + 3;
520 defn->expansion = exp;
526 defn->argnames = arglist->namebuf;
529 defn->rest_args = argv[argc - 1].rest_arg;
543 static struct arglist *
544 collect_formal_parameters (pfile)
547 struct arglist *result = 0;
548 struct arg *argv = 0;
549 U_CHAR *namebuf = xstrdup ("");
556 enum cpp_token token;
559 old_written = CPP_WRITTEN (pfile);
560 token = get_directive_token (pfile);
561 if (token != CPP_LPAREN)
563 cpp_ice (pfile, "first token = %d not %d in collect_formal_parameters",
568 argv = (struct arg *) xmalloc (sizeof (struct arg));
570 argv[argc].rest_arg = 0;
573 CPP_SET_WRITTEN (pfile, old_written);
574 token = get_directive_token (pfile);
578 tok = pfile->token_buffer + old_written;
579 len = CPP_PWRITTEN (pfile) - tok;
581 && (name = strstr (namebuf, tok))
583 && (name == namebuf || name[-1] == ','))
585 cpp_error (pfile, "duplicate macro argument name `%s'", tok);
588 namebuf = xrealloc (namebuf, argslen + len + 1);
589 name = &namebuf[argslen - 1];
592 memcpy (name, tok, len);
595 argv[argc].len = len;
596 argv[argc].rest_arg = 0;
601 argv = xrealloc (argv, (argc + 1)*sizeof(struct arg));
612 cpp_error (pfile, "missing right paren in macro argument list");
616 cpp_error (pfile, "syntax error in #define");
622 /* There are two possible styles for a vararg macro:
623 the C99 way: #define foo(a, ...) a, __VA_ARGS__
624 the gnu way: #define foo(a, b...) a, b
625 The C99 way can be considered a special case of the gnu way.
626 There are also some constraints to worry about, but we'll handle
628 if (argv[argc].len == 0)
630 if (CPP_PEDANTIC (pfile) && ! CPP_OPTIONS (pfile)->c99)
631 cpp_pedwarn (pfile, "C89 does not permit varargs macros");
633 len = sizeof "__VA_ARGS__" - 1;
634 namebuf = xrealloc (namebuf, argslen + len + 1);
635 name = &namebuf[argslen - 1];
637 memcpy (name, "__VA_ARGS__", len);
640 argv[argc].len = len;
643 if (CPP_PEDANTIC (pfile))
644 cpp_pedwarn (pfile, "ISO C does not permit named varargs macros");
646 argv[argc].rest_arg = 1;
647 namebuf = xrealloc (namebuf, argslen + 3);
648 memcpy (&namebuf[argslen - 1], "...", 4);
651 token = get_directive_token (pfile);
652 if (token != CPP_RPAREN)
654 cpp_error (pfile, "another parameter follows `...'");
659 /* Go through argv and fix up the pointers. */
661 for (i = 0; i <= argc; i++)
663 argv[i].name = namebuf + len;
664 len += argv[i].len + 1;
667 CPP_SET_WRITTEN (pfile, old_written);
669 result = (struct arglist *) xmalloc (sizeof (struct arglist));
670 if (namebuf[0] != '\0')
672 result->namebuf = namebuf;
673 result->argc = argc + 1;
694 /* Create a DEFINITION node for a macro. The reader's point is just
695 after the macro name. If FUNLIKE is true, this is a function-like
699 create_definition (pfile, funlike)
703 struct arglist *args = 0;
708 cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
709 file = CPP_BUFFER (pfile)->nominal_fname;
711 pfile->no_macro_expand++;
712 pfile->parsing_define_directive++;
713 CPP_OPTIONS (pfile)->discard_comments++;
714 CPP_OPTIONS (pfile)->no_line_commands++;
718 args = collect_formal_parameters (pfile);
723 defn = collect_expansion (pfile, args);
731 pfile->no_macro_expand--;
732 pfile->parsing_define_directive--;
733 CPP_OPTIONS (pfile)->discard_comments--;
734 CPP_OPTIONS (pfile)->no_line_commands--;
738 pfile->no_macro_expand--;
739 pfile->parsing_define_directive--;
740 CPP_OPTIONS (pfile)->discard_comments--;
741 CPP_OPTIONS (pfile)->no_line_commands--;
746 * Parse a macro argument and append the info on PFILE's token_buffer.
747 * REST_ARGS means to absorb the rest of the args.
748 * Return nonzero to indicate a syntax error.
751 static enum cpp_token
752 macarg (pfile, rest_args)
757 enum cpp_token token;
759 /* Try to parse as much of the argument as exists at this
760 input stack level. */
763 token = cpp_get_token (pfile);
769 /* If we've hit end of file, it's an error (reported by caller).
770 Ditto if it's the end of cpp_expand_to_buffer text.
771 If we've hit end of macro, just continue. */
772 if (!CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
783 /* if we've returned to lowest level and
784 we aren't absorbing all args */
785 if (paren == 0 && rest_args == 0)
789 /* Remove ',' or ')' from argument buffer. */
790 CPP_ADJUST_WRITTEN (pfile, -1);
804 time_t t = time ((time_t *) 0);
805 pfile->timebuf = localtime (&t);
807 return pfile->timebuf;
810 static const char * const monthnames[] =
812 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
813 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
817 * expand things like __FILE__. Place the expansion into the output
818 * buffer *without* rescanning.
822 special_symbol (hp, pfile)
835 ip = CPP_BUFFER (pfile);
836 if (hp->type == T_BASE_FILE)
838 while (CPP_PREV_BUFFER (ip) != CPP_NULL_BUFFER (pfile))
839 ip = CPP_PREV_BUFFER (ip);
843 ip = CPP_BUFFER (pfile);
844 while (!ip->nominal_fname && ip != CPP_NULL_BUFFER (pfile))
845 ip = CPP_PREV_BUFFER (ip);
848 buf = ip->nominal_fname;
852 CPP_RESERVE (pfile, 3 + 4 * strlen (buf));
853 quote_string (pfile, buf);
857 case T_INCLUDE_LEVEL:
859 int true_indepth = 0;
860 ip = CPP_BUFFER (pfile);
861 for (; ip != CPP_NULL_BUFFER (pfile); ip = CPP_PREV_BUFFER (ip))
862 if (ip->fname != NULL)
865 CPP_RESERVE (pfile, 10);
866 sprintf (CPP_PWRITTEN (pfile), "%d", true_indepth);
867 CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
872 len = strlen (version_string);
873 CPP_RESERVE (pfile, 3 + len);
874 CPP_PUTC_Q (pfile, '"');
875 CPP_PUTS_Q (pfile, version_string, len);
876 CPP_PUTC_Q (pfile, '"');
877 CPP_NUL_TERMINATE_Q (pfile);
881 buf = hp->value.cpval;
888 CPP_RESERVE (pfile, len + 1);
889 CPP_PUTS_Q (pfile, buf, len);
890 CPP_NUL_TERMINATE_Q (pfile);
894 CPP_RESERVE (pfile, 2);
895 #ifdef STDC_0_IN_SYSTEM_HEADERS
896 ip = CPP_BUFFER (pfile);
897 while (!ip->nominal_fname && ip != CPP_NULL_BUFFER (pfile))
898 ip = CPP_PREV_BUFFER (ip);
899 if (ip->system_header_p
900 && !cpp_lookup (pfile, (U_CHAR *) "__STRICT_ANSI__", 15))
901 CPP_PUTC_Q (pfile, '0');
904 CPP_PUTC_Q (pfile, '1');
905 CPP_NUL_TERMINATE_Q (pfile);
911 cpp_buf_line_and_col (cpp_file_buffer (pfile), &line, NULL);
913 CPP_RESERVE (pfile, 10);
914 sprintf (CPP_PWRITTEN (pfile), "%ld", line);
915 CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
924 CPP_RESERVE (pfile, 20);
925 timebuf = timestamp (pfile);
926 if (hp->type == T_DATE)
927 sprintf (CPP_PWRITTEN (pfile), "\"%s %2d %4d\"",
928 monthnames[timebuf->tm_mon],
929 timebuf->tm_mday, timebuf->tm_year + 1900);
931 sprintf (CPP_PWRITTEN (pfile), "\"%02d:%02d:%02d\"",
932 timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
934 CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
939 cpp_error (pfile, "attempt to use poisoned `%s'.", hp->name);
940 CPP_RESERVE (pfile, 1);
941 CPP_PUTC_Q (pfile, '0');
942 CPP_NUL_TERMINATE_Q (pfile);
946 cpp_ice (pfile, "invalid special hash type");
951 /* Expand a macro call.
952 HP points to the symbol that is the macro being called.
953 Put the result of expansion onto the input stack
954 so that subsequent input by our caller will use it.
956 If macro wants arguments, caller has already verified that
957 an argument list follows; arguments come from the input stack. */
960 macroexpand (pfile, hp)
966 register U_CHAR *xbuf;
967 long start_line, start_column;
969 struct argdata *args = 0;
970 long old_written = CPP_WRITTEN (pfile);
971 int rest_args, rest_zero = 0;
974 cpp_buf_line_and_col (cpp_file_buffer (pfile), &start_line, &start_column);
976 /* Check for and handle special symbols. */
977 if (hp->type != T_MACRO)
979 special_symbol (hp, pfile);
980 xbuf_len = CPP_WRITTEN (pfile) - old_written;
981 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
982 CPP_SET_WRITTEN (pfile, old_written);
983 memcpy (xbuf, CPP_PWRITTEN (pfile), xbuf_len + 1);
984 push_macro_expansion (pfile, xbuf, xbuf_len, hp);
985 CPP_BUFFER (pfile)->has_escapes = 1;
989 defn = hp->value.defn;
991 pfile->output_escapes++;
995 enum cpp_token token;
997 args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
999 for (i = 0; i < nargs; i++)
1001 args[i].raw = args[i].expanded = 0;
1002 args[i].raw_length = 0;
1003 args[i].expand_length = args[i].stringified_length = -1;
1006 /* Parse all the macro args that are supplied. I counts them.
1007 The first NARGS args are stored in ARGS.
1008 The rest are discarded. If rest_args is set then we assume
1009 macarg absorbed the rest of the args. */
1013 /* Skip over the opening parenthesis. */
1014 CPP_OPTIONS (pfile)->discard_comments++;
1015 CPP_OPTIONS (pfile)->no_line_commands++;
1016 pfile->no_macro_expand++;
1017 pfile->no_directives++;
1019 token = cpp_get_non_space_token (pfile);
1020 if (token != CPP_LPAREN)
1021 cpp_ice (pfile, "macroexpand: unexpected token %d (wanted LPAREN)",
1023 CPP_ADJUST_WRITTEN (pfile, -1);
1030 if (i < nargs || (nargs == 0 && i == 0))
1032 /* if we are working on last arg which absorbs rest of args... */
1033 if (i == nargs - 1 && defn->rest_args)
1035 args[i].raw = CPP_WRITTEN (pfile);
1036 token = macarg (pfile, rest_args);
1037 args[i].raw_length = CPP_WRITTEN (pfile) - args[i].raw;
1040 token = macarg (pfile, 0);
1041 if (token == CPP_EOF || token == CPP_POP)
1042 cpp_error_with_line (pfile, start_line, start_column,
1043 "unterminated macro call");
1046 while (token == CPP_COMMA);
1047 CPP_OPTIONS (pfile)->discard_comments--;
1048 CPP_OPTIONS (pfile)->no_line_commands--;
1049 pfile->no_macro_expand--;
1050 pfile->no_directives--;
1051 if (token != CPP_RPAREN)
1054 /* If we got one arg but it was just whitespace, call that 0 args. */
1057 register U_CHAR *bp = ARG_BASE + args[0].raw;
1058 register U_CHAR *lim = bp + args[0].raw_length;
1059 /* cpp.texi says for foo ( ) we provide one argument.
1060 However, if foo wants just 0 arguments, treat this as 0. */
1062 while (bp != lim && is_space(*bp))
1068 /* Don't output an error message if we have already output one for
1069 a parse error above. */
1071 if (nargs == 0 && i > 0)
1073 cpp_error (pfile, "arguments given to macro `%s'", hp->name);
1077 /* traditional C allows foo() if foo wants one argument. */
1078 if (nargs == 1 && i == 0 && CPP_TRADITIONAL (pfile))
1080 /* the rest args token is allowed to absorb 0 tokens */
1081 else if (i == nargs - 1 && defn->rest_args)
1084 cpp_error (pfile, "macro `%s' used without args", hp->name);
1086 cpp_error (pfile, "macro `%s' used with just one arg", hp->name);
1088 cpp_error (pfile, "macro `%s' used with only %d args",
1094 "macro `%s' used with too many (%d) args", hp->name, i);
1098 /* If macro wants zero args, we parsed the arglist for checking only.
1099 Read directly from the macro definition. */
1102 xbuf = defn->expansion;
1103 xbuf_len = defn->length;
1107 register U_CHAR *exp = defn->expansion;
1108 register int offset; /* offset in expansion,
1109 copied a piece at a time */
1110 register int totlen; /* total amount of exp buffer filled so far */
1112 register struct reflist *ap, *last_ap;
1114 /* Macro really takes args. Compute the expansion of this call. */
1116 /* Compute length in characters of the macro's expansion.
1117 Also count number of times each arg is used. */
1118 xbuf_len = defn->length;
1119 for (ap = defn->pattern; ap != NULL; ap = ap->next)
1123 register struct argdata *arg = &args[ap->argno];
1124 /* Stringify if it hasn't already been */
1125 if (arg->stringified_length < 0)
1127 int arglen = arg->raw_length;
1131 /* Initially need_space is -1. Otherwise, 1 means the
1132 previous character was a space, but we suppressed it;
1133 0 means the previous character was a non-space. */
1134 int need_space = -1;
1136 arg->stringified = CPP_WRITTEN (pfile);
1137 if (!CPP_TRADITIONAL (pfile))
1138 CPP_PUTC (pfile, '\"'); /* insert beginning quote */
1139 for (; i < arglen; i++)
1141 c = (ARG_BASE + arg->raw)[i];
1145 /* Delete "\r " and "\r-" escapes. */
1151 /* Internal sequences of whitespace are
1152 replaced by one space except within
1153 a string or char token. */
1154 else if (is_space(c))
1156 if (need_space == 0)
1160 else if (need_space > 0)
1161 CPP_PUTC (pfile, ' ');
1176 else if (c == '\"' || c == '\'')
1180 /* Escape these chars */
1181 if (c == '\"' || (in_string && c == '\\'))
1182 CPP_PUTC (pfile, '\\');
1184 CPP_PUTC (pfile, c);
1187 CPP_RESERVE (pfile, 4);
1188 sprintf ((char *) CPP_PWRITTEN (pfile), "\\%03o",
1190 CPP_ADJUST_WRITTEN (pfile, 4);
1193 if (!CPP_TRADITIONAL (pfile))
1194 CPP_PUTC (pfile, '\"'); /* insert ending quote */
1195 arg->stringified_length
1196 = CPP_WRITTEN (pfile) - arg->stringified;
1198 xbuf_len += args[ap->argno].stringified_length;
1200 else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
1201 /* Add 4 for two \r-space markers to prevent
1202 token concatenation. */
1203 xbuf_len += args[ap->argno].raw_length + 4;
1206 /* We have an ordinary (expanded) occurrence of the arg.
1207 So compute its expansion, if we have not already. */
1208 if (args[ap->argno].expand_length < 0)
1210 args[ap->argno].expanded = CPP_WRITTEN (pfile);
1211 cpp_expand_to_buffer (pfile,
1212 ARG_BASE + args[ap->argno].raw,
1213 args[ap->argno].raw_length);
1215 args[ap->argno].expand_length
1216 = CPP_WRITTEN (pfile) - args[ap->argno].expanded;
1219 /* Add 4 for two \r-space markers to prevent
1220 token concatenation. */
1221 xbuf_len += args[ap->argno].expand_length + 4;
1225 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
1227 /* Generate in XBUF the complete expansion
1228 with arguments substituted in.
1229 TOTLEN is the total size generated so far.
1230 OFFSET is the index in the definition
1231 of where we are copying from. */
1232 offset = totlen = 0;
1233 for (last_ap = NULL, ap = defn->pattern; ap != NULL;
1234 last_ap = ap, ap = ap->next)
1236 register struct argdata *arg = &args[ap->argno];
1237 int count_before = totlen;
1239 /* Add chars to XBUF. */
1241 memcpy (&xbuf[totlen], &exp[offset], i);
1245 /* If followed by an empty rest arg with concatenation,
1246 delete the last run of nonwhite chars. */
1247 if (rest_zero && totlen > count_before
1248 && ((ap->rest_args && ap->raw_before)
1249 || (last_ap != NULL && last_ap->rest_args
1250 && last_ap->raw_after)))
1252 /* Delete final whitespace. */
1253 while (totlen > count_before && is_space(xbuf[totlen - 1]))
1256 /* Delete the nonwhites before them. */
1257 while (totlen > count_before && !is_space(xbuf[totlen - 1]))
1261 if (ap->stringify != 0)
1263 memcpy (xbuf + totlen, ARG_BASE + arg->stringified,
1264 arg->stringified_length);
1265 totlen += arg->stringified_length;
1267 else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
1269 U_CHAR *p1 = ARG_BASE + arg->raw;
1270 U_CHAR *l1 = p1 + arg->raw_length;
1273 /* Arg is concatenated before: delete leading whitespace,
1274 whitespace markers, and no-reexpansion markers. */
1277 if (is_space(p1[0]))
1279 else if (p1[0] == '\r')
1287 /* Arg is concatenated after: delete trailing whitespace,
1288 whitespace markers, and no-reexpansion markers. */
1291 if (is_space(l1[-1]))
1293 else if (l1[-1] == '\r')
1295 else if (l1[-1] == '-')
1297 if (l1 != p1 + 1 && l1[-2] == '\r')
1307 /* Delete any no-reexpansion marker that precedes
1308 an identifier at the beginning of the argument. */
1309 if (p1[0] == '\r' && p1[1] == '-')
1312 memcpy (xbuf + totlen, p1, l1 - p1);
1317 U_CHAR *expanded = ARG_BASE + arg->expanded;
1318 if (!ap->raw_before && totlen > 0 && arg->expand_length
1319 && !CPP_TRADITIONAL (pfile)
1320 && unsafe_chars (pfile, xbuf[totlen - 1], expanded[0]))
1322 xbuf[totlen++] = '\r';
1323 xbuf[totlen++] = ' ';
1326 memcpy (xbuf + totlen, expanded, arg->expand_length);
1327 totlen += arg->expand_length;
1329 if (!ap->raw_after && totlen > 0 && offset < defn->length
1330 && !CPP_TRADITIONAL (pfile)
1331 && unsafe_chars (pfile, xbuf[totlen - 1], exp[offset]))
1333 xbuf[totlen++] = '\r';
1334 xbuf[totlen++] = ' ';
1338 if (totlen > xbuf_len)
1340 cpp_ice (pfile, "buffer overrun in macroexpand");
1345 /* if there is anything left of the definition
1346 after handling the arg list, copy that in too. */
1348 for (i = offset; i < defn->length; i++)
1350 /* if we've reached the end of the macro */
1353 if (!(rest_zero && last_ap != NULL && last_ap->rest_args
1354 && last_ap->raw_after))
1355 xbuf[totlen++] = exp[i];
1363 pfile->output_escapes--;
1365 /* Now put the expansion on the input stack
1366 so our caller will commence reading from it. */
1367 push_macro_expansion (pfile, xbuf, xbuf_len, hp);
1368 CPP_BUFFER (pfile)->has_escapes = 1;
1370 /* Pop the space we've used in the token_buffer for argument expansion. */
1371 CPP_SET_WRITTEN (pfile, old_written);
1373 /* Recursive macro use sometimes works traditionally.
1374 #define foo(x,y) bar (x (y,0), y)
1377 if (!CPP_TRADITIONAL (pfile))
1378 hp->type = T_DISABLED;
1381 /* Return 1 iff a token ending in C1 followed directly by a token C2
1382 could cause mis-tokenization. */
1385 unsafe_chars (pfile, c1, c2)
1392 if (c2 == c1 || c2 == '=')
1396 case 'e': case 'E': case 'p': case 'P':
1397 if (c2 == '-' || c2 == '+')
1398 return 1; /* could extend a pre-processing number */
1402 if (CPP_OPTIONS (pfile)->dollars_in_ident)
1407 if (c2 == '\'' || c2 == '\"')
1408 return 1; /* Could turn into L"xxx" or L'xxx'. */
1411 case '.': case '0': case '1': case '2': case '3':
1412 case '4': case '5': case '6': case '7': case '8': case '9':
1413 case '_': case 'a': case 'b': case 'c': case 'd': case 'f':
1414 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
1415 case 'm': case 'n': case 'o': case 'q': case 'r': case 's':
1416 case 't': case 'u': case 'v': case 'w': case 'x': case 'y':
1417 case 'z': case 'A': case 'B': case 'C': case 'D': case 'F':
1418 case 'G': case 'H': case 'I': case 'J': case 'K': case 'M':
1419 case 'N': case 'O': case 'Q': case 'R': case 'S': case 'T':
1420 case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z':
1422 /* We're in the middle of either a name or a pre-processing number. */
1423 return (is_idchar(c2) || c2 == '.');
1425 case '<': case '>': case '!': case '%': case '#': case ':':
1426 case '^': case '&': case '|': case '*': case '/': case '=':
1427 return (c2 == c1 || c2 == '=');
1433 push_macro_expansion (pfile, xbuf, xbuf_len, hp)
1435 register U_CHAR *xbuf;
1439 register cpp_buffer *mbuf = cpp_push_buffer (pfile, xbuf, xbuf_len);
1442 mbuf->cleanup = macro_cleanup;
1445 /* The first chars of the expansion should be a "\r " added by
1446 collect_expansion. This is to prevent accidental token-pasting
1447 between the text preceding the macro invocation, and the macro
1450 We would like to avoid adding unneeded spaces (for the sake of
1451 tools that use cpp, such as imake). In some common cases we can
1452 tell that it is safe to omit the space.
1454 The character before the macro invocation cannot have been an
1455 idchar (or else it would have been pasted with the idchars of
1456 the macro name). Therefore, if the first non-space character
1457 of the expansion is an idchar, we do not need the extra space
1458 to prevent token pasting.
1460 Also, we don't need the extra space if the first char is '(',
1461 or some other (less common) characters. */
1463 if (xbuf[0] == '\r' && xbuf[1] == ' '
1464 && (is_idchar(xbuf[2]) || xbuf[2] == '(' || xbuf[2] == '\''
1465 || xbuf[2] == '\"'))
1468 /* Likewise, avoid the extra space at the end of the macro expansion
1469 if this is safe. We can do a better job here since we can know
1470 what the next char will be. */
1472 && mbuf->rlimit[-2] == '\r'
1473 && mbuf->rlimit[-1] == ' ')
1475 int c1 = mbuf->rlimit[-3];
1476 int c2 = CPP_BUF_PEEK (CPP_PREV_BUFFER (CPP_BUFFER (pfile)));
1477 if (c2 == EOF || !unsafe_chars (pfile, c1, c2))
1482 /* Return zero if two DEFINITIONs are isomorphic. */
1485 compare_defs (pfile, d1, d2)
1487 DEFINITION *d1, *d2;
1489 register struct reflist *a1, *a2;
1490 register U_CHAR *p1 = d1->expansion;
1491 register U_CHAR *p2 = d2->expansion;
1494 if (d1->nargs != d2->nargs)
1496 if (CPP_PEDANTIC (pfile)
1497 && d1->argnames && d2->argnames
1498 && strcmp ((char *) d1->argnames, (char *) d2->argnames))
1500 for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
1501 a1 = a1->next, a2 = a2->next)
1503 if (!((a1->nchars == a2->nchars && !strncmp (p1, p2, a1->nchars))
1504 || !comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
1505 || a1->argno != a2->argno
1506 || a1->stringify != a2->stringify
1507 || a1->raw_before != a2->raw_before
1508 || a1->raw_after != a2->raw_after)
1517 return comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
1518 p2, d2->length - (p2 - d2->expansion), 1);
1521 /* Return 1 if two parts of two macro definitions are effectively different.
1522 One of the parts starts at BEG1 and has LEN1 chars;
1523 the other has LEN2 chars at BEG2.
1524 Any sequence of whitespace matches any other sequence of whitespace.
1525 FIRST means these parts are the first of a macro definition;
1526 so ignore leading whitespace entirely.
1527 LAST means these parts are the last of a macro definition;
1528 so ignore trailing whitespace entirely. */
1531 comp_def_part (first, beg1, len1, beg2, len2, last)
1533 U_CHAR *beg1, *beg2;
1537 register U_CHAR *end1 = beg1 + len1;
1538 register U_CHAR *end2 = beg2 + len2;
1541 while (beg1 != end1 && is_space(*beg1))
1543 while (beg2 != end2 && is_space(*beg2))
1548 while (beg1 != end1 && is_space(end1[-1]))
1550 while (beg2 != end2 && is_space(end2[-1]))
1553 while (beg1 != end1 && beg2 != end2)
1555 if (is_space(*beg1) && is_space(*beg2))
1557 while (beg1 != end1 && is_space(*beg1))
1559 while (beg2 != end2 && is_space(*beg2))
1562 else if (*beg1 == *beg2)
1570 return (beg1 != end1) || (beg2 != end2);
1573 /* Dump the definition of macro MACRO on stdout. The format is suitable
1574 to be read back in again. */
1577 dump_definition (pfile, sym, len, defn)
1583 if (pfile->lineno == 0)
1584 output_line_command (pfile, same_file);
1586 CPP_RESERVE (pfile, len + sizeof "#define ");
1587 CPP_PUTS_Q (pfile, "#define ", sizeof "#define " -1);
1588 CPP_PUTS_Q (pfile, sym, len);
1590 if (defn->nargs == -1)
1592 CPP_PUTC_Q (pfile, ' ');
1594 /* The first and last two characters of a macro expansion are
1595 always "\r "; this needs to be trimmed out.
1596 So we need length-4 chars of space, plus one for the NUL. */
1597 CPP_RESERVE (pfile, defn->length - 4 + 1);
1598 CPP_PUTS_Q (pfile, defn->expansion + 2, defn->length - 4);
1603 unsigned char *argnames = (unsigned char *) xstrdup (defn->argnames);
1604 unsigned char **argv = (unsigned char **) alloca (defn->nargs *
1606 int *argl = (int *) alloca (defn->nargs * sizeof(int));
1610 /* First extract the argument list. */
1616 while (*x != ',' && *x != '\0') x++;
1617 argl[i] = x - argv[i];
1621 x += 2; /* skip the space after the comma */
1625 /* Now print out the argument list. */
1626 CPP_PUTC_Q (pfile, '(');
1627 for (i = 0; i < defn->nargs; i++)
1629 CPP_RESERVE (pfile, argl[i] + 2);
1630 CPP_PUTS_Q (pfile, argv[i], argl[i]);
1631 if (i < defn->nargs-1)
1632 CPP_PUTS_Q (pfile, ", ", 2);
1635 if (defn->rest_args)
1636 CPP_PUTS (pfile, "...) ", 5);
1638 CPP_PUTS (pfile, ") ", 2);
1640 /* Now the definition. */
1641 x = defn->expansion;
1642 for (r = defn->pattern; r; r = r->next)
1645 if (*x == '\r') x += 2, i -= 2;
1646 /* i chars for macro text, plus the length of the macro
1647 argument name, plus one for a stringify marker, plus two for
1648 each concatenation marker. */
1650 i + argl[r->argno] + r->stringify
1651 + (r->raw_before + r->raw_after) * 2);
1653 if (i > 0) CPP_PUTS_Q (pfile, x, i);
1655 CPP_PUTS_Q (pfile, "##", 2);
1657 CPP_PUTC_Q (pfile, '#');
1658 CPP_PUTS_Q (pfile, argv[r->argno], argl[r->argno]);
1659 if (r->raw_after && !(r->next && r->next->nchars == 0
1660 && r->next->raw_before))
1661 CPP_PUTS_Q (pfile, "##", 2);
1666 i = defn->length - (x - defn->expansion) - 2;
1667 if (*x == '\r') x += 2, i -= 2;
1668 if (i > 0) CPP_PUTS (pfile, x, i);
1671 if (pfile->lineno == 0)
1672 CPP_PUTC (pfile, '\n');
1673 CPP_NUL_TERMINATE (pfile);