]>
gcc.gnu.org Git - gcc.git/blob - gcc/cpphash.c
1 /* Part of CPP library. (Macro handling.)
2 Copyright (C) 1986, 87, 89, 92-96, 98, 99, 2000
3 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! */
32 static unsigned int hashf
PARAMS ((const U_CHAR
*, int));
33 static int comp_def_part
PARAMS ((int, U_CHAR
*, int, U_CHAR
*,
35 static void push_macro_expansion
PARAMS ((cpp_reader
*,
36 U_CHAR
*, int, HASHNODE
*));
37 static int unsafe_chars
PARAMS ((int, int));
38 static int macro_cleanup
PARAMS ((cpp_buffer
*, cpp_reader
*));
39 static enum cpp_token macarg
PARAMS ((cpp_reader
*, int));
40 static struct tm
*timestamp
PARAMS ((cpp_reader
*));
41 static void special_symbol
PARAMS ((HASHNODE
*, cpp_reader
*));
44 #define SKIP_WHITE_SPACE(p) do { while (is_hspace(*p)) p++; } while (0)
45 #define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->data != NULL)
46 #define FORWARD(N) CPP_FORWARD (CPP_BUFFER (pfile), (N))
48 extern char *version_string
;
50 /* The arglist structure is built by create_definition to tell
51 collect_expansion where the argument names begin. That
52 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
53 would contain pointers to the strings x, y, and z.
54 collect_expansion would then build a DEFINITION node,
55 with reflist nodes pointing to the places x, y, and z had
56 appeared. So the arglist is just convenience data passed
57 between these two routines. It is not kept around after
58 the current #define has been processed and entered into the
70 static DEFINITION
*collect_expansion
PARAMS ((cpp_reader
*, U_CHAR
*, U_CHAR
*,
71 int, struct arglist
*));
73 /* This structure represents one parsed argument in a macro call.
74 `raw' points to the argument text as written (`raw_length' is its length).
75 `expanded' points to the argument's macro-expansion
76 (its length is `expand_length').
77 `stringified_length' is the length the argument would have
80 /* raw and expanded are relative to ARG_BASE */
81 #define ARG_BASE ((pfile)->token_buffer)
85 /* Strings relative to pfile->token_buffer */
86 long raw
, expanded
, stringified
;
87 int raw_length
, expand_length
;
88 int stringified_length
;
92 /* Return hash function on name. must be compatible with the one
93 computed a step at a time, elsewhere */
97 register const U_CHAR
*s
;
100 unsigned int n
= len
;
104 r
= r
* 67 + (*s
++ - 113);
109 /* Find the most recent hash node for name "name" (ending with first
110 non-identifier char) installed by cpp_install
112 If LEN is >= 0, it is the length of the name.
113 Otherwise, compute the length by scanning the entire name. */
116 cpp_lookup (pfile
, name
, len
)
121 register const U_CHAR
*bp
;
122 register HASHNODE
*bucket
;
123 register unsigned int hash
;
127 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;
143 /* Free a DEFINITION structure. Used by delete_macro, and by
144 do_define when redefining macros. */
150 struct reflist
*ap
, *nextap
;
152 for (ap
= d
->pattern
; ap
!= NULL
; ap
= nextap
)
163 * Delete a hash node. Some weirdness to free junk from macros.
164 * More such weirdness will have to be added if you define more hash
165 * types that need it.
173 if (hp
->prev
!= NULL
)
174 hp
->prev
->next
= hp
->next
;
175 if (hp
->next
!= NULL
)
176 hp
->next
->prev
= hp
->prev
;
178 /* make sure that the bucket chain header that
179 the deleted guy was on points to the right thing afterwards. */
180 if (hp
== *hp
->bucket_hdr
)
181 *hp
->bucket_hdr
= hp
->next
;
183 if (hp
->type
== T_MACRO
)
184 free_definition (hp
->value
.defn
);
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
)
210 register HASHNODE
*hp
;
211 register int i
, bucket
;
212 register const U_CHAR
*p
;
218 while (is_idchar(*p
))
223 hash
= hashf (name
, len
) % HASHSIZE
;
225 i
= sizeof (HASHNODE
) + len
+ 1;
226 hp
= (HASHNODE
*) xmalloc (i
);
228 hp
->bucket_hdr
= &pfile
->hashtab
[bucket
];
229 hp
->next
= pfile
->hashtab
[bucket
];
230 pfile
->hashtab
[bucket
] = hp
;
232 if (hp
->next
!= NULL
)
236 hp
->value
.cpval
= value
;
237 hp
->name
= ((U_CHAR
*) hp
) + sizeof (HASHNODE
);
238 bcopy (name
, hp
->name
, len
);
244 macro_cleanup (pbuf
, pfile
)
246 cpp_reader
*pfile ATTRIBUTE_UNUSED
;
248 HASHNODE
*macro
= (HASHNODE
*) pbuf
->data
;
249 if (macro
->type
== T_DISABLED
)
250 macro
->type
= T_MACRO
;
251 if (macro
->type
!= T_MACRO
|| pbuf
->buf
!= macro
->value
.defn
->expansion
)
257 /* Read a replacement list for a macro with parameters.
258 Build the DEFINITION structure.
259 Reads characters of text starting at BUF until END.
260 ARGLIST specifies the formal parameters to look for
261 in the text of the definition; NARGS is the number of args
262 in that list, or -1 for a macro name that wants no argument list.
263 MACRONAME is the macro name itself (so we can avoid recursive expansion)
264 and NAMELEN is its length in characters.
266 Note that comments, backslash-newlines, and leading white space
267 have already been deleted from the argument. */
270 collect_expansion (pfile
, buf
, limit
, nargs
, arglist
)
274 struct arglist
*arglist
;
277 register U_CHAR
*p
, *lastp
, *exp_p
;
278 struct reflist
*endpat
= NULL
;
279 /* Pointer to first nonspace after last ## seen. */
281 /* Pointer to first nonspace after last single-# seen. */
282 U_CHAR
*stringify
= 0;
284 int expected_delimiter
= '\0';
286 /* Scan thru the replacement list, ignoring comments and quoted
287 strings, picking up on the macro calls. It does a linear search
288 thru the arg list on every potential symbol. Profiling might say
289 that something smarter should happen. */
293 cpp_ice (pfile
, "limit < buf in collect_expansion");
294 limit
= buf
; /* treat it like a null defn */
297 /* Find the beginning of the trailing whitespace. */
299 while (p
< limit
&& is_space(limit
[-1]))
302 /* Allocate space for the text in the macro definition.
303 Leading and trailing whitespace chars need 2 bytes each.
304 Each other input char may or may not need 1 byte,
305 so this is an upper bound. The extra 5 are for invented
306 leading and trailing escape-marker and final null. */
307 maxsize
= (sizeof (DEFINITION
)
309 defn
= (DEFINITION
*) xcalloc (1, maxsize
);
312 exp_p
= defn
->expansion
= (U_CHAR
*) defn
+ sizeof (DEFINITION
);
317 /* Add one initial space escape-marker to prevent accidental
318 token-pasting (often removed by macroexpand). */
322 if (limit
- p
>= 2 && p
[0] == '#' && p
[1] == '#')
324 cpp_error (pfile
, "`##' at start of macro definition");
328 /* Process the main body of the definition. */
332 register U_CHAR c
= *p
++;
336 if (!CPP_TRADITIONAL (pfile
))
342 if (expected_delimiter
!= '\0')
344 if (c
== expected_delimiter
)
345 expected_delimiter
= '\0';
348 expected_delimiter
= c
;
352 if (p
< limit
&& expected_delimiter
)
354 /* In a string, backslash goes through
355 and makes next char ordinary. */
361 /* # is ordinary inside a string. */
362 if (expected_delimiter
)
364 if (p
< limit
&& *p
== '#')
366 /* ##: concatenate preceding and following tokens. */
367 /* Take out the first #, discard preceding whitespace. */
369 while (exp_p
> lastp
&& is_hspace(exp_p
[-1]))
371 /* Skip the second #. */
373 /* Discard following whitespace. */
374 SKIP_WHITE_SPACE (p
);
377 cpp_error (pfile
, "`##' at end of macro definition");
381 /* Single #: stringify following argument ref.
382 Don't leave the # in the expansion. */
384 SKIP_WHITE_SPACE (p
);
385 if (p
== limit
|| !is_idstart(*p
)
386 || (*p
== 'L' && p
+ 1 < limit
&& (p
[1] == '\'' ||
389 "`#' operator is not followed by a macro argument name");
398 /* In -traditional mode, recognize arguments inside strings and
399 character constants, and ignore special properties of #.
400 Arguments inside strings are considered "stringified", but no
401 extra quote marks are supplied. */
406 if (expected_delimiter
!= '\0')
408 if (c
== expected_delimiter
)
409 expected_delimiter
= '\0';
412 expected_delimiter
= c
;
416 /* Backslash quotes delimiters and itself,
417 but not macro args. */
418 if (expected_delimiter
!= 0 && p
< limit
419 && (*p
== expected_delimiter
|| *p
== '\\'))
427 if (expected_delimiter
!= '\0')
428 /* No comments inside strings. */
432 /* If we find a comment that wasn't removed by
433 handle_directive, this must be -traditional.
434 So replace the comment with nothing at all. */
437 while (p
< limit
&& !(p
[-2] == '*' && p
[-1] == '/'))
444 /* Handle the start of a symbol. */
445 if (is_idchar(c
) && nargs
> 0)
447 U_CHAR
*id_beg
= p
- 1;
451 while (p
!= limit
&& is_idchar(*p
))
456 && !(id_len
== 1 && c
== 'L' && (*p
== '\'' || *p
== '"')))
458 register struct arglist
*arg
;
460 for (arg
= arglist
; arg
!= NULL
; arg
= arg
->next
)
462 struct reflist
*tpat
;
464 if (arg
->name
[0] == c
465 && arg
->length
== id_len
466 && strncmp (arg
->name
, id_beg
, id_len
) == 0)
468 if (expected_delimiter
&& CPP_OPTIONS
469 (pfile
)->warn_stringify
)
471 if (CPP_TRADITIONAL (pfile
))
474 "macro argument `%.*s' is stringified.",
480 "macro arg `%.*s' would be stringified with -traditional.",
484 /* If ANSI, don't actually substitute
486 if (!CPP_TRADITIONAL (pfile
) && expected_delimiter
)
488 /* make a pat node for this arg and append it
489 to the end of the pat list */
490 tpat
= (struct reflist
*)
491 xmalloc (sizeof (struct reflist
));
493 tpat
->raw_before
= concat
== id_beg
;
495 tpat
->rest_args
= arg
->rest_args
;
496 tpat
->stringify
= (CPP_TRADITIONAL (pfile
)
497 ? expected_delimiter
!= '\0'
498 : stringify
== id_beg
);
501 defn
->pattern
= tpat
;
506 tpat
->argno
= arg
->argno
;
507 tpat
->nchars
= exp_p
- lastp
;
509 register U_CHAR
*p1
= p
;
510 SKIP_WHITE_SPACE (p1
);
511 if (p1
+ 2 <= limit
&& p1
[0] == '#' && p1
[1] == '#')
521 /* If this was not a macro arg, copy it into the expansion. */
524 register U_CHAR
*lim1
= p
;
528 if (stringify
== id_beg
)
530 "`#' operator should be followed by a macro argument name");
535 if (!CPP_TRADITIONAL (pfile
) && expected_delimiter
== 0)
537 /* If ANSI, put in a "\r " marker to prevent token pasting.
538 But not if "inside a string" (which in ANSI mode
539 happens only for -D option). */
546 defn
->length
= exp_p
- defn
->expansion
;
548 /* Crash now if we overrun the allocated size. */
549 if (defn
->length
+ 1 > maxsize
)
553 /* This isn't worth the time it takes. */
554 /* give back excess storage */
555 defn
->expansion
= (U_CHAR
*) xrealloc (defn
->expansion
, defn
->length
+ 1);
562 * special extension string that can be added to the last macro argument to
563 * allow it to absorb the "rest" of the arguments when expanded. Ex:
564 * #define wow(a, b...) process (b, a, b)
565 * { wow (1, 2, 3); } -> { process (2, 3, 1, 2, 3); }
566 * { wow (one, two); } -> { process (two, one, two); }
567 * if this "rest_arg" is used with the concat token '##' and if it is not
568 * supplied then the token attached to with ## will not be outputted. Ex:
569 * #define wow (a, b...) process (b ## , a, ## b)
570 * { wow (1, 2); } -> { process (2, 1, 2); }
571 * { wow (one); } -> { process (one); {
573 static char rest_extension
[] = "...";
574 #define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1)
576 /* Create a DEFINITION node from a #define directive. Arguments are
580 create_definition (buf
, limit
, pfile
)
584 U_CHAR
*bp
; /* temp ptr into input buffer */
585 U_CHAR
*symname
; /* remember where symbol name starts */
586 int sym_length
; /* and how long it is */
590 CPP_BUFFER (pfile
) ? CPP_BUFFER (pfile
)->nominal_fname
: "";
592 int arglengths
= 0; /* Accumulate lengths of arg names
593 plus number of args. */
595 cpp_buf_line_and_col (CPP_BUFFER (pfile
), &line
, &col
);
599 while (is_hspace(*bp
))
602 symname
= bp
; /* remember where it starts */
604 sym_length
= check_macro_name (pfile
, bp
);
607 /* Lossage will occur if identifiers or control keywords are broken
608 across lines using backslash. This is not the right place to take
613 struct arglist
*arg_ptrs
= NULL
;
617 SKIP_WHITE_SPACE (bp
);
619 /* Loop over macro argument names. */
622 struct arglist
*temp
;
624 temp
= (struct arglist
*) alloca (sizeof (struct arglist
));
626 temp
->next
= arg_ptrs
;
627 temp
->argno
= argno
++;
632 cpp_pedwarn (pfile
, "another parameter follows `%s'",
635 if (!is_idstart(*bp
))
636 cpp_pedwarn (pfile
, "invalid character in macro parameter name");
638 /* Find the end of the arg name. */
639 while (is_idchar(*bp
))
642 /* do we have a "special" rest-args extension here? */
643 if ((size_t) (limit
- bp
) > REST_EXTENSION_LENGTH
644 && !strncmp (rest_extension
, bp
, REST_EXTENSION_LENGTH
))
651 temp
->length
= bp
- temp
->name
;
653 bp
+= REST_EXTENSION_LENGTH
;
654 arglengths
+= temp
->length
+ 2;
655 SKIP_WHITE_SPACE (bp
);
656 if (temp
->length
== 0 || (*bp
!= ',' && *bp
!= ')'))
659 "badly punctuated parameter list in `#define'");
665 SKIP_WHITE_SPACE (bp
);
669 cpp_error (pfile
, "unterminated parameter list in `#define'");
673 struct arglist
*otemp
;
675 for (otemp
= temp
->next
; otemp
!= NULL
; otemp
= otemp
->next
)
676 if (temp
->length
== otemp
->length
677 && strncmp (temp
->name
, otemp
->name
, temp
->length
) == 0)
681 name
= (U_CHAR
*) alloca (temp
->length
+ 1);
682 (void) strncpy (name
, temp
->name
, temp
->length
);
683 name
[temp
->length
] = '\0';
685 "duplicate argument name `%s' in `#define'",
692 ++bp
; /* skip paren */
693 SKIP_WHITE_SPACE (bp
);
694 /* now everything from bp before limit is the definition. */
695 defn
= collect_expansion (pfile
, bp
, limit
, argno
, arg_ptrs
);
696 defn
->rest_args
= rest_args
;
698 /* Now set defn->argnames to the result of concatenating
699 the argument names in reverse order
700 with comma-space between them. */
701 defn
->argnames
= (U_CHAR
*) xmalloc (arglengths
+ 1);
703 struct arglist
*temp
;
705 for (temp
= arg_ptrs
; temp
; temp
= temp
->next
)
707 bcopy (temp
->name
, &defn
->argnames
[i
], temp
->length
);
711 defn
->argnames
[i
++] = ',';
712 defn
->argnames
[i
++] = ' ';
715 defn
->argnames
[i
] = 0;
720 /* Simple expansion or empty definition. */
727 SKIP_WHITE_SPACE (bp
);
730 /* Per C9x, missing white space after the name in a #define
731 of an object-like macro is always a constraint violation. */
733 "missing white space after `#define %.*s'",
734 sym_length
, symname
);
736 /* now everything from bp before limit is the definition. */
737 defn
= collect_expansion (pfile
, bp
, limit
, -1, NULL_PTR
);
738 defn
->argnames
= (U_CHAR
*) "";
745 mdef
.symnam
= symname
;
746 mdef
.symlen
= sym_length
;
756 * Parse a macro argument and append the info on PFILE's token_buffer.
757 * REST_ARGS means to absorb the rest of the args.
758 * Return nonzero to indicate a syntax error.
761 static enum cpp_token
762 macarg (pfile
, rest_args
)
767 enum cpp_token token
;
769 /* Try to parse as much of the argument as exists at this
770 input stack level. */
773 token
= cpp_get_token (pfile
);
779 /* If we've hit end of file, it's an error (reported by caller).
780 Ditto if it's the end of cpp_expand_to_buffer text.
781 If we've hit end of macro, just continue. */
782 if (!CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile
)))
793 /* if we've returned to lowest level and
794 we aren't absorbing all args */
795 if (paren
== 0 && rest_args
== 0)
799 /* Remove ',' or ')' from argument buffer. */
800 CPP_ADJUST_WRITTEN (pfile
, -1);
814 time_t t
= time ((time_t *) 0);
815 pfile
->timebuf
= localtime (&t
);
817 return pfile
->timebuf
;
820 static const char * const monthnames
[] =
822 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
823 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
827 * expand things like __FILE__. Place the expansion into the output
828 * buffer *without* rescanning.
832 special_symbol (hp
, pfile
)
845 ip
= CPP_BUFFER (pfile
);
846 if (hp
->type
== T_BASE_FILE
)
848 while (CPP_PREV_BUFFER (ip
) != CPP_NULL_BUFFER (pfile
))
849 ip
= CPP_PREV_BUFFER (ip
);
853 ip
= CPP_BUFFER (pfile
);
854 while (!ip
->nominal_fname
&& ip
!= CPP_NULL_BUFFER (pfile
))
855 ip
= CPP_PREV_BUFFER (ip
);
858 buf
= ip
->nominal_fname
;
862 CPP_RESERVE (pfile
, 3 + 4 * strlen (buf
));
863 quote_string (pfile
, buf
);
867 case T_INCLUDE_LEVEL
:
869 int true_indepth
= 0;
870 ip
= CPP_BUFFER (pfile
);
871 for (; ip
!= CPP_NULL_BUFFER (pfile
); ip
= CPP_PREV_BUFFER (ip
))
872 if (ip
->fname
!= NULL
)
875 CPP_RESERVE (pfile
, 10);
876 sprintf (CPP_PWRITTEN (pfile
), "%d", true_indepth
);
877 CPP_ADJUST_WRITTEN (pfile
, strlen (CPP_PWRITTEN (pfile
)));
882 len
= strlen (version_string
);
883 CPP_RESERVE (pfile
, 3 + len
);
884 CPP_PUTC_Q (pfile
, '"');
885 CPP_PUTS_Q (pfile
, version_string
, len
);
886 CPP_PUTC_Q (pfile
, '"');
887 CPP_NUL_TERMINATE_Q (pfile
);
891 buf
= hp
->value
.cpval
;
898 CPP_RESERVE (pfile
, len
+ 1);
899 CPP_PUTS_Q (pfile
, buf
, len
);
900 CPP_NUL_TERMINATE_Q (pfile
);
904 CPP_RESERVE (pfile
, 2);
905 #ifdef STDC_0_IN_SYSTEM_HEADERS
906 ip
= CPP_BUFFER (pfile
);
907 while (!ip
->nominal_fname
&& ip
!= CPP_NULL_BUFFER (pfile
))
908 ip
= CPP_PREV_BUFFER (ip
);
909 if (ip
->system_header_p
910 && !cpp_lookup (pfile
, (U_CHAR
*) "__STRICT_ANSI__", 15, -1))
911 CPP_PUTC_Q (pfile
, '0');
914 CPP_PUTC_Q (pfile
, '1');
915 CPP_NUL_TERMINATE_Q (pfile
);
921 cpp_buf_line_and_col (cpp_file_buffer (pfile
), &line
, NULL
);
923 CPP_RESERVE (pfile
, 10);
924 sprintf (CPP_PWRITTEN (pfile
), "%ld", line
);
925 CPP_ADJUST_WRITTEN (pfile
, strlen (CPP_PWRITTEN (pfile
)));
934 CPP_RESERVE (pfile
, 20);
935 timebuf
= timestamp (pfile
);
936 if (hp
->type
== T_DATE
)
937 sprintf (CPP_PWRITTEN (pfile
), "\"%s %2d %4d\"",
938 monthnames
[timebuf
->tm_mon
],
939 timebuf
->tm_mday
, timebuf
->tm_year
+ 1900);
941 sprintf (CPP_PWRITTEN (pfile
), "\"%02d:%02d:%02d\"",
942 timebuf
->tm_hour
, timebuf
->tm_min
, timebuf
->tm_sec
);
944 CPP_ADJUST_WRITTEN (pfile
, strlen (CPP_PWRITTEN (pfile
)));
949 cpp_error (pfile
, "attempt to use poisoned `%s'.", hp
->name
);
950 CPP_RESERVE (pfile
, 1);
951 CPP_PUTC_Q (pfile
, '0');
952 CPP_NUL_TERMINATE_Q (pfile
);
956 cpp_ice (pfile
, "invalid special hash type");
961 /* Expand a macro call.
962 HP points to the symbol that is the macro being called.
963 Put the result of expansion onto the input stack
964 so that subsequent input by our caller will use it.
966 If macro wants arguments, caller has already verified that
967 an argument list follows; arguments come from the input stack. */
970 macroexpand (pfile
, hp
)
976 register U_CHAR
*xbuf
;
977 long start_line
, start_column
;
979 struct argdata
*args
= 0;
980 long old_written
= CPP_WRITTEN (pfile
);
981 int rest_args
, rest_zero
= 0;
984 cpp_buf_line_and_col (cpp_file_buffer (pfile
), &start_line
, &start_column
);
986 /* Check for and handle special symbols. */
987 if (hp
->type
!= T_MACRO
)
989 special_symbol (hp
, pfile
);
990 xbuf_len
= CPP_WRITTEN (pfile
) - old_written
;
991 xbuf
= (U_CHAR
*) xmalloc (xbuf_len
+ 1);
992 CPP_SET_WRITTEN (pfile
, old_written
);
993 bcopy (CPP_PWRITTEN (pfile
), xbuf
, xbuf_len
+ 1);
994 push_macro_expansion (pfile
, xbuf
, xbuf_len
, hp
);
995 CPP_BUFFER (pfile
)->has_escapes
= 1;
999 defn
= hp
->value
.defn
;
1000 nargs
= defn
->nargs
;
1001 pfile
->output_escapes
++;
1005 enum cpp_token token
;
1007 args
= (struct argdata
*) alloca ((nargs
+ 1) * sizeof (struct argdata
));
1009 for (i
= 0; i
< nargs
; i
++)
1011 args
[i
].raw
= args
[i
].expanded
= 0;
1012 args
[i
].raw_length
= 0;
1013 args
[i
].expand_length
= args
[i
].stringified_length
= -1;
1016 /* Parse all the macro args that are supplied. I counts them.
1017 The first NARGS args are stored in ARGS.
1018 The rest are discarded. If rest_args is set then we assume
1019 macarg absorbed the rest of the args. */
1023 /* Skip over the opening parenthesis. */
1024 CPP_OPTIONS (pfile
)->discard_comments
++;
1025 CPP_OPTIONS (pfile
)->no_line_commands
++;
1026 pfile
->no_macro_expand
++;
1027 pfile
->no_directives
++;
1029 token
= cpp_get_non_space_token (pfile
);
1030 if (token
!= CPP_LPAREN
)
1031 cpp_ice (pfile
, "macroexpand: unexpected token %d (wanted LPAREN)",
1033 CPP_ADJUST_WRITTEN (pfile
, -1);
1040 if (i
< nargs
|| (nargs
== 0 && i
== 0))
1042 /* if we are working on last arg which absorbs rest of args... */
1043 if (i
== nargs
- 1 && defn
->rest_args
)
1045 args
[i
].raw
= CPP_WRITTEN (pfile
);
1046 token
= macarg (pfile
, rest_args
);
1047 args
[i
].raw_length
= CPP_WRITTEN (pfile
) - args
[i
].raw
;
1050 token
= macarg (pfile
, 0);
1051 if (token
== CPP_EOF
|| token
== CPP_POP
)
1052 cpp_error_with_line (pfile
, start_line
, start_column
,
1053 "unterminated macro call");
1056 while (token
== CPP_COMMA
);
1057 CPP_OPTIONS (pfile
)->discard_comments
--;
1058 CPP_OPTIONS (pfile
)->no_line_commands
--;
1059 pfile
->no_macro_expand
--;
1060 pfile
->no_directives
--;
1061 if (token
!= CPP_RPAREN
)
1064 /* If we got one arg but it was just whitespace, call that 0 args. */
1067 register U_CHAR
*bp
= ARG_BASE
+ args
[0].raw
;
1068 register U_CHAR
*lim
= bp
+ args
[0].raw_length
;
1069 /* cpp.texi says for foo ( ) we provide one argument.
1070 However, if foo wants just 0 arguments, treat this as 0. */
1072 while (bp
!= lim
&& is_space(*bp
))
1078 /* Don't output an error message if we have already output one for
1079 a parse error above. */
1081 if (nargs
== 0 && i
> 0)
1083 cpp_error (pfile
, "arguments given to macro `%s'", hp
->name
);
1087 /* traditional C allows foo() if foo wants one argument. */
1088 if (nargs
== 1 && i
== 0 && CPP_TRADITIONAL (pfile
))
1090 /* the rest args token is allowed to absorb 0 tokens */
1091 else if (i
== nargs
- 1 && defn
->rest_args
)
1094 cpp_error (pfile
, "macro `%s' used without args", hp
->name
);
1096 cpp_error (pfile
, "macro `%s' used with just one arg", hp
->name
);
1098 cpp_error (pfile
, "macro `%s' used with only %d args",
1104 "macro `%s' used with too many (%d) args", hp
->name
, i
);
1108 /* If macro wants zero args, we parsed the arglist for checking only.
1109 Read directly from the macro definition. */
1112 xbuf
= defn
->expansion
;
1113 xbuf_len
= defn
->length
;
1117 register U_CHAR
*exp
= defn
->expansion
;
1118 register int offset
; /* offset in expansion,
1119 copied a piece at a time */
1120 register int totlen
; /* total amount of exp buffer filled so far */
1122 register struct reflist
*ap
, *last_ap
;
1124 /* Macro really takes args. Compute the expansion of this call. */
1126 /* Compute length in characters of the macro's expansion.
1127 Also count number of times each arg is used. */
1128 xbuf_len
= defn
->length
;
1129 for (ap
= defn
->pattern
; ap
!= NULL
; ap
= ap
->next
)
1133 register struct argdata
*arg
= &args
[ap
->argno
];
1134 /* Stringify if it hasn't already been */
1135 if (arg
->stringified_length
< 0)
1137 int arglen
= arg
->raw_length
;
1141 /* Initially need_space is -1. Otherwise, 1 means the
1142 previous character was a space, but we suppressed it;
1143 0 means the previous character was a non-space. */
1144 int need_space
= -1;
1146 arg
->stringified
= CPP_WRITTEN (pfile
);
1147 if (!CPP_TRADITIONAL (pfile
))
1148 CPP_PUTC (pfile
, '\"'); /* insert beginning quote */
1149 for (; i
< arglen
; i
++)
1151 c
= (ARG_BASE
+ arg
->raw
)[i
];
1155 /* Delete "\r " and "\r-" escapes. */
1161 /* Internal sequences of whitespace are
1162 replaced by one space except within
1163 a string or char token. */
1164 else if (is_space(c
))
1166 if (need_space
== 0)
1170 else if (need_space
> 0)
1171 CPP_PUTC (pfile
, ' ');
1186 else if (c
== '\"' || c
== '\'')
1190 /* Escape these chars */
1191 if (c
== '\"' || (in_string
&& c
== '\\'))
1192 CPP_PUTC (pfile
, '\\');
1194 CPP_PUTC (pfile
, c
);
1197 CPP_RESERVE (pfile
, 4);
1198 sprintf ((char *) CPP_PWRITTEN (pfile
), "\\%03o",
1200 CPP_ADJUST_WRITTEN (pfile
, 4);
1203 if (!CPP_TRADITIONAL (pfile
))
1204 CPP_PUTC (pfile
, '\"'); /* insert ending quote */
1205 arg
->stringified_length
1206 = CPP_WRITTEN (pfile
) - arg
->stringified
;
1208 xbuf_len
+= args
[ap
->argno
].stringified_length
;
1210 else if (ap
->raw_before
|| ap
->raw_after
|| CPP_TRADITIONAL (pfile
))
1211 /* Add 4 for two \r-space markers to prevent
1212 token concatenation. */
1213 xbuf_len
+= args
[ap
->argno
].raw_length
+ 4;
1216 /* We have an ordinary (expanded) occurrence of the arg.
1217 So compute its expansion, if we have not already. */
1218 if (args
[ap
->argno
].expand_length
< 0)
1220 args
[ap
->argno
].expanded
= CPP_WRITTEN (pfile
);
1221 cpp_expand_to_buffer (pfile
,
1222 ARG_BASE
+ args
[ap
->argno
].raw
,
1223 args
[ap
->argno
].raw_length
);
1225 args
[ap
->argno
].expand_length
1226 = CPP_WRITTEN (pfile
) - args
[ap
->argno
].expanded
;
1229 /* Add 4 for two \r-space markers to prevent
1230 token concatenation. */
1231 xbuf_len
+= args
[ap
->argno
].expand_length
+ 4;
1235 xbuf
= (U_CHAR
*) xmalloc (xbuf_len
+ 1);
1237 /* Generate in XBUF the complete expansion
1238 with arguments substituted in.
1239 TOTLEN is the total size generated so far.
1240 OFFSET is the index in the definition
1241 of where we are copying from. */
1242 offset
= totlen
= 0;
1243 for (last_ap
= NULL
, ap
= defn
->pattern
; ap
!= NULL
;
1244 last_ap
= ap
, ap
= ap
->next
)
1246 register struct argdata
*arg
= &args
[ap
->argno
];
1247 int count_before
= totlen
;
1249 /* Add chars to XBUF. */
1250 for (i
= 0; i
< ap
->nchars
; i
++, offset
++)
1251 xbuf
[totlen
++] = exp
[offset
];
1253 /* If followed by an empty rest arg with concatenation,
1254 delete the last run of nonwhite chars. */
1255 if (rest_zero
&& totlen
> count_before
1256 && ((ap
->rest_args
&& ap
->raw_before
)
1257 || (last_ap
!= NULL
&& last_ap
->rest_args
1258 && last_ap
->raw_after
)))
1260 /* Delete final whitespace. */
1261 while (totlen
> count_before
&& is_space(xbuf
[totlen
- 1]))
1264 /* Delete the nonwhites before them. */
1265 while (totlen
> count_before
&& !is_space(xbuf
[totlen
- 1]))
1269 if (ap
->stringify
!= 0)
1271 bcopy (ARG_BASE
+ arg
->stringified
,
1272 xbuf
+ totlen
, arg
->stringified_length
);
1273 totlen
+= arg
->stringified_length
;
1275 else if (ap
->raw_before
|| ap
->raw_after
|| CPP_TRADITIONAL (pfile
))
1277 U_CHAR
*p1
= ARG_BASE
+ arg
->raw
;
1278 U_CHAR
*l1
= p1
+ arg
->raw_length
;
1281 /* Arg is concatenated before: delete leading whitespace,
1282 whitespace markers, and no-reexpansion markers. */
1285 if (is_space(p1
[0]))
1287 else if (p1
[0] == '\r')
1295 /* Arg is concatenated after: delete trailing whitespace,
1296 whitespace markers, and no-reexpansion markers. */
1299 if (is_space(l1
[-1]))
1301 else if (l1
[-1] == '\r')
1303 else if (l1
[-1] == '-')
1305 if (l1
!= p1
+ 1 && l1
[-2] == '\r')
1315 /* Delete any no-reexpansion marker that precedes
1316 an identifier at the beginning of the argument. */
1317 if (p1
[0] == '\r' && p1
[1] == '-')
1320 bcopy (p1
, xbuf
+ totlen
, l1
- p1
);
1325 U_CHAR
*expanded
= ARG_BASE
+ arg
->expanded
;
1326 if (!ap
->raw_before
&& totlen
> 0 && arg
->expand_length
1327 && !CPP_TRADITIONAL (pfile
)
1328 && unsafe_chars (xbuf
[totlen
- 1], expanded
[0]))
1330 xbuf
[totlen
++] = '\r';
1331 xbuf
[totlen
++] = ' ';
1334 bcopy (expanded
, xbuf
+ totlen
, arg
->expand_length
);
1335 totlen
+= arg
->expand_length
;
1337 if (!ap
->raw_after
&& totlen
> 0 && offset
< defn
->length
1338 && !CPP_TRADITIONAL (pfile
)
1339 && unsafe_chars (xbuf
[totlen
- 1], exp
[offset
]))
1341 xbuf
[totlen
++] = '\r';
1342 xbuf
[totlen
++] = ' ';
1346 if (totlen
> xbuf_len
)
1348 cpp_ice (pfile
, "buffer overrun in macroexpand");
1353 /* if there is anything left of the definition
1354 after handling the arg list, copy that in too. */
1356 for (i
= offset
; i
< defn
->length
; i
++)
1358 /* if we've reached the end of the macro */
1361 if (!(rest_zero
&& last_ap
!= NULL
&& last_ap
->rest_args
1362 && last_ap
->raw_after
))
1363 xbuf
[totlen
++] = exp
[i
];
1371 pfile
->output_escapes
--;
1373 /* Now put the expansion on the input stack
1374 so our caller will commence reading from it. */
1375 push_macro_expansion (pfile
, xbuf
, xbuf_len
, hp
);
1376 CPP_BUFFER (pfile
)->has_escapes
= 1;
1378 /* Pop the space we've used in the token_buffer for argument expansion. */
1379 CPP_SET_WRITTEN (pfile
, old_written
);
1381 /* Recursive macro use sometimes works traditionally.
1382 #define foo(x,y) bar (x (y,0), y)
1385 if (!CPP_TRADITIONAL (pfile
))
1386 hp
->type
= T_DISABLED
;
1389 /* Return 1 iff a token ending in C1 followed directly by a token C2
1390 could cause mis-tokenization. */
1393 unsafe_chars (c1
, c2
)
1399 if (c2
== c1
|| c2
== '=')
1403 case 'e': case 'E': case 'p': case 'P':
1404 if (c2
== '-' || c2
== '+')
1405 return 1; /* could extend a pre-processing number */
1409 if (c2
== '\'' || c2
== '\"')
1410 return 1; /* Could turn into L"xxx" or L'xxx'. */
1413 case '.': case '0': case '1': case '2': case '3':
1414 case '4': case '5': case '6': case '7': case '8': case '9':
1415 case '_': case 'a': case 'b': case 'c': case 'd': case 'f':
1416 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
1417 case 'm': case 'n': case 'o': case 'q': case 'r': case 's':
1418 case 't': case 'u': case 'v': case 'w': case 'x': case 'y':
1419 case 'z': case 'A': case 'B': case 'C': case 'D': case 'F':
1420 case 'G': case 'H': case 'I': case 'J': case 'K': case 'M':
1421 case 'N': case 'O': case 'Q': case 'R': case 'S': case 'T':
1422 case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z':
1424 /* We're in the middle of either a name or a pre-processing number. */
1425 return (is_idchar(c2
) || c2
== '.');
1427 case '<': case '>': case '!': case '%': case '#': case ':':
1428 case '^': case '&': case '|': case '*': case '/': case '=':
1429 return (c2
== c1
|| c2
== '=');
1435 push_macro_expansion (pfile
, xbuf
, xbuf_len
, hp
)
1437 register U_CHAR
*xbuf
;
1441 register cpp_buffer
*mbuf
= cpp_push_buffer (pfile
, xbuf
, xbuf_len
);
1444 mbuf
->cleanup
= macro_cleanup
;
1447 /* The first chars of the expansion should be a "\r " added by
1448 collect_expansion. This is to prevent accidental token-pasting
1449 between the text preceding the macro invocation, and the macro
1452 We would like to avoid adding unneeded spaces (for the sake of
1453 tools that use cpp, such as imake). In some common cases we can
1454 tell that it is safe to omit the space.
1456 The character before the macro invocation cannot have been an
1457 idchar (or else it would have been pasted with the idchars of
1458 the macro name). Therefore, if the first non-space character
1459 of the expansion is an idchar, we do not need the extra space
1460 to prevent token pasting.
1462 Also, we don't need the extra space if the first char is '(',
1463 or some other (less common) characters. */
1465 if (xbuf
[0] == '\r' && xbuf
[1] == ' '
1466 && (is_idchar(xbuf
[2]) || xbuf
[2] == '(' || xbuf
[2] == '\''
1467 || xbuf
[2] == '\"'))
1470 /* Likewise, avoid the extra space at the end of the macro expansion
1471 if this is safe. We can do a better job here since we can know
1472 what the next char will be. */
1474 && mbuf
->rlimit
[-2] == '\r'
1475 && mbuf
->rlimit
[-1] == ' ')
1477 int c1
= mbuf
->rlimit
[-3];
1478 int c2
= CPP_BUF_PEEK (CPP_PREV_BUFFER (CPP_BUFFER (pfile
)));
1479 if (c2
== EOF
|| !unsafe_chars (c1
, c2
))
1484 /* Return zero if two DEFINITIONs are isomorphic. */
1487 compare_defs (pfile
, d1
, d2
)
1489 DEFINITION
*d1
, *d2
;
1491 register struct reflist
*a1
, *a2
;
1492 register U_CHAR
*p1
= d1
->expansion
;
1493 register U_CHAR
*p2
= d2
->expansion
;
1496 if (d1
->nargs
!= d2
->nargs
)
1498 if (CPP_PEDANTIC (pfile
)
1499 && strcmp ((char *) d1
->argnames
, (char *) d2
->argnames
))
1501 for (a1
= d1
->pattern
, a2
= d2
->pattern
; a1
&& a2
;
1502 a1
= a1
->next
, a2
= a2
->next
)
1504 if (!((a1
->nchars
== a2
->nchars
&& !strncmp (p1
, p2
, a1
->nchars
))
1505 || !comp_def_part (first
, p1
, a1
->nchars
, p2
, a2
->nchars
, 0))
1506 || a1
->argno
!= a2
->argno
1507 || a1
->stringify
!= a2
->stringify
1508 || a1
->raw_before
!= a2
->raw_before
1509 || a1
->raw_after
!= a2
->raw_after
)
1518 return comp_def_part (first
, p1
, d1
->length
- (p1
- d1
->expansion
),
1519 p2
, d2
->length
- (p2
- d2
->expansion
), 1);
1522 /* Return 1 if two parts of two macro definitions are effectively different.
1523 One of the parts starts at BEG1 and has LEN1 chars;
1524 the other has LEN2 chars at BEG2.
1525 Any sequence of whitespace matches any other sequence of whitespace.
1526 FIRST means these parts are the first of a macro definition;
1527 so ignore leading whitespace entirely.
1528 LAST means these parts are the last of a macro definition;
1529 so ignore trailing whitespace entirely. */
1532 comp_def_part (first
, beg1
, len1
, beg2
, len2
, last
)
1534 U_CHAR
*beg1
, *beg2
;
1538 register U_CHAR
*end1
= beg1
+ len1
;
1539 register U_CHAR
*end2
= beg2
+ len2
;
1542 while (beg1
!= end1
&& is_space(*beg1
))
1544 while (beg2
!= end2
&& is_space(*beg2
))
1549 while (beg1
!= end1
&& is_space(end1
[-1]))
1551 while (beg2
!= end2
&& is_space(end2
[-1]))
1554 while (beg1
!= end1
&& beg2
!= end2
)
1556 if (is_space(*beg1
) && is_space(*beg2
))
1558 while (beg1
!= end1
&& is_space(*beg1
))
1560 while (beg2
!= end2
&& is_space(*beg2
))
1563 else if (*beg1
== *beg2
)
1571 return (beg1
!= end1
) || (beg2
!= end2
);
1574 /* Dump the definition of macro MACRO on stdout. The format is suitable
1575 to be read back in again. */
1578 dump_definition (pfile
, macro
)
1582 DEFINITION
*defn
= macro
.defn
;
1584 CPP_RESERVE (pfile
, macro
.symlen
+ sizeof "#define ");
1585 CPP_PUTS_Q (pfile
, "#define ", sizeof "#define " -1);
1586 CPP_PUTS_Q (pfile
, macro
.symnam
, macro
.symlen
);
1588 if (defn
->nargs
== -1)
1590 CPP_PUTC_Q (pfile
, ' ');
1592 /* The first and last two characters of a macro expansion are
1593 always "\r "; this needs to be trimmed out.
1594 So we need length-4 chars of space, plus one for the NUL. */
1595 CPP_RESERVE (pfile
, defn
->length
- 4 + 1);
1596 CPP_PUTS_Q (pfile
, defn
->expansion
+ 2, defn
->length
- 4);
1597 CPP_NUL_TERMINATE_Q (pfile
);
1602 unsigned char *argnames
= (unsigned char *) xstrdup (defn
->argnames
);
1603 unsigned char **argv
= (unsigned char **) alloca (defn
->nargs
*
1605 int *argl
= (int *) alloca (defn
->nargs
* sizeof(int));
1609 /* First extract the argument list. */
1615 while (*x
!= ',' && *x
!= '\0') x
++;
1616 argl
[i
] = x
- argv
[i
];
1620 x
+= 2; /* skip the space after the comma */
1624 /* Now print out the argument list. */
1625 CPP_PUTC_Q (pfile
, '(');
1626 for (i
= 0; i
< defn
->nargs
; i
++)
1628 CPP_RESERVE (pfile
, argl
[i
] + 2);
1629 CPP_PUTS_Q (pfile
, argv
[i
], argl
[i
]);
1630 if (i
< defn
->nargs
-1)
1631 CPP_PUTS_Q (pfile
, ", ", 2);
1634 if (defn
->rest_args
)
1635 CPP_PUTS (pfile
, "...) ", 5);
1637 CPP_PUTS (pfile
, ") ", 2);
1639 /* Now the definition. */
1640 x
= defn
->expansion
;
1641 for (r
= defn
->pattern
; r
; r
= r
->next
)
1644 if (*x
== '\r') x
+= 2, i
-= 2;
1645 /* i chars for macro text, plus the length of the macro
1646 argument name, plus one for a stringify marker, plus two for
1647 each concatenation marker. */
1649 i
+ argl
[r
->argno
] + r
->stringify
1650 + (r
->raw_before
+ r
->raw_after
) * 2);
1652 if (i
> 0) CPP_PUTS_Q (pfile
, x
, i
);
1654 CPP_PUTS_Q (pfile
, "##", 2);
1656 CPP_PUTC_Q (pfile
, '#');
1657 CPP_PUTS_Q (pfile
, argv
[r
->argno
], argl
[r
->argno
]);
1658 if (r
->raw_after
&& !(r
->next
&& r
->next
->nchars
== 0
1659 && r
->next
->raw_before
))
1660 CPP_PUTS_Q (pfile
, "##", 2);
1665 i
= defn
->length
- (x
- defn
->expansion
) - 2;
1666 if (*x
== '\r') x
+= 2, i
-= 2;
1667 if (i
> 0) CPP_PUTS (pfile
, x
, i
);
1668 CPP_NUL_TERMINATE (pfile
);
This page took 0.121614 seconds and 5 git commands to generate.