cppfiles.c interface tweak

[Neil Booth <neil at daikokuya dot co dot uk>]

I don't think cppfiles.c should be dealing with tokens.  This patch
ensures we pass filenames as strings, with an accompanying flag
indicating whether it was an angled header.  It simplifies the code
a bit; we no longer have to construct artifical tokens for -include,
for example.

This patch is preparation for changing the CPP_STRING and CPP_CHAR tokens
to carry the full spelling including quotes, and not just their contents
like they currently do.

I've also moved the check for an empty filename to cppfiles.c, since
include directives aren't the only places that filenames come from.

Neil.

	* c-ppoutput.c (cb_include): Don't take a cpp_token.
	* cppfiles.c: Don't undef strcmp.
	(find_include_file): Don't take a cpp_token.  Check for empty
	file names.
	(_cpp_execute_include, _cpp_compare_file_date): Don't take a cpp_token.
	(cpp_push_include): Simplify.
	* cpphash.h (_cpp_execute_include, _cpp_compare_file_date): Update.
	* cpplib.c (glue_header_name): Return the file name, not a cpp_token.
	(parse_include): Similary.  Don't check for zero-length filenames.
	(do_include_common, do_pragma_dependency): Update accordingly.
	* cpplib.h (struct cpp_callbacks): Change prototype of include.

Index: c-ppoutput.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-ppoutput.c,v
retrieving revision 1.4
diff -u -p -r1.4 c-ppoutput.c
--- c-ppoutput.c	15 Mar 2003 12:18:45 -0000	1.4
+++ c-ppoutput.c	21 Apr 2003 16:25:04 -0000
@@ -55,7 +55,7 @@ static void cb_line_change PARAMS ((cpp_
 static void cb_define	PARAMS ((cpp_reader *, unsigned int, cpp_hashnode *));
 static void cb_undef	PARAMS ((cpp_reader *, unsigned int, cpp_hashnode *));
 static void cb_include	PARAMS ((cpp_reader *, unsigned int,
-				 const unsigned char *, const cpp_token *));
+				 const unsigned char *, const char *, int));
 static void cb_ident	  PARAMS ((cpp_reader *, unsigned int,
 				   const cpp_string *));
 static void cb_def_pragma PARAMS ((cpp_reader *, unsigned int));
@@ -345,15 +345,18 @@ cb_undef (pfile, line, node)
 }
 
 static void
-cb_include (pfile, line, dir, header)
-     cpp_reader *pfile;
+cb_include (pfile, line, dir, header, angle_brackets)
+     cpp_reader *pfile ATTRIBUTE_UNUSED;
      unsigned int line;
      const unsigned char *dir;
-     const cpp_token *header;
+     const char *header;
+     int angle_brackets;
 {
   maybe_print_line (print.map, line);
-  fprintf (print.outf, "#%s %s\n", dir,
-	   cpp_token_as_text (pfile, header));
+  if (angle_brackets)
+    fprintf (print.outf, "#%s <%s>\n", dir, header);
+  else
+    fprintf (print.outf, "#%s \"%s\"\n", dir, header);
   print.line++;
 }
 
Index: cppfiles.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cppfiles.c,v
retrieving revision 1.167
diff -u -p -r1.167 cppfiles.c
--- cppfiles.c	19 Apr 2003 00:22:47 -0000	1.167
+++ cppfiles.c	21 Apr 2003 16:25:05 -0000
@@ -44,10 +44,6 @@ Foundation, 59 Temple Place - Suite 330,
 # define ENOTDIR 0
 #endif
 
-/* Suppress warning about function macros used w/o arguments in traditional
-   C.  It is unlikely that glibc's strcmp macro helps this file at all.  */
-#undef strcmp
-
 /* This structure is used for the table of all includes.  */
 struct include_file {
   const char *name;		/* actual path name of file */
@@ -98,7 +94,7 @@ static char *remap_filename 	PARAMS ((cp
 static struct cpp_path *search_from PARAMS ((cpp_reader *,
 						enum include_type));
 static struct include_file *
-	find_include_file PARAMS ((cpp_reader *, const cpp_token *,
+	find_include_file PARAMS ((cpp_reader *, const char *, int,
 				   enum include_type));
 static struct include_file *open_file PARAMS ((cpp_reader *, const char *));
 static struct include_file *validate_pch PARAMS ((cpp_reader *,
@@ -597,22 +593,28 @@ cpp_included (pfile, fname)
   return 0;
 }
 
-/* Search for HEADER.  Return 0 if there is no such file (or it's
+/* Search for FNAME.  Return 0 if there is no such file (or it's
    un-openable), in which case an error code will be in errno.  If
    there is no include path to use it returns NO_INCLUDE_PATH,
    otherwise an include_file structure.  If this request originates
    from a directive of TYPE #include_next, set INCLUDE_NEXT to true.  */
 static struct include_file *
-find_include_file (pfile, header, type)
+find_include_file (pfile, fname, angle_brackets, type)
      cpp_reader *pfile;
-     const cpp_token *header;
+     const char *fname;
+     int angle_brackets;
      enum include_type type;
 {
-  const char *fname = (const char *) header->val.str.text;
   struct cpp_path *path;
   struct include_file *file;
   char *name, *n;
 
+  if (*fname == '\0')
+    {
+      cpp_error (pfile, DL_ERROR, "empty file name");
+      return NO_INCLUDE_PATH;
+    }
+
   if (IS_ABSOLUTE_PATHNAME (fname))
     return open_file_pch (pfile, fname);
 
@@ -621,7 +623,7 @@ find_include_file (pfile, header, type)
      path use the normal search logic.  */
   if (type == IT_INCLUDE_NEXT && pfile->buffer->inc->foundhere)
     path = pfile->buffer->inc->foundhere->next;
-  else if (header->type == CPP_HEADER_NAME)
+  else if (angle_brackets)
     path = pfile->bracket_include;
   else
     path = search_from (pfile, type);
@@ -751,17 +753,18 @@ handle_missing_header (pfile, fname, ang
    including HEADER, and the command line -imacros and -include.
    Returns true if a buffer was stacked.  */
 bool
-_cpp_execute_include (pfile, header, type)
+_cpp_execute_include (pfile, fname, angle_brackets, type)
      cpp_reader *pfile;
-     const cpp_token *header;
+     const char *fname;
+     int angle_brackets;
      enum include_type type;
 {
   bool stacked = false;
-  struct include_file *inc = find_include_file (pfile, header, type);
+  struct include_file *inc;
 
+  inc = find_include_file (pfile, fname, angle_brackets, type);
   if (inc == 0)
-    handle_missing_header (pfile, (const char *) header->val.str.text,
-			   header->type == CPP_HEADER_NAME);
+    handle_missing_header (pfile, fname, angle_brackets);
   else if (inc != NO_INCLUDE_PATH)
     {
       stacked = stack_include_file (pfile, inc);
@@ -777,12 +780,14 @@ _cpp_execute_include (pfile, header, typ
    file.  If it cannot be located or dated, return -1, if it is newer
    newer, return 1, otherwise 0.  */
 int
-_cpp_compare_file_date (pfile, header)
+_cpp_compare_file_date (pfile, fname, angle_brackets)
      cpp_reader *pfile;
-     const cpp_token *header;
+     const char *fname;
+     int angle_brackets;
 {
-  struct include_file *inc = find_include_file (pfile, header, 0);
+  struct include_file *inc;
 
+  inc = find_include_file (pfile, fname, angle_brackets, IT_INCLUDE);
   if (inc == NULL || inc == NO_INCLUDE_PATH)
     return -1;
 
@@ -825,15 +830,9 @@ cpp_push_include (pfile, filename)
      cpp_reader *pfile;
      const char *filename;
 {
-  cpp_token header;
-
-  header.type = CPP_STRING;
-  header.val.str.text = (const unsigned char *) filename;
-  header.val.str.len = strlen (filename);
   /* Make the command line directive take up a line.  */
   pfile->line++;
-
-  return _cpp_execute_include (pfile, &header, IT_CMDLINE);
+  return _cpp_execute_include (pfile, filename, false, IT_CMDLINE);
 }
 
 /* Do appropriate cleanup when a file INC's buffer is popped off the
Index: cpphash.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cpphash.h,v
retrieving revision 1.185
diff -u -p -r1.185 cpphash.h
--- cpphash.h	20 Apr 2003 19:02:53 -0000	1.185
+++ cpphash.h	21 Apr 2003 16:25:05 -0000
@@ -498,11 +498,10 @@ extern void _cpp_destroy_hashtable	PARAM
 extern void _cpp_fake_include		PARAMS ((cpp_reader *, const char *));
 extern void _cpp_never_reread		PARAMS ((struct include_file *));
 extern bool _cpp_read_file		PARAMS ((cpp_reader *, const char *));
-extern bool _cpp_execute_include	PARAMS ((cpp_reader *,
-						 const cpp_token *,
-						 enum include_type));
-extern int _cpp_compare_file_date       PARAMS ((cpp_reader *,
-						 const cpp_token *));
+extern bool _cpp_execute_include	PARAMS ((cpp_reader *, const char *,
+						 int, enum include_type));
+extern int _cpp_compare_file_date       PARAMS ((cpp_reader *, const char *,
+						 int));
 extern void _cpp_report_missing_guards	PARAMS ((cpp_reader *));
 extern void _cpp_init_includes		PARAMS ((cpp_reader *));
 extern void _cpp_cleanup_includes	PARAMS ((cpp_reader *));
Index: cpplib.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cpplib.c,v
retrieving revision 1.333
diff -u -p -r1.333 cpplib.c
--- cpplib.c	19 Apr 2003 00:22:48 -0000	1.333
+++ cpplib.c	21 Apr 2003 16:25:05 -0000
@@ -104,8 +104,8 @@ static void directive_diagnostics
 	PARAMS ((cpp_reader *, const directive *, int));
 static void run_directive	PARAMS ((cpp_reader *, int,
 					 const char *, size_t));
-static const cpp_token *glue_header_name PARAMS ((cpp_reader *));
-static const cpp_token *parse_include PARAMS ((cpp_reader *));
+static char *glue_header_name	PARAMS ((cpp_reader *));
+static const char *parse_include PARAMS ((cpp_reader *, int *));
 static void push_conditional	PARAMS ((cpp_reader *, int, int,
 					 const cpp_hashnode *));
 static unsigned int read_flag	PARAMS ((cpp_reader *, unsigned int));
@@ -570,96 +570,89 @@ do_undef (pfile)
 
 /* Helper routine used by parse_include.  Reinterpret the current line
    as an h-char-sequence (< ... >); we are looking at the first token
-   after the <.  Returns the header as a token, or NULL on failure.  */
-static const cpp_token *
+   after the <.  Returns a malloced filename.  */
+static char *
 glue_header_name (pfile)
      cpp_reader *pfile;
 {
-  cpp_token *header = NULL;
   const cpp_token *token;
-  unsigned char *buffer;
+  char *buffer;
   size_t len, total_len = 0, capacity = 1024;
 
   /* To avoid lexed tokens overwriting our glued name, we can only
      allocate from the string pool once we've lexed everything.  */
-  buffer = (unsigned char *) xmalloc (capacity);
+  buffer = xmalloc (capacity);
   for (;;)
     {
       token = get_token_no_padding (pfile);
 
-      if (token->type == CPP_GREATER || token->type == CPP_EOF)
+      if (token->type == CPP_GREATER)
 	break;
+      if (token->type == CPP_EOF)
+	{
+	  cpp_error (pfile, DL_ERROR, "missing terminating > character");
+	  break;
+	}
 
       len = cpp_token_len (token);
       if (total_len + len > capacity)
 	{
 	  capacity = (capacity + len) * 2;
-	  buffer = (unsigned char *) xrealloc (buffer, capacity);
+	  buffer = xrealloc (buffer, capacity);
 	}
 
       if (token->flags & PREV_WHITE)
 	buffer[total_len++] = ' ';
 
-      total_len = cpp_spell_token (pfile, token, &buffer[total_len]) - buffer;
-    }
-
-  if (token->type == CPP_EOF)
-    cpp_error (pfile, DL_ERROR, "missing terminating > character");
-  else
-    {
-      unsigned char *token_mem = _cpp_unaligned_alloc (pfile, total_len + 1);
-      memcpy (token_mem, buffer, total_len);
-      token_mem[total_len] = '\0';
-
-      header = _cpp_temp_token (pfile);
-      header->type = CPP_HEADER_NAME;
-      header->flags = 0;
-      header->val.str.len = total_len;
-      header->val.str.text = token_mem;
+      total_len = (cpp_spell_token (pfile, token, (uchar *) &buffer[total_len])
+		   - (uchar *) buffer);
     }
 
-  free ((PTR) buffer);
-  return header;
+  buffer[total_len] = '\0';
+  return buffer;
 }
 
-/* Returns the header string of #include, #include_next, #import and
-   #pragma dependency.  Returns NULL on error.  */
-static const cpp_token *
-parse_include (pfile)
+/* Returns the file name of #include, #include_next, #import and
+   #pragma dependency.  The string is malloced and the caller should
+   free it.  Returns NULL on error.  */
+static const char *
+parse_include (pfile, pangle_brackets)
      cpp_reader *pfile;
+     int *pangle_brackets;
 {
-  const unsigned char *dir;
+  char *fname;
   const cpp_token *header;
 
-  if (pfile->directive == &dtable[T_PRAGMA])
-    dir = U"pragma dependency";
-  else
-    dir = pfile->directive->name;
-
   /* Allow macro expansion.  */
   header = get_token_no_padding (pfile);
-  if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
+  if (header->type == CPP_STRING || header->type == CPP_HEADER_NAME)
     {
-      if (header->type != CPP_LESS)
-	{
-	  cpp_error (pfile, DL_ERROR,
-		     "#%s expects \"FILENAME\" or <FILENAME>", dir);
-	  return NULL;
-	}
-
-      header = glue_header_name (pfile);
-      if (header == NULL)
-	return header;
+      fname = xmalloc (header->val.str.len + 1);
+      memcpy (fname, header->val.str.text, header->val.str.len);
+      fname[header->val.str.len] = '\0';
+      *pangle_brackets = header->type == CPP_HEADER_NAME;
     }
-
-  if (header->val.str.len == 0)
+  else if (header->type == CPP_LESS)
     {
-      cpp_error (pfile, DL_ERROR, "empty file name in #%s", dir);
+      fname = glue_header_name (pfile);
+      *pangle_brackets = 1;
+    }
+  else
+    {
+      const unsigned char *dir;
+
+      if (pfile->directive == &dtable[T_PRAGMA])
+	dir = U"pragma dependency";
+      else
+	dir = pfile->directive->name;
+      cpp_error (pfile, DL_ERROR, "#%s expects \"FILENAME\" or <FILENAME>",
+		 dir);
+
       return NULL;
     }
 
   check_eol (pfile);
-  return header;
+  return fname;
 }
 
 /* Handle #include, #include_next and #import.  */
@@ -668,25 +661,29 @@ do_include_common (pfile, type)
      cpp_reader *pfile;
      enum include_type type;
 {
-  const cpp_token *header = parse_include (pfile);
-  if (!header)
+  const char *fname;
+  int angle_brackets;
+
+  fname = parse_include (pfile, &angle_brackets);
+  if (!fname)
     return;
 
   /* Prevent #include recursion.  */
   if (pfile->line_maps.depth >= CPP_STACK_MAX)
+    cpp_error (pfile, DL_ERROR, "#include nested too deeply");
+  else
     {
-      cpp_error (pfile, DL_ERROR, "#include nested too deeply");
-      return;
-    }
+      /* Get out of macro context, if we are.  */
+      skip_rest_of_line (pfile);
 
-  /* Get out of macro context, if we are.  */
-  skip_rest_of_line (pfile);
+      if (pfile->cb.include)
+	(*pfile->cb.include) (pfile, pfile->directive_line,
+			      pfile->directive->name, fname, angle_brackets);
 
-  if (pfile->cb.include)
-    (*pfile->cb.include) (pfile, pfile->directive_line,
-			  pfile->directive->name, header);
+      _cpp_execute_include (pfile, fname, angle_brackets, type);
+    }
 
-  _cpp_execute_include (pfile, header, type);
+  free ((PTR) fname);
 }
 
 static void
@@ -1305,27 +1302,27 @@ static void
 do_pragma_dependency (pfile)
      cpp_reader *pfile;
 {
-  const cpp_token *header;
-  int ordering;
+  const char *fname;
+  int angle_brackets, ordering;
 
-  header = parse_include (pfile);
-  if (!header)
+  fname = parse_include (pfile, &angle_brackets);
+  if (!fname)
     return;
 
-  ordering = _cpp_compare_file_date (pfile, header);
+  ordering = _cpp_compare_file_date (pfile, fname, angle_brackets);
   if (ordering < 0)
-    cpp_error (pfile, DL_WARNING, "cannot find source %s",
-	       cpp_token_as_text (pfile, header));
+    cpp_error (pfile, DL_WARNING, "cannot find source file %s", fname);
   else if (ordering > 0)
     {
-      cpp_error (pfile, DL_WARNING, "current file is older than %s",
-		 cpp_token_as_text (pfile, header));
+      cpp_error (pfile, DL_WARNING, "current file is older than %s", fname);
       if (cpp_get_token (pfile)->type != CPP_EOF)
 	{
 	  _cpp_backup_tokens (pfile, 1);
 	  do_diagnostic (pfile, DL_WARNING, 0);
 	}
     }
+
+  free ((PTR) fname);
 }
 
 /* Get a token but skip padding.  */
Index: cpplib.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cpplib.h,v
retrieving revision 1.250
diff -u -p -r1.250 cpplib.h
--- cpplib.h	20 Mar 2003 16:46:18 -0000	1.250
+++ cpplib.h	21 Apr 2003 16:25:06 -0000
@@ -375,7 +375,7 @@ struct cpp_callbacks
   void (*line_change) PARAMS ((cpp_reader *, const cpp_token *, int));
   void (*file_change) PARAMS ((cpp_reader *, const struct line_map *));
   void (*include) PARAMS ((cpp_reader *, unsigned int,
-			   const unsigned char *, const cpp_token *));
+			   const unsigned char *, const char *, int));
   void (*define) PARAMS ((cpp_reader *, unsigned int, cpp_hashnode *));
   void (*undef) PARAMS ((cpp_reader *, unsigned int, cpp_hashnode *));
   void (*ident) PARAMS ((cpp_reader *, unsigned int, const cpp_string *));