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 ((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 *));
45 #define SKIP_WHITE_SPACE(p) do { while (is_hspace(*p)) p++; } while (0)
46 #define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->data != NULL)
47 #define FORWARD(N) CPP_FORWARD (CPP_BUFFER (pfile), (N))
49 /* The arglist structure is built by create_definition to tell
50 collect_expansion where the argument names begin. That
51 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
52 would contain pointers to the strings x, y, and z.
53 collect_expansion would then build a DEFINITION node,
54 with reflist nodes pointing to the places x, y, and z had
55 appeared. So the arglist is just convenience data passed
56 between these two routines. It is not kept around after
57 the current #define has been processed and entered into the
69 static DEFINITION *collect_expansion PARAMS ((cpp_reader *, U_CHAR *, U_CHAR *,
70 int, struct arglist *));
72 /* This structure represents one parsed argument in a macro call.
73 `raw' points to the argument text as written (`raw_length' is its length).
74 `expanded' points to the argument's macro-expansion
75 (its length is `expand_length').
76 `stringified_length' is the length the argument would have
79 /* raw and expanded are relative to ARG_BASE */
80 #define ARG_BASE ((pfile)->token_buffer)
84 /* Strings relative to pfile->token_buffer */
85 long raw, expanded, stringified;
86 int raw_length, expand_length;
87 int stringified_length;
91 /* Calculate hash function on a string. */
95 register const U_CHAR *s;
102 r = r * 67 + (*s++ - 113);
107 /* Find the most recent hash node for name "name" (ending with first
108 non-identifier char) installed by cpp_install
110 If LEN is >= 0, it is the length of the name.
111 Otherwise, compute the length by scanning the entire name. */
114 cpp_lookup (pfile, name, len)
119 register const U_CHAR *bp;
120 register HASHNODE *bucket;
121 register unsigned int hash;
125 for (bp = name; is_idchar (*bp); bp++);
129 hash = hashf (name, len) % HASHSIZE;
131 bucket = pfile->hashtab[hash];
134 if (bucket->length == len && strncmp (bucket->name, name, len) == 0)
136 bucket = bucket->next;
138 return (HASHNODE *) 0;
141 /* Free a DEFINITION structure. Used by delete_macro, and by
142 do_define when redefining macros. */
148 struct reflist *ap, *nextap;
150 for (ap = d->pattern; ap != NULL; ap = nextap)
161 * Delete a hash node. Some weirdness to free junk from macros.
162 * More such weirdness will have to be added if you define more hash
163 * types that need it.
170 if (hp->prev != NULL)
171 hp->prev->next = hp->next;
172 if (hp->next != NULL)
173 hp->next->prev = hp->prev;
175 /* make sure that the bucket chain header that
176 the deleted guy was on points to the right thing afterwards. */
177 if (hp == *hp->bucket_hdr)
178 *hp->bucket_hdr = hp->next;
180 if (hp->type == T_MACRO)
181 free_definition (hp->value.defn);
186 /* Install a name in the main hash table, even if it is already there.
187 Name stops with first non alphanumeric, except leading '#'.
188 Caller must check against redefinition if that is desired.
189 delete_macro () removes things installed by cpp_install () in fifo order.
190 this is important because of the `defined' special symbol used
191 in #if, and also if pushdef/popdef directives are ever implemented.
193 If LEN is >= 0, it is the length of the name.
194 Otherwise, compute the length by scanning the entire name.
196 If HASH is >= 0, it is the precomputed hash code.
197 Otherwise, compute the hash code. */
200 cpp_install (pfile, name, len, type, value)
207 register HASHNODE *hp;
208 register int i, bucket;
209 register const U_CHAR *p;
215 while (is_idchar(*p))
220 hash = hashf (name, len) % HASHSIZE;
222 i = sizeof (HASHNODE) + len + 1;
223 hp = (HASHNODE *) xmalloc (i);
225 hp->bucket_hdr = &pfile->hashtab[bucket];
226 hp->next = pfile->hashtab[bucket];
227 pfile->hashtab[bucket] = hp;
229 if (hp->next != NULL)
233 hp->value.cpval = value;
234 hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
235 bcopy (name, hp->name, len);
241 macro_cleanup (pbuf, pfile)
243 cpp_reader *pfile ATTRIBUTE_UNUSED;
245 HASHNODE *macro = (HASHNODE *) pbuf->data;
246 if (macro->type == T_DISABLED)
247 macro->type = T_MACRO;
248 if (macro->type != T_MACRO || pbuf->buf != macro->value.defn->expansion)
254 /* Read a replacement list for a macro with parameters.
255 Build the DEFINITION structure.
256 Reads characters of text starting at BUF until END.
257 ARGLIST specifies the formal parameters to look for
258 in the text of the definition; NARGS is the number of args
259 in that list, or -1 for a macro name that wants no argument list.
260 MACRONAME is the macro name itself (so we can avoid recursive expansion)
261 and NAMELEN is its length in characters.
263 Note that comments, backslash-newlines, and leading white space
264 have already been deleted from the argument. */
267 collect_expansion (pfile, buf, limit, nargs, arglist)
271 struct arglist *arglist;
274 register U_CHAR *p, *lastp, *exp_p;
275 struct reflist *endpat = NULL;
276 /* Pointer to first nonspace after last ## seen. */
278 /* Pointer to first nonspace after last single-# seen. */
279 U_CHAR *stringify = 0;
281 int expected_delimiter = '\0';
283 /* Scan thru the replacement list, ignoring comments and quoted
284 strings, picking up on the macro calls. It does a linear search
285 thru the arg list on every potential symbol. Profiling might say
286 that something smarter should happen. */
290 cpp_ice (pfile, "limit < buf in collect_expansion");
291 limit = buf; /* treat it like a null defn */
294 /* Find the beginning of the trailing whitespace. */
296 while (p < limit && is_space(limit[-1]))
299 /* Allocate space for the text in the macro definition.
300 Leading and trailing whitespace chars need 2 bytes each.
301 Each other input char may or may not need 1 byte,
302 so this is an upper bound. The extra 5 are for invented
303 leading and trailing escape-marker and final null. */
304 maxsize = (sizeof (DEFINITION)
306 defn = (DEFINITION *) xcalloc (1, maxsize);
309 exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
314 /* Add one initial space escape-marker to prevent accidental
315 token-pasting (often removed by macroexpand). */
319 if (limit - p >= 2 && p[0] == '#' && p[1] == '#')
321 cpp_error (pfile, "`##' at start of macro definition");
325 /* Process the main body of the definition. */
329 register U_CHAR c = *p++;
333 if (!CPP_TRADITIONAL (pfile))
339 if (expected_delimiter != '\0')
341 if (c == expected_delimiter)
342 expected_delimiter = '\0';
345 expected_delimiter = c;
349 if (p < limit && expected_delimiter)
351 /* In a string, backslash goes through
352 and makes next char ordinary. */
358 /* # is ordinary inside a string. */
359 if (expected_delimiter)
361 if (p < limit && *p == '#')
363 /* ##: concatenate preceding and following tokens. */
364 /* Take out the first #, discard preceding whitespace. */
366 while (exp_p > lastp && is_hspace(exp_p[-1]))
368 /* Skip the second #. */
370 /* Discard following whitespace. */
371 SKIP_WHITE_SPACE (p);
374 cpp_error (pfile, "`##' at end of macro definition");
378 /* Single #: stringify following argument ref.
379 Don't leave the # in the expansion. */
381 SKIP_WHITE_SPACE (p);
382 if (p == limit || !is_idstart(*p)
383 || (*p == 'L' && p + 1 < limit && (p[1] == '\'' ||
386 "`#' operator is not followed by a macro argument name");
395 /* In -traditional mode, recognize arguments inside strings and
396 character constants, and ignore special properties of #.
397 Arguments inside strings are considered "stringified", but no
398 extra quote marks are supplied. */
403 if (expected_delimiter != '\0')
405 if (c == expected_delimiter)
406 expected_delimiter = '\0';
409 expected_delimiter = c;
413 /* Backslash quotes delimiters and itself,
414 but not macro args. */
415 if (expected_delimiter != 0 && p < limit
416 && (*p == expected_delimiter || *p == '\\'))
424 if (expected_delimiter != '\0')
425 /* No comments inside strings. */
429 /* If we find a comment that wasn't removed by
430 handle_directive, this must be -traditional.
431 So replace the comment with nothing at all. */
434 while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
441 /* Handle the start of a symbol. */
442 if (is_idchar(c) && nargs > 0)
444 U_CHAR *id_beg = p - 1;
448 while (p != limit && is_idchar(*p))
453 && !(id_len == 1 && c == 'L' && (*p == '\'' || *p == '"')))
455 register struct arglist *arg;
457 for (arg = arglist; arg != NULL; arg = arg->next)
459 struct reflist *tpat;
461 if (arg->name[0] == c
462 && arg->length == id_len
463 && strncmp (arg->name, id_beg, id_len) == 0)
465 if (expected_delimiter && CPP_OPTIONS
466 (pfile)->warn_stringify)
468 if (CPP_TRADITIONAL (pfile))
471 "macro argument `%.*s' is stringified.",
477 "macro arg `%.*s' would be stringified with -traditional.",
481 /* If ANSI, don't actually substitute
483 if (!CPP_TRADITIONAL (pfile) && expected_delimiter)
485 /* make a pat node for this arg and append it
486 to the end of the pat list */
487 tpat = (struct reflist *)
488 xmalloc (sizeof (struct reflist));
490 tpat->raw_before = concat == id_beg;
492 tpat->rest_args = arg->rest_args;
493 tpat->stringify = (CPP_TRADITIONAL (pfile)
494 ? expected_delimiter != '\0'
495 : stringify == id_beg);
498 defn->pattern = tpat;
503 tpat->argno = arg->argno;
504 tpat->nchars = exp_p - lastp;
506 register U_CHAR *p1 = p;
507 SKIP_WHITE_SPACE (p1);
508 if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
518 /* If this was not a macro arg, copy it into the expansion. */
521 register U_CHAR *lim1 = p;
525 if (stringify == id_beg)
527 "`#' operator should be followed by a macro argument name");
532 if (!CPP_TRADITIONAL (pfile) && expected_delimiter == 0)
534 /* If ANSI, put in a "\r " marker to prevent token pasting.
535 But not if "inside a string" (which in ANSI mode
536 happens only for -D option). */
543 defn->length = exp_p - defn->expansion;
545 /* Crash now if we overrun the allocated size. */
546 if (defn->length + 1 > maxsize)
550 /* This isn't worth the time it takes. */
551 /* give back excess storage */
552 defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
559 * special extension string that can be added to the last macro argument to
560 * allow it to absorb the "rest" of the arguments when expanded. Ex:
561 * #define wow(a, b...) process (b, a, b)
562 * { wow (1, 2, 3); } -> { process (2, 3, 1, 2, 3); }
563 * { wow (one, two); } -> { process (two, one, two); }
564 * if this "rest_arg" is used with the concat token '##' and if it is not
565 * supplied then the token attached to with ## will not be outputted. Ex:
566 * #define wow (a, b...) process (b ## , a, ## b)
567 * { wow (1, 2); } -> { process (2, 1, 2); }
568 * { wow (one); } -> { process (one); {
570 static char rest_extension[] = "...";
571 #define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1)
573 /* Create a DEFINITION node from a #define directive. Arguments are
577 create_definition (buf, limit, pfile)
581 U_CHAR *bp; /* temp ptr into input buffer */
582 U_CHAR *symname; /* remember where symbol name starts */
583 int sym_length; /* and how long it is */
587 CPP_BUFFER (pfile) ? CPP_BUFFER (pfile)->nominal_fname : "";
589 int arglengths = 0; /* Accumulate lengths of arg names
590 plus number of args. */
592 cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
596 while (is_hspace(*bp))
599 symname = bp; /* remember where it starts */
601 sym_length = check_macro_name (pfile, bp);
604 /* Lossage will occur if identifiers or control keywords are broken
605 across lines using backslash. This is not the right place to take
610 struct arglist *arg_ptrs = NULL;
614 SKIP_WHITE_SPACE (bp);
616 /* Loop over macro argument names. */
619 struct arglist *temp;
621 temp = (struct arglist *) alloca (sizeof (struct arglist));
623 temp->next = arg_ptrs;
624 temp->argno = argno++;
629 cpp_pedwarn (pfile, "another parameter follows `%s'",
632 if (!is_idstart(*bp))
633 cpp_pedwarn (pfile, "invalid character in macro parameter name");
635 /* Find the end of the arg name. */
636 while (is_idchar(*bp))
639 /* do we have a "special" rest-args extension here? */
640 if ((size_t) (limit - bp) > REST_EXTENSION_LENGTH
641 && !strncmp (rest_extension, bp, REST_EXTENSION_LENGTH))
648 temp->length = bp - temp->name;
650 bp += REST_EXTENSION_LENGTH;
651 arglengths += temp->length + 2;
652 SKIP_WHITE_SPACE (bp);
653 if (temp->length == 0 || (*bp != ',' && *bp != ')'))
656 "badly punctuated parameter list in `#define'");
662 SKIP_WHITE_SPACE (bp);
666 cpp_error (pfile, "unterminated parameter list in `#define'");
670 struct arglist *otemp;
672 for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
673 if (temp->length == otemp->length
674 && strncmp (temp->name, otemp->name, temp->length) == 0)
678 name = (U_CHAR *) alloca (temp->length + 1);
679 (void) strncpy (name, temp->name, temp->length);
680 name[temp->length] = '\0';
682 "duplicate argument name `%s' in `#define'",
689 ++bp; /* skip paren */
690 SKIP_WHITE_SPACE (bp);
691 /* now everything from bp before limit is the definition. */
692 defn = collect_expansion (pfile, bp, limit, argno, arg_ptrs);
693 defn->rest_args = rest_args;
695 /* Now set defn->argnames to the result of concatenating
696 the argument names in reverse order
697 with comma-space between them. */
698 defn->argnames = (U_CHAR *) xmalloc (arglengths + 1);
700 struct arglist *temp;
702 for (temp = arg_ptrs; temp; temp = temp->next)
704 bcopy (temp->name, &defn->argnames[i], temp->length);
708 defn->argnames[i++] = ',';
709 defn->argnames[i++] = ' ';
712 defn->argnames[i] = 0;
717 /* Simple expansion or empty definition. */
724 SKIP_WHITE_SPACE (bp);
727 /* Per C9x, missing white space after the name in a #define
728 of an object-like macro is always a constraint violation. */
730 "missing white space after `#define %.*s'",
731 sym_length, symname);
733 /* now everything from bp before limit is the definition. */
734 defn = collect_expansion (pfile, bp, limit, -1, NULL_PTR);
735 defn->argnames = (U_CHAR *) "";
742 mdef.symnam = symname;
743 mdef.symlen = sym_length;
753 * Parse a macro argument and append the info on PFILE's token_buffer.
754 * REST_ARGS means to absorb the rest of the args.
755 * Return nonzero to indicate a syntax error.
758 static enum cpp_token
759 macarg (pfile, rest_args)
764 enum cpp_token token;
766 /* Try to parse as much of the argument as exists at this
767 input stack level. */
770 token = cpp_get_token (pfile);
776 /* If we've hit end of file, it's an error (reported by caller).
777 Ditto if it's the end of cpp_expand_to_buffer text.
778 If we've hit end of macro, just continue. */
779 if (!CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
790 /* if we've returned to lowest level and
791 we aren't absorbing all args */
792 if (paren == 0 && rest_args == 0)
796 /* Remove ',' or ')' from argument buffer. */
797 CPP_ADJUST_WRITTEN (pfile, -1);
811 time_t t = time ((time_t *) 0);
812 pfile->timebuf = localtime (&t);
814 return pfile->timebuf;
817 static const char * const monthnames[] =
819 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
820 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
824 * expand things like __FILE__. Place the expansion into the output
825 * buffer *without* rescanning.
829 special_symbol (hp, pfile)
842 ip = CPP_BUFFER (pfile);
843 if (hp->type == T_BASE_FILE)
845 while (CPP_PREV_BUFFER (ip) != CPP_NULL_BUFFER (pfile))
846 ip = CPP_PREV_BUFFER (ip);
850 ip = CPP_BUFFER (pfile);
851 while (!ip->nominal_fname && ip != CPP_NULL_BUFFER (pfile))
852 ip = CPP_PREV_BUFFER (ip);
855 buf = ip->nominal_fname;
859 CPP_RESERVE (pfile, 3 + 4 * strlen (buf));
860 quote_string (pfile, buf);
864 case T_INCLUDE_LEVEL:
866 int true_indepth = 0;
867 ip = CPP_BUFFER (pfile);
868 for (; ip != CPP_NULL_BUFFER (pfile); ip = CPP_PREV_BUFFER (ip))
869 if (ip->fname != NULL)
872 CPP_RESERVE (pfile, 10);
873 sprintf (CPP_PWRITTEN (pfile), "%d", true_indepth);
874 CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
879 len = strlen (version_string);
880 CPP_RESERVE (pfile, 3 + len);
881 CPP_PUTC_Q (pfile, '"');
882 CPP_PUTS_Q (pfile, version_string, len);
883 CPP_PUTC_Q (pfile, '"');
884 CPP_NUL_TERMINATE_Q (pfile);
888 buf = hp->value.cpval;
895 CPP_RESERVE (pfile, len + 1);
896 CPP_PUTS_Q (pfile, buf, len);
897 CPP_NUL_TERMINATE_Q (pfile);
901 CPP_RESERVE (pfile, 2);
902 #ifdef STDC_0_IN_SYSTEM_HEADERS
903 ip = CPP_BUFFER (pfile);
904 while (!ip->nominal_fname && ip != CPP_NULL_BUFFER (pfile))
905 ip = CPP_PREV_BUFFER (ip);
906 if (ip->system_header_p
907 && !cpp_lookup (pfile, (U_CHAR *) "__STRICT_ANSI__", 15))
908 CPP_PUTC_Q (pfile, '0');
911 CPP_PUTC_Q (pfile, '1');
912 CPP_NUL_TERMINATE_Q (pfile);
918 cpp_buf_line_and_col (cpp_file_buffer (pfile), &line, NULL);
920 CPP_RESERVE (pfile, 10);
921 sprintf (CPP_PWRITTEN (pfile), "%ld", line);
922 CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
931 CPP_RESERVE (pfile, 20);
932 timebuf = timestamp (pfile);
933 if (hp->type == T_DATE)
934 sprintf (CPP_PWRITTEN (pfile), "\"%s %2d %4d\"",
935 monthnames[timebuf->tm_mon],
936 timebuf->tm_mday, timebuf->tm_year + 1900);
938 sprintf (CPP_PWRITTEN (pfile), "\"%02d:%02d:%02d\"",
939 timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
941 CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
946 cpp_error (pfile, "attempt to use poisoned `%s'.", hp->name);
947 CPP_RESERVE (pfile, 1);
948 CPP_PUTC_Q (pfile, '0');
949 CPP_NUL_TERMINATE_Q (pfile);
953 cpp_ice (pfile, "invalid special hash type");
958 /* Expand a macro call.
959 HP points to the symbol that is the macro being called.
960 Put the result of expansion onto the input stack
961 so that subsequent input by our caller will use it.
963 If macro wants arguments, caller has already verified that
964 an argument list follows; arguments come from the input stack. */
967 macroexpand (pfile, hp)
973 register U_CHAR *xbuf;
974 long start_line, start_column;
976 struct argdata *args = 0;
977 long old_written = CPP_WRITTEN (pfile);
978 int rest_args, rest_zero = 0;
981 cpp_buf_line_and_col (cpp_file_buffer (pfile), &start_line, &start_column);
983 /* Check for and handle special symbols. */
984 if (hp->type != T_MACRO)
986 special_symbol (hp, pfile);
987 xbuf_len = CPP_WRITTEN (pfile) - old_written;
988 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
989 CPP_SET_WRITTEN (pfile, old_written);
990 bcopy (CPP_PWRITTEN (pfile), xbuf, xbuf_len + 1);
991 push_macro_expansion (pfile, xbuf, xbuf_len, hp);
992 CPP_BUFFER (pfile)->has_escapes = 1;
996 defn = hp->value.defn;
998 pfile->output_escapes++;
1002 enum cpp_token token;
1004 args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
1006 for (i = 0; i < nargs; i++)
1008 args[i].raw = args[i].expanded = 0;
1009 args[i].raw_length = 0;
1010 args[i].expand_length = args[i].stringified_length = -1;
1013 /* Parse all the macro args that are supplied. I counts them.
1014 The first NARGS args are stored in ARGS.
1015 The rest are discarded. If rest_args is set then we assume
1016 macarg absorbed the rest of the args. */
1020 /* Skip over the opening parenthesis. */
1021 CPP_OPTIONS (pfile)->discard_comments++;
1022 CPP_OPTIONS (pfile)->no_line_commands++;
1023 pfile->no_macro_expand++;
1024 pfile->no_directives++;
1026 token = cpp_get_non_space_token (pfile);
1027 if (token != CPP_LPAREN)
1028 cpp_ice (pfile, "macroexpand: unexpected token %d (wanted LPAREN)",
1030 CPP_ADJUST_WRITTEN (pfile, -1);
1037 if (i < nargs || (nargs == 0 && i == 0))
1039 /* if we are working on last arg which absorbs rest of args... */
1040 if (i == nargs - 1 && defn->rest_args)
1042 args[i].raw = CPP_WRITTEN (pfile);
1043 token = macarg (pfile, rest_args);
1044 args[i].raw_length = CPP_WRITTEN (pfile) - args[i].raw;
1047 token = macarg (pfile, 0);
1048 if (token == CPP_EOF || token == CPP_POP)
1049 cpp_error_with_line (pfile, start_line, start_column,
1050 "unterminated macro call");
1053 while (token == CPP_COMMA);
1054 CPP_OPTIONS (pfile)->discard_comments--;
1055 CPP_OPTIONS (pfile)->no_line_commands--;
1056 pfile->no_macro_expand--;
1057 pfile->no_directives--;
1058 if (token != CPP_RPAREN)
1061 /* If we got one arg but it was just whitespace, call that 0 args. */
1064 register U_CHAR *bp = ARG_BASE + args[0].raw;
1065 register U_CHAR *lim = bp + args[0].raw_length;
1066 /* cpp.texi says for foo ( ) we provide one argument.
1067 However, if foo wants just 0 arguments, treat this as 0. */
1069 while (bp != lim && is_space(*bp))
1075 /* Don't output an error message if we have already output one for
1076 a parse error above. */
1078 if (nargs == 0 && i > 0)
1080 cpp_error (pfile, "arguments given to macro `%s'", hp->name);
1084 /* traditional C allows foo() if foo wants one argument. */
1085 if (nargs == 1 && i == 0 && CPP_TRADITIONAL (pfile))
1087 /* the rest args token is allowed to absorb 0 tokens */
1088 else if (i == nargs - 1 && defn->rest_args)
1091 cpp_error (pfile, "macro `%s' used without args", hp->name);
1093 cpp_error (pfile, "macro `%s' used with just one arg", hp->name);
1095 cpp_error (pfile, "macro `%s' used with only %d args",
1101 "macro `%s' used with too many (%d) args", hp->name, i);
1105 /* If macro wants zero args, we parsed the arglist for checking only.
1106 Read directly from the macro definition. */
1109 xbuf = defn->expansion;
1110 xbuf_len = defn->length;
1114 register U_CHAR *exp = defn->expansion;
1115 register int offset; /* offset in expansion,
1116 copied a piece at a time */
1117 register int totlen; /* total amount of exp buffer filled so far */
1119 register struct reflist *ap, *last_ap;
1121 /* Macro really takes args. Compute the expansion of this call. */
1123 /* Compute length in characters of the macro's expansion.
1124 Also count number of times each arg is used. */
1125 xbuf_len = defn->length;
1126 for (ap = defn->pattern; ap != NULL; ap = ap->next)
1130 register struct argdata *arg = &args[ap->argno];
1131 /* Stringify if it hasn't already been */
1132 if (arg->stringified_length < 0)
1134 int arglen = arg->raw_length;
1138 /* Initially need_space is -1. Otherwise, 1 means the
1139 previous character was a space, but we suppressed it;
1140 0 means the previous character was a non-space. */
1141 int need_space = -1;
1143 arg->stringified = CPP_WRITTEN (pfile);
1144 if (!CPP_TRADITIONAL (pfile))
1145 CPP_PUTC (pfile, '\"'); /* insert beginning quote */
1146 for (; i < arglen; i++)
1148 c = (ARG_BASE + arg->raw)[i];
1152 /* Delete "\r " and "\r-" escapes. */
1158 /* Internal sequences of whitespace are
1159 replaced by one space except within
1160 a string or char token. */
1161 else if (is_space(c))
1163 if (need_space == 0)
1167 else if (need_space > 0)
1168 CPP_PUTC (pfile, ' ');
1183 else if (c == '\"' || c == '\'')
1187 /* Escape these chars */
1188 if (c == '\"' || (in_string && c == '\\'))
1189 CPP_PUTC (pfile, '\\');
1191 CPP_PUTC (pfile, c);
1194 CPP_RESERVE (pfile, 4);
1195 sprintf ((char *) CPP_PWRITTEN (pfile), "\\%03o",
1197 CPP_ADJUST_WRITTEN (pfile, 4);
1200 if (!CPP_TRADITIONAL (pfile))
1201 CPP_PUTC (pfile, '\"'); /* insert ending quote */
1202 arg->stringified_length
1203 = CPP_WRITTEN (pfile) - arg->stringified;
1205 xbuf_len += args[ap->argno].stringified_length;
1207 else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
1208 /* Add 4 for two \r-space markers to prevent
1209 token concatenation. */
1210 xbuf_len += args[ap->argno].raw_length + 4;
1213 /* We have an ordinary (expanded) occurrence of the arg.
1214 So compute its expansion, if we have not already. */
1215 if (args[ap->argno].expand_length < 0)
1217 args[ap->argno].expanded = CPP_WRITTEN (pfile);
1218 cpp_expand_to_buffer (pfile,
1219 ARG_BASE + args[ap->argno].raw,
1220 args[ap->argno].raw_length);
1222 args[ap->argno].expand_length
1223 = CPP_WRITTEN (pfile) - args[ap->argno].expanded;
1226 /* Add 4 for two \r-space markers to prevent
1227 token concatenation. */
1228 xbuf_len += args[ap->argno].expand_length + 4;
1232 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
1234 /* Generate in XBUF the complete expansion
1235 with arguments substituted in.
1236 TOTLEN is the total size generated so far.
1237 OFFSET is the index in the definition
1238 of where we are copying from. */
1239 offset = totlen = 0;
1240 for (last_ap = NULL, ap = defn->pattern; ap != NULL;
1241 last_ap = ap, ap = ap->next)
1243 register struct argdata *arg = &args[ap->argno];
1244 int count_before = totlen;
1246 /* Add chars to XBUF. */
1247 for (i = 0; i < ap->nchars; i++, offset++)
1248 xbuf[totlen++] = exp[offset];
1250 /* If followed by an empty rest arg with concatenation,
1251 delete the last run of nonwhite chars. */
1252 if (rest_zero && totlen > count_before
1253 && ((ap->rest_args && ap->raw_before)
1254 || (last_ap != NULL && last_ap->rest_args
1255 && last_ap->raw_after)))
1257 /* Delete final whitespace. */
1258 while (totlen > count_before && is_space(xbuf[totlen - 1]))
1261 /* Delete the nonwhites before them. */
1262 while (totlen > count_before && !is_space(xbuf[totlen - 1]))
1266 if (ap->stringify != 0)
1268 bcopy (ARG_BASE + arg->stringified,
1269 xbuf + totlen, arg->stringified_length);
1270 totlen += arg->stringified_length;
1272 else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
1274 U_CHAR *p1 = ARG_BASE + arg->raw;
1275 U_CHAR *l1 = p1 + arg->raw_length;
1278 /* Arg is concatenated before: delete leading whitespace,
1279 whitespace markers, and no-reexpansion markers. */
1282 if (is_space(p1[0]))
1284 else if (p1[0] == '\r')
1292 /* Arg is concatenated after: delete trailing whitespace,
1293 whitespace markers, and no-reexpansion markers. */
1296 if (is_space(l1[-1]))
1298 else if (l1[-1] == '\r')
1300 else if (l1[-1] == '-')
1302 if (l1 != p1 + 1 && l1[-2] == '\r')
1312 /* Delete any no-reexpansion marker that precedes
1313 an identifier at the beginning of the argument. */
1314 if (p1[0] == '\r' && p1[1] == '-')
1317 bcopy (p1, xbuf + totlen, l1 - p1);
1322 U_CHAR *expanded = ARG_BASE + arg->expanded;
1323 if (!ap->raw_before && totlen > 0 && arg->expand_length
1324 && !CPP_TRADITIONAL (pfile)
1325 && unsafe_chars (xbuf[totlen - 1], expanded[0]))
1327 xbuf[totlen++] = '\r';
1328 xbuf[totlen++] = ' ';
1331 bcopy (expanded, xbuf + totlen, arg->expand_length);
1332 totlen += arg->expand_length;
1334 if (!ap->raw_after && totlen > 0 && offset < defn->length
1335 && !CPP_TRADITIONAL (pfile)
1336 && unsafe_chars (xbuf[totlen - 1], exp[offset]))
1338 xbuf[totlen++] = '\r';
1339 xbuf[totlen++] = ' ';
1343 if (totlen > xbuf_len)
1345 cpp_ice (pfile, "buffer overrun in macroexpand");
1350 /* if there is anything left of the definition
1351 after handling the arg list, copy that in too. */
1353 for (i = offset; i < defn->length; i++)
1355 /* if we've reached the end of the macro */
1358 if (!(rest_zero && last_ap != NULL && last_ap->rest_args
1359 && last_ap->raw_after))
1360 xbuf[totlen++] = exp[i];
1368 pfile->output_escapes--;
1370 /* Now put the expansion on the input stack
1371 so our caller will commence reading from it. */
1372 push_macro_expansion (pfile, xbuf, xbuf_len, hp);
1373 CPP_BUFFER (pfile)->has_escapes = 1;
1375 /* Pop the space we've used in the token_buffer for argument expansion. */
1376 CPP_SET_WRITTEN (pfile, old_written);
1378 /* Recursive macro use sometimes works traditionally.
1379 #define foo(x,y) bar (x (y,0), y)
1382 if (!CPP_TRADITIONAL (pfile))
1383 hp->type = T_DISABLED;
1386 /* Return 1 iff a token ending in C1 followed directly by a token C2
1387 could cause mis-tokenization. */
1390 unsafe_chars (c1, c2)
1396 if (c2 == c1 || c2 == '=')
1400 case 'e': case 'E': case 'p': case 'P':
1401 if (c2 == '-' || c2 == '+')
1402 return 1; /* could extend a pre-processing number */
1406 if (c2 == '\'' || c2 == '\"')
1407 return 1; /* Could turn into L"xxx" or L'xxx'. */
1410 case '.': case '0': case '1': case '2': case '3':
1411 case '4': case '5': case '6': case '7': case '8': case '9':
1412 case '_': case 'a': case 'b': case 'c': case 'd': case 'f':
1413 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
1414 case 'm': case 'n': case 'o': case 'q': case 'r': case 's':
1415 case 't': case 'u': case 'v': case 'w': case 'x': case 'y':
1416 case 'z': case 'A': case 'B': case 'C': case 'D': case 'F':
1417 case 'G': case 'H': case 'I': case 'J': case 'K': case 'M':
1418 case 'N': case 'O': case 'Q': case 'R': case 'S': case 'T':
1419 case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z':
1421 /* We're in the middle of either a name or a pre-processing number. */
1422 return (is_idchar(c2) || c2 == '.');
1424 case '<': case '>': case '!': case '%': case '#': case ':':
1425 case '^': case '&': case '|': case '*': case '/': case '=':
1426 return (c2 == c1 || c2 == '=');
1432 push_macro_expansion (pfile, xbuf, xbuf_len, hp)
1434 register U_CHAR *xbuf;
1438 register cpp_buffer *mbuf = cpp_push_buffer (pfile, xbuf, xbuf_len);
1441 mbuf->cleanup = macro_cleanup;
1444 /* The first chars of the expansion should be a "\r " added by
1445 collect_expansion. This is to prevent accidental token-pasting
1446 between the text preceding the macro invocation, and the macro
1449 We would like to avoid adding unneeded spaces (for the sake of
1450 tools that use cpp, such as imake). In some common cases we can
1451 tell that it is safe to omit the space.
1453 The character before the macro invocation cannot have been an
1454 idchar (or else it would have been pasted with the idchars of
1455 the macro name). Therefore, if the first non-space character
1456 of the expansion is an idchar, we do not need the extra space
1457 to prevent token pasting.
1459 Also, we don't need the extra space if the first char is '(',
1460 or some other (less common) characters. */
1462 if (xbuf[0] == '\r' && xbuf[1] == ' '
1463 && (is_idchar(xbuf[2]) || xbuf[2] == '(' || xbuf[2] == '\''
1464 || xbuf[2] == '\"'))
1467 /* Likewise, avoid the extra space at the end of the macro expansion
1468 if this is safe. We can do a better job here since we can know
1469 what the next char will be. */
1471 && mbuf->rlimit[-2] == '\r'
1472 && mbuf->rlimit[-1] == ' ')
1474 int c1 = mbuf->rlimit[-3];
1475 int c2 = CPP_BUF_PEEK (CPP_PREV_BUFFER (CPP_BUFFER (pfile)));
1476 if (c2 == EOF || !unsafe_chars (c1, c2))
1481 /* Return zero if two DEFINITIONs are isomorphic. */
1484 compare_defs (pfile, d1, d2)
1486 DEFINITION *d1, *d2;
1488 register struct reflist *a1, *a2;
1489 register U_CHAR *p1 = d1->expansion;
1490 register U_CHAR *p2 = d2->expansion;
1493 if (d1->nargs != d2->nargs)
1495 if (CPP_PEDANTIC (pfile)
1496 && strcmp ((char *) d1->argnames, (char *) d2->argnames))
1498 for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
1499 a1 = a1->next, a2 = a2->next)
1501 if (!((a1->nchars == a2->nchars && !strncmp (p1, p2, a1->nchars))
1502 || !comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
1503 || a1->argno != a2->argno
1504 || a1->stringify != a2->stringify
1505 || a1->raw_before != a2->raw_before
1506 || a1->raw_after != a2->raw_after)
1515 return comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
1516 p2, d2->length - (p2 - d2->expansion), 1);
1519 /* Return 1 if two parts of two macro definitions are effectively different.
1520 One of the parts starts at BEG1 and has LEN1 chars;
1521 the other has LEN2 chars at BEG2.
1522 Any sequence of whitespace matches any other sequence of whitespace.
1523 FIRST means these parts are the first of a macro definition;
1524 so ignore leading whitespace entirely.
1525 LAST means these parts are the last of a macro definition;
1526 so ignore trailing whitespace entirely. */
1529 comp_def_part (first, beg1, len1, beg2, len2, last)
1531 U_CHAR *beg1, *beg2;
1535 register U_CHAR *end1 = beg1 + len1;
1536 register U_CHAR *end2 = beg2 + len2;
1539 while (beg1 != end1 && is_space(*beg1))
1541 while (beg2 != end2 && is_space(*beg2))
1546 while (beg1 != end1 && is_space(end1[-1]))
1548 while (beg2 != end2 && is_space(end2[-1]))
1551 while (beg1 != end1 && beg2 != end2)
1553 if (is_space(*beg1) && is_space(*beg2))
1555 while (beg1 != end1 && is_space(*beg1))
1557 while (beg2 != end2 && is_space(*beg2))
1560 else if (*beg1 == *beg2)
1568 return (beg1 != end1) || (beg2 != end2);
1571 /* Dump the definition of macro MACRO on stdout. The format is suitable
1572 to be read back in again. */
1575 dump_definition (pfile, sym, len, defn)
1581 CPP_RESERVE (pfile, len + sizeof "#define ");
1582 CPP_PUTS_Q (pfile, "#define ", sizeof "#define " -1);
1583 CPP_PUTS_Q (pfile, sym, len);
1585 if (defn->nargs == -1)
1587 CPP_PUTC_Q (pfile, ' ');
1589 /* The first and last two characters of a macro expansion are
1590 always "\r "; this needs to be trimmed out.
1591 So we need length-4 chars of space, plus one for the NUL. */
1592 CPP_RESERVE (pfile, defn->length - 4 + 1);
1593 CPP_PUTS_Q (pfile, defn->expansion + 2, defn->length - 4);
1594 CPP_NUL_TERMINATE_Q (pfile);
1599 unsigned char *argnames = (unsigned char *) xstrdup (defn->argnames);
1600 unsigned char **argv = (unsigned char **) alloca (defn->nargs *
1602 int *argl = (int *) alloca (defn->nargs * sizeof(int));
1606 /* First extract the argument list. */
1612 while (*x != ',' && *x != '\0') x++;
1613 argl[i] = x - argv[i];
1617 x += 2; /* skip the space after the comma */
1621 /* Now print out the argument list. */
1622 CPP_PUTC_Q (pfile, '(');
1623 for (i = 0; i < defn->nargs; i++)
1625 CPP_RESERVE (pfile, argl[i] + 2);
1626 CPP_PUTS_Q (pfile, argv[i], argl[i]);
1627 if (i < defn->nargs-1)
1628 CPP_PUTS_Q (pfile, ", ", 2);
1631 if (defn->rest_args)
1632 CPP_PUTS (pfile, "...) ", 5);
1634 CPP_PUTS (pfile, ") ", 2);
1636 /* Now the definition. */
1637 x = defn->expansion;
1638 for (r = defn->pattern; r; r = r->next)
1641 if (*x == '\r') x += 2, i -= 2;
1642 /* i chars for macro text, plus the length of the macro
1643 argument name, plus one for a stringify marker, plus two for
1644 each concatenation marker. */
1646 i + argl[r->argno] + r->stringify
1647 + (r->raw_before + r->raw_after) * 2);
1649 if (i > 0) CPP_PUTS_Q (pfile, x, i);
1651 CPP_PUTS_Q (pfile, "##", 2);
1653 CPP_PUTC_Q (pfile, '#');
1654 CPP_PUTS_Q (pfile, argv[r->argno], argl[r->argno]);
1655 if (r->raw_after && !(r->next && r->next->nchars == 0
1656 && r->next->raw_before))
1657 CPP_PUTS_Q (pfile, "##", 2);
1662 i = defn->length - (x - defn->expansion) - 2;
1663 if (*x == '\r') x += 2, i -= 2;
1664 if (i > 0) CPP_PUTS (pfile, x, i);
1665 CPP_NUL_TERMINATE (pfile);