1 /* CPP Library. (Directive handling.)
2    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005,
4    2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
5    Contributed by Per Bothner, 1994-95.
6    Based on CCCP program by Paul Rubin, June 1986
7    Adapted to ANSI C, Richard Stallman, Jan 1987
8 
9 This program is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 3, or (at your option) any
12 later version.
13 
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 GNU General Public License for more details.
18 
19 You should have received a copy of the GNU General Public License
20 along with this program; see the file COPYING3.  If not see
21 <http://www.gnu.org/licenses/>.  */
22 
23 #include "config.h"
24 #include "system.h"
25 #include "cpplib.h"
26 #include "internal.h"
27 #include "mkdeps.h"
28 #include "obstack.h"
29 
30 /* Stack of conditionals currently in progress
31    (including both successful and failing conditionals).  */
32 struct if_stack
33 {
34   struct if_stack *next;
35   source_location line;		/* Line where condition started.  */
36   const cpp_hashnode *mi_cmacro;/* macro name for #ifndef around entire file */
37   bool skip_elses;		/* Can future #else / #elif be skipped?  */
38   bool was_skipping;		/* If were skipping on entry.  */
39   int type;			/* Most recent conditional for diagnostics.  */
40 };
41 
42 /* Contains a registered pragma or pragma namespace.  */
43 typedef void (*pragma_cb) (cpp_reader *);
44 struct pragma_entry
45 {
46   struct pragma_entry *next;
47   const cpp_hashnode *pragma;	/* Name and length.  */
48   bool is_nspace;
49   bool is_internal;
50   bool is_deferred;
51   bool allow_expansion;
52   union {
53     pragma_cb handler;
54     struct pragma_entry *space;
55     unsigned int ident;
56   } u;
57 };
58 
59 /* Values for the origin field of struct directive.  KANDR directives
60    come from traditional (K&R) C.  STDC89 directives come from the
61    1989 C standard.  EXTENSION directives are extensions.  */
62 #define KANDR		0
63 #define STDC89		1
64 #define EXTENSION	2
65 
66 /* Values for the flags field of struct directive.  COND indicates a
67    conditional; IF_COND an opening conditional.  INCL means to treat
68    "..." and <...> as q-char and h-char sequences respectively.  IN_I
69    means this directive should be handled even if -fpreprocessed is in
70    effect (these are the directives with callback hooks).
71 
72    EXPAND is set on directives that are always macro-expanded.  */
73 #define COND		(1 << 0)
74 #define IF_COND		(1 << 1)
75 #define INCL		(1 << 2)
76 #define IN_I		(1 << 3)
77 #define EXPAND		(1 << 4)
78 #define DEPRECATED	(1 << 5)
79 
80 /* Defines one #-directive, including how to handle it.  */
81 typedef void (*directive_handler) (cpp_reader *);
82 typedef struct directive directive;
83 struct directive
84 {
85   directive_handler handler;	/* Function to handle directive.  */
86   const uchar *name;		/* Name of directive.  */
87   unsigned short length;	/* Length of name.  */
88   unsigned char origin;		/* Origin of directive.  */
89   unsigned char flags;	        /* Flags describing this directive.  */
90 };
91 
92 /* Forward declarations.  */
93 
94 static void skip_rest_of_line (cpp_reader *);
95 static void check_eol (cpp_reader *, bool);
96 static void start_directive (cpp_reader *);
97 static void prepare_directive_trad (cpp_reader *);
98 static void end_directive (cpp_reader *, int);
99 static void directive_diagnostics (cpp_reader *, const directive *, int);
100 static void run_directive (cpp_reader *, int, const char *, size_t);
101 static char *glue_header_name (cpp_reader *);
102 static const char *parse_include (cpp_reader *, int *, const cpp_token ***,
103 				  source_location *);
104 static void push_conditional (cpp_reader *, int, int, const cpp_hashnode *);
105 static unsigned int read_flag (cpp_reader *, unsigned int);
106 static bool strtolinenum (const uchar *, size_t, linenum_type *, bool *);
107 static void do_diagnostic (cpp_reader *, int, int, int);
108 static cpp_hashnode *lex_macro_node (cpp_reader *, bool);
109 static int undefine_macros (cpp_reader *, cpp_hashnode *, void *);
110 static void do_include_common (cpp_reader *, enum include_type);
111 static struct pragma_entry *lookup_pragma_entry (struct pragma_entry *,
112                                                  const cpp_hashnode *);
113 static int count_registered_pragmas (struct pragma_entry *);
114 static char ** save_registered_pragmas (struct pragma_entry *, char **);
115 static char ** restore_registered_pragmas (cpp_reader *, struct pragma_entry *,
116                                            char **);
117 static void do_pragma_once (cpp_reader *);
118 static void do_pragma_poison (cpp_reader *);
119 static void do_pragma_system_header (cpp_reader *);
120 static void do_pragma_dependency (cpp_reader *);
121 static void do_linemarker (cpp_reader *);
122 static const cpp_token *get_token_no_padding (cpp_reader *);
123 static const cpp_token *get__Pragma_string (cpp_reader *);
124 static void destringize_and_run (cpp_reader *, const cpp_string *);
125 static int parse_answer (cpp_reader *, struct answer **, int, source_location);
126 static cpp_hashnode *parse_assertion (cpp_reader *, struct answer **, int);
127 static struct answer ** find_answer (cpp_hashnode *, const struct answer *);
128 static void handle_assertion (cpp_reader *, const char *, int);
129 static void do_pragma_push_macro (cpp_reader *);
130 static void do_pragma_pop_macro (cpp_reader *);
131 static void cpp_pop_definition (cpp_reader *, struct def_pragma_macro *);
132 
133 /* This is the table of directive handlers.  It is ordered by
134    frequency of occurrence; the numbers at the end are directive
135    counts from all the source code I have lying around (egcs and libc
136    CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
137    pcmcia-cs-3.0.9).  This is no longer important as directive lookup
138    is now O(1).  All extensions other than #warning, #include_next,
139    and #import are deprecated.  The name is where the extension
140    appears to have come from.  */
141 
142 #define DIRECTIVE_TABLE							\
143 D(define,	T_DEFINE = 0,	KANDR,     IN_I)	   /* 270554 */ \
144 D(include,	T_INCLUDE,	KANDR,     INCL | EXPAND)  /*  52262 */ \
145 D(endif,	T_ENDIF,	KANDR,     COND)	   /*  45855 */ \
146 D(ifdef,	T_IFDEF,	KANDR,     COND | IF_COND) /*  22000 */ \
147 D(if,		T_IF,		KANDR, COND | IF_COND | EXPAND) /*  18162 */ \
148 D(else,		T_ELSE,		KANDR,     COND)	   /*   9863 */ \
149 D(ifndef,	T_IFNDEF,	KANDR,     COND | IF_COND) /*   9675 */ \
150 D(undef,	T_UNDEF,	KANDR,     IN_I)	   /*   4837 */ \
151 D(line,		T_LINE,		KANDR,     EXPAND)	   /*   2465 */ \
152 D(elif,		T_ELIF,		STDC89,    COND | EXPAND)  /*    610 */ \
153 D(error,	T_ERROR,	STDC89,    0)		   /*    475 */ \
154 D(pragma,	T_PRAGMA,	STDC89,    IN_I)	   /*    195 */ \
155 D(warning,	T_WARNING,	EXTENSION, 0)		   /*     22 */ \
156 D(include_next,	T_INCLUDE_NEXT,	EXTENSION, INCL | EXPAND)  /*     19 */ \
157 D(ident,	T_IDENT,	EXTENSION, IN_I)           /*     11 */ \
158 D(import,	T_IMPORT,	EXTENSION, INCL | EXPAND)  /* 0 ObjC */	\
159 D(assert,	T_ASSERT,	EXTENSION, DEPRECATED)	   /* 0 SVR4 */	\
160 D(unassert,	T_UNASSERT,	EXTENSION, DEPRECATED)	   /* 0 SVR4 */	\
161 D(sccs,		T_SCCS,		EXTENSION, IN_I)           /* 0 SVR4? */
162 
163 /* #sccs is synonymous with #ident.  */
164 #define do_sccs do_ident
165 
166 /* Use the table to generate a series of prototypes, an enum for the
167    directive names, and an array of directive handlers.  */
168 
169 #define D(name, t, o, f) static void do_##name (cpp_reader *);
170 DIRECTIVE_TABLE
171 #undef D
172 
173 #define D(n, tag, o, f) tag,
174 enum
175 {
176   DIRECTIVE_TABLE
177   N_DIRECTIVES
178 };
179 #undef D
180 
181 #define D(name, t, origin, flags) \
182 { do_##name, (const uchar *) #name, \
183   sizeof #name - 1, origin, flags },
184 static const directive dtable[] =
185 {
186 DIRECTIVE_TABLE
187 };
188 #undef D
189 #undef DIRECTIVE_TABLE
190 
191 /* Wrapper struct directive for linemarkers.
192    The origin is more or less true - the original K+R cpp
193    did use this notation in its preprocessed output.  */
194 static const directive linemarker_dir =
195 {
196   do_linemarker, UC"#", 1, KANDR, IN_I
197 };
198 
199 #define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
200 
201 /* Skip any remaining tokens in a directive.  */
202 static void
skip_rest_of_line(cpp_reader * pfile)203 skip_rest_of_line (cpp_reader *pfile)
204 {
205   /* Discard all stacked contexts.  */
206   while (pfile->context->prev)
207     _cpp_pop_context (pfile);
208 
209   /* Sweep up all tokens remaining on the line.  */
210   if (! SEEN_EOL ())
211     while (_cpp_lex_token (pfile)->type != CPP_EOF)
212       ;
213 }
214 
215 /* Ensure there are no stray tokens at the end of a directive.  If
216    EXPAND is true, tokens macro-expanding to nothing are allowed.  */
217 static void
check_eol(cpp_reader * pfile,bool expand)218 check_eol (cpp_reader *pfile, bool expand)
219 {
220   if (! SEEN_EOL () && (expand
221 			? cpp_get_token (pfile)
222 			: _cpp_lex_token (pfile))->type != CPP_EOF)
223     cpp_error (pfile, CPP_DL_PEDWARN, "extra tokens at end of #%s directive",
224 	       pfile->directive->name);
225 }
226 
227 /* Ensure there are no stray tokens other than comments at the end of
228    a directive, and gather the comments.  */
229 static const cpp_token **
check_eol_return_comments(cpp_reader * pfile)230 check_eol_return_comments (cpp_reader *pfile)
231 {
232   size_t c;
233   size_t capacity = 8;
234   const cpp_token **buf;
235 
236   buf = XNEWVEC (const cpp_token *, capacity);
237   c = 0;
238   if (! SEEN_EOL ())
239     {
240       while (1)
241 	{
242 	  const cpp_token *tok;
243 
244 	  tok = _cpp_lex_token (pfile);
245 	  if (tok->type == CPP_EOF)
246 	    break;
247 	  if (tok->type != CPP_COMMENT)
248 	    cpp_error (pfile, CPP_DL_PEDWARN,
249 		       "extra tokens at end of #%s directive",
250 		       pfile->directive->name);
251 	  else
252 	    {
253 	      if (c + 1 >= capacity)
254 		{
255 		  capacity *= 2;
256 		  buf = XRESIZEVEC (const cpp_token *, buf, capacity);
257 		}
258 	      buf[c] = tok;
259 	      ++c;
260 	    }
261 	}
262     }
263   buf[c] = NULL;
264   return buf;
265 }
266 
267 /* Called when entering a directive, _Pragma or command-line directive.  */
268 static void
start_directive(cpp_reader * pfile)269 start_directive (cpp_reader *pfile)
270 {
271   /* Setup in-directive state.  */
272   pfile->state.in_directive = 1;
273   pfile->state.save_comments = 0;
274   pfile->directive_result.type = CPP_PADDING;
275 
276   /* Some handlers need the position of the # for diagnostics.  */
277   pfile->directive_line = pfile->line_table->highest_line;
278 }
279 
280 /* Called when leaving a directive, _Pragma or command-line directive.  */
281 static void
end_directive(cpp_reader * pfile,int skip_line)282 end_directive (cpp_reader *pfile, int skip_line)
283 {
284   if (CPP_OPTION (pfile, traditional))
285     {
286       /* Revert change of prepare_directive_trad.  */
287       if (!pfile->state.in_deferred_pragma)
288 	pfile->state.prevent_expansion--;
289 
290       if (pfile->directive != &dtable[T_DEFINE])
291 	_cpp_remove_overlay (pfile);
292     }
293   else if (pfile->state.in_deferred_pragma)
294     ;
295   /* We don't skip for an assembler #.  */
296   else if (skip_line)
297     {
298       skip_rest_of_line (pfile);
299       if (!pfile->keep_tokens)
300 	{
301 	  pfile->cur_run = &pfile->base_run;
302 	  pfile->cur_token = pfile->base_run.base;
303 	}
304     }
305 
306   /* Restore state.  */
307   pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
308   pfile->state.in_directive = 0;
309   pfile->state.in_expression = 0;
310   pfile->state.angled_headers = 0;
311   pfile->directive = 0;
312 }
313 
314 /* Prepare to handle the directive in pfile->directive.  */
315 static void
prepare_directive_trad(cpp_reader * pfile)316 prepare_directive_trad (cpp_reader *pfile)
317 {
318   if (pfile->directive != &dtable[T_DEFINE])
319     {
320       bool no_expand = (pfile->directive
321 			&& ! (pfile->directive->flags & EXPAND));
322       bool was_skipping = pfile->state.skipping;
323 
324       pfile->state.in_expression = (pfile->directive == &dtable[T_IF]
325 				    || pfile->directive == &dtable[T_ELIF]);
326       if (pfile->state.in_expression)
327 	pfile->state.skipping = false;
328 
329       if (no_expand)
330 	pfile->state.prevent_expansion++;
331       _cpp_scan_out_logical_line (pfile, NULL);
332       if (no_expand)
333 	pfile->state.prevent_expansion--;
334 
335       pfile->state.skipping = was_skipping;
336       _cpp_overlay_buffer (pfile, pfile->out.base,
337 			   pfile->out.cur - pfile->out.base);
338     }
339 
340   /* Stop ISO C from expanding anything.  */
341   pfile->state.prevent_expansion++;
342 }
343 
344 /* Output diagnostics for a directive DIR.  INDENTED is nonzero if
345    the '#' was indented.  */
346 static void
directive_diagnostics(cpp_reader * pfile,const directive * dir,int indented)347 directive_diagnostics (cpp_reader *pfile, const directive *dir, int indented)
348 {
349   /* Issue -pedantic or deprecated warnings for extensions.  We let
350      -pedantic take precedence if both are applicable.  */
351   if (! pfile->state.skipping)
352     {
353       if (dir->origin == EXTENSION
354 	  && !(dir == &dtable[T_IMPORT] && CPP_OPTION (pfile, objc))
355 	  && CPP_PEDANTIC (pfile))
356 	cpp_error (pfile, CPP_DL_PEDWARN, "#%s is a GCC extension", dir->name);
357       else if (((dir->flags & DEPRECATED) != 0
358 		|| (dir == &dtable[T_IMPORT] && !CPP_OPTION (pfile, objc)))
359 	       && CPP_OPTION (pfile, cpp_warn_deprecated))
360 	cpp_warning (pfile, CPP_W_DEPRECATED,
361                      "#%s is a deprecated GCC extension", dir->name);
362     }
363 
364   /* Traditionally, a directive is ignored unless its # is in
365      column 1.  Therefore in code intended to work with K+R
366      compilers, directives added by C89 must have their #
367      indented, and directives present in traditional C must not.
368      This is true even of directives in skipped conditional
369      blocks.  #elif cannot be used at all.  */
370   if (CPP_WTRADITIONAL (pfile))
371     {
372       if (dir == &dtable[T_ELIF])
373 	cpp_warning (pfile, CPP_W_TRADITIONAL,
374 		     "suggest not using #elif in traditional C");
375       else if (indented && dir->origin == KANDR)
376 	cpp_warning (pfile, CPP_W_TRADITIONAL,
377 		     "traditional C ignores #%s with the # indented",
378 		     dir->name);
379       else if (!indented && dir->origin != KANDR)
380 	cpp_warning (pfile, CPP_W_TRADITIONAL,
381 		     "suggest hiding #%s from traditional C with an indented #",
382 		     dir->name);
383     }
384 }
385 
386 /* Check if we have a known directive.  INDENTED is nonzero if the
387    '#' of the directive was indented.  This function is in this file
388    to save unnecessarily exporting dtable etc. to lex.c.  Returns
389    nonzero if the line of tokens has been handled, zero if we should
390    continue processing the line.  */
391 int
_cpp_handle_directive(cpp_reader * pfile,int indented)392 _cpp_handle_directive (cpp_reader *pfile, int indented)
393 {
394   const directive *dir = 0;
395   const cpp_token *dname;
396   bool was_parsing_args = pfile->state.parsing_args;
397   bool was_discarding_output = pfile->state.discarding_output;
398   int skip = 1;
399 
400   if (was_discarding_output)
401     pfile->state.prevent_expansion = 0;
402 
403   if (was_parsing_args)
404     {
405       if (CPP_OPTION (pfile, cpp_pedantic))
406 	cpp_error (pfile, CPP_DL_PEDWARN,
407 	     "embedding a directive within macro arguments is not portable");
408       pfile->state.parsing_args = 0;
409       pfile->state.prevent_expansion = 0;
410     }
411   start_directive (pfile);
412   dname = _cpp_lex_token (pfile);
413 
414   if (dname->type == CPP_NAME)
415     {
416       if (dname->val.node.node->is_directive)
417 	dir = &dtable[dname->val.node.node->directive_index];
418     }
419   /* We do not recognize the # followed by a number extension in
420      assembler code.  */
421   else if (dname->type == CPP_NUMBER && CPP_OPTION (pfile, lang) != CLK_ASM)
422     {
423       dir = &linemarker_dir;
424       if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed)
425 	  && ! pfile->state.skipping)
426 	cpp_error (pfile, CPP_DL_PEDWARN,
427 		   "style of line directive is a GCC extension");
428     }
429 
430   if (dir)
431     {
432       /* If we have a directive that is not an opening conditional,
433 	 invalidate any control macro.  */
434       if (! (dir->flags & IF_COND))
435 	pfile->mi_valid = false;
436 
437       /* Kluge alert.  In order to be sure that code like this
438 
439 	 #define HASH #
440 	 HASH define foo bar
441 
442 	 does not cause '#define foo bar' to get executed when
443 	 compiled with -save-temps, we recognize directives in
444 	 -fpreprocessed mode only if the # is in column 1.  macro.c
445 	 puts a space in front of any '#' at the start of a macro.
446 
447 	 We exclude the -fdirectives-only case because macro expansion
448 	 has not been performed yet, and block comments can cause spaces
449 	 to preceed the directive.  */
450       if (CPP_OPTION (pfile, preprocessed)
451 	  && !CPP_OPTION (pfile, directives_only)
452 	  && (indented || !(dir->flags & IN_I)))
453 	{
454 	  skip = 0;
455 	  dir = 0;
456 	}
457       else
458 	{
459 	  /* In failed conditional groups, all non-conditional
460 	     directives are ignored.  Before doing that, whether
461 	     skipping or not, we should lex angle-bracketed headers
462 	     correctly, and maybe output some diagnostics.  */
463 	  pfile->state.angled_headers = dir->flags & INCL;
464 	  pfile->state.directive_wants_padding = dir->flags & INCL;
465 	  if (! CPP_OPTION (pfile, preprocessed))
466 	    directive_diagnostics (pfile, dir, indented);
467 	  if (pfile->state.skipping && !(dir->flags & COND))
468 	    dir = 0;
469 	}
470     }
471   else if (dname->type == CPP_EOF)
472     ;	/* CPP_EOF is the "null directive".  */
473   else
474     {
475       /* An unknown directive.  Don't complain about it in assembly
476 	 source: we don't know where the comments are, and # may
477 	 introduce assembler pseudo-ops.  Don't complain about invalid
478 	 directives in skipped conditional groups (6.10 p4).  */
479       if (CPP_OPTION (pfile, lang) == CLK_ASM)
480 	skip = 0;
481       else if (!pfile->state.skipping)
482 	cpp_error (pfile, CPP_DL_ERROR, "invalid preprocessing directive #%s",
483 		   cpp_token_as_text (pfile, dname));
484     }
485 
486   pfile->directive = dir;
487   if (CPP_OPTION (pfile, traditional))
488     prepare_directive_trad (pfile);
489 
490   if (dir)
491     pfile->directive->handler (pfile);
492   else if (skip == 0)
493     _cpp_backup_tokens (pfile, 1);
494 
495   end_directive (pfile, skip);
496   if (was_parsing_args && !pfile->state.in_deferred_pragma)
497     {
498       /* Restore state when within macro args.  */
499       pfile->state.parsing_args = 2;
500       pfile->state.prevent_expansion = 1;
501     }
502   if (was_discarding_output)
503     pfile->state.prevent_expansion = 1;
504   return skip;
505 }
506 
507 /* Directive handler wrapper used by the command line option
508    processor.  BUF is \n terminated.  */
509 static void
run_directive(cpp_reader * pfile,int dir_no,const char * buf,size_t count)510 run_directive (cpp_reader *pfile, int dir_no, const char *buf, size_t count)
511 {
512   cpp_push_buffer (pfile, (const uchar *) buf, count,
513 		   /* from_stage3 */ true);
514   start_directive (pfile);
515 
516   /* This is a short-term fix to prevent a leading '#' being
517      interpreted as a directive.  */
518   _cpp_clean_line (pfile);
519 
520   pfile->directive = &dtable[dir_no];
521   if (CPP_OPTION (pfile, traditional))
522     prepare_directive_trad (pfile);
523   pfile->directive->handler (pfile);
524   end_directive (pfile, 1);
525   _cpp_pop_buffer (pfile);
526 }
527 
528 /* Checks for validity the macro name in #define, #undef, #ifdef and
529    #ifndef directives.  IS_DEF_OR_UNDEF is true if this call is
530    processing a #define or #undefine directive, and false
531    otherwise.  */
532 static cpp_hashnode *
lex_macro_node(cpp_reader * pfile,bool is_def_or_undef)533 lex_macro_node (cpp_reader *pfile, bool is_def_or_undef)
534 {
535   const cpp_token *token = _cpp_lex_token (pfile);
536 
537   /* The token immediately after #define must be an identifier.  That
538      identifier may not be "defined", per C99 6.10.8p4.
539      In C++, it may not be any of the "named operators" either,
540      per C++98 [lex.digraph], [lex.key].
541      Finally, the identifier may not have been poisoned.  (In that case
542      the lexer has issued the error message for us.)  */
543 
544   if (token->type == CPP_NAME)
545     {
546       cpp_hashnode *node = token->val.node.node;
547 
548       if (is_def_or_undef && node == pfile->spec_nodes.n_defined)
549 	cpp_error (pfile, CPP_DL_ERROR,
550 		   "\"defined\" cannot be used as a macro name");
551       else if (! (node->flags & NODE_POISONED))
552 	return node;
553     }
554   else if (token->flags & NAMED_OP)
555     cpp_error (pfile, CPP_DL_ERROR,
556        "\"%s\" cannot be used as a macro name as it is an operator in C++",
557 	       NODE_NAME (token->val.node.node));
558   else if (token->type == CPP_EOF)
559     cpp_error (pfile, CPP_DL_ERROR, "no macro name given in #%s directive",
560 	       pfile->directive->name);
561   else
562     cpp_error (pfile, CPP_DL_ERROR, "macro names must be identifiers");
563 
564   return NULL;
565 }
566 
567 /* Process a #define directive.  Most work is done in macro.c.  */
568 static void
do_define(cpp_reader * pfile)569 do_define (cpp_reader *pfile)
570 {
571   cpp_hashnode *node = lex_macro_node (pfile, true);
572 
573   if (node)
574     {
575       /* If we have been requested to expand comments into macros,
576 	 then re-enable saving of comments.  */
577       pfile->state.save_comments =
578 	! CPP_OPTION (pfile, discard_comments_in_macro_exp);
579 
580       if (pfile->cb.before_define)
581 	pfile->cb.before_define (pfile);
582 
583       if (_cpp_create_definition (pfile, node))
584 	if (pfile->cb.define)
585 	  pfile->cb.define (pfile, pfile->directive_line, node);
586 
587       node->flags &= ~NODE_USED;
588     }
589 }
590 
591 /* Handle #undef.  Mark the identifier NT_VOID in the hash table.  */
592 static void
do_undef(cpp_reader * pfile)593 do_undef (cpp_reader *pfile)
594 {
595   cpp_hashnode *node = lex_macro_node (pfile, true);
596 
597   if (node)
598     {
599       if (pfile->cb.before_define)
600 	pfile->cb.before_define (pfile);
601 
602       if (pfile->cb.undef)
603 	pfile->cb.undef (pfile, pfile->directive_line, node);
604 
605       /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified
606 	 identifier is not currently defined as a macro name.  */
607       if (node->type == NT_MACRO)
608 	{
609 	  if (node->flags & NODE_WARN)
610 	    cpp_error (pfile, CPP_DL_WARNING,
611 		       "undefining \"%s\"", NODE_NAME (node));
612 
613 	  if (CPP_OPTION (pfile, warn_unused_macros))
614 	    _cpp_warn_if_unused_macro (pfile, node, NULL);
615 
616 	  _cpp_free_definition (node);
617 	}
618     }
619 
620   check_eol (pfile, false);
621 }
622 
623 /* Undefine a single macro/assertion/whatever.  */
624 
625 static int
undefine_macros(cpp_reader * pfile ATTRIBUTE_UNUSED,cpp_hashnode * h,void * data_p ATTRIBUTE_UNUSED)626 undefine_macros (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *h,
627 		 void *data_p ATTRIBUTE_UNUSED)
628 {
629   /* Body of _cpp_free_definition inlined here for speed.
630      Macros and assertions no longer have anything to free.  */
631   h->type = NT_VOID;
632   h->flags &= ~(NODE_POISONED|NODE_BUILTIN|NODE_DISABLED|NODE_USED);
633   return 1;
634 }
635 
636 /* Undefine all macros and assertions.  */
637 
638 void
cpp_undef_all(cpp_reader * pfile)639 cpp_undef_all (cpp_reader *pfile)
640 {
641   cpp_forall_identifiers (pfile, undefine_macros, NULL);
642 }
643 
644 
645 /* Helper routine used by parse_include.  Reinterpret the current line
646    as an h-char-sequence (< ... >); we are looking at the first token
647    after the <.  Returns a malloced filename.  */
648 static char *
glue_header_name(cpp_reader * pfile)649 glue_header_name (cpp_reader *pfile)
650 {
651   const cpp_token *token;
652   char *buffer;
653   size_t len, total_len = 0, capacity = 1024;
654 
655   /* To avoid lexed tokens overwriting our glued name, we can only
656      allocate from the string pool once we've lexed everything.  */
657   buffer = XNEWVEC (char, capacity);
658   for (;;)
659     {
660       token = get_token_no_padding (pfile);
661 
662       if (token->type == CPP_GREATER)
663 	break;
664       if (token->type == CPP_EOF)
665 	{
666 	  cpp_error (pfile, CPP_DL_ERROR, "missing terminating > character");
667 	  break;
668 	}
669 
670       len = cpp_token_len (token) + 2; /* Leading space, terminating \0.  */
671       if (total_len + len > capacity)
672 	{
673 	  capacity = (capacity + len) * 2;
674 	  buffer = XRESIZEVEC (char, buffer, capacity);
675 	}
676 
677       if (token->flags & PREV_WHITE)
678 	buffer[total_len++] = ' ';
679 
680       total_len = (cpp_spell_token (pfile, token, (uchar *) &buffer[total_len],
681 				    true)
682 		   - (uchar *) buffer);
683     }
684 
685   buffer[total_len] = '\0';
686   return buffer;
687 }
688 
689 /* Returns the file name of #include, #include_next, #import and
690    #pragma dependency.  The string is malloced and the caller should
691    free it.  Returns NULL on error.  LOCATION is the source location
692    of the file name.  */
693 
694 static const char *
parse_include(cpp_reader * pfile,int * pangle_brackets,const cpp_token *** buf,source_location * location)695 parse_include (cpp_reader *pfile, int *pangle_brackets,
696 	       const cpp_token ***buf, source_location *location)
697 {
698   char *fname;
699   const cpp_token *header;
700 
701   /* Allow macro expansion.  */
702   header = get_token_no_padding (pfile);
703   *location = header->src_loc;
704   if ((header->type == CPP_STRING && header->val.str.text[0] != 'R')
705       || header->type == CPP_HEADER_NAME)
706     {
707       fname = XNEWVEC (char, header->val.str.len - 1);
708       memcpy (fname, header->val.str.text + 1, header->val.str.len - 2);
709       fname[header->val.str.len - 2] = '\0';
710       *pangle_brackets = header->type == CPP_HEADER_NAME;
711     }
712   else if (header->type == CPP_LESS)
713     {
714       fname = glue_header_name (pfile);
715       *pangle_brackets = 1;
716     }
717   else
718     {
719       const unsigned char *dir;
720 
721       if (pfile->directive == &dtable[T_PRAGMA])
722 	dir = UC"pragma dependency";
723       else
724 	dir = pfile->directive->name;
725       cpp_error (pfile, CPP_DL_ERROR, "#%s expects \"FILENAME\" or <FILENAME>",
726 		 dir);
727 
728       return NULL;
729     }
730 
731   if (pfile->directive == &dtable[T_PRAGMA])
732     {
733       /* This pragma allows extra tokens after the file name.  */
734     }
735   else if (buf == NULL || CPP_OPTION (pfile, discard_comments))
736     check_eol (pfile, true);
737   else
738     {
739       /* If we are not discarding comments, then gather them while
740 	 doing the eol check.  */
741       *buf = check_eol_return_comments (pfile);
742     }
743 
744   return fname;
745 }
746 
747 /* Handle #include, #include_next and #import.  */
748 static void
do_include_common(cpp_reader * pfile,enum include_type type)749 do_include_common (cpp_reader *pfile, enum include_type type)
750 {
751   const char *fname;
752   int angle_brackets;
753   const cpp_token **buf = NULL;
754   source_location location;
755 
756   /* Re-enable saving of comments if requested, so that the include
757      callback can dump comments which follow #include.  */
758   pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
759 
760   fname = parse_include (pfile, &angle_brackets, &buf, &location);
761   if (!fname)
762     {
763       if (buf)
764 	XDELETEVEC (buf);
765       return;
766     }
767 
768   if (!*fname)
769   {
770     cpp_error_with_line (pfile, CPP_DL_ERROR, location, 0,
771 			 "empty filename in #%s",
772 			 pfile->directive->name);
773     XDELETEVEC (fname);
774     if (buf)
775       XDELETEVEC (buf);
776     return;
777   }
778 
779   /* Prevent #include recursion.  */
780   if (pfile->line_table->depth >= CPP_STACK_MAX)
781     cpp_error (pfile, CPP_DL_ERROR, "#include nested too deeply");
782   else
783     {
784       /* Get out of macro context, if we are.  */
785       skip_rest_of_line (pfile);
786 
787       if (pfile->cb.include)
788 	pfile->cb.include (pfile, pfile->directive_line,
789 			   pfile->directive->name, fname, angle_brackets,
790 			   buf);
791 
792       _cpp_stack_include (pfile, fname, angle_brackets, type);
793     }
794 
795   XDELETEVEC (fname);
796   if (buf)
797     XDELETEVEC (buf);
798 }
799 
800 static void
do_include(cpp_reader * pfile)801 do_include (cpp_reader *pfile)
802 {
803   do_include_common (pfile, IT_INCLUDE);
804 }
805 
806 static void
do_import(cpp_reader * pfile)807 do_import (cpp_reader *pfile)
808 {
809   do_include_common (pfile, IT_IMPORT);
810 }
811 
812 static void
do_include_next(cpp_reader * pfile)813 do_include_next (cpp_reader *pfile)
814 {
815   enum include_type type = IT_INCLUDE_NEXT;
816 
817   /* If this is the primary source file, warn and use the normal
818      search logic.  */
819   if (cpp_in_primary_file (pfile))
820     {
821       cpp_error (pfile, CPP_DL_WARNING,
822 		 "#include_next in primary source file");
823       type = IT_INCLUDE;
824     }
825   do_include_common (pfile, type);
826 }
827 
828 /* Subroutine of do_linemarker.  Read possible flags after file name.
829    LAST is the last flag seen; 0 if this is the first flag. Return the
830    flag if it is valid, 0 at the end of the directive. Otherwise
831    complain.  */
832 static unsigned int
read_flag(cpp_reader * pfile,unsigned int last)833 read_flag (cpp_reader *pfile, unsigned int last)
834 {
835   const cpp_token *token = _cpp_lex_token (pfile);
836 
837   if (token->type == CPP_NUMBER && token->val.str.len == 1)
838     {
839       unsigned int flag = token->val.str.text[0] - '0';
840 
841       if (flag > last && flag <= 4
842 	  && (flag != 4 || last == 3)
843 	  && (flag != 2 || last == 0))
844 	return flag;
845     }
846 
847   if (token->type != CPP_EOF)
848     cpp_error (pfile, CPP_DL_ERROR, "invalid flag \"%s\" in line directive",
849 	       cpp_token_as_text (pfile, token));
850   return 0;
851 }
852 
853 /* Subroutine of do_line and do_linemarker.  Convert a number in STR,
854    of length LEN, to binary; store it in NUMP, and return false if the
855    number was well-formed, true if not. WRAPPED is set to true if the
856    number did not fit into 'unsigned long'.  */
857 static bool
strtolinenum(const uchar * str,size_t len,linenum_type * nump,bool * wrapped)858 strtolinenum (const uchar *str, size_t len, linenum_type *nump, bool *wrapped)
859 {
860   linenum_type reg = 0;
861   linenum_type reg_prev = 0;
862 
863   uchar c;
864   *wrapped = false;
865   while (len--)
866     {
867       c = *str++;
868       if (!ISDIGIT (c))
869 	return true;
870       reg *= 10;
871       reg += c - '0';
872       if (reg < reg_prev)
873 	*wrapped = true;
874       reg_prev = reg;
875     }
876   *nump = reg;
877   return false;
878 }
879 
880 /* Interpret #line command.
881    Note that the filename string (if any) is a true string constant
882    (escapes are interpreted), unlike in #line.  */
883 static void
do_line(cpp_reader * pfile)884 do_line (cpp_reader *pfile)
885 {
886   const struct line_maps *line_table = pfile->line_table;
887   const struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
888 
889   /* skip_rest_of_line() may cause line table to be realloc()ed so note down
890      sysp right now.  */
891 
892   unsigned char map_sysp = ORDINARY_MAP_IN_SYSTEM_HEADER_P (map);
893   const cpp_token *token;
894   const char *new_file = ORDINARY_MAP_FILE_NAME (map);
895   linenum_type new_lineno;
896 
897   /* C99 raised the minimum limit on #line numbers.  */
898   linenum_type cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
899   bool wrapped;
900 
901   /* #line commands expand macros.  */
902   token = cpp_get_token (pfile);
903   if (token->type != CPP_NUMBER
904       || strtolinenum (token->val.str.text, token->val.str.len,
905 		       &new_lineno, &wrapped))
906     {
907       if (token->type == CPP_EOF)
908 	cpp_error (pfile, CPP_DL_ERROR, "unexpected end of file after #line");
909       else
910 	cpp_error (pfile, CPP_DL_ERROR,
911 		   "\"%s\" after #line is not a positive integer",
912 		   cpp_token_as_text (pfile, token));
913       return;
914     }
915 
916   if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap || wrapped))
917     cpp_error (pfile, CPP_DL_PEDWARN, "line number out of range");
918   else if (wrapped)
919     cpp_error (pfile, CPP_DL_WARNING, "line number out of range");
920 
921   token = cpp_get_token (pfile);
922   if (token->type == CPP_STRING)
923     {
924       cpp_string s = { 0, 0 };
925       if (cpp_interpret_string_notranslate (pfile, &token->val.str, 1,
926 					    &s, CPP_STRING))
927 	new_file = (const char *)s.text;
928       check_eol (pfile, true);
929     }
930   else if (token->type != CPP_EOF)
931     {
932       cpp_error (pfile, CPP_DL_ERROR, "\"%s\" is not a valid filename",
933 		 cpp_token_as_text (pfile, token));
934       return;
935     }
936 
937   skip_rest_of_line (pfile);
938   _cpp_do_file_change (pfile, LC_RENAME_VERBATIM, new_file, new_lineno,
939 		       map_sysp);
940 }
941 
942 /* Interpret the # 44 "file" [flags] notation, which has slightly
943    different syntax and semantics from #line:  Flags are allowed,
944    and we never complain about the line number being too big.  */
945 static void
do_linemarker(cpp_reader * pfile)946 do_linemarker (cpp_reader *pfile)
947 {
948   const struct line_maps *line_table = pfile->line_table;
949   const struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
950   const cpp_token *token;
951   const char *new_file = ORDINARY_MAP_FILE_NAME (map);
952   linenum_type new_lineno;
953   unsigned int new_sysp = ORDINARY_MAP_IN_SYSTEM_HEADER_P (map);
954   enum lc_reason reason = LC_RENAME_VERBATIM;
955   int flag;
956   bool wrapped;
957 
958   /* Back up so we can get the number again.  Putting this in
959      _cpp_handle_directive risks two calls to _cpp_backup_tokens in
960      some circumstances, which can segfault.  */
961   _cpp_backup_tokens (pfile, 1);
962 
963   /* #line commands expand macros.  */
964   token = cpp_get_token (pfile);
965   if (token->type != CPP_NUMBER
966       || strtolinenum (token->val.str.text, token->val.str.len,
967 		       &new_lineno, &wrapped))
968     {
969       /* Unlike #line, there does not seem to be a way to get an EOF
970 	 here.  So, it should be safe to always spell the token.  */
971       cpp_error (pfile, CPP_DL_ERROR,
972 		 "\"%s\" after # is not a positive integer",
973 		 cpp_token_as_text (pfile, token));
974       return;
975     }
976 
977   token = cpp_get_token (pfile);
978   if (token->type == CPP_STRING)
979     {
980       cpp_string s = { 0, 0 };
981       if (cpp_interpret_string_notranslate (pfile, &token->val.str,
982 					    1, &s, CPP_STRING))
983 	new_file = (const char *)s.text;
984 
985       new_sysp = 0;
986       flag = read_flag (pfile, 0);
987       if (flag == 1)
988 	{
989 	  reason = LC_ENTER;
990 	  /* Fake an include for cpp_included ().  */
991 	  _cpp_fake_include (pfile, new_file);
992 	  flag = read_flag (pfile, flag);
993 	}
994       else if (flag == 2)
995 	{
996 	  reason = LC_LEAVE;
997 	  flag = read_flag (pfile, flag);
998 	}
999       if (flag == 3)
1000 	{
1001 	  new_sysp = 1;
1002 	  flag = read_flag (pfile, flag);
1003 	  if (flag == 4)
1004 	    new_sysp = 2;
1005 	}
1006       pfile->buffer->sysp = new_sysp;
1007 
1008       check_eol (pfile, false);
1009     }
1010   else if (token->type != CPP_EOF)
1011     {
1012       cpp_error (pfile, CPP_DL_ERROR, "\"%s\" is not a valid filename",
1013 		 cpp_token_as_text (pfile, token));
1014       return;
1015     }
1016 
1017   skip_rest_of_line (pfile);
1018 
1019   /* Compensate for the increment in linemap_add that occurs in
1020      _cpp_do_file_change.  We're currently at the start of the line
1021      *following* the #line directive.  A separate source_location for this
1022      location makes no sense (until we do the LC_LEAVE), and
1023      complicates LAST_SOURCE_LINE_LOCATION.  */
1024   pfile->line_table->highest_location--;
1025 
1026   _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp);
1027 }
1028 
1029 /* Arrange the file_change callback.  pfile->line has changed to
1030    FILE_LINE of TO_FILE, for reason REASON.  SYSP is 1 for a system
1031    header, 2 for a system header that needs to be extern "C" protected,
1032    and zero otherwise.  */
1033 void
_cpp_do_file_change(cpp_reader * pfile,enum lc_reason reason,const char * to_file,linenum_type file_line,unsigned int sysp)1034 _cpp_do_file_change (cpp_reader *pfile, enum lc_reason reason,
1035 		     const char *to_file, linenum_type file_line,
1036 		     unsigned int sysp)
1037 {
1038   const struct line_map *map = linemap_add (pfile->line_table, reason, sysp,
1039 					    to_file, file_line);
1040   if (map != NULL)
1041     linemap_line_start (pfile->line_table,
1042 			ORDINARY_MAP_STARTING_LINE_NUMBER (map),
1043 			127);
1044 
1045   if (pfile->cb.file_change)
1046     pfile->cb.file_change (pfile, map);
1047 }
1048 
1049 /* Report a warning or error detected by the program we are
1050    processing.  Use the directive's tokens in the error message.  */
1051 static void
do_diagnostic(cpp_reader * pfile,int code,int reason,int print_dir)1052 do_diagnostic (cpp_reader *pfile, int code, int reason, int print_dir)
1053 {
1054   const unsigned char *dir_name;
1055   unsigned char *line;
1056   source_location src_loc = pfile->cur_token[-1].src_loc;
1057 
1058   if (print_dir)
1059     dir_name = pfile->directive->name;
1060   else
1061     dir_name = NULL;
1062   pfile->state.prevent_expansion++;
1063   line = cpp_output_line_to_string (pfile, dir_name);
1064   pfile->state.prevent_expansion--;
1065 
1066   if (code == CPP_DL_WARNING_SYSHDR && reason)
1067     cpp_warning_with_line_syshdr (pfile, reason, src_loc, 0, "%s", line);
1068   else if (code == CPP_DL_WARNING && reason)
1069     cpp_warning_with_line (pfile, reason, src_loc, 0, "%s", line);
1070   else
1071     cpp_error_with_line (pfile, code, src_loc, 0, "%s", line);
1072   free (line);
1073 }
1074 
1075 static void
do_error(cpp_reader * pfile)1076 do_error (cpp_reader *pfile)
1077 {
1078   do_diagnostic (pfile, CPP_DL_ERROR, 0, 1);
1079 }
1080 
1081 static void
do_warning(cpp_reader * pfile)1082 do_warning (cpp_reader *pfile)
1083 {
1084   /* We want #warning diagnostics to be emitted in system headers too.  */
1085   do_diagnostic (pfile, CPP_DL_WARNING_SYSHDR, CPP_W_WARNING_DIRECTIVE, 1);
1086 }
1087 
1088 /* Report program identification.  */
1089 static void
do_ident(cpp_reader * pfile)1090 do_ident (cpp_reader *pfile)
1091 {
1092   const cpp_token *str = cpp_get_token (pfile);
1093 
1094   if (str->type != CPP_STRING)
1095     cpp_error (pfile, CPP_DL_ERROR, "invalid #%s directive",
1096 	       pfile->directive->name);
1097   else if (pfile->cb.ident)
1098     pfile->cb.ident (pfile, pfile->directive_line, &str->val.str);
1099 
1100   check_eol (pfile, false);
1101 }
1102 
1103 /* Lookup a PRAGMA name in a singly-linked CHAIN.  Returns the
1104    matching entry, or NULL if none is found.  The returned entry could
1105    be the start of a namespace chain, or a pragma.  */
1106 static struct pragma_entry *
lookup_pragma_entry(struct pragma_entry * chain,const cpp_hashnode * pragma)1107 lookup_pragma_entry (struct pragma_entry *chain, const cpp_hashnode *pragma)
1108 {
1109   while (chain && chain->pragma != pragma)
1110     chain = chain->next;
1111 
1112   return chain;
1113 }
1114 
1115 /* Create and insert a blank pragma entry at the beginning of a
1116    singly-linked CHAIN.  */
1117 static struct pragma_entry *
new_pragma_entry(cpp_reader * pfile,struct pragma_entry ** chain)1118 new_pragma_entry (cpp_reader *pfile, struct pragma_entry **chain)
1119 {
1120   struct pragma_entry *new_entry;
1121 
1122   new_entry = (struct pragma_entry *)
1123     _cpp_aligned_alloc (pfile, sizeof (struct pragma_entry));
1124 
1125   memset (new_entry, 0, sizeof (struct pragma_entry));
1126   new_entry->next = *chain;
1127 
1128   *chain = new_entry;
1129   return new_entry;
1130 }
1131 
1132 /* Register a pragma NAME in namespace SPACE.  If SPACE is null, it
1133    goes in the global namespace.  */
1134 static struct pragma_entry *
register_pragma_1(cpp_reader * pfile,const char * space,const char * name,bool allow_name_expansion)1135 register_pragma_1 (cpp_reader *pfile, const char *space, const char *name,
1136 		   bool allow_name_expansion)
1137 {
1138   struct pragma_entry **chain = &pfile->pragmas;
1139   struct pragma_entry *entry;
1140   const cpp_hashnode *node;
1141 
1142   if (space)
1143     {
1144       node = cpp_lookup (pfile, UC space, strlen (space));
1145       entry = lookup_pragma_entry (*chain, node);
1146       if (!entry)
1147 	{
1148 	  entry = new_pragma_entry (pfile, chain);
1149 	  entry->pragma = node;
1150 	  entry->is_nspace = true;
1151 	  entry->allow_expansion = allow_name_expansion;
1152 	}
1153       else if (!entry->is_nspace)
1154 	goto clash;
1155       else if (entry->allow_expansion != allow_name_expansion)
1156 	{
1157 	  cpp_error (pfile, CPP_DL_ICE,
1158 		     "registering pragmas in namespace \"%s\" with mismatched "
1159 		     "name expansion", space);
1160 	  return NULL;
1161 	}
1162       chain = &entry->u.space;
1163     }
1164   else if (allow_name_expansion)
1165     {
1166       cpp_error (pfile, CPP_DL_ICE,
1167 		 "registering pragma \"%s\" with name expansion "
1168 		 "and no namespace", name);
1169       return NULL;
1170     }
1171 
1172   /* Check for duplicates.  */
1173   node = cpp_lookup (pfile, UC name, strlen (name));
1174   entry = lookup_pragma_entry (*chain, node);
1175   if (entry == NULL)
1176     {
1177       entry = new_pragma_entry (pfile, chain);
1178       entry->pragma = node;
1179       return entry;
1180     }
1181 
1182   if (entry->is_nspace)
1183     clash:
1184     cpp_error (pfile, CPP_DL_ICE,
1185 	       "registering \"%s\" as both a pragma and a pragma namespace",
1186 	       NODE_NAME (node));
1187   else if (space)
1188     cpp_error (pfile, CPP_DL_ICE, "#pragma %s %s is already registered",
1189 	       space, name);
1190   else
1191     cpp_error (pfile, CPP_DL_ICE, "#pragma %s is already registered", name);
1192 
1193   return NULL;
1194 }
1195 
1196 /* Register a cpplib internal pragma SPACE NAME with HANDLER.  */
1197 static void
register_pragma_internal(cpp_reader * pfile,const char * space,const char * name,pragma_cb handler)1198 register_pragma_internal (cpp_reader *pfile, const char *space,
1199 			  const char *name, pragma_cb handler)
1200 {
1201   struct pragma_entry *entry;
1202 
1203   entry = register_pragma_1 (pfile, space, name, false);
1204   entry->is_internal = true;
1205   entry->u.handler = handler;
1206 }
1207 
1208 /* Register a pragma NAME in namespace SPACE.  If SPACE is null, it
1209    goes in the global namespace.  HANDLER is the handler it will call,
1210    which must be non-NULL.  If ALLOW_EXPANSION is set, allow macro
1211    expansion while parsing pragma NAME.  This function is exported
1212    from libcpp. */
1213 void
cpp_register_pragma(cpp_reader * pfile,const char * space,const char * name,pragma_cb handler,bool allow_expansion)1214 cpp_register_pragma (cpp_reader *pfile, const char *space, const char *name,
1215 		     pragma_cb handler, bool allow_expansion)
1216 {
1217   struct pragma_entry *entry;
1218 
1219   if (!handler)
1220     {
1221       cpp_error (pfile, CPP_DL_ICE, "registering pragma with NULL handler");
1222       return;
1223     }
1224 
1225   entry = register_pragma_1 (pfile, space, name, false);
1226   if (entry)
1227     {
1228       entry->allow_expansion = allow_expansion;
1229       entry->u.handler = handler;
1230     }
1231 }
1232 
1233 /* Similarly, but create mark the pragma for deferred processing.
1234    When found, a CPP_PRAGMA token will be insertted into the stream
1235    with IDENT in the token->u.pragma slot.  */
1236 void
cpp_register_deferred_pragma(cpp_reader * pfile,const char * space,const char * name,unsigned int ident,bool allow_expansion,bool allow_name_expansion)1237 cpp_register_deferred_pragma (cpp_reader *pfile, const char *space,
1238 			      const char *name, unsigned int ident,
1239 			      bool allow_expansion, bool allow_name_expansion)
1240 {
1241   struct pragma_entry *entry;
1242 
1243   entry = register_pragma_1 (pfile, space, name, allow_name_expansion);
1244   if (entry)
1245     {
1246       entry->is_deferred = true;
1247       entry->allow_expansion = allow_expansion;
1248       entry->u.ident = ident;
1249     }
1250 }
1251 
1252 /* Register the pragmas the preprocessor itself handles.  */
1253 void
_cpp_init_internal_pragmas(cpp_reader * pfile)1254 _cpp_init_internal_pragmas (cpp_reader *pfile)
1255 {
1256   /* Pragmas in the global namespace.  */
1257   register_pragma_internal (pfile, 0, "once", do_pragma_once);
1258   register_pragma_internal (pfile, 0, "push_macro", do_pragma_push_macro);
1259   register_pragma_internal (pfile, 0, "pop_macro", do_pragma_pop_macro);
1260 
1261   /* New GCC-specific pragmas should be put in the GCC namespace.  */
1262   register_pragma_internal (pfile, "GCC", "poison", do_pragma_poison);
1263   register_pragma_internal (pfile, "GCC", "system_header",
1264 			    do_pragma_system_header);
1265   register_pragma_internal (pfile, "GCC", "dependency", do_pragma_dependency);
1266 }
1267 
1268 /* Return the number of registered pragmas in PE.  */
1269 
1270 static int
count_registered_pragmas(struct pragma_entry * pe)1271 count_registered_pragmas (struct pragma_entry *pe)
1272 {
1273   int ct = 0;
1274   for (; pe != NULL; pe = pe->next)
1275     {
1276       if (pe->is_nspace)
1277 	ct += count_registered_pragmas (pe->u.space);
1278       ct++;
1279     }
1280   return ct;
1281 }
1282 
1283 /* Save into SD the names of the registered pragmas referenced by PE,
1284    and return a pointer to the next free space in SD.  */
1285 
1286 static char **
save_registered_pragmas(struct pragma_entry * pe,char ** sd)1287 save_registered_pragmas (struct pragma_entry *pe, char **sd)
1288 {
1289   for (; pe != NULL; pe = pe->next)
1290     {
1291       if (pe->is_nspace)
1292 	sd = save_registered_pragmas (pe->u.space, sd);
1293       *sd++ = (char *) xmemdup (HT_STR (&pe->pragma->ident),
1294                                 HT_LEN (&pe->pragma->ident),
1295                                 HT_LEN (&pe->pragma->ident) + 1);
1296     }
1297   return sd;
1298 }
1299 
1300 /* Return a newly-allocated array which saves the names of the
1301    registered pragmas.  */
1302 
1303 char **
_cpp_save_pragma_names(cpp_reader * pfile)1304 _cpp_save_pragma_names (cpp_reader *pfile)
1305 {
1306   int ct = count_registered_pragmas (pfile->pragmas);
1307   char **result = XNEWVEC (char *, ct);
1308   (void) save_registered_pragmas (pfile->pragmas, result);
1309   return result;
1310 }
1311 
1312 /* Restore from SD the names of the registered pragmas referenced by PE,
1313    and return a pointer to the next unused name in SD.  */
1314 
1315 static char **
restore_registered_pragmas(cpp_reader * pfile,struct pragma_entry * pe,char ** sd)1316 restore_registered_pragmas (cpp_reader *pfile, struct pragma_entry *pe,
1317 			    char **sd)
1318 {
1319   for (; pe != NULL; pe = pe->next)
1320     {
1321       if (pe->is_nspace)
1322 	sd = restore_registered_pragmas (pfile, pe->u.space, sd);
1323       pe->pragma = cpp_lookup (pfile, UC *sd, strlen (*sd));
1324       free (*sd);
1325       sd++;
1326     }
1327   return sd;
1328 }
1329 
1330 /* Restore the names of the registered pragmas from SAVED.  */
1331 
1332 void
_cpp_restore_pragma_names(cpp_reader * pfile,char ** saved)1333 _cpp_restore_pragma_names (cpp_reader *pfile, char **saved)
1334 {
1335   (void) restore_registered_pragmas (pfile, pfile->pragmas, saved);
1336   free (saved);
1337 }
1338 
1339 /* Pragmata handling.  We handle some, and pass the rest on to the
1340    front end.  C99 defines three pragmas and says that no macro
1341    expansion is to be performed on them; whether or not macro
1342    expansion happens for other pragmas is implementation defined.
1343    This implementation allows for a mix of both, since GCC did not
1344    traditionally macro expand its (few) pragmas, whereas OpenMP
1345    specifies that macro expansion should happen.  */
1346 static void
do_pragma(cpp_reader * pfile)1347 do_pragma (cpp_reader *pfile)
1348 {
1349   const struct pragma_entry *p = NULL;
1350   const cpp_token *token, *pragma_token = pfile->cur_token;
1351   cpp_token ns_token;
1352   unsigned int count = 1;
1353 
1354   pfile->state.prevent_expansion++;
1355 
1356   token = cpp_get_token (pfile);
1357   ns_token = *token;
1358   if (token->type == CPP_NAME)
1359     {
1360       p = lookup_pragma_entry (pfile->pragmas, token->val.node.node);
1361       if (p && p->is_nspace)
1362 	{
1363 	  bool allow_name_expansion = p->allow_expansion;
1364 	  if (allow_name_expansion)
1365 	    {
1366 	      pfile->state.prevent_expansion--;
1367 	      /*
1368 		Kludge ahead.
1369 
1370 		Consider this code snippet:
1371 
1372 		#define P parallel
1373 		#pragma omp P for
1374 		... a for loop ...
1375 
1376 		Once we parsed the 'omp' namespace of the #pragma
1377 		directive, we then parse the 'P' token that represents the
1378 		pragma name.  P being a macro, it is expanded into the
1379 		resulting 'parallel' token.
1380 
1381 		At this point the 'p' variable contains the 'parallel'
1382 		pragma name.  And pfile->context->macro is non-null
1383 		because we are still right at the end of the macro
1384 		context of 'P'.  The problem is, if we are being
1385 		(indirectly) called by cpp_get_token_with_location,
1386 		that function might test pfile->context->macro to see
1387 		if we are in the context of a macro expansion, (and we
1388 		are) and then use pfile->invocation_location as the
1389 		location of the macro invocation.  So we must instruct
1390 		cpp_get_token below to set
1391 		pfile->invocation_location.  */
1392 	      pfile->set_invocation_location = true;
1393 	    }
1394 
1395 	  token = cpp_get_token (pfile);
1396 	  if (token->type == CPP_NAME)
1397 	    p = lookup_pragma_entry (p->u.space, token->val.node.node);
1398 	  else
1399 	    p = NULL;
1400 	  if (allow_name_expansion)
1401 	    pfile->state.prevent_expansion++;
1402 	  count = 2;
1403 	}
1404     }
1405 
1406   if (p)
1407     {
1408       if (p->is_deferred)
1409 	{
1410 	  pfile->directive_result.src_loc = pragma_token->src_loc;
1411 	  pfile->directive_result.type = CPP_PRAGMA;
1412 	  pfile->directive_result.flags = pragma_token->flags;
1413 	  pfile->directive_result.val.pragma = p->u.ident;
1414 	  pfile->state.in_deferred_pragma = true;
1415 	  pfile->state.pragma_allow_expansion = p->allow_expansion;
1416 	  if (!p->allow_expansion)
1417 	    pfile->state.prevent_expansion++;
1418 	}
1419       else
1420 	{
1421 	  /* Since the handler below doesn't get the line number, that
1422 	     it might need for diagnostics, make sure it has the right
1423 	     numbers in place.  */
1424 	  if (pfile->cb.line_change)
1425 	    (*pfile->cb.line_change) (pfile, pragma_token, false);
1426 	  if (p->allow_expansion)
1427 	    pfile->state.prevent_expansion--;
1428 	  (*p->u.handler) (pfile);
1429 	  if (p->allow_expansion)
1430 	    pfile->state.prevent_expansion++;
1431 	}
1432     }
1433   else if (pfile->cb.def_pragma)
1434     {
1435       if (count == 1 || pfile->context->prev == NULL)
1436 	_cpp_backup_tokens (pfile, count);
1437       else
1438 	{
1439 	  /* Invalid name comes from macro expansion, _cpp_backup_tokens
1440 	     won't allow backing 2 tokens.  */
1441 	  /* ??? The token buffer is leaked.  Perhaps if def_pragma hook
1442 	     reads both tokens, we could perhaps free it, but if it doesn't,
1443 	     we don't know the exact lifespan.  */
1444 	  cpp_token *toks = XNEWVEC (cpp_token, 2);
1445 	  toks[0] = ns_token;
1446 	  toks[0].flags |= NO_EXPAND;
1447 	  toks[1] = *token;
1448 	  toks[1].flags |= NO_EXPAND;
1449 	  _cpp_push_token_context (pfile, NULL, toks, 2);
1450 	}
1451       pfile->cb.def_pragma (pfile, pfile->directive_line);
1452     }
1453 
1454   pfile->state.prevent_expansion--;
1455 }
1456 
1457 /* Handle #pragma once.  */
1458 static void
do_pragma_once(cpp_reader * pfile)1459 do_pragma_once (cpp_reader *pfile)
1460 {
1461   if (cpp_in_primary_file (pfile))
1462     cpp_error (pfile, CPP_DL_WARNING, "#pragma once in main file");
1463 
1464   check_eol (pfile, false);
1465   _cpp_mark_file_once_only (pfile, pfile->buffer->file);
1466 }
1467 
1468 /* Handle #pragma push_macro(STRING).  */
1469 static void
do_pragma_push_macro(cpp_reader * pfile)1470 do_pragma_push_macro (cpp_reader *pfile)
1471 {
1472   cpp_hashnode *node;
1473   size_t defnlen;
1474   const uchar *defn = NULL;
1475   char *macroname, *dest;
1476   const char *limit, *src;
1477   const cpp_token *txt;
1478   struct def_pragma_macro *c;
1479 
1480   txt = get__Pragma_string (pfile);
1481   if (!txt)
1482     {
1483       source_location src_loc = pfile->cur_token[-1].src_loc;
1484       cpp_error_with_line (pfile, CPP_DL_ERROR, src_loc, 0,
1485 		 "invalid #pragma push_macro directive");
1486       check_eol (pfile, false);
1487       skip_rest_of_line (pfile);
1488       return;
1489     }
1490   dest = macroname = (char *) alloca (txt->val.str.len + 2);
1491   src = (const char *) (txt->val.str.text + 1 + (txt->val.str.text[0] == 'L'));
1492   limit = (const char *) (txt->val.str.text + txt->val.str.len - 1);
1493   while (src < limit)
1494     {
1495       /* We know there is a character following the backslash.  */
1496       if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1497 	src++;
1498       *dest++ = *src++;
1499     }
1500   *dest = 0;
1501   check_eol (pfile, false);
1502   skip_rest_of_line (pfile);
1503   c = XNEW (struct def_pragma_macro);
1504   memset (c, 0, sizeof (struct def_pragma_macro));
1505   c->name = XNEWVAR (char, strlen (macroname) + 1);
1506   strcpy (c->name, macroname);
1507   c->next = pfile->pushed_macros;
1508   node = _cpp_lex_identifier (pfile, c->name);
1509   if (node->type == NT_VOID)
1510     c->is_undef = 1;
1511   else
1512     {
1513       defn = cpp_macro_definition (pfile, node);
1514       defnlen = ustrlen (defn);
1515       c->definition = XNEWVEC (uchar, defnlen + 2);
1516       c->definition[defnlen] = '\n';
1517       c->definition[defnlen + 1] = 0;
1518       c->line = node->value.macro->line;
1519       c->syshdr = node->value.macro->syshdr;
1520       c->used = node->value.macro->used;
1521       memcpy (c->definition, defn, defnlen);
1522     }
1523 
1524   pfile->pushed_macros = c;
1525 }
1526 
1527 /* Handle #pragma pop_macro(STRING).  */
1528 static void
do_pragma_pop_macro(cpp_reader * pfile)1529 do_pragma_pop_macro (cpp_reader *pfile)
1530 {
1531   char *macroname, *dest;
1532   const char *limit, *src;
1533   const cpp_token *txt;
1534   struct def_pragma_macro *l = NULL, *c = pfile->pushed_macros;
1535   txt = get__Pragma_string (pfile);
1536   if (!txt)
1537     {
1538       source_location src_loc = pfile->cur_token[-1].src_loc;
1539       cpp_error_with_line (pfile, CPP_DL_ERROR, src_loc, 0,
1540 		 "invalid #pragma pop_macro directive");
1541       check_eol (pfile, false);
1542       skip_rest_of_line (pfile);
1543       return;
1544     }
1545   dest = macroname = (char *) alloca (txt->val.str.len + 2);
1546   src = (const char *) (txt->val.str.text + 1 + (txt->val.str.text[0] == 'L'));
1547   limit = (const char *) (txt->val.str.text + txt->val.str.len - 1);
1548   while (src < limit)
1549     {
1550       /* We know there is a character following the backslash.  */
1551       if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1552 	src++;
1553       *dest++ = *src++;
1554     }
1555   *dest = 0;
1556   check_eol (pfile, false);
1557   skip_rest_of_line (pfile);
1558 
1559   while (c != NULL)
1560     {
1561       if (!strcmp (c->name, macroname))
1562 	{
1563 	  if (!l)
1564 	    pfile->pushed_macros = c->next;
1565 	  else
1566 	    l->next = c->next;
1567 	  cpp_pop_definition (pfile, c);
1568 	  free (c->definition);
1569 	  free (c->name);
1570 	  free (c);
1571 	  break;
1572 	}
1573       l = c;
1574       c = c->next;
1575     }
1576 }
1577 
1578 /* Handle #pragma GCC poison, to poison one or more identifiers so
1579    that the lexer produces a hard error for each subsequent usage.  */
1580 static void
do_pragma_poison(cpp_reader * pfile)1581 do_pragma_poison (cpp_reader *pfile)
1582 {
1583   const cpp_token *tok;
1584   cpp_hashnode *hp;
1585 
1586   pfile->state.poisoned_ok = 1;
1587   for (;;)
1588     {
1589       tok = _cpp_lex_token (pfile);
1590       if (tok->type == CPP_EOF)
1591 	break;
1592       if (tok->type != CPP_NAME)
1593 	{
1594 	  cpp_error (pfile, CPP_DL_ERROR,
1595 		     "invalid #pragma GCC poison directive");
1596 	  break;
1597 	}
1598 
1599       hp = tok->val.node.node;
1600       if (hp->flags & NODE_POISONED)
1601 	continue;
1602 
1603       if (hp->type == NT_MACRO)
1604 	cpp_error (pfile, CPP_DL_WARNING, "poisoning existing macro \"%s\"",
1605 		   NODE_NAME (hp));
1606       _cpp_free_definition (hp);
1607       hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1608     }
1609   pfile->state.poisoned_ok = 0;
1610 }
1611 
1612 /* Mark the current header as a system header.  This will suppress
1613    some categories of warnings (notably those from -pedantic).  It is
1614    intended for use in system libraries that cannot be implemented in
1615    conforming C, but cannot be certain that their headers appear in a
1616    system include directory.  To prevent abuse, it is rejected in the
1617    primary source file.  */
1618 static void
do_pragma_system_header(cpp_reader * pfile)1619 do_pragma_system_header (cpp_reader *pfile)
1620 {
1621   if (cpp_in_primary_file (pfile))
1622     cpp_error (pfile, CPP_DL_WARNING,
1623 	       "#pragma system_header ignored outside include file");
1624   else
1625     {
1626       check_eol (pfile, false);
1627       skip_rest_of_line (pfile);
1628       cpp_make_system_header (pfile, 1, 0);
1629     }
1630 }
1631 
1632 /* Check the modified date of the current include file against a specified
1633    file. Issue a diagnostic, if the specified file is newer. We use this to
1634    determine if a fixed header should be refixed.  */
1635 static void
do_pragma_dependency(cpp_reader * pfile)1636 do_pragma_dependency (cpp_reader *pfile)
1637 {
1638   const char *fname;
1639   int angle_brackets, ordering;
1640   source_location location;
1641 
1642   fname = parse_include (pfile, &angle_brackets, NULL, &location);
1643   if (!fname)
1644     return;
1645 
1646   ordering = _cpp_compare_file_date (pfile, fname, angle_brackets);
1647   if (ordering < 0)
1648     cpp_error (pfile, CPP_DL_WARNING, "cannot find source file %s", fname);
1649   else if (ordering > 0)
1650     {
1651       cpp_error (pfile, CPP_DL_WARNING,
1652 		 "current file is older than %s", fname);
1653       if (cpp_get_token (pfile)->type != CPP_EOF)
1654 	{
1655 	  _cpp_backup_tokens (pfile, 1);
1656 	  do_diagnostic (pfile, CPP_DL_WARNING, 0, 0);
1657 	}
1658     }
1659 
1660   free ((void *) fname);
1661 }
1662 
1663 /* Get a token but skip padding.  */
1664 static const cpp_token *
get_token_no_padding(cpp_reader * pfile)1665 get_token_no_padding (cpp_reader *pfile)
1666 {
1667   for (;;)
1668     {
1669       const cpp_token *result = cpp_get_token (pfile);
1670       if (result->type != CPP_PADDING)
1671 	return result;
1672     }
1673 }
1674 
1675 /* Check syntax is "(string-literal)".  Returns the string on success,
1676    or NULL on failure.  */
1677 static const cpp_token *
get__Pragma_string(cpp_reader * pfile)1678 get__Pragma_string (cpp_reader *pfile)
1679 {
1680   const cpp_token *string;
1681   const cpp_token *paren;
1682 
1683   paren = get_token_no_padding (pfile);
1684   if (paren->type == CPP_EOF)
1685     _cpp_backup_tokens (pfile, 1);
1686   if (paren->type != CPP_OPEN_PAREN)
1687     return NULL;
1688 
1689   string = get_token_no_padding (pfile);
1690   if (string->type == CPP_EOF)
1691     _cpp_backup_tokens (pfile, 1);
1692   if (string->type != CPP_STRING && string->type != CPP_WSTRING
1693       && string->type != CPP_STRING32 && string->type != CPP_STRING16
1694       && string->type != CPP_UTF8STRING)
1695     return NULL;
1696 
1697   paren = get_token_no_padding (pfile);
1698   if (paren->type == CPP_EOF)
1699     _cpp_backup_tokens (pfile, 1);
1700   if (paren->type != CPP_CLOSE_PAREN)
1701     return NULL;
1702 
1703   return string;
1704 }
1705 
1706 /* Destringize IN into a temporary buffer, by removing the first \ of
1707    \" and \\ sequences, and process the result as a #pragma directive.  */
1708 static void
destringize_and_run(cpp_reader * pfile,const cpp_string * in)1709 destringize_and_run (cpp_reader *pfile, const cpp_string *in)
1710 {
1711   const unsigned char *src, *limit;
1712   char *dest, *result;
1713   cpp_context *saved_context;
1714   cpp_token *saved_cur_token;
1715   tokenrun *saved_cur_run;
1716   cpp_token *toks;
1717   int count;
1718   const struct directive *save_directive;
1719 
1720   dest = result = (char *) alloca (in->len - 1);
1721   src = in->text + 1 + (in->text[0] == 'L');
1722   limit = in->text + in->len - 1;
1723   while (src < limit)
1724     {
1725       /* We know there is a character following the backslash.  */
1726       if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1727 	src++;
1728       *dest++ = *src++;
1729     }
1730   *dest = '\n';
1731 
1732   /* Ugh; an awful kludge.  We are really not set up to be lexing
1733      tokens when in the middle of a macro expansion.  Use a new
1734      context to force cpp_get_token to lex, and so skip_rest_of_line
1735      doesn't go beyond the end of the text.  Also, remember the
1736      current lexing position so we can return to it later.
1737 
1738      Something like line-at-a-time lexing should remove the need for
1739      this.  */
1740   saved_context = pfile->context;
1741   saved_cur_token = pfile->cur_token;
1742   saved_cur_run = pfile->cur_run;
1743 
1744   pfile->context = XNEW (cpp_context);
1745   pfile->context->c.macro = 0;
1746   pfile->context->prev = 0;
1747   pfile->context->next = 0;
1748 
1749   /* Inline run_directive, since we need to delay the _cpp_pop_buffer
1750      until we've read all of the tokens that we want.  */
1751   cpp_push_buffer (pfile, (const uchar *) result, dest - result,
1752 		   /* from_stage3 */ true);
1753   /* ??? Antique Disgusting Hack.  What does this do?  */
1754   if (pfile->buffer->prev)
1755     pfile->buffer->file = pfile->buffer->prev->file;
1756 
1757   start_directive (pfile);
1758   _cpp_clean_line (pfile);
1759   save_directive = pfile->directive;
1760   pfile->directive = &dtable[T_PRAGMA];
1761   do_pragma (pfile);
1762   end_directive (pfile, 1);
1763   pfile->directive = save_directive;
1764 
1765   /* We always insert at least one token, the directive result.  It'll
1766      either be a CPP_PADDING or a CPP_PRAGMA.  In the later case, we
1767      need to insert *all* of the tokens, including the CPP_PRAGMA_EOL.  */
1768 
1769   /* If we're not handling the pragma internally, read all of the tokens from
1770      the string buffer now, while the string buffer is still installed.  */
1771   /* ??? Note that the token buffer allocated here is leaked.  It's not clear
1772      to me what the true lifespan of the tokens are.  It would appear that
1773      the lifespan is the entire parse of the main input stream, in which case
1774      this may not be wrong.  */
1775   if (pfile->directive_result.type == CPP_PRAGMA)
1776     {
1777       int maxcount;
1778 
1779       count = 1;
1780       maxcount = 50;
1781       toks = XNEWVEC (cpp_token, maxcount);
1782       toks[0] = pfile->directive_result;
1783 
1784       do
1785 	{
1786 	  if (count == maxcount)
1787 	    {
1788 	      maxcount = maxcount * 3 / 2;
1789 	      toks = XRESIZEVEC (cpp_token, toks, maxcount);
1790 	    }
1791 	  toks[count] = *cpp_get_token (pfile);
1792 	  /* Macros have been already expanded by cpp_get_token
1793 	     if the pragma allowed expansion.  */
1794 	  toks[count++].flags |= NO_EXPAND;
1795 	}
1796       while (toks[count-1].type != CPP_PRAGMA_EOL);
1797     }
1798   else
1799     {
1800       count = 1;
1801       toks = XNEW (cpp_token);
1802       toks[0] = pfile->directive_result;
1803 
1804       /* If we handled the entire pragma internally, make sure we get the
1805 	 line number correct for the next token.  */
1806       if (pfile->cb.line_change)
1807 	pfile->cb.line_change (pfile, pfile->cur_token, false);
1808     }
1809 
1810   /* Finish inlining run_directive.  */
1811   pfile->buffer->file = NULL;
1812   _cpp_pop_buffer (pfile);
1813 
1814   /* Reset the old macro state before ...  */
1815   XDELETE (pfile->context);
1816   pfile->context = saved_context;
1817   pfile->cur_token = saved_cur_token;
1818   pfile->cur_run = saved_cur_run;
1819 
1820   /* ... inserting the new tokens we collected.  */
1821   _cpp_push_token_context (pfile, NULL, toks, count);
1822 }
1823 
1824 /* Handle the _Pragma operator.  Return 0 on error, 1 if ok.  */
1825 int
_cpp_do__Pragma(cpp_reader * pfile)1826 _cpp_do__Pragma (cpp_reader *pfile)
1827 {
1828   const cpp_token *string = get__Pragma_string (pfile);
1829   pfile->directive_result.type = CPP_PADDING;
1830 
1831   if (string)
1832     {
1833       destringize_and_run (pfile, &string->val.str);
1834       return 1;
1835     }
1836   cpp_error (pfile, CPP_DL_ERROR,
1837 	     "_Pragma takes a parenthesized string literal");
1838   return 0;
1839 }
1840 
1841 /* Handle #ifdef.  */
1842 static void
do_ifdef(cpp_reader * pfile)1843 do_ifdef (cpp_reader *pfile)
1844 {
1845   int skip = 1;
1846 
1847   if (! pfile->state.skipping)
1848     {
1849       cpp_hashnode *node = lex_macro_node (pfile, false);
1850 
1851       if (node)
1852 	{
1853 	  /* Do not treat conditional macros as being defined.  This is due to
1854 	     the powerpc and spu ports using conditional macros for 'vector',
1855 	     'bool', and 'pixel' to act as conditional keywords.  This messes
1856 	     up tests like #ifndef bool.  */
1857 	  skip = (node->type != NT_MACRO
1858 		  || ((node->flags & NODE_CONDITIONAL) != 0));
1859 	  _cpp_mark_macro_used (node);
1860 	  if (!(node->flags & NODE_USED))
1861 	    {
1862 	      node->flags |= NODE_USED;
1863 	      if (node->type == NT_MACRO)
1864 		{
1865 		  if ((node->flags & NODE_BUILTIN)
1866 		      && pfile->cb.user_builtin_macro)
1867 		    pfile->cb.user_builtin_macro (pfile, node);
1868 		  if (pfile->cb.used_define)
1869 		    pfile->cb.used_define (pfile, pfile->directive_line, node);
1870 		}
1871 	      else
1872 		{
1873 		  if (pfile->cb.used_undef)
1874 		    pfile->cb.used_undef (pfile, pfile->directive_line, node);
1875 		}
1876 	    }
1877 	  if (pfile->cb.used)
1878 	    pfile->cb.used (pfile, pfile->directive_line, node);
1879 	  check_eol (pfile, false);
1880 	}
1881     }
1882 
1883   push_conditional (pfile, skip, T_IFDEF, 0);
1884 }
1885 
1886 /* Handle #ifndef.  */
1887 static void
do_ifndef(cpp_reader * pfile)1888 do_ifndef (cpp_reader *pfile)
1889 {
1890   int skip = 1;
1891   cpp_hashnode *node = 0;
1892 
1893   if (! pfile->state.skipping)
1894     {
1895       node = lex_macro_node (pfile, false);
1896 
1897       if (node)
1898 	{
1899 	  /* Do not treat conditional macros as being defined.  This is due to
1900 	     the powerpc and spu ports using conditional macros for 'vector',
1901 	     'bool', and 'pixel' to act as conditional keywords.  This messes
1902 	     up tests like #ifndef bool.  */
1903 	  skip = (node->type == NT_MACRO
1904 		  && ((node->flags & NODE_CONDITIONAL) == 0));
1905 	  _cpp_mark_macro_used (node);
1906 	  if (!(node->flags & NODE_USED))
1907 	    {
1908 	      node->flags |= NODE_USED;
1909 	      if (node->type == NT_MACRO)
1910 		{
1911 		  if ((node->flags & NODE_BUILTIN)
1912 		      && pfile->cb.user_builtin_macro)
1913 		    pfile->cb.user_builtin_macro (pfile, node);
1914 		  if (pfile->cb.used_define)
1915 		    pfile->cb.used_define (pfile, pfile->directive_line, node);
1916 		}
1917 	      else
1918 		{
1919 		  if (pfile->cb.used_undef)
1920 		    pfile->cb.used_undef (pfile, pfile->directive_line, node);
1921 		}
1922 	    }
1923 	  if (pfile->cb.used)
1924 	    pfile->cb.used (pfile, pfile->directive_line, node);
1925 	  check_eol (pfile, false);
1926 	}
1927     }
1928 
1929   push_conditional (pfile, skip, T_IFNDEF, node);
1930 }
1931 
1932 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1933    pfile->mi_ind_cmacro so we can handle multiple-include
1934    optimizations.  If macro expansion occurs in the expression, we
1935    cannot treat it as a controlling conditional, since the expansion
1936    could change in the future.  That is handled by cpp_get_token.  */
1937 static void
do_if(cpp_reader * pfile)1938 do_if (cpp_reader *pfile)
1939 {
1940   int skip = 1;
1941 
1942   if (! pfile->state.skipping)
1943     skip = _cpp_parse_expr (pfile, true) == false;
1944 
1945   push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
1946 }
1947 
1948 /* Flip skipping state if appropriate and continue without changing
1949    if_stack; this is so that the error message for missing #endif's
1950    etc. will point to the original #if.  */
1951 static void
do_else(cpp_reader * pfile)1952 do_else (cpp_reader *pfile)
1953 {
1954   cpp_buffer *buffer = pfile->buffer;
1955   struct if_stack *ifs = buffer->if_stack;
1956 
1957   if (ifs == NULL)
1958     cpp_error (pfile, CPP_DL_ERROR, "#else without #if");
1959   else
1960     {
1961       if (ifs->type == T_ELSE)
1962 	{
1963 	  cpp_error (pfile, CPP_DL_ERROR, "#else after #else");
1964 	  cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
1965 			       "the conditional began here");
1966 	}
1967       ifs->type = T_ELSE;
1968 
1969       /* Skip any future (erroneous) #elses or #elifs.  */
1970       pfile->state.skipping = ifs->skip_elses;
1971       ifs->skip_elses = true;
1972 
1973       /* Invalidate any controlling macro.  */
1974       ifs->mi_cmacro = 0;
1975 
1976       /* Only check EOL if was not originally skipping.  */
1977       if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
1978 	check_eol (pfile, false);
1979     }
1980 }
1981 
1982 /* Handle a #elif directive by not changing if_stack either.  See the
1983    comment above do_else.  */
1984 static void
do_elif(cpp_reader * pfile)1985 do_elif (cpp_reader *pfile)
1986 {
1987   cpp_buffer *buffer = pfile->buffer;
1988   struct if_stack *ifs = buffer->if_stack;
1989 
1990   if (ifs == NULL)
1991     cpp_error (pfile, CPP_DL_ERROR, "#elif without #if");
1992   else
1993     {
1994       if (ifs->type == T_ELSE)
1995 	{
1996 	  cpp_error (pfile, CPP_DL_ERROR, "#elif after #else");
1997 	  cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
1998 			       "the conditional began here");
1999 	}
2000       ifs->type = T_ELIF;
2001 
2002       if (! ifs->was_skipping)
2003 	{
2004 	  bool value;
2005 	  /* The standard mandates that the expression be parsed even
2006 	     if we are skipping elses at this point -- the lexical
2007 	     restrictions on #elif only apply to skipped groups, but
2008 	     this group is not being skipped.  Temporarily set
2009 	     skipping to false to get lexer warnings.  */
2010 	  pfile->state.skipping = 0;
2011 	  value = _cpp_parse_expr (pfile, false);
2012 	  if (ifs->skip_elses)
2013 	    pfile->state.skipping = 1;
2014 	  else
2015 	    {
2016 	      pfile->state.skipping = ! value;
2017 	      ifs->skip_elses = value;
2018 	    }
2019 	}
2020 
2021       /* Invalidate any controlling macro.  */
2022       ifs->mi_cmacro = 0;
2023     }
2024 }
2025 
2026 /* #endif pops the if stack and resets pfile->state.skipping.  */
2027 static void
do_endif(cpp_reader * pfile)2028 do_endif (cpp_reader *pfile)
2029 {
2030   cpp_buffer *buffer = pfile->buffer;
2031   struct if_stack *ifs = buffer->if_stack;
2032 
2033   if (ifs == NULL)
2034     cpp_error (pfile, CPP_DL_ERROR, "#endif without #if");
2035   else
2036     {
2037       /* Only check EOL if was not originally skipping.  */
2038       if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
2039 	check_eol (pfile, false);
2040 
2041       /* If potential control macro, we go back outside again.  */
2042       if (ifs->next == 0 && ifs->mi_cmacro)
2043 	{
2044 	  pfile->mi_valid = true;
2045 	  pfile->mi_cmacro = ifs->mi_cmacro;
2046 	}
2047 
2048       buffer->if_stack = ifs->next;
2049       pfile->state.skipping = ifs->was_skipping;
2050       obstack_free (&pfile->buffer_ob, ifs);
2051     }
2052 }
2053 
2054 /* Push an if_stack entry for a preprocessor conditional, and set
2055    pfile->state.skipping to SKIP.  If TYPE indicates the conditional
2056    is #if or #ifndef, CMACRO is a potentially controlling macro, and
2057    we need to check here that we are at the top of the file.  */
2058 static void
push_conditional(cpp_reader * pfile,int skip,int type,const cpp_hashnode * cmacro)2059 push_conditional (cpp_reader *pfile, int skip, int type,
2060 		  const cpp_hashnode *cmacro)
2061 {
2062   struct if_stack *ifs;
2063   cpp_buffer *buffer = pfile->buffer;
2064 
2065   ifs = XOBNEW (&pfile->buffer_ob, struct if_stack);
2066   ifs->line = pfile->directive_line;
2067   ifs->next = buffer->if_stack;
2068   ifs->skip_elses = pfile->state.skipping || !skip;
2069   ifs->was_skipping = pfile->state.skipping;
2070   ifs->type = type;
2071   /* This condition is effectively a test for top-of-file.  */
2072   if (pfile->mi_valid && pfile->mi_cmacro == 0)
2073     ifs->mi_cmacro = cmacro;
2074   else
2075     ifs->mi_cmacro = 0;
2076 
2077   pfile->state.skipping = skip;
2078   buffer->if_stack = ifs;
2079 }
2080 
2081 /* Read the tokens of the answer into the macro pool, in a directive
2082    of type TYPE.  Only commit the memory if we intend it as permanent
2083    storage, i.e. the #assert case.  Returns 0 on success, and sets
2084    ANSWERP to point to the answer.  PRED_LOC is the location of the
2085    predicate.  */
2086 static int
parse_answer(cpp_reader * pfile,struct answer ** answerp,int type,source_location pred_loc)2087 parse_answer (cpp_reader *pfile, struct answer **answerp, int type,
2088 	      source_location pred_loc)
2089 {
2090   const cpp_token *paren;
2091   struct answer *answer;
2092   unsigned int acount;
2093 
2094   /* In a conditional, it is legal to not have an open paren.  We
2095      should save the following token in this case.  */
2096   paren = cpp_get_token (pfile);
2097 
2098   /* If not a paren, see if we're OK.  */
2099   if (paren->type != CPP_OPEN_PAREN)
2100     {
2101       /* In a conditional no answer is a test for any answer.  It
2102          could be followed by any token.  */
2103       if (type == T_IF)
2104 	{
2105 	  _cpp_backup_tokens (pfile, 1);
2106 	  return 0;
2107 	}
2108 
2109       /* #unassert with no answer is valid - it removes all answers.  */
2110       if (type == T_UNASSERT && paren->type == CPP_EOF)
2111 	return 0;
2112 
2113       cpp_error_with_line (pfile, CPP_DL_ERROR, pred_loc, 0,
2114 			   "missing '(' after predicate");
2115       return 1;
2116     }
2117 
2118   for (acount = 0;; acount++)
2119     {
2120       size_t room_needed;
2121       const cpp_token *token = cpp_get_token (pfile);
2122       cpp_token *dest;
2123 
2124       if (token->type == CPP_CLOSE_PAREN)
2125 	break;
2126 
2127       if (token->type == CPP_EOF)
2128 	{
2129 	  cpp_error (pfile, CPP_DL_ERROR, "missing ')' to complete answer");
2130 	  return 1;
2131 	}
2132 
2133       /* struct answer includes the space for one token.  */
2134       room_needed = (sizeof (struct answer) + acount * sizeof (cpp_token));
2135 
2136       if (BUFF_ROOM (pfile->a_buff) < room_needed)
2137 	_cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer));
2138 
2139       dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount];
2140       *dest = *token;
2141 
2142       /* Drop whitespace at start, for answer equivalence purposes.  */
2143       if (acount == 0)
2144 	dest->flags &= ~PREV_WHITE;
2145     }
2146 
2147   if (acount == 0)
2148     {
2149       cpp_error (pfile, CPP_DL_ERROR, "predicate's answer is empty");
2150       return 1;
2151     }
2152 
2153   answer = (struct answer *) BUFF_FRONT (pfile->a_buff);
2154   answer->count = acount;
2155   answer->next = NULL;
2156   *answerp = answer;
2157 
2158   return 0;
2159 }
2160 
2161 /* Parses an assertion directive of type TYPE, returning a pointer to
2162    the hash node of the predicate, or 0 on error.  If an answer was
2163    supplied, it is placed in ANSWERP, otherwise it is set to 0.  */
2164 static cpp_hashnode *
parse_assertion(cpp_reader * pfile,struct answer ** answerp,int type)2165 parse_assertion (cpp_reader *pfile, struct answer **answerp, int type)
2166 {
2167   cpp_hashnode *result = 0;
2168   const cpp_token *predicate;
2169 
2170   /* We don't expand predicates or answers.  */
2171   pfile->state.prevent_expansion++;
2172 
2173   *answerp = 0;
2174   predicate = cpp_get_token (pfile);
2175   if (predicate->type == CPP_EOF)
2176     cpp_error (pfile, CPP_DL_ERROR, "assertion without predicate");
2177   else if (predicate->type != CPP_NAME)
2178     cpp_error_with_line (pfile, CPP_DL_ERROR, predicate->src_loc, 0,
2179 			 "predicate must be an identifier");
2180   else if (parse_answer (pfile, answerp, type, predicate->src_loc) == 0)
2181     {
2182       unsigned int len = NODE_LEN (predicate->val.node.node);
2183       unsigned char *sym = (unsigned char *) alloca (len + 1);
2184 
2185       /* Prefix '#' to get it out of macro namespace.  */
2186       sym[0] = '#';
2187       memcpy (sym + 1, NODE_NAME (predicate->val.node.node), len);
2188       result = cpp_lookup (pfile, sym, len + 1);
2189     }
2190 
2191   pfile->state.prevent_expansion--;
2192   return result;
2193 }
2194 
2195 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
2196    or a pointer to NULL if the answer is not in the chain.  */
2197 static struct answer **
find_answer(cpp_hashnode * node,const struct answer * candidate)2198 find_answer (cpp_hashnode *node, const struct answer *candidate)
2199 {
2200   unsigned int i;
2201   struct answer **result;
2202 
2203   for (result = &node->value.answers; *result; result = &(*result)->next)
2204     {
2205       struct answer *answer = *result;
2206 
2207       if (answer->count == candidate->count)
2208 	{
2209 	  for (i = 0; i < answer->count; i++)
2210 	    if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
2211 	      break;
2212 
2213 	  if (i == answer->count)
2214 	    break;
2215 	}
2216     }
2217 
2218   return result;
2219 }
2220 
2221 /* Test an assertion within a preprocessor conditional.  Returns
2222    nonzero on failure, zero on success.  On success, the result of
2223    the test is written into VALUE, otherwise the value 0.  */
2224 int
_cpp_test_assertion(cpp_reader * pfile,unsigned int * value)2225 _cpp_test_assertion (cpp_reader *pfile, unsigned int *value)
2226 {
2227   struct answer *answer;
2228   cpp_hashnode *node;
2229 
2230   node = parse_assertion (pfile, &answer, T_IF);
2231 
2232   /* For recovery, an erroneous assertion expression is handled as a
2233      failing assertion.  */
2234   *value = 0;
2235 
2236   if (node)
2237     *value = (node->type == NT_ASSERTION &&
2238 	      (answer == 0 || *find_answer (node, answer) != 0));
2239   else if (pfile->cur_token[-1].type == CPP_EOF)
2240     _cpp_backup_tokens (pfile, 1);
2241 
2242   /* We don't commit the memory for the answer - it's temporary only.  */
2243   return node == 0;
2244 }
2245 
2246 /* Handle #assert.  */
2247 static void
do_assert(cpp_reader * pfile)2248 do_assert (cpp_reader *pfile)
2249 {
2250   struct answer *new_answer;
2251   cpp_hashnode *node;
2252 
2253   node = parse_assertion (pfile, &new_answer, T_ASSERT);
2254   if (node)
2255     {
2256       size_t answer_size;
2257 
2258       /* Place the new answer in the answer list.  First check there
2259          is not a duplicate.  */
2260       new_answer->next = 0;
2261       if (node->type == NT_ASSERTION)
2262 	{
2263 	  if (*find_answer (node, new_answer))
2264 	    {
2265 	      cpp_error (pfile, CPP_DL_WARNING, "\"%s\" re-asserted",
2266 			 NODE_NAME (node) + 1);
2267 	      return;
2268 	    }
2269 	  new_answer->next = node->value.answers;
2270 	}
2271 
2272       answer_size = sizeof (struct answer) + ((new_answer->count - 1)
2273 					      * sizeof (cpp_token));
2274       /* Commit or allocate storage for the object.  */
2275       if (pfile->hash_table->alloc_subobject)
2276 	{
2277 	  struct answer *temp_answer = new_answer;
2278 	  new_answer = (struct answer *) pfile->hash_table->alloc_subobject
2279             (answer_size);
2280 	  memcpy (new_answer, temp_answer, answer_size);
2281 	}
2282       else
2283 	BUFF_FRONT (pfile->a_buff) += answer_size;
2284 
2285       node->type = NT_ASSERTION;
2286       node->value.answers = new_answer;
2287       check_eol (pfile, false);
2288     }
2289 }
2290 
2291 /* Handle #unassert.  */
2292 static void
do_unassert(cpp_reader * pfile)2293 do_unassert (cpp_reader *pfile)
2294 {
2295   cpp_hashnode *node;
2296   struct answer *answer;
2297 
2298   node = parse_assertion (pfile, &answer, T_UNASSERT);
2299   /* It isn't an error to #unassert something that isn't asserted.  */
2300   if (node && node->type == NT_ASSERTION)
2301     {
2302       if (answer)
2303 	{
2304 	  struct answer **p = find_answer (node, answer), *temp;
2305 
2306 	  /* Remove the answer from the list.  */
2307 	  temp = *p;
2308 	  if (temp)
2309 	    *p = temp->next;
2310 
2311 	  /* Did we free the last answer?  */
2312 	  if (node->value.answers == 0)
2313 	    node->type = NT_VOID;
2314 
2315 	  check_eol (pfile, false);
2316 	}
2317       else
2318 	_cpp_free_definition (node);
2319     }
2320 
2321   /* We don't commit the memory for the answer - it's temporary only.  */
2322 }
2323 
2324 /* These are for -D, -U, -A.  */
2325 
2326 /* Process the string STR as if it appeared as the body of a #define.
2327    If STR is just an identifier, define it with value 1.
2328    If STR has anything after the identifier, then it should
2329    be identifier=definition.  */
2330 void
cpp_define(cpp_reader * pfile,const char * str)2331 cpp_define (cpp_reader *pfile, const char *str)
2332 {
2333   char *buf;
2334   const char *p;
2335   size_t count;
2336 
2337   /* Copy the entire option so we can modify it.
2338      Change the first "=" in the string to a space.  If there is none,
2339      tack " 1" on the end.  */
2340 
2341   count = strlen (str);
2342   buf = (char *) alloca (count + 3);
2343   memcpy (buf, str, count);
2344 
2345   p = strchr (str, '=');
2346   if (p)
2347     buf[p - str] = ' ';
2348   else
2349     {
2350       buf[count++] = ' ';
2351       buf[count++] = '1';
2352     }
2353   buf[count] = '\n';
2354 
2355   run_directive (pfile, T_DEFINE, buf, count);
2356 }
2357 
2358 
2359 /* Use to build macros to be run through cpp_define() as
2360    described above.
2361    Example: cpp_define_formatted (pfile, "MACRO=%d", value);  */
2362 
2363 void
cpp_define_formatted(cpp_reader * pfile,const char * fmt,...)2364 cpp_define_formatted (cpp_reader *pfile, const char *fmt, ...)
2365 {
2366   char *ptr = NULL;
2367 
2368   va_list ap;
2369   va_start (ap, fmt);
2370   vasprintf (&ptr, fmt, ap);
2371   va_end (ap);
2372 
2373   cpp_define (pfile, ptr);
2374   free (ptr);
2375 }
2376 
2377 
2378 /* Slight variant of the above for use by initialize_builtins.  */
2379 void
_cpp_define_builtin(cpp_reader * pfile,const char * str)2380 _cpp_define_builtin (cpp_reader *pfile, const char *str)
2381 {
2382   size_t len = strlen (str);
2383   char *buf = (char *) alloca (len + 1);
2384   memcpy (buf, str, len);
2385   buf[len] = '\n';
2386   run_directive (pfile, T_DEFINE, buf, len);
2387 }
2388 
2389 /* Process MACRO as if it appeared as the body of an #undef.  */
2390 void
cpp_undef(cpp_reader * pfile,const char * macro)2391 cpp_undef (cpp_reader *pfile, const char *macro)
2392 {
2393   size_t len = strlen (macro);
2394   char *buf = (char *) alloca (len + 1);
2395   memcpy (buf, macro, len);
2396   buf[len] = '\n';
2397   run_directive (pfile, T_UNDEF, buf, len);
2398 }
2399 
2400 /* Replace a previous definition DEF of the macro STR.  If DEF is NULL,
2401    or first element is zero, then the macro should be undefined.  */
2402 static void
cpp_pop_definition(cpp_reader * pfile,struct def_pragma_macro * c)2403 cpp_pop_definition (cpp_reader *pfile, struct def_pragma_macro *c)
2404 {
2405   cpp_hashnode *node = _cpp_lex_identifier (pfile, c->name);
2406   if (node == NULL)
2407     return;
2408 
2409   if (pfile->cb.before_define)
2410     pfile->cb.before_define (pfile);
2411 
2412   if (node->type == NT_MACRO)
2413     {
2414       if (pfile->cb.undef)
2415 	pfile->cb.undef (pfile, pfile->directive_line, node);
2416       if (CPP_OPTION (pfile, warn_unused_macros))
2417 	_cpp_warn_if_unused_macro (pfile, node, NULL);
2418     }
2419   if (node->type != NT_VOID)
2420     _cpp_free_definition (node);
2421 
2422   if (c->is_undef)
2423     return;
2424   {
2425     size_t namelen;
2426     const uchar *dn;
2427     cpp_hashnode *h = NULL;
2428     cpp_buffer *nbuf;
2429 
2430     namelen = ustrcspn (c->definition, "( \n");
2431     h = cpp_lookup (pfile, c->definition, namelen);
2432     dn = c->definition + namelen;
2433 
2434     h->type = NT_VOID;
2435     h->flags &= ~(NODE_POISONED|NODE_BUILTIN|NODE_DISABLED|NODE_USED);
2436     nbuf = cpp_push_buffer (pfile, dn, ustrchr (dn, '\n') - dn, true);
2437     if (nbuf != NULL)
2438       {
2439 	_cpp_clean_line (pfile);
2440 	nbuf->sysp = 1;
2441 	if (!_cpp_create_definition (pfile, h))
2442 	  abort ();
2443 	_cpp_pop_buffer (pfile);
2444       }
2445     else
2446       abort ();
2447     h->value.macro->line = c->line;
2448     h->value.macro->syshdr = c->syshdr;
2449     h->value.macro->used = c->used;
2450   }
2451 }
2452 
2453 /* Process the string STR as if it appeared as the body of a #assert.  */
2454 void
cpp_assert(cpp_reader * pfile,const char * str)2455 cpp_assert (cpp_reader *pfile, const char *str)
2456 {
2457   handle_assertion (pfile, str, T_ASSERT);
2458 }
2459 
2460 /* Process STR as if it appeared as the body of an #unassert.  */
2461 void
cpp_unassert(cpp_reader * pfile,const char * str)2462 cpp_unassert (cpp_reader *pfile, const char *str)
2463 {
2464   handle_assertion (pfile, str, T_UNASSERT);
2465 }
2466 
2467 /* Common code for cpp_assert (-A) and cpp_unassert (-A-).  */
2468 static void
handle_assertion(cpp_reader * pfile,const char * str,int type)2469 handle_assertion (cpp_reader *pfile, const char *str, int type)
2470 {
2471   size_t count = strlen (str);
2472   const char *p = strchr (str, '=');
2473 
2474   /* Copy the entire option so we can modify it.  Change the first
2475      "=" in the string to a '(', and tack a ')' on the end.  */
2476   char *buf = (char *) alloca (count + 2);
2477 
2478   memcpy (buf, str, count);
2479   if (p)
2480     {
2481       buf[p - str] = '(';
2482       buf[count++] = ')';
2483     }
2484   buf[count] = '\n';
2485   str = buf;
2486 
2487   run_directive (pfile, type, str, count);
2488 }
2489 
2490 /* The options structure.  */
2491 cpp_options *
cpp_get_options(cpp_reader * pfile)2492 cpp_get_options (cpp_reader *pfile)
2493 {
2494   return &pfile->opts;
2495 }
2496 
2497 /* The callbacks structure.  */
2498 cpp_callbacks *
cpp_get_callbacks(cpp_reader * pfile)2499 cpp_get_callbacks (cpp_reader *pfile)
2500 {
2501   return &pfile->cb;
2502 }
2503 
2504 /* Copy the given callbacks structure to our own.  */
2505 void
cpp_set_callbacks(cpp_reader * pfile,cpp_callbacks * cb)2506 cpp_set_callbacks (cpp_reader *pfile, cpp_callbacks *cb)
2507 {
2508   pfile->cb = *cb;
2509 }
2510 
2511 /* The dependencies structure.  (Creates one if it hasn't already been.)  */
2512 struct deps *
cpp_get_deps(cpp_reader * pfile)2513 cpp_get_deps (cpp_reader *pfile)
2514 {
2515   if (!pfile->deps)
2516     pfile->deps = deps_init ();
2517   return pfile->deps;
2518 }
2519 
2520 /* Push a new buffer on the buffer stack.  Returns the new buffer; it
2521    doesn't fail.  It does not generate a file change call back; that
2522    is the responsibility of the caller.  */
2523 cpp_buffer *
cpp_push_buffer(cpp_reader * pfile,const uchar * buffer,size_t len,int from_stage3)2524 cpp_push_buffer (cpp_reader *pfile, const uchar *buffer, size_t len,
2525 		 int from_stage3)
2526 {
2527   cpp_buffer *new_buffer = XOBNEW (&pfile->buffer_ob, cpp_buffer);
2528 
2529   /* Clears, amongst other things, if_stack and mi_cmacro.  */
2530   memset (new_buffer, 0, sizeof (cpp_buffer));
2531 
2532   new_buffer->next_line = new_buffer->buf = buffer;
2533   new_buffer->rlimit = buffer + len;
2534   new_buffer->from_stage3 = from_stage3;
2535   new_buffer->prev = pfile->buffer;
2536   new_buffer->need_line = true;
2537 
2538   pfile->buffer = new_buffer;
2539 
2540   return new_buffer;
2541 }
2542 
2543 /* Pops a single buffer, with a file change call-back if appropriate.
2544    Then pushes the next -include file, if any remain.  */
2545 void
_cpp_pop_buffer(cpp_reader * pfile)2546 _cpp_pop_buffer (cpp_reader *pfile)
2547 {
2548   cpp_buffer *buffer = pfile->buffer;
2549   struct _cpp_file *inc = buffer->file;
2550   struct if_stack *ifs;
2551 
2552   /* Walk back up the conditional stack till we reach its level at
2553      entry to this file, issuing error messages.  */
2554   for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
2555     cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
2556 			 "unterminated #%s", dtable[ifs->type].name);
2557 
2558   /* In case of a missing #endif.  */
2559   pfile->state.skipping = 0;
2560 
2561   /* _cpp_do_file_change expects pfile->buffer to be the new one.  */
2562   pfile->buffer = buffer->prev;
2563 
2564   free (buffer->notes);
2565 
2566   /* Free the buffer object now; we may want to push a new buffer
2567      in _cpp_push_next_include_file.  */
2568   obstack_free (&pfile->buffer_ob, buffer);
2569 
2570   if (inc)
2571     {
2572       _cpp_pop_file_buffer (pfile, inc);
2573 
2574       _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
2575     }
2576 }
2577 
2578 /* Enter all recognized directives in the hash table.  */
2579 void
_cpp_init_directives(cpp_reader * pfile)2580 _cpp_init_directives (cpp_reader *pfile)
2581 {
2582   unsigned int i;
2583   cpp_hashnode *node;
2584 
2585   for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
2586     {
2587       node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
2588       node->is_directive = 1;
2589       node->directive_index = i;
2590     }
2591 }
2592