3 http://src.openresources.com/debian/src/devel/HTML/S/altgcc_2.7.2.2.orig%20altgcc-2.7.2.2.orig%20protoize.c.html
\r
5 abspath (cwd, rel_filename)
\r
10 *** cpplib.c.old Tue Nov 28 2000 09:04:09 AM
\r
11 --- cpplib.c Tue Nov 28 2000 08:55:18 AM
\r
14 c2 = cppReader_peekC (pfile)
\r
17 ! token = CPP_HSPACE
\r
21 c2 = cppReader_peekC (pfile)
\r
24 ! cppReader_forward (pfile, 1)
\r
30 cppReader_putChar (pfile, c)
\r
33 Carl J. Appellof ( mailto:cappello@legato.com <mailto:cappello@legato.com> )
\r
37 ** LCLint - annotation-assisted static program checker
\r
38 ** Copyright (C) 1994-2001 University of Virginia,
\r
39 ** Massachusetts Institute of Technology
\r
41 ** This program is free software; you can redistribute it and/or modify it
\r
42 ** under the terms of the GNU General Public License as published by the
\r
43 ** Free Software Foundation; either version 2 of the License, or (at your
\r
44 ** option) any later version.
\r
46 ** This program is distributed in the hope that it will be useful, but
\r
47 ** WITHOUT ANY WARRANTY; without even the implied warranty of
\r
48 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
\r
49 ** General Public License for more details.
\r
51 ** The GNU General Public License is available from http://www.gnu.org/ or
\r
52 ** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
\r
53 ** MA 02111-1307, USA.
\r
55 ** For information on lclint: lclint-request@cs.virginia.edu
\r
56 ** To report a bug: lclint-bug@cs.virginia.edu
\r
57 ** For more information: http://lclint.cs.virginia.edu
\r
63 Copyright (C) 1986, 87, 89, 92-6, 1997 Free Software Foundation, Inc.
\r
64 Contributed by Per Bothner, 1994-95.
\r
65 Based on CCCP program by Paul Rubin, June 1986
\r
66 Adapted to ANSI C, Richard Stallman, Jan 1987
\r
68 This program is free software; you can redistribute it and/or modify it
\r
69 under the terms of the GNU General Public License as published by the
\r
70 Free Software Foundation; either version 2, or (at your option) any
\r
73 This program is distributed in the hope that it will be useful,
\r
74 but WITHOUT ANY WARRANTY; without even the implied warranty of
\r
75 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
\r
76 GNU General Public License for more details.
\r
78 You should have received a copy of the GNU General Public License
\r
79 along with this program; if not, write to the Free Software
\r
80 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
\r
82 In other words, you are welcome to use, share and improve this program.
\r
83 You are forbidden to forbid anyone else to use, share and improve
\r
84 what you give them. Help stamp out software-hoarding! */
\r
87 * Herbert 06/12/2000:
\r
88 * - OS2 drive specs like WIN32
\r
89 * - Includes for IBMs OS/2 compiler
\r
94 # include <signal.h>
\r
96 # include <stdlib.h>
\r
99 # include <string.h>
\r
101 # if !(defined (WIN32) || defined (OS2) && defined (__IBMC__))
\r
102 # include <unistd.h>
\r
105 # include <sys/types.h>
\r
106 # include <sys/stat.h>
\r
107 # include <fcntl.h>
\r
109 # if defined (WIN32) || defined (OS2) && defined (__IBMC__)
\r
111 # include <sys/utime.h> /* for __DATE__ and __TIME__ */
\r
116 # include <time.h> /* Reported by Paul Smith */
\r
117 # include <sys/time.h>
\r
118 # include <sys/resource.h>
\r
120 # include <sys/times.h>
\r
122 # include <fcntl.h>
\r
124 # endif /* not VMS */
\r
125 # endif /* not WIN32 */
\r
127 /* This defines "errno" properly for VMS, and gives us EACCES. */
\r
128 # include <errno.h>
\r
130 # include "lclintMacros.nf"
\r
131 # include "llbasic.h"
\r
132 # include "lcllib.h"
\r
133 # include "cpplib.h"
\r
134 # include "cpperror.h"
\r
135 # include "cpphash.h"
\r
136 # include "cppexp.h"
\r
137 # include "version.h"
\r
138 # include "portab.h"
\r
142 ** This is really kludgey code...
\r
148 #define NO_SHORTNAMES
\r
156 /*@constant int IMPORT_FOUND@*/
\r
157 # define IMPORT_FOUND -2
\r
159 /*@constant int SKIP_INCLUDE@*/
\r
160 # define SKIP_INCLUDE IMPORT_FOUND
\r
162 /*@constant unused int IMPORT_NOT_FOUND@*/
\r
163 # define IMPORT_NOT_FOUND -1
\r
166 /*@constant unused int STDC_VALUE@*/
\r
167 #define STDC_VALUE 1
\r
170 /* By default, colon separates directories in a path. */
\r
171 #ifndef PATH_SEPARATOR
\r
172 /*@constant char PATH_SEPARATOR@*/
\r
173 #define PATH_SEPARATOR ':'
\r
176 static void parse_name (cppReader *, int);
\r
178 static int cpp_openIncludeFile (char *p_filename)
\r
179 /*@modifies fileSystem @*/ ;
\r
181 static void cpp_setLocation (cppReader *p_pfile)
\r
182 /*@modifies g_currentloc@*/ ;
\r
184 static enum cpp_token cpp_handleComment (cppReader *p_pfile,
\r
185 struct parse_marker *p_smark)
\r
186 /*@modifies p_pfile, p_smark@*/;
\r
188 static bool cpp_shouldCheckMacro (cppReader *p_pfile, char *p_p) /*@*/ ;
\r
190 static bool cpp_skipIncludeFile (cstring p_fname) /*@*/ ;
\r
196 /* Symbols to predefine. */
\r
198 #ifdef CPP_PREDEFINES
\r
199 static /*@observer@*/ char *predefs = CPP_PREDEFINES;
\r
201 static /*@observer@*/ char *predefs = "";
\r
204 /* We let tm.h override the types used here, to handle trivial differences
\r
205 such as the choice of unsigned int or long unsigned int for size_t.
\r
206 When machines start needing nontrivial differences in the size type,
\r
207 it would be best to do something here to figure out automatically
\r
208 from other information what type to use. */
\r
210 /* The string value for __SIZE_TYPE__. */
\r
213 /*@constant observer char *SIZE_TYPE@*/
\r
214 #define SIZE_TYPE "long unsigned int"
\r
217 /* The string value for __PTRDIFF_TYPE__. */
\r
219 #ifndef PTRDIFF_TYPE
\r
220 /*@constant observer char *PTRDIFF_TYPE@*/
\r
221 #define PTRDIFF_TYPE "long int"
\r
224 /* The string value for __WCHAR_TYPE__. */
\r
227 /*@constant observer char *WCHAR_TYPE@*/
\r
228 #define WCHAR_TYPE "int"
\r
231 /* The string value for __USER_LABEL_PREFIX__ */
\r
233 #ifndef USER_LABEL_PREFIX
\r
234 /*@constant observer char *USER_LABEL_PREFIX@*/
\r
235 #define USER_LABEL_PREFIX ""
\r
238 /* The string value for __REGISTER_PREFIX__ */
\r
240 #ifndef REGISTER_PREFIX
\r
241 /*@constant observer char *REGISTER_PREFIX@*/
\r
242 #define REGISTER_PREFIX ""
\r
245 /* table to tell if char can be part of a C identifier. */
\r
246 static bool is_idchar[256];
\r
247 /* table to tell if char can be first char of a c identifier. */
\r
248 static bool is_idstart[256];
\r
249 /* table to tell if c is horizontal space. */
\r
250 static bool is_hor_space[256];
\r
251 /* table to tell if c is horizontal or vertical space. */
\r
252 static bool is_space[256];
\r
254 static /*@exposed@*/ /*@null@*/ cppBuffer *
\r
255 cppReader_getBuffer (/*@special@*/ cppReader *p_pfile)
\r
256 /*@uses p_pfile->buffer@*/
\r
257 /*@modifies nothing@*/ ;
\r
260 # define SKIP_WHITE_SPACE(p) do { /*@access cstring@*/ while (is_hor_space[(int) *(p)]) { (p)++; } } /*@noaccess cstring@*/ while (0)
\r
263 # define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*(p)]) { (p)++; } } while (0)
\r
265 static int cpp_peekN (cppReader *p_pfile, int p_n) /*@*/ ;
\r
267 /*@function static int cppBuffer_get (sef cppBuffer *p_b) modifies *p_b ; @*/
\r
268 # define cppBuffer_get(BUFFER) \
\r
269 ((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur++ : EOF)
\r
271 /* Append string STR (of length N) to PFILE's output buffer. Make space. */
\r
272 /*@function static void cppReader_puts (sef cppReader *p_file, char *p_str, sef size_t p_n)
\r
273 modifies *p_file; @*/
\r
274 # define cppReader_puts(PFILE, STR, N) \
\r
275 cppReader_reserve(PFILE, N), cppReader_putStrN (PFILE, STR,N)
\r
277 /* Append character CH to PFILE's output buffer. Assume sufficient space. */
\r
279 /*@function static void cppReader_putCharQ (cppReader *p_file, char p_ch)
\r
280 modifies *p_file; @*/
\r
281 # define cppReader_putCharQ(PFILE, CH) (*(PFILE)->limit++ = (CH))
\r
283 /* Append character CH to PFILE's output buffer. Make space if need be. */
\r
285 /*@function static void cppReader_putChar (sef cppReader *p_file, char p_ch)
\r
286 modifies *p_file; @*/
\r
287 #define cppReader_putChar(PFILE, CH) (cppReader_reserve (PFILE, (size_t) 1), cppReader_putCharQ (PFILE, CH))
\r
289 /* Make sure PFILE->limit is followed by '\0'. */
\r
290 /*@function static void cppReader_nullTerminateQ (cppReader *p_file)
\r
291 modifies *p_file; @*/
\r
293 #define cppReader_nullTerminateQ(PFILE) (*(PFILE)->limit = 0)
\r
295 /*@function static void cppReader_nullTerminate (sef cppReader *p_file)
\r
296 modifies *p_file; @*/
\r
297 # define cppReader_nullTerminate(PFILE) \
\r
298 (cppReader_reserve (PFILE, (size_t) 1), *(PFILE)->limit = 0)
\r
300 /*@function static void cppReader_adjustWritten (cppReader *p_file, size_t)
\r
301 modifies *p_file; @*/
\r
302 #define cppReader_adjustWritten(PFILE,DELTA) ((PFILE)->limit += (DELTA))
\r
304 /*@function static bool cppReader_isC89 (cppReader *) modifies nothing; @*/
\r
305 #define cppReader_isC89(PFILE) (CPPOPTIONS(PFILE)->c89)
\r
307 /*@function static observer char *cppReader_wcharType (cppReader *)
\r
308 modifies nothing; @*/
\r
310 # define cppReader_wcharType(PFILE) \
\r
311 (CPPOPTIONS (PFILE)->cplusplus ? "__wchar_t" : WCHAR_TYPE)
\r
313 static void cppBuffer_forward (cppBuffer *p_buf, int p_n) /*@modifies *p_buf@*/ ;
\r
315 /*@function static void cppReader_forward (cppReader *p_pfile, int) modifies *p_pfile; @*/
\r
316 # define cppReader_forward(pfile, N) \
\r
317 (cppBuffer_forward (cppReader_getBufferSafe (pfile), (N)))
\r
319 /*@function static int cppReader_getC (cppReader *p_pfile) modifies *p_pfile; @*/
\r
320 # define cppReader_getC(pfile) (cppBuffer_get (cppReader_getBufferSafe (pfile)))
\r
322 /*@function static int cppReader_peekC (cppReader *) modifies nothing;@*/
\r
323 # define cppReader_peekC(pfile) (cppBufPeek (cppReader_getBufferSafe (pfile)))
\r
325 /* Move all backslash-newline pairs out of embarrassing places.
\r
326 Exchange all such pairs following BP
\r
327 with any potentially-embarrassing characters that follow them.
\r
328 Potentially-embarrassing characters are / and *
\r
329 (because a backslash-newline inside a comment delimiter
\r
330 would cause it not to be recognized). */
\r
333 # define NEWLINE_FIX \
\r
334 do { while (cppReader_peekC (pfile) == '\\' && cpp_peekN (pfile, 1) == '\n') { cppReader_forward (pfile, 2); } } while(FALSE)
\r
336 /* Same, but assume we've already read the potential '\\' into C. */
\r
338 # define NEWLINE_FIX1(C) do { \
\r
339 while ((C) == '\\' && cppReader_peekC (pfile) == '\n') { cppReader_forward (pfile, 1); (C) = cppReader_getC (pfile); }\
\r
342 static void parseSetMark (/*@out@*/ struct parse_marker *,
\r
344 static void parseClearMark (struct parse_marker *);
\r
345 static void parseGotoMark (struct parse_marker *, cppReader *);
\r
346 static void parseMoveMark (struct parse_marker *, cppReader *);
\r
348 /* If we have a huge buffer, may need to cache more recent counts */
\r
349 static /*@exposed@*/ char *cppLineBase (/*@sef@*/ cppBuffer *);
\r
351 static /*@exposed@*/ /*@null@*/ cppBuffer *
\r
352 cppReader_pushBuffer (cppReader *p_pfile,
\r
353 /*@owned@*/ /*@null@*/ char *, size_t)
\r
354 /*@modifies p_pfile@*/ ;
\r
356 static void cppReader_appendIncludeChain
\r
357 (cppReader *p_pfile,
\r
358 /*@keep@*/ struct file_name_list *p_first,
\r
359 /*@dependent@*/ struct file_name_list *p_last);
\r
361 static void cppReader_macroCleanup (cppBuffer *p_pbuf, cppReader *p_pfile);
\r
362 static enum cpp_token cppReader_nullUnderflow (/*@unused@*/ cppReader *p_pfile);
\r
364 static void cppReader_nullCleanup (/*@unused@*/ cppBuffer *p_pbuf,
\r
365 /*@unused@*/ cppReader *p_pfile);
\r
367 static void cppReader_fileCleanup (cppBuffer *p_pbuf,
\r
368 /*@unused@*/ cppReader *p_pfile);
\r
370 static int cppReader_handleDirective (cppReader *p_pfile);
\r
372 static void cppReader_scanBuffer (cppReader *p_pfile);
\r
374 # if defined (WIN32) || defined (OS2) && defined (__IBMC__)
\r
377 ** WIN32 (at least the VC++ include files) does not define mode_t.
\r
380 /*@-incondefs@*/ /*@-czechtypes@*/
\r
381 typedef unsigned int mode_t;
\r
382 /*@=incondefs@*/ /*@=czechtypes@*/
\r
386 static int file_size_and_mode (int p_fd, /*@out@*/ mode_t *p_mode_pointer,
\r
387 /*@out@*/ size_t *p_size_pointer);
\r
388 static int safe_read (int p_desc, /*@out@*/ char *p_ptr, int p_len);
\r
392 ** cppBuffer_isMacro is true if the buffer contains macro expansion.
\r
393 ** (Note that it is false while we're expanding marco *arguments*.)
\r
396 static bool cppBuffer_isMacro (/*@null@*/ cppBuffer *) /*@*/ ;
\r
398 static void path_include (cppReader *p_pfile, char *p_path)
\r
399 /*@modifies p_pfile@*/ ;
\r
401 static void initialize_builtins (cppReader *p_pfile)
\r
402 /*@modifies p_pfile@*/ ;
\r
404 static void initialize_char_syntax (struct cppOptions *p_opts) ;
\r
406 static int /*@alt void@*/ finclude (cppReader *p_pfile, int p_f,
\r
408 bool p_system_header_p,
\r
409 /*@dependent@*/ /*@null@*/ struct file_name_list *p_dirptr);
\r
411 static void validate_else (cppReader *p_pfile, cstring p_directive);
\r
413 static void conditional_skip (cppReader *p_pfile, int p_skip,
\r
414 enum node_type p_type,
\r
415 /*@dependent@*/ /*@null@*/ char *p_control_macro);
\r
417 static HOST_WIDE_INT eval_if_expression (cppReader *p_pfile,
\r
421 static void skip_if_group (cppReader *p_pfile, int p_any);
\r
423 static bool comp_def_part (bool p_first, char *p_beg1, int p_len1,
\r
424 char *p_beg2, int p_len2, bool p_last);
\r
427 extern void fancy_abort ();
\r
430 static bool redundant_include_p (cppReader *p_pfile, /*@null@*/ cstring p_name);
\r
431 static bool is_system_include (cppReader *p_pfile, cstring p_filename);
\r
433 static /*@observer@*/ /*@null@*/ struct file_name_map *
\r
434 read_name_map (cppReader *p_pfile, cstring p_dirname);
\r
436 static cstring read_filename_string (int p_ch, /*:open:*/ FILE *p_f);
\r
438 static int open_include_file (cppReader *p_pfile,
\r
439 /*@owned@*/ cstring p_fname,
\r
440 /*@null@*/ struct file_name_list *p_searchptr);
\r
442 static void push_macro_expansion (cppReader *,
\r
443 /*@owned@*/ char *, size_t,
\r
444 /*@dependent@*/ hashNode);
\r
446 /* Last arg to output_line_command. */
\r
447 enum file_change_code {
\r
448 same_file, enter_file, leave_file
\r
451 /* `struct directive' defines one #-directive, including how to handle it. */
\r
454 int length; /* Length of name */
\r
455 /*@null@*/ int (*func)(); /* Function to handle directive */
\r
456 /*@observer@*/ cstring name; /* Name of directive */
\r
457 enum node_type type; /* Code which describes which directive. */
\r
458 bool command_reads_line; /* One if rest of line is read by func. */
\r
459 bool traditional_comments; /* Nonzero: keep comments if -traditional. */
\r
460 bool pass_thru; /* Copy preprocessed directive to output file.*/
\r
463 /* These functions are declared to return int instead of void since they
\r
464 are going to be placed in a table and some old compilers have trouble with
\r
465 pointers to functions returning void. */
\r
467 static int do_define (cppReader *, /*@null@*/ struct directive *,
\r
469 static int do_defineAux (cppReader *, /*@null@*/ struct directive *,
\r
470 char *, char *, bool);
\r
472 static int do_line (cppReader *, /*@null@*/ struct directive *);
\r
473 static int do_include (cppReader *, struct directive *, char *, char *);
\r
474 static int do_undef (cppReader *, struct directive *, char *, char *);
\r
475 static int do_error (cppReader *, struct directive *, char *, char *);
\r
476 static int do_pragma (cppReader *, struct directive *, char *, char *);
\r
477 static int do_ident (cppReader *, struct directive *, char *, char *);
\r
478 static int do_if (cppReader *, struct directive *, char *, char *);
\r
479 static int do_xifdef (cppReader *, struct directive *, char *, char *);
\r
480 static int do_else (cppReader *, struct directive *, char *, char *);
\r
481 static int do_elif (cppReader *, struct directive *, char *, char *);
\r
482 static int do_endif (cppReader *, struct directive *, char *, char *);
\r
483 static int do_warning (cppReader *, struct directive *, char *, char *);
\r
485 /* If a buffer's dir field is SELF_DIR_DUMMY, it means the file was found
\r
486 via the same directory as the file that #included it. */
\r
488 /*@constant observer struct file_name_list *SELF_DIR_DUMMY@*/
\r
489 #define SELF_DIR_DUMMY ((struct file_name_list *) (~0))
\r
491 /* #include "file" looks in source file dir, then stack. */
\r
492 /* #include <file> just looks in the stack. */
\r
493 /* -I directories are added to the end, then the defaults are added. */
\r
495 /*@access cstring@*/
\r
497 static struct default_include {
\r
498 /*@dependent@*/ /*@observer@*/ cstring fname; /* The name of the directory. */
\r
499 int cplusplus; /* Only look here if we're compiling C++. */
\r
500 int cxx_aware; /* Includes in this directory don't need to
\r
501 be wrapped in extern "C" when compiling
\r
503 } include_defaults_array[]
\r
505 /* This is the dir for fixincludes. Put it just before
\r
506 the files that we fix. */
\r
507 { GCC_INCLUDE_DIR, 0, 0 },
\r
508 { GCC_INCLUDE_DIR2, 0, 0 },
\r
509 { cstring_undefined, 0, 0 }
\r
512 /*@noaccess cstring@*/
\r
514 /* Here is the actual list of #-directives, most-often-used first.
\r
515 The initialize_builtins function assumes #define is the very first. */
\r
517 /*@access cstring@*/
\r
519 static struct directive directive_table[] = {
\r
520 { 6, do_define, "define", T_DEFINE, FALSE, TRUE, FALSE },
\r
521 { 5, do_xifdef, "ifdef", T_IFDEF, TRUE, FALSE, FALSE },
\r
522 { 6, do_xifdef, "ifndef", T_IFNDEF, TRUE, FALSE, FALSE },
\r
523 { 7, do_include, "include", T_INCLUDE, TRUE, FALSE, FALSE },
\r
524 { 5, do_endif, "endif", T_ENDIF, TRUE, FALSE, FALSE },
\r
525 { 4, do_else, "else", T_ELSE, TRUE, FALSE, FALSE },
\r
526 { 2, do_if, "if", T_IF, TRUE, FALSE, FALSE },
\r
527 { 4, do_elif, "elif", T_ELIF, TRUE, FALSE, FALSE },
\r
528 { 5, do_undef, "undef", T_UNDEF, FALSE, FALSE, FALSE },
\r
529 { 5, do_error, "error", T_ERROR, FALSE, FALSE, FALSE },
\r
530 { 7, do_warning, "warning", T_WARNING, FALSE, FALSE, FALSE },
\r
531 { 6, do_pragma, "pragma", T_PRAGMA, FALSE, FALSE, TRUE},
\r
532 { 4, do_line, "line", T_LINE, TRUE, FALSE, FALSE },
\r
533 { 5, do_ident, "ident", T_IDENT, TRUE, FALSE, TRUE },
\r
534 /* { 8, do_unassert, "unassert", T_UNASSERT, TRUE, FALSE, FALSE }, */
\r
535 { -1, 0, "", T_UNUSED, FALSE, FALSE, FALSE },
\r
537 /*@noaccess cstring@*/
\r
539 static cstring searchPath_unparse (struct file_name_list *search_start)
\r
541 cstring res = cstring_newEmpty ();
\r
542 struct file_name_list *searchptr = NULL;
\r
544 for (searchptr = search_start; searchptr != NULL;
\r
545 searchptr = searchptr->next)
\r
547 if (!cstring_isEmpty (searchptr->fname)) {
\r
548 res = cstring_concatFree1 (res, searchptr->fname);
\r
549 if (searchptr->next != NULL) {
\r
550 res = cstring_appendChar (res, ';');
\r
560 initialize_char_syntax (struct cppOptions *opts)
\r
565 * Set up is_idchar and is_idstart tables. These should be
\r
566 * faster than saying (is_alpha (c) || c == '_'), etc.
\r
567 * Set up these things before calling any routines tthat
\r
571 for (i = 'a'; i <= 'z'; i++) {
\r
572 is_idchar[i - 'a' + 'A'] = TRUE;
\r
573 is_idchar[(int) i] = TRUE;
\r
574 is_idstart[i - 'a' + 'A'] = TRUE;
\r
575 is_idstart[(int) i] = TRUE;
\r
578 for (i = '0'; i <= '9'; i++)
\r
580 is_idchar[(int) i] = TRUE;
\r
583 is_idchar['_'] = TRUE;
\r
584 is_idstart['_'] = TRUE;
\r
585 is_idchar['$'] = opts->dollars_in_ident;
\r
586 is_idstart['$'] = opts->dollars_in_ident;
\r
588 /* horizontal space table */
\r
589 is_hor_space[' '] = TRUE;
\r
590 is_hor_space['\t'] = TRUE;
\r
591 is_hor_space['\v'] = TRUE;
\r
592 is_hor_space['\f'] = TRUE;
\r
593 is_hor_space['\r'] = TRUE;
\r
595 is_space[' '] = TRUE;
\r
596 is_space['\t'] = TRUE;
\r
597 is_space['\v'] = TRUE;
\r
598 is_space['\f'] = TRUE;
\r
599 is_space['\n'] = TRUE;
\r
600 is_space['\r'] = TRUE;
\r
603 bool isIdentifierChar (char c)
\r
605 return is_idchar[(int) c];
\r
608 /* Place into P_PFILE a quoted string representing the string SRC.
\r
609 Caller must reserve enough space in pfile->token_buffer. */
\r
612 quote_string (cppReader *pfile, char *src)
\r
616 cppReader_putCharQ (pfile, '\"');
\r
619 switch ((c = *src++))
\r
623 cppReader_putCharQ (pfile, c);
\r
626 sprintf (cppReader_getPWritten (pfile), "\\%03o",
\r
628 cppReader_adjustWritten (pfile, (size_t) 4);
\r
630 /*@switchbreak@*/ break;
\r
634 cppReader_putCharQ (pfile, '\\');
\r
635 cppReader_putCharQ (pfile, c);
\r
636 /*@switchbreak@*/ break;
\r
639 cppReader_putCharQ (pfile, '\"');
\r
640 cppReader_nullTerminateQ (pfile);
\r
646 /* Re-allocates PFILE->token_buffer so it will hold at least N more chars. */
\r
649 cppReader_growBuffer (cppReader *pfile, size_t n)
\r
651 size_t old_written = cppReader_getWritten (pfile);
\r
652 pfile->token_buffer_size = n + 2 * pfile->token_buffer_size;
\r
653 pfile->token_buffer = (char *)
\r
654 drealloc (pfile->token_buffer, pfile->token_buffer_size);
\r
655 cppReader_setWritten (pfile, old_written);
\r
659 * process a given definition string, for initialization
\r
660 * If STR is just an identifier, define it with value 1.
\r
661 * If STR has anything after the identifier, then it should
\r
662 * be identifier=definition.
\r
666 cppReader_define (cppReader *pfile, char *str)
\r
671 DPRINTF (("Cpp reader define: %s", str));
\r
673 if (!is_idstart[(int) *p])
\r
675 DPRINTF (("ERROR 1"));
\r
676 cppReader_error (pfile,
\r
677 message ("Malformed option `-D%s'",
\r
678 cstring_fromChars (str)));
\r
685 DPRINTF (("Here 2"));
\r
687 while (is_idchar[(int) *p])
\r
694 while (*p != ')' && *p != '\0') {
\r
703 message ("Malformed option: -D%s (no closing parenthesis)",
\r
704 cstring_fromChars (str)));
\r
708 DPRINTF (("Here 2"));
\r
712 buf = (char *) dmalloc (size_fromInt (p - str + 4));
\r
713 strcpy ((char *) buf, str);
\r
714 strcat ((char *) buf, " 1");
\r
716 else if (*p != '=')
\r
718 DPRINTF (("ERROR 2"));
\r
719 cppReader_error (pfile,
\r
720 message ("Malformed option: -D%s (expected '=', found '%c')",
\r
721 cstring_fromChars (str),
\r
728 /* Copy the entire option so we can modify it. */
\r
729 DPRINTF (("Copying..."));
\r
730 buf = (char *) dmalloc (2 * strlen (str) + 1);
\r
731 strncpy (buf, str, size_fromInt (p - str));
\r
733 /* Change the = to a space. */
\r
734 buf[p - str] = ' ';
\r
735 /* Scan for any backslash-newline and remove it. */
\r
741 if (*p == '\\' && p[1] == '\n')
\r
747 DPRINTF (("Here we are..."));
\r
751 llassert (buf != NULL);
\r
752 DPRINTF (("Do define: %s / %ld", buf, size_toLong (strlen (buf))));
\r
753 (void) do_define (pfile, NULL, buf, buf + strlen (buf));
\r
757 /* Append a chain of `struct file_name_list's
\r
758 to the end of the main include chain.
\r
759 FIRST is gthe beginning of the chain to append, and LAST is the end. */
\r
762 cppReader_appendIncludeChain (cppReader *pfile,
\r
763 struct file_name_list *first,
\r
764 struct file_name_list *last)
\r
766 struct cppOptions *opts = CPPOPTIONS (pfile);
\r
767 struct file_name_list *dir;
\r
769 if (first == NULL || last == NULL)
\r
774 if (opts->include == 0)
\r
776 opts->include = first;
\r
780 llassert (opts->last_include->next == NULL);
\r
781 opts->last_include->next = first;
\r
784 if (opts->first_bracket_include == 0)
\r
786 opts->first_bracket_include = first;
\r
788 for (dir = first; ; dir = dir->next) {
\r
789 int len = cstring_length (dir->fname) + INCLUDE_LEN_FUDGE;
\r
790 if (len > pfile->max_include_len)
\r
791 pfile->max_include_len = len;
\r
797 llassert (last->next == NULL);
\r
798 /* last->next = NULL; */
\r
799 opts->last_include = last;
\r
803 static /*@unused@*/ void
\r
804 cppReader_showIncludeChain (cppReader *pfile)
\r
806 struct file_name_list *dirs = CPPOPTIONS (pfile)->include;
\r
810 while (dirs != NULL)
\r
812 fprintf (stderr, "*%s*:", cstring_toCharsSafe (dirs->fname));
\r
816 fprintf (stderr, "\n");
\r
820 fprintf (stderr, "No includes\n");
\r
826 cppReader_getIncludePath ()
\r
828 cppReader *pfile = &g_cppState;
\r
829 struct file_name_list *dirs = CPPOPTIONS (pfile)->include;
\r
830 cstring res = cstring_undefined;
\r
834 while (dirs != NULL)
\r
836 res = message ("%q%c%s", res, PATH_SEPARATOR, dirs->fname);
\r
842 res = cstring_makeLiteral ("<no include path>");
\r
849 cppReader_addIncludeChain (cppReader *pfile, struct file_name_list *dir)
\r
851 struct cppOptions *opts = CPPOPTIONS (pfile);
\r
858 if (opts->include == 0)
\r
860 opts->include = dir;
\r
864 llassert (opts->last_include->next == NULL);
\r
865 opts->last_include->next = dir;
\r
868 if (opts->first_bracket_include == 0)
\r
870 int len = cstring_length (dir->fname) + INCLUDE_LEN_FUDGE;
\r
871 opts->first_bracket_include = dir;
\r
872 if (len > pfile->max_include_len)
\r
874 pfile->max_include_len = len;
\r
879 opts->last_include = dir;
\r
880 /* cppReader_showIncludeChain (pfile); */
\r
883 /* Given a colon-separated list of file names PATH,
\r
884 add all the names to the search path for include files. */
\r
887 path_include (cppReader *pfile, char *path)
\r
891 #ifdef __CYGWIN32__
\r
894 /* if we have a posix path list, convert to win32 path list */
\r
895 win32temp = (char *) dmalloc /*@i4@*/
\r
896 (cygwin32_posix_to_win32_path_list_buf_size (path));
\r
897 cygwin32_posix_to_win32_path_list (path, win32temp);
\r
907 struct file_name_list *dirtmp;
\r
909 /* Find the end of this name. */
\r
910 while (*q != '\0' && *q != PATH_SEPARATOR)
\r
917 /* An empty name in the path stands for the current directory. */
\r
918 name = (char *) dmalloc ((size_t) 2);
\r
924 /* Otherwise use the directory that is named. */
\r
925 name = (char *) dmalloc (size_fromInt (q - p + 1));
\r
926 memcpy (name, p, size_fromInt (q - p));
\r
927 name[q - p] = '\0';
\r
930 dirtmp = (struct file_name_list *) dmalloc (sizeof (*dirtmp));
\r
931 dirtmp->next = 0; /* New one goes on the end */
\r
932 dirtmp->control_macro = 0;
\r
933 dirtmp->c_system_include_path = 0;
\r
934 dirtmp->fname = cstring_fromChars (name);
\r
935 dirtmp->got_name_map = 0;
\r
936 cppReader_addIncludeChain (pfile, dirtmp);
\r
938 /* Advance past this name. */
\r
942 /* Skip the colon. */
\r
948 cppOptions_init (cppOptions *opts)
\r
950 memset ((char *) opts, 0, sizeof *opts);
\r
953 opts->in_fname = NULL;
\r
954 opts->out_fname = NULL;
\r
956 /* Initialize is_idchar to allow $. */
\r
957 opts->dollars_in_ident = TRUE;
\r
959 opts->no_line_commands = 0;
\r
960 opts->no_trigraphs = TRUE;
\r
961 opts->put_out_comments = 1;
\r
962 opts->print_include_names = 0;
\r
963 opts->dump_macros = DUMP_DEFINITIONS; /* DUMP_NONE; */
\r
964 opts->no_output = 0;
\r
965 opts->cplusplus = 0;
\r
967 opts->cplusplus_comments = 1;
\r
969 opts->lang_asm = 0;
\r
970 opts->for_lint = 0;
\r
972 opts->pedantic_errors = 0;
\r
973 opts->warn_comments = 0;
\r
974 opts->warnings_are_errors = 0;
\r
976 initialize_char_syntax (opts);
\r
980 cppReader_nullUnderflow (/*@unused@*/ cppReader *pfile)
\r
986 cppReader_nullCleanup (/*@unused@*/ cppBuffer *pbuf,
\r
987 /*@unused@*/ cppReader *pfile)
\r
993 cppReader_macroCleanup (cppBuffer *pbuf, /*@unused@*/ cppReader *pfile)
\r
995 hashNode macro = pbuf->hnode;
\r
997 if (macro->type == T_DISABLED)
\r
999 macro->type = T_MACRO;
\r
1002 if (macro->type != T_MACRO || pbuf->buf != macro->value.defn->expansion)
\r
1004 sfree (pbuf->buf);
\r
1010 cppReader_fileCleanup (cppBuffer *pbuf, /*@unused@*/ cppReader *pfile)
\r
1012 if (pbuf->buf != NULL)
\r
1014 sfree (pbuf->buf);
\r
1019 /* Assuming we have read '/'.
\r
1020 If this is the start of a comment (followed by '*' or '/'),
\r
1021 skip to the end of the comment, and return ' '.
\r
1022 Return EOF if we reached the end of file before the end of the comment.
\r
1023 If not the start of a comment, return '/'. */
\r
1026 skip_comment (cppReader *pfile, /*@null@*/ long *linep)
\r
1030 llassert (pfile->buffer != NULL);
\r
1031 llassert (pfile->buffer->cur != NULL);
\r
1033 while (cppReader_peekC (pfile) == '\\' && cpp_peekN (pfile, 1) == '\n')
\r
1035 if (linep != NULL)
\r
1040 cppReader_forward (pfile, 2);
\r
1043 if (cppReader_peekC (pfile) == '*')
\r
1045 cppReader_forward (pfile, 1);
\r
1050 c = cppReader_getC (pfile);
\r
1057 while (c == (int) '\\' && cppReader_peekC (pfile) == (int) '\n')
\r
1059 if (linep != NULL )
\r
1064 cppReader_forward (pfile, 1), c = cppReader_getC (pfile);
\r
1067 if (prev_c == (int) '*' && c == (int) '/')
\r
1072 if (c == (int) '\n' && (linep != NULL))
\r
1078 else if (cppReader_peekC (pfile) == '/'
\r
1079 && CPPOPTIONS (pfile)->cplusplus_comments)
\r
1081 cppReader_forward (pfile, 1);
\r
1085 c = cppReader_getC (pfile);
\r
1089 /* Allow hash comment to be terminated by EOF. */
\r
1090 return (int) ' ';
\r
1093 while (c == (int) '\\' && cppReader_peekC (pfile) == '\n')
\r
1095 cppReader_forward (pfile, 1);
\r
1096 c = cppReader_getC (pfile);
\r
1098 if (linep != NULL)
\r
1104 if (c == (int) '\n')
\r
1106 /* Don't consider final '\n' to be part of comment. */
\r
1107 cppReader_forward (pfile, -1);
\r
1118 /* Skip whitespace \-newline and comments. Does not macro-expand. */
\r
1119 int /*@alt void@*/
\r
1120 cppSkipHspace (cppReader *pfile)
\r
1128 llassert (pfile->buffer != NULL);
\r
1130 c = cppReader_peekC (pfile);
\r
1134 return 0; /* FIXME */
\r
1137 if (is_hor_space[c])
\r
1139 if ((c == '\f' || c == '\v') && cppReader_isPedantic (pfile))
\r
1140 cppReader_pedwarn (pfile,
\r
1141 message ("%s in preprocessing directive",
\r
1143 ? cstring_makeLiteralTemp ("formfeed")
\r
1144 : cstring_makeLiteralTemp ("vertical tab")));
\r
1147 cppReader_forward (pfile, 1);
\r
1149 else if (c == '/')
\r
1151 cppReader_forward (pfile, 1);
\r
1152 c = skip_comment (pfile, NULL);
\r
1156 cppReader_forward (pfile, -1);
\r
1159 if (c == EOF || c == '/')
\r
1164 else if (c == '\\' && cpp_peekN (pfile, 1) == '\n')
\r
1166 cppReader_forward (pfile, 2);
\r
1168 else if (c == '@' && CPPBUFFER (pfile)->has_escapes
\r
1169 && is_hor_space [cpp_peekN (pfile, 1)])
\r
1171 cppReader_forward (pfile, 2);
\r
1180 /* Read the rest of the current line.
\r
1181 The line is appended to PFILE's output buffer. */
\r
1184 copy_rest_of_line (cppReader *pfile)
\r
1186 struct cppOptions *opts = CPPOPTIONS (pfile);
\r
1193 llassert (pfile->buffer != NULL);
\r
1195 c = cppReader_getC (pfile);
\r
1199 goto end_directive;
\r
1201 if (cppReader_peekC (pfile) == '\n')
\r
1203 cppReader_forward (pfile, 1);
\r
1207 /*@fallthrough@*/ case '\'': case '\"':
\r
1208 goto scan_directive_token;
\r
1211 nextc = cppReader_peekC (pfile);
\r
1214 ** was (opts->cplusplus_comments && nextc == '*')
\r
1219 || (opts->cplusplus_comments && nextc == '/'))
\r
1221 goto scan_directive_token;
\r
1223 /*@switchbreak@*/ break;
\r
1226 if (cppReader_isPedantic (pfile))
\r
1227 cppReader_pedwarn (pfile,
\r
1228 message ("%s in preprocessing directive",
\r
1230 ? cstring_makeLiteralTemp ("formfeed")
\r
1231 : cstring_makeLiteralTemp ("vertical tab")));
\r
1232 /*@switchbreak@*/ break;
\r
1235 cppReader_forward (pfile, -1);
\r
1236 goto end_directive;
\r
1237 scan_directive_token:
\r
1238 cppReader_forward (pfile, -1);
\r
1239 (void) cppGetToken (pfile);
\r
1242 cppReader_putChar (pfile, c);
\r
1245 cppReader_nullTerminate (pfile);
\r
1249 cppReader_skipRestOfLine (cppReader *pfile)
\r
1251 size_t old = cppReader_getWritten (pfile);
\r
1252 copy_rest_of_line (pfile);
\r
1253 cppReader_setWritten (pfile, old);
\r
1256 /* Handle a possible # directive.
\r
1257 '#' has already been read. */
\r
1260 cppReader_handleDirective (cppReader *pfile)
\r
1263 struct directive *kt = NULL;
\r
1265 size_t after_ident = 0;
\r
1266 char *ident = NULL;
\r
1267 char *line_end = NULL;
\r
1268 size_t old_written = cppReader_getWritten (pfile);
\r
1269 int nspaces = cppSkipHspace (pfile);
\r
1271 c = cppReader_peekC (pfile);
\r
1273 if (c >= '0' && c <= '9')
\r
1275 /* Handle # followed by a line number. */
\r
1276 if (cppReader_isPedantic (pfile))
\r
1278 cppReader_pedwarnLit
\r
1280 cstring_makeLiteralTemp ("`#' followed by integer"));
\r
1283 (void) do_line (pfile, NULL);
\r
1284 goto done_a_directive;
\r
1288 /* Now find the directive name. */
\r
1290 cppReader_putChar (pfile, '#');
\r
1292 parse_name (pfile, cppReader_getC (pfile));
\r
1294 llassert (pfile->token_buffer != NULL);
\r
1295 ident = pfile->token_buffer + old_written + 1;
\r
1297 ident_length = cppReader_getPWritten (pfile) - ident;
\r
1299 if (ident_length == 0 && cppReader_peekC (pfile) == '\n')
\r
1301 /* A line of just `#' becomes blank. */
\r
1305 for (kt = directive_table; ; kt++)
\r
1307 if (kt->length <= 0)
\r
1309 return 0; /* goto not_a_directive; */
\r
1312 if (kt->length == ident_length
\r
1313 && (cstring_equalPrefix (kt->name, cstring_fromChars (ident))))
\r
1319 if (kt->command_reads_line)
\r
1325 /* Nonzero means do not delete comments within the directive.
\r
1326 #define needs this when -traditional. */
\r
1327 bool comments = 1; /*cppReader_isTraditional (pfile) && kt->traditional_comments; */
\r
1328 int save_put_out_comments = CPPOPTIONS (pfile)->put_out_comments;
\r
1329 CPPOPTIONS (pfile)->put_out_comments = comments;
\r
1330 after_ident = cppReader_getWritten (pfile);
\r
1331 copy_rest_of_line (pfile);
\r
1332 CPPOPTIONS (pfile)->put_out_comments = save_put_out_comments;
\r
1336 /* For #pragma and #define, we may want to pass through the directive.
\r
1337 Other directives may create output, but we don't want the directive
\r
1338 itself out, so we pop it now. For example #include may write a #line
\r
1339 command (see comment in do_include), and conditionals may emit
\r
1340 #failed ... #endfailed stuff. But note that popping the buffer
\r
1341 means the parameters to kt->func may point after pfile->limit
\r
1342 so these parameters are invalid as soon as something gets appended
\r
1343 to the token_buffer. */
\r
1345 line_end = cppReader_getPWritten (pfile);
\r
1348 if (!kt->pass_thru && kt->type != T_DEFINE)
\r
1350 cppReader_setWritten (pfile, old_written);
\r
1353 llassert (pfile->token_buffer != NULL);
\r
1355 /* was kt->pass_thru || */
\r
1357 if (kt->type == T_DEFINE
\r
1358 && cpp_shouldCheckMacro (pfile, pfile->token_buffer + old_written))
\r
1360 char *p = pfile->token_buffer + old_written;
\r
1363 ** Still need to record value for preprocessing, so
\r
1364 ** #ifdef's, etc. using the value behave correctly.
\r
1367 (void) do_defineAux (pfile, kt,
\r
1368 pfile->token_buffer + after_ident,
\r
1377 SKIP_WHITE_SPACE (p);
\r
1379 llassert (*p == 'd');
\r
1380 *p++ = LLMRCODE[0];
\r
1382 llassert (*p == 'e');
\r
1383 *p++ = LLMRCODE[1];
\r
1385 llassert (*p == 'f');
\r
1386 *p++ = LLMRCODE[2];
\r
1388 llassert (*p == 'i');
\r
1389 *p++ = LLMRCODE[3];
\r
1391 llassert (*p == 'n');
\r
1392 *p++ = LLMRCODE[4];
\r
1394 llassert (*p == 'e');
\r
1397 ** This is way-bogus. We use the last char to record the number of
\r
1398 ** spaces. Its too hard to get them back into the input stream.
\r
1401 if (nspaces > 9) nspaces = 9;
\r
1403 *p++ = '0' + nspaces;
\r
1405 return 0; /* not_a_directive */
\r
1407 else if (kt->pass_thru)
\r
1409 /* Just leave the entire #define in the output stack. */
\r
1410 return 0; /* not_a_directive */
\r
1413 else if (kt->type == T_DEFINE
\r
1414 && CPPOPTIONS (pfile)->dump_macros == DUMP_NAMES)
\r
1416 char *p = pfile->token_buffer + old_written + 7; /* Skip "#define". */
\r
1417 SKIP_WHITE_SPACE (p);
\r
1419 while (is_idchar[(int) *p])
\r
1425 cppReader_putChar (pfile, '\n');
\r
1427 else if (kt->type == T_DEFINE)
\r
1429 cppReader_setWritten (pfile, old_written);
\r
1440 llassert (kt->func != NULL);
\r
1441 (void) (kt->func) (pfile, kt, pfile->token_buffer + after_ident, line_end);
\r
1446 /* Pass a directive through to the output file.
\r
1447 BUF points to the contents of the directive, as a contiguous string.
\r
1448 LIMIT points to the first character past the end of the directive.
\r
1449 KEYWORD is the keyword-table entry for the directive. */
\r
1452 pass_thru_directive (char *buf, char *limit,
\r
1454 struct directive *keyword)
\r
1456 int keyword_length = keyword->length;
\r
1458 cppReader_reserve (pfile,
\r
1459 size_fromInt (2 + keyword_length + (limit - buf)));
\r
1460 cppReader_putCharQ (pfile, '#');
\r
1461 /*@-observertrans@*/
\r
1462 cppReader_putStrN (pfile, cstring_toCharsSafe (keyword->name),
\r
1463 size_fromInt (keyword_length));
\r
1464 /*:=observertrans@*/
\r
1466 if (limit != buf && buf[0] != ' ')
\r
1468 /* Was a bug, since reserve only used 1 + ... */
\r
1469 cppReader_putCharQ (pfile, ' ');
\r
1472 cppReader_putStrN (pfile, buf, size_fromInt (limit - buf));
\r
1475 /* Read a replacement list for a macro with parameters.
\r
1476 Build the DEFINITION structure.
\r
1477 Reads characters of text starting at BUF until END.
\r
1478 ARGLIST specifies the formal parameters to look for
\r
1479 in the text of the definition; NARGS is the number of args
\r
1480 in that list, or -1 for a macro name that wants no argument list.
\r
1481 MACRONAME is the macro name itself (so we can avoid recursive expansion)
\r
1482 and NAMELEN is its length in characters.
\r
1484 Note that comments, backslash-newlines, and leading white space
\r
1485 have already been deleted from the argument. */
\r
1487 static DEFINITION *
\r
1488 collect_expansion (cppReader *pfile, char *buf, char *limit,
\r
1489 int nargs, /*@null@*/ struct arglist *arglist)
\r
1492 char *p, *lastp, *exp_p;
\r
1493 struct reflist *endpat = NULL;
\r
1494 /* Pointer to first nonspace after last ## seen. */
\r
1496 /* Pointer to first nonspace after last single-# seen. */
\r
1497 char *stringify = 0;
\r
1499 char expected_delimiter = '\0';
\r
1502 /* Scan thru the replacement list, ignoring comments and quoted
\r
1503 strings, picking up on the macro calls. It does a linear search
\r
1504 thru the arg list on every potential symbol. Profiling might say
\r
1505 that something smarter should happen. */
\r
1510 /* Find the beginning of the trailing whitespace. */
\r
1513 while (p < limit && is_space[(int) limit[-1]])
\r
1518 /* Allocate space for the text in the macro definition.
\r
1519 Leading and trailing whitespace chars need 2 bytes each.
\r
1520 Each other input char may or may not need 1 byte,
\r
1521 so this is an upper bound. The extra 5 are for invented
\r
1522 leading and trailing newline-marker and final null. */
\r
1523 maxsize = (sizeof (*defn) + (limit - p) + 5);
\r
1525 /* Occurrences of '@' get doubled, so allocate extra space for them. */
\r
1534 defn = (DEFINITION *) dmalloc (maxsize);
\r
1535 defn->noExpand = FALSE;
\r
1536 defn->file = NULL;
\r
1537 defn->pattern = NULL;
\r
1538 defn->nargs = nargs;
\r
1539 defn->predefined = NULL;
\r
1541 exp_p = defn->expansion = (char *) defn + sizeof (*defn);
\r
1544 defn->rest_args = NULL;
\r
1545 defn->args.argnames = NULL;
\r
1551 /* Add one initial space escape-marker to prevent accidental
\r
1552 token-pasting (often removed by macroexpand). */
\r
1556 if (limit - p >= 2 && p[0] == '#' && p[1] == '#') {
\r
1557 cppReader_errorLit (pfile,
\r
1558 cstring_makeLiteralTemp ("`##' at start of macro definition"));
\r
1562 /* Process the main body of the definition. */
\r
1563 while (p < limit) {
\r
1564 int skipped_arg = 0;
\r
1565 register char c = *p++;
\r
1569 if (!cppReader_isTraditional (pfile)) {
\r
1573 if (expected_delimiter != '\0')
\r
1575 if (c == expected_delimiter)
\r
1576 expected_delimiter = '\0';
\r
1580 expected_delimiter = c;
\r
1582 /*@switchbreak@*/ break;
\r
1585 if (p < limit && (expected_delimiter != '\0'))
\r
1587 /* In a string, backslash goes through
\r
1588 and makes next char ordinary. */
\r
1591 /*@switchbreak@*/ break;
\r
1594 /* An '@' in a string or character constant stands for itself,
\r
1595 and does not need to be escaped. */
\r
1596 if (expected_delimiter == '\0')
\r
1601 /*@switchbreak@*/ break;
\r
1604 /* # is ordinary inside a string. */
\r
1605 if (expected_delimiter != '\0')
\r
1607 /*@switchbreak@*/ break;
\r
1610 if (p < limit && *p == '#') {
\r
1611 /* ##: concatenate preceding and following tokens. */
\r
1612 /* Take out the first #, discard preceding whitespace. */
\r
1616 while (exp_p > lastp && is_hor_space[(int) exp_p[-1]])
\r
1622 /* Skip the second #. */
\r
1624 /* Discard following whitespace. */
\r
1625 SKIP_WHITE_SPACE (p);
\r
1629 cppReader_errorLit (pfile,
\r
1630 cstring_makeLiteralTemp ("`##' at end of macro definition"));
\r
1632 } else if (nargs >= 0) {
\r
1633 /* Single #: stringify following argument ref.
\r
1634 Don't leave the # in the expansion. */
\r
1636 SKIP_WHITE_SPACE (p);
\r
1637 if (p == limit || ! is_idstart[(int) *p]
\r
1638 || (*p == 'L' && p + 1 < limit && (p[1] == '\'' || p[1] == '"')))
\r
1639 cppReader_errorLit (pfile,
\r
1640 cstring_makeLiteralTemp ("`#' operator is not followed by a macro argument name"));
\r
1644 ; /* BADBRANCH; */
\r
1647 /*@switchbreak@*/ break;
\r
1650 /* In -traditional mode, recognize arguments inside strings and
\r
1651 and character constants, and ignore special properties of #.
\r
1652 Arguments inside strings are considered "stringified", but no
\r
1653 extra quote marks are supplied. */
\r
1657 if (expected_delimiter != '\0') {
\r
1658 if (c == expected_delimiter)
\r
1659 expected_delimiter = '\0';
\r
1661 expected_delimiter = c;
\r
1662 /*@switchbreak@*/ break;
\r
1665 /* Backslash quotes delimiters and itself, but not macro args. */
\r
1666 if (expected_delimiter != '\0' && p < limit
\r
1667 && (*p == expected_delimiter || *p == '\\')) {
\r
1671 /*@switchbreak@*/ break;
\r
1674 if (expected_delimiter != '\0') /* No comments inside strings. */
\r
1675 /*@switchbreak@*/ break;
\r
1677 /* If we find a comment that wasn't removed by cppReader_handleDirective,
\r
1678 this must be -traditional. So replace the comment with
\r
1679 nothing at all. */
\r
1682 while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
\r
1687 /*@switchbreak@*/ break;
\r
1691 /* Handle the start of a symbol. */
\r
1692 if (is_idchar[(int) c] && nargs > 0) {
\r
1693 char *id_beg = p - 1;
\r
1697 while (p != limit && is_idchar[(int) *p])
\r
1702 id_len = p - id_beg;
\r
1704 if (is_idstart[(int) c]
\r
1705 && ! (id_len == 1 && c == 'L' && (*p == '\'' || *p == '"'))) {
\r
1706 register struct arglist *arg;
\r
1708 for (arg = arglist; arg != NULL; arg = arg->next) {
\r
1709 struct reflist *tpat;
\r
1711 if (arg->name[0] == c
\r
1712 && arg->length == id_len
\r
1713 && strncmp (arg->name, id_beg, size_fromInt (id_len)) == 0) {
\r
1716 if (expected_delimiter && CPPOPTIONS (pfile)->warn_stringify) {
\r
1717 if (cppReader_isTraditional (pfile)) {
\r
1718 cppReader_warning (pfile,
\r
1719 message ("macro argument `%x' is stringified.",
\r
1720 cstring_prefix (cstring_fromChars (arg->name), id_len)));
\r
1722 cppReader_warning (pfile,
\r
1723 message ("macro arg `%x' would be stringified with -traditional.",
\r
1724 cstring_prefix (cstring_fromChars (arg->name), id_len)));
\r
1727 /* If ANSI, don't actually substitute inside a string. */
\r
1728 if (!cppReader_isTraditional (pfile) && expected_delimiter)
\r
1729 /*@innerbreak@*/ break;
\r
1730 /* make a pat node for this arg and append it to the end of
\r
1732 tpat = (struct reflist *) dmalloc (sizeof (*tpat));
\r
1733 tpat->next = NULL;
\r
1734 tpat->raw_before = (concat == id_beg);
\r
1735 tpat->raw_after = 0;
\r
1736 tpat->rest_args = arg->rest_args;
\r
1737 tpat->stringify = (cppReader_isTraditional (pfile)
\r
1738 ? expected_delimiter != '\0'
\r
1739 : stringify == id_beg);
\r
1741 if (endpat == NULL)
\r
1743 defn->pattern = tpat;
\r
1747 endpat->next = tpat;
\r
1748 /*@-branchstate@*/
\r
1749 } /*@=branchstate@*/ /* evs 2000 was =branchstate */
\r
1753 tpat->argno = arg->argno;
\r
1754 tpat->nchars = exp_p - lastp;
\r
1758 SKIP_WHITE_SPACE (p1);
\r
1760 if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
\r
1762 tpat->raw_after = 1;
\r
1765 lastp = exp_p; /* place to start copying from next time */
\r
1768 /*@innerbreak@*/ break;
\r
1773 /* If this was not a macro arg, copy it into the expansion. */
\r
1774 if (skipped_arg == 0) {
\r
1775 register char *lim1 = p;
\r
1783 if (stringify == id_beg)
\r
1784 cppReader_errorLit (pfile,
\r
1785 cstring_makeLiteralTemp ("`#' operator should be followed by a macro argument name"));
\r
1790 if (!cppReader_isTraditional (pfile) && expected_delimiter == '\0')
\r
1792 /* If ANSI, put in a "@ " marker to prevent token pasting.
\r
1793 But not if "inside a string" (which in ANSI mode
\r
1794 happens only for -D option). */
\r
1801 defn->length = size_fromInt (exp_p - defn->expansion);
\r
1803 /* Crash now if we overrun the allocated size. */
\r
1804 if (defn->length + 1 > maxsize)
\r
1806 llfatalbug (cstring_makeLiteral ("Maximum definition size exceeded."));
\r
1813 * special extension string that can be added to the last macro argument to
\r
1814 * allow it to absorb the "rest" of the arguments when expanded. Ex:
\r
1815 * #define wow(a, b...) process (b, a, b)
\r
1816 * { wow (1, 2, 3); } -> { process (2, 3, 1, 2, 3); }
\r
1817 * { wow (one, two); } -> { process (two, one, two); }
\r
1818 * if this "rest_arg" is used with the concat token '##' and if it is not
\r
1819 * supplied then the token attached to with ## will not be outputted. Ex:
\r
1820 * #define wow (a, b...) process (b ## , a, ## b)
\r
1821 * { wow (1, 2); } -> { process (2, 1, 2); }
\r
1822 * { wow (one); } -> { process (one); {
\r
1825 /*@-readonlytrans@*/
\r
1826 static char rest_extension[] = "...";
\r
1827 /*:=readonlytrans@*/
\r
1830 #define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1)
\r
1832 /* Create a DEFINITION node from a #define directive. Arguments are
\r
1833 as for do_define. */
\r
1835 static /*@null@*/ MACRODEF
\r
1836 create_definition (char *buf, char *limit,
\r
1837 cppReader *pfile, bool predefinition,
\r
1840 char *bp; /* temp ptr into input buffer */
\r
1841 char *symname; /* remember where symbol name starts */
\r
1842 int sym_length; /* and how long it is */
\r
1843 int rest_args = 0; /* really int! */
\r
1846 cstring file = (CPPBUFFER (pfile) != NULL)
\r
1847 ? CPPBUFFER (pfile)->nominal_fname : cstring_makeLiteralTemp ("");
\r
1849 int arglengths = 0; /* Accumulate lengths of arg names
\r
1850 plus number of args. */
\r
1853 cppBuffer_lineAndColumn (CPPBUFFER (pfile), &line, &col);
\r
1857 while (is_hor_space[(int) *bp])
\r
1862 symname = bp; /* remember where it starts */
\r
1864 sym_length = cppReader_checkMacroName (pfile, bp, cstring_makeLiteralTemp ("macro"));
\r
1868 /* Lossage will occur if identifiers or control keywords are broken
\r
1869 across lines using backslash. This is not the right place to take
\r
1873 struct arglist *arg_ptrs = NULL;
\r
1876 bp++; /* skip '(' */
\r
1877 SKIP_WHITE_SPACE (bp);
\r
1879 /* Loop over macro argument names. */
\r
1880 while (*bp != ')')
\r
1882 struct arglist *temp = (struct arglist *) dmalloc (sizeof (*temp));
\r
1884 temp->next = arg_ptrs;
\r
1885 temp->argno = argno++;
\r
1886 temp->rest_args = 0;
\r
1890 if (rest_args != 0)
\r
1892 cppReader_pedwarn (pfile,
\r
1893 message ("another parameter follows `%s'",
\r
1894 cstring_fromChars (rest_extension)));
\r
1897 if (!is_idstart[(int) *bp])
\r
1899 cppReader_pedwarnLit (pfile,
\r
1900 cstring_makeLiteralTemp ("invalid character in macro parameter name"));
\r
1903 /* Find the end of the arg name. */
\r
1904 while (is_idchar[(int) *bp])
\r
1907 /* do we have a "special" rest-args extension here? */
\r
1908 if (limit - bp > size_toInt (REST_EXTENSION_LENGTH)
\r
1909 && strncmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0)
\r
1912 temp->rest_args = 1;
\r
1913 /*@innerbreak@*/ break;
\r
1917 temp->length = bp - temp->name;
\r
1919 if (rest_args != 0)
\r
1921 bp += REST_EXTENSION_LENGTH;
\r
1924 arglengths += temp->length + 2;
\r
1925 SKIP_WHITE_SPACE (bp);
\r
1927 if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
\r
1928 cppReader_errorLit (pfile,
\r
1929 cstring_makeLiteralTemp ("Parameter list for #define is not parseable"));
\r
1935 SKIP_WHITE_SPACE (bp);
\r
1937 if (bp >= limit) {
\r
1938 cppReader_errorLit (pfile,
\r
1939 cstring_makeLiteralTemp ("unterminated parameter list in `#define'"));
\r
1943 struct arglist *otemp;
\r
1945 for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
\r
1947 if (temp->length == otemp->length &&
\r
1948 strncmp (temp->name, otemp->name, size_fromInt (temp->length)) == 0) {
\r
1949 cstring name = cstring_copyLength (temp->name, temp->length);
\r
1950 cppReader_error (pfile,
\r
1951 message ("duplicate argument name `%x' in `#define'", name));
\r
1958 ++bp; /* skip paren */
\r
1959 SKIP_WHITE_SPACE (bp);
\r
1960 /* now everything from bp before limit is the definition. */
\r
1961 defn = collect_expansion (pfile, bp, limit, argno, arg_ptrs);
\r
1962 defn->rest_args = rest_args;
\r
1964 /* Now set defn->args.argnames to the result of concatenating
\r
1965 the argument names in reverse order
\r
1966 with comma-space between them. */
\r
1967 defn->args.argnames = (char *) dmalloc (size_fromInt (arglengths + 1));
\r
1970 struct arglist *temp;
\r
1972 for (temp = arg_ptrs; temp != NULL; temp = temp->next) {
\r
1973 memcpy (&defn->args.argnames[i], temp->name, size_fromInt (temp->length));
\r
1974 i += temp->length;
\r
1975 if (temp->next != 0) {
\r
1976 defn->args.argnames[i++] = ',';
\r
1977 defn->args.argnames[i++] = ' ';
\r
1981 defn->args.argnames[i] = '\0';
\r
1986 /* Simple expansion or empty definition. */
\r
1990 if (is_hor_space[(int) *bp]) {
\r
1992 SKIP_WHITE_SPACE (bp);
\r
1995 case '!': case '"': case '#': case '%': case '&': case '\'':
\r
1996 case ')': case '*': case '+': case ',': case '-': case '.':
\r
1997 case '/': case ':': case ';': case '<': case '=': case '>':
\r
1998 case '?': case '[': case '\\': case ']': case '^': case '{':
\r
1999 case '|': case '}': case '~':
\r
2000 cppReader_warning (pfile,
\r
2001 message ("Missing white space after #define %x",
\r
2002 cstring_prefix (cstring_fromChars (symname),
\r
2007 cppReader_pedwarn (pfile,
\r
2008 message ("Missing white space after #define %x",
\r
2009 cstring_prefix (cstring_fromChars (symname),
\r
2015 /* now everything from bp before limit is the definition. */
\r
2016 defn = collect_expansion (pfile, bp, limit, -1, NULL);
\r
2017 defn->args.argnames = mstring_createEmpty ();
\r
2020 defn->noExpand = noExpand;
\r
2021 DPRINTF (("No expand: %d", noExpand));
\r
2023 defn->line = line;
\r
2025 /* not: llassert (cstring_isUndefined (defn->file)); */
\r
2026 defn->file = file;
\r
2028 /* OP is null if this is a predefinition */
\r
2029 defn->predefined = predefinition;
\r
2031 mdef.symnam = symname;
\r
2032 mdef.symlen = sym_length;
\r
2038 mdef.symnam = NULL;
\r
2042 /* Check a purported macro name SYMNAME, and yield its length.
\r
2043 USAGE is the kind of name this is intended for. */
\r
2045 int cppReader_checkMacroName (cppReader *pfile,
\r
2050 size_t sym_length;
\r
2052 for (p = symname; is_idchar[(int) *p]; p++)
\r
2057 sym_length = size_fromInt (p - symname);
\r
2059 if (sym_length == 0
\r
2060 || (sym_length == 1 && *symname == 'L' && (*p == '\'' || *p == '"')))
\r
2061 cppReader_error (pfile, message ("invalid %s name", usage));
\r
2062 else if (!is_idstart[(int) *symname])
\r
2064 char *msg = (char *) dmalloc (sym_length + 1);
\r
2065 memcpy (msg, symname, sym_length);
\r
2066 msg[sym_length] = '\0';
\r
2067 cppReader_error (pfile, message ("invalid %s name `%s'", usage,
\r
2068 cstring_fromChars (msg)));
\r
2073 if ((strncmp (symname, "defined", 7) == 0) && sym_length == 7)
\r
2075 cppReader_error (pfile, message ("invalid %s name `defined'", usage));
\r
2079 return size_toInt (sym_length);
\r
2082 /* Return zero if two DEFINITIONs are isomorphic. */
\r
2085 compare_defs (DEFINITION *d1, DEFINITION *d2)
\r
2087 register struct reflist *a1, *a2;
\r
2088 register char *p1 = d1->expansion;
\r
2089 register char *p2 = d2->expansion;
\r
2090 bool first = TRUE;
\r
2092 if (d1->nargs != d2->nargs)
\r
2097 llassert (d1->args.argnames != NULL);
\r
2098 llassert (d2->args.argnames != NULL);
\r
2100 if (strcmp ((char *)d1->args.argnames, (char *)d2->args.argnames) != 0)
\r
2105 for (a1 = d1->pattern, a2 = d2->pattern;
\r
2106 (a1 != NULL) && (a2 != NULL);
\r
2107 a1 = a1->next, a2 = a2->next) {
\r
2108 if (!((a1->nchars == a2->nchars
\r
2109 && (strncmp (p1, p2, size_fromInt (a1->nchars)) == 0))
\r
2110 || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
\r
2111 || a1->argno != a2->argno
\r
2112 || a1->stringify != a2->stringify
\r
2113 || a1->raw_before != a2->raw_before
\r
2114 || a1->raw_after != a2->raw_after)
\r
2123 if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
\r
2124 p2, d2->length - (p2 - d2->expansion), 1))
\r
2130 /* Return TRUE if two parts of two macro definitions are effectively different.
\r
2131 One of the parts starts at BEG1 and has LEN1 chars;
\r
2132 the other has LEN2 chars at BEG2.
\r
2133 Any sequence of whitespace matches any other sequence of whitespace.
\r
2134 FIRST means these parts are the first of a macro definition;
\r
2135 so ignore leading whitespace entirely.
\r
2136 LAST means these parts are the last of a macro definition;
\r
2137 so ignore trailing whitespace entirely. */
\r
2140 comp_def_part (bool first, char *beg1, int len1, char *beg2, int len2, bool last)
\r
2142 char *end1 = beg1 + len1;
\r
2143 char *end2 = beg2 + len2;
\r
2146 while (beg1 != end1 && is_space[(int) *beg1]) { beg1++; }
\r
2147 while (beg2 != end2 && is_space[(int) *beg2]) { beg2++; }
\r
2150 while (beg1 != end1 && is_space[(int) end1[-1]]) { end1--; }
\r
2151 while (beg2 != end2 && is_space[(int) end2[-1]]) { end2--; }
\r
2153 while (beg1 != end1 && beg2 != end2) {
\r
2154 if (is_space[(int) *beg1] && is_space[(int) *beg2]) {
\r
2155 while (beg1 != end1 && is_space[(int) *beg1]) { beg1++; }
\r
2156 while (beg2 != end2 && is_space[(int) *beg2]) { beg2++; }
\r
2157 } else if (*beg1 == *beg2) {
\r
2161 return (beg1 != end1) || (beg2 != end2);
\r
2164 /* Process a #define command.
\r
2165 BUF points to the contents of the #define command, as a contiguous string.
\r
2166 LIMIT points to the first character past the end of the definition.
\r
2167 KEYWORD is the keyword-table entry for #define,
\r
2168 or NULL for a "predefined" macro. */
\r
2171 do_defineAux (cppReader *pfile, struct directive *keyword,
\r
2172 char *buf, char *limit, bool noExpand)
\r
2178 DPRINTF (("Define aux: %d", noExpand));
\r
2180 mdef = create_definition (buf, limit, pfile, keyword == NULL, noExpand);
\r
2182 if (mdef.defn == 0)
\r
2185 hashcode = hashf (mdef.symnam, mdef.symlen, CPP_HASHSIZE);
\r
2187 DPRINTF (("Macro: %s / %s",
\r
2188 cstring_copyLength (mdef.symnam, mdef.symlen),
\r
2189 bool_unparse (noExpand)));
\r
2191 if ((hp = cppReader_lookup (mdef.symnam, mdef.symlen, hashcode)) != NULL)
\r
2195 /* Redefining a precompiled key is ok. */
\r
2196 if (hp->type == T_PCSTRING)
\r
2198 /* Redefining a macro is ok if the definitions are the same. */
\r
2199 else if (hp->type == T_MACRO)
\r
2200 ok = !compare_defs (mdef.defn, hp->value.defn);
\r
2201 /* Redefining a constant is ok with -D. */
\r
2202 else if (hp->type == T_CONST)
\r
2203 ok = !CPPOPTIONS (pfile)->done_initializing;
\r
2208 /* Print the warning if it's not ok. */
\r
2212 ** If we are passing through #define and #undef directives, do
\r
2213 ** that for this re-definition now.
\r
2216 if (CPPOPTIONS (pfile)->debug_output && (keyword != NULL))
\r
2218 /* llassert (keyword != NULL); */
\r
2219 pass_thru_directive (buf, limit, pfile, keyword);
\r
2222 cpp_setLocation (pfile);
\r
2224 if (hp->type == T_MACRO)
\r
2226 if (hp->value.defn->noExpand)
\r
2228 ; /* error will be reported checking macros */
\r
2234 message ("Macro %q already defined",
\r
2235 cstring_copyLength (mdef.symnam, mdef.symlen)),
\r
2236 message ("%q: Previous definition of %q",
\r
2237 fileloc_unparseRaw (hp->value.defn->file,
\r
2238 (int) hp->value.defn->line),
\r
2239 cstring_copyLength (mdef.symnam, mdef.symlen)));
\r
2244 genppllerror (FLG_MACROREDEF,
\r
2245 message ("Macro %q already defined",
\r
2246 cstring_copyLength (mdef.symnam,
\r
2252 /* Replace the old definition. */
\r
2253 hp->type = T_MACRO;
\r
2254 hp->value.defn = mdef.defn;
\r
2259 ** If we are passing through #define and #undef directives, do
\r
2260 ** that for this new definition now.
\r
2265 if (CPPOPTIONS (pfile)->debug_output && (keyword != NULL))
\r
2267 pass_thru_directive (buf, limit, pfile, keyword);
\r
2270 DPRINTF (("Define macro: %s / %d",
\r
2271 mdef.symnam, mdef.defn->noExpand));
\r
2273 hn = cppReader_installMacro (mdef.symnam, mdef.symlen, mdef.defn, hashcode);
\r
2274 /*@-branchstate@*/
\r
2275 } /*@=branchstate@*/
\r
2285 do_define (cppReader *pfile, struct directive *keyword,
\r
2286 char *buf, char *limit)
\r
2288 DPRINTF (("Regular do define"));
\r
2289 return do_defineAux (pfile, keyword, buf, limit, FALSE);
\r
2292 /* This structure represents one parsed argument in a macro call.
\r
2293 `raw' points to the argument text as written (`raw_length' is its length).
\r
2294 `expanded' points to the argument's macro-expansion
\r
2295 (its length is `expand_length').
\r
2296 `stringified_length' is the length the argument would have
\r
2298 `use_count' is the number of times this macro arg is substituted
\r
2299 into the macro. If the actual use count exceeds 10,
\r
2300 the value stored is 10. */
\r
2302 /* raw and expanded are relative to ARG_BASE */
\r
2304 #define ARG_BASE ((pfile)->token_buffer)
\r
2307 /* Strings relative to pfile->token_buffer */
\r
2310 size_t stringified;
\r
2312 int expand_length;
\r
2313 int stringified_length;
\r
2318 /* Allocate a new cppBuffer for PFILE, and push it on the input buffer stack.
\r
2319 If BUFFER != NULL, then use the LENGTH characters in BUFFER
\r
2320 as the new input buffer.
\r
2321 Return the new buffer, or NULL on failure. */
\r
2323 /*@null@*/ /*@exposed@*/ cppBuffer *
\r
2324 cppReader_pushBuffer (cppReader *pfile, char *buffer, size_t length)
\r
2326 cppBuffer *buf = cppReader_getBuffer (pfile);
\r
2328 if (buf == pfile->buffer_stack)
\r
2330 cppReader_fatalError
\r
2332 message ("%s: macro or `#include' recursion too deep",
\r
2333 (buf->fname != NULL)
\r
2335 : cstring_makeLiteral ("<no name>")));
\r
2336 sfreeEventually (buffer);
\r
2340 llassert (buf != NULL);
\r
2343 memset ((char *) buf, 0, sizeof (*buf));
\r
2344 CPPBUFFER (pfile) = buf;
\r
2346 buf->if_stack = pfile->if_stack;
\r
2347 buf->cleanup = cppReader_nullCleanup;
\r
2348 buf->underflow = cppReader_nullUnderflow;
\r
2349 buf->buf = buffer;
\r
2350 buf->cur = buf->buf;
\r
2352 if (buffer != NULL)
\r
2354 buf->alimit = buf->rlimit = buffer + length;
\r
2358 buf->alimit = buf->rlimit = NULL;
\r
2365 cppReader_popBuffer (cppReader *pfile)
\r
2367 cppBuffer *buf = CPPBUFFER (pfile);
\r
2369 llassert (buf != NULL);
\r
2371 (void) (*buf->cleanup) (buf, pfile);
\r
2372 return ++CPPBUFFER (pfile);
\r
2375 /* Scan until CPPBUFFER (PFILE) is exhausted into PFILE->token_buffer.
\r
2376 Pop the buffer when done. */
\r
2379 cppReader_scanBuffer (cppReader *pfile)
\r
2381 cppBuffer *buffer = CPPBUFFER (pfile);
\r
2384 enum cpp_token token;
\r
2386 token = cppGetToken (pfile);
\r
2388 if (token == CPP_EOF) /* Should not happen ... */
\r
2393 if (token == CPP_POP && CPPBUFFER (pfile) == buffer)
\r
2395 (void) cppReader_popBuffer (pfile);
\r
2402 * Rescan a string (which may have escape marks) into pfile's buffer.
\r
2403 * Place the result in pfile->token_buffer.
\r
2405 * The input is copied before it is scanned, so it is safe to pass
\r
2406 * it something from the token_buffer that will get overwritten
\r
2407 * (because it follows cppReader_getWritten). This is used by do_include.
\r
2411 cpp_expand_to_buffer (cppReader *pfile, char *buf, size_t length)
\r
2413 register cppBuffer *ip;
\r
2414 char *limit = buf + length;
\r
2415 char *buf1, *p1, *p2;
\r
2417 /* evans - 2001-08-26
\r
2418 ** length is unsigned - this doesn't make sense
\r
2424 /* Set up the input on the input stack. */
\r
2426 buf1 = (char *) dmalloc (length + 1);
\r
2431 while (p1 != limit)
\r
2436 buf1[length] = '\0';
\r
2438 ip = cppReader_pushBuffer (pfile, buf1, length);
\r
2443 ip->has_escapes = TRUE;
\r
2445 /* Scan the input, create the output. */
\r
2446 cppReader_scanBuffer (pfile);
\r
2448 cppReader_nullTerminate (pfile);
\r
2452 adjust_position (char *buf, char *limit, int *linep, int *colp)
\r
2454 while (buf < limit)
\r
2458 (*linep)++, (*colp) = 1;
\r
2464 /* Move line_base forward, updating lineno and colno. */
\r
2467 update_position (cppBuffer *pbuf)
\r
2470 char *new_pos = pbuf->cur;
\r
2471 register struct parse_marker *mark;
\r
2473 llassert (pbuf->buf != NULL);
\r
2474 old_pos = pbuf->buf + pbuf->line_base;
\r
2476 for (mark = pbuf->marks; mark != NULL; mark = mark->next)
\r
2478 if (pbuf->buf + mark->position < new_pos)
\r
2479 new_pos = pbuf->buf + mark->position;
\r
2481 pbuf->line_base += new_pos - old_pos;
\r
2483 llassert (old_pos != NULL);
\r
2484 llassert (new_pos != NULL);
\r
2486 adjust_position (old_pos, new_pos, &pbuf->lineno, &pbuf->colno);
\r
2490 cppBuffer_lineAndColumn (/*@null@*/ cppBuffer *pbuf, /*@out@*/ int *linep,
\r
2491 /*@null@*/ /*@out@*/ int *colp)
\r
2498 /*@-branchstate@*/
\r
2499 } /*@=branchstate@*/
\r
2503 *linep = pbuf->lineno;
\r
2504 *colp = pbuf->colno;
\r
2506 llassert (pbuf->buf != NULL);
\r
2507 llassert (pbuf->cur != NULL);
\r
2509 adjust_position (pbuf->buf + pbuf->line_base, pbuf->cur, linep, colp);
\r
2518 /* Return the cppBuffer that corresponds to a file (not a macro). */
\r
2520 /*@exposed@*/ /*@null@*/ cppBuffer *cppReader_fileBuffer (cppReader *pfile)
\r
2522 cppBuffer *ip = cppReader_getBuffer (pfile);
\r
2525 ip != NULL && ip != cppReader_nullBuffer (pfile);
\r
2526 ip = cppBuffer_prevBuffer (ip))
\r
2528 if (ip->fname != NULL)
\r
2538 count_newlines (char *buf, char *limit)
\r
2540 register long count = 0;
\r
2542 while (buf < limit)
\r
2552 * write out a #line command, for instance, after an #include file.
\r
2553 * If CONDITIONAL is nonzero, we can omit the #line if it would
\r
2554 * appear to be a no-op, and we can output a few newlines instead
\r
2555 * if we want to increase the line number by a small amount.
\r
2556 * FILE_CHANGE says whether we are entering a file, leaving, or neither.
\r
2560 output_line_command (cppReader *pfile, bool conditional,
\r
2561 enum file_change_code file_change)
\r
2564 cppBuffer *ip = CPPBUFFER (pfile);
\r
2567 llassert (ip != NULL);
\r
2569 if (ip->fname == NULL)
\r
2572 update_position (ip);
\r
2574 if (CPPOPTIONS (pfile)->no_line_commands
\r
2575 || CPPOPTIONS (pfile)->no_output)
\r
2578 buf = CPPBUFFER (pfile);
\r
2580 llassert (buf != NULL);
\r
2582 line = buf->lineno;
\r
2585 llassert (ip->cur != NULL);
\r
2587 adjust_position (cppLineBase (ip), ip->cur, &line, &col);
\r
2589 if (CPPOPTIONS (pfile)->no_line_commands)
\r
2592 if (conditional) {
\r
2593 if (line == pfile->lineno)
\r
2596 /* If the inherited line number is a little too small,
\r
2597 output some newlines instead of a #line command. */
\r
2599 if (line > pfile->lineno && line < pfile->lineno + 8)
\r
2601 cppReader_reserve (pfile, 20);
\r
2602 while (line > pfile->lineno)
\r
2604 cppReader_putCharQ (pfile, '\n');
\r
2612 cppReader_reserve (pfile,
\r
2613 size_fromInt (4 * cstring_length (ip->nominal_fname) + 50));
\r
2616 #ifdef OUTPUT_LINE_COMMANDS
\r
2617 static char sharp_line[] = "#line ";
\r
2619 static char sharp_line[] = "# ";
\r
2621 cppReader_putStrN (pfile, sharp_line, sizeof(sharp_line)-1);
\r
2624 sprintf (cppReader_getPWritten (pfile), "%d ", line);
\r
2625 cppReader_adjustWritten (pfile, strlen (cppReader_getPWritten (pfile)));
\r
2627 quote_string (pfile, cstring_toCharsSafe (ip->nominal_fname));
\r
2629 if (file_change != same_file) {
\r
2630 cppReader_putCharQ (pfile, ' ');
\r
2631 cppReader_putCharQ (pfile, file_change == enter_file ? '1' : '2');
\r
2633 /* Tell cc1 if following text comes from a system header file. */
\r
2634 if (ip->system_header_p != '\0') {
\r
2635 cppReader_putCharQ (pfile, ' ');
\r
2636 cppReader_putCharQ (pfile, '3');
\r
2638 #ifndef NO_IMPLICIT_EXTERN_C
\r
2639 /* Tell cc1plus if following text should be treated as C. */
\r
2640 if (ip->system_header_p == (char) 2 && CPPOPTIONS (pfile)->cplusplus) {
\r
2641 cppReader_putCharQ (pfile, ' ');
\r
2642 cppReader_putCharQ (pfile, '4');
\r
2645 cppReader_putCharQ (pfile, '\n');
\r
2646 pfile->lineno = line;
\r
2651 * Parse a macro argument and append the info on PFILE's token_buffer.
\r
2652 * REST_ARGS means to absorb the rest of the args.
\r
2653 * Return nonzero to indicate a syntax error.
\r
2656 static enum cpp_token
\r
2657 macarg (cppReader *pfile, int rest_args)
\r
2660 enum cpp_token token;
\r
2661 char save_put_out_comments = CPPOPTIONS (pfile)->put_out_comments;
\r
2662 bool oldexpand = pfile->no_macro_expand;
\r
2663 CPPOPTIONS (pfile)->put_out_comments = 1;
\r
2665 /* Try to parse as much of the argument as exists at this
\r
2666 input stack level. */
\r
2668 pfile->no_macro_expand = TRUE;
\r
2672 token = cppGetToken (pfile);
\r
2679 /* If we've hit end of file, it's an error (reported by caller).
\r
2680 Ditto if it's the end of cpp_expand_to_buffer text.
\r
2681 If we've hit end of macro, just continue. */
\r
2682 if (!cppBuffer_isMacro (CPPBUFFER (pfile)))
\r
2684 /*@switchbreak@*/ break;
\r
2687 /*@switchbreak@*/ break;
\r
2691 /*@switchbreak@*/ break;
\r
2693 /* if we've returned to lowest level and
\r
2694 we aren't absorbing all args */
\r
2695 if (paren == 0 && rest_args == 0)
\r
2697 /*@switchbreak@*/ break;
\r
2699 /* Remove ',' or ')' from argument buffer. */
\r
2700 cppReader_adjustWritten (pfile, -1);
\r
2708 CPPOPTIONS (pfile)->put_out_comments = save_put_out_comments;
\r
2709 pfile->no_macro_expand = oldexpand;
\r
2715 /* Turn newlines to spaces in the string of length LENGTH at START,
\r
2716 except inside of string constants.
\r
2717 The string is copied into itself with its beginning staying fixed. */
\r
2720 change_newlines (char *start, int length)
\r
2722 register char *ibp;
\r
2723 register char *obp;
\r
2724 register char *limit;
\r
2728 limit = start + length;
\r
2731 while (ibp < limit) {
\r
2732 *obp++ = c = *ibp++;
\r
2737 /* Notice and skip strings, so that we don't delete newlines in them. */
\r
2740 while (ibp < limit) {
\r
2741 *obp++ = c = *ibp++;
\r
2743 /*@innerbreak@*/ break;
\r
2744 if (c == '\n' && quotec == '\'')
\r
2745 /*@innerbreak@*/ break;
\r
2748 /*@switchbreak@*/ break;
\r
2752 return obp - start;
\r
2755 static /*@observer@*/ struct tm *
\r
2756 timestamp (/*@returned@*/ cppReader *pfile)
\r
2758 if (pfile->timebuf == NULL)
\r
2760 time_t t = time ((time_t *) 0);
\r
2761 pfile->timebuf = localtime (&t);
\r
2764 llassert (pfile->timebuf != NULL);
\r
2766 return pfile->timebuf;
\r
2769 static ob_mstring monthnames[] = {
\r
2770 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
\r
2771 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
\r
2775 * expand things like __FILE__. Place the expansion into the output
\r
2776 * buffer *without* rescanning.
\r
2780 special_symbol (hashNode hp, cppReader *pfile)
\r
2782 cstring buf = cstring_undefined;
\r
2786 struct tm *timebuf;
\r
2788 int paren = 0; /* For special `defined' keyword */
\r
2790 for (ip = cppReader_getBuffer (pfile); ip != NULL; ip = cppBuffer_prevBuffer (ip))
\r
2792 if (ip == cppReader_nullBuffer (pfile))
\r
2794 cppReader_errorLit (pfile,
\r
2795 cstring_makeLiteralTemp ("cccp error: not in any file?!"));
\r
2796 return; /* the show must go on */
\r
2799 if (ip != NULL && ip->fname != NULL)
\r
2811 if (hp->type == T_BASE_FILE)
\r
2813 while (cppBuffer_prevBuffer (ip) != cppReader_nullBuffer (pfile))
\r
2815 ip = cppBuffer_prevBuffer (ip);
\r
2819 llassert (ip != NULL);
\r
2820 string = cstring_toCharsSafe (ip->nominal_fname);
\r
2822 if (string == NULL)
\r
2827 cppReader_reserve (pfile, 3 + 4 * strlen (string));
\r
2828 quote_string (pfile, string);
\r
2832 case T_INCLUDE_LEVEL:
\r
2834 ip = cppReader_getBuffer (pfile);
\r
2836 for (; ip != cppReader_nullBuffer (pfile) && ip != NULL;
\r
2837 ip = cppBuffer_prevBuffer (ip))
\r
2839 if (ip != NULL && ip->fname != NULL)
\r
2845 buf = message ("%d", true_indepth - 1);
\r
2849 buf = message ("\"%s\"", cstring_makeLiteralTemp (CPP_VERSION));
\r
2852 #ifndef NO_BUILTIN_SIZE_TYPE
\r
2854 buf = cstring_makeLiteral (SIZE_TYPE);
\r
2858 #ifndef NO_BUILTIN_PTRDIFF_TYPE
\r
2859 case T_PTRDIFF_TYPE:
\r
2860 buf = cstring_makeLiteral (PTRDIFF_TYPE);
\r
2864 case T_WCHAR_TYPE:
\r
2865 buf = cstring_makeLiteral (cppReader_wcharType (pfile));
\r
2868 case T_USER_LABEL_PREFIX_TYPE:
\r
2869 buf = cstring_makeLiteral (USER_LABEL_PREFIX);
\r
2872 case T_REGISTER_PREFIX_TYPE:
\r
2873 buf = cstring_makeLiteral (REGISTER_PREFIX);
\r
2877 buf = message ("%d", hp->value.ival);
\r
2884 int line = ip->lineno;
\r
2885 int col = ip->colno;
\r
2887 llassert (ip->cur != NULL);
\r
2888 adjust_position (cppLineBase (ip), ip->cur, &line, &col);
\r
2890 buf = message ("%d", (int) line);
\r
2902 char *sbuf = (char *) dmalloc (20);
\r
2903 timebuf = timestamp (pfile);
\r
2904 if (hp->type == T_DATE)
\r
2906 sprintf (sbuf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
\r
2907 timebuf->tm_mday, timebuf->tm_year + 1900);
\r
2911 sprintf (sbuf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
\r
2915 buf = cstring_fromCharsNew (sbuf);
\r
2920 case T_SPEC_DEFINED:
\r
2921 buf = cstring_makeLiteral (" 0 "); /* Assume symbol is not defined */
\r
2922 ip = cppReader_getBuffer (pfile);
\r
2924 llassert (ip->cur != NULL);
\r
2925 SKIP_WHITE_SPACE (ip->cur);
\r
2927 if (*ip->cur == '(')
\r
2930 ip->cur++; /* Skip over the paren */
\r
2931 SKIP_WHITE_SPACE (ip->cur);
\r
2934 if (!is_idstart[(int) *ip->cur])
\r
2936 if (ip->cur[0] == 'L' && (ip->cur[1] == '\'' || ip->cur[1] == '"'))
\r
2939 if ((hp = cppReader_lookup (ip->cur, -1, -1)) != 0)
\r
2941 cstring_free (buf);
\r
2942 buf = cstring_makeLiteral (" 1 ");
\r
2945 while (is_idchar[(int) *ip->cur])
\r
2950 SKIP_WHITE_SPACE (ip->cur);
\r
2954 if (*ip->cur != ')')
\r
2962 cppReader_errorLit (pfile,
\r
2963 cstring_makeLiteralTemp ("`defined' without an identifier"));
\r
2967 cpp_setLocation (pfile);
\r
2968 llfatalerror (message ("Pre-processing error: invalid special hash type"));
\r
2971 len = size_fromInt (cstring_length (buf));
\r
2973 cppReader_reserve (pfile, len + 1);
\r
2974 cppReader_putStrN (pfile, cstring_toCharsSafe (buf), len);
\r
2975 cppReader_nullTerminateQ (pfile);
\r
2977 cstring_free (buf);
\r
2981 /* Write out a #define command for the special named MACRO_NAME
\r
2982 to PFILE's token_buffer. */
\r
2985 dump_special_to_buffer (cppReader *pfile, char *macro_name)
\r
2987 static char define_directive[] = "#define ";
\r
2988 size_t macro_name_length = strlen (macro_name);
\r
2989 output_line_command (pfile, 0, same_file);
\r
2990 cppReader_reserve (pfile, sizeof(define_directive) + macro_name_length);
\r
2991 cppReader_putStrN (pfile, define_directive, sizeof(define_directive)-1);
\r
2992 cppReader_putStrN (pfile, macro_name, macro_name_length);
\r
2993 cppReader_putCharQ (pfile, ' ');
\r
2994 cpp_expand_to_buffer (pfile, macro_name, macro_name_length);
\r
2995 cppReader_putChar (pfile, '\n');
\r
2998 /* Initialize the built-in macros. */
\r
3001 cppReader_installBuiltin (/*@observer@*/ char *name, ctype ctyp,
\r
3002 int len, enum node_type type,
\r
3003 int ivalue, /*@null@*/ /*@only@*/ char *value,
\r
3006 cstring sname = cstring_fromCharsNew (name);
\r
3008 llassert (usymtab_inGlobalScope ());
\r
3011 ** Be careful here: this is done before the ctype table has
\r
3012 ** been initialized.
\r
3015 if (!usymtab_exists (sname))
\r
3017 uentry ue = uentry_makeConstant (sname, ctyp, fileloc_createBuiltin ());
\r
3019 if (ctype_equal (ctyp, ctype_string))
\r
3021 qualList ql = qualList_new ();
\r
3022 ql = qualList_add (ql, qual_createObserver ());
\r
3023 uentry_reflectQualifiers (ue, ql);
\r
3024 qualList_free (ql);
\r
3027 usymtab_addGlobalEntry (ue);
\r
3034 (void) cppReader_install (name, len, type, ivalue, value, hash);
\r
3035 cstring_free (sname);
\r
3039 cppReader_installBuiltinType (/*@observer@*/ char *name, ctype ctyp,
\r
3040 int len, enum node_type type,
\r
3042 /*@only@*/ /*@null@*/ char *value, int hash)
\r
3044 cstring sname = cstring_fromChars (name);
\r
3045 /* evs 2000 07 10 - removed a memory leak, detected by lclint */
\r
3047 llassert (usymtab_inGlobalScope ());
\r
3049 if (!usymtab_existsTypeEither (sname))
\r
3051 uentry ue = uentry_makeDatatype (sname, ctyp,
\r
3053 fileloc_createBuiltin ());
\r
3054 llassert (!usymtab_existsEither (sname));
\r
3055 usymtab_addGlobalEntry (ue);
\r
3058 (void) cppReader_install (name, len, type, ivalue, value, hash);
\r
3062 initialize_builtins (cppReader *pfile)
\r
3064 cppReader_installBuiltin ("__LINE__", ctype_int, -1, T_SPECLINE, 0, NULL, -1);
\r
3065 cppReader_installBuiltin ("__DATE__", ctype_string, -1, T_DATE, 0, NULL, -1);
\r
3066 cppReader_installBuiltin ("__FILE__", ctype_string, -1, T_FILE, 0, NULL, -1);
\r
3067 cppReader_installBuiltin ("__BASE_FILE__", ctype_string, -1, T_BASE_FILE, 0, NULL, -1);
\r
3068 cppReader_installBuiltin ("__INCLUDE_LEVEL__", ctype_int, -1, T_INCLUDE_LEVEL, 0, NULL, -1);
\r
3069 cppReader_installBuiltin ("__VERSION__", ctype_string, -1, T_VERSION, 0, NULL, -1);
\r
3070 #ifndef NO_BUILTIN_SIZE_TYPE
\r
3071 cppReader_installBuiltinType ("__SIZE_TYPE__", ctype_anyintegral, -1, T_SIZE_TYPE, 0, NULL, -1);
\r
3073 #ifndef NO_BUILTIN_PTRDIFF_TYPE
\r
3074 cppReader_installBuiltinType ("__PTRDIFF_TYPE__", ctype_anyintegral, -1, T_PTRDIFF_TYPE, 0, NULL, -1);
\r
3076 cppReader_installBuiltinType ("__WCHAR_TYPE__", ctype_anyintegral, -1, T_WCHAR_TYPE, 0, NULL, -1);
\r
3077 cppReader_installBuiltin ("__USER_LABEL_PREFIX__", ctype_string, -1, T_USER_LABEL_PREFIX_TYPE, 0, NULL, -1);
\r
3078 cppReader_installBuiltin ("__REGISTER_PREFIX__", ctype_string, -1, T_REGISTER_PREFIX_TYPE, 0, NULL, -1);
\r
3079 cppReader_installBuiltin ("__TIME__", ctype_string, -1, T_TIME, 0, NULL, -1);
\r
3082 ** No, don't define __STDC__
\r
3085 if (!cppReader_isTraditional (pfile))
\r
3087 cppReader_installBuiltin ("__STDC__", ctype_int, -1, T_CONST, STDC_VALUE, NULL, -1);
\r
3094 cppReader_installBuiltin ("_WIN32", ctype_int, -1, T_CONST, STDC_VALUE, NULL, -1);
\r
3098 ** This is supplied using a -D by the compiler driver
\r
3099 ** so that it is present only when truly compiling with GNU C.
\r
3102 /* cppReader_install ("__GNUC__", -1, T_CONST, 2, 0, -1); */
\r
3104 cppReader_installBuiltin ("__LCLINT__", ctype_int, -1, T_CONST, 2, NULL, -1);
\r
3106 if (CPPOPTIONS (pfile)->debug_output)
\r
3108 dump_special_to_buffer (pfile, "__BASE_FILE__");
\r
3109 dump_special_to_buffer (pfile, "__VERSION__");
\r
3110 #ifndef NO_BUILTIN_SIZE_TYPE
\r
3111 dump_special_to_buffer (pfile, "__SIZE_TYPE__");
\r
3113 #ifndef NO_BUILTIN_PTRDIFF_TYPE
\r
3114 dump_special_to_buffer (pfile, "__PTRDIFF_TYPE__");
\r
3116 dump_special_to_buffer (pfile, "__WCHAR_TYPE__");
\r
3117 dump_special_to_buffer (pfile, "__DATE__");
\r
3118 dump_special_to_buffer (pfile, "__TIME__");
\r
3119 if (!cppReader_isTraditional (pfile))
\r
3120 dump_special_to_buffer (pfile, "__STDC__");
\r
3125 /* Return 1 iff a token ending in C1 followed directly by a token C2
\r
3126 could cause mis-tokenization. */
\r
3129 unsafe_chars (char c1, char c2)
\r
3133 case '+': case '-':
\r
3134 if (c2 == c1 || c2 == '=')
\r
3138 case '0': case '1': case '2': case '3': case '4':
\r
3139 case '5': case '6': case '7': case '8': case '9':
\r
3140 case 'e': case 'E': case 'p': case 'P':
\r
3141 if (c2 == '-' || c2 == '+')
\r
3142 return 1; /* could extend a pre-processing number */
\r
3145 if (c2 == '\'' || c2 == '\"')
\r
3146 return 1; /* Could turn into L"xxx" or L'xxx'. */
\r
3150 case 'a': case 'b': case 'c': case 'd': case 'f':
\r
3151 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
\r
3152 case 'm': case 'n': case 'o': case 'q': case 'r':
\r
3153 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
\r
3154 case 'y': case 'z':
\r
3155 case 'A': case 'B': case 'C': case 'D': case 'F':
\r
3156 case 'G': case 'H': case 'I': case 'J': case 'K':
\r
3157 case 'M': case 'N': case 'O': case 'Q': case 'R':
\r
3158 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
\r
3159 case 'Y': case 'Z':
\r
3160 /* We're in the middle of either a name or a pre-processing number. */
\r
3161 return (is_idchar[(int) c2] || c2 == '.');
\r
3162 case '<': case '>': case '!': case '%': case '#': case ':':
\r
3163 case '^': case '&': case '|': case '*': case '/': case '=':
\r
3164 return (c2 == c1 || c2 == '=');
\r
3169 /* Expand a macro call.
\r
3170 HP points to the symbol that is the macro being called.
\r
3171 Put the result of expansion onto the input stack
\r
3172 so that subsequent input by our caller will use it.
\r
3174 If macro wants arguments, caller has already verified that
\r
3175 an argument list follows; arguments come from the input stack. */
\r
3178 macroexpand (cppReader *pfile, /*@dependent@*/ hashNode hp)
\r
3181 DEFINITION *defn = hp->value.defn;
\r
3183 char *oxbuf = NULL;
\r
3187 size_t old_written = cppReader_getWritten (pfile);
\r
3189 int rest_zero = 0;
\r
3191 struct argdata *args = NULL;
\r
3193 pfile->output_escapes++;
\r
3195 cppBuffer_lineAndColumn (cppReader_fileBuffer (pfile), &start_line, &start_column);
\r
3197 nargs = defn->nargs;
\r
3201 enum cpp_token token = CPP_EOF;
\r
3203 args = (struct argdata *) dmalloc ((nargs + 1) * sizeof (*args));
\r
3205 for (i = 0; i < nargs; i++)
\r
3207 args[i].expanded = 0;
\r
3209 args[i].raw_length = 0;
\r
3210 args[i].expand_length = args[i].stringified_length = -1;
\r
3211 args[i].use_count = 0;
\r
3215 ** Parse all the macro args that are supplied. I counts them.
\r
3216 ** The first NARGS args are stored in ARGS.
\r
3217 ** The rest are discarded. If rest_args is set then we assume
\r
3218 ** macarg absorbed the rest of the args.
\r
3224 cppReader_forward (pfile, 1); /* Discard the open-parenthesis before the first arg. */
\r
3227 if (rest_args != 0)
\r
3232 if (i < nargs || (nargs == 0 && i == 0))
\r
3234 /* if we are working on last arg which absorbs rest of args... */
\r
3235 if (i == nargs - 1 && defn->rest_args)
\r
3240 args[i].raw = size_toLong (cppReader_getWritten (pfile));
\r
3241 token = macarg (pfile, rest_args);
\r
3242 args[i].raw_length = cppReader_getWritten (pfile) - args[i].raw;
\r
3243 args[i].newlines = FALSE; /* FIXME */
\r
3247 token = macarg (pfile, 0);
\r
3250 if (token == CPP_EOF || token == CPP_POP)
\r
3252 cppReader_errorWithLine (pfile, start_line, start_column,
\r
3253 cstring_fromCharsNew ("unterminated macro call"));
\r
3258 } while (token == CPP_COMMA);
\r
3260 /* If we got one arg but it was just whitespace, call that 0 args. */
\r
3268 bp = ARG_BASE + args[0].raw;
\r
3269 lim = bp + args[0].raw_length;
\r
3271 /* cpp.texi says for foo ( ) we provide one argument.
\r
3272 However, if foo wants just 0 arguments, treat this as 0. */
\r
3276 while (bp != lim && is_space[(int) *bp])
\r
3286 /* Don't output an error message if we have already output one for
\r
3287 a parse error above. */
\r
3290 if (nargs == 0 && i > 0)
\r
3292 cppReader_error (pfile,
\r
3293 message ("arguments given to macro `%s'", hp->name));
\r
3295 else if (i < nargs)
\r
3297 /* traditional C allows foo() if foo wants one argument. */
\r
3298 if (nargs == 1 && i == 0 && cppReader_isTraditional (pfile))
\r
3302 /* the rest args token is allowed to absorb 0 tokens */
\r
3303 else if (i == nargs - 1 && defn->rest_args)
\r
3306 cppReader_error (pfile,
\r
3307 message ("macro `%s' used without args", hp->name));
\r
3309 cppReader_error (pfile,
\r
3310 message ("macro `%s' used with just one arg", hp->name));
\r
3313 cppReader_error (pfile,
\r
3314 message ("macro `%s' used with only %d args",
\r
3318 else if (i > nargs)
\r
3320 cppReader_error (pfile,
\r
3321 message ("macro `%s' used with too many (%d) args", hp->name, i));
\r
3329 /* If macro wants zero args, we parsed the arglist for checking only.
\r
3330 Read directly from the macro definition. */
\r
3334 xbuf = defn->expansion;
\r
3335 xbuf_len = defn->length;
\r
3339 char *exp = defn->expansion;
\r
3340 int offset; /* offset in expansion,
\r
3341 copied a piece at a time */
\r
3342 size_t totlen; /* total amount of exp buffer filled so far */
\r
3344 register struct reflist *ap, *last_ap;
\r
3346 assertSet (args); /* args is defined since the nargs > 0 path was taken */
\r
3348 /* Macro really takes args. Compute the expansion of this call. */
\r
3350 /* Compute length in characters of the macro's expansion.
\r
3351 Also count number of times each arg is used. */
\r
3352 xbuf_len = defn->length;
\r
3354 llassert (args != NULL);
\r
3356 for (ap = defn->pattern; ap != NULL; ap = ap->next)
\r
3358 if (ap->stringify)
\r
3360 struct argdata *arg = &args[ap->argno];
\r
3362 /* Stringify it it hasn't already been */
\r
3365 if (arg->stringified_length < 0)
\r
3367 int arglen = arg->raw_length;
\r
3368 bool escaped = FALSE;
\r
3369 char in_string = '\0';
\r
3372 /* Initially need_space is -1. Otherwise, 1 means the
\r
3373 previous character was a space, but we suppressed it;
\r
3374 0 means the previous character was a non-space. */
\r
3375 int need_space = -1;
\r
3378 arg->stringified = cppReader_getWritten (pfile);
\r
3379 if (!cppReader_isTraditional (pfile))
\r
3380 cppReader_putChar (pfile, '\"'); /* insert beginning quote */
\r
3381 for (; i < arglen; i++)
\r
3383 c = (ARG_BASE + arg->raw)[i];
\r
3385 if (in_string == '\0')
\r
3387 /* Internal sequences of whitespace are replaced by
\r
3388 one space except within an string or char token.*/
\r
3389 if (is_space[(int) c])
\r
3391 if (cppReader_getWritten (pfile) > arg->stringified
\r
3392 && (cppReader_getPWritten (pfile))[-1] == '@')
\r
3394 /* "@ " escape markers are removed */
\r
3395 cppReader_adjustWritten (pfile, -1);
\r
3396 /*@innercontinue@*/ continue;
\r
3398 if (need_space == 0)
\r
3400 /*@innercontinue@*/ continue;
\r
3402 else if (need_space > 0)
\r
3403 cppReader_putChar (pfile, ' ');
\r
3419 if (in_string != '\0')
\r
3421 if (c == in_string)
\r
3424 else if (c == '\"' || c == '\'')
\r
3434 /* Escape these chars */
\r
3435 if (c == '\"' || (in_string != '\0' && c == '\\'))
\r
3436 cppReader_putChar (pfile, '\\');
\r
3438 cppReader_putChar (pfile, c);
\r
3441 cppReader_reserve (pfile, 4);
\r
3442 sprintf (cppReader_getPWritten (pfile), "\\%03o",
\r
3443 (unsigned int) c);
\r
3444 cppReader_adjustWritten (pfile, 4);
\r
3447 if (!cppReader_isTraditional (pfile))
\r
3448 cppReader_putChar (pfile, '\"'); /* insert ending quote */
\r
3449 arg->stringified_length
\r
3450 = size_toInt (cppReader_getWritten (pfile) - arg->stringified);
\r
3453 xbuf_len += args[ap->argno].stringified_length;
\r
3455 else if (ap->raw_before || ap->raw_after || cppReader_isTraditional (pfile))
\r
3457 /* Add 4 for two newline-space markers to prevent
\r
3458 token concatenation. */
\r
3459 assertSet (args); /*@i534 shouldn't need this */
\r
3460 xbuf_len += args[ap->argno].raw_length + 4;
\r
3464 /* We have an ordinary (expanded) occurrence of the arg.
\r
3465 So compute its expansion, if we have not already. */
\r
3467 assertSet (args); /*@i534 shouldn't need this */
\r
3469 if (args[ap->argno].expand_length < 0)
\r
3471 args[ap->argno].expanded = cppReader_getWritten (pfile);
\r
3472 cpp_expand_to_buffer (pfile,
\r
3473 ARG_BASE + args[ap->argno].raw,
\r
3474 size_fromInt (args[ap->argno].raw_length));
\r
3476 args[ap->argno].expand_length
\r
3477 = size_toInt (cppReader_getWritten (pfile) - args[ap->argno].expanded);
\r
3480 /* Add 4 for two newline-space markers to prevent
\r
3481 token concatenation. */
\r
3482 xbuf_len += args[ap->argno].expand_length + 4;
\r
3484 if (args[ap->argno].use_count < 10)
\r
3485 args[ap->argno].use_count++;
\r
3488 xbuf = (char *) dmalloc (xbuf_len + 1);
\r
3492 ** Generate in XBUF the complete expansion
\r
3493 ** with arguments substituted in.
\r
3494 ** TOTLEN is the total size generated so far.
\r
3495 ** OFFSET is the index in the definition
\r
3496 ** of where we are copying from.
\r
3502 for (last_ap = NULL, ap = defn->pattern; ap != NULL;
\r
3503 last_ap = ap, ap = ap->next)
\r
3505 register struct argdata *arg = &args[ap->argno];
\r
3506 size_t count_before = totlen;
\r
3508 /* Add chars to XBUF. */
\r
3509 for (i = 0; i < ap->nchars; i++, offset++)
\r
3511 xbuf[totlen++] = exp[offset];
\r
3514 /* If followed by an empty rest arg with concatenation,
\r
3515 delete the last run of nonwhite chars. */
\r
3516 if (rest_zero && totlen > count_before
\r
3517 && ((ap->rest_args && ap->raw_before)
\r
3518 || (last_ap != NULL && last_ap->rest_args
\r
3519 && last_ap->raw_after)))
\r
3521 /* Delete final whitespace. */
\r
3522 while (totlen > count_before && is_space[(int) xbuf[totlen - 1]])
\r
3527 /* Delete the nonwhites before them. */
\r
3528 while (totlen > count_before && ! is_space[(int) xbuf[totlen - 1]])
\r
3534 if (ap->stringify != 0)
\r
3537 memcpy (xbuf + totlen,
\r
3538 ARG_BASE + arg->stringified,
\r
3539 size_fromInt (arg->stringified_length));
\r
3540 totlen += arg->stringified_length;
\r
3542 else if (ap->raw_before || ap->raw_after || cppReader_isTraditional (pfile))
\r
3549 p1 = ARG_BASE + arg->raw;
\r
3550 l1 = p1 + arg->raw_length;
\r
3552 if (ap->raw_before)
\r
3554 while (p1 != l1 && is_space[(int) *p1])
\r
3559 while (p1 != l1 && is_idchar[(int) *p1])
\r
3561 xbuf[totlen++] = *p1++;
\r
3564 /* Delete any no-reexpansion marker that follows
\r
3565 an identifier at the beginning of the argument
\r
3566 if the argument is concatenated with what precedes it. */
\r
3567 if (p1[0] == '@' && p1[1] == '-')
\r
3570 if (ap->raw_after)
\r
3572 /* Arg is concatenated after: delete trailing whitespace,
\r
3573 whitespace markers, and no-reexpansion markers. */
\r
3576 if (is_space[(int) l1[-1]]) l1--;
\r
3577 else if (l1[-1] == '-')
\r
3579 char *p2 = l1 - 1;
\r
3580 /* If a `-' is preceded by an odd number of newlines then it
\r
3581 and the last newline are a no-reexpansion marker. */
\r
3582 while (p2 != p1 && p2[-1] == '\n')
\r
3587 if (((l1 - 1 - p2) & 1) != 0)
\r
3593 /*@innerbreak@*/ break;
\r
3598 /*@innerbreak@*/ break;
\r
3603 memcpy (xbuf + totlen, p1, size_fromInt (l1 - p1));
\r
3604 totlen += l1 - p1;
\r
3611 expanded = ARG_BASE + arg->expanded;
\r
3613 if (!ap->raw_before && totlen > 0
\r
3614 && (arg->expand_length != 0)
\r
3615 && !cppReader_isTraditional(pfile)
\r
3616 && unsafe_chars (xbuf[totlen-1], expanded[0]))
\r
3618 xbuf[totlen++] = '@';
\r
3619 xbuf[totlen++] = ' ';
\r
3622 memcpy (xbuf + totlen, expanded,
\r
3623 size_fromInt (arg->expand_length));
\r
3624 totlen += arg->expand_length;
\r
3626 if (!ap->raw_after && totlen > 0
\r
3627 && offset < size_toInt (defn->length)
\r
3628 && !cppReader_isTraditional(pfile)
\r
3629 && unsafe_chars (xbuf[totlen-1], exp[offset]))
\r
3631 xbuf[totlen++] = '@';
\r
3632 xbuf[totlen++] = ' ';
\r
3635 /* If a macro argument with newlines is used multiple times,
\r
3636 then only expand the newlines once. This avoids creating
\r
3637 output lines which don't correspond to any input line,
\r
3638 which confuses gdb and gcov. */
\r
3639 if (arg->use_count > 1 && arg->newlines > 0)
\r
3641 /* Don't bother doing change_newlines for subsequent
\r
3643 arg->use_count = 1;
\r
3644 arg->expand_length
\r
3645 = change_newlines (expanded, arg->expand_length);
\r
3649 if (totlen > xbuf_len)
\r
3653 /* if there is anything left of the definition
\r
3654 after handling the arg list, copy that in too. */
\r
3656 for (i = offset; i < size_toInt (defn->length); i++)
\r
3658 /* if we've reached the end of the macro */
\r
3659 if (exp[i] == ')')
\r
3661 if (! (rest_zero && last_ap != NULL && last_ap->rest_args
\r
3662 && last_ap->raw_after))
\r
3663 xbuf[totlen++] = exp[i];
\r
3666 xbuf[totlen] = '\0';
\r
3667 xbuf_len = totlen;
\r
3670 pfile->output_escapes--;
\r
3672 /* Now put the expansion on the input stack
\r
3673 so our caller will commence reading from it. */
\r
3674 push_macro_expansion (pfile, xbuf, xbuf_len, hp);
\r
3675 cppReader_getBuffer (pfile)->has_escapes = 1;
\r
3677 /* Pop the space we've used in the token_buffer for argument expansion. */
\r
3678 cppReader_setWritten (pfile, old_written);
\r
3680 /* Recursive macro use sometimes works traditionally.
\r
3681 #define foo(x,y) bar (x (y,0), y)
\r
3684 if (!cppReader_isTraditional (pfile))
\r
3685 hp->type = T_DISABLED;
\r
3691 push_macro_expansion (cppReader *pfile, char *xbuf, size_t xbuf_len,
\r
3692 /*@dependent@*/ hashNode hp)
\r
3694 cppBuffer *mbuf = cppReader_pushBuffer (pfile, xbuf, xbuf_len);
\r
3701 mbuf->cleanup = cppReader_macroCleanup;
\r
3703 llassert (mbuf->hnode == NULL);
\r
3706 /* The first chars of the expansion should be a "@ " added by
\r
3707 collect_expansion. This is to prevent accidental token-pasting
\r
3708 between the text preceding the macro invocation, and the macro
\r
3711 We would like to avoid adding unneeded spaces (for the sake of
\r
3712 tools that use cpp, such as imake). In some common cases we can
\r
3713 tell that it is safe to omit the space.
\r
3715 The character before the macro invocation cannot have been an
\r
3716 idchar (or else it would have been pasted with the idchars of
\r
3717 the macro name). Therefore, if the first non-space character
\r
3718 of the expansion is an idchar, we do not need the extra space
\r
3719 to prevent token pasting.
\r
3721 Also, we don't need the extra space if the first char is '(',
\r
3722 or some other (less common) characters. */
\r
3724 if (xbuf[0] == '@' && xbuf[1] == ' '
\r
3725 && (is_idchar[(int) xbuf[2]] || xbuf[2] == '(' || xbuf[2] == '\''
\r
3726 || xbuf[2] == '\"'))
\r
3728 llassert (mbuf->cur != NULL);
\r
3734 /* Like cppGetToken, except that it does not read past end-of-line.
\r
3735 Also, horizontal space is skipped, and macros are popped. */
\r
3737 static enum cpp_token
\r
3738 get_directive_token (cppReader *pfile)
\r
3742 size_t old_written = cppReader_getWritten (pfile);
\r
3743 enum cpp_token token;
\r
3744 cppSkipHspace (pfile);
\r
3745 if (cppReader_peekC (pfile) == '\n')
\r
3747 return CPP_VSPACE;
\r
3750 token = cppGetToken (pfile);
\r
3755 if (!cppBuffer_isMacro (cppReader_getBuffer (pfile)))
\r
3760 cppReader_setWritten (pfile, old_written);
\r
3761 /*@switchbreak@*/ break;
\r
3769 /* Handle #include and #import.
\r
3770 This function expects to see "fname" or <fname> on the input.
\r
3772 The input is normally in part of the output_buffer following
\r
3773 cppReader_getWritten, and will get overwritten by output_line_command.
\r
3774 I.e. in input file specification has been popped by cppReader_handleDirective.
\r
3778 do_include (cppReader *pfile, struct directive *keyword,
\r
3779 /*@unused@*/ char *unused1, /*@unused@*/ char *unused2)
\r
3781 bool skip_dirs = (keyword->type == T_INCLUDE_NEXT);
\r
3783 char *fbeg, *fend; /* Beginning and end of fname */
\r
3784 enum cpp_token token;
\r
3786 /* Chain of dirs to search */
\r
3787 struct file_name_list *search_start = CPPOPTIONS (pfile)->include;
\r
3788 struct file_name_list dsp[1]; /* First in chain, if #include "..." */
\r
3789 struct file_name_list *searchptr = NULL;
\r
3790 size_t old_written = cppReader_getWritten (pfile);
\r
3794 int f; /* file number */
\r
3795 int angle_brackets = 0; /* 0 for "...", 1 for <...> */
\r
3796 f= -1; /* JF we iz paranoid! */
\r
3798 pfile->parsing_include_directive++;
\r
3799 token = get_directive_token (pfile);
\r
3800 pfile->parsing_include_directive--;
\r
3802 if (token == CPP_STRING)
\r
3804 /* FIXME - check no trailing garbage */
\r
3805 fbeg = pfile->token_buffer + old_written + 1;
\r
3806 fend = cppReader_getPWritten (pfile) - 1;
\r
3807 if (fbeg[-1] == '<')
\r
3809 angle_brackets = 1;
\r
3810 /* If -I-, start with the first -I dir after the -I-. */
\r
3811 if (CPPOPTIONS (pfile)->first_bracket_include != NULL)
\r
3812 search_start = CPPOPTIONS (pfile)->first_bracket_include;
\r
3814 /* If -I- was specified, don't search current dir, only spec'd ones. */
\r
3815 else if (!CPPOPTIONS (pfile)->ignore_srcdir)
\r
3817 cppBuffer *fp = CPPBUFFER (pfile);
\r
3818 /* We have "filename". Figure out directory this source
\r
3819 file is coming from and put it on the front of the list. */
\r
3821 for ( ; fp != cppReader_nullBuffer (pfile); fp = cppBuffer_prevBuffer (fp))
\r
3826 llassert (fp != NULL);
\r
3830 if (cstring_isDefined (fp->nominal_fname))
\r
3832 nam = cstring_toCharsSafe (fp->nominal_fname);
\r
3834 /* Found a named file. Figure out dir of the file,
\r
3835 and put it in front of the search list. */
\r
3836 dsp[0].next = search_start;
\r
3837 search_start = dsp;
\r
3840 ep = strrchr (nam, CONNECTCHAR);
\r
3842 ep = strrchr (nam, ']');
\r
3843 if (ep == NULL) ep = strrchr (nam, '>');
\r
3844 if (ep == NULL) ep = strrchr (nam, ':');
\r
3845 if (ep != NULL) ep++;
\r
3855 /*@-onlytrans@*/ /* This looks like a memory leak... */
\r
3856 dsp[0].fname = cstring_fromCharsNew (nam); /* evs 2000-07-20: was fromChars */
\r
3860 if (n + INCLUDE_LEN_FUDGE > pfile->max_include_len)
\r
3861 pfile->max_include_len = n + INCLUDE_LEN_FUDGE;
\r
3865 dsp[0].fname = cstring_undefined; /* Current directory */
\r
3868 dsp[0].got_name_map = 0;
\r
3879 else if (token == CPP_NAME)
\r
3882 * Support '#include xyz' like VAX-C to allow for easy use of all the
\r
3883 * decwindow include files. It defaults to '#include <xyz.h>' (so the
\r
3884 * code from case '<' is repeated here) and generates a warning.
\r
3886 cppReader_warning (pfile,
\r
3887 "VAX-C-style include specification found, use '#include <filename.h>' !");
\r
3888 angle_brackets = 1;
\r
3889 /* If -I-, start with the first -I dir after the -I-. */
\r
3890 if (CPPOPTIONS (pfile)->first_bracket_include)
\r
3891 search_start = CPPOPTIONS (pfile)->first_bracket_include;
\r
3892 fbeg = pfile->token_buffer + old_written;
\r
3893 fend = cppReader_getPWritten (pfile);
\r
3898 cppReader_error (pfile,
\r
3899 message ("Preprocessor command #%s expects \"FILENAME\" or <FILENAME>",
\r
3902 cppReader_setWritten (pfile, old_written);
\r
3903 cppReader_skipRestOfLine (pfile);
\r
3909 token = get_directive_token (pfile);
\r
3910 if (token != CPP_VSPACE)
\r
3912 cppReader_errorLit (pfile,
\r
3913 cstring_makeLiteralTemp ("Junk at end of #include"));
\r
3915 while (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP)
\r
3917 token = get_directive_token (pfile);
\r
3922 ** For #include_next, skip in the search path
\r
3923 ** past the dir in which the containing file was found.
\r
3928 cppBuffer *fp = CPPBUFFER (pfile);
\r
3930 for (; fp != cppReader_nullBuffer (pfile); fp = cppBuffer_prevBuffer (fp))
\r
3932 llassert (fp != NULL);
\r
3934 if (fp->fname != NULL)
\r
3936 /* fp->dir is null if the containing file was specified with
\r
3937 an absolute file name. In that case, don't skip anything. */
\r
3938 if (fp->dir == SELF_DIR_DUMMY)
\r
3940 search_start = CPPOPTIONS (pfile)->include;
\r
3942 else if (fp->dir != NULL)
\r
3944 search_start = fp->dir->next;
\r
3956 cppReader_setWritten (pfile, old_written);
\r
3958 flen = fend - fbeg;
\r
3960 DPRINTF (("fbeg: %s", fbeg));
\r
3964 cppReader_error (pfile,
\r
3965 message ("Empty file name in #%s", keyword->name));
\r
3970 ** Allocate this permanently, because it gets stored in the definitions
\r
3974 fname = cstring_undefined;
\r
3976 /* + 2 above for slash and terminating null. */
\r
3977 /* + 2 added for '.h' on VMS (to support '#include filename') */
\r
3979 /* If specified file name is absolute, just open it. */
\r
3981 if (osd_isConnectChar (*fbeg)
\r
3982 # if defined (WIN32) || defined (OS2)
\r
3983 || (*(fbeg + 1) == ':')
\r
3987 fname = cstring_copyLength (fbeg, flen);
\r
3989 if (redundant_include_p (pfile, fname))
\r
3991 cstring_free (fname);
\r
3995 f = open_include_file (pfile, fname, NULL);
\r
3997 if (f == IMPORT_FOUND)
\r
3999 return 0; /* Already included this file */
\r
4004 /* Search directory path, trying to open the file.
\r
4005 Copy each filename tried into FNAME. */
\r
4007 for (searchptr = search_start; searchptr != NULL;
\r
4008 searchptr = searchptr->next)
\r
4010 if (!cstring_isEmpty (searchptr->fname))
\r
4012 /* The empty string in a search path is ignored.
\r
4013 This makes it possible to turn off entirely
\r
4014 a standard piece of the list. */
\r
4015 if (cstring_isEmpty (searchptr->fname))
\r
4018 fname = cstring_copy (searchptr->fname);
\r
4019 fname = cstring_appendChar (fname, CONNECTCHAR);
\r
4020 DPRINTF (("Here: %s", fname));
\r
4027 fname = cstring_concatLength (fname, fbeg, flen);
\r
4029 DPRINTF (("fname: %s", fname));
\r
4031 /* Win32 directory fix from Kay Buschner. */
\r
4032 #if defined (WIN32) || defined (OS2)
\r
4033 /* Fix all unixdir slashes to win dir slashes */
\r
4034 if (searchptr->fname && (searchptr->fname[0] != 0))
\r
4036 cstring_replaceAll (fname, '/', '\\');
\r
4038 #endif /* WIN32 */
\r
4041 /* Change this 1/2 Unix 1/2 VMS file specification into a
\r
4042 full VMS file specification */
\r
4043 if (searchptr->fname && (searchptr->fname[0] != 0)) {
\r
4044 /* Fix up the filename */
\r
4045 hack_vms_include_specification (fname);
\r
4047 /* This is a normal VMS filespec, so use it unchanged. */
\r
4048 strncpy (fname, fbeg, flen);
\r
4050 /* if it's '#include filename', add the missing .h */
\r
4051 if (strchr (fname,'.') == NULL) {
\r
4052 strcat (fname, ".h");
\r
4056 /* ??? There are currently 3 separate mechanisms for avoiding processing
\r
4057 of redundant include files: #import, #pragma once, and
\r
4058 redundant_include_p. It would be nice if they were unified. */
\r
4060 if (redundant_include_p (pfile, fname))
\r
4062 cstring_free (fname);
\r
4066 DPRINTF (("Trying: %s", fname));
\r
4068 f = open_include_file (pfile, fname, searchptr);
\r
4070 if (f == IMPORT_FOUND)
\r
4072 return 0; /* Already included this file */
\r
4075 else if (f == IMPORT_NOT_FOUND && errno == EACCES)
\r
4077 cppReader_warning (pfile,
\r
4078 message ("Header file %s exists, but is not readable", fname));
\r
4091 /* A file that was not found. */
\r
4092 fname = cstring_copyLength (fbeg, flen);
\r
4094 if (search_start != NULL)
\r
4096 cppReader_error (pfile,
\r
4097 message ("Cannot find include file %s on search path: %x",
\r
4099 searchPath_unparse (search_start)));
\r
4103 cppReader_error (pfile,
\r
4104 message ("No include path in which to find %s", fname));
\r
4109 ** Check to see if this include file is a once-only include file.
\r
4110 ** If so, give up.
\r
4113 struct file_name_list *ptr;
\r
4115 for (ptr = pfile->all_include_files; ptr != NULL; ptr = ptr->next)
\r
4117 if (cstring_equal (ptr->fname, fname))
\r
4119 /* This file was included before. */
\r
4126 /* This is the first time for this file. */
\r
4127 /* Add it to list of files included. */
\r
4129 ptr = (struct file_name_list *) dmalloc (sizeof (*ptr));
\r
4130 ptr->control_macro = NULL;
\r
4131 ptr->c_system_include_path = NULL;
\r
4132 ptr->next = pfile->all_include_files;
\r
4133 ptr->fname = fname;
\r
4134 ptr->got_name_map = NULL;
\r
4136 DPRINTF (("Including file: %s", fname));
\r
4137 pfile->all_include_files = ptr;
\r
4138 assertSet (pfile->all_include_files);
\r
4141 if (angle_brackets != 0)
\r
4143 pfile->system_include_depth++;
\r
4146 /* Actually process the file */
\r
4147 if (cppReader_pushBuffer (pfile, NULL, 0) == NULL)
\r
4149 cstring_free (fname);
\r
4153 if (finclude (pfile, f, fname, is_system_include (pfile, fname),
\r
4154 searchptr != dsp ? searchptr : SELF_DIR_DUMMY))
\r
4156 output_line_command (pfile, 0, enter_file);
\r
4157 pfile->only_seen_white = 2;
\r
4160 if (angle_brackets)
\r
4162 pfile->system_include_depth--;
\r
4164 /*@-branchstate@*/
\r
4165 } /*@=branchstate@*/
\r
4170 /* Return nonzero if there is no need to include file NAME
\r
4171 because it has already been included and it contains a conditional
\r
4172 to make a repeated include do nothing. */
\r
4175 redundant_include_p (cppReader *pfile, cstring name)
\r
4177 struct file_name_list *l = pfile->all_include_files;
\r
4179 for (; l != NULL; l = l->next)
\r
4181 if (cstring_equal (name, l->fname)
\r
4182 && (l->control_macro != NULL)
\r
4183 && (cppReader_lookup (l->control_macro, -1, -1) != NULL))
\r
4192 /* Return nonzero if the given FILENAME is an absolute pathname which
\r
4193 designates a file within one of the known "system" include file
\r
4194 directories. We assume here that if the given FILENAME looks like
\r
4195 it is the name of a file which resides either directly in a "system"
\r
4196 include file directory, or within any subdirectory thereof, then the
\r
4197 given file must be a "system" include file. This function tells us
\r
4198 if we should suppress pedantic errors/warnings for the given FILENAME.
\r
4200 The value is 2 if the file is a C-language system header file
\r
4201 for which C++ should (on most systems) assume `extern "C"'. */
\r
4204 is_system_include (cppReader *pfile, cstring filename)
\r
4206 struct file_name_list *searchptr;
\r
4208 for (searchptr = CPPOPTIONS (pfile)->first_system_include;
\r
4209 searchptr != NULL;
\r
4210 searchptr = searchptr->next)
\r
4212 if (!cstring_isEmpty (searchptr->fname)) {
\r
4213 cstring sys_dir = searchptr->fname;
\r
4214 int length = cstring_length (sys_dir);
\r
4216 if (cstring_equalLen (sys_dir, filename, length)
\r
4217 && osd_isConnectChar (cstring_getChar (filename, length)))
\r
4219 if (searchptr->c_system_include_path)
\r
4230 /* Convert a character string literal into a nul-terminated string.
\r
4231 The input string is [IN ... LIMIT).
\r
4232 The result is placed in RESULT. RESULT can be the same as IN.
\r
4233 The value returned in the end of the string written to RESULT,
\r
4234 or NULL on error. */
\r
4236 static /*@null@*/ char *
\r
4237 convert_string (cppReader *pfile, /*@returned@*/ char *result,
\r
4238 char *in, char *limit, int handle_escapes)
\r
4248 while (in < limit)
\r
4258 /*@switchbreak@*/ break;
\r
4260 if (handle_escapes)
\r
4262 char *bpc = (char *) in;
\r
4263 int i = (char) cppReader_parseEscape (pfile, &bpc);
\r
4264 in = (char *) bpc;
\r
4266 *result++ = (char) c;
\r
4267 /*@switchbreak@*/ break;
\r
4281 * interpret #line command. Remembers previously seen fnames
\r
4282 * in its very own hash table.
\r
4285 /*@constant int FNAME_HASHSIZE@*/
\r
4286 #define FNAME_HASHSIZE 37
\r
4289 do_line (cppReader *pfile, /*@unused@*/ struct directive *keyword)
\r
4291 cppBuffer *ip = cppReader_getBuffer (pfile);
\r
4293 size_t old_written = cppReader_getWritten (pfile);
\r
4294 enum file_change_code file_change = same_file;
\r
4295 enum cpp_token token;
\r
4297 token = get_directive_token (pfile);
\r
4299 if (token != CPP_NUMBER
\r
4300 || !isdigit(pfile->token_buffer[old_written]))
\r
4302 cppReader_errorLit (pfile,
\r
4303 cstring_makeLiteralTemp ("invalid format `#line' command"));
\r
4305 goto bad_line_directive;
\r
4308 /* The Newline at the end of this line remains to be processed.
\r
4309 To put the next line at the specified line number,
\r
4310 we must store a line number now that is one less. */
\r
4311 new_lineno = atoi (pfile->token_buffer + old_written) - 1;
\r
4312 cppReader_setWritten (pfile, old_written);
\r
4314 /* NEW_LINENO is one less than the actual line number here. */
\r
4315 if (cppReader_isPedantic (pfile) && new_lineno < 0)
\r
4316 cppReader_pedwarnLit (pfile,
\r
4317 cstring_makeLiteralTemp ("line number out of range in `#line' command"));
\r
4319 token = get_directive_token (pfile);
\r
4321 if (token == CPP_STRING) {
\r
4322 char *fname = pfile->token_buffer + old_written;
\r
4324 static hashNode fname_table[FNAME_HASHSIZE];
\r
4326 hashNode *hash_bucket;
\r
4331 /* Turn the file name, which is a character string literal,
\r
4332 into a null-terminated string. Do this in place. */
\r
4333 end_name = convert_string (pfile, fname, fname, cppReader_getPWritten (pfile), 1);
\r
4334 if (end_name == NULL)
\r
4336 cppReader_errorLit (pfile,
\r
4337 cstring_makeLiteralTemp ("invalid format `#line' command"));
\r
4338 goto bad_line_directive;
\r
4341 fname_length = end_name - fname;
\r
4342 num_start = cppReader_getWritten (pfile);
\r
4344 token = get_directive_token (pfile);
\r
4345 if (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP) {
\r
4346 p = pfile->token_buffer + num_start;
\r
4347 if (cppReader_isPedantic (pfile))
\r
4348 cppReader_pedwarnLit (pfile,
\r
4349 cstring_makeLiteralTemp ("garbage at end of `#line' command"));
\r
4351 if (token != CPP_NUMBER || *p < '0' || *p > '4' || p[1] != '\0')
\r
4353 cppReader_errorLit (pfile,
\r
4354 cstring_makeLiteralTemp ("invalid format `#line' command"));
\r
4355 goto bad_line_directive;
\r
4358 file_change = enter_file;
\r
4360 file_change = leave_file;
\r
4362 ip->system_header_p = 1;
\r
4363 else /* if (*p == 4) */
\r
4364 ip->system_header_p = 2;
\r
4366 cppReader_setWritten (pfile, num_start);
\r
4367 token = get_directive_token (pfile);
\r
4368 p = pfile->token_buffer + num_start;
\r
4369 if (token == CPP_NUMBER && p[1] == '\0' && (*p == '3' || *p== '4')) {
\r
4370 ip->system_header_p = *p == 3 ? 1 : 2;
\r
4371 token = get_directive_token (pfile);
\r
4373 if (token != CPP_VSPACE) {
\r
4374 cppReader_errorLit (pfile,
\r
4375 cstring_makeLiteralTemp ("invalid format `#line' command"));
\r
4377 goto bad_line_directive;
\r
4382 &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
\r
4383 for (hp = *hash_bucket; hp != NULL; hp = hp->next)
\r
4385 if (hp->length == fname_length &&
\r
4386 strncmp (hp->value.cpval, fname, size_fromInt (fname_length)) == 0) {
\r
4387 ip->nominal_fname = cstring_fromChars (hp->value.cpval);
\r
4393 /* Didn't find it; cons up a new one. */
\r
4394 hp = (hashNode) dmalloc (sizeof (*hp));
\r
4397 hp->bucket_hdr = NULL;
\r
4398 hp->type = T_NONE;
\r
4399 hp->name = cstring_undefined;
\r
4400 hp->next = *hash_bucket;
\r
4402 *hash_bucket = hp;
\r
4404 hp->length = fname_length;
\r
4405 hp->value.cpval = dmalloc (sizeof (*hp->value.cpval) * (fname_length + 1));
\r
4406 memcpy (hp->value.cpval, fname, size_fromInt (fname_length));
\r
4407 hp->value.cpval[fname_length] = '\0';
\r
4408 ip->nominal_fname = cstring_fromChars (hp->value.cpval);
\r
4411 else if (token != CPP_VSPACE && token != CPP_EOF)
\r
4413 cppReader_errorLit (pfile,
\r
4414 cstring_makeLiteralTemp ("invalid format `#line' command"));
\r
4415 goto bad_line_directive;
\r
4422 ip->lineno = new_lineno;
\r
4423 bad_line_directive:
\r
4424 cppReader_skipRestOfLine (pfile);
\r
4425 cppReader_setWritten (pfile, old_written);
\r
4426 output_line_command (pfile, 0, file_change);
\r
4431 * remove the definition of a symbol from the symbol table.
\r
4432 * according to un*x /lib/cpp, it is not an error to undef
\r
4433 * something that has no definitions, so it isn't one here either.
\r
4437 do_undef (cppReader *pfile, struct directive *keyword, char *buf, char *limit)
\r
4442 char *orig_buf = buf;
\r
4444 SKIP_WHITE_SPACE (buf);
\r
4446 sym_length = cppReader_checkMacroName (pfile, buf, cstring_makeLiteralTemp ("macro"));
\r
4448 while ((hp = cppReader_lookup (buf, sym_length, -1)) != NULL)
\r
4450 /* If we are generating additional info for debugging (with -g) we
\r
4451 need to pass through all effective #undef commands. */
\r
4452 if (CPPOPTIONS (pfile)->debug_output && (keyword != NULL))
\r
4454 pass_thru_directive (orig_buf, limit, pfile, keyword);
\r
4457 if (hp->type != T_MACRO)
\r
4459 cppReader_warning (pfile,
\r
4460 message ("Undefining preprocessor builtin: %s",
\r
4464 cppReader_deleteMacro (hp);
\r
4467 if (cppReader_isPedantic (pfile)) {
\r
4468 buf += sym_length;
\r
4469 SKIP_WHITE_SPACE (buf);
\r
4472 cppReader_pedwarnLit (pfile,
\r
4473 cstring_makeLiteralTemp ("garbage after `#undef' directive"));
\r
4482 * Report an error detected by the program we are processing.
\r
4483 * Use the text of the line in the error message.
\r
4484 * (We use error because it prints the filename & line#.)
\r
4488 do_error (cppReader *pfile, /*@unused@*/ struct directive *keyword,
\r
4489 char *buf, char *limit)
\r
4491 int length = limit - buf;
\r
4492 cstring copy = cstring_copyLength (buf, length);
\r
4493 cstring adv = cstring_advanceWhiteSpace (copy);
\r
4495 cppReader_error (pfile, message ("#error %s", adv));
\r
4496 cstring_free (copy);
\r
4501 * Report a warning detected by the program we are processing.
\r
4502 * Use the text of the line in the warning message, then continue.
\r
4503 * (We use error because it prints the filename & line#.)
\r
4507 do_warning (cppReader *pfile, /*@unused@*/ struct directive *keyword,
\r
4508 char *buf, char *limit)
\r
4510 int length = limit - buf;
\r
4511 cstring copy = cstring_copyLength (buf, length);
\r
4512 cstring adv = cstring_advanceWhiteSpace (copy);
\r
4513 cppReader_warning (pfile, message ("#warning %s", adv));
\r
4514 cstring_free (copy);
\r
4519 /* #ident has already been copied to the output file, so just ignore it. */
\r
4522 do_ident (cppReader *pfile, /*@unused@*/ struct directive *keyword,
\r
4523 /*@unused@*/ char *buf, /*@unused@*/ char *limit)
\r
4525 /* Allow #ident in system headers, since that's not user's fault. */
\r
4526 if (cppReader_isPedantic (pfile) && !cppReader_getBuffer (pfile)->system_header_p)
\r
4527 cppReader_pedwarnLit (pfile,
\r
4528 cstring_makeLiteralTemp ("ANSI C does not allow `#ident'"));
\r
4530 /* Leave rest of line to be read by later calls to cppGetToken. */
\r
4535 /* #pragma and its argument line have already been copied to the output file.
\r
4536 Just check for some recognized pragmas that need validation here. */
\r
4539 do_pragma (cppReader *pfile, /*@unused@*/ struct directive *keyword,
\r
4540 /*@unused@*/ char *buf, /*@unused@*/ char *limit)
\r
4542 while (*buf == ' ' || *buf == '\t')
\r
4547 if (!strncmp (buf, "implementation", 14)) {
\r
4548 /* Be quiet about `#pragma implementation' for a file only if it hasn't
\r
4549 been included yet. */
\r
4550 struct file_name_list *ptr;
\r
4551 char *p = buf + 14, *fname, *inc_fname;
\r
4553 SKIP_WHITE_SPACE (p);
\r
4554 if (*p == '\n' || *p != '\"')
\r
4558 p = (char *) strchr (fname, '\"');
\r
4559 fname_len = p != NULL ? p - fname : mstring_length (fname);
\r
4561 for (ptr = pfile->all_include_files; ptr != NULL; ptr = ptr->next)
\r
4563 inc_fname = (char *) strrchr (cstring_toCharsSafe (ptr->fname), CONNECTCHAR);
\r
4564 inc_fname = (inc_fname != NULL)
\r
4565 ? inc_fname + 1 : cstring_toCharsSafe (ptr->fname);
\r
4567 if ((inc_fname != NULL)
\r
4568 && (strncmp (inc_fname, fname, size_fromInt (fname_len)) == 0))
\r
4570 cpp_setLocation (pfile);
\r
4572 ppllerror (message ("`#pragma implementation' for `%s' appears "
\r
4573 "after file is included",
\r
4574 cstring_fromChars (fname)));
\r
4583 * handle #if command by
\r
4584 * 1) inserting special `defined' keyword into the hash table
\r
4585 * that gets turned into 0 or 1 by special_symbol (thus,
\r
4586 * if the luser has a symbol called `defined' already, it won't
\r
4587 * work inside the #if command)
\r
4588 * 2) rescan the input into a temporary output buffer
\r
4589 * 3) pass the output buffer to the yacc parser and collect a value
\r
4590 * 4) clean up the mess left from steps 1 and 2.
\r
4591 * 5) call conditional_skip to skip til the next #endif (etc.),
\r
4592 * or not, depending on the value from step 3.
\r
4596 do_if (cppReader *pfile, /*@unused@*/ struct directive *keyword,
\r
4597 char *buf, char *limit)
\r
4599 HOST_WIDE_INT value = eval_if_expression (pfile, buf, limit - buf);
\r
4600 conditional_skip (pfile, value == 0, T_IF, NULL);
\r
4605 * handle a #elif directive by not changing if_stack either.
\r
4606 * see the comment above do_else.
\r
4609 static int do_elif (cppReader *pfile, /*@unused@*/ struct directive *keyword,
\r
4610 char *buf, char *limit)
\r
4612 if (pfile->if_stack == cppReader_getBuffer (pfile)->if_stack)
\r
4614 cppReader_errorLit (pfile,
\r
4615 cstring_makeLiteralTemp ("Preprocessor command #elif is not within a conditional"));
\r
4620 llassert (pfile->if_stack != NULL);
\r
4622 if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF)
\r
4624 cppReader_errorLit (pfile,
\r
4625 cstring_makeLiteralTemp ("`#elif' after `#else'"));
\r
4627 if (pfile->if_stack->fname != NULL
\r
4628 && cppReader_getBuffer (pfile)->fname != NULL
\r
4629 && !cstring_equal (pfile->if_stack->fname,
\r
4630 cppReader_getBuffer (pfile)->nominal_fname))
\r
4631 fprintf (stderr, ", file %s", cstring_toCharsSafe (pfile->if_stack->fname));
\r
4632 fprintf (stderr, ")\n");
\r
4634 pfile->if_stack->type = T_ELIF;
\r
4637 if (pfile->if_stack->if_succeeded)
\r
4639 skip_if_group (pfile, 0);
\r
4643 HOST_WIDE_INT value = eval_if_expression (pfile, buf, limit - buf);
\r
4645 skip_if_group (pfile, 0);
\r
4648 ++pfile->if_stack->if_succeeded; /* continue processing input */
\r
4649 output_line_command (pfile, 1, same_file);
\r
4657 * evaluate a #if expression in BUF, of length LENGTH,
\r
4658 * then parse the result as a C expression and return the value as an int.
\r
4661 static HOST_WIDE_INT
\r
4662 eval_if_expression (cppReader *pfile,
\r
4663 /*@unused@*/ char *buf,
\r
4664 /*@unused@*/ int length)
\r
4666 hashNode save_defined;
\r
4667 HOST_WIDE_INT value;
\r
4668 size_t old_written = cppReader_getWritten (pfile);
\r
4670 save_defined = cppReader_install ("defined", -1, T_SPEC_DEFINED, 0, 0, -1);
\r
4671 pfile->pcp_inside_if = 1;
\r
4673 value = cppReader_parseExpression (pfile);
\r
4674 pfile->pcp_inside_if = 0;
\r
4676 /* Clean up special symbol */
\r
4677 cppReader_deleteMacro (save_defined);
\r
4679 cppReader_setWritten (pfile, old_written); /* Pop */
\r
4685 * routine to handle ifdef/ifndef. Try to look up the symbol,
\r
4686 * then do or don't skip to the #endif/#else/#elif depending
\r
4687 * on what directive is actually being processed.
\r
4691 do_xifdef (cppReader *pfile, struct directive *keyword,
\r
4692 /*@unused@*/ char *unused1, /*@unused@*/ char *unused2)
\r
4695 cppBuffer *ip = cppReader_getBuffer (pfile);
\r
4698 enum cpp_token token;
\r
4699 int start_of_file = 0;
\r
4700 char *control_macro = 0;
\r
4701 size_t old_written = cppReader_getWritten (pfile);
\r
4703 DPRINTF (("do xifdef: %d",
\r
4704 keyword->type == T_IFNDEF));
\r
4706 /* Detect a #ifndef at start of file (not counting comments). */
\r
4707 if (cstring_isDefined (ip->fname) && keyword->type == T_IFNDEF)
\r
4709 start_of_file = pfile->only_seen_white == 2;
\r
4712 pfile->no_macro_expand++;
\r
4713 token = get_directive_token (pfile);
\r
4714 pfile->no_macro_expand--;
\r
4716 ident = pfile->token_buffer + old_written;
\r
4717 ident_length = size_toInt (cppReader_getWritten (pfile) - old_written);
\r
4718 cppReader_setWritten (pfile, old_written); /* Pop */
\r
4720 if (token == CPP_VSPACE || token == CPP_POP || token == CPP_EOF)
\r
4722 skip = (keyword->type == T_IFDEF);
\r
4723 if (! cppReader_isTraditional (pfile))
\r
4725 cppReader_pedwarn (pfile,
\r
4726 message ("`#%s' with no argument", keyword->name));
\r
4729 else if (token == CPP_NAME)
\r
4731 hashNode hp = cppReader_lookup (ident, ident_length, -1);
\r
4732 skip = (keyword->type == T_IFDEF)
\r
4733 ? (hp == NULL) : (hp != NULL);
\r
4735 DPRINTF (("hp null: %d / %d / %d",
\r
4737 (keyword->type == T_IFNDEF),
\r
4740 if (start_of_file && !skip)
\r
4742 DPRINTF (("Not skipping!"));
\r
4743 control_macro = (char *) dmalloc (size_fromInt (ident_length + 1));
\r
4744 memcpy (control_macro, ident, size_fromInt (ident_length + 1));
\r
4749 skip = (keyword->type == T_IFDEF);
\r
4750 if (! cppReader_isTraditional (pfile))
\r
4752 cppReader_error (pfile,
\r
4753 message ("`#%s' with invalid argument", keyword->name));
\r
4757 if (!cppReader_isTraditional (pfile))
\r
4760 cppSkipHspace (pfile);
\r
4761 c = cppReader_peekC (pfile);
\r
4762 if (c != EOF && c != '\n')
\r
4764 cppReader_pedwarn (pfile,
\r
4765 message ("garbage at end of `#%s' argument", keyword->name));
\r
4769 cppReader_skipRestOfLine (pfile);
\r
4771 DPRINTF (("Conditional skip: %d", skip));
\r
4772 conditional_skip (pfile, skip, T_IF, control_macro);
\r
4776 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
\r
4777 If this is a #ifndef starting at the beginning of a file,
\r
4778 CONTROL_MACRO is the macro name tested by the #ifndef.
\r
4779 Otherwise, CONTROL_MACRO is 0. */
\r
4782 conditional_skip (cppReader *pfile, int skip,
\r
4783 enum node_type type,
\r
4784 /*@dependent@*/ char *control_macro)
\r
4786 cppIfStackFrame *temp = (cppIfStackFrame *) dmalloc (sizeof (*temp));
\r
4788 temp->fname = cppReader_getBuffer (pfile)->nominal_fname;
\r
4789 temp->next = pfile->if_stack;
\r
4790 temp->control_macro = control_macro;
\r
4792 temp->if_succeeded = 0;
\r
4794 pfile->if_stack = temp;
\r
4795 pfile->if_stack->type = type;
\r
4799 skip_if_group (pfile, 0);
\r
4804 ++pfile->if_stack->if_succeeded;
\r
4805 output_line_command (pfile, 1, same_file);
\r
4810 * skip to #endif, #else, or #elif. adjust line numbers, etc.
\r
4811 * leaves input ptr at the sharp sign found.
\r
4812 * If ANY is nonzero, return at next directive of any sort.
\r
4816 skip_if_group (cppReader *pfile, int any)
\r
4819 struct directive *kt;
\r
4820 cppIfStackFrame *save_if_stack = pfile->if_stack; /* don't pop past here */
\r
4821 register int ident_length;
\r
4823 struct parse_marker line_start_mark;
\r
4825 parseSetMark (&line_start_mark, pfile);
\r
4827 if (CPPOPTIONS (pfile)->output_conditionals) {
\r
4828 static char failed[] = "#failed\n";
\r
4829 cppReader_puts (pfile, failed, sizeof(failed)-1);
\r
4831 output_line_command (pfile, 1, same_file);
\r
4835 if (CPPOPTIONS (pfile)->output_conditionals)
\r
4837 cppBuffer *pbuf = cppReader_getBuffer (pfile);
\r
4840 llassert (pbuf->buf != NULL);
\r
4842 start_line = pbuf->buf + line_start_mark.position;
\r
4843 cppReader_puts (pfile, start_line, size_fromInt (pbuf->cur - start_line));
\r
4846 parseMoveMark (&line_start_mark, pfile);
\r
4848 if (!cppReader_isTraditional (pfile))
\r
4850 cppSkipHspace (pfile);
\r
4853 c = cppReader_getC (pfile);
\r
4856 size_t old_written = cppReader_getWritten (pfile);
\r
4857 cppSkipHspace (pfile);
\r
4859 parse_name (pfile, cppReader_getC (pfile));
\r
4860 ident_length = size_toInt (cppReader_getWritten (pfile) - old_written);
\r
4861 ident = pfile->token_buffer + old_written;
\r
4862 pfile->limit = ident;
\r
4864 for (kt = directive_table; kt->length >= 0; kt++)
\r
4866 cppIfStackFrame *temp;
\r
4867 if (ident_length == kt->length
\r
4868 && cstring_equalPrefix (kt->name, cstring_fromChars (ident)))
\r
4870 /* If we are asked to return on next directive, do so now. */
\r
4881 temp = (cppIfStackFrame *) dmalloc (sizeof (*temp));
\r
4882 temp->next = pfile->if_stack;
\r
4883 temp->fname = cppReader_getBuffer (pfile)->nominal_fname;
\r
4884 temp->type = kt->type;
\r
4886 temp->if_succeeded = 0;
\r
4887 temp->control_macro = NULL;
\r
4889 pfile->if_stack = temp;
\r
4890 /*@switchbreak@*/ break;
\r
4893 if (cppReader_isPedantic (pfile) && pfile->if_stack != save_if_stack)
\r
4894 validate_else (pfile,
\r
4895 cstring_makeLiteralTemp (kt->type == T_ELSE ? "#else" : "#endif"));
\r
4898 if (pfile->if_stack == cppReader_getBuffer (pfile)->if_stack)
\r
4900 cppReader_error (pfile,
\r
4901 message ("Preprocessor command #%s is not within a conditional", kt->name));
\r
4902 /*@switchbreak@*/ break;
\r
4904 else if (pfile->if_stack == save_if_stack)
\r
4906 goto done; /* found what we came for */
\r
4913 if (kt->type != T_ENDIF)
\r
4915 llassert (pfile->if_stack != NULL);
\r
4917 if (pfile->if_stack->type == T_ELSE)
\r
4919 cppReader_errorLit (pfile,
\r
4920 cstring_makeLiteralTemp ("`#else' or `#elif' after `#else'"));
\r
4923 pfile->if_stack->type = kt->type;
\r
4924 /*@switchbreak@*/ break;
\r
4927 temp = pfile->if_stack;
\r
4928 llassert (temp != NULL);
\r
4929 pfile->if_stack = temp->next;
\r
4931 /*@switchbreak@*/ break;
\r
4933 /*@-branchstate@*/
\r
4935 /*@=branchstate@*/
\r
4939 /* Don't let erroneous code go by. */
\r
4941 if (kt->length < 0 && !CPPOPTIONS (pfile)->lang_asm
\r
4942 && cppReader_isPedantic (pfile))
\r
4944 cppReader_pedwarnLit (pfile,
\r
4945 cstring_makeLiteralTemp ("Invalid preprocessor directive name"));
\r
4949 c = cppReader_getC (pfile);
\r
4951 /* We're in the middle of a line. Skip the rest of it. */
\r
4959 case '/': /* possible comment */
\r
4960 c = skip_comment (pfile, NULL);
\r
4963 /*@switchbreak@*/ break;
\r
4966 cppReader_forward (pfile, -1);
\r
4967 old = cppReader_getWritten (pfile);
\r
4968 (void) cppGetToken (pfile);
\r
4969 cppReader_setWritten (pfile, old);
\r
4970 /*@switchbreak@*/ break;
\r
4972 /* Char after backslash loses its special meaning. */
\r
4973 if (cppReader_peekC (pfile) == '\n')
\r
4975 cppReader_forward (pfile, 1);
\r
4978 /*@switchbreak@*/ break;
\r
4982 c = cppReader_getC (pfile);
\r
4985 if (CPPOPTIONS (pfile)->output_conditionals) {
\r
4986 static char end_failed[] = "#endfailed\n";
\r
4987 cppReader_puts (pfile, end_failed, sizeof(end_failed)-1);
\r
4990 pfile->only_seen_white = 1;
\r
4992 parseGotoMark (&line_start_mark, pfile);
\r
4993 parseClearMark (&line_start_mark);
\r
4997 * handle a #else directive. Do this by just continuing processing
\r
4998 * without changing if_stack ; this is so that the error message
\r
4999 * for missing #endif's etc. will point to the original #if. It
\r
5000 * is possible that something different would be better.
\r
5004 do_else (cppReader *pfile, /*@unused@*/ struct directive *keyword,
\r
5005 /*@unused@*/ char *buf, /*@unused@*/ char *limit)
\r
5007 if (cppReader_isPedantic (pfile))
\r
5009 validate_else (pfile, cstring_makeLiteralTemp ("#else"));
\r
5012 cppReader_skipRestOfLine (pfile);
\r
5014 if (pfile->if_stack == cppReader_getBuffer (pfile)->if_stack) {
\r
5015 cppReader_errorLit (pfile,
\r
5016 cstring_makeLiteralTemp ("Preprocessor command #else is not within a conditional"));
\r
5019 /* #ifndef can't have its special treatment for containing the whole file
\r
5020 if it has a #else clause. */
\r
5022 llassert (pfile->if_stack != NULL);
\r
5024 pfile->if_stack->control_macro = 0;
\r
5026 if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF)
\r
5028 cpp_setLocation (pfile);
\r
5029 genppllerrorhint (FLG_PREPROC,
\r
5030 message ("Pre-processor directive #else after #else"),
\r
5031 message ("%q: Location of match",
\r
5032 fileloc_unparseRaw (pfile->if_stack->fname,
\r
5033 pfile->if_stack->lineno)));
\r
5036 pfile->if_stack->type = T_ELSE;
\r
5039 if (pfile->if_stack->if_succeeded)
\r
5040 skip_if_group (pfile, 0);
\r
5042 ++pfile->if_stack->if_succeeded; /* continue processing input */
\r
5043 output_line_command (pfile, 1, same_file);
\r
5050 * unstack after #endif command
\r
5054 do_endif (cppReader *pfile, /*@unused@*/ struct directive *keyword,
\r
5055 /*@unused@*/ char *buf, /*@unused@*/ char *limit)
\r
5057 if (cppReader_isPedantic (pfile))
\r
5059 validate_else (pfile, cstring_makeLiteralTemp ("#endif"));
\r
5062 cppReader_skipRestOfLine (pfile);
\r
5064 if (pfile->if_stack == cppReader_getBuffer (pfile)->if_stack)
\r
5066 cppReader_errorLit (pfile, cstring_makeLiteralTemp ("Unbalanced #endif"));
\r
5070 cppIfStackFrame *temp = pfile->if_stack;
\r
5072 llassert (temp != NULL);
\r
5074 pfile->if_stack = temp->next;
\r
5075 if (temp->control_macro != 0)
\r
5077 /* This #endif matched a #ifndef at the start of the file.
\r
5078 See if it is at the end of the file. */
\r
5079 struct parse_marker start_mark;
\r
5082 parseSetMark (&start_mark, pfile);
\r
5086 cppSkipHspace (pfile);
\r
5087 c = cppReader_getC (pfile);
\r
5093 parseGotoMark (&start_mark, pfile);
\r
5094 parseClearMark (&start_mark);
\r
5098 /* If we get here, this #endif ends a #ifndef
\r
5099 that contains all of the file (aside from whitespace).
\r
5100 Arrange not to include the file again
\r
5101 if the macro that was tested is defined.
\r
5103 Do not do this for the top-level file in a -include or any
\r
5104 file in a -imacros. */
\r
5105 struct file_name_list *ifile = pfile->all_include_files;
\r
5107 for ( ; ifile != NULL; ifile = ifile->next)
\r
5109 if (cstring_equal (ifile->fname, cppReader_getBuffer (pfile)->fname))
\r
5111 ifile->control_macro = temp->control_macro;
\r
5119 output_line_command (pfile, 1, same_file);
\r
5124 /* When an #else or #endif is found while skipping failed conditional,
\r
5125 if -pedantic was specified, this is called to warn about text after
\r
5126 the command name. P points to the first char after the command name. */
\r
5129 validate_else (cppReader *pfile, cstring directive)
\r
5132 cppSkipHspace (pfile);
\r
5133 c = cppReader_peekC (pfile);
\r
5134 if (c != EOF && c != '\n')
\r
5136 cppReader_pedwarn (pfile,
\r
5137 message ("text following `%s' violates ANSI standard", directive));
\r
5142 ** Get the next token, and add it to the text in pfile->token_buffer.
\r
5143 ** Return the kind of token we got.
\r
5147 cppGetToken (cppReader *pfile)
\r
5150 size_t old_written = 0;
\r
5151 int start_line, start_column;
\r
5152 enum cpp_token token;
\r
5153 struct cppOptions *opts = CPPOPTIONS (pfile);
\r
5154 cppReader_getBuffer (pfile)->prev = cppReader_getBuffer (pfile)->cur;
\r
5157 c = cppReader_getC (pfile);
\r
5162 if (cppReader_getBuffer (pfile)->seen_eof)
\r
5164 cppBuffer *buf = cppReader_popBuffer (pfile);
\r
5166 if (buf != cppReader_nullBuffer (pfile))
\r
5177 cppBuffer *next_buf = cppBuffer_prevBuffer (cppReader_getBuffer (pfile));
\r
5178 cppReader_getBuffer (pfile)->seen_eof = 1;
\r
5180 if (cstring_isDefined (cppReader_getBuffer (pfile)->nominal_fname)
\r
5181 && next_buf != cppReader_nullBuffer (pfile))
\r
5183 /* We're about to return from an #include file.
\r
5184 Emit #line information now (as part of the CPP_POP) result.
\r
5185 But the #line refers to the file we will pop to. */
\r
5186 cppBuffer *cur_buffer = CPPBUFFER (pfile);
\r
5187 CPPBUFFER (pfile) = next_buf;
\r
5188 pfile->input_stack_listing_current = 0;
\r
5189 output_line_command (pfile, 0, leave_file);
\r
5190 CPPBUFFER (pfile) = cur_buffer;
\r
5198 struct parse_marker start_mark;
\r
5203 if (cppReader_peekC (pfile) == '=')
\r
5208 if (opts->put_out_comments)
\r
5210 parseSetMark (&start_mark, pfile);
\r
5214 cppBuffer_lineAndColumn (cppReader_fileBuffer (pfile),
\r
5215 &start_line, &start_column);
\r
5216 c = skip_comment (pfile, &newlines);
\r
5218 if (opts->put_out_comments && (c == '/' || c == EOF))
\r
5220 assertSet (&start_mark);
\r
5221 parseClearMark (&start_mark);
\r
5228 cppReader_errorWithLine (pfile, start_line, start_column,
\r
5229 cstring_makeLiteral ("Unterminated comment"));
\r
5232 c = '/'; /* Initial letter of comment. */
\r
5234 /* Comments are equivalent to spaces.
\r
5235 For -traditional, a comment is equivalent to nothing. */
\r
5237 if (opts->put_out_comments)
\r
5239 enum cpp_token res;
\r
5241 assertSet (&start_mark);
\r
5242 res = cpp_handleComment (pfile, &start_mark);
\r
5243 pfile->lineno += newlines;
\r
5246 else if (cppReader_isTraditional (pfile))
\r
5248 return CPP_COMMENT;
\r
5252 cppReader_reserve(pfile, 1);
\r
5253 cppReader_putCharQ (pfile, ' ');
\r
5254 return CPP_HSPACE;
\r
5258 if (!pfile->only_seen_white)
\r
5263 if (cppReader_handleDirective (pfile))
\r
5265 return CPP_DIRECTIVE;
\r
5268 pfile->only_seen_white = 0;
\r
5273 /* A single quoted string is treated like a double -- some
\r
5274 programs (e.g., troff) are perverse this way */
\r
5275 cppBuffer_lineAndColumn (cppReader_fileBuffer (pfile),
\r
5276 &start_line, &start_column);
\r
5277 old_written = cppReader_getWritten (pfile);
\r
5279 cppReader_putChar (pfile, c);
\r
5282 int cc = cppReader_getC (pfile);
\r
5285 if (cppBuffer_isMacro (CPPBUFFER (pfile)))
\r
5287 /* try harder: this string crosses a macro expansion
\r
5288 boundary. This can happen naturally if -traditional.
\r
5289 Otherwise, only -D can make a macro with an unmatched
\r
5291 cppBuffer *next_buf
\r
5292 = cppBuffer_prevBuffer (cppReader_getBuffer (pfile));
\r
5293 (*cppReader_getBuffer (pfile)->cleanup)
\r
5294 (cppReader_getBuffer (pfile), pfile);
\r
5295 CPPBUFFER (pfile) = next_buf;
\r
5298 if (!cppReader_isTraditional (pfile))
\r
5300 cpp_setLocation (pfile);
\r
5302 setLine (long_toInt (start_line));
\r
5303 setColumn (long_toInt (start_column));
\r
5305 if (pfile->multiline_string_line != long_toInt (start_line)
\r
5306 && pfile->multiline_string_line != 0)
\r
5310 message ("Unterminated string or character constant"),
\r
5311 message ("%q: Possible real start of unterminated constant",
\r
5312 fileloc_unparseRaw
\r
5313 (fileloc_filename (g_currentloc),
\r
5314 pfile->multiline_string_line)));
\r
5315 pfile->multiline_string_line = 0;
\r
5321 message ("Unterminated string or character constant"));
\r
5324 /*@loopbreak@*/ break;
\r
5326 cppReader_putChar (pfile, cc);
\r
5330 /* Traditionally, end of line ends a string constant with
\r
5331 no error. So exit the loop and record the new line. */
\r
5332 if (cppReader_isTraditional (pfile))
\r
5338 if (cppReader_isPedantic (pfile)
\r
5339 && pfile->multiline_string_line == 0)
\r
5341 cppReader_pedwarnWithLine
\r
5342 (pfile, long_toInt (start_line),
\r
5343 long_toInt (start_column),
\r
5344 cstring_makeLiteral ("String constant runs past end of line"));
\r
5346 if (pfile->multiline_string_line == 0)
\r
5348 pfile->multiline_string_line = start_line;
\r
5351 /*@switchbreak@*/ break;
\r
5354 cc = cppReader_getC (pfile);
\r
5357 /* Backslash newline is replaced by nothing at all. */
\r
5358 cppReader_adjustWritten (pfile, -1);
\r
5363 /* ANSI stupidly requires that in \\ the second \
\r
5364 is *not* prevented from combining with a newline. */
\r
5367 cppReader_putChar (pfile, cc);
\r
5369 /*@switchbreak@*/ break;
\r
5375 /*@switchbreak@*/ break;
\r
5379 pfile->lineno += count_newlines (pfile->token_buffer + old_written,
\r
5380 cppReader_getPWritten (pfile));
\r
5381 pfile->only_seen_white = 0;
\r
5382 return c == '\'' ? CPP_CHAR : CPP_STRING;
\r
5385 if (!opts->dollars_in_ident)
\r
5390 if (opts->cplusplus && cppReader_peekC (pfile) == ':')
\r
5398 c2 = cppReader_peekC (pfile);
\r
5399 if (c2 == c || c2 == '=')
\r
5409 if (cppReader_peekC (pfile) == '=')
\r
5415 c2 = cppReader_peekC (pfile);
\r
5416 if (c2 == '-' && opts->chill)
\r
5418 /* Chill style comment */
\r
5419 if (opts->put_out_comments)
\r
5421 parseSetMark (&start_mark, pfile);
\r
5424 cppReader_forward (pfile, 1); /* Skip second '-'. */
\r
5428 c = cppReader_getC (pfile);
\r
5430 /*@loopbreak@*/ break;
\r
5433 /* Don't consider final '\n' to be part of comment. */
\r
5434 cppReader_forward (pfile, -1);
\r
5435 /*@loopbreak@*/ break;
\r
5439 goto return_comment;
\r
5441 if (c2 == '-' || c2 == '=' || c2 == '>')
\r
5446 if (pfile->parsing_include_directive)
\r
5450 cppReader_putChar (pfile, c);
\r
5452 /*@loopbreak@*/ break;
\r
5453 c = cppReader_getC (pfile);
\r
5455 if (c == '\n' || c == EOF)
\r
5457 cppReader_errorLit (pfile,
\r
5458 cstring_makeLiteralTemp ("Missing '>' in \"#include <FILENAME>\""));
\r
5459 /*@loopbreak@*/ break;
\r
5462 return CPP_STRING;
\r
5467 c2 = cppReader_peekC (pfile);
\r
5472 cppReader_forward (pfile, 1);
\r
5473 cppReader_reserve (pfile, 4);
\r
5474 cppReader_putChar (pfile, c);
\r
5475 cppReader_putChar (pfile, c2);
\r
5477 c3 = cppReader_peekC (pfile);
\r
5479 cppReader_putCharQ (pfile, cppReader_getC (pfile));
\r
5480 cppReader_nullTerminateQ (pfile);
\r
5481 pfile->only_seen_white = 0;
\r
5485 if (cppReader_getBuffer (pfile)->has_escapes)
\r
5487 c = cppReader_getC (pfile);
\r
5490 if (pfile->output_escapes)
\r
5491 cppReader_puts (pfile, "@-", 2);
\r
5492 parse_name (pfile, cppReader_getC (pfile));
\r
5495 else if (is_space [c])
\r
5497 cppReader_reserve (pfile, 2);
\r
5498 if (pfile->output_escapes)
\r
5499 cppReader_putCharQ (pfile, '@');
\r
5500 cppReader_putCharQ (pfile, c);
\r
5501 return CPP_HSPACE;
\r
5508 if (pfile->output_escapes)
\r
5510 cppReader_puts (pfile, "@@", 2);
\r
5516 c2 = cppReader_peekC (pfile);
\r
5519 cppReader_reserve(pfile, 2);
\r
5520 cppReader_putCharQ (pfile, '.');
\r
5521 c = cppReader_getC (pfile);
\r
5525 /* FIXME - misses the case "..\\\n." */
\r
5526 if (c2 == '.' && cpp_peekN (pfile, 1) == '.')
\r
5528 cppReader_reserve(pfile, 4);
\r
5529 cppReader_putCharQ (pfile, '.');
\r
5530 cppReader_putCharQ (pfile, '.');
\r
5531 cppReader_putCharQ (pfile, '.');
\r
5532 cppReader_forward (pfile, 2);
\r
5533 cppReader_nullTerminateQ (pfile);
\r
5534 pfile->only_seen_white = 0;
\r
5539 token = CPP_OTHER;
\r
5540 pfile->only_seen_white = 0;
\r
5542 cppReader_reserve(pfile, 3);
\r
5543 cppReader_putCharQ (pfile, c);
\r
5544 cppReader_putCharQ (pfile, cppReader_getC (pfile));
\r
5545 cppReader_nullTerminateQ (pfile);
\r
5550 c2 = cppReader_peekC (pfile);
\r
5551 if ((c2 == '\'' || c2 == '\"') && !cppReader_isTraditional (pfile))
\r
5553 cppReader_putChar (pfile, c);
\r
5554 c = cppReader_getC (pfile);
\r
5559 case '0': case '1': case '2': case '3': case '4':
\r
5560 case '5': case '6': case '7': case '8': case '9':
\r
5565 cppReader_reserve (pfile, 2);
\r
5566 cppReader_putCharQ (pfile, c);
\r
5568 c = cppReader_peekC (pfile);
\r
5570 /*@loopbreak@*/ break;
\r
5571 if (!is_idchar[c] && c != '.'
\r
5572 && ((c2 != 'e' && c2 != 'E'
\r
5573 && ((c2 != 'p' && c2 != 'P') || cppReader_isC89 (pfile)))
\r
5574 || (c != '+' && c != '-')))
\r
5575 /*@loopbreak@*/ break;
\r
5576 cppReader_forward (pfile, 1);
\r
5580 cppReader_nullTerminateQ (pfile);
\r
5581 pfile->only_seen_white = 0;
\r
5582 return CPP_NUMBER;
\r
5584 case 'b': case 'c': case 'd': case 'h': case 'o':
\r
5585 case 'B': case 'C': case 'D': case 'H': case 'O':
\r
5586 if (opts->chill && cppReader_peekC (pfile) == '\'')
\r
5588 pfile->only_seen_white = 0;
\r
5589 cppReader_reserve (pfile, 2);
\r
5590 cppReader_putCharQ (pfile, c);
\r
5591 cppReader_putCharQ (pfile, '\'');
\r
5592 cppReader_forward (pfile, 1);
\r
5595 c = cppReader_getC (pfile);
\r
5597 goto chill_number_eof;
\r
5598 if (!is_idchar[c])
\r
5600 if (c == '\\' && cppReader_peekC (pfile) == '\n')
\r
5602 cppReader_forward (pfile, 2);
\r
5605 /*@loopbreak@*/ break;
\r
5607 cppReader_putChar (pfile, c);
\r
5611 cppReader_reserve (pfile, 2);
\r
5612 cppReader_putCharQ (pfile, c);
\r
5613 cppReader_nullTerminateQ (pfile);
\r
5614 return CPP_STRING;
\r
5618 cppReader_forward (pfile, -1);
\r
5620 cppReader_nullTerminate (pfile);
\r
5621 return CPP_NUMBER;
\r
5627 case 'a': case 'e': case 'f': case 'g': case 'i': case 'j':
\r
5628 case 'k': case 'l': case 'm': case 'n': case 'p': case 'q':
\r
5629 case 'r': case 's': case 't': case 'u': case 'v': case 'w':
\r
5630 case 'x': case 'y': case 'z':
\r
5631 case 'A': case 'E': case 'F': case 'G': case 'I': case 'J':
\r
5632 case 'K': case 'M': case 'N': case 'P': case 'Q': case 'R':
\r
5633 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
\r
5634 case 'Y': case 'Z':
\r
5639 size_t before_name_written = cppReader_getWritten (pfile);
\r
5641 parse_name (pfile, c);
\r
5642 pfile->only_seen_white = 0;
\r
5643 if (pfile->no_macro_expand)
\r
5648 ident = pfile->token_buffer + before_name_written;
\r
5649 ident_len = (cppReader_getPWritten (pfile)) - ident;
\r
5651 hp = cppReader_lookupExpand (ident, ident_len, -1);
\r
5658 if (hp->type == T_DISABLED)
\r
5660 if (pfile->output_escapes)
\r
5661 { /* Return "@-IDENT", followed by '\0'. */
\r
5663 cppReader_reserve (pfile, 3);
\r
5664 ident = pfile->token_buffer + before_name_written;
\r
5665 cppReader_adjustWritten (pfile, 2);
\r
5667 for (i = ident_len; i >= 0; i--)
\r
5669 ident[i+2] = ident[i];
\r
5678 /* If macro wants an arglist, verify that a '(' follows.
\r
5679 first skip all whitespace, copying it to the output
\r
5680 after the macro name. Then, if there is no '(',
\r
5681 decide this is not a macro call and leave things that way. */
\r
5683 if (hp->type == T_MACRO && hp->value.defn->nargs >= 0)
\r
5685 struct parse_marker macro_mark;
\r
5686 int is_macro_call;
\r
5688 while (cppBuffer_isMacro (CPPBUFFER (pfile)))
\r
5690 cppBuffer *next_buf;
\r
5691 cppSkipHspace (pfile);
\r
5692 if (cppReader_peekC (pfile) != EOF)
\r
5694 /*@loopbreak@*/ break;
\r
5697 next_buf = cppBuffer_prevBuffer (cppReader_getBuffer (pfile));
\r
5698 (*cppReader_getBuffer (pfile)->cleanup) (cppReader_getBuffer (pfile), pfile);
\r
5699 CPPBUFFER (pfile) = next_buf;
\r
5702 parseSetMark (¯o_mark, pfile);
\r
5706 cppSkipHspace (pfile);
\r
5707 c = cppReader_peekC (pfile);
\r
5708 is_macro_call = c == '(';
\r
5710 /*@loopbreak@*/ break;
\r
5711 cppReader_forward (pfile, 1);
\r
5714 if (!is_macro_call)
\r
5716 parseGotoMark (¯o_mark, pfile);
\r
5719 parseClearMark (¯o_mark);
\r
5721 if (!is_macro_call)
\r
5726 /* This is now known to be a macro call. */
\r
5728 /* it might not actually be a macro. */
\r
5729 if (hp->type != T_MACRO)
\r
5734 cppReader_setWritten (pfile, before_name_written);
\r
5735 special_symbol (hp, pfile);
\r
5736 xbuf_len = cppReader_getWritten (pfile) - before_name_written;
\r
5737 xbuf = (char *) dmalloc (xbuf_len + 1);
\r
5738 cppReader_setWritten (pfile, before_name_written);
\r
5739 memcpy (xbuf, cppReader_getPWritten (pfile), xbuf_len + 1);
\r
5740 push_macro_expansion (pfile, xbuf, xbuf_len, hp);
\r
5744 /* Expand the macro, reading arguments as needed,
\r
5745 and push the expansion on the input stack. */
\r
5746 macroexpand (pfile, hp);
\r
5747 cppReader_setWritten (pfile, before_name_written);
\r
5750 /* An extra "@ " is added to the end of a macro expansion
\r
5751 to prevent accidental token pasting. We prefer to avoid
\r
5752 unneeded extra spaces (for the sake of cpp-using tools like
\r
5753 imake). Here we remove the space if it is safe to do so. */
\r
5755 llassert (pfile->buffer->rlimit != NULL);
\r
5757 if (pfile->buffer->rlimit - pfile->buffer->cur >= 3
\r
5758 && pfile->buffer->rlimit[-2] == '@'
\r
5759 && pfile->buffer->rlimit[-1] == ' ')
\r
5761 int c1 = pfile->buffer->rlimit[-3];
\r
5762 int cl2 = cppBufPeek (cppBuffer_prevBuffer (CPPBUFFER (pfile)));
\r
5764 if (cl2 == EOF || !unsafe_chars ((char) c1, (char) cl2))
\r
5765 pfile->buffer->rlimit -= 2;
\r
5771 case ' ': case '\t': case '\v': case '\r':
\r
5774 cppReader_putChar (pfile, c);
\r
5775 c = cppReader_peekC (pfile);
\r
5776 if (c == EOF || !is_hor_space[c])
\r
5777 /*@loopbreak@*/ break;
\r
5778 cppReader_forward (pfile, 1);
\r
5780 return CPP_HSPACE;
\r
5783 c2 = cppReader_peekC (pfile);
\r
5786 token = CPP_HSPACE;
\r
5790 cppReader_putChar (pfile, c);
\r
5791 if (pfile->only_seen_white == 0)
\r
5792 pfile->only_seen_white = 1;
\r
5794 output_line_command (pfile, 1, same_file);
\r
5795 return CPP_VSPACE;
\r
5797 case '(': token = CPP_LPAREN; goto char1;
\r
5798 case ')': token = CPP_RPAREN; goto char1;
\r
5799 case '{': token = CPP_LBRACE; goto char1;
\r
5800 case '}': token = CPP_RBRACE; goto char1;
\r
5801 case ',': token = CPP_COMMA; goto char1;
\r
5802 case ';': token = CPP_SEMICOLON; goto char1;
\r
5806 token = CPP_OTHER;
\r
5808 pfile->only_seen_white = 0;
\r
5809 cppReader_putChar (pfile, c);
\r
5818 /* Parse an identifier starting with C. */
\r
5821 parse_name (cppReader *pfile, int c)
\r
5825 if (!is_idchar[c])
\r
5827 if (c == '\\' && cppReader_peekC (pfile) == '\n')
\r
5829 cppReader_forward (pfile, 2);
\r
5833 cppReader_forward (pfile, -1);
\r
5837 if (c == '$' && cppReader_isPedantic (pfile))
\r
5839 cppReader_pedwarnLit (pfile,
\r
5840 cstring_makeLiteralTemp ("`$' in identifier"));
\r
5843 cppReader_reserve(pfile, 2); /* One more for final NUL. */
\r
5844 cppReader_putCharQ (pfile, c);
\r
5845 c = cppReader_getC (pfile);
\r
5851 cppReader_nullTerminateQ (pfile);
\r
5854 /* The file_name_map structure holds a mapping of file names for a
\r
5855 particular directory. This mapping is read from the file named
\r
5856 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
\r
5857 map filenames on a file system with severe filename restrictions,
\r
5858 such as DOS. The format of the file name map file is just a series
\r
5859 of lines with two tokens on each line. The first token is the name
\r
5860 to map, and the second token is the actual name to use. */
\r
5862 struct file_name_map
\r
5864 struct file_name_map *map_next;
\r
5869 /*@constant observer char *FILE_NAME_MAP_FILE*/
\r
5870 #define FILE_NAME_MAP_FILE "header.gcc"
\r
5872 /* Read a space delimited string of unlimited length from a stdio
\r
5875 static cstring read_filename_string (int ch, /*:open:*/ FILE *f)
\r
5877 char *alloc, *set;
\r
5881 set = alloc = dmalloc (len + 1);
\r
5883 if (!is_space[ch])
\r
5886 while ((ch = getc (f)) != EOF && ! is_space[ch])
\r
5888 if (set - alloc == size_toInt (len))
\r
5891 alloc = drealloc (alloc, len + 1);
\r
5892 set = alloc + len / 2;
\r
5893 /*@-branchstate@*/ }
\r
5896 } /*@=branchstate@*/
\r
5899 check (ungetc (ch, f) != EOF);
\r
5901 return cstring_fromChars (alloc);
\r
5904 /* This structure holds a linked list of file name maps, one per directory. */
\r
5906 struct file_name_map_list
\r
5908 struct file_name_map_list *map_list_next;
\r
5909 cstring map_list_name;
\r
5910 struct file_name_map *map_list_map;
\r
5913 /* Read the file name map file for DIRNAME. */
\r
5915 static struct file_name_map *
\r
5916 read_name_map (cppReader *pfile, cstring dirname)
\r
5918 struct file_name_map_list *map_list_ptr;
\r
5922 for (map_list_ptr = CPPOPTIONS (pfile)->map_list;
\r
5923 map_list_ptr != NULL;
\r
5924 map_list_ptr = map_list_ptr->map_list_next)
\r
5926 if (cstring_equal (map_list_ptr->map_list_name, dirname))
\r
5928 return map_list_ptr->map_list_map;
\r
5932 map_list_ptr = (struct file_name_map_list *) dmalloc (sizeof (*map_list_ptr));
\r
5933 map_list_ptr->map_list_name = cstring_copy (dirname);
\r
5934 map_list_ptr->map_list_map = NULL;
\r
5936 name = cstring_copy (dirname);
\r
5938 if (cstring_length (dirname) > 0)
\r
5940 name = cstring_appendChar (name, CONNECTCHAR);
\r
5943 name = cstring_concatFree1 (name, cstring_makeLiteralTemp (FILE_NAME_MAP_FILE));
\r
5945 f = fileTable_openFile (context_fileTable (), name, "r");
\r
5946 cstring_free (name);
\r
5950 map_list_ptr->map_list_map = NULL;
\r
5956 while ((ch = getc (f)) != EOF)
\r
5959 struct file_name_map *ptr;
\r
5966 from = read_filename_string (ch, f);
\r
5967 while ((ch = getc (f)) != EOF && is_hor_space[ch])
\r
5972 to = read_filename_string (ch, f);
\r
5974 ptr = (struct file_name_map *) dmalloc (sizeof (*ptr));
\r
5975 ptr->map_from = from;
\r
5977 /* Make the real filename absolute. */
\r
5978 if (cstring_length (to) > 1
\r
5979 && osd_isConnectChar (cstring_firstChar (to)))
\r
5985 ptr->map_to = cstring_copy (dirname);
\r
5986 ptr->map_to = cstring_appendChar (ptr->map_to, CONNECTCHAR);
\r
5987 ptr->map_to = cstring_concatFree (ptr->map_to, to);
\r
5990 ptr->map_next = map_list_ptr->map_list_map;
\r
5991 map_list_ptr->map_list_map = ptr;
\r
5993 while ((ch = getc (f)) != '\n')
\r
5997 /*@innerbreak@*/ break;
\r
6002 assertSet (map_list_ptr->map_list_map);
\r
6003 check (fileTable_closeFile (context_fileTable (),f) == 0);
\r
6006 map_list_ptr->map_list_next = pfile->opts->map_list;
\r
6007 pfile->opts->map_list = map_list_ptr;
\r
6009 return map_list_ptr->map_list_map;
\r
6012 /* Try to open include file FILENAME. SEARCHPTR is the directory
\r
6013 being tried from the include file search path. This function maps
\r
6014 filenames on file systems based on information read by
\r
6018 open_include_file (cppReader *pfile,
\r
6020 struct file_name_list *searchptr)
\r
6022 char *filename = cstring_toCharsSafe (fname);
\r
6023 struct file_name_map *map;
\r
6027 cstring_markOwned (fname);
\r
6029 cpp_setLocation (pfile);
\r
6031 if (context_getFlag (FLG_NEVERINCLUDE))
\r
6033 if (isHeaderFile (fname))
\r
6035 return SKIP_INCLUDE;
\r
6039 if ((searchptr != NULL) && ! searchptr->got_name_map)
\r
6041 searchptr->name_map = read_name_map (pfile,
\r
6042 !cstring_isEmpty (searchptr->fname)
\r
6043 ? searchptr->fname :
\r
6044 cstring_makeLiteralTemp ("."));
\r
6045 searchptr->got_name_map = 1;
\r
6048 /* First check the mapping for the directory we are using. */
\r
6050 if ((searchptr != NULL)
\r
6051 && (searchptr->name_map != NULL))
\r
6055 if (!cstring_isEmpty (searchptr->fname))
\r
6057 from += cstring_length (searchptr->fname) + 1;
\r
6060 for (map = searchptr->name_map;
\r
6062 map = map->map_next)
\r
6064 if (cstring_equal (map->map_from, cstring_fromChars (from)))
\r
6067 ** Found a match. Check if the file should be skipped
\r
6070 if (cpp_skipIncludeFile (map->map_to))
\r
6072 return SKIP_INCLUDE;
\r
6076 return cpp_openIncludeFile (cstring_toCharsSafe (map->map_to));
\r
6083 ** Try to find a mapping file for the particular directory we are
\r
6084 ** looking in. Thus #include <sys/types.h> will look up sys/types.h
\r
6085 ** in /usr/include/header.gcc and look up types.h in
\r
6086 ** /usr/include/sys/header.gcc.
\r
6089 p = strrchr (filename, CONNECTCHAR);
\r
6096 if ((searchptr != NULL)
\r
6097 && (cstring_isDefined (searchptr->fname))
\r
6098 && (cstring_length (searchptr->fname) == p - filename)
\r
6099 && !strncmp (cstring_toCharsSafe (searchptr->fname),
\r
6101 size_fromInt (p - filename)))
\r
6103 /* filename is in SEARCHPTR, which we've already checked. */
\r
6105 if (cpp_skipIncludeFile (cstring_fromChars (filename)))
\r
6107 return SKIP_INCLUDE;
\r
6111 return cpp_openIncludeFile (filename);
\r
6115 if (p == filename)
\r
6117 dir = mstring_copy (".");
\r
6122 dir = (char *) dmalloc (size_fromInt (p - filename + 1));
\r
6123 memcpy (dir, filename, size_fromInt (p - filename));
\r
6124 dir[p - filename] = '\0';
\r
6128 for (map = read_name_map (pfile, cstring_fromChars (dir));
\r
6130 map = map->map_next)
\r
6132 if (cstring_equal (map->map_from, cstring_fromChars (from)))
\r
6136 if (cpp_skipIncludeFile (map->map_to))
\r
6138 return SKIP_INCLUDE;
\r
6142 return cpp_openIncludeFile (cstring_toCharsSafe (map->map_to));
\r
6149 if (cpp_skipIncludeFile (cstring_fromChars (filename)))
\r
6151 return SKIP_INCLUDE;
\r
6155 return cpp_openIncludeFile (filename);
\r
6159 /* Process the contents of include file FNAME, already open on descriptor F,
\r
6160 with output to OP.
\r
6161 SYSTEM_HEADER_P is 1 if this file resides in any one of the known
\r
6162 "system" include directories (as decided by the `is_system_include'
\r
6164 DIRPTR is the link in the dir path through which this file was found,
\r
6165 or 0 if the file name was absolute or via the current directory.
\r
6166 Return 1 on success, 0 on failure.
\r
6168 The caller is responsible for the cppReader_pushBuffer. */
\r
6171 finclude (cppReader *pfile, int f,
\r
6173 bool system_header_p,
\r
6174 /*@dependent@*/ struct file_name_list *dirptr)
\r
6180 cppBuffer *fp; /* For input stack frame */
\r
6182 if (file_size_and_mode (f, &st_mode, &st_size) < 0)
\r
6184 cppReader_perrorWithName (pfile, fname);
\r
6185 check (close (f) == 0);
\r
6186 (void) cppReader_popBuffer (pfile);
\r
6192 fp = cppReader_getBuffer (pfile);
\r
6194 /*@-temptrans@*/ /* fname shouldn't really be temp */
\r
6195 fp->nominal_fname = fp->fname = fname;
\r
6199 fp->system_header_p = system_header_p;
\r
6202 fp->cleanup = cppReader_fileCleanup;
\r
6204 if (S_ISREG (st_mode))
\r
6207 fp->buf = (char *) dmalloc (st_size + 2);
\r
6208 fp->alimit = fp->buf + st_size + 2;
\r
6209 fp->cur = fp->buf;
\r
6211 /* Read the file contents, knowing that st_size is an upper bound
\r
6212 on the number of bytes we can read. */
\r
6213 length = safe_read (f, fp->buf, size_toInt (st_size));
\r
6214 fp->rlimit = fp->buf + length;
\r
6215 if (length < 0) goto nope;
\r
6217 else if (S_ISDIR (st_mode))
\r
6219 cppReader_error (pfile,
\r
6220 message ("Directory specified in #include: %s", fname));
\r
6221 check (close (f) == 0);
\r
6227 ** Cannot count its file size before reading.
\r
6228 ** First read the entire file into heap and
\r
6229 ** copy them into buffer on stack.
\r
6232 size_t bsize = 2000;
\r
6237 fp->buf = (char *) dmalloc (bsize + 2);
\r
6240 i = safe_read (f, fp->buf + st_size, size_toInt (bsize - st_size));
\r
6243 goto nope; /* error! */
\r
6246 if (st_size != bsize)
\r
6248 break; /* End of file */
\r
6252 fp->buf = (char *) drealloc (fp->buf, bsize + 2);
\r
6255 fp->cur = fp->buf;
\r
6256 length = size_toInt (st_size);
\r
6259 if ((length > 0 && fp->buf[length - 1] != '\n')
\r
6260 /* Backslash-newline at end is not good enough. */
\r
6261 || (length > 1 && fp->buf[length - 2] == '\\')) {
\r
6262 fp->buf[length++] = '\n';
\r
6265 fp->buf[length] = '\0';
\r
6266 fp->rlimit = fp->buf + length;
\r
6268 /* Close descriptor now, so nesting does not use lots of descriptors. */
\r
6269 check (close (f) == 0);
\r
6271 /* Must do this before calling trigraph_pcp, so that the correct file name
\r
6272 will be printed in warning messages. */
\r
6274 pfile->input_stack_listing_current = 0;
\r
6279 cppReader_perrorWithName (pfile, fname);
\r
6280 check (close (f) == 0);
\r
6286 cppReader_init (cppReader *pfile)
\r
6288 memset ((char *) pfile, 0, sizeof (*pfile));
\r
6290 pfile->get_token = cppGetToken;
\r
6291 pfile->token_buffer_size = 200;
\r
6292 pfile->token_buffer = (char *) dmalloc (pfile->token_buffer_size);
\r
6293 pfile->all_include_files = NULL;
\r
6295 assertSet (pfile);
\r
6297 cppReader_setWritten (pfile, 0);
\r
6299 pfile->system_include_depth = 0;
\r
6300 pfile->max_include_len = 0;
\r
6301 pfile->timebuf = NULL;
\r
6302 pfile->only_seen_white = 1;
\r
6304 pfile->buffer = cppReader_nullBuffer (pfile);
\r
6308 cppReader_finish (/*@unused@*/ cppReader *pfile)
\r
6313 /* Free resources used by PFILE.
\r
6314 This is the cppReader 'finalizer' or 'destructor' (in C++ terminology). */
\r
6317 cppCleanup (cppReader *pfile)
\r
6319 while (CPPBUFFER (pfile) != cppReader_nullBuffer (pfile))
\r
6321 (void) cppReader_popBuffer (pfile);
\r
6324 if (pfile->token_buffer != NULL)
\r
6326 sfree (pfile->token_buffer);
\r
6327 pfile->token_buffer = NULL;
\r
6330 while (pfile->if_stack != NULL)
\r
6332 cppIfStackFrame *temp = pfile->if_stack;
\r
6333 pfile->if_stack = temp->next;
\r
6337 while (pfile->all_include_files != NULL)
\r
6339 struct file_name_list *temp = pfile->all_include_files;
\r
6340 pfile->all_include_files = temp->next;
\r
6341 /*@-dependenttrans@*/
\r
6342 cstring_free (temp->fname);
\r
6343 /*@=dependenttrans@*/
\r
6347 cppReader_hashCleanup ();
\r
6351 ** Get the file-mode and data size of the file open on FD
\r
6352 ** and store them in *MODE_POINTER and *SIZE_POINTER.
\r
6356 file_size_and_mode (int fd, mode_t *mode_pointer, size_t *size_pointer)
\r
6360 if (fstat (fd, &sbuf) < 0) {
\r
6364 if (mode_pointer != NULL)
\r
6366 *mode_pointer = sbuf.st_mode;
\r
6369 if (size_pointer != NULL)
\r
6371 *size_pointer = (size_t) sbuf.st_size;
\r
6377 /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
\r
6378 retrying if necessary. Return a negative value if an error occurs,
\r
6379 otherwise return the actual number of bytes read,
\r
6380 which must be LEN unless end-of-file was reached. */
\r
6382 static int safe_read (int desc, char *ptr, int len)
\r
6388 # if defined (WIN32) || defined (OS2) && defined (__IBMC__)
\r
6389 /*@-compdef@*/ /* ptr is an out parameter */
\r
6390 int nchars = _read (desc, ptr, (unsigned) left);
\r
6393 ssize_t nchars = read (desc, ptr, size_fromInt (left));
\r
6399 if (errno == EINTR)
\r
6402 return (int) nchars;
\r
6405 if (nchars == 0) {
\r
6413 return len - left;
\r
6416 /* Initialize PMARK to remember the current position of PFILE. */
\r
6419 parseSetMark (struct parse_marker *pmark, cppReader *pfile)
\r
6421 cppBuffer *pbuf = cppReader_getBuffer (pfile);
\r
6423 pmark->next = pbuf->marks;
\r
6425 pbuf->marks = pmark;
\r
6428 pmark->buf = pbuf;
\r
6429 pmark->position = pbuf->cur - pbuf->buf;
\r
6432 /* Cleanup PMARK - we no longer need it. */
\r
6434 void parseClearMark (struct parse_marker *pmark)
\r
6436 struct parse_marker **pp = &pmark->buf->marks;
\r
6438 for (; ; pp = &(*pp)->next)
\r
6440 llassert (*pp != NULL);
\r
6441 if (*pp == pmark) break;
\r
6444 *pp = pmark->next;
\r
6447 /* Backup the current position of PFILE to that saved in PMARK. */
\r
6450 parseGotoMark (struct parse_marker *pmark, cppReader *pfile)
\r
6452 cppBuffer *pbuf = cppReader_getBuffer (pfile);
\r
6454 if (pbuf != pmark->buf)
\r
6456 cpp_setLocation (pfile);
\r
6457 llfatalbug (cstring_makeLiteral ("Internal error parseGotoMark"));
\r
6460 llassert (pbuf->buf != NULL);
\r
6461 pbuf->cur = pbuf->buf + pmark->position;
\r
6464 /* Reset PMARK to point to the current position of PFILE. (Same
\r
6465 as parseClearMark (PMARK), parseSetMark (PMARK, PFILE) but faster. */
\r
6468 parseMoveMark (struct parse_marker *pmark, cppReader *pfile)
\r
6470 cppBuffer *pbuf = cppReader_getBuffer (pfile);
\r
6472 if (pbuf != pmark->buf)
\r
6474 cpp_setLocation (pfile);
\r
6475 llfatalerror (cstring_makeLiteral ("Internal error parseMoveMark"));
\r
6478 pmark->position = pbuf->cur - pbuf->buf;
\r
6481 void cppReader_initializeReader (cppReader *pfile) /* Must be done after library is loaded. */
\r
6483 struct cppOptions *opts = CPPOPTIONS (pfile);
\r
6486 /* The code looks at the defaults through this pointer, rather than through
\r
6487 the constant structure above. This pointer gets changed if an environment
\r
6488 variable specifies other defaults. */
\r
6490 struct default_include *include_defaults = include_defaults_array;
\r
6492 /* Add dirs from INCLUDEPATH_VAR after dirs from -I. */
\r
6493 /* There seems to be confusion about what CPATH should do,
\r
6494 so for the moment it is not documented. */
\r
6495 /* Some people say that CPATH should replace the standard include dirs,
\r
6496 but that seems pointless: it comes before them, so it overrides them
\r
6499 xp = osd_getEnvironmentVariable (INCLUDEPATH_VAR);
\r
6501 if (cstring_isDefined (xp) && !opts->no_standard_includes)
\r
6503 path_include (pfile, cstring_toCharsSafe (xp));
\r
6506 /* Now that dollars_in_ident is known, initialize is_idchar. */
\r
6507 initialize_char_syntax (opts);
\r
6509 /* CppReader_Install __LINE__, etc. Must follow initialize_char_syntax
\r
6510 and option processing. */
\r
6512 initialize_builtins (pfile);
\r
6514 /* Do standard #defines and assertions
\r
6515 that identify system and machine type. */
\r
6517 if (!opts->inhibit_predefs) {
\r
6518 char *p = (char *) dmalloc (strlen (predefs) + 1);
\r
6519 strcpy (p, predefs);
\r
6525 while (*p == ' ' || *p == '\t')
\r
6530 /* Handle -D options. */
\r
6531 if (p[0] == '-' && p[1] == 'D')
\r
6535 while (*p && *p != ' ' && *p != '\t')
\r
6545 if (opts->debug_output)
\r
6547 output_line_command (pfile, 0, same_file);
\r
6550 cppReader_define (pfile, q);
\r
6552 while (*p == ' ' || *p == '\t')
\r
6566 opts->done_initializing = 1;
\r
6568 { /* Read the appropriate environment variable and if it exists
\r
6569 replace include_defaults with the listed path. */
\r
6571 #ifdef __CYGWIN32__
\r
6573 int win32_buf_size = 0; /* memory we need to allocate */
\r
6576 if (opts->cplusplus)
\r
6578 epath = getenv ("CPLUS_INCLUDE_PATH");
\r
6582 epath = getenv ("C_INCLUDE_PATH");
\r
6586 ** If the environment var for this language is set,
\r
6587 ** add to the default list of include directories.
\r
6590 if (epath != NULL) {
\r
6591 char *nstore = (char *) dmalloc (strlen (epath) + 2);
\r
6593 char *startp, *endp;
\r
6595 #ifdef __CYGWIN32__
\r
6596 /* if we have a posix path list, convert to win32 path list */
\r
6597 if (cygwin32_posix_path_list_p (epath))
\r
6599 win32_buf_size = cygwin32_posix_to_win32_path_list_buf_size (epath);
\r
6600 win32epath = (char *) dmalloc /*@i4@*/ (win32_buf_size);
\r
6601 cygwin32_posix_to_win32_path_list (epath, win32epath);
\r
6602 epath = win32epath;
\r
6605 for (num_dirs = 1, startp = epath; *startp; startp++)
\r
6607 if (*startp == PATH_SEPARATOR)
\r
6613 = (struct default_include *) dmalloc ((num_dirs
\r
6614 * sizeof (struct default_include))
\r
6615 + sizeof (include_defaults_array));
\r
6618 startp = endp = epath;
\r
6621 /* Handle cases like c:/usr/lib:d:/gcc/lib */
\r
6622 if ((*endp == PATH_SEPARATOR) || *endp == 0)
\r
6624 strncpy (nstore, startp, size_fromInt (endp - startp));
\r
6625 if (endp == startp)
\r
6627 strcpy (nstore, ".");
\r
6631 nstore[endp-startp] = '\0';
\r
6634 include_defaults[num_dirs].fname = cstring_fromCharsNew (nstore);
\r
6635 include_defaults[num_dirs].cplusplus = opts->cplusplus;
\r
6636 include_defaults[num_dirs].cxx_aware = 1;
\r
6639 if (*endp == '\0')
\r
6643 endp = startp = endp + 1;
\r
6650 /* Put the usual defaults back in at the end. */
\r
6651 memcpy ((char *) &include_defaults[num_dirs],
\r
6652 (char *) include_defaults_array,
\r
6653 sizeof (include_defaults_array));
\r
6656 /*@-branchstate@*/ } /*@=branchstate@*/
\r
6659 cppReader_appendIncludeChain (pfile, opts->before_system,
\r
6660 opts->last_before_system);
\r
6661 opts->first_system_include = opts->before_system;
\r
6663 /* Unless -fnostdinc,
\r
6664 tack on the standard include file dirs to the specified list */
\r
6665 if (!opts->no_standard_includes) {
\r
6666 struct default_include *p = include_defaults;
\r
6667 char *specd_prefix = opts->include_prefix;
\r
6668 char *default_prefix = mstring_copy (GCC_INCLUDE_DIR);
\r
6669 int default_len = 0;
\r
6671 /* Remove the `include' from /usr/local/lib/gcc.../include. */
\r
6672 if (default_prefix != NULL) {
\r
6673 if (!strcmp (default_prefix + strlen (default_prefix) - 8, "/include")) {
\r
6674 default_len = strlen (default_prefix) - 7;
\r
6675 default_prefix[default_len] = 0;
\r
6679 /* Search "translated" versions of GNU directories.
\r
6680 These have /usr/local/lib/gcc... replaced by specd_prefix. */
\r
6681 if (specd_prefix != 0 && default_len != 0)
\r
6682 for (p = include_defaults; p->fname != NULL; p++) {
\r
6683 /* Some standard dirs are only for C++. */
\r
6685 || (opts->cplusplus && !opts->no_standard_cplusplus_includes)) {
\r
6686 /* Does this dir start with the prefix? */
\r
6687 if (!strncmp (cstring_toCharsSafe (p->fname), default_prefix,
\r
6688 size_fromInt (default_len)))
\r
6690 /* Yes; change prefix and add to search list. */
\r
6691 struct file_name_list *nlist
\r
6692 = (struct file_name_list *) dmalloc (sizeof (*nlist));
\r
6693 size_t this_len = strlen (specd_prefix) + cstring_length (p->fname) - default_len;
\r
6694 char *str = (char *) dmalloc (this_len + 1);
\r
6695 strcpy (str, specd_prefix);
\r
6696 strcat (str, cstring_toCharsSafe (p->fname) + default_len);
\r
6698 nlist->next = NULL;
\r
6699 nlist->fname = cstring_fromChars (str);
\r
6700 nlist->control_macro = 0;
\r
6701 nlist->c_system_include_path = !p->cxx_aware;
\r
6702 nlist->got_name_map = 0;
\r
6704 cppReader_addIncludeChain (pfile, nlist);
\r
6705 if (opts->first_system_include == 0)
\r
6707 opts->first_system_include = nlist;
\r
6713 /* Search ordinary names for GNU include directories. */
\r
6715 for (p = include_defaults; p->fname != NULL; p++)
\r
6717 /* Some standard dirs are only for C++. */
\r
6719 || (opts->cplusplus && !opts->no_standard_cplusplus_includes))
\r
6721 struct file_name_list *nlist
\r
6722 = (struct file_name_list *) dmalloc (sizeof (*nlist));
\r
6723 nlist->control_macro = 0;
\r
6724 nlist->c_system_include_path = !p->cxx_aware;
\r
6725 nlist->fname = p->fname;
\r
6726 nlist->got_name_map = 0;
\r
6727 nlist->next = NULL;
\r
6729 cppReader_addIncludeChain (pfile, nlist);
\r
6731 if (opts->first_system_include == 0)
\r
6733 opts->first_system_include = nlist;
\r
6737 sfree (default_prefix);
\r
6740 /* Tack the after_include chain at the end of the include chain. */
\r
6741 cppReader_appendIncludeChain (pfile, opts->after_include,
\r
6742 opts->last_after_include);
\r
6744 if (opts->first_system_include == 0)
\r
6746 opts->first_system_include = opts->after_include;
\r
6749 /* With -v, print the list of dirs to search. */
\r
6750 if (opts->verbose) {
\r
6751 struct file_name_list *p;
\r
6752 fprintf (stderr, "#include \"...\" search starts here:\n");
\r
6754 for (p = opts->include; p != NULL; p = p->next) {
\r
6755 if (p == opts->first_bracket_include)
\r
6756 fprintf (stderr, "#include <...> search starts here:\n");
\r
6758 fprintf (stderr, " %s\n", cstring_toCharsSafe (p->fname));
\r
6760 fprintf (stderr, "End of search list.\n");
\r
6764 int cppReader_startProcess (cppReader *pfile, cstring fname)
\r
6768 struct cppOptions *opts = CPPOPTIONS (pfile);
\r
6770 fp = cppReader_pushBuffer (pfile, NULL, 0);
\r
6777 if (opts->in_fname == NULL)
\r
6779 opts->in_fname = cstring_makeLiteralTemp ("");
\r
6782 fp->fname = opts->in_fname;
\r
6783 fp->nominal_fname = fp->fname;
\r
6786 /* Copy the entire contents of the main input file into
\r
6787 the stacked input buffer previously allocated for it. */
\r
6789 if (cstring_isEmpty (fname))
\r
6791 fname = cstring_makeLiteralTemp ("");
\r
6794 else if ((f = open (cstring_toCharsSafe (fname), O_RDONLY, 0666)) < 0)
\r
6796 cppReader_error (pfile,
\r
6797 message ("Error opening %s for reading: %s",
\r
6798 fname, lldecodeerror (errno)));
\r
6807 if (finclude (pfile, f, fname, 0, NULL))
\r
6809 output_line_command (pfile, 0, same_file);
\r
6815 static /*@exposed@*/ /*@null@*/ cppBuffer *cppReader_getBuffer (cppReader *pfile)
\r
6817 return pfile->buffer;
\r
6820 /*@exposed@*/ cppBuffer *cppReader_getBufferSafe (cppReader *pfile)
\r
6822 llassert (pfile->buffer != NULL);
\r
6823 return pfile->buffer;
\r
6826 /*@exposed@*/ char *cppLineBase (cppBuffer *buf)
\r
6828 llassert (buf->buf != NULL);
\r
6829 return (buf->buf + buf->line_base);
\r
6832 int cppBufPeek (cppBuffer *buf)
\r
6834 if (buf->cur == NULL || buf->rlimit == NULL) {
\r
6838 if (buf->cur < buf->rlimit) {
\r
6839 return *(buf->cur);
\r
6845 bool cppBuffer_isMacro (cppBuffer *buf)
\r
6849 return (buf->cleanup == cppReader_macroCleanup);
\r
6856 ** Returns true if the macro should be checked, false
\r
6857 ** if it should be expanded normally.
\r
6860 static bool notparseable = FALSE; /* preceeded by @notparseable@ */
\r
6861 static bool notfunction = FALSE; /* preceeded by @notfunction@ */
\r
6862 static bool expectiter = FALSE; /* preceeded by @iter@ */
\r
6863 static bool expectenditer = FALSE; /* second after @iter@ */
\r
6864 static bool expectfunction = FALSE; /* preceeded by @function@ */
\r
6865 static bool expectconstant = FALSE; /* preceeded by @constant@ */
\r
6866 static bool expectmacro = FALSE; /* preceeded by notfunction or notparseable */
\r
6868 static void cpp_setLocation (cppReader *pfile)
\r
6873 if (pfile->buffer != NULL)
\r
6875 if (cstring_isDefined (cppReader_getBuffer (pfile)->nominal_fname))
\r
6877 cstring fname = cppReader_getBuffer (pfile)->nominal_fname;
\r
6879 DPRINTF (("Looking up: %s", fname));
\r
6881 if (fileTable_exists (context_fileTable (), fname))
\r
6883 fid = fileTable_lookup (context_fileTable (), fname);
\r
6887 DPRINTF (("Trying %s", cppReader_getBuffer (pfile)->fname));
\r
6889 fid = fileTable_lookup (context_fileTable (),
\r
6890 cppReader_getBuffer (pfile)->fname);
\r
6895 fid = fileTable_lookup (context_fileTable (),
\r
6896 cppReader_getBuffer (pfile)->fname);
\r
6899 line = cppReader_getBuffer (pfile)->lineno;
\r
6900 fileloc_free (g_currentloc);
\r
6902 if (fileId_isValid (fid))
\r
6904 g_currentloc = fileloc_create (fid, line, 1);
\r
6908 g_currentloc = fileloc_createBuiltin ();
\r
6913 fileloc_free (g_currentloc);
\r
6914 g_currentloc = fileloc_createBuiltin ();
\r
6918 static bool cpp_shouldCheckMacro (cppReader *pfile, char *p) /*@*/
\r
6920 bool checkmacro = FALSE;
\r
6921 bool hasParams = FALSE;
\r
6922 bool noexpand = FALSE;
\r
6926 cpp_setLocation (pfile);
\r
6928 DPRINTF (("Should check macro? %s", p));
\r
6930 if (expectiter || expectconstant || expectenditer)
\r
6934 expectiter = FALSE;
\r
6935 expectenditer = TRUE;
\r
6939 expectiter = FALSE;
\r
6940 expectconstant = FALSE;
\r
6941 expectenditer = FALSE;
\r
6944 if (notfunction || notparseable)
\r
6946 notfunction = FALSE;
\r
6947 notparseable = FALSE;
\r
6956 llassert (*p == '#');
\r
6959 while (*p == ' ' || *p == '\t')
\r
6964 llassert (*p == 'd'); /* define starts */
\r
6968 while (*p == ' ' || *p == '\t')
\r
6973 sname = cstring_fromChars (p);
\r
6974 DPRINTF (("Check macro: %s", sname));
\r
6976 while (((c = *p) != ' ')
\r
6977 && c != '\0' && c != '('
\r
6978 && c != '\t' && c != '\\' && c != '\n'
\r
6984 hasParams = (c == '(');
\r
6990 notparseable = FALSE;
\r
6992 else if (notfunction || fileloc_isStandardLib (g_currentloc))
\r
6994 DPRINTF (("Clear notfunction"));
\r
6995 notfunction = FALSE;
\r
7001 checkmacro = TRUE;
\r
7003 if (!expectenditer)
\r
7010 if (usymtab_existsReal (sname))
\r
7012 uentry ue = usymtab_lookup (sname);
\r
7014 DPRINTF (("Lookup macro: %s", uentry_unparse (ue)));
\r
7016 if (fileloc_isPreproc (uentry_whereLast (ue)))
\r
7022 if (uentry_isSpecified (ue))
\r
7024 checkmacro = context_getFlag (FLG_SPECMACROS);
\r
7030 checkmacro = context_getFlag (FLG_LIBMACROS)
\r
7031 || context_getFlag (FLG_FCNMACROS);
\r
7039 DPRINTF (("Macro doesn't exist: %s", bool_unparse (checkmacro)));
\r
7041 if (fileloc_isSystemFile (g_currentloc)
\r
7042 && context_getFlag (FLG_SYSTEMDIREXPAND))
\r
7044 ; /* don't check this macro */
\r
7045 DPRINTF (("Don't check 1"));
\r
7053 DPRINTF (("Has params..."));
\r
7055 if (context_getFlag (FLG_FCNMACROS))
\r
7057 if (usymtab_exists (sname))
\r
7060 ** only get here is macro is redefined
\r
7061 ** error reported elsewhere
\r
7064 DPRINTF (("It exists!"));
\r
7069 ** We make it a forward function, since it might be declared elsewhere.
\r
7070 ** After all headers have been processed, we should check the forward
\r
7074 fileloc loc = fileloc_makePreproc (g_currentloc);
\r
7076 /* the line is off-by-one, since the newline was already read */
\r
7079 if (expectfunction)
\r
7081 expectfunction = FALSE;
\r
7084 le = uentry_makeForwardFunction (sname,
\r
7085 typeId_invalid, loc);
\r
7087 fileloc_free (loc);
\r
7091 /* Do not define here! */
\r
7093 (void) usymtab_addEntry (le);
\r
7096 checkmacro = TRUE;
\r
7097 DPRINTF (("Check: TRUE"));
\r
7101 DPRINTF (("Flag FCN_MACROS not set!"));
\r
7106 DPRINTF (("No params"));
\r
7108 if (context_getFlag (FLG_CONSTMACROS))
\r
7110 bool nocontent = FALSE;
\r
7120 char *rest = p + 1;
\r
7123 ** Check if there is nothing after the define.
\r
7126 while ((*rest) != '\0' && isspace (*rest))
\r
7131 if (*rest == '\0')
\r
7133 nocontent = TRUE; /* empty macro, don't check */
\r
7138 if (usymtab_exists (sname))
\r
7144 fileloc loc = fileloc_makePreproc (g_currentloc);
\r
7145 DPRINTF (("Make constant: %s", sname));
\r
7146 le = uentry_makeConstant (sname,
\r
7147 ctype_unknown, loc);
\r
7148 (void) usymtab_addEntry (le);
\r
7151 checkmacro = !nocontent;
\r
7156 if (checkmacro && usymtab_existsType (sname))
\r
7158 DPRINTF (("Making false..."));
\r
7160 ppllerror (message ("Specified type implemented as macro: %s", sname));
\r
7161 checkmacro = FALSE;
\r
7170 if (usymtab_exists (sname))
\r
7172 uentry ue = usymtab_lookupExpose (sname);
\r
7173 fileloc tloc = fileloc_makePreproc (g_currentloc);
\r
7175 uentry_setDefined (ue, tloc);
\r
7176 fileloc_free (tloc);
\r
7177 uentry_setUsed (ue, fileloc_undefined);
\r
7181 fileloc tloc = fileloc_makePreproc (g_currentloc);
\r
7182 uentry ue = uentry_makeExpandedMacro (sname, tloc);
\r
7183 DPRINTF (("Make expanded macro: %s", sname));
\r
7184 DPRINTF (("Not in symbol table: %s", sname));
\r
7186 (void) usymtab_addGlobalEntry (ue);
\r
7187 fileloc_free (tloc);
\r
7192 DPRINTF (("Returning: %s", bool_unparse (checkmacro)));
\r
7193 return checkmacro;
\r
7196 static enum cpp_token
\r
7197 cpp_handleComment (cppReader *pfile, struct parse_marker *smark)
\r
7199 cppBuffer *pbuf = cppReader_getBuffer (pfile);
\r
7202 bool eliminateComment = FALSE;
\r
7204 llassert (pbuf->buf != NULL);
\r
7206 start = pbuf->buf + smark->position;
\r
7208 llassert (pbuf->cur != NULL);
\r
7209 len = pbuf->cur - start;
\r
7211 if (start[0] == '*'
\r
7212 && start[1] == context_getCommentMarkerChar ())
\r
7216 char *scomment = start + 2;
\r
7217 char savec = start[len];
\r
7219 start[0] = BEFORE_COMMENT_MARKER[0];
\r
7220 start[1] = BEFORE_COMMENT_MARKER[1];
\r
7222 llassert (start[len - 2] == '*');
\r
7223 start[len - 2] = AFTER_COMMENT_MARKER[0];
\r
7225 llassert (start[len - 1] == '/');
\r
7226 start[len - 1] = AFTER_COMMENT_MARKER[1];
\r
7228 cppReader_reserve(pfile, size_fromInt (1 + len));
\r
7229 cppReader_putCharQ (pfile, c);
\r
7231 cpp_setLocation (pfile);
\r
7233 start[len] = '\0';
\r
7235 if (mstring_containsString (scomment, "/*"))
\r
7237 (void) cppoptgenerror
\r
7239 message ("Comment starts inside syntactic comment: %s",
\r
7240 cstring_fromChars (scomment)),
\r
7244 start[len] = savec;
\r
7246 if (mstring_equalPrefix (scomment, "ignore"))
\r
7248 if (!context_getFlag (FLG_NOCOMMENTS))
\r
7250 context_enterSuppressRegion ();
\r
7253 else if (mstring_equalPrefix (scomment, "end"))
\r
7255 if (!context_getFlag (FLG_NOCOMMENTS))
\r
7257 context_exitSuppressRegion ();
\r
7260 else if (mstring_equalPrefix (scomment, "notparseable"))
\r
7262 notparseable = TRUE;
\r
7263 expectmacro = TRUE;
\r
7264 eliminateComment = TRUE;
\r
7266 else if (mstring_equalPrefix (scomment, "notfunction"))
\r
7268 notfunction = TRUE;
\r
7269 expectmacro = TRUE;
\r
7270 eliminateComment = TRUE;
\r
7272 else if (mstring_equalPrefix (scomment, "iter"))
\r
7274 expectiter = TRUE;
\r
7276 else if (mstring_equalPrefix (scomment, "function"))
\r
7278 expectfunction = TRUE;
\r
7280 else if (mstring_equalPrefix (scomment, "constant"))
\r
7282 expectconstant = TRUE;
\r
7286 char sChar = *scomment;
\r
7292 char *rest = scomment + 1;
\r
7294 if (mstring_equalPrefix (rest, "commentchar"))
\r
7296 eliminateComment = TRUE;
\r
7300 ppllerror (cstring_makeLiteral
\r
7301 ("Cannot restore commentchar"));
\r
7305 char *next = scomment + 12; /* strlen commentchar = 12 */
\r
7307 if (*next != ' ' && *next != '\t' && *next != '\n')
\r
7311 ("Syntactic commentchar comment is not followed by a "
\r
7312 "whitespace character: %c",
\r
7317 char cchar = *(next + 1);
\r
7319 if (cchar == '\0')
\r
7322 (cstring_makeLiteral
\r
7323 ("Cannot set commentchar to NUL"));
\r
7327 context_setCommentMarkerChar (cchar);
\r
7328 /* setComment = TRUE; */
\r
7333 else if (mstring_equalPrefix (scomment, "nestcomment"))
\r
7335 /* fix from Mike Miller <MikeM@xata.com> */
\r
7336 context_fileSetFlag (FLG_NESTCOMMENT,
\r
7337 ynm_fromCodeChar (sChar));
\r
7339 else if (mstring_equalPrefix (rest, "namechecks"))
\r
7341 context_fileSetFlag (FLG_NAMECHECKS,
\r
7342 ynm_fromCodeChar (sChar));
\r
7344 else if (mstring_equalPrefix (rest, "macroredef"))
\r
7346 context_fileSetFlag (FLG_MACROREDEF,
\r
7347 ynm_fromCodeChar (sChar));
\r
7349 else if (mstring_equalPrefix (rest, "usevarargs"))
\r
7351 context_fileSetFlag (FLG_USEVARARGS,
\r
7352 ynm_fromCodeChar (sChar));
\r
7354 else if (mstring_equalPrefix (rest, "nextlinemacros"))
\r
7356 context_fileSetFlag (FLG_MACRONEXTLINE,
\r
7357 ynm_fromCodeChar (sChar));
\r
7359 else if (mstring_equalPrefix (rest, "allmacros")
\r
7360 || mstring_equalPrefix (rest, "fcnmacros")
\r
7361 || mstring_equalPrefix (rest, "constmacros"))
\r
7365 if (mstring_equalPrefix (rest, "allmacros"))
\r
7367 fl = FLG_ALLMACROS;
\r
7369 else if (mstring_equalPrefix (rest, "fcnmacros"))
\r
7371 fl = FLG_FCNMACROS;
\r
7375 llassert (mstring_equalPrefix (rest, "constmacros"));
\r
7376 fl = FLG_CONSTMACROS;
\r
7380 context_fileSetFlag (fl, ynm_fromCodeChar (sChar));
\r
7381 notfunction = FALSE;
\r
7394 if (eliminateComment)
\r
7396 goto removeComment;
\r
7399 /* Replaces comment char's in start with spaces */
\r
7401 for (i = 2; i < len - 2; i++)
\r
7403 if (start[i] == BEFORE_COMMENT_MARKER[0]
\r
7404 || start[i] == BEFORE_COMMENT_MARKER[1]
\r
7405 || start[i] == context_getCommentMarkerChar ())
\r
7411 cppReader_putStrN (pfile, start, size_fromInt (len));
\r
7412 parseClearMark (smark);
\r
7413 return CPP_COMMENT;
\r
7422 ** Output the comment as all spaces so line/column
\r
7423 ** in output file is still correct.
\r
7427 cstring lintcomment = cstring_undefined;
\r
7429 if (context_getFlag (FLG_LINTCOMMENTS))
\r
7431 if (mstring_equalPrefix (start, "*NOTREACHED*/"))
\r
7433 lintcomment = cstring_makeLiteralTemp ("l_notreach");
\r
7435 else if (mstring_equalPrefix (start, "*PRINTFLIKE*/"))
\r
7437 lintcomment = cstring_makeLiteralTemp ("l_printfli");
\r
7439 else if (mstring_equalPrefix (start, "*FALLTHROUGH*/"))
\r
7441 lintcomment = cstring_makeLiteralTemp ("l_fallthrou");
\r
7443 else if (mstring_equalPrefix (start, "*ARGSUSED*/"))
\r
7445 lintcomment = cstring_makeLiteralTemp ("l_argsus");
\r
7447 else if (mstring_equalPrefix (start, "*FALLTHRU*/"))
\r
7449 lintcomment = cstring_makeLiteralTemp ("l_fallth");
\r
7453 lintcomment = cstring_undefined;
\r
7458 lintcomment = cstring_undefined;
\r
7461 if (cstring_isDefined (lintcomment))
\r
7463 c = BEFORE_COMMENT_MARKER[0];
\r
7464 start[0] = BEFORE_COMMENT_MARKER[1];
\r
7466 llassert (cstring_length (lintcomment) == len - 3);
\r
7468 for (i = 1; i < len - 2; i++)
\r
7470 start[i] = cstring_getChar (lintcomment, i);
\r
7473 start[len - 2] = AFTER_COMMENT_MARKER[0];
\r
7474 start[len - 1] = AFTER_COMMENT_MARKER[1];
\r
7478 /* Replaces char's in start with spaces */
\r
7479 for (i = 0; i < len; i++)
\r
7481 if (start[i] == '/'
\r
7483 && start[i + 1] == '*') {
\r
7484 (void) cppoptgenerror (FLG_NESTCOMMENT,
\r
7485 message ("Comment starts inside comment"),
\r
7489 if (start[i] != '\n')
\r
7496 cppReader_reserve (pfile, size_fromInt (1 + len));
\r
7497 cppReader_putCharQ (pfile, c);
\r
7498 cppReader_putStrN (pfile, start, size_fromInt (len));
\r
7499 parseClearMark (smark);
\r
7500 return CPP_COMMENT;
\r
7505 static int cpp_openIncludeFile (char *filename)
\r
7507 int res = open (filename, O_RDONLY, 0666);
\r
7509 /* evans 2001-08-23: was (res) - open returns -1 on error! reported by Robin Watts */
\r
7512 if (!fileTable_exists (context_fileTable (),
\r
7513 cstring_fromChars (filename)))
\r
7515 (void) fileTable_addHeaderFile (context_fileTable (),
\r
7516 cstring_fromChars (filename));
\r
7520 DPRINTF (("File already exists: %s", filename));
\r
7527 static bool cpp_skipIncludeFile (cstring fname)
\r
7529 if (context_isSystemDir (fname))
\r
7531 DPRINTF (("System dir: %s", fname));
\r
7533 if (lcllib_isSkipHeader (fname))
\r
7535 DPRINTF (("Skip include TRUE: %s", fname));
\r
7539 if (context_getFlag (FLG_SKIPSYSHEADERS))
\r
7541 DPRINTF (("Skip include TRUE: %s", fname));
\r
7546 if (context_getFlag (FLG_SINGLEINCLUDE))
\r
7548 fname = removePreDirs (fname);
\r
7550 # if defined (WIN32) || defined (OS2)
\r
7551 cstring_replaceAll (fname, '\\', '/');
\r
7554 if (fileTable_exists (context_fileTable (), fname))
\r
7556 DPRINTF (("Skip include TRUE: %s", fname));
\r
7561 DPRINTF (("Skip include FALSE: %s", fname));
\r
7565 static int cpp_peekN (cppReader *pfile, int n)
\r
7567 cppBuffer *buf = cppReader_getBuffer (pfile);
\r
7569 llassert (buf->cur != NULL);
\r
7571 return (buf->rlimit - buf->cur >= (n)
\r
7576 cppBuffer *cppBuffer_prevBuffer (cppBuffer *buf)
\r
7581 void cppBuffer_forward (cppBuffer *buf, int n)
\r
7583 llassert (buf->cur != NULL);
\r
andersk / splint.git / blob