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! */
31 static int comp_def_part
PARAMS ((int, U_CHAR
*, int, U_CHAR
*,
33 static int change_newlines
PARAMS ((U_CHAR
*, int));
34 static void push_macro_expansion
PARAMS ((cpp_reader
*,
35 U_CHAR
*, int, HASHNODE
*));
36 static int unsafe_chars
PARAMS ((int, int));
38 #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
39 #define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->data != NULL)
40 #define FORWARD(N) CPP_FORWARD (CPP_BUFFER (pfile), (N))
42 extern char *version_string
;
44 /* The arglist structure is built by create_definition to tell
45 collect_expansion where the argument names begin. That
46 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
47 would contain pointers to the strings x, y, and z.
48 collect_expansion would then build a DEFINITION node,
49 with reflist nodes pointing to the places x, y, and z had
50 appeared. So the arglist is just convenience data passed
51 between these two routines. It is not kept around after
52 the current #define has been processed and entered into the
64 /* This structure represents one parsed argument in a macro call.
65 `raw' points to the argument text as written (`raw_length' is its length).
66 `expanded' points to the argument's macro-expansion
67 (its length is `expand_length').
68 `stringified_length' is the length the argument would have
70 `use_count' is the number of times this macro arg is substituted
71 into the macro. If the actual use count exceeds 10,
72 the value stored is 10. */
74 /* raw and expanded are relative to ARG_BASE */
75 #define ARG_BASE ((pfile)->token_buffer)
79 /* Strings relative to pfile->token_buffer */
80 long raw
, expanded
, stringified
;
81 int raw_length
, expand_length
;
82 int stringified_length
;
88 /* Return hash function on name. must be compatible with the one
89 computed a step at a time, elsewhere */
92 hashf (name
, len
, hashsize
)
93 register const U_CHAR
*name
;
100 r
= HASHSTEP (r
, *name
++);
102 return MAKE_POS (r
) % hashsize
;
105 /* Find the most recent hash node for name "name" (ending with first
106 non-identifier char) installed by cpp_install
108 If LEN is >= 0, it is the length of the name.
109 Otherwise, compute the length by scanning the entire name.
111 If HASH is >= 0, it is the precomputed hash code.
112 Otherwise, compute the hash code. */
115 cpp_lookup (pfile
, name
, len
, hash
)
116 cpp_reader
*pfile ATTRIBUTE_UNUSED
;
121 register const U_CHAR
*bp
;
122 register HASHNODE
*bucket
;
126 for (bp
= name
; is_idchar
[*bp
]; bp
++);
131 hash
= hashf (name
, len
, HASHSIZE
);
133 bucket
= pfile
->hashtab
[hash
];
136 if (bucket
->length
== len
&& strncmp (bucket
->name
, name
, len
) == 0)
138 bucket
= bucket
->next
;
140 return (HASHNODE
*) 0;
144 * Delete a hash node. Some weirdness to free junk from macros.
145 * More such weirdness will have to be added if you define more hash
146 * types that need it.
149 /* Note that the DEFINITION of a macro is removed from the hash table
150 but its storage is not freed. This would be a storage leak
151 except that it is not reasonable to keep undefining and redefining
152 large numbers of macros many times.
153 In any case, this is necessary, because a macro can be #undef'd
154 in the middle of reading the arguments to a call to it.
155 If #undef freed the DEFINITION, that would crash. */
162 if (hp
->prev
!= NULL
)
163 hp
->prev
->next
= hp
->next
;
164 if (hp
->next
!= NULL
)
165 hp
->next
->prev
= hp
->prev
;
167 /* make sure that the bucket chain header that
168 the deleted guy was on points to the right thing afterwards. */
169 if (hp
== *hp
->bucket_hdr
)
170 *hp
->bucket_hdr
= hp
->next
;
172 if (hp
->type
== T_MACRO
)
174 DEFINITION
*d
= hp
->value
.defn
;
175 struct reflist
*ap
, *nextap
;
177 for (ap
= d
->pattern
; ap
!= NULL
; ap
= nextap
)
183 free (d
->args
.argnames
);
190 /* Install a name in the main hash table, even if it is already there.
191 Name stops with first non alphanumeric, except leading '#'.
192 Caller must check against redefinition if that is desired.
193 delete_macro () removes things installed by cpp_install () in fifo order.
194 this is important because of the `defined' special symbol used
195 in #if, and also if pushdef/popdef directives are ever implemented.
197 If LEN is >= 0, it is the length of the name.
198 Otherwise, compute the length by scanning the entire name.
200 If HASH is >= 0, it is the precomputed hash code.
201 Otherwise, compute the hash code. */
204 cpp_install (pfile
, name
, len
, type
, value
, hash
)
212 register HASHNODE
*hp
;
213 register int i
, bucket
;
219 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 with parameters.
260 Build the DEFINITION structure.
261 Reads characters of text starting at BUF until END.
262 ARGLIST specifies the formal parameters to look for
263 in the text of the definition; NARGS is the number of args
264 in that list, or -1 for a macro name that wants no argument list.
265 MACRONAME is the macro name itself (so we can avoid recursive expansion)
266 and NAMELEN is its length in characters.
268 Note that comments, backslash-newlines, and leading white space
269 have already been deleted from the argument. */
272 collect_expansion (pfile
, buf
, limit
, nargs
, arglist
)
276 struct arglist
*arglist
;
279 register U_CHAR
*p
, *lastp
, *exp_p
;
280 struct reflist
*endpat
= NULL
;
281 /* Pointer to first nonspace after last ## seen. */
283 /* Pointer to first nonspace after last single-# seen. */
284 U_CHAR
*stringify
= 0;
286 int expected_delimiter
= '\0';
288 /* Scan thru the replacement list, ignoring comments and quoted
289 strings, picking up on the macro calls. It does a linear search
290 thru the arg list on every potential symbol. Profiling might say
291 that something smarter should happen. */
295 cpp_fatal (pfile
, "internal error: limit < buf in collect_expansion");
296 limit
= buf
; /* treat it like a null defn */
299 /* Find the beginning of the trailing whitespace. */
301 while (p
< limit
&& is_space
[limit
[-1]])
304 /* Allocate space for the text in the macro definition.
305 Leading and trailing whitespace chars need 2 bytes each.
306 Each other input char may or may not need 1 byte,
307 so this is an upper bound. The extra 5 are for invented
308 leading and trailing newline-marker and final null. */
309 maxsize
= (sizeof (DEFINITION
)
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 /* # is ordinary inside a string. */
364 if (expected_delimiter
)
366 if (p
< limit
&& *p
== '#')
368 /* ##: concatenate preceding and following tokens. */
369 /* Take out the first #, discard preceding whitespace. */
371 while (exp_p
> lastp
&& is_hor_space
[exp_p
[-1]])
373 /* Skip the second #. */
375 /* Discard following whitespace. */
376 SKIP_WHITE_SPACE (p
);
379 cpp_error (pfile
, "`##' at end of macro definition");
383 /* Single #: stringify following argument ref.
384 Don't leave the # in the expansion. */
386 SKIP_WHITE_SPACE (p
);
387 if (p
== limit
|| !is_idstart
[*p
]
388 || (*p
== 'L' && p
+ 1 < limit
&& (p
[1] == '\'' ||
391 "`#' operator is not followed by a macro argument name");
400 /* In -traditional mode, recognize arguments inside strings and
401 character constants, and ignore special properties of #.
402 Arguments inside strings are considered "stringified", but no
403 extra quote marks are supplied. */
408 if (expected_delimiter
!= '\0')
410 if (c
== expected_delimiter
)
411 expected_delimiter
= '\0';
414 expected_delimiter
= c
;
418 /* Backslash quotes delimiters and itself,
419 but not macro args. */
420 if (expected_delimiter
!= 0 && p
< limit
421 && (*p
== expected_delimiter
|| *p
== '\\'))
429 if (expected_delimiter
!= '\0')
430 /* No comments inside strings. */
434 /* If we find a comment that wasn't removed by
435 handle_directive, this must be -traditional.
436 So replace the comment with nothing at all. */
439 while (p
< limit
&& !(p
[-2] == '*' && p
[-1] == '/'))
442 /* Mark this as a concatenation-point,
443 as if it had been ##. */
451 /* Handle the start of a symbol. */
452 if (is_idchar
[c
] && nargs
> 0)
454 U_CHAR
*id_beg
= p
- 1;
458 while (p
!= limit
&& is_idchar
[*p
])
463 && !(id_len
== 1 && c
== 'L' && (*p
== '\'' || *p
== '"')))
465 register struct arglist
*arg
;
467 for (arg
= arglist
; arg
!= NULL
; arg
= arg
->next
)
469 struct reflist
*tpat
;
471 if (arg
->name
[0] == c
472 && arg
->length
== id_len
473 && strncmp (arg
->name
, id_beg
, id_len
) == 0)
475 if (expected_delimiter
&& CPP_OPTIONS
476 (pfile
)->warn_stringify
)
478 if (CPP_TRADITIONAL (pfile
))
481 "macro argument `%.*s' is stringified.",
487 "macro arg `%.*s' would be stringified with -traditional.",
491 /* If ANSI, don't actually substitute
493 if (!CPP_TRADITIONAL (pfile
) && expected_delimiter
)
495 /* make a pat node for this arg and append it
496 to the end of the pat list */
497 tpat
= (struct reflist
*)
498 xmalloc (sizeof (struct reflist
));
500 tpat
->raw_before
= concat
== id_beg
;
502 tpat
->rest_args
= arg
->rest_args
;
503 tpat
->stringify
= (CPP_TRADITIONAL (pfile
)
504 ? expected_delimiter
!= '\0'
505 : stringify
== id_beg
);
508 defn
->pattern
= tpat
;
513 tpat
->argno
= arg
->argno
;
514 tpat
->nchars
= exp_p
- lastp
;
516 register U_CHAR
*p1
= p
;
517 SKIP_WHITE_SPACE (p1
);
518 if (p1
+ 2 <= limit
&& p1
[0] == '#' && p1
[1] == '#')
528 /* If this was not a macro arg, copy it into the expansion. */
531 register U_CHAR
*lim1
= p
;
535 if (stringify
== id_beg
)
537 "`#' operator should be followed by a macro argument name");
542 if (!CPP_TRADITIONAL (pfile
) && expected_delimiter
== 0)
544 /* If ANSI, put in a "\r " marker to prevent token pasting.
545 But not if "inside a string" (which in ANSI mode
546 happens only for -D option). */
553 defn
->length
= exp_p
- defn
->expansion
;
555 /* Crash now if we overrun the allocated size. */
556 if (defn
->length
+ 1 > maxsize
)
560 /* This isn't worth the time it takes. */
561 /* give back excess storage */
562 defn
->expansion
= (U_CHAR
*) xrealloc (defn
->expansion
, defn
->length
+ 1);
569 * special extension string that can be added to the last macro argument to
570 * allow it to absorb the "rest" of the arguments when expanded. Ex:
571 * #define wow(a, b...) process (b, a, b)
572 * { wow (1, 2, 3); } -> { process (2, 3, 1, 2, 3); }
573 * { wow (one, two); } -> { process (two, one, two); }
574 * if this "rest_arg" is used with the concat token '##' and if it is not
575 * supplied then the token attached to with ## will not be outputted. Ex:
576 * #define wow (a, b...) process (b ## , a, ## b)
577 * { wow (1, 2); } -> { process (2, 1, 2); }
578 * { wow (one); } -> { process (one); {
580 static char rest_extension
[] = "...";
581 #define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1)
583 /* Create a DEFINITION node from a #define directive. Arguments are
587 create_definition (buf
, limit
, pfile
, predefinition
)
592 U_CHAR
*bp
; /* temp ptr into input buffer */
593 U_CHAR
*symname
; /* remember where symbol name starts */
594 int sym_length
; /* and how long it is */
597 char *file
= CPP_BUFFER (pfile
) ? CPP_BUFFER (pfile
)->nominal_fname
: "";
599 int arglengths
= 0; /* Accumulate lengths of arg names
600 plus number of args. */
602 cpp_buf_line_and_col (CPP_BUFFER (pfile
), &line
, &col
);
606 while (is_hor_space
[*bp
])
609 symname
= bp
; /* remember where it starts */
611 sym_length
= check_macro_name (pfile
, bp
, 0);
614 /* Lossage will occur if identifiers or control keywords are broken
615 across lines using backslash. This is not the right place to take
620 struct arglist
*arg_ptrs
= NULL
;
624 SKIP_WHITE_SPACE (bp
);
626 /* Loop over macro argument names. */
629 struct arglist
*temp
;
631 temp
= (struct arglist
*) alloca (sizeof (struct arglist
));
633 temp
->next
= arg_ptrs
;
634 temp
->argno
= argno
++;
639 cpp_pedwarn (pfile
, "another parameter follows `%s'",
642 if (!is_idstart
[*bp
])
643 cpp_pedwarn (pfile
, "invalid character in macro parameter name");
645 /* Find the end of the arg name. */
646 while (is_idchar
[*bp
])
649 /* do we have a "special" rest-args extension here? */
650 if ((size_t) (limit
- bp
) > REST_EXTENSION_LENGTH
651 && !strncmp (rest_extension
, bp
, REST_EXTENSION_LENGTH
))
658 temp
->length
= bp
- temp
->name
;
660 bp
+= REST_EXTENSION_LENGTH
;
661 arglengths
+= temp
->length
+ 2;
662 SKIP_WHITE_SPACE (bp
);
663 if (temp
->length
== 0 || (*bp
!= ',' && *bp
!= ')'))
666 "badly punctuated parameter list in `#define'");
672 SKIP_WHITE_SPACE (bp
);
676 cpp_error (pfile
, "unterminated parameter list in `#define'");
680 struct arglist
*otemp
;
682 for (otemp
= temp
->next
; otemp
!= NULL
; otemp
= otemp
->next
)
683 if (temp
->length
== otemp
->length
684 && strncmp (temp
->name
, otemp
->name
, temp
->length
) == 0)
688 name
= (U_CHAR
*) alloca (temp
->length
+ 1);
689 (void) strncpy (name
, temp
->name
, temp
->length
);
690 name
[temp
->length
] = '\0';
692 "duplicate argument name `%s' in `#define'",
699 ++bp
; /* skip paren */
700 SKIP_WHITE_SPACE (bp
);
701 /* now everything from bp before limit is the definition. */
702 defn
= collect_expansion (pfile
, bp
, limit
, argno
, arg_ptrs
);
703 defn
->rest_args
= rest_args
;
705 /* Now set defn->args.argnames to the result of concatenating
706 the argument names in reverse order
707 with comma-space between them. */
708 defn
->args
.argnames
= (U_CHAR
*) xmalloc (arglengths
+ 1);
710 struct arglist
*temp
;
712 for (temp
= arg_ptrs
; temp
; temp
= temp
->next
)
714 bcopy (temp
->name
, &defn
->args
.argnames
[i
], temp
->length
);
718 defn
->args
.argnames
[i
++] = ',';
719 defn
->args
.argnames
[i
++] = ' ';
722 defn
->args
.argnames
[i
] = 0;
727 /* Simple expansion or empty definition. */
731 if (is_hor_space
[*bp
])
734 SKIP_WHITE_SPACE (bp
);
737 /* Per C9x, missing white space after the name in a #define
738 of an object-like macro is always a constraint violation. */
740 "missing white space after `#define %.*s'",
741 sym_length
, symname
);
743 /* now everything from bp before limit is the definition. */
744 defn
= collect_expansion (pfile
, bp
, limit
, -1, NULL_PTR
);
745 defn
->args
.argnames
= (U_CHAR
*) "";
751 /* OP is null if this is a predefinition */
752 defn
->predefined
= predefinition
;
754 mdef
.symnam
= symname
;
755 mdef
.symlen
= sym_length
;
765 * Parse a macro argument and append the info on PFILE's token_buffer.
766 * REST_ARGS means to absorb the rest of the args.
767 * Return nonzero to indicate a syntax error.
770 static enum cpp_token
771 macarg (pfile
, rest_args
)
776 enum cpp_token token
;
777 char save_put_out_comments
= CPP_OPTIONS (pfile
)->put_out_comments
;
778 CPP_OPTIONS (pfile
)->put_out_comments
= 0;
780 /* Try to parse as much of the argument as exists at this
781 input stack level. */
782 pfile
->no_macro_expand
++;
783 CPP_OPTIONS (pfile
)->no_line_commands
++;
786 token
= cpp_get_token (pfile
);
792 /* If we've hit end of file, it's an error (reported by caller).
793 Ditto if it's the end of cpp_expand_to_buffer text.
794 If we've hit end of macro, just continue. */
795 if (!CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile
)))
806 /* if we've returned to lowest level and
807 we aren't absorbing all args */
808 if (paren
== 0 && rest_args
== 0)
812 /* Remove ',' or ')' from argument buffer. */
813 CPP_ADJUST_WRITTEN (pfile
, -1);
820 CPP_OPTIONS (pfile
)->put_out_comments
= save_put_out_comments
;
821 CPP_OPTIONS (pfile
)->no_line_commands
--;
822 pfile
->no_macro_expand
--;
827 /* Turn newlines to spaces in the string of length LENGTH at START,
828 except inside of string constants.
829 The string is copied into itself with its beginning staying fixed. */
832 change_newlines (start
, length
)
836 register U_CHAR
*ibp
;
837 register U_CHAR
*obp
;
838 register U_CHAR
*limit
;
842 limit
= start
+ length
;
853 /* Notice and skip strings, so that we don't
854 delete newlines in them. */
862 if (c
== '\n' && quotec
== '\'')
880 time_t t
= time ((time_t *) 0);
881 pfile
->timebuf
= localtime (&t
);
883 return pfile
->timebuf
;
886 static char *monthnames
[] =
888 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
889 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
893 * expand things like __FILE__. Place the expansion into the output
894 * buffer *without* rescanning.
898 special_symbol (hp
, pfile
)
911 ip
= CPP_BUFFER (pfile
);
912 if (hp
->type
== T_BASE_FILE
)
914 while (CPP_PREV_BUFFER (ip
) != CPP_NULL_BUFFER (pfile
))
915 ip
= CPP_PREV_BUFFER (ip
);
919 ip
= CPP_BUFFER (pfile
);
920 while (!ip
->nominal_fname
&& ip
!= CPP_NULL_BUFFER (pfile
))
921 ip
= CPP_PREV_BUFFER (ip
);
924 buf
= ip
->nominal_fname
;
928 CPP_RESERVE (pfile
, 3 + 4 * strlen (buf
));
929 quote_string (pfile
, buf
);
933 case T_INCLUDE_LEVEL
:
935 int true_indepth
= 0;
936 ip
= CPP_BUFFER (pfile
);
937 for (; ip
!= CPP_NULL_BUFFER (pfile
); ip
= CPP_PREV_BUFFER (ip
))
938 if (ip
->fname
!= NULL
)
941 CPP_RESERVE (pfile
, 10);
942 sprintf (CPP_PWRITTEN (pfile
), "%d", true_indepth
);
943 CPP_ADJUST_WRITTEN (pfile
, strlen (CPP_PWRITTEN (pfile
)));
948 len
= strlen (version_string
);
949 CPP_RESERVE (pfile
, 3 + len
);
950 CPP_PUTC_Q (pfile
, '"');
951 CPP_PUTS_Q (pfile
, version_string
, len
);
952 CPP_PUTC_Q (pfile
, '"');
953 CPP_NUL_TERMINATE_Q (pfile
);
957 buf
= hp
->value
.cpval
;
964 CPP_RESERVE (pfile
, len
+ 1);
965 CPP_PUTS_Q (pfile
, buf
, len
);
966 CPP_NUL_TERMINATE_Q (pfile
);
970 CPP_RESERVE (pfile
, 2);
971 #ifdef STDC_0_IN_SYSTEM_HEADERS
972 ip
= CPP_BUFFER (pfile
);
973 while (!ip
->nominal_fname
&& ip
!= CPP_NULL_BUFFER (pfile
))
974 ip
= CPP_PREV_BUFFER (ip
);
975 if (ip
->system_header_p
976 && !cpp_lookup (pfile
, (U_CHAR
*) "__STRICT_ANSI__", 15, -1))
977 CPP_PUTC_Q (pfile
, '0');
980 CPP_PUTC_Q (pfile
, '1');
981 CPP_NUL_TERMINATE_Q (pfile
);
987 cpp_buf_line_and_col (cpp_file_buffer (pfile
), &line
, NULL
);
989 CPP_RESERVE (pfile
, 10);
990 sprintf (CPP_PWRITTEN (pfile
), "%ld", line
);
991 CPP_ADJUST_WRITTEN (pfile
, strlen (CPP_PWRITTEN (pfile
)));
1000 CPP_RESERVE (pfile
, 20);
1001 timebuf
= timestamp (pfile
);
1002 if (hp
->type
== T_DATE
)
1003 sprintf (CPP_PWRITTEN (pfile
), "\"%s %2d %4d\"",
1004 monthnames
[timebuf
->tm_mon
],
1005 timebuf
->tm_mday
, timebuf
->tm_year
+ 1900);
1007 sprintf (CPP_PWRITTEN (pfile
), "\"%02d:%02d:%02d\"",
1008 timebuf
->tm_hour
, timebuf
->tm_min
, timebuf
->tm_sec
);
1010 CPP_ADJUST_WRITTEN (pfile
, strlen (CPP_PWRITTEN (pfile
)));
1015 cpp_fatal (pfile
, "cpplib internal error: invalid special hash type");
1020 /* Expand a macro call.
1021 HP points to the symbol that is the macro being called.
1022 Put the result of expansion onto the input stack
1023 so that subsequent input by our caller will use it.
1025 If macro wants arguments, caller has already verified that
1026 an argument list follows; arguments come from the input stack. */
1029 macroexpand (pfile
, hp
)
1035 register U_CHAR
*xbuf
;
1036 long start_line
, start_column
;
1038 struct argdata
*args
;
1039 long old_written
= CPP_WRITTEN (pfile
);
1041 int start_line
= instack
[indepth
].lineno
;
1043 int rest_args
, rest_zero
;
1047 /* This macro is being used inside a #if, which means it must be */
1048 /* recorded as a precondition. */
1049 if (pcp_inside_if
&& pcp_outfile
&& defn
->predefined
)
1050 dump_single_macro (hp
, pcp_outfile
);
1053 cpp_buf_line_and_col (cpp_file_buffer (pfile
), &start_line
, &start_column
);
1055 /* Check for and handle special symbols. */
1056 if (hp
->type
!= T_MACRO
)
1058 special_symbol (hp
, pfile
);
1059 xbuf_len
= CPP_WRITTEN (pfile
) - old_written
;
1060 xbuf
= (U_CHAR
*) xmalloc (xbuf_len
+ 1);
1061 CPP_SET_WRITTEN (pfile
, old_written
);
1062 bcopy (CPP_PWRITTEN (pfile
), xbuf
, xbuf_len
+ 1);
1063 push_macro_expansion (pfile
, xbuf
, xbuf_len
, hp
);
1064 CPP_BUFFER (pfile
)->has_escapes
= 1;
1068 defn
= hp
->value
.defn
;
1069 nargs
= defn
->nargs
;
1070 pfile
->output_escapes
++;
1074 enum cpp_token token
= CPP_EOF
;
1076 args
= (struct argdata
*) alloca ((nargs
+ 1) * sizeof (struct argdata
));
1078 for (i
= 0; i
< nargs
; i
++)
1080 args
[i
].raw
= args
[i
].expanded
= 0;
1081 args
[i
].raw_length
= 0;
1082 args
[i
].expand_length
= args
[i
].stringified_length
= -1;
1083 args
[i
].use_count
= 0;
1086 /* Parse all the macro args that are supplied. I counts them.
1087 The first NARGS args are stored in ARGS.
1088 The rest are discarded. If rest_args is set then we assume
1089 macarg absorbed the rest of the args. */
1093 FORWARD (1); /* Discard open-parenthesis before first arg. */
1098 if (i
< nargs
|| (nargs
== 0 && i
== 0))
1100 /* if we are working on last arg which absorbs rest of args... */
1101 if (i
== nargs
- 1 && defn
->rest_args
)
1103 args
[i
].raw
= CPP_WRITTEN (pfile
);
1104 token
= macarg (pfile
, rest_args
);
1105 args
[i
].raw_length
= CPP_WRITTEN (pfile
) - args
[i
].raw
;
1106 args
[i
].newlines
= 0; /* FIXME */
1109 token
= macarg (pfile
, 0);
1110 if (token
== CPP_EOF
|| token
== CPP_POP
)
1112 cpp_error_with_line (pfile
, start_line
, start_column
,
1113 "unterminated macro call");
1118 while (token
== CPP_COMMA
);
1120 /* If we got one arg but it was just whitespace, call that 0 args. */
1123 register U_CHAR
*bp
= ARG_BASE
+ args
[0].raw
;
1124 register U_CHAR
*lim
= bp
+ args
[0].raw_length
;
1125 /* cpp.texi says for foo ( ) we provide one argument.
1126 However, if foo wants just 0 arguments, treat this as 0. */
1128 while (bp
!= lim
&& is_space
[*bp
])
1134 /* Don't output an error message if we have already output one for
1135 a parse error above. */
1137 if (nargs
== 0 && i
> 0)
1139 cpp_error (pfile
, "arguments given to macro `%s'", hp
->name
);
1143 /* traditional C allows foo() if foo wants one argument. */
1144 if (nargs
== 1 && i
== 0 && CPP_TRADITIONAL (pfile
))
1146 /* the rest args token is allowed to absorb 0 tokens */
1147 else if (i
== nargs
- 1 && defn
->rest_args
)
1150 cpp_error (pfile
, "macro `%s' used without args", hp
->name
);
1152 cpp_error (pfile
, "macro `%s' used with just one arg", hp
->name
);
1154 cpp_error (pfile
, "macro `%s' used with only %d args",
1160 "macro `%s' used with too many (%d) args", hp
->name
, i
);
1164 /* If macro wants zero args, we parsed the arglist for checking only.
1165 Read directly from the macro definition. */
1168 xbuf
= defn
->expansion
;
1169 xbuf_len
= defn
->length
;
1173 register U_CHAR
*exp
= defn
->expansion
;
1174 register int offset
; /* offset in expansion,
1175 copied a piece at a time */
1176 register int totlen
; /* total amount of exp buffer filled so far */
1178 register struct reflist
*ap
, *last_ap
;
1180 /* Macro really takes args. Compute the expansion of this call. */
1182 /* Compute length in characters of the macro's expansion.
1183 Also count number of times each arg is used. */
1184 xbuf_len
= defn
->length
;
1185 for (ap
= defn
->pattern
; ap
!= NULL
; ap
= ap
->next
)
1189 register struct argdata
*arg
= &args
[ap
->argno
];
1190 /* Stringify if it hasn't already been */
1191 if (arg
->stringified_length
< 0)
1193 int arglen
= arg
->raw_length
;
1197 /* Initially need_space is -1. Otherwise, 1 means the
1198 previous character was a space, but we suppressed it;
1199 0 means the previous character was a non-space. */
1200 int need_space
= -1;
1202 arg
->stringified
= CPP_WRITTEN (pfile
);
1203 if (!CPP_TRADITIONAL (pfile
))
1204 CPP_PUTC (pfile
, '\"'); /* insert beginning quote */
1205 for (; i
< arglen
; i
++)
1207 c
= (ARG_BASE
+ arg
->raw
)[i
];
1211 /* Internal sequences of whitespace are
1212 replaced by one space except within
1213 a string or char token. */
1216 if (CPP_WRITTEN (pfile
) > (unsigned) arg
->stringified
1217 && (CPP_PWRITTEN (pfile
))[-1] == '\r')
1219 /* "\r " escape markers are removed */
1220 CPP_ADJUST_WRITTEN (pfile
, -1);
1223 if (need_space
== 0)
1227 else if (need_space
> 0)
1228 CPP_PUTC (pfile
, ' ');
1243 else if (c
== '\"' || c
== '\'')
1247 /* Escape these chars */
1248 if (c
== '\"' || (in_string
&& c
== '\\'))
1249 CPP_PUTC (pfile
, '\\');
1251 CPP_PUTC (pfile
, c
);
1254 CPP_RESERVE (pfile
, 4);
1255 sprintf ((char *) CPP_PWRITTEN (pfile
), "\\%03o",
1257 CPP_ADJUST_WRITTEN (pfile
, 4);
1260 if (!CPP_TRADITIONAL (pfile
))
1261 CPP_PUTC (pfile
, '\"'); /* insert ending quote */
1262 arg
->stringified_length
1263 = CPP_WRITTEN (pfile
) - arg
->stringified
;
1265 xbuf_len
+= args
[ap
->argno
].stringified_length
;
1267 else if (ap
->raw_before
|| ap
->raw_after
|| CPP_TRADITIONAL (pfile
))
1268 /* Add 4 for two newline-space markers to prevent
1269 token concatenation. */
1270 xbuf_len
+= args
[ap
->argno
].raw_length
+ 4;
1273 /* We have an ordinary (expanded) occurrence of the arg.
1274 So compute its expansion, if we have not already. */
1275 if (args
[ap
->argno
].expand_length
< 0)
1277 args
[ap
->argno
].expanded
= CPP_WRITTEN (pfile
);
1278 cpp_expand_to_buffer (pfile
,
1279 ARG_BASE
+ args
[ap
->argno
].raw
,
1280 args
[ap
->argno
].raw_length
);
1282 args
[ap
->argno
].expand_length
1283 = CPP_WRITTEN (pfile
) - args
[ap
->argno
].expanded
;
1286 /* Add 4 for two newline-space markers to prevent
1287 token concatenation. */
1288 xbuf_len
+= args
[ap
->argno
].expand_length
+ 4;
1290 if (args
[ap
->argno
].use_count
< 10)
1291 args
[ap
->argno
].use_count
++;
1294 xbuf
= (U_CHAR
*) xmalloc (xbuf_len
+ 1);
1296 /* Generate in XBUF the complete expansion
1297 with arguments substituted in.
1298 TOTLEN is the total size generated so far.
1299 OFFSET is the index in the definition
1300 of where we are copying from. */
1301 offset
= totlen
= 0;
1302 for (last_ap
= NULL
, ap
= defn
->pattern
; ap
!= NULL
;
1303 last_ap
= ap
, ap
= ap
->next
)
1305 register struct argdata
*arg
= &args
[ap
->argno
];
1306 int count_before
= totlen
;
1308 /* Add chars to XBUF. */
1309 for (i
= 0; i
< ap
->nchars
; i
++, offset
++)
1310 xbuf
[totlen
++] = exp
[offset
];
1312 /* If followed by an empty rest arg with concatenation,
1313 delete the last run of nonwhite chars. */
1314 if (rest_zero
&& totlen
> count_before
1315 && ((ap
->rest_args
&& ap
->raw_before
)
1316 || (last_ap
!= NULL
&& last_ap
->rest_args
1317 && last_ap
->raw_after
)))
1319 /* Delete final whitespace. */
1320 while (totlen
> count_before
&& is_space
[xbuf
[totlen
- 1]])
1323 /* Delete the nonwhites before them. */
1324 while (totlen
> count_before
&& !is_space
[xbuf
[totlen
- 1]])
1328 if (ap
->stringify
!= 0)
1330 bcopy (ARG_BASE
+ arg
->stringified
,
1331 xbuf
+ totlen
, arg
->stringified_length
);
1332 totlen
+= arg
->stringified_length
;
1334 else if (ap
->raw_before
|| ap
->raw_after
|| CPP_TRADITIONAL (pfile
))
1336 U_CHAR
*p1
= ARG_BASE
+ arg
->raw
;
1337 U_CHAR
*l1
= p1
+ arg
->raw_length
;
1340 while (p1
!= l1
&& is_space
[*p1
])
1342 while (p1
!= l1
&& is_idchar
[*p1
])
1343 xbuf
[totlen
++] = *p1
++;
1347 /* Arg is concatenated after: delete trailing whitespace,
1348 whitespace markers, and no-reexpansion markers. */
1351 if (is_space
[l1
[-1]])
1353 else if (l1
[-1] == '\r')
1355 else if (l1
[-1] == '-')
1357 if (l1
!= p1
+ 1 && l1
[-2] == '\r')
1367 /* Delete any no-reexpansion marker that precedes
1368 an identifier at the beginning of the argument. */
1369 if (p1
[0] == '\r' && p1
[1] == '-')
1372 bcopy (p1
, xbuf
+ totlen
, l1
- p1
);
1377 U_CHAR
*expanded
= ARG_BASE
+ arg
->expanded
;
1378 if (!ap
->raw_before
&& totlen
> 0 && arg
->expand_length
1379 && !CPP_TRADITIONAL (pfile
)
1380 && unsafe_chars (xbuf
[totlen
- 1], expanded
[0]))
1382 xbuf
[totlen
++] = '\r';
1383 xbuf
[totlen
++] = ' ';
1386 bcopy (expanded
, xbuf
+ totlen
, arg
->expand_length
);
1387 totlen
+= arg
->expand_length
;
1389 if (!ap
->raw_after
&& totlen
> 0 && offset
< defn
->length
1390 && !CPP_TRADITIONAL (pfile
)
1391 && unsafe_chars (xbuf
[totlen
- 1], exp
[offset
]))
1393 xbuf
[totlen
++] = '\r';
1394 xbuf
[totlen
++] = ' ';
1397 /* If a macro argument with newlines is used multiple times,
1398 then only expand the newlines once. This avoids creating
1399 output lines which don't correspond to any input line,
1400 which confuses gdb and gcov. */
1401 if (arg
->use_count
> 1 && arg
->newlines
> 0)
1403 /* Don't bother doing change_newlines for subsequent
1407 = change_newlines (expanded
, arg
->expand_length
);
1411 if (totlen
> xbuf_len
)
1413 cpp_fatal (pfile
, "internal_error: buffer overrun in macroexpand");
1418 /* if there is anything left of the definition
1419 after handling the arg list, copy that in too. */
1421 for (i
= offset
; i
< defn
->length
; i
++)
1423 /* if we've reached the end of the macro */
1426 if (!(rest_zero
&& last_ap
!= NULL
&& last_ap
->rest_args
1427 && last_ap
->raw_after
))
1428 xbuf
[totlen
++] = exp
[i
];
1436 pfile
->output_escapes
--;
1438 /* Now put the expansion on the input stack
1439 so our caller will commence reading from it. */
1440 push_macro_expansion (pfile
, xbuf
, xbuf_len
, hp
);
1441 CPP_BUFFER (pfile
)->has_escapes
= 1;
1443 /* Pop the space we've used in the token_buffer for argument expansion. */
1444 CPP_SET_WRITTEN (pfile
, old_written
);
1446 /* Recursive macro use sometimes works traditionally.
1447 #define foo(x,y) bar (x (y,0), y)
1450 if (!CPP_TRADITIONAL (pfile
))
1451 hp
->type
= T_DISABLED
;
1454 /* Return 1 iff a token ending in C1 followed directly by a token C2
1455 could cause mis-tokenization. */
1458 unsafe_chars (c1
, c2
)
1465 if (c2
== c1
|| c2
== '=')
1469 case '.': case '0': case '1': case '2': case '3':
1470 case '4': case '5': case '6': case '7': case '8':
1471 case '9': case 'e': case 'E': case 'p': case 'P':
1472 if (c2
== '-' || c2
== '+')
1473 return 1; /* could extend a pre-processing number */
1477 if (c2
== '\'' || c2
== '\"')
1478 return 1; /* Could turn into L"xxx" or L'xxx'. */
1481 case '_': case 'a': case 'b': case 'c': case 'd': case 'f':
1482 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
1483 case 'm': case 'n': case 'o': case 'q': case 'r': case 's':
1484 case 't': case 'u': case 'v': case 'w': case 'x': case 'y':
1485 case 'z': case 'A': case 'B': case 'C': case 'D': case 'F':
1486 case 'G': case 'H': case 'I': case 'J': case 'K': case 'M':
1487 case 'N': case 'O': case 'Q': case 'R': case 'S': case 'T':
1488 case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z':
1490 /* We're in the middle of either a name or a pre-processing number. */
1491 return (is_idchar
[c2
] || c2
== '.');
1493 case '<': case '>': case '!': case '%': case '#': case ':':
1494 case '^': case '&': case '|': case '*': case '/': case '=':
1495 return (c2
== c1
|| c2
== '=');
1501 push_macro_expansion (pfile
, xbuf
, xbuf_len
, hp
)
1503 register U_CHAR
*xbuf
;
1507 register cpp_buffer
*mbuf
= cpp_push_buffer (pfile
, xbuf
, xbuf_len
);
1510 mbuf
->cleanup
= macro_cleanup
;
1513 /* The first chars of the expansion should be a "\r " added by
1514 collect_expansion. This is to prevent accidental token-pasting
1515 between the text preceding the macro invocation, and the macro
1518 We would like to avoid adding unneeded spaces (for the sake of
1519 tools that use cpp, such as imake). In some common cases we can
1520 tell that it is safe to omit the space.
1522 The character before the macro invocation cannot have been an
1523 idchar (or else it would have been pasted with the idchars of
1524 the macro name). Therefore, if the first non-space character
1525 of the expansion is an idchar, we do not need the extra space
1526 to prevent token pasting.
1528 Also, we don't need the extra space if the first char is '(',
1529 or some other (less common) characters. */
1531 if (xbuf
[0] == '\r' && xbuf
[1] == ' '
1532 && (is_idchar
[xbuf
[2]] || xbuf
[2] == '(' || xbuf
[2] == '\''
1533 || xbuf
[2] == '\"'))
1536 /* Likewise, avoid the extra space at the end of the macro expansion
1537 if this is safe. We can do a better job here since we can know
1538 what the next char will be. */
1540 && mbuf
->rlimit
[-2] == '\r'
1541 && mbuf
->rlimit
[-1] == ' ')
1543 int c1
= mbuf
->rlimit
[-3];
1544 int c2
= CPP_BUF_PEEK (CPP_PREV_BUFFER (CPP_BUFFER (pfile
)));
1545 if (c2
== EOF
|| !unsafe_chars (c1
, c2
))
1550 /* Return zero if two DEFINITIONs are isomorphic. */
1553 compare_defs (pfile
, d1
, d2
)
1555 DEFINITION
*d1
, *d2
;
1557 register struct reflist
*a1
, *a2
;
1558 register U_CHAR
*p1
= d1
->expansion
;
1559 register U_CHAR
*p2
= d2
->expansion
;
1562 if (d1
->nargs
!= d2
->nargs
)
1564 if (CPP_PEDANTIC (pfile
)
1565 && strcmp ((char *) d1
->args
.argnames
, (char *) d2
->args
.argnames
))
1567 for (a1
= d1
->pattern
, a2
= d2
->pattern
; a1
&& a2
;
1568 a1
= a1
->next
, a2
= a2
->next
)
1570 if (!((a1
->nchars
== a2
->nchars
&& !strncmp (p1
, p2
, a1
->nchars
))
1571 || !comp_def_part (first
, p1
, a1
->nchars
, p2
, a2
->nchars
, 0))
1572 || a1
->argno
!= a2
->argno
1573 || a1
->stringify
!= a2
->stringify
1574 || a1
->raw_before
!= a2
->raw_before
1575 || a1
->raw_after
!= a2
->raw_after
)
1584 return comp_def_part (first
, p1
, d1
->length
- (p1
- d1
->expansion
),
1585 p2
, d2
->length
- (p2
- d2
->expansion
), 1);
1588 /* Return 1 if two parts of two macro definitions are effectively different.
1589 One of the parts starts at BEG1 and has LEN1 chars;
1590 the other has LEN2 chars at BEG2.
1591 Any sequence of whitespace matches any other sequence of whitespace.
1592 FIRST means these parts are the first of a macro definition;
1593 so ignore leading whitespace entirely.
1594 LAST means these parts are the last of a macro definition;
1595 so ignore trailing whitespace entirely. */
1598 comp_def_part (first
, beg1
, len1
, beg2
, len2
, last
)
1600 U_CHAR
*beg1
, *beg2
;
1604 register U_CHAR
*end1
= beg1
+ len1
;
1605 register U_CHAR
*end2
= beg2
+ len2
;
1608 while (beg1
!= end1
&& is_space
[*beg1
])
1610 while (beg2
!= end2
&& is_space
[*beg2
])
1615 while (beg1
!= end1
&& is_space
[end1
[-1]])
1617 while (beg2
!= end2
&& is_space
[end2
[-1]])
1620 while (beg1
!= end1
&& beg2
!= end2
)
1622 if (is_space
[*beg1
] && is_space
[*beg2
])
1624 while (beg1
!= end1
&& is_space
[*beg1
])
1626 while (beg2
!= end2
&& is_space
[*beg2
])
1629 else if (*beg1
== *beg2
)
1637 return (beg1
!= end1
) || (beg2
!= end2
);
1640 /* Dump the definition of macro MACRO on stdout. The format is suitable
1641 to be read back in again. */
1644 dump_definition (pfile
, macro
)
1648 DEFINITION
*defn
= macro
.defn
;
1650 CPP_RESERVE (pfile
, macro
.symlen
+ sizeof "#define ");
1651 CPP_PUTS_Q (pfile
, "#define ", sizeof "#define " -1);
1652 CPP_PUTS_Q (pfile
, macro
.symnam
, macro
.symlen
);
1654 if (defn
->nargs
== -1)
1656 CPP_PUTC_Q (pfile
, ' ');
1658 /* The first and last two characters of a macro expansion are
1659 always "\r "; this needs to be trimmed out.
1660 So we need length-4 chars of space, plus one for the NUL. */
1661 CPP_RESERVE (pfile
, defn
->length
- 4 + 1);
1662 CPP_PUTS_Q (pfile
, defn
->expansion
+ 2, defn
->length
- 4);
1663 CPP_NUL_TERMINATE_Q (pfile
);
1668 unsigned char *argnames
= (unsigned char *) xstrdup (defn
->args
.argnames
);
1669 unsigned char **argv
= (unsigned char **) alloca (defn
->nargs
*
1671 int *argl
= (int *) alloca (defn
->nargs
* sizeof(int));
1675 /* First extract the argument list. */
1681 while (*x
!= ',' && *x
!= '\0') x
++;
1682 argl
[i
] = x
- argv
[i
];
1686 x
+= 2; /* skip the space after the comma */
1690 /* Now print out the argument list. */
1691 CPP_PUTC_Q (pfile
, '(');
1692 for (i
= 0; i
< defn
->nargs
; i
++)
1694 CPP_RESERVE (pfile
, argl
[i
] + 2);
1695 CPP_PUTS_Q (pfile
, argv
[i
], argl
[i
]);
1696 if (i
< defn
->nargs
-1)
1697 CPP_PUTS_Q (pfile
, ", ", 2);
1700 if (defn
->rest_args
)
1701 CPP_PUTS (pfile
, "...) ", 5);
1703 CPP_PUTS (pfile
, ") ", 2);
1705 /* Now the definition. */
1706 x
= defn
->expansion
;
1707 for (r
= defn
->pattern
; r
; r
= r
->next
)
1710 if (*x
== '\r') x
+= 2, i
-= 2;
1711 /* i chars for macro text, plus the length of the macro
1712 argument name, plus one for a stringify marker, plus two for
1713 each concatenation marker. */
1715 i
+ argl
[r
->argno
] + r
->stringify
1716 + (r
->raw_before
+ r
->raw_after
) * 2);
1718 if (i
> 0) CPP_PUTS_Q (pfile
, x
, i
);
1720 CPP_PUTS_Q (pfile
, "##", 2);
1722 CPP_PUTC_Q (pfile
, '#');
1723 CPP_PUTS_Q (pfile
, argv
[r
->argno
], argl
[r
->argno
]);
1724 if (r
->raw_after
&& !(r
->next
&& r
->next
->nchars
== 0
1725 && r
->next
->raw_before
))
1726 CPP_PUTS_Q (pfile
, "##", 2);
1731 i
= defn
->length
- (x
- defn
->expansion
) - 2;
1732 if (*x
== '\r') x
+= 2, i
-= 2;
1733 if (i
> 0) CPP_PUTS (pfile
, x
, i
);
1734 CPP_NUL_TERMINATE (pfile
);