CbC/CbC_gcc: libcpp/directives.c comparison

comparison libcpp/directives.c @ 111:04ced10e8804

gcc 7

author	kono
date	Fri, 27 Oct 2017 22:46:09 +0900
parents	f6334be47118
children	84e7813d76e9

comparison

equal deleted inserted replaced

-:561a7518be6b
+:04ced10e8804
 /* CPP Library. (Directive handling.)
-Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+Copyright (C) 1986-2017 Free Software Foundation, Inc.
-1999, 2000, 2001, 2002, 2003, 2004, 2005,
-2007, 2008, 2009, 2010 Free Software Foundation, Inc.
 Contributed by Per Bothner, 1994-95.
 Based on CCCP program by Paul Rubin, June 1986
 Adapted to ANSI C, Richard Stallman, Jan 1987
 This program is free software; you can redistribute it and/or modify it
 /* Stack of conditionals currently in progress
 (including both successful and failing conditionals).  */
 struct if_stack
 {
 struct if_stack *next;
-linenum_type line;		/* Line where condition started.  */
+source_location line;		/* Line where condition started.  */
 const cpp_hashnode *mi_cmacro;/* macro name for #ifndef around entire file */
 bool skip_elses;		/* Can future #else / #elif be skipped?  */
 bool was_skipping;		/* If were skipping on entry.  */
 int type;			/* Most recent conditional for diagnostics.  */
 };
 char **);
 static void do_pragma_once (cpp_reader *);
 static void do_pragma_poison (cpp_reader *);
 static void do_pragma_system_header (cpp_reader *);
 static void do_pragma_dependency (cpp_reader *);
+static void do_pragma_warning_or_error (cpp_reader *, bool error);
+static void do_pragma_warning (cpp_reader *);
+static void do_pragma_error (cpp_reader *);
 static void do_linemarker (cpp_reader *);
 static const cpp_token *get_token_no_padding (cpp_reader *);
 static const cpp_token *get__Pragma_string (cpp_reader *);
-static void destringize_and_run (cpp_reader *, const cpp_string *);
+static void destringize_and_run (cpp_reader *, const cpp_string *,
+				 source_location);
 static int parse_answer (cpp_reader *, struct answer **, int, source_location);
 static cpp_hashnode *parse_assertion (cpp_reader *, struct answer **, int);
 static struct answer ** find_answer (cpp_hashnode *, const struct answer *);
 static void handle_assertion (cpp_reader *, const char *, int);
 static void do_pragma_push_macro (cpp_reader *);
 static const directive dtable[] =
 {
 DIRECTIVE_TABLE
 };
 #undef D
+/* A NULL-terminated array of directive names for use
+when suggesting corrections for misspelled directives.  */
+#define D(name, t, origin, flags) #name,
+static const char * const directive_names[] = {
+DIRECTIVE_TABLE
+NULL
+};
+#undef D
 #undef DIRECTIVE_TABLE
 /* Wrapper struct directive for linemarkers.
 The origin is more or less true - the original K+R cpp
 did use this notation in its preprocessed output.  */
 if (! SEEN_EOL ())
 while (_cpp_lex_token (pfile)->type != CPP_EOF)
 ;
 }
-/* Ensure there are no stray tokens at the end of a directive.  If
+/* Helper function for check_oel.  */
-EXPAND is true, tokens macro-expanding to nothing are allowed.  */
 static void
-check_eol (cpp_reader *pfile, bool expand)
+check_eol_1 (cpp_reader *pfile, bool expand, int reason)
 {
 if (! SEEN_EOL () && (expand
 			? cpp_get_token (pfile)
 			: _cpp_lex_token (pfile))->type != CPP_EOF)
-cpp_error (pfile, CPP_DL_PEDWARN, "extra tokens at end of #%s directive",
+cpp_pedwarning (pfile, reason, "extra tokens at end of #%s directive",
-	       pfile->directive->name);
+		    pfile->directive->name);
+}
+/* Variant of check_eol used for Wendif-labels warnings.  */
+static void
+check_eol_endif_labels (cpp_reader *pfile)
+{
+check_eol_1 (pfile, false, CPP_W_ENDIF_LABELS);
+}
+/* Ensure there are no stray tokens at the end of a directive.  If
+EXPAND is true, tokens macro-expanding to nothing are allowed.  */
+static void
+check_eol (cpp_reader *pfile, bool expand)
+{
+check_eol_1 (pfile, expand, CPP_W_NONE);
 }
 /* Ensure there are no stray tokens other than comments at the end of
 a directive, and gather the comments.  */
 static const cpp_token **
 if (pfile->state.in_expression)
 	pfile->state.skipping = false;
 if (no_expand)
 	pfile->state.prevent_expansion++;
-_cpp_scan_out_logical_line (pfile, NULL);
+_cpp_scan_out_logical_line (pfile, NULL, false);
 if (no_expand)
 	pfile->state.prevent_expansion--;
 pfile->state.skipping = was_skipping;
 _cpp_overlay_buffer (pfile, pfile->out.base,
 	 -fpreprocessed mode only if the # is in column 1.  macro.c
 	 puts a space in front of any '#' at the start of a macro.
 	 We exclude the -fdirectives-only case because macro expansion
 	 has not been performed yet, and block comments can cause spaces
-	 to preceed the directive.  */
+	 to precede the directive.  */
 if (CPP_OPTION (pfile, preprocessed)
 	  && !CPP_OPTION (pfile, directives_only)
 	  && (indented || !(dir->flags & IN_I)))
 	{
 	  skip = 0;
 	 introduce assembler pseudo-ops.  Don't complain about invalid
 	 directives in skipped conditional groups (6.10 p4).  */
 if (CPP_OPTION (pfile, lang) == CLK_ASM)
 	skip = 0;
 else if (!pfile->state.skipping)
-	cpp_error (pfile, CPP_DL_ERROR, "invalid preprocessing directive #%s",
+	{
-		   cpp_token_as_text (pfile, dname));
+	  const char *unrecognized
+	    = (const char *)cpp_token_as_text (pfile, dname);
+	  const char *hint = NULL;
+	  /* Call back into gcc to get a spelling suggestion.  Ideally
+	     we'd just use best_match from gcc/spellcheck.h (and filter
+	     out the uncommon directives), but that requires moving it
+	     to a support library.  */
+	  if (pfile->cb.get_suggestion)
+	    hint = pfile->cb.get_suggestion (pfile, unrecognized,
+					     directive_names);
+	  if (hint)
+	    {
+	      rich_location richloc (pfile->line_table, dname->src_loc);
+	      source_range misspelled_token_range
+		= get_range_from_loc (pfile->line_table, dname->src_loc);
+	      richloc.add_fixit_replace (misspelled_token_range, hint);
+	      cpp_error_at_richloc (pfile, CPP_DL_ERROR, &richloc,
+				    "invalid preprocessing directive #%s;"
+				    " did you mean #%s?",
+				    unrecognized, hint);
+	    }
+	  else
+	    cpp_error (pfile, CPP_DL_ERROR,
+		       "invalid preprocessing directive #%s",
+		       unrecognized);
+	}
 }
 pfile->directive = dir;
 if (CPP_OPTION (pfile, traditional))
 prepare_directive_trad (pfile);
 cpp_hashnode *node = token->val.node.node;
 if (is_def_or_undef && node == pfile->spec_nodes.n_defined)
 	cpp_error (pfile, CPP_DL_ERROR,
 		   "\"defined\" cannot be used as a macro name");
+else if (is_def_or_undef
+	    && (node == pfile->spec_nodes.n__has_include__
+	     || node == pfile->spec_nodes.n__has_include_next__))
+	cpp_error (pfile, CPP_DL_ERROR,
+		   "\"__has_include__\" cannot be used as a macro name");
 else if (! (node->flags & NODE_POISONED))
 	return node;
 }
 else if (token->flags & NAMED_OP)
 cpp_error (pfile, CPP_DL_ERROR,
 if (node->type == NT_MACRO)
 	{
 	  if (node->flags & NODE_WARN)
 	    cpp_error (pfile, CPP_DL_WARNING,
 		       "undefining \"%s\"", NODE_NAME (node));
+	  else if ((node->flags & NODE_BUILTIN)
+		   && CPP_OPTION (pfile, warn_builtin_macro_redefined))
+	    cpp_warning_with_line (pfile, CPP_W_BUILTIN_MACRO_REDEFINED,
+				   pfile->directive_line, 0,
+				   "undefining \"%s\"", NODE_NAME (node));
 	  if (CPP_OPTION (pfile, warn_unused_macros))
 	    _cpp_warn_if_unused_macro (pfile, node, NULL);
 	  _cpp_free_definition (node);
 if (pfile->cb.include)
 	pfile->cb.include (pfile, pfile->directive_line,
 			   pfile->directive->name, fname, angle_brackets,
 			   buf);
-_cpp_stack_include (pfile, fname, angle_brackets, type);
+_cpp_stack_include (pfile, fname, angle_brackets, type, location);
 }
 XDELETEVEC (fname);
 if (buf)
 XDELETEVEC (buf);
 Note that the filename string (if any) is a true string constant
 (escapes are interpreted), unlike in #line.  */
 static void
 do_line (cpp_reader *pfile)
 {
-const struct line_maps *line_table = pfile->line_table;
+struct line_maps *line_table = pfile->line_table;
-const struct line_map *map = &line_table->maps[line_table->used - 1];
+const line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
 /* skip_rest_of_line() may cause line table to be realloc()ed so note down
 sysp right now.  */
-unsigned char map_sysp = map->sysp;
+unsigned char map_sysp = ORDINARY_MAP_IN_SYSTEM_HEADER_P (map);
 const cpp_token *token;
-const char *new_file = map->to_file;
+const char *new_file = ORDINARY_MAP_FILE_NAME (map);
 linenum_type new_lineno;
 /* C99 raised the minimum limit on #line numbers.  */
 linenum_type cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
 bool wrapped;
 }
 skip_rest_of_line (pfile);
 _cpp_do_file_change (pfile, LC_RENAME_VERBATIM, new_file, new_lineno,
 		       map_sysp);
+line_table->seen_line_directive = true;
 }
 /* Interpret the # 44 "file" [flags] notation, which has slightly
 different syntax and semantics from #line:  Flags are allowed,
 and we never complain about the line number being too big.  */
 static void
 do_linemarker (cpp_reader *pfile)
 {
-const struct line_maps *line_table = pfile->line_table;
+struct line_maps *line_table = pfile->line_table;
-const struct line_map *map = &line_table->maps[line_table->used - 1];
+const line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
 const cpp_token *token;
-const char *new_file = map->to_file;
+const char *new_file = ORDINARY_MAP_FILE_NAME (map);
 linenum_type new_lineno;
-unsigned int new_sysp = map->sysp;
+unsigned int new_sysp = ORDINARY_MAP_IN_SYSTEM_HEADER_P (map);
 enum lc_reason reason = LC_RENAME_VERBATIM;
 int flag;
 bool wrapped;
 /* Back up so we can get the number again.  Putting this in
 return;
 }
 skip_rest_of_line (pfile);
+if (reason == LC_LEAVE)
+{
+/* Reread map since cpp_get_token can invalidate it with a
+	 reallocation.  */
+map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
+const line_map_ordinary *from;
+if (MAIN_FILE_P (map)
+	  || (new_file
+	      && (from = INCLUDED_FROM (pfile->line_table, map)) != NULL
+	      && filename_cmp (ORDINARY_MAP_FILE_NAME (from), new_file) != 0))
+	{
+	  cpp_warning (pfile, CPP_W_NONE,
+		       "file \"%s\" linemarker ignored due to "
+		       "incorrect nesting", new_file);
+	  return;
+	}
+}
 /* Compensate for the increment in linemap_add that occurs in
 _cpp_do_file_change.  We're currently at the start of the line
 *following* the #line directive.  A separate source_location for this
 location makes no sense (until we do the LC_LEAVE), and
 complicates LAST_SOURCE_LINE_LOCATION.  */
 pfile->line_table->highest_location--;
 _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp);
+line_table->seen_line_directive = true;
 }
 /* Arrange the file_change callback.  pfile->line has changed to
 FILE_LINE of TO_FILE, for reason REASON.  SYSP is 1 for a system
 header, 2 for a system header that needs to be extern "C" protected,
 void
 _cpp_do_file_change (cpp_reader *pfile, enum lc_reason reason,
 		     const char *to_file, linenum_type file_line,
 		     unsigned int sysp)
 {
+linemap_assert (reason != LC_ENTER_MACRO);
 const struct line_map *map = linemap_add (pfile->line_table, reason, sysp,
 					    to_file, file_line);
+const line_map_ordinary *ord_map = NULL;
 if (map != NULL)
-linemap_line_start (pfile->line_table, map->to_line, 127);
+{
+ord_map = linemap_check_ordinary (map);
+linemap_line_start (pfile->line_table,
+			  ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map),
+			  127);
+}
 if (pfile->cb.file_change)
-pfile->cb.file_change (pfile, map);
+pfile->cb.file_change (pfile, ord_map);
 }
 /* Report a warning or error detected by the program we are
 processing.  Use the directive's tokens in the error message.  */
 static void
 /* New GCC-specific pragmas should be put in the GCC namespace.  */
 register_pragma_internal (pfile, "GCC", "poison", do_pragma_poison);
 register_pragma_internal (pfile, "GCC", "system_header",
 			    do_pragma_system_header);
 register_pragma_internal (pfile, "GCC", "dependency", do_pragma_dependency);
+register_pragma_internal (pfile, "GCC", "warning", do_pragma_warning);
+register_pragma_internal (pfile, "GCC", "error", do_pragma_error);
 }
 /* Return the number of registered pragmas in PE.  */
 static int
 specifies that macro expansion should happen.  */
 static void
 do_pragma (cpp_reader *pfile)
 {
 const struct pragma_entry *p = NULL;
-const cpp_token *token, *pragma_token = pfile->cur_token;
+const cpp_token *token, *pragma_token;
+source_location pragma_token_virt_loc = 0;
 cpp_token ns_token;
 unsigned int count = 1;
 pfile->state.prevent_expansion++;
-token = cpp_get_token (pfile);
+pragma_token = token = cpp_get_token_with_location (pfile,
+						      &pragma_token_virt_loc);
 ns_token = *token;
 if (token->type == CPP_NAME)
 {
 p = lookup_pragma_entry (pfile->pragmas, token->val.node.node);
 if (p && p->is_nspace)
 	{
 	  bool allow_name_expansion = p->allow_expansion;
 	  if (allow_name_expansion)
 	    pfile->state.prevent_expansion--;
 	  token = cpp_get_token (pfile);
 	  if (token->type == CPP_NAME)
 	    p = lookup_pragma_entry (p->u.space, token->val.node.node);
 	  else
 	    p = NULL;
 if (p)
 {
 if (p->is_deferred)
 	{
-	  pfile->directive_result.src_loc = pragma_token->src_loc;
+	  pfile->directive_result.src_loc = pragma_token_virt_loc;
 	  pfile->directive_result.type = CPP_PRAGMA;
 	  pfile->directive_result.flags = pragma_token->flags;
 	  pfile->directive_result.val.pragma = p->u.ident;
 	  pfile->state.in_deferred_pragma = true;
 	  pfile->state.pragma_allow_expansion = p->allow_expansion;
 }
 free ((void *) fname);
 }
+/* Issue a diagnostic with the message taken from the pragma.  If
+ERROR is true, the diagnostic is a warning, otherwise, it is an
+error.  */
+static void
+do_pragma_warning_or_error (cpp_reader *pfile, bool error)
+{
+const cpp_token *tok = _cpp_lex_token (pfile);
+cpp_string str;
+if (tok->type != CPP_STRING
+|| !cpp_interpret_string_notranslate (pfile, &tok->val.str, 1, &str,
+					    CPP_STRING)
+|| str.len == 0)
+{
+cpp_error (pfile, CPP_DL_ERROR, "invalid \"#pragma GCC %s\" directive",
+		 error ? "error" : "warning");
+return;
+}
+cpp_error (pfile, error ? CPP_DL_ERROR : CPP_DL_WARNING,
+	     "%s", str.text);
+free ((void *)str.text);
+}
+/* Issue a warning diagnostic.  */
+static void
+do_pragma_warning (cpp_reader *pfile)
+{
+do_pragma_warning_or_error (pfile, false);
+}
+/* Issue an error diagnostic.  */
+static void
+do_pragma_error (cpp_reader *pfile)
+{
+do_pragma_warning_or_error (pfile, true);
+}
 /* Get a token but skip padding.  */
 static const cpp_token *
 get_token_no_padding (cpp_reader *pfile)
 {
 for (;;)
 }
 /* Destringize IN into a temporary buffer, by removing the first \ of
 \" and \\ sequences, and process the result as a #pragma directive.  */
 static void
-destringize_and_run (cpp_reader *pfile, const cpp_string *in)
+destringize_and_run (cpp_reader *pfile, const cpp_string *in,
+		     source_location expansion_loc)
 {
 const unsigned char *src, *limit;
 char *dest, *result;
 cpp_context *saved_context;
 cpp_token *saved_cur_token;
 this.  */
 saved_context = pfile->context;
 saved_cur_token = pfile->cur_token;
 saved_cur_run = pfile->cur_run;
-pfile->context = XNEW (cpp_context);
+pfile->context = XCNEW (cpp_context);
-pfile->context->macro = 0;
-pfile->context->prev = 0;
-pfile->context->next = 0;
 /* Inline run_directive, since we need to delay the _cpp_pop_buffer
 until we've read all of the tokens that we want.  */
 cpp_push_buffer (pfile, (const uchar *) result, dest - result,
 		   /* from_stage3 */ true);
 	    {
 	      maxcount = maxcount * 3 / 2;
 	      toks = XRESIZEVEC (cpp_token, toks, maxcount);
 	    }
 	  toks[count] = *cpp_get_token (pfile);
+	  /* _Pragma is a builtin, so we're not within a macro-map, and so
+	     the token locations are set to bogus ordinary locations
+	     near to, but after that of the "_Pragma".
+	     Paper over this by setting them equal to the location of the
+	     _Pragma itself (PR preprocessor/69126).  */
+	  toks[count].src_loc = expansion_loc;
 	  /* Macros have been already expanded by cpp_get_token
 	     if the pragma allowed expansion.  */
 	  toks[count++].flags |= NO_EXPAND;
 	}
 while (toks[count-1].type != CPP_PRAGMA_EOL);
 _cpp_push_token_context (pfile, NULL, toks, count);
 }
 /* Handle the _Pragma operator.  Return 0 on error, 1 if ok.  */
 int
-_cpp_do__Pragma (cpp_reader *pfile)
+_cpp_do__Pragma (cpp_reader *pfile, source_location expansion_loc)
 {
 const cpp_token *string = get__Pragma_string (pfile);
 pfile->directive_result.type = CPP_PADDING;
 if (string)
 {
-destringize_and_run (pfile, &string->val.str);
+destringize_and_run (pfile, &string->val.str, expansion_loc);
 return 1;
 }
 cpp_error (pfile, CPP_DL_ERROR,
 	     "_Pragma takes a parenthesized string literal");
 return 0;
 {
 cpp_hashnode *node = lex_macro_node (pfile, false);
 if (node)
 	{
-	  skip = node->type != NT_MACRO;
+	  /* Do not treat conditional macros as being defined.  This is due to
+	     the powerpc and spu ports using conditional macros for 'vector',
+	     'bool', and 'pixel' to act as conditional keywords.  This messes
+	     up tests like #ifndef bool.  */
+	  skip = (node->type != NT_MACRO
+		  || ((node->flags & NODE_CONDITIONAL) != 0));
 	  _cpp_mark_macro_used (node);
 	  if (!(node->flags & NODE_USED))
 	    {
 	      node->flags |= NODE_USED;
 	      if (node->type == NT_MACRO)
 {
 node = lex_macro_node (pfile, false);
 if (node)
 	{
-	  skip = node->type == NT_MACRO;
+	  /* Do not treat conditional macros as being defined.  This is due to
+	     the powerpc and spu ports using conditional macros for 'vector',
+	     'bool', and 'pixel' to act as conditional keywords.  This messes
+	     up tests like #ifndef bool.  */
+	  skip = (node->type == NT_MACRO
+		  && ((node->flags & NODE_CONDITIONAL) == 0));
 	  _cpp_mark_macro_used (node);
 	  if (!(node->flags & NODE_USED))
 	    {
 	      node->flags |= NODE_USED;
 	      if (node->type == NT_MACRO)
 /* Invalidate any controlling macro.  */
 ifs->mi_cmacro = 0;
 /* Only check EOL if was not originally skipping.  */
 if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
-	check_eol (pfile, false);
+	check_eol_endif_labels (pfile);
 }
 }
 /* Handle a #elif directive by not changing if_stack either.  See the
 comment above do_else.  */
 	  cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
 			       "the conditional began here");
 	}
 ifs->type = T_ELIF;
-if (! ifs->was_skipping)
+/* See DR#412: "Only the first group whose control condition
-	{
+	 evaluates to true (nonzero) is processed; any following groups
-	  bool value;
+	 are skipped and their controlling directives are processed as
-	  /* The standard mandates that the expression be parsed even
+	 if they were in a group that is skipped."  */
-	     if we are skipping elses at this point -- the lexical
+if (ifs->skip_elses)
-	     restrictions on #elif only apply to skipped groups, but
+	pfile->state.skipping = 1;
-	     this group is not being skipped.  Temporarily set
+else
-	     skipping to false to get lexer warnings.  */
+	{
-	  pfile->state.skipping = 0;
+	  pfile->state.skipping = ! _cpp_parse_expr (pfile, false);
-	  value = _cpp_parse_expr (pfile, false);
+	  ifs->skip_elses = ! pfile->state.skipping;
-	  if (ifs->skip_elses)
-	    pfile->state.skipping = 1;
-	  else
-	    {
-	      pfile->state.skipping = ! value;
-	      ifs->skip_elses = value;
-	    }
 	}
 /* Invalidate any controlling macro.  */
 ifs->mi_cmacro = 0;
 }
 cpp_error (pfile, CPP_DL_ERROR, "#endif without #if");
 else
 {
 /* Only check EOL if was not originally skipping.  */
 if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
-	check_eol (pfile, false);
+	check_eol_endif_labels (pfile);
 /* If potential control macro, we go back outside again.  */
 if (ifs->next == 0 && ifs->mi_cmacro)
 	{
 	  pfile->mi_valid = true;
 Example: cpp_define_formatted (pfile, "MACRO=%d", value);  */
 void
 cpp_define_formatted (cpp_reader *pfile, const char *fmt, ...)
 {
-char *ptr = NULL;
+char *ptr;
 va_list ap;
 va_start (ap, fmt);
-vasprintf (&ptr, fmt, ap);
+ptr = xvasprintf (fmt, ap);
 va_end (ap);
 cpp_define (pfile, ptr);
 free (ptr);
 }
 _cpp_pop_buffer (cpp_reader *pfile)
 {
 cpp_buffer *buffer = pfile->buffer;
 struct _cpp_file *inc = buffer->file;
 struct if_stack *ifs;
+const unsigned char *to_free;
 /* Walk back up the conditional stack till we reach its level at
 entry to this file, issuing error messages.  */
 for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
 cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
 pfile->state.skipping = 0;
 /* _cpp_do_file_change expects pfile->buffer to be the new one.  */
 pfile->buffer = buffer->prev;
+to_free = buffer->to_free;
 free (buffer->notes);
 /* Free the buffer object now; we may want to push a new buffer
 in _cpp_push_next_include_file.  */
 obstack_free (&pfile->buffer_ob, buffer);
 if (inc)
 {
-_cpp_pop_file_buffer (pfile, inc);
+_cpp_pop_file_buffer (pfile, inc, to_free);
 _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
 }
 }
 node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
 node->is_directive = 1;
 node->directive_index = i;
 }
 }
+/* Extract header file from a bracket include. Parsing starts after '<'.
+The string is malloced and must be freed by the caller.  */
+char *
+_cpp_bracket_include(cpp_reader *pfile)
+{
+return glue_header_name (pfile);
+}

Mercurial > hg > CbC > CbC_gcc

comparison libcpp/directives.c @ 111:04ced10e8804