[gcc] GCC 4.5.0=>4.5.1

gcc/libcpp/files.c

 /* Part of CPP library.  File handling.
    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1998,
    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
    Free Software Foundation, Inc.
    Written by Per Bothner, 1994.
    Based on CCCP program by Paul Rubin, June 1986
    Adapted to ANSI C, Richard Stallman, Jan 1987
    Split out of cpplib.c, Zack Weinberg, Oct 1998
    Reimplemented, Neil Booth, Jul 2003
 
@@ skipping 270 matching lines @@
   const char *path = file->path;
   size_t len, flen;
   char *pchname;
   struct stat st;
   bool valid = false;
 
   /* No PCH on <stdin> or if not requested.  */
   if (file->name[0] == '\0' || !pfile->cb.valid_pch)
     return false;
 
+  /* If the file is not included as first include from either the toplevel
+     file or the command-line it is not a valid use of PCH.  */
+  if (pfile->all_files
+      && pfile->all_files->next_file)
+    return false;
+
   flen = strlen (path);
   len = flen + sizeof (extension);
   pchname = XNEWVEC (char, len);
   memcpy (pchname, path, flen);
   memcpy (pchname + flen, extension, sizeof (extension));
 
   if (stat (pchname, &st) == 0)
     {
       DIR *pchdir;
       struct dirent *d;
@@ skipping 73 matching lines @@
 
       if (file->err_no != ENOENT)
         {
           open_file_failed (pfile, file, 0);
           return true;
         }
 
       /* We copy the path name onto an obstack partly so that we don't
          leak the memory, but mostly so that we don't fragment the
          heap.  */
-      copy = obstack_copy0 (&pfile->nonexistent_file_ob, path,
-                            strlen (path));
+      copy = (char *) obstack_copy0 (&pfile->nonexistent_file_ob, path,
+                                     strlen (path));
       free (path);
       pp = htab_find_slot_with_hash (pfile->nonexistent_file_hash,
                                      copy, hv, INSERT);
       *pp = copy;
 
       file->path = file->name;
     }
   else
     {
       file->err_no = ENOENT; 
@@ skipping 85 matching lines @@
             {
               /* Although this file must not go in the cache, because
                  the file found might depend on things (like the current file)
                  that aren't represented in the cache, it still has to go in
                  the list of all files so that #import works.  */
               file->next_file = pfile->all_files;
               pfile->all_files = file;
               return file;
             }
 
-          open_file_failed (pfile, file, angle_brackets);
           if (invalid_pch)
             {
               cpp_error (pfile, CPP_DL_ERROR,
                "one or more PCH files were found, but they were invalid");
               if (!cpp_get_options (pfile)->warn_invalid_pch)
                 cpp_error (pfile, CPP_DL_ERROR,
                            "use -Winvalid-pch for more information");
             }
+          open_file_failed (pfile, file, angle_brackets);
           break;
         }
 
       /* Only check the cache for the starting location (done above)
          and the quote and bracket chain heads because there are no
          other possible starting points for searches.  */
       if (file->dir == pfile->bracket_include)
         saw_bracket_include = true;
       else if (file->dir == pfile->quote_include)
         saw_quote_include = true;
@@ skipping 395 matching lines @@
 {
   struct cpp_dir *dir;
   _cpp_file *file;
 
   dir = search_path_head (pfile, fname, angle_brackets, type);
   if (!dir)
     return false;
 
   file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
 
-  /* Compensate for the increment in linemap_add.  In the case of a
-     normal #include, we're currently at the start of the line
-     *following* the #include.  A separate source_location for this
-     location makes no sense (until we do the LC_LEAVE), and
-     complicates LAST_SOURCE_LINE_LOCATION.  This does not apply if we
-     found a PCH file (in which case linemap_add is not called) or we
-     were included from the command-line.  */
+  /* Compensate for the increment in linemap_add that occurs in
+     _cpp_stack_file.  In the case of a normal #include, we're
+     currently at the start of the line *following* the #include.  A
+     separate source_location for this location makes no sense (until
+     we do the LC_LEAVE), and complicates LAST_SOURCE_LINE_LOCATION.
+     This does not apply if we found a PCH file (in which case
+     linemap_add is not called) or we were included from the
+     command-line.  */
   if (file->pchname == NULL && file->err_no == 0 && type != IT_CMDLINE)
     pfile->line_table->highest_location--;
 
   return _cpp_stack_file (pfile, file, type == IT_IMPORT);
 }
 
 /* Could not open FILE.  The complication is dependency output.  */
 static void
 open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets)
 {
   int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
   bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp);
 
   errno = file->err_no;
   if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
-    deps_add_dep (pfile->deps, file->name);
+    {
+      deps_add_dep (pfile->deps, file->name);
+      /* If the preprocessor output (other than dependency information) is
+         being used, we must also flag an error.  */
+      if (CPP_OPTION (pfile, deps.need_preprocessor_output))
+        cpp_errno (pfile, CPP_DL_FATAL, file->path);
+    }
   else
     {
-      /* If we are outputting dependencies but not for this file then
-         don't error because we can still produce correct output.  */
-      if (CPP_OPTION (pfile, deps.style) && ! print_dep)
+      /* If we are not outputting dependencies, or if we are and dependencies
+         were requested for this file, or if preprocessor output is needed
+         in addition to dependency information, this is an error.
+
+         Otherwise (outputting dependencies but not for this file, and not
+         using the preprocessor output), we can still produce correct output
+         so it's only a warning.  */
+      if (CPP_OPTION (pfile, deps.style) == DEPS_NONE
+          || print_dep
+          || CPP_OPTION (pfile, deps.need_preprocessor_output))
+        cpp_errno (pfile, CPP_DL_FATAL, file->path);
+      else
         cpp_errno (pfile, CPP_DL_WARNING, file->path);
-      else
-        cpp_errno (pfile, CPP_DL_ERROR, file->path);
     }
 }
 
 /* Search in the chain beginning at HEAD for a file whose search path
    started at START_DIR != NULL.  */
 static struct file_hash_entry *
 search_cache (struct file_hash_entry *head, const cpp_dir *start_dir)
 {
   while (head && head->start_dir != start_dir)
     head = head->next;
@@ skipping 180 matching lines @@
     hname = entry->u.dir->name;
 
   return strcmp (hname, fname) == 0;
 }
 
 /* Compare entries in the nonexistent file hash table.  These are just
    strings.  */
 static int
 nonexistent_file_hash_eq (const void *p, const void *q)
 {
-  return strcmp (p, q) == 0;
+  return strcmp ((const char *) p, (const char *) q) == 0;
 }
 
 /* Initialize everything in this source file.  */
 void
 _cpp_init_files (cpp_reader *pfile)
 {
   pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
                                         NULL, xcalloc, free);
   pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
                                         NULL, xcalloc, free);
@@ skipping 641 matching lines @@
       || (! check_included && ! pchf->have_once_only))
     return false;
 
   d.size = f->st.st_size;
   d.sum_computed = false;
   d.f = f;
   d.check_included = check_included;
   return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
                   pchf_compare) != NULL;
 }