MatCat.OpenSource/8sa1-gcc
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
0fb8cb90e8
8sa1-gcc/gcc/cppfiles.c
Laurynas Biveinis ae0f4dee02 cppfiles.c (purge_cache): use munmap() only if MMAP_THRESHOLD defined. 
* cppfiles.c (purge_cache): use munmap() only if MMAP_THRESHOLD
	 defined.
	(read_include_file): Ensure inc->mmaped is initialized.

From-SVN: r36459
2000-09-16 18:17:53 +00:00

1409 lines
36 KiB
C
Raw Blame History

/* Part of CPP library. (include file handling)
Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1998,
1999, 2000 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
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#include "config.h"
#include "system.h"
#include "cpplib.h"
#include "cpphash.h"
#include "intl.h"
#include "mkdeps.h"
#include "splay-tree.h"
#ifdef HAVE_MMAP_FILE
# include <sys/mman.h>
# ifndef MMAP_THRESHOLD
# define MMAP_THRESHOLD 3 /* Minimum page count to mmap the file. */
# endif
#else /* No MMAP_FILE */
# undef MMAP_THRESHOLD
# define MMAP_THRESHOLD 0
#endif
#ifndef O_BINARY
# define O_BINARY 0
#endif
#ifndef INCLUDE_LEN_FUDGE
# define INCLUDE_LEN_FUDGE 0
#endif
/* If errno is inspected immediately after a system call fails, it will be
nonzero, and no error number will ever be zero. */
#ifndef ENOENT
# define ENOENT 0
#endif
#ifndef ENOTDIR
# define ENOTDIR 0
#endif
#ifndef ENOMEM
# define ENOMEM 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
static struct file_name_map *read_name_map
PARAMS ((cpp_reader *, const char *));
static char *read_filename_string PARAMS ((int, FILE *));
static char *remap_filename PARAMS ((cpp_reader *, char *,
struct file_name_list *));
static struct file_name_list *actual_directory
PARAMS ((cpp_reader *, const char *));
static struct include_file *find_include_file
PARAMS ((cpp_reader *, const char *,
struct file_name_list *));
static struct include_file *lookup_include_file
PARAMS ((cpp_reader *, const char *));
static int read_include_file PARAMS ((cpp_reader *, struct include_file *));
static int stack_include_file PARAMS ((cpp_reader *, struct include_file *));
static void purge_cache PARAMS ((struct include_file *));
static void destroy_include_file_node PARAMS ((splay_tree_value));
static int report_missing_guard PARAMS ((splay_tree_node, void *));
#if 0
static void hack_vms_include_specification PARAMS ((char *));
#endif
/* We use a splay tree to store information about all the include
files seen in this compilation. The key of each tree node is the
physical path to the file. The value is 0 if the file does not
exist, or a struct include_file pointer. */
static void
destroy_include_file_node (v)
splay_tree_value v;
{
struct include_file *f = (struct include_file *)v;
if (f)
{
purge_cache (f);
free (f);
}
}
void
_cpp_init_includes (pfile)
cpp_reader *pfile;
{
pfile->all_include_files
= splay_tree_new ((splay_tree_compare_fn) strcmp,
(splay_tree_delete_key_fn) free,
destroy_include_file_node);
}
void
_cpp_cleanup_includes (pfile)
cpp_reader *pfile;
{
splay_tree_delete (pfile->all_include_files);
}
/* Given a file name, look it up in the cache; if there is no entry,
create one. Returns 0 if the file doesn't exist or is
inaccessible, otherwise the cache entry. */
static struct include_file *
lookup_include_file (pfile, filename)
cpp_reader *pfile;
const char *filename;
{
splay_tree_node nd;
struct include_file *file = 0;
int fd;
struct stat st;
nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) filename);
if (nd)
return (struct include_file *)nd->value;
/* We used to open files in nonblocking mode, but that caused more
problems than it solved. Do take care not to acquire a
controlling terminal by mistake (this can't happen on sane
systems, but paranoia is a virtue).
Use the three-argument form of open even though we aren't
specifying O_CREAT, to defend against broken system headers.
O_BINARY tells some runtime libraries (notably DJGPP) not to do
newline translation; we can handle DOS line breaks just fine
ourselves.
Special case: the empty string is translated to stdin. */
if (filename[0] == '\0')
fd = 0;
else
fd = open (filename, O_RDONLY|O_NOCTTY|O_BINARY, 0666);
if (fd == -1)
goto fail;
if (fstat (fd, &st) < 0)
goto fail;
file = xcnew (struct include_file);
file->name = xstrdup (filename);
file->st = st;
file->fd = fd;
/* If the file is plain and zero length, mark it never-reread now. */
if (S_ISREG (st.st_mode) && st.st_size == 0)
file->cmacro = NEVER_REREAD;
splay_tree_insert (pfile->all_include_files,
(splay_tree_key) file->name, (splay_tree_value) file);
return file;
fail:
/* Don't issue an error message if the file doesn't exist. */
if (errno != ENOENT && errno != ENOTDIR)
cpp_error_from_errno (pfile, filename);
/* Create a negative node for this path. */
splay_tree_insert (pfile->all_include_files,
(splay_tree_key) xstrdup (filename), 0);
return 0;
}
/* Place the file referenced by INC into a new buffer on PFILE's stack.
Return 1 if successful, 0 if not. */
static int
stack_include_file (pfile, inc)
cpp_reader *pfile;
struct include_file *inc;
{
cpp_buffer *fp;
if (DO_NOT_REREAD (inc))
return 0;
if (inc->buffer == NULL)
if (read_include_file (pfile, inc) == 0)
return 0;
fp = cpp_push_buffer (pfile, NULL, 0);
if (fp == 0)
return 0;
fp->inc = inc;
fp->nominal_fname = inc->name;
fp->buf = inc->buffer;
fp->rlimit = fp->buf + inc->st.st_size;
fp->cur = fp->buf;
fp->lineno = 1;
fp->line_base = fp->buf;
/* The ->actual_dir field is only used when ignore_srcdir is not in effect;
see do_include */
if (!CPP_OPTION (pfile, ignore_srcdir))
fp->actual_dir = actual_directory (pfile, inc->name);
fp->inc->refcnt++;
pfile->include_depth++;
pfile->input_stack_listing_current = 0;
if (pfile->cb.enter_file)
(*pfile->cb.enter_file) (pfile);
return 1;
}
/* Read the file referenced by INC into the file cache.
If fd points to a plain file, we might be able to mmap it; we can
definitely allocate the buffer all at once. If fd is a pipe or
terminal, we can't do either. If fd is something weird, like a
block device or a directory, we don't want to read it at all.
Unfortunately, different systems use different st.st_mode values
for pipes: some have S_ISFIFO, some S_ISSOCK, some are buggy and
zero the entire struct stat except a couple fields. Hence we don't
even try to figure out what something is, except for plain files,
directories, and block devices.
FIXME: Flush file cache and try again if we run out of memory. */
static int
read_include_file (pfile, inc)
cpp_reader *pfile;
struct include_file *inc;
{
ssize_t size, offset, count;
U_CHAR *buf;
#if MMAP_THRESHOLD
static int pagesize = -1;
#endif
if (S_ISREG (inc->st.st_mode))
{
/* off_t might have a wider range than ssize_t - in other words,
the max size of a file might be bigger than the address
space. We can't handle a file that large. (Anyone with
a single source file bigger than 2GB needs to rethink
their coding style.) Some systems (e.g. AIX 4.1) define
SSIZE_MAX to be much smaller than the actual range of the
type. Use INTTYPE_MAXIMUM unconditionally to ensure this
does not bite us. */
if (inc->st.st_size > INTTYPE_MAXIMUM (ssize_t))
{
cpp_error (pfile, "%s is too large", inc->name);
goto fail;
}
size = inc->st.st_size;
inc->mapped = 0;
#if MMAP_THRESHOLD
if (pagesize == -1)
pagesize = getpagesize ();
if (size / pagesize >= MMAP_THRESHOLD)
{
buf = (U_CHAR *) mmap (0, size, PROT_READ, MAP_PRIVATE, inc->fd, 0);
if (buf == (U_CHAR *)-1)
goto perror_fail;
inc->mapped = 1;
}
else
#endif
{
buf = (U_CHAR *) xmalloc (size);
offset = 0;
while (offset < size)
{
count = read (inc->fd, buf + offset, size - offset);
if (count < 0)
goto perror_fail;
if (count == 0)
{
cpp_warning (pfile, "%s is shorter than expected", inc->name);
break;
}
offset += count;
}
}
}
else if (S_ISBLK (inc->st.st_mode))
{
cpp_error (pfile, "%s is a block device", inc->name);
goto fail;
}
else if (S_ISDIR (inc->st.st_mode))
{
cpp_error (pfile, "%s is a directory", inc->name);
goto fail;
}
else
{
/* 8 kilobytes is a sensible starting size. It ought to be
bigger than the kernel pipe buffer, and it's definitely
bigger than the majority of C source files. */
size = 8 * 1024;
buf = (U_CHAR *) xmalloc (size);
offset = 0;
while ((count = read (inc->fd, buf + offset, size - offset)) > 0)
{
offset += count;
if (offset == size)
buf = xrealloc (buf, (size *= 2));
}
if (count < 0)
goto perror_fail;
if (offset == 0)
{
free (buf);
return 0;
}
if (offset < size)
buf = xrealloc (buf, offset);
inc->st.st_size = offset;
}
close (inc->fd);
inc->buffer = buf;
inc->fd = -1;
return 1;
perror_fail:
cpp_error_from_errno (pfile, inc->name);
fail:
/* Do not try to read this file again. */
close (inc->fd);
inc->fd = -1;
inc->cmacro = NEVER_REREAD;
return 0;
}
static void
purge_cache (inc)
struct include_file *inc;
{
if (inc->buffer)
{
#if MMAP_THRESHOLD
if (inc->mapped)
munmap ((PTR) inc->buffer, inc->st.st_size);
else
#endif
free ((PTR) inc->buffer);
inc->buffer = NULL;
}
}
/* Return 1 if the file named by FNAME has been included before in
any context, 0 otherwise. */
int
cpp_included (pfile, fname)
cpp_reader *pfile;
const char *fname;
{
struct file_name_list *path;
char *name;
splay_tree_node nd;
if (fname[0] == '/')
{
/* Just look it up. */
nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) fname);
return (nd && nd->value);
}
/* Search directory path for the file. */
name = (char *) alloca (strlen (fname) + pfile->max_include_len
+ 2 + INCLUDE_LEN_FUDGE);
for (path = CPP_OPTION (pfile, quote_include); path; path = path->next)
{
memcpy (name, path->name, path->nlen);
name[path->nlen] = '/';
strcpy (&name[path->nlen+1], fname);
_cpp_simplify_pathname (name);
if (CPP_OPTION (pfile, remap))
name = remap_filename (pfile, name, path);
nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) name);
if (nd && nd->value)
return 1;
}
return 0;
}
/* Search for include file FNAME in the include chain starting at
SEARCH_START. Return 0 if there is no such file (or it's un-openable),
otherwise an include_file structure. */
static struct include_file *
find_include_file (pfile, fname, search_start)
cpp_reader *pfile;
const char *fname;
struct file_name_list *search_start;
{
struct file_name_list *path;
char *name;
struct include_file *file;
if (fname[0] == '/')
return lookup_include_file (pfile, fname);
/* Search directory path for the file. */
name = (char *) alloca (strlen (fname) + pfile->max_include_len
+ 2 + INCLUDE_LEN_FUDGE);
for (path = search_start; path; path = path->next)
{
memcpy (name, path->name, path->nlen);
name[path->nlen] = '/';
strcpy (&name[path->nlen+1], fname);
_cpp_simplify_pathname (name);
if (CPP_OPTION (pfile, remap))
name = remap_filename (pfile, name, path);
file = lookup_include_file (pfile, name);
if (file)
{
file->sysp = path->sysp;
file->foundhere = path;
return file;
}
}
return 0;
}
/* #line uses this to save artificial file names. We have to stat the
file because an all_include_files entry is always either + or -,
there's no 'I don't know' value. */
const char *
_cpp_fake_include (pfile, fname)
cpp_reader *pfile;
const char *fname;
{
splay_tree_node nd;
struct include_file *file;
char *name;
file = find_include_file (pfile, fname, CPP_OPTION (pfile, quote_include));
if (file)
{
if (file->fd > 0)
{
close (file->fd);
file->fd = -1;
}
return file->name;
}
name = xstrdup (fname);
_cpp_simplify_pathname (name);
/* We cannot just blindly insert a node, because there's still the
chance that the node already exists but isn't on the search path. */
nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) name);
if (nd)
{
free (name);
return (const char *) nd->key;
}
splay_tree_insert (pfile->all_include_files, (splay_tree_key) name, 0);
return (const char *)name;
}
/* Not everyone who wants to set system-header-ness on a buffer can
see the details of struct include_file. This is an exported interface
because fix-header needs it. */
void
cpp_make_system_header (pfile, pbuf, flag)
cpp_reader *pfile;
cpp_buffer *pbuf;
int flag;
{
if (flag < 0 || flag > 2)
cpp_ice (pfile, "cpp_make_system_header: bad flag %d\n", flag);
else if (!pbuf->inc)
cpp_ice (pfile, "cpp_make_system_header called on non-file buffer");
else
pbuf->inc->sysp = flag;
}
const char *
cpp_syshdr_flags (pfile, pbuf)
cpp_reader *pfile ATTRIBUTE_UNUSED;
cpp_buffer *pbuf;
{
#ifndef NO_IMPLICIT_EXTERN_C
if (CPP_OPTION (pfile, cplusplus) && pbuf->inc->sysp == 2)
return " 3 4";
#endif
if (pbuf->inc->sysp)
return " 3";
return "";
}
/* Report on all files that might benefit from a multiple include guard.
Triggered by -H. */
void
_cpp_report_missing_guards (pfile)
cpp_reader *pfile;
{
int banner = 0;
splay_tree_foreach (pfile->all_include_files, report_missing_guard,
(PTR) &banner);
}
static int
report_missing_guard (n, b)
splay_tree_node n;
void *b;
{
struct include_file *f = (struct include_file *) n->value;
int *bannerp = (int *)b;
if (f && f->cmacro == 0 && f->include_count == 1)
{
if (*bannerp == 0)
{
fputs (_("Multiple include guards may be useful for:\n"), stderr);
*bannerp = 1;
}
fputs (f->name, stderr);
putc ('\n', stderr);
}
return 0;
}
#define PRINT_THIS_DEP(p, b) (CPP_PRINT_DEPS(p) > (b||p->system_include_depth))
void
_cpp_execute_include (pfile, f, len, no_reinclude, search_start, angle_brackets)
cpp_reader *pfile;
const U_CHAR *f;
unsigned int len;
int no_reinclude;
struct file_name_list *search_start;
int angle_brackets;
{
struct include_file *inc;
char *fname;
if (!search_start)
{
if (angle_brackets)
search_start = CPP_OPTION (pfile, bracket_include);
else if (CPP_OPTION (pfile, ignore_srcdir))
search_start = CPP_OPTION (pfile, quote_include);
else
search_start = CPP_BUFFER (pfile)->actual_dir;
}
if (!search_start)
{
cpp_error (pfile, "No include path in which to find %s", f);
return;
}
fname = alloca (len + 1);
memcpy (fname, f, len);
fname[len] = '\0';
inc = find_include_file (pfile, fname, search_start);
if (inc)
{
/* For -M, add the file to the dependencies on its first inclusion. */
if (!inc->include_count && PRINT_THIS_DEP (pfile, angle_brackets))
deps_add_dep (pfile->deps, inc->name);
inc->include_count++;
/* Actually process the file. */
if (stack_include_file (pfile, inc))
{
if (angle_brackets)
pfile->system_include_depth++;
if (no_reinclude)
inc->cmacro = NEVER_REREAD;
/* Handle -H option. */
if (CPP_OPTION (pfile, print_include_names))
{
cpp_buffer *fp = CPP_BUFFER (pfile);
while ((fp = CPP_PREV_BUFFER (fp)) != NULL)
putc ('.', stderr);
fprintf (stderr, " %s\n", inc->name);
}
}
return;
}
if (CPP_OPTION (pfile, print_deps_missing_files)
&& PRINT_THIS_DEP (pfile, angle_brackets))
{
if (!angle_brackets)
deps_add_dep (pfile->deps, fname);
else
{
char *p;
struct file_name_list *ptr;
/* If requested as a system header, assume it belongs in
the first system header directory. */
if (CPP_OPTION (pfile, bracket_include))
ptr = CPP_OPTION (pfile, bracket_include);
else
ptr = CPP_OPTION (pfile, quote_include);
p = (char *) alloca (strlen (ptr->name)
+ strlen (fname) + 2);
if (*ptr->name != '\0')
{
strcpy (p, ptr->name);
strcat (p, "/");
}
strcat (p, fname);
_cpp_simplify_pathname (p);
deps_add_dep (pfile->deps, p);
}
}
/* If -M was specified, and this header file won't be added to
the dependency list, then don't count this as an error,
because we can still produce correct output. Otherwise, we
can't produce correct output, because there may be
dependencies we need inside the missing file, and we don't
know what directory this missing file exists in. */
else if (CPP_PRINT_DEPS (pfile)
&& ! PRINT_THIS_DEP (pfile, angle_brackets))
cpp_warning (pfile, "No include path in which to find %s", fname);
else
cpp_error_from_errno (pfile, fname);
}
/* Locate file F, and determine whether it is newer than PFILE. Return -1,
if F cannot be located or dated, 1, if it is newer and 0 if older. */
int
_cpp_compare_file_date (pfile, f, len, angle_brackets)
cpp_reader *pfile;
const U_CHAR *f;
unsigned int len;
int angle_brackets;
{
char *fname;
struct file_name_list *search_start;
struct include_file *inc;
struct include_file *current_include = CPP_BUFFER (pfile)->inc;
if (angle_brackets)
search_start = CPP_OPTION (pfile, bracket_include);
else if (CPP_OPTION (pfile, ignore_srcdir))
search_start = CPP_OPTION (pfile, quote_include);
else
search_start = CPP_BUFFER (pfile)->actual_dir;
fname = alloca (len + 1);
memcpy (fname, f, len);
fname[len] = '\0';
inc = find_include_file (pfile, fname, search_start);
if (!inc)
return -1;
if (inc->fd > 0)
{
close (inc->fd);
inc->fd = -1;
}
return inc->st.st_mtime > current_include->st.st_mtime;
}
/* Push an input buffer and load it up with the contents of FNAME.
If FNAME is "" or NULL, read standard input. */
int
cpp_read_file (pfile, fname)
cpp_reader *pfile;
const char *fname;
{
struct include_file *f;
if (fname == NULL)
fname = "";
f = lookup_include_file (pfile, fname);
if (f == NULL)
{
cpp_error_from_errno (pfile, fname);
return 0;
}
return stack_include_file (pfile, f);
}
/* Do appropriate cleanup when a file buffer is popped off the input
stack. */
void
_cpp_pop_file_buffer (pfile, buf)
cpp_reader *pfile;
cpp_buffer *buf;
{
struct include_file *inc = buf->inc;
if (pfile->system_include_depth)
pfile->system_include_depth--;
if (pfile->include_depth)
pfile->include_depth--;
if (pfile->potential_control_macro)
{
if (inc->cmacro != NEVER_REREAD)
inc->cmacro = pfile->potential_control_macro;
pfile->potential_control_macro = 0;
}
pfile->input_stack_listing_current = 0;
inc->refcnt--;
if (inc->refcnt == 0 && DO_NOT_REREAD (inc))
purge_cache (inc);
}
/* The file_name_map structure holds a mapping of file names for a
particular directory. This mapping is read from the file named
FILE_NAME_MAP_FILE in that directory. Such a file can be used to
map filenames on a file system with severe filename restrictions,
such as DOS. The format of the file name map file is just a series
of lines with two tokens on each line. The first token is the name
to map, and the second token is the actual name to use. */
struct file_name_map
{
struct file_name_map *map_next;
char *map_from;
char *map_to;
};
#define FILE_NAME_MAP_FILE "header.gcc"
/* Read a space delimited string of unlimited length from a stdio
file. */
static char *
read_filename_string (ch, f)
int ch;
FILE *f;
{
char *alloc, *set;
int len;
len = 20;
set = alloc = xmalloc (len + 1);
if (! is_space(ch))
{
*set++ = ch;
while ((ch = getc (f)) != EOF && ! is_space(ch))
{
if (set - alloc == len)
{
len *= 2;
alloc = xrealloc (alloc, len + 1);
set = alloc + len / 2;
}
*set++ = ch;
}
}
*set = '\0';
ungetc (ch, f);
return alloc;
}
/* This structure holds a linked list of file name maps, one per directory. */
struct file_name_map_list
{
struct file_name_map_list *map_list_next;
char *map_list_name;
struct file_name_map *map_list_map;
};
/* Read the file name map file for DIRNAME. */
static struct file_name_map *
read_name_map (pfile, dirname)
cpp_reader *pfile;
const char *dirname;
{
register struct file_name_map_list *map_list_ptr;
char *name;
FILE *f;
for (map_list_ptr = CPP_OPTION (pfile, map_list); map_list_ptr;
map_list_ptr = map_list_ptr->map_list_next)
if (! strcmp (map_list_ptr->map_list_name, dirname))
return map_list_ptr->map_list_map;
map_list_ptr = ((struct file_name_map_list *)
xmalloc (sizeof (struct file_name_map_list)));
map_list_ptr->map_list_name = xstrdup (dirname);
map_list_ptr->map_list_map = NULL;
name = (char *) alloca (strlen (dirname) + strlen (FILE_NAME_MAP_FILE) + 2);
strcpy (name, dirname);
if (*dirname)
strcat (name, "/");
strcat (name, FILE_NAME_MAP_FILE);
f = fopen (name, "r");
if (!f)
map_list_ptr->map_list_map = (struct file_name_map *)-1;
else
{
int ch;
int dirlen = strlen (dirname);
while ((ch = getc (f)) != EOF)
{
char *from, *to;
struct file_name_map *ptr;
if (is_space(ch))
continue;
from = read_filename_string (ch, f);
while ((ch = getc (f)) != EOF && is_hspace(ch))
;
to = read_filename_string (ch, f);
ptr = ((struct file_name_map *)
xmalloc (sizeof (struct file_name_map)));
ptr->map_from = from;
/* Make the real filename absolute. */
if (*to == '/')
ptr->map_to = to;
else
{
ptr->map_to = xmalloc (dirlen + strlen (to) + 2);
strcpy (ptr->map_to, dirname);
ptr->map_to[dirlen] = '/';
strcpy (ptr->map_to + dirlen + 1, to);
free (to);
}
ptr->map_next = map_list_ptr->map_list_map;
map_list_ptr->map_list_map = ptr;
while ((ch = getc (f)) != '\n')
if (ch == EOF)
break;
}
fclose (f);
}
map_list_ptr->map_list_next = CPP_OPTION (pfile, map_list);
CPP_OPTION (pfile, map_list) = map_list_ptr;
return map_list_ptr->map_list_map;
}
/* Remap NAME based on the file_name_map (if any) for LOC. */
static char *
remap_filename (pfile, name, loc)
cpp_reader *pfile;
char *name;
struct file_name_list *loc;
{
struct file_name_map *map;
const char *from, *p, *dir;
if (! loc->name_map)
loc->name_map = read_name_map (pfile,
loc->name
? loc->name : ".");
if (loc->name_map == (struct file_name_map *)-1)
return name;
from = name + strlen (loc->name) + 1;
for (map = loc->name_map; map; map = map->map_next)
if (!strcmp (map->map_from, from))
return map->map_to;
/* Try to find a mapping file for the particular directory we are
looking in. Thus #include <sys/types.h> will look up sys/types.h
in /usr/include/header.gcc and look up types.h in
/usr/include/sys/header.gcc. */
p = strrchr (name, '/');
if (!p)
p = name;
if (loc && loc->name
&& strlen (loc->name) == (size_t) (p - name)
&& !strncmp (loc->name, name, p - name))
/* FILENAME is in SEARCHPTR, which we've already checked. */
return name;
if (p == name)
{
dir = ".";
from = name;
}
else
{
char * newdir = (char *) alloca (p - name + 1);
memcpy (newdir, name, p - name);
newdir[p - name] = '\0';
dir = newdir;
from = p + 1;
}
for (map = read_name_map (pfile, dir); map; map = map->map_next)
if (! strcmp (map->map_from, name))
return map->map_to;
return name;
}
/* Given a path FNAME, extract the directory component and place it
onto the actual_dirs list. Return a pointer to the allocated
file_name_list structure. These structures are used to implement
current-directory "" include searching. */
static struct file_name_list *
actual_directory (pfile, fname)
cpp_reader *pfile;
const char *fname;
{
char *last_slash, *dir;
size_t dlen;
struct file_name_list *x;
dir = xstrdup (fname);
last_slash = strrchr (dir, '/');
if (last_slash)
{
if (last_slash == dir)
{
dlen = 1;
last_slash[1] = '\0';
}
else
{
dlen = last_slash - dir;
*last_slash = '\0';
}
}
else
{
free (dir);
dir = xstrdup (".");
dlen = 1;
}
if (dlen > pfile->max_include_len)
pfile->max_include_len = dlen;
for (x = pfile->actual_dirs; x; x = x->alloc)
if (!strcmp (x->name, dir))
{
free (dir);
return x;
}
/* Not found, make a new one. */
x = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
x->name = dir;
x->nlen = dlen;
x->next = CPP_OPTION (pfile, quote_include);
x->alloc = pfile->actual_dirs;
x->sysp = CPP_BUFFER (pfile)->inc->sysp;
x->name_map = NULL;
pfile->actual_dirs = x;
return x;
}
/* Simplify a path name in place, deleting redundant components. This
reduces OS overhead and guarantees that equivalent paths compare
the same (modulo symlinks).
Transforms made:
foo/bar/../quux foo/quux
foo/./bar foo/bar
foo//bar foo/bar
/../quux /quux
//quux //quux (POSIX allows leading // as a namespace escape)
Guarantees no trailing slashes. All transforms reduce the length
of the string.
*/
void
_cpp_simplify_pathname (path)
char *path;
{
char *from, *to;
char *base;
int absolute = 0;
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
/* Convert all backslashes to slashes. */
for (from = path; *from; from++)
if (*from == '\\') *from = '/';
/* Skip over leading drive letter if present. */
if (ISALPHA (path[0]) && path[1] == ':')
from = to = &path[2];
else
from = to = path;
#else
from = to = path;
#endif
/* Remove redundant initial /s. */
if (*from == '/')
{
absolute = 1;
to++;
from++;
if (*from == '/')
{
if (*++from == '/')
/* 3 or more initial /s are equivalent to 1 /. */
while (*++from == '/');
else
/* On some hosts // differs from /; Posix allows this. */
to++;
}
}
base = to;
for (;;)
{
while (*from == '/')
from++;
if (from[0] == '.' && from[1] == '/')
from += 2;
else if (from[0] == '.' && from[1] == '\0')
goto done;
else if (from[0] == '.' && from[1] == '.' && from[2] == '/')
{
if (base == to)
{
if (absolute)
from += 3;
else
{
*to++ = *from++;
*to++ = *from++;
*to++ = *from++;
base = to;
}
}
else
{
to -= 2;
while (to > base && *to != '/') to--;
if (*to == '/')
to++;
from += 3;
}
}
else if (from[0] == '.' && from[1] == '.' && from[2] == '\0')
{
if (base == to)
{
if (!absolute)
{
*to++ = *from++;
*to++ = *from++;
}
}
else
{
to -= 2;
while (to > base && *to != '/') to--;
if (*to == '/')
to++;
}
goto done;
}
else
/* Copy this component and trailing /, if any. */
while ((*to++ = *from++) != '/')
{
if (!to[-1])
{
to--;
goto done;
}
}
}
done:
/* Trim trailing slash */
if (to[0] == '/' && (!absolute || to > path+1))
to--;
/* Change the empty string to "." so that stat() on the result
will always work. */
if (to == path)
*to++ = '.';
*to = '\0';
return;
}
/* It is not clear when this should be used if at all, so I've
disabled it until someone who understands VMS can look at it. */
#if 0
/* Under VMS we need to fix up the "include" specification filename.
Rules for possible conversions
fullname tried paths
name name
./dir/name [.dir]name
/dir/name dir:name
/name [000000]name, name
dir/name dir:[000000]name, dir:name, dir/name
dir1/dir2/name dir1:[dir2]name, dir1:[000000.dir2]name
path:/name path:[000000]name, path:name
path:/dir/name path:[000000.dir]name, path:[dir]name
path:dir/name path:[dir]name
[path]:[dir]name [path.dir]name
path/[dir]name [path.dir]name
The path:/name input is constructed when expanding <> includes. */
static void
hack_vms_include_specification (fullname)
char *fullname;
{
register char *basename, *unixname, *local_ptr, *first_slash;
int f, check_filename_before_returning, must_revert;
char Local[512];
check_filename_before_returning = 0;
must_revert = 0;
/* See if we can find a 1st slash. If not, there's no path information. */
first_slash = strchr (fullname, '/');
if (first_slash == 0)
return 0; /* Nothing to do!!! */
/* construct device spec if none given. */
if (strchr (fullname, ':') == 0)
{
/* If fullname has a slash, take it as device spec. */
if (first_slash == fullname)
{
first_slash = strchr (fullname + 1, '/'); /* 2nd slash ? */
if (first_slash)
*first_slash = ':'; /* make device spec */
for (basename = fullname; *basename != 0; basename++)
*basename = *(basename+1); /* remove leading slash */
}
else if ((first_slash[-1] != '.') /* keep ':/', './' */
&& (first_slash[-1] != ':')
&& (first_slash[-1] != ']')) /* or a vms path */
{
*first_slash = ':';
}
else if ((first_slash[1] == '[') /* skip './' in './[dir' */
&& (first_slash[-1] == '.'))
fullname += 2;
}
/* Get part after first ':' (basename[-1] == ':')
or last '/' (basename[-1] == '/'). */
basename = base_name (fullname);
local_ptr = Local; /* initialize */
/* We are trying to do a number of things here. First of all, we are
trying to hammer the filenames into a standard format, such that later
processing can handle them.
If the file name contains something like [dir.], then it recognizes this
as a root, and strips the ".]". Later processing will add whatever is
needed to get things working properly.
If no device is specified, then the first directory name is taken to be
a device name (or a rooted logical). */
/* Point to the UNIX filename part (which needs to be fixed!)
but skip vms path information.
[basename != fullname since first_slash != 0]. */
if ((basename[-1] == ':') /* vms path spec. */
|| (basename[-1] == ']')
|| (basename[-1] == '>'))
unixname = basename;
else
unixname = fullname;
if (*unixname == '/')
unixname++;
/* If the directory spec is not rooted, we can just copy
the UNIX filename part and we are done. */
if (((basename - fullname) > 1)
&& ( (basename[-1] == ']')
|| (basename[-1] == '>')))
{
if (basename[-2] != '.')
{
/* The VMS part ends in a `]', and the preceding character is not a `.'.
-> PATH]:/name (basename = '/name', unixname = 'name')
We strip the `]', and then splice the two parts of the name in the
usual way. Given the default locations for include files,
we will only use this code if the user specifies alternate locations
with the /include (-I) switch on the command line. */
basename -= 1; /* Strip "]" */
unixname--; /* backspace */
}
else
{
/* The VMS part has a ".]" at the end, and this will not do. Later
processing will add a second directory spec, and this would be a syntax
error. Thus we strip the ".]", and thus merge the directory specs.
We also backspace unixname, so that it points to a '/'. This inhibits the
generation of the 000000 root directory spec (which does not belong here
in this case). */
basename -= 2; /* Strip ".]" */
unixname--; /* backspace */
}
}
else
{
/* We drop in here if there is no VMS style directory specification yet.
If there is no device specification either, we make the first dir a
device and try that. If we do not do this, then we will be essentially
searching the users default directory (as if they did a #include "asdf.h").
Then all we need to do is to push a '[' into the output string. Later
processing will fill this in, and close the bracket. */
if ((unixname != fullname) /* vms path spec found. */
&& (basename[-1] != ':'))
*local_ptr++ = ':'; /* dev not in spec. take first dir */
*local_ptr++ = '['; /* Open the directory specification */
}
if (unixname == fullname) /* no vms dir spec. */
{
must_revert = 1;
if ((first_slash != 0) /* unix dir spec. */
&& (*unixname != '/') /* not beginning with '/' */
&& (*unixname != '.')) /* or './' or '../' */
*local_ptr++ = '.'; /* dir is local ! */
}
/* at this point we assume that we have the device spec, and (at least
the opening "[" for a directory specification. We may have directories
specified already.
If there are no other slashes then the filename will be
in the "root" directory. Otherwise, we need to add
directory specifications. */
if (strchr (unixname, '/') == 0)
{
/* if no directories specified yet and none are following. */
if (local_ptr[-1] == '[')
{
/* Just add "000000]" as the directory string */
strcpy (local_ptr, "000000]");
local_ptr += strlen (local_ptr);
check_filename_before_returning = 1; /* we might need to fool with this later */
}
}
else
{
/* As long as there are still subdirectories to add, do them. */
while (strchr (unixname, '/') != 0)
{
/* If this token is "." we can ignore it
if it's not at the beginning of a path. */
if ((unixname[0] == '.') && (unixname[1] == '/'))
{
/* remove it at beginning of path. */
if ( ((unixname == fullname) /* no device spec */
&& (fullname+2 != basename)) /* starts with ./ */
/* or */
|| ((basename[-1] == ':') /* device spec */
&& (unixname-1 == basename))) /* and ./ afterwards */
*local_ptr++ = '.'; /* make '[.' start of path. */
unixname += 2;
continue;
}
/* Add a subdirectory spec. Do not duplicate "." */
if ( local_ptr[-1] != '.'
&& local_ptr[-1] != '['
&& local_ptr[-1] != '<')
*local_ptr++ = '.';
/* If this is ".." then the spec becomes "-" */
if ( (unixname[0] == '.')
&& (unixname[1] == '.')
&& (unixname[2] == '/'))
{
/* Add "-" and skip the ".." */
if ((local_ptr[-1] == '.')
&& (local_ptr[-2] == '['))
local_ptr--; /* prevent [.- */
*local_ptr++ = '-';
unixname += 3;
continue;
}
/* Copy the subdirectory */
while (*unixname != '/')
*local_ptr++= *unixname++;
unixname++; /* Skip the "/" */
}
/* Close the directory specification */
if (local_ptr[-1] == '.') /* no trailing periods */
local_ptr--;
if (local_ptr[-1] == '[') /* no dir needed */
local_ptr--;
else
*local_ptr++ = ']';
}
/* Now add the filename. */
while (*unixname)
*local_ptr++ = *unixname++;
*local_ptr = 0;
/* Now append it to the original VMS spec. */
strcpy ((must_revert==1)?fullname:basename, Local);
/* If we put a [000000] in the filename, try to open it first. If this fails,
remove the [000000], and return that name. This provides flexibility
to the user in that they can use both rooted and non-rooted logical names
to point to the location of the file. */
if (check_filename_before_returning)
{
f = open (fullname, O_RDONLY|O_NONBLOCK);
if (f >= 0)
{
/* The file name is OK as it is, so return it as is. */
close (f);
return 1;
}
/* The filename did not work. Try to remove the [000000] from the name,
and return it. */
basename = strchr (fullname, '[');
local_ptr = strchr (fullname, ']') + 1;
strcpy (basename, local_ptr); /* this gets rid of it */
}
return 1;
}
#endif /* VMS */
Reference in New Issue View Git Blame Copy Permalink