1 /* Part of CPP library. (Macro handling.)
2 Copyright (C) 1986, 87, 89, 92-95, 1996, 1998 Free Software Foundation, Inc.
3 Written by Per Bothner, 1994.
4 Based on CCCP program by Paul Rubin, June 1986
5 Adapted to ANSI C, Richard Stallman, Jan 1987
7 This program is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 2, or (at your option) any
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 In other words, you are welcome to use, share and improve this program.
22 You are forbidden to forbid anyone else to use, share and improve
23 what you give them. Help stamp out software-hoarding! */
30 static int comp_def_part PARAMS ((int, U_CHAR *, int, U_CHAR *,
32 static int change_newlines PARAMS ((U_CHAR *, int));
33 static void push_macro_expansion PARAMS ((cpp_reader *,
34 U_CHAR *, int, HASHNODE *));
35 static int unsafe_chars PARAMS ((int, int));
37 #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
38 #define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->data != NULL)
39 #define FORWARD(N) CPP_FORWARD (CPP_BUFFER (pfile), (N))
41 extern char *version_string;
43 /* The arglist structure is built by create_definition to tell
44 collect_expansion where the argument names begin. That
45 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
46 would contain pointers to the strings x, y, and z.
47 collect_expansion would then build a DEFINITION node,
48 with reflist nodes pointing to the places x, y, and z had
49 appeared. So the arglist is just convenience data passed
50 between these two routines. It is not kept around after
51 the current #define has been processed and entered into the
63 /* This structure represents one parsed argument in a macro call.
64 `raw' points to the argument text as written (`raw_length' is its length).
65 `expanded' points to the argument's macro-expansion
66 (its length is `expand_length').
67 `stringified_length' is the length the argument would have
69 `use_count' is the number of times this macro arg is substituted
70 into the macro. If the actual use count exceeds 10,
71 the value stored is 10. */
73 /* raw and expanded are relative to ARG_BASE */
74 #define ARG_BASE ((pfile)->token_buffer)
78 /* Strings relative to pfile->token_buffer */
79 long raw, expanded, stringified;
80 int raw_length, expand_length;
81 int stringified_length;
87 /* Return hash function on name. must be compatible with the one
88 computed a step at a time, elsewhere */
91 hashf (name, len, hashsize)
92 register const U_CHAR *name;
99 r = HASHSTEP (r, *name++);
101 return MAKE_POS (r) % hashsize;
104 /* Find the most recent hash node for name "name" (ending with first
105 non-identifier char) installed by cpp_install
107 If LEN is >= 0, it is the length of the name.
108 Otherwise, compute the length by scanning the entire name.
110 If HASH is >= 0, it is the precomputed hash code.
111 Otherwise, compute the hash code. */
114 cpp_lookup (pfile, name, len, hash)
115 cpp_reader *pfile ATTRIBUTE_UNUSED;
120 register const U_CHAR *bp;
121 register HASHNODE *bucket;
125 for (bp = name; is_idchar[*bp]; bp++);
130 hash = hashf (name, len, HASHSIZE);
132 bucket = pfile->hashtab[hash];
135 if (bucket->length == len && strncmp (bucket->name, name, len) == 0)
137 bucket = bucket->next;
139 return (HASHNODE *) 0;
143 * Delete a hash node. Some weirdness to free junk from macros.
144 * More such weirdness will have to be added if you define more hash
145 * types that need it.
148 /* Note that the DEFINITION of a macro is removed from the hash table
149 but its storage is not freed. This would be a storage leak
150 except that it is not reasonable to keep undefining and redefining
151 large numbers of macros many times.
152 In any case, this is necessary, because a macro can be #undef'd
153 in the middle of reading the arguments to a call to it.
154 If #undef freed the DEFINITION, that would crash. */
161 if (hp->prev != NULL)
162 hp->prev->next = hp->next;
163 if (hp->next != NULL)
164 hp->next->prev = hp->prev;
166 /* make sure that the bucket chain header that
167 the deleted guy was on points to the right thing afterwards. */
168 if (hp == *hp->bucket_hdr)
169 *hp->bucket_hdr = hp->next;
171 if (hp->type == T_MACRO)
173 DEFINITION *d = hp->value.defn;
174 struct reflist *ap, *nextap;
176 for (ap = d->pattern; ap != NULL; ap = nextap)
182 free (d->args.argnames);
189 /* Install a name in the main hash table, even if it is already there.
190 Name stops with first non alphanumeric, except leading '#'.
191 Caller must check against redefinition if that is desired.
192 delete_macro () removes things installed by cpp_install () in fifo order.
193 this is important because of the `defined' special symbol used
194 in #if, and also if pushdef/popdef directives are ever implemented.
196 If LEN is >= 0, it is the length of the name.
197 Otherwise, compute the length by scanning the entire name.
199 If HASH is >= 0, it is the precomputed hash code.
200 Otherwise, compute the hash code. */
203 cpp_install (pfile, name, len, type, value, hash)
211 register HASHNODE *hp;
212 register int i, bucket;
218 while (is_idchar[*p])
224 hash = hashf (name, len, HASHSIZE);
226 i = sizeof (HASHNODE) + len + 1;
227 hp = (HASHNODE *) xmalloc (i);
229 hp->bucket_hdr = &pfile->hashtab[bucket];
230 hp->next = pfile->hashtab[bucket];
231 pfile->hashtab[bucket] = hp;
233 if (hp->next != NULL)
237 hp->value.cpval = value;
238 hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
239 bcopy (name, hp->name, len);
245 macro_cleanup (pbuf, pfile)
247 cpp_reader *pfile ATTRIBUTE_UNUSED;
249 HASHNODE *macro = (HASHNODE *) pbuf->data;
250 if (macro->type == T_DISABLED)
251 macro->type = T_MACRO;
252 if (macro->type != T_MACRO || pbuf->buf != macro->value.defn->expansion)
258 /* Read a replacement list for a macro with parameters.
259 Build the DEFINITION structure.
260 Reads characters of text starting at BUF until END.
261 ARGLIST specifies the formal parameters to look for
262 in the text of the definition; NARGS is the number of args
263 in that list, or -1 for a macro name that wants no argument list.
264 MACRONAME is the macro name itself (so we can avoid recursive expansion)
265 and NAMELEN is its length in characters.
267 Note that comments, backslash-newlines, and leading white space
268 have already been deleted from the argument. */
271 collect_expansion (pfile, buf, limit, nargs, arglist)
275 struct arglist *arglist;
278 register U_CHAR *p, *lastp, *exp_p;
279 struct reflist *endpat = NULL;
280 /* Pointer to first nonspace after last ## seen. */
282 /* Pointer to first nonspace after last single-# seen. */
283 U_CHAR *stringify = 0;
285 int expected_delimiter = '\0';
287 /* Scan thru the replacement list, ignoring comments and quoted
288 strings, picking up on the macro calls. It does a linear search
289 thru the arg list on every potential symbol. Profiling might say
290 that something smarter should happen. */
295 /* Find the beginning of the trailing whitespace. */
297 while (p < limit && is_space[limit[-1]])
300 /* Allocate space for the text in the macro definition.
301 Leading and trailing whitespace chars need 2 bytes each.
302 Each other input char may or may not need 1 byte,
303 so this is an upper bound. The extra 5 are for invented
304 leading and trailing newline-marker and final null. */
305 maxsize = (sizeof (DEFINITION)
307 /* Occurrences of '@' get doubled, so allocate extra space for them. */
311 defn = (DEFINITION *) xcalloc (1, maxsize);
314 exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
319 /* Add one initial space escape-marker to prevent accidental
320 token-pasting (often removed by macroexpand). */
324 if (limit - p >= 2 && p[0] == '#' && p[1] == '#')
326 cpp_error (pfile, "`##' at start of macro definition");
330 /* Process the main body of the definition. */
334 register U_CHAR c = *p++;
338 if (!CPP_TRADITIONAL (pfile))
344 if (expected_delimiter != '\0')
346 if (c == expected_delimiter)
347 expected_delimiter = '\0';
350 expected_delimiter = c;
354 if (p < limit && expected_delimiter)
356 /* In a string, backslash goes through
357 and makes next char ordinary. */
363 /* An '@' in a string or character constant stands for itself,
364 and does not need to be escaped. */
365 if (!expected_delimiter)
370 /* # is ordinary inside a string. */
371 if (expected_delimiter)
373 if (p < limit && *p == '#')
375 /* ##: concatenate preceding and following tokens. */
376 /* Take out the first #, discard preceding whitespace. */
378 while (exp_p > lastp && is_hor_space[exp_p[-1]])
380 /* Skip the second #. */
382 /* Discard following whitespace. */
383 SKIP_WHITE_SPACE (p);
386 cpp_error (pfile, "`##' at end of macro definition");
390 /* Single #: stringify following argument ref.
391 Don't leave the # in the expansion. */
393 SKIP_WHITE_SPACE (p);
394 if (p == limit || !is_idstart[*p]
395 || (*p == 'L' && p + 1 < limit && (p[1] == '\'' ||
398 "`#' operator is not followed by a macro argument name");
407 /* In -traditional mode, recognize arguments inside strings and
408 character constants, and ignore special properties of #.
409 Arguments inside strings are considered "stringified", but no
410 extra quote marks are supplied. */
415 if (expected_delimiter != '\0')
417 if (c == expected_delimiter)
418 expected_delimiter = '\0';
421 expected_delimiter = c;
425 /* Backslash quotes delimiters and itself,
426 but not macro args. */
427 if (expected_delimiter != 0 && p < limit
428 && (*p == expected_delimiter || *p == '\\'))
436 if (expected_delimiter != '\0')
437 /* No comments inside strings. */
441 /* If we find a comment that wasn't removed by
442 handle_directive, this must be -traditional.
443 So replace the comment with nothing at all. */
446 while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
449 /* Mark this as a concatenation-point,
450 as if it had been ##. */
458 /* Handle the start of a symbol. */
459 if (is_idchar[c] && nargs > 0)
461 U_CHAR *id_beg = p - 1;
465 while (p != limit && is_idchar[*p])
470 && !(id_len == 1 && c == 'L' && (*p == '\'' || *p == '"')))
472 register struct arglist *arg;
474 for (arg = arglist; arg != NULL; arg = arg->next)
476 struct reflist *tpat;
478 if (arg->name[0] == c
479 && arg->length == id_len
480 && strncmp (arg->name, id_beg, id_len) == 0)
482 if (expected_delimiter && CPP_OPTIONS
483 (pfile)->warn_stringify)
485 if (CPP_TRADITIONAL (pfile))
488 "macro argument `%.*s' is stringified.",
494 "macro arg `%.*s' would be stringified with -traditional.",
498 /* If ANSI, don't actually substitute
500 if (!CPP_TRADITIONAL (pfile) && expected_delimiter)
502 /* make a pat node for this arg and append it
503 to the end of the pat list */
504 tpat = (struct reflist *)
505 xmalloc (sizeof (struct reflist));
507 tpat->raw_before = concat == id_beg;
509 tpat->rest_args = arg->rest_args;
510 tpat->stringify = (CPP_TRADITIONAL (pfile)
511 ? expected_delimiter != '\0'
512 : stringify == id_beg);
515 defn->pattern = tpat;
520 tpat->argno = arg->argno;
521 tpat->nchars = exp_p - lastp;
523 register U_CHAR *p1 = p;
524 SKIP_WHITE_SPACE (p1);
525 if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
535 /* If this was not a macro arg, copy it into the expansion. */
538 register U_CHAR *lim1 = p;
542 if (stringify == id_beg)
544 "`#' operator should be followed by a macro argument name");
549 if (!CPP_TRADITIONAL (pfile) && expected_delimiter == 0)
551 /* If ANSI, put in a "@ " marker to prevent token pasting.
552 But not if "inside a string" (which in ANSI mode
553 happens only for -D option). */
560 defn->length = exp_p - defn->expansion;
562 /* Crash now if we overrun the allocated size. */
563 if (defn->length + 1 > maxsize)
567 /* This isn't worth the time it takes. */
568 /* give back excess storage */
569 defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
576 * special extension string that can be added to the last macro argument to
577 * allow it to absorb the "rest" of the arguments when expanded. Ex:
578 * #define wow(a, b...) process (b, a, b)
579 * { wow (1, 2, 3); } -> { process (2, 3, 1, 2, 3); }
580 * { wow (one, two); } -> { process (two, one, two); }
581 * if this "rest_arg" is used with the concat token '##' and if it is not
582 * supplied then the token attached to with ## will not be outputted. Ex:
583 * #define wow (a, b...) process (b ## , a, ## b)
584 * { wow (1, 2); } -> { process (2, 1, 2); }
585 * { wow (one); } -> { process (one); {
587 static char rest_extension[] = "...";
588 #define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1)
590 /* Create a DEFINITION node from a #define directive. Arguments are
594 create_definition (buf, limit, pfile, predefinition)
599 U_CHAR *bp; /* temp ptr into input buffer */
600 U_CHAR *symname; /* remember where symbol name starts */
601 int sym_length; /* and how long it is */
604 char *file = CPP_BUFFER (pfile) ? CPP_BUFFER (pfile)->nominal_fname : "";
606 int arglengths = 0; /* Accumulate lengths of arg names
607 plus number of args. */
609 cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
613 while (is_hor_space[*bp])
616 symname = bp; /* remember where it starts */
618 sym_length = check_macro_name (pfile, bp, 0);
621 /* Lossage will occur if identifiers or control keywords are broken
622 across lines using backslash. This is not the right place to take
627 struct arglist *arg_ptrs = NULL;
631 SKIP_WHITE_SPACE (bp);
633 /* Loop over macro argument names. */
636 struct arglist *temp;
638 temp = (struct arglist *) alloca (sizeof (struct arglist));
640 temp->next = arg_ptrs;
641 temp->argno = argno++;
646 cpp_pedwarn (pfile, "another parameter follows `%s'",
649 if (!is_idstart[*bp])
650 cpp_pedwarn (pfile, "invalid character in macro parameter name");
652 /* Find the end of the arg name. */
653 while (is_idchar[*bp])
656 /* do we have a "special" rest-args extension here? */
657 if ((size_t) (limit - bp) > REST_EXTENSION_LENGTH
658 && !strncmp (rest_extension, bp, REST_EXTENSION_LENGTH))
665 temp->length = bp - temp->name;
667 bp += REST_EXTENSION_LENGTH;
668 arglengths += temp->length + 2;
669 SKIP_WHITE_SPACE (bp);
670 if (temp->length == 0 || (*bp != ',' && *bp != ')'))
673 "badly punctuated parameter list in `#define'");
679 SKIP_WHITE_SPACE (bp);
683 cpp_error (pfile, "unterminated parameter list in `#define'");
687 struct arglist *otemp;
689 for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
690 if (temp->length == otemp->length
691 && strncmp (temp->name, otemp->name, temp->length) == 0)
695 name = (U_CHAR *) alloca (temp->length + 1);
696 (void) strncpy (name, temp->name, temp->length);
697 name[temp->length] = '\0';
699 "duplicate argument name `%s' in `#define'",
706 ++bp; /* skip paren */
707 SKIP_WHITE_SPACE (bp);
708 /* now everything from bp before limit is the definition. */
709 defn = collect_expansion (pfile, bp, limit, argno, arg_ptrs);
710 defn->rest_args = rest_args;
712 /* Now set defn->args.argnames to the result of concatenating
713 the argument names in reverse order
714 with comma-space between them. */
715 defn->args.argnames = (U_CHAR *) xmalloc (arglengths + 1);
717 struct arglist *temp;
719 for (temp = arg_ptrs; temp; temp = temp->next)
721 bcopy (temp->name, &defn->args.argnames[i], temp->length);
725 defn->args.argnames[i++] = ',';
726 defn->args.argnames[i++] = ' ';
729 defn->args.argnames[i] = 0;
734 /* Simple expansion or empty definition. */
738 if (is_hor_space[*bp])
741 SKIP_WHITE_SPACE (bp);
744 /* Per C9x, missing white space after the name in a #define
745 of an object-like macro is always a constraint violation. */
747 "missing white space after `#define %.*s'",
748 sym_length, symname);
750 /* now everything from bp before limit is the definition. */
751 defn = collect_expansion (pfile, bp, limit, -1, NULL_PTR);
752 defn->args.argnames = (U_CHAR *) "";
758 /* OP is null if this is a predefinition */
759 defn->predefined = predefinition;
761 mdef.symnam = symname;
762 mdef.symlen = sym_length;
772 * Parse a macro argument and append the info on PFILE's token_buffer.
773 * REST_ARGS means to absorb the rest of the args.
774 * Return nonzero to indicate a syntax error.
777 static enum cpp_token
778 macarg (pfile, rest_args)
783 enum cpp_token token;
784 char save_put_out_comments = CPP_OPTIONS (pfile)->put_out_comments;
785 CPP_OPTIONS (pfile)->put_out_comments = 0;
787 /* Try to parse as much of the argument as exists at this
788 input stack level. */
789 pfile->no_macro_expand++;
790 CPP_OPTIONS (pfile)->no_line_commands++;
793 token = cpp_get_token (pfile);
799 /* If we've hit end of file, it's an error (reported by caller).
800 Ditto if it's the end of cpp_expand_to_buffer text.
801 If we've hit end of macro, just continue. */
802 if (!CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
813 /* if we've returned to lowest level and
814 we aren't absorbing all args */
815 if (paren == 0 && rest_args == 0)
819 /* Remove ',' or ')' from argument buffer. */
820 CPP_ADJUST_WRITTEN (pfile, -1);
827 CPP_OPTIONS (pfile)->put_out_comments = save_put_out_comments;
828 CPP_OPTIONS (pfile)->no_line_commands--;
829 pfile->no_macro_expand--;
834 /* Turn newlines to spaces in the string of length LENGTH at START,
835 except inside of string constants.
836 The string is copied into itself with its beginning staying fixed. */
839 change_newlines (start, length)
843 register U_CHAR *ibp;
844 register U_CHAR *obp;
845 register U_CHAR *limit;
849 limit = start + length;
860 /* Notice and skip strings, so that we don't
861 delete newlines in them. */
869 if (c == '\n' && quotec == '\'')
887 time_t t = time ((time_t *) 0);
888 pfile->timebuf = localtime (&t);
890 return pfile->timebuf;
893 static char *monthnames[] =
895 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
896 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
900 * expand things like __FILE__. Place the expansion into the output
901 * buffer *without* rescanning.
905 special_symbol (hp, pfile)
918 ip = CPP_BUFFER (pfile);
919 if (hp->type == T_BASE_FILE)
921 while (CPP_PREV_BUFFER (ip) != CPP_NULL_BUFFER (pfile))
922 ip = CPP_PREV_BUFFER (ip);
926 ip = CPP_BUFFER (pfile);
927 while (!ip->nominal_fname && ip != CPP_NULL_BUFFER (pfile))
928 ip = CPP_PREV_BUFFER (ip);
931 buf = ip->nominal_fname;
935 CPP_RESERVE (pfile, 3 + 4 * strlen (buf));
936 quote_string (pfile, buf);
940 case T_INCLUDE_LEVEL:
942 int true_indepth = 0;
943 ip = CPP_BUFFER (pfile);
944 for (; ip != CPP_NULL_BUFFER (pfile); ip = CPP_PREV_BUFFER (ip))
945 if (ip->fname != NULL)
948 CPP_RESERVE (pfile, 10);
949 sprintf (CPP_PWRITTEN (pfile), "%d", true_indepth);
950 CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
955 len = strlen (version_string);
956 CPP_RESERVE (pfile, 3 + len);
957 CPP_PUTC_Q (pfile, '"');
958 CPP_PUTS_Q (pfile, version_string, len);
959 CPP_PUTC_Q (pfile, '"');
960 CPP_NUL_TERMINATE_Q (pfile);
964 buf = hp->value.cpval;
971 CPP_RESERVE (pfile, len + 1);
972 CPP_PUTS_Q (pfile, buf, len);
973 CPP_NUL_TERMINATE_Q (pfile);
977 CPP_RESERVE (pfile, 2);
978 #ifdef STDC_0_IN_SYSTEM_HEADERS
979 ip = CPP_BUFFER (pfile);
980 while (!ip->nominal_fname && ip != CPP_NULL_BUFFER (pfile))
981 ip = CPP_PREV_BUFFER (ip);
982 if (ip->system_header_p
983 && !cpp_lookup (pfile, (U_CHAR *) "__STRICT_ANSI__", 15, -1))
984 CPP_PUTC_Q (pfile, '0');
987 CPP_PUTC_Q (pfile, '1');
988 CPP_NUL_TERMINATE_Q (pfile);
994 cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, NULL);
996 CPP_RESERVE (pfile, 10);
997 sprintf (CPP_PWRITTEN (pfile), "%ld", line);
998 CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
1007 CPP_RESERVE (pfile, 20);
1008 timebuf = timestamp (pfile);
1009 if (hp->type == T_DATE)
1010 sprintf (CPP_PWRITTEN (pfile), "\"%s %2d %4d\"",
1011 monthnames[timebuf->tm_mon],
1012 timebuf->tm_mday, timebuf->tm_year + 1900);
1014 sprintf (CPP_PWRITTEN (pfile), "\"%02d:%02d:%02d\"",
1015 timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
1017 CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
1022 cpp_fatal (pfile, "cpplib internal error: invalid special hash type");
1026 /* This point should be unreachable. */
1030 /* Expand a macro call.
1031 HP points to the symbol that is the macro being called.
1032 Put the result of expansion onto the input stack
1033 so that subsequent input by our caller will use it.
1035 If macro wants arguments, caller has already verified that
1036 an argument list follows; arguments come from the input stack. */
1039 macroexpand (pfile, hp)
1045 register U_CHAR *xbuf;
1046 long start_line, start_column;
1048 struct argdata *args;
1049 long old_written = CPP_WRITTEN (pfile);
1051 int start_line = instack[indepth].lineno;
1053 int rest_args, rest_zero;
1057 /* This macro is being used inside a #if, which means it must be */
1058 /* recorded as a precondition. */
1059 if (pcp_inside_if && pcp_outfile && defn->predefined)
1060 dump_single_macro (hp, pcp_outfile);
1063 cpp_buf_line_and_col (cpp_file_buffer (pfile), &start_line, &start_column);
1065 /* Check for and handle special symbols. */
1066 if (hp->type != T_MACRO)
1068 special_symbol (hp, pfile);
1069 xbuf_len = CPP_WRITTEN (pfile) - old_written;
1070 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
1071 CPP_SET_WRITTEN (pfile, old_written);
1072 bcopy (CPP_PWRITTEN (pfile), xbuf, xbuf_len + 1);
1073 push_macro_expansion (pfile, xbuf, xbuf_len, hp);
1074 CPP_BUFFER (pfile)->has_escapes = 1;
1078 defn = hp->value.defn;
1079 nargs = defn->nargs;
1080 pfile->output_escapes++;
1084 enum cpp_token token;
1086 args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
1088 for (i = 0; i < nargs; i++)
1090 args[i].raw = args[i].expanded = 0;
1091 args[i].raw_length = 0;
1092 args[i].expand_length = args[i].stringified_length = -1;
1093 args[i].use_count = 0;
1096 /* Parse all the macro args that are supplied. I counts them.
1097 The first NARGS args are stored in ARGS.
1098 The rest are discarded. If rest_args is set then we assume
1099 macarg absorbed the rest of the args. */
1103 FORWARD (1); /* Discard open-parenthesis before first arg. */
1108 if (i < nargs || (nargs == 0 && i == 0))
1110 /* if we are working on last arg which absorbs rest of args... */
1111 if (i == nargs - 1 && defn->rest_args)
1113 args[i].raw = CPP_WRITTEN (pfile);
1114 token = macarg (pfile, rest_args);
1115 args[i].raw_length = CPP_WRITTEN (pfile) - args[i].raw;
1116 args[i].newlines = 0; /* FIXME */
1119 token = macarg (pfile, 0);
1120 if (token == CPP_EOF || token == CPP_POP)
1122 cpp_error_with_line (pfile, start_line, start_column,
1123 "unterminated macro call");
1128 while (token == CPP_COMMA);
1130 /* If we got one arg but it was just whitespace, call that 0 args. */
1133 register U_CHAR *bp = ARG_BASE + args[0].raw;
1134 register U_CHAR *lim = bp + args[0].raw_length;
1135 /* cpp.texi says for foo ( ) we provide one argument.
1136 However, if foo wants just 0 arguments, treat this as 0. */
1138 while (bp != lim && is_space[*bp])
1144 /* Don't output an error message if we have already output one for
1145 a parse error above. */
1147 if (nargs == 0 && i > 0)
1149 cpp_error (pfile, "arguments given to macro `%s'", hp->name);
1153 /* traditional C allows foo() if foo wants one argument. */
1154 if (nargs == 1 && i == 0 && CPP_TRADITIONAL (pfile))
1156 /* the rest args token is allowed to absorb 0 tokens */
1157 else if (i == nargs - 1 && defn->rest_args)
1160 cpp_error (pfile, "macro `%s' used without args", hp->name);
1162 cpp_error (pfile, "macro `%s' used with just one arg", hp->name);
1164 cpp_error (pfile, "macro `%s' used with only %d args",
1170 "macro `%s' used with too many (%d) args", hp->name, i);
1174 /* If macro wants zero args, we parsed the arglist for checking only.
1175 Read directly from the macro definition. */
1178 xbuf = defn->expansion;
1179 xbuf_len = defn->length;
1183 register U_CHAR *exp = defn->expansion;
1184 register int offset; /* offset in expansion,
1185 copied a piece at a time */
1186 register int totlen; /* total amount of exp buffer filled so far */
1188 register struct reflist *ap, *last_ap;
1190 /* Macro really takes args. Compute the expansion of this call. */
1192 /* Compute length in characters of the macro's expansion.
1193 Also count number of times each arg is used. */
1194 xbuf_len = defn->length;
1195 for (ap = defn->pattern; ap != NULL; ap = ap->next)
1199 register struct argdata *arg = &args[ap->argno];
1200 /* Stringify if it hasn't already been */
1201 if (arg->stringified_length < 0)
1203 int arglen = arg->raw_length;
1207 /* Initially need_space is -1. Otherwise, 1 means the
1208 previous character was a space, but we suppressed it;
1209 0 means the previous character was a non-space. */
1210 int need_space = -1;
1212 arg->stringified = CPP_WRITTEN (pfile);
1213 if (!CPP_TRADITIONAL (pfile))
1214 CPP_PUTC (pfile, '\"'); /* insert beginning quote */
1215 for (; i < arglen; i++)
1217 c = (ARG_BASE + arg->raw)[i];
1221 /* Internal sequences of whitespace are
1222 replaced by one space except within
1223 a string or char token. */
1226 if (CPP_WRITTEN (pfile) > (unsigned) arg->stringified
1227 && (CPP_PWRITTEN (pfile))[-1] == '@')
1229 /* "@ " escape markers are removed */
1230 CPP_ADJUST_WRITTEN (pfile, -1);
1233 if (need_space == 0)
1237 else if (need_space > 0)
1238 CPP_PUTC (pfile, ' ');
1253 else if (c == '\"' || c == '\'')
1257 /* Escape these chars */
1258 if (c == '\"' || (in_string && c == '\\'))
1259 CPP_PUTC (pfile, '\\');
1261 CPP_PUTC (pfile, c);
1264 CPP_RESERVE (pfile, 4);
1265 sprintf ((char *) CPP_PWRITTEN (pfile), "\\%03o",
1267 CPP_ADJUST_WRITTEN (pfile, 4);
1270 if (!CPP_TRADITIONAL (pfile))
1271 CPP_PUTC (pfile, '\"'); /* insert ending quote */
1272 arg->stringified_length
1273 = CPP_WRITTEN (pfile) - arg->stringified;
1275 xbuf_len += args[ap->argno].stringified_length;
1277 else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
1278 /* Add 4 for two newline-space markers to prevent
1279 token concatenation. */
1280 xbuf_len += args[ap->argno].raw_length + 4;
1283 /* We have an ordinary (expanded) occurrence of the arg.
1284 So compute its expansion, if we have not already. */
1285 if (args[ap->argno].expand_length < 0)
1287 args[ap->argno].expanded = CPP_WRITTEN (pfile);
1288 cpp_expand_to_buffer (pfile,
1289 ARG_BASE + args[ap->argno].raw,
1290 args[ap->argno].raw_length);
1292 args[ap->argno].expand_length
1293 = CPP_WRITTEN (pfile) - args[ap->argno].expanded;
1296 /* Add 4 for two newline-space markers to prevent
1297 token concatenation. */
1298 xbuf_len += args[ap->argno].expand_length + 4;
1300 if (args[ap->argno].use_count < 10)
1301 args[ap->argno].use_count++;
1304 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
1306 /* Generate in XBUF the complete expansion
1307 with arguments substituted in.
1308 TOTLEN is the total size generated so far.
1309 OFFSET is the index in the definition
1310 of where we are copying from. */
1311 offset = totlen = 0;
1312 for (last_ap = NULL, ap = defn->pattern; ap != NULL;
1313 last_ap = ap, ap = ap->next)
1315 register struct argdata *arg = &args[ap->argno];
1316 int count_before = totlen;
1318 /* Add chars to XBUF. */
1319 for (i = 0; i < ap->nchars; i++, offset++)
1320 xbuf[totlen++] = exp[offset];
1322 /* If followed by an empty rest arg with concatenation,
1323 delete the last run of nonwhite chars. */
1324 if (rest_zero && totlen > count_before
1325 && ((ap->rest_args && ap->raw_before)
1326 || (last_ap != NULL && last_ap->rest_args
1327 && last_ap->raw_after)))
1329 /* Delete final whitespace. */
1330 while (totlen > count_before && is_space[xbuf[totlen - 1]])
1333 /* Delete the nonwhites before them. */
1334 while (totlen > count_before && !is_space[xbuf[totlen - 1]])
1338 if (ap->stringify != 0)
1340 bcopy (ARG_BASE + arg->stringified,
1341 xbuf + totlen, arg->stringified_length);
1342 totlen += arg->stringified_length;
1344 else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
1346 U_CHAR *p1 = ARG_BASE + arg->raw;
1347 U_CHAR *l1 = p1 + arg->raw_length;
1350 while (p1 != l1 && is_space[*p1])
1352 while (p1 != l1 && is_idchar[*p1])
1353 xbuf[totlen++] = *p1++;
1357 /* Arg is concatenated after: delete trailing whitespace,
1358 whitespace markers, and no-reexpansion markers. */
1361 if (is_space[l1[-1]])
1363 else if (l1[-1] == '@')
1365 U_CHAR *p2 = l1 - 1;
1366 /* If whitespace is preceded by an odd number
1367 of `@' signs, the last `@' was a whitespace
1368 marker; drop it too. */
1369 while (p2 != p1 && p2[0] == '@')
1375 else if (l1[-1] == '-')
1377 U_CHAR *p2 = l1 - 1;
1378 /* If a `-' is preceded by an odd number of
1379 `@' signs then it and the last `@' are
1380 a no-reexpansion marker. */
1381 while (p2 != p1 && p2[0] == '@')
1393 /* Delete any no-reexpansion marker that precedes
1394 an identifier at the beginning of the argument. */
1395 if (p1[0] == '@' && p1[1] == '-')
1398 bcopy (p1, xbuf + totlen, l1 - p1);
1403 U_CHAR *expanded = ARG_BASE + arg->expanded;
1404 if (!ap->raw_before && totlen > 0 && arg->expand_length
1405 && !CPP_TRADITIONAL (pfile)
1406 && unsafe_chars (xbuf[totlen - 1], expanded[0]))
1408 xbuf[totlen++] = '@';
1409 xbuf[totlen++] = ' ';
1412 bcopy (expanded, xbuf + totlen, arg->expand_length);
1413 totlen += arg->expand_length;
1415 if (!ap->raw_after && totlen > 0 && offset < defn->length
1416 && !CPP_TRADITIONAL (pfile)
1417 && unsafe_chars (xbuf[totlen - 1], exp[offset]))
1419 xbuf[totlen++] = '@';
1420 xbuf[totlen++] = ' ';
1423 /* If a macro argument with newlines is used multiple times,
1424 then only expand the newlines once. This avoids creating
1425 output lines which don't correspond to any input line,
1426 which confuses gdb and gcov. */
1427 if (arg->use_count > 1 && arg->newlines > 0)
1429 /* Don't bother doing change_newlines for subsequent
1433 = change_newlines (expanded, arg->expand_length);
1437 if (totlen > xbuf_len)
1441 /* if there is anything left of the definition
1442 after handling the arg list, copy that in too. */
1444 for (i = offset; i < defn->length; i++)
1446 /* if we've reached the end of the macro */
1449 if (!(rest_zero && last_ap != NULL && last_ap->rest_args
1450 && last_ap->raw_after))
1451 xbuf[totlen++] = exp[i];
1459 pfile->output_escapes--;
1461 /* Now put the expansion on the input stack
1462 so our caller will commence reading from it. */
1463 push_macro_expansion (pfile, xbuf, xbuf_len, hp);
1464 CPP_BUFFER (pfile)->has_escapes = 1;
1466 /* Pop the space we've used in the token_buffer for argument expansion. */
1467 CPP_SET_WRITTEN (pfile, old_written);
1469 /* Recursive macro use sometimes works traditionally.
1470 #define foo(x,y) bar (x (y,0), y)
1473 if (!CPP_TRADITIONAL (pfile))
1474 hp->type = T_DISABLED;
1477 /* Return 1 iff a token ending in C1 followed directly by a token C2
1478 could cause mis-tokenization. */
1481 unsafe_chars (c1, c2)
1488 if (c2 == c1 || c2 == '=')
1492 case '.': case '0': case '1': case '2': case '3':
1493 case '4': case '5': case '6': case '7': case '8':
1494 case '9': case 'e': case 'E': case 'p': case 'P':
1495 if (c2 == '-' || c2 == '+')
1496 return 1; /* could extend a pre-processing number */
1500 if (c2 == '\'' || c2 == '\"')
1501 return 1; /* Could turn into L"xxx" or L'xxx'. */
1504 case '_': case 'a': case 'b': case 'c': case 'd': case 'f':
1505 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
1506 case 'm': case 'n': case 'o': case 'q': case 'r': case 's':
1507 case 't': case 'u': case 'v': case 'w': case 'x': case 'y':
1508 case 'z': case 'A': case 'B': case 'C': case 'D': case 'F':
1509 case 'G': case 'H': case 'I': case 'J': case 'K': case 'M':
1510 case 'N': case 'O': case 'Q': case 'R': case 'S': case 'T':
1511 case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z':
1513 /* We're in the middle of either a name or a pre-processing number. */
1514 return (is_idchar[c2] || c2 == '.');
1516 case '<': case '>': case '!': case '%': case '#': case ':':
1517 case '^': case '&': case '|': case '*': case '/': case '=':
1518 return (c2 == c1 || c2 == '=');
1524 push_macro_expansion (pfile, xbuf, xbuf_len, hp)
1526 register U_CHAR *xbuf;
1530 register cpp_buffer *mbuf = cpp_push_buffer (pfile, xbuf, xbuf_len);
1533 mbuf->cleanup = macro_cleanup;
1536 /* The first chars of the expansion should be a "@ " added by
1537 collect_expansion. This is to prevent accidental token-pasting
1538 between the text preceding the macro invocation, and the macro
1541 We would like to avoid adding unneeded spaces (for the sake of
1542 tools that use cpp, such as imake). In some common cases we can
1543 tell that it is safe to omit the space.
1545 The character before the macro invocation cannot have been an
1546 idchar (or else it would have been pasted with the idchars of
1547 the macro name). Therefore, if the first non-space character
1548 of the expansion is an idchar, we do not need the extra space
1549 to prevent token pasting.
1551 Also, we don't need the extra space if the first char is '(',
1552 or some other (less common) characters. */
1554 if (xbuf[0] == '@' && xbuf[1] == ' '
1555 && (is_idchar[xbuf[2]] || xbuf[2] == '(' || xbuf[2] == '\''
1556 || xbuf[2] == '\"'))
1559 /* Likewise, avoid the extra space at the end of the macro expansion
1560 if this is safe. We can do a better job here since we can know
1561 what the next char will be. */
1563 && mbuf->rlimit[-2] == '@'
1564 && mbuf->rlimit[-1] == ' ')
1566 int c1 = mbuf->rlimit[-3];
1567 int c2 = CPP_BUF_PEEK (CPP_PREV_BUFFER (CPP_BUFFER (pfile)));
1568 if (c2 == EOF || !unsafe_chars (c1, c2))
1573 /* Return zero if two DEFINITIONs are isomorphic. */
1576 compare_defs (pfile, d1, d2)
1578 DEFINITION *d1, *d2;
1580 register struct reflist *a1, *a2;
1581 register U_CHAR *p1 = d1->expansion;
1582 register U_CHAR *p2 = d2->expansion;
1585 if (d1->nargs != d2->nargs)
1587 if (CPP_PEDANTIC (pfile)
1588 && strcmp ((char *) d1->args.argnames, (char *) d2->args.argnames))
1590 for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
1591 a1 = a1->next, a2 = a2->next)
1593 if (!((a1->nchars == a2->nchars && !strncmp (p1, p2, a1->nchars))
1594 || !comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
1595 || a1->argno != a2->argno
1596 || a1->stringify != a2->stringify
1597 || a1->raw_before != a2->raw_before
1598 || a1->raw_after != a2->raw_after)
1607 return comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
1608 p2, d2->length - (p2 - d2->expansion), 1);
1611 /* Return 1 if two parts of two macro definitions are effectively different.
1612 One of the parts starts at BEG1 and has LEN1 chars;
1613 the other has LEN2 chars at BEG2.
1614 Any sequence of whitespace matches any other sequence of whitespace.
1615 FIRST means these parts are the first of a macro definition;
1616 so ignore leading whitespace entirely.
1617 LAST means these parts are the last of a macro definition;
1618 so ignore trailing whitespace entirely. */
1621 comp_def_part (first, beg1, len1, beg2, len2, last)
1623 U_CHAR *beg1, *beg2;
1627 register U_CHAR *end1 = beg1 + len1;
1628 register U_CHAR *end2 = beg2 + len2;
1631 while (beg1 != end1 && is_space[*beg1])
1633 while (beg2 != end2 && is_space[*beg2])
1638 while (beg1 != end1 && is_space[end1[-1]])
1640 while (beg2 != end2 && is_space[end2[-1]])
1643 while (beg1 != end1 && beg2 != end2)
1645 if (is_space[*beg1] && is_space[*beg2])
1647 while (beg1 != end1 && is_space[*beg1])
1649 while (beg2 != end2 && is_space[*beg2])
1652 else if (*beg1 == *beg2)
1660 return (beg1 != end1) || (beg2 != end2);