X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gcc%2Fcppfiles.c;h=bacb8e18ef97d06087b897bcf9fc13440b2ca547;hb=6f32162af66395b5ae357d714d8d18fb6f666feb;hp=657130400f1e088d5179d158e1373d634567d9f2;hpb=47d89cf3e65223298aef15f371a4e59511e0ad31;p=gcc.git

diff --git a/gcc/cppfiles.c b/gcc/cppfiles.c
index 657130400f1..bacb8e18ef9 100644
--- a/gcc/cppfiles.c
+++ b/gcc/cppfiles.c
@@ -95,7 +95,7 @@ static struct include_file *
 				   enum include_type));
 static struct include_file *open_file PARAMS ((cpp_reader *, const char *));
 static int read_include_file	PARAMS ((cpp_reader *, struct include_file *));
-static void stack_include_file	PARAMS ((cpp_reader *, struct include_file *));
+static bool stack_include_file	PARAMS ((cpp_reader *, struct include_file *));
 static void purge_cache 	PARAMS ((struct include_file *));
 static void destroy_node	PARAMS ((splay_tree_value));
 static int report_missing_guard		PARAMS ((splay_tree_node, void *));
@@ -248,95 +248,81 @@ open_file (pfile, filename)
 
   if (file->fd != -1 && fstat (file->fd, &file->st) == 0)
     {
+      if (!S_ISDIR (file->st.st_mode))
+	return file;
       /* If it's a directory, we return null and continue the search
 	 as the file we're looking for may appear elsewhere in the
 	 search path.  */
-      if (S_ISDIR (file->st.st_mode))
-	errno = ENOENT;
-      else
-	{
-	  /* Mark a regular, zero-length file never-reread now.  */
-	  if (S_ISREG (file->st.st_mode) && file->st.st_size == 0)
-	    {
-	      _cpp_never_reread (file);
-	      close (file->fd);
-	      file->fd = -1;
-	    }
-
-	  return file;
-	}
+      errno = ENOENT;
     }
 
-  /* Don't issue an error message if the file doesn't exist.  */
   file->err_no = errno;
-  if (errno != ENOENT && errno != ENOTDIR)
-    cpp_error_from_errno (pfile, file->name);
-
   return 0;
 }
 
-/* Place the file referenced by INC into a new buffer on PFILE's
-   stack.  If there are errors, or the file should not be re-included,
-   a null (zero-length) buffer is pushed.  */
+/* Place the file referenced by INC into a new buffer on the buffer
+   stack, unless there are errors, or the file is not re-included
+   because of e.g. multiple-include guards.  Returns true if a buffer
+   is stacked.  */
 
-static void
+static bool
 stack_include_file (pfile, inc)
      cpp_reader *pfile;
      struct include_file *inc;
 {
-  size_t len = 0;
   cpp_buffer *fp;
-  int sysp, deps_sysp;
+  int sysp;
+  const char *filename;
+
+  if (DO_NOT_REREAD (inc))
+    return false;
 
-  /* We'll try removing deps_sysp after the release of 3.0.  */
-  deps_sysp = pfile->system_include_depth != 0;
   sysp = MAX ((pfile->map ? pfile->map->sysp : 0),
 	      (inc->foundhere ? inc->foundhere->sysp : 0));
 
   /* For -M, add the file to the dependencies on its first inclusion.  */
-  if (CPP_OPTION (pfile, print_deps) > deps_sysp && !inc->include_count)
+  if (CPP_OPTION (pfile, print_deps) > sysp && !inc->include_count)
     deps_add_dep (pfile->deps, inc->name);
 
   /* Not in cache?  */
-  if (! DO_NOT_REREAD (inc) && ! inc->buffer)
+  if (! inc->buffer)
     {
-      /* If an error occurs, do not try to read this file again.  */
-      if (read_include_file (pfile, inc))
+      /* Mark a regular, zero-length file never-reread.  Zero-length
+	 files are stacked the first time, so preprocessing a main
+	 file of zero length does not raise an error.  */
+      if (S_ISREG (inc->st.st_mode) && inc->st.st_size == 0)
 	_cpp_never_reread (inc);
+      else if (read_include_file (pfile, inc))
+	{
+	  /* If an error occurs, do not try to read this file again.  */
+	  _cpp_never_reread (inc);
+	  return false;
+	}
       close (inc->fd);
       inc->fd = -1;
     }
 
-  if (! DO_NOT_REREAD (inc))
-    {
-      len = inc->st.st_size;
-      if (pfile->buffer)
-	{
-	  /* We don't want MI guard advice for the main file.  */
-	  inc->include_count++;
-
-	  /* Handle -H option.  */
-	  if (CPP_OPTION (pfile, print_include_names))
-	    {
-	      for (fp = pfile->buffer; fp; fp = fp->prev)
-		putc ('.', stderr);
-	      fprintf (stderr, " %s\n", inc->name);
-	    }
-	}
-    }
+  if (pfile->buffer)
+    /* We don't want MI guard advice for the main file.  */
+    inc->include_count++;
 
   /* Push a buffer.  */
-  fp = cpp_push_buffer (pfile, inc->buffer, len, BUF_FILE, inc->name, 0);
+  fp = cpp_push_buffer (pfile, inc->buffer, inc->st.st_size,
+			/* from_stage3 */ CPP_OPTION (pfile, preprocessed), 0);
   fp->inc = inc;
   fp->inc->refcnt++;
 
   /* Initialise controlling macro state.  */
   pfile->mi_valid = true;
   pfile->mi_cmacro = 0;
-  pfile->include_depth++;
 
   /* Generate the call back.  */
-  _cpp_do_file_change (pfile, LC_ENTER, fp->nominal_fname, 1, sysp);
+  filename = inc->name;
+  if (*filename == '\0')
+    filename = _("<stdin>");
+  _cpp_do_file_change (pfile, LC_ENTER, filename, 1, sysp);
+
+  return true;
 }
 
 /* Read the file referenced by INC into the file cache.
@@ -611,16 +597,14 @@ report_missing_guard (n, b)
   return 0;
 }
 
-/* Create a dependency, or issue an error message as appropriate.   */
+/* Create a dependency, or issue an error message as appropriate.  */
 static void
 handle_missing_header (pfile, fname, angle_brackets)
      cpp_reader *pfile;
      const char *fname;
      int angle_brackets;
 {
-  /* We will try making the RHS pfile->buffer->sysp after 3.0.  */
-  int print_dep = CPP_PRINT_DEPS(pfile) > (angle_brackets
-					   || pfile->system_include_depth);
+  int print_dep = CPP_PRINT_DEPS(pfile) > (angle_brackets || pfile->map->sysp);
 
   if (CPP_OPTION (pfile, print_deps_missing_files) && print_dep)
     {
@@ -659,13 +643,15 @@ handle_missing_header (pfile, fname, angle_brackets)
     cpp_error_from_errno (pfile, fname);
 }
 
-/* Returns non-zero if a buffer was stacked.  */
-int
+/* Handles #include-family directives, and the command line -imacros
+   and -include.  Returns true if a buffer was stacked.  */
+bool
 _cpp_execute_include (pfile, header, type)
      cpp_reader *pfile;
      const cpp_token *header;
      enum include_type type;
 {
+  bool stacked = false;
   struct include_file *inc = find_include_file (pfile, header, type);
 
   if (inc == 0)
@@ -673,18 +659,13 @@ _cpp_execute_include (pfile, header, type)
 			   header->type == CPP_HEADER_NAME);
   else if (inc != NO_INCLUDE_PATH)
     {
-      if (header->type == CPP_HEADER_NAME)
-	pfile->system_include_depth++;
-
-      stack_include_file (pfile, inc);
+      stacked = stack_include_file (pfile, inc);
 
       if (type == IT_IMPORT)
 	_cpp_never_reread (inc);
-
-      return 1;
     }
 
-  return 0;
+  return stacked;
 }
 
 /* Locate HEADER, and determine whether it is newer than the current
@@ -710,9 +691,10 @@ _cpp_compare_file_date (pfile, header)
 }
 
 
-/* Push an input buffer and load it up with the contents of FNAME.
-   If FNAME is "", read standard input.  */
-int
+/* Push an input buffer and load it up with the contents of FNAME.  If
+   FNAME is "", read standard input.  Return true if a buffer was
+   stacked.  */
+bool
 _cpp_read_file (pfile, fname)
      cpp_reader *pfile;
      const char *fname;
@@ -722,27 +704,19 @@ _cpp_read_file (pfile, fname)
   if (f == NULL)
     {
       cpp_error_from_errno (pfile, fname);
-      return 0;
+      return false;
     }
 
-  stack_include_file (pfile, f);
-  return 1;
+  return stack_include_file (pfile, f);
 }
 
 /* Do appropriate cleanup when a file buffer is popped off the input
-   stack.  */
+   stack.  Push the next -include file, if any remain.  */
 void
-_cpp_pop_file_buffer (pfile, buf)
+_cpp_pop_file_buffer (pfile, inc)
      cpp_reader *pfile;
-     cpp_buffer *buf;
+     struct include_file *inc;
 {
-  struct include_file *inc = buf->inc;
-
-  if (pfile->system_include_depth)
-    pfile->system_include_depth--;
-  if (pfile->include_depth)
-    pfile->include_depth--;
-
   /* Record the inclusion-preventing macro, which could be NULL
      meaning no controlling macro.  */
   if (pfile->mi_valid && inc->cmacro == NULL)
@@ -754,6 +728,16 @@ _cpp_pop_file_buffer (pfile, buf)
   inc->refcnt--;
   if (inc->refcnt == 0 && DO_NOT_REREAD (inc))
     purge_cache (inc);
+
+  /* Don't generate a callback for popping the main file.  */
+  if (pfile->buffer)
+    {
+      _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
+
+      /* Finally, push the next -included file, if any.  */
+      if (!pfile->buffer->prev)
+	_cpp_push_next_buffer (pfile);
+    }
 }
 
 /* Returns the first place in the include chain to start searching for
@@ -787,8 +771,7 @@ search_from (pfile, type)
       if (dlen)
 	{
 	  /* We don't guarantee NAME is null-terminated.  This saves
-	     allocating and freeing memory, and duplicating it when faking
-	     buffers in cpp_push_buffer.  Drop a trailing '/'.  */
+	     allocating and freeing memory.  Drop a trailing '/'.  */
 	  buffer->dir.name = buffer->inc->name;
 	  if (dlen > 1)
 	    dlen--;
@@ -876,7 +859,7 @@ read_name_map (pfile, dirname)
      cpp_reader *pfile;
      const char *dirname;
 {
-  register struct file_name_map_list *map_list_ptr;
+  struct file_name_map_list *map_list_ptr;
   char *name;
   FILE *f;