Daily bump.

[pf3gnuchains/gcc-fork.git] / gcc / cppfiles.c

diff --git a/gcc/cppfiles.c b/gcc/cppfiles.c
index da244be..bacb8e1 100644 (file)
--- a/gcc/cppfiles.c
+++ b/gcc/cppfiles.c
@@ -248,30 +248,15 @@ 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;
 }
 
@@ -302,9 +287,14 @@ stack_include_file (pfile, inc)
   /* Not in cache?  */
   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;
        }
@@ -313,28 +303,18 @@ stack_include_file (pfile, inc)
     }
 
   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);
-       }
-    }
+    /* We don't want MI guard advice for the main file.  */
+    inc->include_count++;
 
   /* Push a buffer.  */
-  fp = cpp_push_buffer (pfile, inc->buffer, inc->st.st_size, BUF_FILE, 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.  */
   filename = inc->name;
@@ -617,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)
     {
@@ -681,9 +659,6 @@ _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++;
-
       stacked = stack_include_file (pfile, inc);
 
       if (type == IT_IMPORT)
@@ -725,30 +700,23 @@ _cpp_read_file (pfile, fname)
      const char *fname;
 {
   struct include_file *f = open_file (pfile, fname);
-  bool stacked = false;
 
   if (f == NULL)
-    cpp_error_from_errno (pfile, fname);
-  else
-    stacked = stack_include_file (pfile, f);
+    {
+      cpp_error_from_errno (pfile, fname);
+      return false;
+    }
 
-  return stacked;
+  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)
@@ -760,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
@@ -793,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--;
@@ -882,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;