bug-coreutils
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

revised coreutils to use "file name" rather than "path" or "filename"


From: Paul Eggert
Subject: revised coreutils to use "file name" rather than "path" or "filename"
Date: Wed, 01 Jun 2005 22:27:59 -0700
User-agent: Gnus/5.1006 (Gnus v5.10.6) Emacs/21.4 (gnu/linux)

RMS was looking at an extract from the coreutils source code 
and noticed that it used "path" where it should have said
"file name".  The GNO coding standards say:

  Please do not use the term ``pathname'' that is used in Unix
  documentation; use ``file name'' (two words) instead.  We use the term
  ``path'' only for search paths, which are lists of directory names.

I looked through coreutils and found several uses of "path"
and "filename" that don't conform to the above usage, so
I installed the following patch.

As part of this patch I renamed the following files, since
their names used "path" inappropriately:

lib/makepath.c to lib/mkdir-p.c
lib/makepath.h to lib/mkdir-p.h
m4/makepath.m4 to m4/mkdir-p.m4
lib/path-concat.h to lib/filenamecat.h
lib/path-concat.c to lib/filenamecat.c
m4/path-concat.m4 to m4/filenamecat.m4

The diff below compares these files according to their old and new names.

2005-06-01  Paul Eggert  <address@hidden>

        Use "file name" when talking about file names, instead of "filename"
        or "path", as per the GNU coding standards.
        * doc/coreutils.texi (readlink invocation): "path component" ->
        "component", since we don't use the POSIX "path" nomenclature.
        * lib/mkdir-p.c: Renamed from makepath.c.
        (make_dir_parents): Renamed from make_path.  All callers changed.
        * lib/mkdir-p.h: Likewise.  All includers changed.
        * lib/filenamecat.c: Renamed from path-concat.c.
        (file_name_concat): Renamed from path_concat.  All callers changed.
        [TEST_FILE_NAME_CONCAT]: Renamed from TEST_PATH_CONCAT.
        * lib/filenamecat.h: Likewise.  All includers changed.
        * lib/acl.c: Don't use "path" or "filename" to mean "file name"
        in comments or local variable names.
        * lib/basename.c: Likewise.
        * lib/canonicalize.c, canonicalize.h: Likewise.
        * lib/dirname.c, dirname.h: Likewise.
        * lib/euidaccess.c: Likewise.
        * lib/exclude.c: Likewise
        * lib/fnmatch_.h, fnmatch_loop.c: Likewise.
        * lib/fsusage.c, fsuage.h: Likewise.
        * lib/fts.c, fts_.h: Likewise.
        * lib/getcwd.c: Likewise.
        * lib/getloadavg.c: Likewise.
        * lib/mkstemp.c: Likewise.
        * lib/mountlist.c, mountlist.h: Likewise.
        * lib/openat.c, openat.h: Likewise.
        * lib/readlink-stub.c: Likewise.
        * lib/readutmp.c, readutmp.h: Likewise.
        * lib/rename.c: Likewise.
        * lib/rmdir.c: Likewise.
        * lib/same.c: Likewise.
        * lib/savedir.c: Likewise.
        * lib/stripslash.c: Likewise.
        * lib/tempname.c: Likewise.
        * lib/xreadlink.c: Likewise.
        * lib/exclude.c (excluded_file_name): Renamed from excluded_filename.
        All uses changed.
        * lib/exclude.h: Likewise.
        * m4/mkdir-p.m4: Renamed from makepath.m4.
        (gl_MKDIR_PARENTS): Renamed from gl_MAKEPATH.  All uses changed.
        Rename files from makepath.c to mkdir-p.c, and from
        makepath.h to mkdir-p.h.
        * m4/filenamecat.m4: Renamed from path-concat.m4.
        (gl_FILE_NAME_CONCAT): Renamed from gl_PATH_CONCAT.  All uses changed.
        Rename files from path-concat.c to filenamecat.c,
        and from path-concat.h to filenamecat.h.
        * m4/getcwd-path-max.m4: Don't use "path" or "filename" to mean
        "file name" in local variables or comments.
        * m4/rename.m4: Likewise.
        * src/basename.c: Don't use "path" or "filename".
        * src/copy.c: Likewise.
        * src/copy.h: Likewise.
        * src/cp-hash.c: Likewise.
        * src/cp.c: Likewise.
        * src/df.c: Likewise.
        * src/install.c: Likewise.
        * src/ls.c: Likewise.
        * src/pinky.c: Likewise.
        * src/pr.c: Likewise.
        * src/pwd.c: Likewise.
        * src/remove.c: Likewise.
        * src/rmdir.c: Likewise.
        * src/sort.c: Likewise.
        * src/system.h: Likewise.
        * src/tty.c: Likewise.
        * src/who.c: Likewise.
        * src/cp.c (parents_option): Renamed from flag_path.  All uses changed.
        (make_dir_parents_private): Renamed from make_path_private.
        All uses changed.
        * src/cp.c (usage): Don't use "path" to describe a file name.
        * src/readlink.c (usage): Likewise.
        * src/rmdir.c (usage): Likewise.
        * src/df.c: Don't include "path-concat.h"; not needed.
        * src/install.c (install_file_in_file_parents): Renamed from
        install_file_to_path.  All uses changed.
        * src/ln.c (FILE_BASENAME_CONCAT): Renamed from PATH_BASENAME_CONCAT.
        All uses changed.
        * src/ls.c (make_link_name): Renamed from make_link_path.
        All uses changed.
        * src/pwd.c (struct file_name): Renamed from struct Path.
        All uses changed.
        (file_name_free): Renamed from path_free.  All uses changed.
        (file_name_init): Renamed from path_init.  All uses changed.
        (file_name_prepend): Renamed from path_prepend.  All uses changed.
        * src/rmdir.c (remove_empty_parents): Renamed from empty_paths.
        All uses changed.
        (longopts): Add comment that --path is deprecated.

--- ../cu/lib/makepath.c        2005-05-14 00:58:06 -0700
+++ lib/mkdir-p.c       2005-06-01 16:39:08 -0700
@@ -1,4 +1,4 @@
-/* makepath.c -- Ensure that a directory path exists.
+/* mkdir-p.c -- Ensure that a directory and its parents exist.
 
    Copyright (C) 1990, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005
    Free Software Foundation, Inc.
@@ -23,7 +23,7 @@
 # include <config.h>
 #endif
 
-#include "makepath.h"
+#include "mkdir-p.h"
 
 #include <alloca.h>
 
@@ -78,16 +78,16 @@
     }                                                  \
   while (0)
 
-/* Attempt to create directory DIR (aka DIRPATH) with the specified MODE.
+/* Attempt to create directory DIR (aka FULLDIR) with the specified MODE.
    If CREATED_DIR_P is non-NULL, set *CREATED_DIR_P if this
    function creates DIR and clear it otherwise.  Give a diagnostic and
    return false if DIR cannot be created or cannot be determined to
-   exist already.  Use DIRPATH in any diagnostic, not DIR.
+   exist already.  Use FULLDIR in any diagnostic, not DIR.
    Note that if DIR already exists, this function returns true
    (indicating success) and clears *CREATED_DIR_P.  */
 
 bool
-make_dir (const char *dir, const char *dirpath, mode_t mode,
+make_dir (char const *dir, char const *fulldir, mode_t mode,
          bool *created_dir_p)
 {
   bool ok = true;
@@ -111,17 +111,17 @@ make_dir (const char *dir, const char *d
       if (stat (dir, &stats))
        {
          error (0, saved_errno, _("cannot create directory %s"),
-                quote (dirpath));
+                quote (fulldir));
          ok = false;
        }
       else if (!S_ISDIR (stats.st_mode))
        {
-         error (0, 0, _("%s exists but is not a directory"), quote (dirpath));
+         error (0, 0, _("%s exists but is not a directory"), quote (fulldir));
          ok = false;
        }
       else
        {
-         /* DIR (aka DIRPATH) already exists and is a directory. */
+         /* DIR (aka FULLDIR) already exists and is a directory. */
        }
     }
 
@@ -131,36 +131,36 @@ make_dir (const char *dir, const char *d
   return ok;
 }
 
-/* Ensure that the directory ARGPATH exists.
+/* Ensure that the directory ARG exists.
 
    Create any leading directories that don't already exist, with
    permissions PARENT_MODE.
-   If the last element of ARGPATH does not exist, create it as
+   If the last element of ARG does not exist, create it as
    a new directory with permissions MODE.
    If OWNER and GROUP are non-negative, use them to set the UID and GID of
    any created directories.
    If VERBOSE_FMT_STRING is nonzero, use it as a printf format
    string for printing a message after successfully making a directory,
    with the name of the directory that was just made as an argument.
-   If PRESERVE_EXISTING is true and ARGPATH is an existing directory,
+   If PRESERVE_EXISTING is true and ARG is an existing directory,
    then do not attempt to set its permissions and ownership.
 
-   Return true iff ARGPATH exists as a directory with the proper
+   Return true iff ARG exists as a directory with the proper
    ownership and permissions when done.  */
 
 bool
-make_path (const char *argpath,
-          mode_t mode,
-          mode_t parent_mode,
-          uid_t owner,
-          gid_t group,
-          bool preserve_existing,
-          const char *verbose_fmt_string)
+make_dir_parents (char const *arg,
+                 mode_t mode,
+                 mode_t parent_mode,
+                 uid_t owner,
+                 gid_t group,
+                 bool preserve_existing,
+                 char const *verbose_fmt_string)
 {
   struct stat stats;
   bool retval = true;
 
-  if (stat (argpath, &stats))
+  if (stat (arg, &stats) != 0)
     {
       char *slash;
       mode_t tmp_mode;         /* Initial perms for leading dirs.  */
@@ -174,15 +174,15 @@ make_path (const char *argpath,
       bool do_chdir;           /* Whether to chdir before each mkdir.  */
       struct saved_cwd cwd;
       char *basename_dir;
-      char *dirpath;
+      char *dir;
 
       /* Temporarily relax umask in case it's overly restrictive.  */
       mode_t oldmask = umask (0);
 
-      /* Make a copy of ARGPATH that we can scribble NULs on.  */
-      dirpath = (char *) alloca (strlen (argpath) + 1);
-      strcpy (dirpath, argpath);
-      strip_trailing_slashes (dirpath);
+      /* Make a copy of ARG that we can scribble NULs on.  */
+      dir = (char *) alloca (strlen (arg) + 1);
+      strcpy (dir, arg);
+      strip_trailing_slashes (dir);
 
       /* If leading directories shouldn't be writable or executable,
         or should have set[ug]id or sticky bits set and we are setting
@@ -204,19 +204,19 @@ make_path (const char *argpath,
         to do the chdir optimization.  */
       do_chdir = (save_cwd (&cwd) == 0);
 
-      /* If we've saved the cwd and DIRPATH is an absolute pathname,
+      /* If we've saved the cwd and DIR is an absolute file name,
         we must chdir to `/' in order to enable the chdir optimization.
          So if chdir ("/") fails, turn off the optimization.  */
-      if (do_chdir && dirpath[0] == '/')
+      if (do_chdir && dir[0] == '/')
        {
          /* POSIX says "//" might be special, so chdir to "//" if the
             file name starts with exactly two slashes.  */
-         char const *root = "//" + (dirpath[1] != '/' || dirpath[2] == '/');
+         char const *root = "//" + (dir[1] != '/' || dir[2] == '/');
          if (chdir (root) != 0)
            do_chdir = false;
        }
 
-      slash = dirpath;
+      slash = dir;
 
       /* Skip over leading slashes.  */
       while (*slash == '/')
@@ -226,7 +226,7 @@ make_path (const char *argpath,
        {
          bool newly_created_dir;
 
-         /* slash points to the leftmost unprocessed component of dirpath.  */
+         /* slash points to the leftmost unprocessed component of dir.  */
          basename_dir = slash;
 
          slash = strchr (slash, '/');
@@ -236,10 +236,10 @@ make_path (const char *argpath,
          /* If we're *not* doing chdir before each mkdir, then we have to refer
             to the target using the full (multi-component) directory name.  */
          if (!do_chdir)
-           basename_dir = dirpath;
+           basename_dir = dir;
 
          *slash = '\0';
-         if (! make_dir (basename_dir, dirpath, tmp_mode, &newly_created_dir))
+         if (! make_dir (basename_dir, dir, tmp_mode, &newly_created_dir))
            {
              CLEANUP;
              return false;
@@ -248,7 +248,7 @@ make_path (const char *argpath,
          if (newly_created_dir)
            {
              if (verbose_fmt_string)
-               error (0, 0, verbose_fmt_string, quote (dirpath));
+               error (0, 0, verbose_fmt_string, quote (dir));
 
              if ((owner != (uid_t) -1 || group != (gid_t) -1)
                  && chown (basename_dir, owner, group)
@@ -258,7 +258,7 @@ make_path (const char *argpath,
                  )
                {
                  error (0, errno, _("cannot change owner and/or group of %s"),
-                        quote (dirpath));
+                        quote (dir));
                  CLEANUP;
                  return false;
                }
@@ -280,7 +280,7 @@ make_path (const char *argpath,
          if (do_chdir && chdir (basename_dir) < 0)
            {
              error (0, errno, _("cannot chdir to directory %s"),
-                    quote (dirpath));
+                    quote (dir));
              CLEANUP;
              return false;
            }
@@ -288,28 +288,28 @@ make_path (const char *argpath,
          *slash++ = '/';
 
          /* Avoid unnecessary calls to `stat' when given
-            pathnames containing multiple adjacent slashes.  */
+            file names containing multiple adjacent slashes.  */
          while (*slash == '/')
            slash++;
        }
 
       if (!do_chdir)
-       basename_dir = dirpath;
+       basename_dir = dir;
 
       /* Done creating leading directories.  Restore original umask.  */
       umask (oldmask);
 
       /* We're done making leading directories.
-        Create the final component of the path.  */
+        Create the final component of the file name.  */
 
-      if (! make_dir (basename_dir, dirpath, mode, NULL))
+      if (! make_dir (basename_dir, dir, mode, NULL))
        {
          CLEANUP;
          return false;
        }
 
       if (verbose_fmt_string != NULL)
-       error (0, 0, verbose_fmt_string, quote (dirpath));
+       error (0, 0, verbose_fmt_string, quote (dir));
 
       if (owner != (uid_t) -1 || group != (gid_t) -1)
        {
@@ -320,7 +320,7 @@ make_path (const char *argpath,
              )
            {
              error (0, errno, _("cannot change owner and/or group of %s"),
-                    quote (dirpath));
+                    quote (dir));
              retval = false;
            }
        }
@@ -334,7 +334,7 @@ make_path (const char *argpath,
          && chmod (basename_dir, mode))
        {
          error (0, errno, _("cannot change permissions of %s"),
-                quote (dirpath));
+                quote (dir));
          retval = false;
        }
 
@@ -346,23 +346,23 @@ make_path (const char *argpath,
       for (p = leading_dirs; p != NULL; p = p->next)
        {
          *(p->dirname_end) = '\0';
-         if (chmod (dirpath, parent_mode))
+         if (chmod (dir, parent_mode) != 0)
            {
              error (0, errno, _("cannot change permissions of %s"),
-                    quote (dirpath));
+                    quote (dir));
              retval = false;
            }
        }
     }
   else
     {
-      /* We get here if the entire path already exists.  */
+      /* We get here if the file already exists.  */
 
-      const char *dirpath = argpath;
+      char const *dir = arg;
 
       if (!S_ISDIR (stats.st_mode))
        {
-         error (0, 0, _("%s exists but is not a directory"), quote (dirpath));
+         error (0, 0, _("%s exists but is not a directory"), quote (dir));
          return false;
        }
 
@@ -375,20 +375,20 @@ make_path (const char *argpath,
             be able to chmod them.  So don't give files away.  */
 
          if ((owner != (uid_t) -1 || group != (gid_t) -1)
-             && chown (dirpath, owner, group)
+             && chown (dir, owner, group)
 #ifdef AFS
              && errno != EPERM
 #endif
              )
            {
              error (0, errno, _("cannot change owner and/or group of %s"),
-                    quote (dirpath));
+                    quote (dir));
              retval = false;
            }
-         if (chmod (dirpath, mode))
+         if (chmod (dir, mode) != 0)
            {
              error (0, errno, _("cannot change permissions of %s"),
-                                quote (dirpath));
+                                quote (dir));
              retval = false;
            }
        }
--- ../cu/lib/makepath.h        2005-05-14 00:58:06 -0700
+++ lib/mkdir-p.h       2005-06-01 16:16:24 -0700
@@ -1,6 +1,6 @@
-/* makepath.c -- Ensure that a directory path exists.
+/* mkdir-p.h -- Ensure that a directory and its parents exist.
 
-   Copyright (C) 1994, 1995, 1996, 1997, 2000, 2003, 2004 Free
+   Copyright (C) 1994, 1995, 1996, 1997, 2000, 2003, 2004, 2005 Free
    Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
@@ -22,15 +22,15 @@
 #include <stdbool.h>
 #include <sys/types.h>
 
-bool make_path (const char *argpath,
-               mode_t mode,
-               mode_t parent_mode,
-               uid_t owner,
-               gid_t group,
-               bool preserve_existing,
-               const char *verbose_fmt_string);
+bool make_dir_parents (char const *argname,
+                      mode_t mode,
+                      mode_t parent_mode,
+                      uid_t owner,
+                      gid_t group,
+                      bool preserve_existing,
+                      char const *verbose_fmt_string);
 
-bool make_dir (const char *dir,
-              const char *dirpath,
+bool make_dir (char const *dir,
+              char const *fulldir,
               mode_t mode,
               bool *created_dir_p);
--- ../cu/m4/makepath.m4        2005-04-28 09:55:43 -0700
+++ m4/mkdir-p.m4       2005-06-01 15:58:10 -0700
@@ -1,15 +1,15 @@
-# makepath.m4 serial 7
+# mkdir-p.m4 serial 8
 dnl Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
 dnl with or without modifications, as long as this notice is preserved.
 
-AC_DEFUN([gl_MAKEPATH],
+AC_DEFUN([gl_MKDIR_PARENTS],
 [
-  AC_LIBSOURCES([makepath.c, makepath.h])
-  AC_LIBOBJ([makepath])
+  AC_LIBSOURCES([mkdir-p.c, mkdir-p.h])
+  AC_LIBOBJ([mkdir-p])
 
-  dnl Prerequisites of lib/makepath.c.
+  dnl Prerequisites of lib/mkdir-p.c.
   AC_REQUIRE([AC_FUNC_ALLOCA])
   AC_CHECK_HEADERS_ONCE(unistd.h)
   AC_REQUIRE([gl_AFS])
--- ../cu/lib/path-concat.h     2005-05-14 00:58:06 -0700
+++ lib/filenamecat.h   2005-06-01 10:39:15 -0700
@@ -1,6 +1,6 @@
-/* Concatenate two arbitrary pathnames.
+/* Concatenate two arbitrary file names.
 
-   Copyright (C) 1996, 1997, 2003 Free Software Foundation, Inc.
+   Copyright (C) 1996, 1997, 2003, 2005 Free Software Foundation, Inc.
 
    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
@@ -18,9 +18,5 @@
 
 /* Written by Jim Meyering.  */
 
-#if ! defined PATH_CONCAT_H_
-# define PATH_CONCAT_H_
-
-char *path_concat (const char *dir, const char *base, char **base_in_result);
-
-#endif
+char *file_name_concat (char const *dir, char const *base,
+                       char **base_in_result);
--- ../cu/lib/path-concat.c     2005-05-14 01:03:44 -0700
+++ lib/filenamecat.c   2005-06-01 16:02:00 -0700
@@ -1,4 +1,4 @@
-/* path-concat.c -- concatenate two arbitrary pathnames
+/* Concatenate two arbitrary file names.
 
    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 
Free
    Software Foundation, Inc.
@@ -24,7 +24,7 @@
 #endif
 
 /* Specification.  */
-#include "path-concat.h"
+#include "filenamecat.h"
 
 #include <string.h>
 
@@ -46,7 +46,7 @@ longest_relative_suffix (char const *f)
   return f;
 }
 
-/* Concatenate two pathname components, DIR and ABASE, in
+/* Concatenate two file name components, DIR and ABASE, in
    newly-allocated storage and return the result.
    The resulting file name F is such that the commands "ls F" and "(cd
    DIR; ls BASE)" refer to the same file, where BASE is ABASE with any
@@ -62,7 +62,7 @@ longest_relative_suffix (char const *f)
    Report an error if memory is exhausted.  */
 
 char *
-path_concat (char const *dir, char const *abase, char **base_in_result)
+file_name_concat (char const *dir, char const *abase, char **base_in_result)
 {
   char const *dirbase = base_name (dir);
   size_t dirbaselen = base_len (dirbase);
@@ -88,7 +88,7 @@ path_concat (char const *dir, char const
   return p_concat;
 }
 
-#ifdef TEST_PATH_CONCAT
+#ifdef TEST_FILE_NAME_CONCAT
 # include <stdlib.h>
 # include <stdio.h>
 int
@@ -114,7 +114,7 @@ main ()
     {
       char *base_in_result;
       char const *const *t = tests[i];
-      char *res = path_concat (t[0], t[1], &base_in_result);
+      char *res = file_name_concat (t[0], t[1], &base_in_result);
       if (strcmp (res, t[2]) != 0)
        {
          printf ("got %s, expected %s\n", res, t[2]);
--- ../cu/m4/path-concat.m4     2005-01-28 16:16:39 -0800
+++ m4/filenamecat.m4   2005-06-01 16:07:20 -0700
@@ -1,14 +1,14 @@
-# path-concat.m4 serial 6
+# filenamecat.m4 serial 7
 dnl Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
 dnl with or without modifications, as long as this notice is preserved.
 
-AC_DEFUN([gl_PATH_CONCAT],
+AC_DEFUN([gl_FILE_NAME_CONCAT],
 [
-  AC_LIBSOURCES([path-concat.c, path-concat.h])
-  AC_LIBOBJ([path-concat])
+  AC_LIBSOURCES([filenamecat.c, filenamecat.h])
+  AC_LIBOBJ([filenamecat])
 
-  dnl Prerequisites of lib/path-concat.c.
+  dnl Prerequisites of lib/filenamecat.c.
   AC_CHECK_FUNCS_ONCE(mempcpy)
 ])
Index: doc/coreutils.texi
===================================================================
RCS file: /fetish/cu/doc/coreutils.texi,v
retrieving revision 1.258
diff -p -u -r1.258 coreutils.texi
--- doc/coreutils.texi  26 May 2005 19:27:50 -0000      1.258
+++ doc/coreutils.texi  2 Jun 2005 04:54:32 -0000
@@ -7955,7 +7955,7 @@ The program accepts the following option
 @opindex -f
 @opindex --canonicalize
 Activate canonicalize mode.
-If any path component except the last one is missing or unavailable,
+If any component of the file name except the last one is missing or 
unavailable,
 @command{readlink} produces no output and exits with a nonzero exit code.
 
 @item -e
@@ -7963,7 +7963,7 @@ If any path component except the last on
 @opindex -e
 @opindex --canonicalize-existing
 Activate canonicalize mode.
-If any path component is missing or unavailable, @command{readlink} produces
+If any component is missing or unavailable, @command{readlink} produces
 no output and exits with a nonzero exit code.
 
 @item -m
@@ -7971,7 +7971,7 @@ no output and exits with a nonzero exit 
 @opindex -m
 @opindex --canonicalize-missing
 Activate canonicalize mode.
-If any path component is missing or unavailable, @command{readlink} treats it
+If any component is missing or unavailable, @command{readlink} treats it
 as a directory.
 
 @item -n
Index: lib/acl.c
===================================================================
RCS file: /fetish/cu/lib/acl.c,v
retrieving revision 1.3
diff -p -u -r1.3 acl.c
--- lib/acl.c   14 May 2005 07:58:06 -0000      1.3
+++ lib/acl.c   2 Jun 2005 04:54:32 -0000
@@ -1,6 +1,6 @@
 /* acl.c - access control lists
 
-   Copyright (C) 2002, 2003 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2003, 2005 Free Software Foundation, Inc.
 
    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
@@ -39,11 +39,11 @@
 # define MIN_ACL_ENTRIES 4
 #endif
 
-/* Return 1 if PATH has a nontrivial access control list, 0 if not,
+/* Return 1 if FILE has a nontrivial access control list, 0 if not,
    and -1 (setting errno) if an error is encountered.  */
 
 int
-file_has_acl (char const *path, struct stat const *pathstat)
+file_has_acl (char const *file, struct stat const *filestat)
 {
   /* FIXME: This implementation should work on recent-enough versions
      of HP-UX, Solaris, and Unixware, but it simply returns 0 with
@@ -52,9 +52,9 @@ file_has_acl (char const *path, struct s
      fix-related ideas.  */
 
 #if HAVE_ACL && defined GETACLCNT
-  if (! S_ISLNK (pathstat->st_mode))
+  if (! S_ISLNK (filestat->st_mode))
     {
-      int n = acl (path, GETACLCNT, 0, NULL);
+      int n = acl (file, GETACLCNT, 0, NULL);
       return n < 0 ? (errno == ENOSYS ? 0 : -1) : (MIN_ACL_ENTRIES < n);
     }
 #endif
Index: lib/basename.c
===================================================================
RCS file: /fetish/cu/lib/basename.c,v
retrieving revision 1.24
diff -p -u -r1.24 basename.c
--- lib/basename.c      14 May 2005 07:58:06 -0000      1.24
+++ lib/basename.c      2 Jun 2005 04:54:32 -0000
@@ -1,6 +1,6 @@
-/* basename.c -- return the last element in a path
+/* basename.c -- return the last element in a file name
 
-   Copyright (C) 1990, 1998, 1999, 2000, 2001, 2003, 2004 Free
+   Copyright (C) 1990, 1998, 1999, 2000, 2001, 2003, 2004, 2005 Free
    Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
Index: lib/canonicalize.c
===================================================================
RCS file: /fetish/cu/lib/canonicalize.c,v
retrieving revision 1.21
diff -p -u -r1.21 canonicalize.c
--- lib/canonicalize.c  18 May 2005 19:28:21 -0000      1.21
+++ lib/canonicalize.c  2 Jun 2005 04:54:32 -0000
@@ -48,7 +48,7 @@ void free ();
 #include <stddef.h>
 
 #include "cycle-check.h"
-#include "path-concat.h"
+#include "filenamecat.h"
 #include "stat-macros.h"
 #include "xalloc.h"
 #include "xgetcwd.h"
@@ -62,8 +62,8 @@ void free ();
 
 #if !HAVE_CANONICALIZE_FILE_NAME
 /* Return the canonical absolute name of file NAME.  A canonical name
-   does not contain any `.', `..' components nor any repeated path
-   separators ('/') or symlinks.  All path components must exist.
+   does not contain any `.', `..' components nor any repeated file name
+   separators ('/') or symlinks.  All components must exist.
    The result is malloc'd.  */
 
 char *
@@ -89,7 +89,7 @@ canonicalize_file_name (const char *name
 
   /* All known hosts with resolvepath (e.g. Solaris 7) don't turn
      relative names into absolute ones, so prepend the working
-     directory if the path is not absolute.  */
+     directory if the file name is not absolute.  */
   if (name[0] != '/')
     {
       char *wd;
@@ -97,7 +97,7 @@ canonicalize_file_name (const char *name
       if (!(wd = xgetcwd ()))
        return NULL;
 
-      extra_buf = path_concat (wd, name, NULL);
+      extra_buf = file_name_concat (wd, name, NULL);
       name = extra_buf;
       free (wd);
     }
@@ -135,15 +135,17 @@ canonicalize_file_name (const char *name
 #endif /* !HAVE_CANONICALIZE_FILE_NAME */
 
 /* Return the canonical absolute name of file NAME.  A canonical name
-   does not contain any `.', `..' components nor any repeated path
-   separators ('/') or symlinks.  Whether path components must exist
+   does not contain any `.', `..' components nor any repeated file name
+   separators ('/') or symlinks.  Whether components must exist
    or not depends on canonicalize mode.  The result is malloc'd.  */
 
 char *
 canonicalize_filename_mode (const char *name, canonicalize_mode_t can_mode)
 {
-  char *rpath, *dest, *extra_buf = NULL;
-  const char *start, *end, *rpath_limit;
+  char *rname, *dest, *extra_buf = NULL;
+  char const *start;
+  char const *end;
+  char const *rname_limit;
   size_t extra_len = 0;
   struct cycle_check_state cycle_state;
 
@@ -161,38 +163,38 @@ canonicalize_filename_mode (const char *
 
   if (name[0] != '/')
     {
-      rpath = xgetcwd ();
-      if (!rpath)
+      rname = xgetcwd ();
+      if (!rname)
        return NULL;
-      dest = strchr (rpath, '\0');
-      if (dest - rpath < PATH_MAX)
+      dest = strchr (rname, '\0');
+      if (dest - rname < PATH_MAX)
        {
-         char *p = xrealloc (rpath, PATH_MAX);
-         dest = p + (dest - rpath);
-         rpath = p;
-         rpath_limit = rpath + PATH_MAX;
+         char *p = xrealloc (rname, PATH_MAX);
+         dest = p + (dest - rname);
+         rname = p;
+         rname_limit = rname + PATH_MAX;
        }
       else
        {
-         rpath_limit = dest;
+         rname_limit = dest;
        }
     }
   else
     {
-      rpath = xmalloc (PATH_MAX);
-      rpath_limit = rpath + PATH_MAX;
-      rpath[0] = '/';
-      dest = rpath + 1;
+      rname = xmalloc (PATH_MAX);
+      rname_limit = rname + PATH_MAX;
+      rname[0] = '/';
+      dest = rname + 1;
     }
 
   cycle_check_init (&cycle_state);
   for (start = end = name; *start; start = end)
     {
-      /* Skip sequence of multiple path-separators.  */
+      /* Skip sequence of multiple file name separators.  */
       while (*start == '/')
        ++start;
 
-      /* Find end of path component.  */
+      /* Find end of component.  */
       for (end = start; *end && *end != '/'; ++end)
        /* Nothing.  */;
 
@@ -203,7 +205,7 @@ canonicalize_filename_mode (const char *
       else if (end - start == 2 && start[0] == '.' && start[1] == '.')
        {
          /* Back up to previous component, ignore if at root already.  */
-         if (dest > rpath + 1)
+         if (dest > rname + 1)
            while ((--dest)[-1] != '/');
        }
       else
@@ -213,26 +215,26 @@ canonicalize_filename_mode (const char *
          if (dest[-1] != '/')
            *dest++ = '/';
 
-         if (dest + (end - start) >= rpath_limit)
+         if (dest + (end - start) >= rname_limit)
            {
-             ptrdiff_t dest_offset = dest - rpath;
-             size_t new_size = rpath_limit - rpath;
+             ptrdiff_t dest_offset = dest - rname;
+             size_t new_size = rname_limit - rname;
 
              if (end - start + 1 > PATH_MAX)
                new_size += end - start + 1;
              else
                new_size += PATH_MAX;
-             rpath = xrealloc (rpath, new_size);
-             rpath_limit = rpath + new_size;
+             rname = xrealloc (rname, new_size);
+             rname_limit = rname + new_size;
 
-             dest = rpath + dest_offset;
+             dest = rname + dest_offset;
            }
 
          dest = memcpy (dest, start, end - start);
          dest += end - start;
          *dest = '\0';
 
-         if (lstat (rpath, &st) < 0)
+         if (lstat (rname, &st) != 0)
            {
              if (can_mode == CAN_EXISTING)
                goto error;
@@ -255,7 +257,7 @@ canonicalize_filename_mode (const char *
                    goto error;
                }
 
-             buf = xreadlink (rpath, st.st_size);
+             buf = xreadlink (rname, st.st_size);
              if (!buf)
                {
                  if (can_mode == CAN_MISSING)
@@ -284,10 +286,10 @@ canonicalize_filename_mode (const char *
              name = end = memcpy (extra_buf, buf, n);
 
              if (buf[0] == '/')
-               dest = rpath + 1;       /* It's an absolute symlink */
+               dest = rname + 1;       /* It's an absolute symlink */
              else
                /* Back up to previous component, ignore if at root already: */
-               if (dest > rpath + 1)
+               if (dest > rname + 1)
                  while ((--dest)[-1] != '/');
 
              free (buf);
@@ -302,15 +304,15 @@ canonicalize_filename_mode (const char *
            }
        }
     }
-  if (dest > rpath + 1 && dest[-1] == '/')
+  if (dest > rname + 1 && dest[-1] == '/')
     --dest;
   *dest = '\0';
 
   free (extra_buf);
-  return rpath;
+  return rname;
 
 error:
   free (extra_buf);
-  free (rpath);
+  free (rname);
   return NULL;
 }
Index: lib/canonicalize.h
===================================================================
RCS file: /fetish/cu/lib/canonicalize.h,v
retrieving revision 1.5
diff -p -u -r1.5 canonicalize.h
--- lib/canonicalize.h  14 May 2005 07:58:06 -0000      1.5
+++ lib/canonicalize.h  2 Jun 2005 04:54:32 -0000
@@ -1,5 +1,5 @@
 /* Return the canonical absolute name of a given file.
-   Copyright (C) 1996-2004 Free Software Foundation, Inc.
+   Copyright (C) 1996-2005 Free Software Foundation, Inc.
 
    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
@@ -21,10 +21,10 @@
 
 enum canonicalize_mode_t
   {
-    /* All path components must exist.  */
+    /* All components must exist.  */
     CAN_EXISTING = 0,
 
-    /* All path components excluding last one must exist.  */
+    /* All components excluding last one must exist.  */
     CAN_ALL_BUT_LAST = 1,
 
     /* No requirements on components existence.  */
Index: lib/dirname.c
===================================================================
RCS file: /fetish/cu/lib/dirname.c,v
retrieving revision 1.34
diff -p -u -r1.34 dirname.c
--- lib/dirname.c       14 May 2005 07:58:06 -0000      1.34
+++ lib/dirname.c       2 Jun 2005 04:54:32 -0000
@@ -1,6 +1,6 @@
-/* dirname.c -- return all but the last element in a path
+/* dirname.c -- return all but the last element in a file name
 
-   Copyright (C) 1990, 1998, 2000, 2001, 2003, 2004 Free Software
+   Copyright (C) 1990, 1998, 2000, 2001, 2003, 2004, 2005 Free Software
    Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
@@ -26,40 +26,40 @@
 #include <string.h>
 #include "xalloc.h"
 
-/* Return the length of `dirname (PATH)', or zero if PATH is
+/* Return the length of `dirname (FILE)', or zero if FILE is
    in the working directory.  Works properly even if
    there are trailing slashes (by effectively ignoring them).  */
 size_t
-dir_len (char const *path)
+dir_len (char const *file)
 {
-  size_t prefix_length = FILE_SYSTEM_PREFIX_LEN (path);
+  size_t prefix_length = FILE_SYSTEM_PREFIX_LEN (file);
   size_t length;
 
   /* Strip the basename and any redundant slashes before it.  */
-  for (length = base_name (path) - path;  prefix_length < length;  length--)
-    if (! ISSLASH (path[length - 1]))
+  for (length = base_name (file) - file;  prefix_length < length;  length--)
+    if (! ISSLASH (file[length - 1]))
       return length;
 
   /* But don't strip the only slash from "/".  */
-  return prefix_length + ISSLASH (path[prefix_length]);
+  return prefix_length + ISSLASH (file[prefix_length]);
 }
 
-/* Return the leading directories part of PATH,
+/* Return the leading directories part of FILE,
    allocated with xmalloc.
    Works properly even if there are trailing slashes
    (by effectively ignoring them).  */
 
 char *
-dir_name (char const *path)
+dir_name (char const *file)
 {
-  size_t length = dir_len (path);
-  bool append_dot = (length == FILE_SYSTEM_PREFIX_LEN (path));
-  char *newpath = xmalloc (length + append_dot + 1);
-  memcpy (newpath, path, length);
+  size_t length = dir_len (file);
+  bool append_dot = (length == FILE_SYSTEM_PREFIX_LEN (file));
+  char *dir = xmalloc (length + append_dot + 1);
+  memcpy (dir, file, length);
   if (append_dot)
-    newpath[length++] = '.';
-  newpath[length] = 0;
-  return newpath;
+    dir[length++] = '.';
+  dir[length] = 0;
+  return dir;
 }
 
 #ifdef TEST_DIRNAME
@@ -108,13 +108,13 @@ main (int argc, char *argv[])
   buff[MAX_BUFF_LEN] = 0;
   while (fgets (buff, MAX_BUFF_LEN, stdin) && buff[0])
     {
-      char path[MAX_BUFF_LEN];
+      char file[MAX_BUFF_LEN];
       char expected_result[MAX_BUFF_LEN];
       char const *result;
-      sscanf (buff, "%s %s", path, expected_result);
-      result = dir_name (path);
+      sscanf (buff, "%s %s", file, expected_result);
+      result = dir_name (file);
       if (strcmp (result, expected_result))
-       printf ("%s: got %s, expected %s\n", path, result, expected_result);
+       printf ("%s: got %s, expected %s\n", file, result, expected_result);
     }
   return 0;
 }
Index: lib/dirname.h
===================================================================
RCS file: /fetish/cu/lib/dirname.h,v
retrieving revision 1.14
diff -p -u -r1.14 dirname.h
--- lib/dirname.h       14 May 2005 07:58:06 -0000      1.14
+++ lib/dirname.h       2 Jun 2005 04:54:32 -0000
@@ -1,6 +1,6 @@
 /*  Take file names apart into directory and base names.
 
-    Copyright (C) 1998, 2001, 2003, 2004 Free Software Foundation, Inc.
+    Copyright (C) 1998, 2001, 2003, 2004, 2005 Free Software Foundation, Inc.
 
     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
@@ -31,17 +31,17 @@
 # endif
 
 # ifndef FILE_SYSTEM_PREFIX_LEN
-#  define FILE_SYSTEM_PREFIX_LEN(Filename) 0
+#  define FILE_SYSTEM_PREFIX_LEN(File_name) 0
 # endif
 
 # define IS_ABSOLUTE_FILE_NAME(F) ISSLASH ((F)[FILE_SYSTEM_PREFIX_LEN (F)])
 # define IS_RELATIVE_FILE_NAME(F) (! IS_ABSOLUTE_FILE_NAME (F))
 
-char *base_name (char const *path);
-char *dir_name (char const *path);
-size_t base_len (char const *path);
-size_t dir_len (char const *path);
+char *base_name (char const *file);
+char *dir_name (char const *file);
+size_t base_len (char const *file);
+size_t dir_len (char const *file);
 
-bool strip_trailing_slashes (char *path);
+bool strip_trailing_slashes (char *file);
 
 #endif /* not DIRNAME_H_ */
Index: lib/euidaccess.c
===================================================================
RCS file: /fetish/cu/lib/euidaccess.c,v
retrieving revision 1.21
diff -p -u -r1.21 euidaccess.c
--- lib/euidaccess.c    30 May 2005 07:30:01 -0000      1.21
+++ lib/euidaccess.c    2 Jun 2005 04:54:32 -0000
@@ -77,21 +77,21 @@
 
 #endif
 
-/* Return 0 if the user has permission of type MODE on file PATH;
+/* Return 0 if the user has permission of type MODE on FILE;
    otherwise, return -1 and set `errno'.
    Like access, except that it uses the effective user and group
    id's instead of the real ones, and it does not always check for read-only
    file system, text busy, etc.  */
 
 int
-euidaccess (const char *path, int mode)
+euidaccess (const char *file, int mode)
 {
 #if defined EFF_ONLY_OK
-  return access (path, mode | EFF_ONLY_OK);
+  return access (file, mode | EFF_ONLY_OK);
 #elif defined ACC_SELF
-  return accessx (path, mode, ACC_SELF);
+  return accessx (file, mode, ACC_SELF);
 #elif HAVE_EACCESS
-  return eaccess (path, mode);
+  return eaccess (file, mode);
 #else
 
   uid_t uid = getuid ();
@@ -110,7 +110,7 @@ euidaccess (const char *path, int mode)
      safe.  */
 
   if (mode == F_OK)
-    return stat (path, &stats);
+    return stat (file, &stats);
   else
     {
       int result;
@@ -121,7 +121,7 @@ euidaccess (const char *path, int mode)
       if (gid != egid)
        setregid (egid, gid);
 
-      result = access (path, mode);
+      result = access (file, mode);
       saved_errno = errno;
 
       /* Restore them.  */
@@ -143,9 +143,9 @@ euidaccess (const char *path, int mode)
   unsigned int granted;
   if (uid == euid && gid == egid)
     /* If we are not set-uid or set-gid, access does the same.  */
-    return access (path, mode);
+    return access (file, mode);
 
-  if (stat (path, &stats))
+  if (stat (file, &stats) != 0)
     return -1;
 
   /* The super-user can read and write any file, and execute any file
Index: lib/exclude.c
===================================================================
RCS file: /fetish/cu/lib/exclude.c,v
retrieving revision 1.24
diff -p -u -r1.24 exclude.c
--- lib/exclude.c       14 May 2005 07:58:06 -0000      1.24
+++ lib/exclude.c       2 Jun 2005 04:54:32 -0000
@@ -1,7 +1,7 @@
 /* exclude.c -- exclude file names
 
    Copyright (C) 1992, 1993, 1994, 1997, 1999, 2000, 2001, 2002, 2003,
-   2004 Free Software Foundation, Inc.
+   2004, 2005 Free Software Foundation, Inc.
 
    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
@@ -134,7 +134,7 @@ fnmatch_no_wildcards (char const *patter
 /* Return true if EX excludes F.  */
 
 bool
-excluded_filename (struct exclude const *ex, char const *f)
+excluded_file_name (struct exclude const *ex, char const *f)
 {
   size_t exclude_count = ex->exclude_count;
 
@@ -193,17 +193,17 @@ add_exclude (struct exclude *ex, char co
   patopts->options = options;
 }
 
-/* Use ADD_FUNC to append to EX the patterns in FILENAME, each with
+/* Use ADD_FUNC to append to EX the patterns in FILE_NAME, each with
    OPTIONS.  LINE_END terminates each pattern in the file.  If
    LINE_END is a space character, ignore trailing spaces and empty
    lines in FILE.  Return -1 on failure, 0 on success.  */
 
 int
 add_exclude_file (void (*add_func) (struct exclude *, char const *, int),
-                 struct exclude *ex, char const *filename, int options,
+                 struct exclude *ex, char const *file_name, int options,
                  char line_end)
 {
-  bool use_stdin = filename[0] == '-' && !filename[1];
+  bool use_stdin = file_name[0] == '-' && !file_name[1];
   FILE *in;
   char *buf = NULL;
   char *p;
@@ -216,7 +216,7 @@ add_exclude_file (void (*add_func) (stru
 
   if (use_stdin)
     in = stdin;
-  else if (! (in = fopen (filename, "r")))
+  else if (! (in = fopen (file_name, "r")))
     return -1;
 
   while ((c = getc (in)) != EOF)
Index: lib/exclude.h
===================================================================
RCS file: /fetish/cu/lib/exclude.h,v
retrieving revision 1.9
diff -p -u -r1.9 exclude.h
--- lib/exclude.h       14 May 2005 07:58:06 -0000      1.9
+++ lib/exclude.h       2 Jun 2005 04:54:32 -0000
@@ -1,7 +1,7 @@
 /* exclude.h -- declarations for excluding file names
 
-   Copyright (C) 1992, 1993, 1994, 1997, 1999, 2001, 2002, 2003 Free
-   Software Foundation, Inc.
+   Copyright (C) 1992, 1993, 1994, 1997, 1999, 2001, 2002, 2003, 2005
+   Free Software Foundation, Inc.
 
    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
@@ -40,4 +40,4 @@ void free_exclude (struct exclude *);
 void add_exclude (struct exclude *, char const *, int);
 int add_exclude_file (void (*) (struct exclude *, char const *, int),
                      struct exclude *, char const *, int, char);
-bool excluded_filename (struct exclude const *, char const *);
+bool excluded_file_name (struct exclude const *, char const *);
Index: lib/fnmatch_.h
===================================================================
RCS file: /fetish/cu/lib/fnmatch_.h,v
retrieving revision 1.4
diff -p -u -r1.4 fnmatch_.h
--- lib/fnmatch_.h      14 May 2005 07:58:06 -0000      1.4
+++ lib/fnmatch_.h      2 Jun 2005 04:54:32 -0000
@@ -1,5 +1,5 @@
-/* Copyright (C) 1991, 1992, 1993, 1996, 1997, 1998, 1999, 2001, 2002, 2003
-   Free Software Foundation, Inc.
+/* Copyright (C) 1991, 1992, 1993, 1996, 1997, 1998, 1999, 2001, 2002, 2003,
+   2005 Free Software Foundation, Inc.
 
    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
@@ -51,7 +51,7 @@ extern "C" {
 #  define FNM_NOSYS    (-1)
 # endif
 
-/* Match NAME against the filename pattern PATTERN,
+/* Match NAME against the file name pattern PATTERN,
    returning zero if it matches, FNM_NOMATCH if not.  */
 extern int fnmatch (const char *__pattern, const char *__name,
                    int __flags);
Index: lib/fnmatch_loop.c
===================================================================
RCS file: /fetish/cu/lib/fnmatch_loop.c,v
retrieving revision 1.9
diff -p -u -r1.9 fnmatch_loop.c
--- lib/fnmatch_loop.c  14 May 2005 07:58:06 -0000      1.9
+++ lib/fnmatch_loop.c  2 Jun 2005 04:54:32 -0000
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991,1992,1993,1996,1997,1998,1999,2000,2001,2002,2003,2004
+/* Copyright (C) 
1991,1992,1993,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005
        Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
@@ -15,7 +15,7 @@
    along with this program; if not, write to the Free Software Foundation,
    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
 
-/* Match STRING against the filename pattern PATTERN, returning zero if
+/* Match STRING against the file name pattern PATTERN, returning zero if
    it matches, nonzero if not.  */
 static int EXT (INT opt, const CHAR *pattern, const CHAR *string,
                const CHAR *string_end, bool no_leading_period, int flags)
Index: lib/fsusage.c
===================================================================
RCS file: /fetish/cu/lib/fsusage.c,v
retrieving revision 1.50
diff -p -u -r1.50 fsusage.c
--- lib/fsusage.c       14 May 2005 07:58:06 -0000      1.50
+++ lib/fsusage.c       2 Jun 2005 04:54:32 -0000
@@ -1,7 +1,7 @@
 /* fsusage.c -- return space usage of mounted file systems
 
-   Copyright (C) 1991, 1992, 1996, 1998, 1999, 2002, 2003, 2004 Free
-   Software Foundation, Inc.
+   Copyright (C) 1991, 1992, 1996, 1998, 1999, 2002, 2003, 2004, 2005
+   Free Software Foundation, Inc.
 
    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
@@ -103,20 +103,20 @@
 #define PROPAGATE_TOP_BIT(x) ((x) | ~ (EXTRACT_TOP_BIT (x) - 1))
 
 /* Fill in the fields of FSP with information about space usage for
-   the file system on which PATH resides.
-   DISK is the device on which PATH is mounted, for space-getting
+   the file system on which FILE resides.
+   DISK is the device on which FILE is mounted, for space-getting
    methods that need to know it.
    Return 0 if successful, -1 if not.  When returning -1, ensure that
    ERRNO is either a system error value, or zero if DISK is NULL
    on a system that requires a non-NULL value.  */
 int
-get_fs_usage (const char *path, const char *disk, struct fs_usage *fsp)
+get_fs_usage (char const *file, char const *disk, struct fs_usage *fsp)
 {
 #ifdef STAT_STATFS3_OSF1
 
   struct statfs fsd;
 
-  if (statfs (path, &fsd, sizeof (struct statfs)) != 0)
+  if (statfs (file, &fsd, sizeof (struct statfs)) != 0)
     return -1;
 
   fsp->fsu_blocksize = PROPAGATE_ALL_ONES (fsd.f_fsize);
@@ -127,7 +127,7 @@ get_fs_usage (const char *path, const ch
 
   struct fs_data fsd;
 
-  if (statfs (path, &fsd) != 1)
+  if (statfs (file, &fsd) != 1)
     return -1;
 
   fsp->fsu_blocksize = 1024;
@@ -181,7 +181,7 @@ get_fs_usage (const char *path, const ch
 
   struct statfs fsd;
 
-  if (statfs (path, &fsd) < 0)
+  if (statfs (file, &fsd) < 0)
     return -1;
 
   fsp->fsu_blocksize = PROPAGATE_ALL_ONES (fsd.f_bsize);
@@ -207,7 +207,7 @@ get_fs_usage (const char *path, const ch
 
   struct statfs fsd;
 
-  if (statfs (path, &fsd) < 0)
+  if (statfs (file, &fsd) < 0)
     return -1;
 
   fsp->fsu_blocksize = PROPAGATE_ALL_ONES (fsd.f_fsize);
@@ -222,7 +222,7 @@ get_fs_usage (const char *path, const ch
 
   struct statfs fsd;
 
-  if (statfs (path, &fsd, sizeof fsd, 0) < 0)
+  if (statfs (file, &fsd, sizeof fsd, 0) < 0)
     return -1;
 
   /* Empirically, the block counts on most SVR3 and SVR3-derived
@@ -240,7 +240,7 @@ get_fs_usage (const char *path, const ch
 
   struct statvfs fsd;
 
-  if (statvfs (path, &fsd) < 0)
+  if (statvfs (file, &fsd) < 0)
     return -1;
 
   /* f_frsize isn't guaranteed to be supported.  */
@@ -269,12 +269,12 @@ get_fs_usage (const char *path, const ch
 /* AIX PS/2 does not supply statfs.  */
 
 int
-statfs (char *path, struct statfs *fsb)
+statfs (char *file, struct statfs *fsb)
 {
   struct stat stats;
   struct dustat fsd;
 
-  if (stat (path, &stats))
+  if (stat (file, &stats) != 0)
     return -1;
   if (dustat (stats.st_dev, 0, &fsd, sizeof (fsd)))
     return -1;
Index: lib/fsusage.h
===================================================================
RCS file: /fetish/cu/lib/fsusage.h,v
retrieving revision 1.13
diff -p -u -r1.13 fsusage.h
--- lib/fsusage.h       14 May 2005 07:58:06 -0000      1.13
+++ lib/fsusage.h       2 Jun 2005 04:54:32 -0000
@@ -1,6 +1,6 @@
 /* fsusage.h -- declarations for file system space usage info
 
-   Copyright (C) 1991, 1992, 1997, 2003, 2004 Free Software
+   Copyright (C) 1991, 1992, 1997, 2003, 2004, 2005 Free Software
    Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
@@ -35,6 +35,6 @@ struct fs_usage
   uintmax_t fsu_ffree;         /* Free file nodes. */
 };
 
-int get_fs_usage (const char *path, const char *disk, struct fs_usage *fsp);
+int get_fs_usage (char const *file, char const *disk, struct fs_usage *fsp);
 
 #endif
Index: lib/fts.c
===================================================================
RCS file: /fetish/cu/lib/fts.c,v
retrieving revision 1.33
diff -p -u -r1.33 fts.c
--- lib/fts.c   28 May 2005 00:00:06 -0000      1.33
+++ lib/fts.c   2 Jun 2005 04:54:32 -0000
@@ -244,8 +244,8 @@ fts_open (char * const *argv,
                SET(FTS_NOCHDIR);
 
        /*
-        * Start out with 1K of path space, and enough, in any case,
-        * to hold the user's paths.
+        * Start out with 1K of file name space, and enough, in any case,
+        * to hold the user's file names.
         */
 #ifndef MAXPATHLEN
 # define MAXPATHLEN 1024
@@ -260,7 +260,7 @@ fts_open (char * const *argv,
 
        /* Allocate/initialize root(s). */
        for (root = NULL, nitems = 0; *argv != NULL; ++argv, ++nitems) {
-               /* Don't allow zero-length paths. */
+               /* Don't allow zero-length file names. */
                if ((len = strlen(*argv)) == 0) {
                        __set_errno (ENOENT);
                        goto mem3;
@@ -311,7 +311,7 @@ fts_open (char * const *argv,
 
        /*
         * If using chdir(2), grab a file descriptor pointing to dot to ensure
-        * that we can get back here; this could be avoided for some paths,
+        * that we can get back here; this could be avoided for some file names,
         * but almost certainly not worth the effort.  Slashes, symbolic links,
         * and ".." are all fairly nasty problems.  Note, if we can't get the
         * descriptor we run anyway, just more slowly.
@@ -341,7 +341,7 @@ fts_load (FTS *sp, register FTSENT *p)
         * actually enter the directory until after the preorder visit, set
         * the fts_accpath field specially so the chdir gets done to the right
         * place and the user can access the first node.  From fts_open it's
-        * known that the path will fit.
+        * known that the file name will fit.
         */
        len = p->fts_pathlen = p->fts_namelen;
        memmove(sp->fts_path, p->fts_name, len + 1);
@@ -374,7 +374,7 @@ fts_close (FTS *sp)
                free(p);
        }
 
-       /* Free up child linked list, sort array, path buffer. */
+       /* Free up child linked list, sort array, file name buffer. */
        if (sp->fts_child)
                fts_lfree(sp->fts_child);
        if (sp->fts_array)
@@ -403,8 +403,8 @@ fts_close (FTS *sp)
 }
 
 /*
- * Special case of "/" at the end of the path so that slashes aren't
- * appended which would cause paths to be written as "....//foo".
+ * Special case of "/" at the end of the file name so that slashes aren't
+ * appended which would cause file names to be written as "....//foo".
  */
 #define NAPPEND(p)                                                     \
        (p->fts_path[p->fts_pathlen - 1] == '/'                         \
@@ -524,7 +524,8 @@ next:       tmp = p;
 
                /*
                 * If reached the top, return to the original directory (or
-                * the root of the tree), and load the paths for the next root.
+                * the root of the tree), and load the file names for the next
+                * root.
                 */
                if (p->fts_level == FTS_ROOTLEVEL) {
                        if (FCHDIR(sp, sp->fts_rfd)) {
@@ -585,7 +586,7 @@ check_for_dir:
                return (sp->fts_cur = NULL);
        }
 
-       /* NUL terminate the pathname. */
+       /* NUL terminate the file name.  */
        sp->fts_path[p->fts_pathlen] = '\0';
 
        /*
@@ -685,8 +686,8 @@ fts_children (register FTS *sp, int inst
                instr = BCHILD;
 
        /*
-        * If using chdir on a relative path and called BEFORE fts_read does
-        * its chdir to the root of a traversal, we can lose -- we need to
+        * If using chdir on a relative file name and called BEFORE fts_read
+        * does its chdir to the root of a traversal, we can lose -- we need to
         * chdir into the subdirectory, and we don't know where the current
         * directory is, so we can't get back so that the upcoming chdir by
         * fts_read will work.
@@ -753,7 +754,7 @@ fts_build (register FTS *sp, int type)
        else
                oflag = DTF_HIDEW|DTF_NODUP|DTF_REWIND;
 #else
-# define __opendir2(path, flag) opendir(path)
+# define __opendir2(file, flag) opendir(file)
 #endif
        if ((dirp = __opendir2(cur->fts_accpath, oflag)) == NULL) {
                if (type == BREAD) {
@@ -787,7 +788,7 @@ fts_build (register FTS *sp, int type)
         * but set a flag so we don't chdir after the post-order visit.
         * We won't be able to stat anything, but we can still return the
         * names themselves.  Note, that since fts_read won't be able to
-        * chdir into the directory, it will have to return different path
+        * chdir into the directory, it will have to return different file
         * names than before, i.e. "a/b" instead of "b".  Since the node
         * has already been visited in pre-order, have to wait until the
         * post-order visit to return the error.  There is a special case
@@ -813,13 +814,13 @@ fts_build (register FTS *sp, int type)
 
        /*
         * Figure out the max file name length that can be stored in the
-        * current path -- the inner loop allocates more path as necessary.
+        * current buffer -- the inner loop allocates more space as necessary.
         * We really wouldn't have to do the maxlen calculations here, we
-        * could do them in fts_read before returning the path, but it's a
+        * could do them in fts_read before returning the name, but it's a
         * lot easier here since the length is part of the dirent structure.
         *
         * If not changing directories set a pointer so that can just append
-        * each new name into the path.
+        * each new component into the file name.
         */
        len = NAPPEND(cur);
        if (ISSET(FTS_NOCHDIR)) {
@@ -846,7 +847,7 @@ fts_build (register FTS *sp, int type)
                        oldaddr = sp->fts_path;
                        if (! fts_palloc(sp, NAMLEN (dp) + len + 1)) {
                                /*
-                                * No more memory for path or structures.  Save
+                                * No more memory.  Save
                                 * errno, free up the current structure and the
                                 * structures already allocated.
                                 */
@@ -873,7 +874,7 @@ mem1:                               saved_errno = errno;
                if (new_len < len) {
                        /*
                         * In the unlikely even that we would end up
-                        * with a path longer than SIZE_MAX, free up
+                        * with a file name longer than SIZE_MAX, free up
                         * the current structure and the structures already
                         * allocated, then error out with ENAMETOOLONG.
                         */
@@ -940,14 +941,14 @@ mem1:                             saved_errno = errno;
                closedir(dirp);
 
        /*
-        * If realloc() changed the address of the path, adjust the
+        * If realloc() changed the address of the file name, adjust the
         * addresses for the rest of the tree and the dir list.
         */
        if (doadjust)
                fts_padjust(sp, head);
 
        /*
-        * If not changing directories, reset the path back to original
+        * If not changing directories, reset the file name back to original
         * state.
         */
        if (ISSET(FTS_NOCHDIR)) {
@@ -959,7 +960,7 @@ mem1:                               saved_errno = errno;
        /*
         * If descended after called from fts_children or after called from
         * fts_read and nothing found, get back.  At the root level we use
-        * the saved fd; if one of fts_open()'s arguments is a relative path
+        * the saved fd; if one of fts_open()'s arguments is a relative name
         * to an empty directory, we wind up here with no other way back.  If
         * can't get back, we're done.
         */
@@ -1226,10 +1227,11 @@ fts_lfree (register FTSENT *head)
 }
 
 /*
- * Allow essentially unlimited paths; find, rm, ls should all work on any tree.
- * Most systems will allow creation of paths much longer than MAXPATHLEN, even
- * though the kernel won't resolve them.  Add the size (not just what's needed)
- * plus 256 bytes so don't realloc the path 2 bytes at a time.
+ * Allow essentially unlimited file name lengths; find, rm, ls should
+ * all work on any tree.  Most systems will allow creation of file
+ * names much longer than MAXPATHLEN, even though the kernel won't
+ * resolve them.  Add the size (not just what's needed) plus 256 bytes
+ * so don't realloc the file name 2 bytes at a time.
  */
 static bool
 internal_function
@@ -1262,8 +1264,8 @@ fts_palloc (FTS *sp, size_t more)
 }
 
 /*
- * When the path is realloc'd, have to fix all of the pointers in structures
- * already returned.
+ * When the file name is realloc'd, have to fix all of the pointers in
+ *  structures already returned.
  */
 static void
 internal_function
@@ -1303,13 +1305,13 @@ fts_maxarglen (char * const *argv)
 }
 
 /*
- * Change to dir specified by fd or path without getting
+ * Change to dir specified by fd or file name without getting
  * tricked by someone changing the world out from underneath us.
  * Assumes p->fts_statp->st_dev and p->fts_statp->st_ino are filled in.
  */
 static int
 internal_function
-fts_safe_changedir (FTS *sp, FTSENT *p, int fd, char const *path)
+fts_safe_changedir (FTS *sp, FTSENT *p, int fd, char const *dir)
 {
        int ret, oerrno, newfd;
        struct stat sb;
@@ -1317,7 +1319,7 @@ fts_safe_changedir (FTS *sp, FTSENT *p, 
        newfd = fd;
        if (ISSET(FTS_NOCHDIR))
                return (0);
-       if (fd < 0 && (newfd = fd_safer (diropen (path))) < 0)
+       if (fd < 0 && (newfd = fd_safer (diropen (dir))) < 0)
                return (-1);
        if (fstat(newfd, &sb)) {
                ret = -1;
Index: lib/fts_.h
===================================================================
RCS file: /fetish/cu/lib/fts_.h,v
retrieving revision 1.16
diff -p -u -r1.16 fts_.h
--- lib/fts_.h  20 May 2005 22:33:59 -0000      1.16
+++ lib/fts_.h  2 Jun 2005 04:54:32 -0000
@@ -71,7 +71,7 @@ typedef struct {
        struct _ftsent *fts_child;      /* linked list of children */
        struct _ftsent **fts_array;     /* sort array */
        dev_t fts_dev;                  /* starting device # */
-       char *fts_path;                 /* path for this descent */
+       char *fts_path;                 /* file name for this descent */
        int fts_rfd;                    /* fd for root */
        size_t fts_pathlen;             /* sizeof(path) */
        size_t fts_nitems;                      /* elements in the sort array */
@@ -135,8 +135,8 @@ typedef struct _ftsent {
        struct _ftsent *fts_link;       /* next file in directory */
        long fts_number;                /* local numeric value */
        void *fts_pointer;              /* local address value */
-       char *fts_accpath;              /* access path */
-       char *fts_path;                 /* root path; == fts_fts->fts_path */
+       char *fts_accpath;              /* access file name */
+       char *fts_path;                 /* root name; == fts_fts->fts_path */
        int fts_errno;                  /* errno for this node */
        int fts_symfd;                  /* fd for symlink */
        size_t fts_pathlen;             /* strlen(fts_path) */
Index: lib/getcwd.c
===================================================================
RCS file: /fetish/cu/lib/getcwd.c,v
retrieving revision 1.11
diff -p -u -r1.11 getcwd.c
--- lib/getcwd.c        14 May 2005 07:58:06 -0000      1.11
+++ lib/getcwd.c        2 Jun 2005 04:54:32 -0000
@@ -1,5 +1,5 @@
-/* Copyright (C) 1991,92,93,94,95,96,97,98,99,2004 Free Software Foundation,
-   Inc.
+/* Copyright (C) 1991,92,93,94,95,96,97,98,99,2004,2005 Free Software
+   Foundation, Inc.
    This file is part of the GNU C Library.
 
    This program is free software; you can redistribute it and/or modify
@@ -114,7 +114,7 @@
 # define __readdir readdir
 #endif
 
-/* Get the pathname of the current working directory, and put it in SIZE
+/* Get the name of the current working directory, and put it in SIZE
    bytes of BUF.  Returns NULL if the directory couldn't be determined or
    SIZE was too small.  If successful, returns BUF.  In GNU, if BUF is
    NULL, an array is allocated with `malloc'; the array is SIZE bytes long,
@@ -147,8 +147,8 @@ __getcwd (char *buf, size_t size)
   DIR *dirstream = NULL;
   dev_t rootdev, thisdev;
   ino_t rootino, thisino;
-  char *path;
-  register char *pathp;
+  char *dir;
+  register char *dirp;
   struct stat st;
   size_t allocated = size;
   size_t used;
@@ -161,9 +161,9 @@ __getcwd (char *buf, size_t size)
      So trust the system getcwd's results unless they look
      suspicious.  */
 # undef getcwd
-  path = getcwd (buf, size);
-  if (path || (errno != ERANGE && !is_ENAMETOOLONG (errno) && errno != ENOENT))
-    return path;
+  dir = getcwd (buf, size);
+  if (dir || (errno != ERANGE && !is_ENAMETOOLONG (errno) && errno != ENOENT))
+    return dir;
 #endif
 
   if (size == 0)
@@ -179,15 +179,15 @@ __getcwd (char *buf, size_t size)
 
   if (buf == NULL)
     {
-      path = malloc (allocated);
-      if (path == NULL)
+      dir = malloc (allocated);
+      if (dir == NULL)
        return NULL;
     }
   else
-    path = buf;
+    dir = buf;
 
-  pathp = path + allocated;
-  *--pathp = '\0';
+  dirp = dir + allocated;
+  *--dirp = '\0';
 
   if (__lstat (".", &st) < 0)
     goto lose;
@@ -318,10 +318,10 @@ __getcwd (char *buf, size_t size)
        }
       else
        {
-         size_t pathroom = pathp - path;
+         size_t dirroom = dirp - dir;
          size_t namlen = _D_EXACT_NAMLEN (d);
 
-         if (pathroom <= namlen)
+         if (dirroom <= namlen)
            {
              if (size != 0)
                {
@@ -335,20 +335,20 @@ __getcwd (char *buf, size_t size)
 
                  allocated += MAX (allocated, namlen);
                  if (allocated < oldsize
-                     || ! (tmp = realloc (path, allocated)))
+                     || ! (tmp = realloc (dir, allocated)))
                    goto memory_exhausted;
 
                  /* Move current contents up to the end of the buffer.
                     This is guaranteed to be non-overlapping.  */
-                 pathp = memcpy (tmp + allocated - (oldsize - pathroom),
-                                 tmp + pathroom,
-                                 oldsize - pathroom);
-                 path = tmp;
+                 dirp = memcpy (tmp + allocated - (oldsize - dirroom),
+                                tmp + dirroom,
+                                oldsize - dirroom);
+                 dir = tmp;
                }
            }
-         pathp -= namlen;
-         memcpy (pathp, d->d_name, namlen);
-         *--pathp = '/';
+         dirp -= namlen;
+         memcpy (dirp, d->d_name, namlen);
+         *--dirp = '/';
        }
 
       thisdev = dotdev;
@@ -361,25 +361,25 @@ __getcwd (char *buf, size_t size)
       goto lose;
     }
 
-  if (pathp == &path[allocated - 1])
-    *--pathp = '/';
+  if (dirp == &dir[allocated - 1])
+    *--dirp = '/';
 
 #ifndef AT_FDCWD
   if (dotlist != dots)
     free (dotlist);
 #endif
 
-  used = path + allocated - pathp;
-  memmove (path, pathp, used);
+  used = dir + allocated - dirp;
+  memmove (dir, dirp, used);
 
   if (buf == NULL && size == 0)
     /* Ensure that the buffer is only as large as necessary.  */
-    buf = realloc (path, used);
+    buf = realloc (dir, used);
 
   if (buf == NULL)
     /* Either buf was NULL all along, or `realloc' failed but
        we still have the original string.  */
-    buf = path;
+    buf = dir;
 
   return buf;
 
@@ -398,7 +398,7 @@ __getcwd (char *buf, size_t size)
       free (dotlist);
 #endif
     if (buf == NULL)
-      free (path);
+      free (dir);
     __set_errno (save);
   }
   return NULL;
Index: lib/getloadavg.c
===================================================================
RCS file: /fetish/cu/lib/getloadavg.c,v
retrieving revision 1.29
diff -p -u -r1.29 getloadavg.c
--- lib/getloadavg.c    14 May 2005 07:58:06 -0000      1.29
+++ lib/getloadavg.c    2 Jun 2005 04:54:32 -0000
@@ -32,7 +32,7 @@
                                AC_CHECK_FUNCS(pstat_getdynamic) in your
                                configure.in file.
    FIXUP_KERNEL_SYMBOL_ADDR()  Adjust address in returned struct nlist.
-   KERNEL_FILE                 Pathname of the kernel to nlist.
+   KERNEL_FILE                 Name of the kernel file to nlist.
    LDAV_CVT()                  Scale the load average from the kernel.
                                Returns a double.
    LDAV_SYMBOL                 Name of kernel symbol giving load average.
Index: lib/mkstemp.c
===================================================================
RCS file: /fetish/cu/lib/mkstemp.c,v
retrieving revision 1.4
diff -p -u -r1.4 mkstemp.c
--- lib/mkstemp.c       14 May 2005 07:58:06 -0000      1.4
+++ lib/mkstemp.c       2 Jun 2005 04:54:32 -0000
@@ -1,4 +1,4 @@
-/* Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
+/* Copyright (C) 1998, 1999, 2001, 2005 Free Software Foundation, Inc.
    This file is derived from the one in the GNU C Library.
 
    This program is free software; you can redistribute it and/or modify
@@ -33,7 +33,7 @@ int __gen_tempname ();
 
 /* Generate a unique temporary file name from TEMPLATE.
    The last six characters of TEMPLATE must be "XXXXXX";
-   they are replaced with a string that makes the filename unique.
+   they are replaced with a string that makes the file name unique.
    Then open the file and return a fd. */
 int
 rpl_mkstemp (char *template)
Index: lib/mountlist.c
===================================================================
RCS file: /fetish/cu/lib/mountlist.c,v
retrieving revision 1.51
diff -p -u -r1.51 mountlist.c
--- lib/mountlist.c     14 May 2005 07:58:06 -0000      1.51
+++ lib/mountlist.c     2 Jun 2005 04:54:32 -0000
@@ -755,16 +755,16 @@ read_file_system_list (bool need_fs_type
        me = xmalloc (sizeof *me);
        if (vmp->vmt_flags & MNT_REMOTE)
          {
-           char *host, *path;
+           char *host, *dir;
 
            me->me_remote = 1;
-           /* Prepend the remote pathname.  */
+           /* Prepend the remote dirname.  */
            host = thisent + vmp->vmt_data[VMT_HOSTNAME].vmt_off;
-           path = thisent + vmp->vmt_data[VMT_OBJECT].vmt_off;
-           me->me_devname = xmalloc (strlen (host) + strlen (path) + 2);
+           dir = thisent + vmp->vmt_data[VMT_OBJECT].vmt_off;
+           me->me_devname = xmalloc (strlen (host) + strlen (dir) + 2);
            strcpy (me->me_devname, host);
            strcat (me->me_devname, ":");
-           strcat (me->me_devname, path);
+           strcat (me->me_devname, dir);
          }
        else
          {
Index: lib/mountlist.h
===================================================================
RCS file: /fetish/cu/lib/mountlist.h,v
retrieving revision 1.19
diff -p -u -r1.19 mountlist.h
--- lib/mountlist.h     14 May 2005 08:03:44 -0000      1.19
+++ lib/mountlist.h     2 Jun 2005 04:54:32 -0000
@@ -26,8 +26,8 @@
 /* A mount table entry. */
 struct mount_entry
 {
-  char *me_devname;            /* Device node pathname, including "/dev/". */
-  char *me_mountdir;           /* Mount point directory pathname. */
+  char *me_devname;            /* Device node name, including "/dev/". */
+  char *me_mountdir;           /* Mount point directory name. */
   char *me_type;               /* "nfs", "4.2", etc. */
   dev_t me_dev;                        /* Device number of me_mountdir. */
   unsigned int me_dummy : 1;   /* Nonzero for dummy file systems. */
Index: lib/openat.c
===================================================================
RCS file: /fetish/cu/lib/openat.c,v
retrieving revision 1.7
diff -p -u -r1.7 openat.c
--- lib/openat.c        14 May 2005 07:58:06 -0000      1.7
+++ lib/openat.c        2 Jun 2005 04:54:32 -0000
@@ -43,7 +43,7 @@
    Otherwise, upon failure, set errno and return -1, as openat does.
    Upon successful completion, return a file descriptor.  */
 int
-rpl_openat (int fd, char const *filename, int flags, ...)
+rpl_openat (int fd, char const *file, int flags, ...)
 {
   struct saved_cwd saved_cwd;
   int saved_errno;
@@ -62,8 +62,8 @@ rpl_openat (int fd, char const *filename
       va_end (arg);
     }
 
-  if (fd == AT_FDCWD || *filename == '/')
-    return open (filename, flags, mode);
+  if (fd == AT_FDCWD || *file == '/')
+    return open (file, flags, mode);
 
   if (save_cwd (&saved_cwd) != 0)
     error (exit_failure, errno,
@@ -77,7 +77,7 @@ rpl_openat (int fd, char const *filename
       return -1;
     }
 
-  new_fd = open (filename, flags, mode);
+  new_fd = open (file, flags, mode);
   saved_errno = errno;
 
   if (restore_cwd (&saved_cwd) != 0)
@@ -140,7 +140,7 @@ fdopendir (int fd)
    then give a diagnostic and exit nonzero.
    Otherwise, this function works just like Solaris' fstatat.  */
 int
-fstatat (int fd, char const *filename, struct stat *st, int flag)
+fstatat (int fd, char const *file, struct stat *st, int flag)
 {
   struct saved_cwd saved_cwd;
   int saved_errno;
@@ -148,8 +148,8 @@ fstatat (int fd, char const *filename, s
 
   if (fd == AT_FDCWD)
     return (flag == AT_SYMLINK_NOFOLLOW
-           ? lstat (filename, st)
-           : stat (filename, st));
+           ? lstat (file, st)
+           : stat (file, st));
 
   if (save_cwd (&saved_cwd) != 0)
     error (exit_failure, errno,
@@ -164,8 +164,8 @@ fstatat (int fd, char const *filename, s
     }
 
   err = (flag == AT_SYMLINK_NOFOLLOW
-        ? lstat (filename, st)
-        : stat (filename, st));
+        ? lstat (file, st)
+        : stat (file, st));
   saved_errno = errno;
 
   if (restore_cwd (&saved_cwd) != 0)
Index: lib/openat.h
===================================================================
RCS file: /fetish/cu/lib/openat.h,v
retrieving revision 1.6
diff -p -u -r1.6 openat.h
--- lib/openat.h        14 May 2005 07:58:06 -0000      1.6
+++ lib/openat.h        2 Jun 2005 04:54:32 -0000
@@ -36,11 +36,11 @@
 #  define __OPENAT_XCONCAT(x, y) __OPENAT_CONCAT (x, y)
 #  define __OPENAT_ID(y) __OPENAT_XCONCAT (__OPENAT_PREFIX, y)
 #  define openat __OPENAT_ID (openat)
-int openat (int fd, char const *filename, int flags, /* mode_t mode */ ...);
+int openat (int fd, char const *file, int flags, /* mode_t mode */ ...);
 #  define fdopendir __OPENAT_ID (fdopendir)
 DIR *fdopendir (int fd);
 #  define fstatat __OPENAT_ID (fstatat)
-int fstatat (int fd, char const *filename, struct stat *st, int flag);
+int fstatat (int fd, char const *file, struct stat *st, int flag);
 # endif
 
 #endif
Index: lib/readlink-stub.c
===================================================================
RCS file: /fetish/cu/lib/readlink-stub.c,v
retrieving revision 1.2
diff -p -u -r1.2 readlink-stub.c
--- lib/readlink-stub.c 17 Mar 2003 19:21:28 -0000      1.2
+++ lib/readlink-stub.c 2 Jun 2005 04:54:32 -0000
@@ -8,7 +8,7 @@
    symlinks. */
 
 int
-readlink (const char *filename, char *buffer, size_t size)
+readlink (const char *file, char *buffer, size_t size)
 {
   errno = EINVAL;
   return -1;
Index: lib/readutmp.c
===================================================================
RCS file: /fetish/cu/lib/readutmp.c,v
retrieving revision 1.26
diff -p -u -r1.26 readutmp.c
--- lib/readutmp.c      14 May 2005 07:58:07 -0000      1.26
+++ lib/readutmp.c      2 Jun 2005 04:54:32 -0000
@@ -72,7 +72,7 @@ desirable_utmp_entry (STRUCT_UTMP const 
                || (kill (UT_PID (u), 0) < 0 && errno == ESRCH)));
 }
 
-/* Read the utmp entries corresponding to file FILENAME into freshly-
+/* Read the utmp entries corresponding to file FILE into freshly-
    malloc'd storage, set *UTMP_BUF to that pointer, set *N_ENTRIES to
    the number of entries, and return zero.  If there is any error,
    return -1, setting errno, and don't modify the parameters.
@@ -82,7 +82,7 @@ desirable_utmp_entry (STRUCT_UTMP const 
 #ifdef UTMP_NAME_FUNCTION
 
 int
-read_utmp (const char *filename, size_t *n_entries, STRUCT_UTMP **utmp_buf,
+read_utmp (char const *file, size_t *n_entries, STRUCT_UTMP **utmp_buf,
           int options)
 {
   size_t n_read = 0;
@@ -94,7 +94,7 @@ read_utmp (const char *filename, size_t 
      Solaris' utmpname returns 1 upon success -- which is contrary
      to what the GNU libc version does.  In addition, older GNU libc
      versions are actually void.   */
-  UTMP_NAME_FUNCTION (filename);
+  UTMP_NAME_FUNCTION (file);
 
   SET_UTMP_ENT ();
 
@@ -118,14 +118,14 @@ read_utmp (const char *filename, size_t 
 #else
 
 int
-read_utmp (const char *filename, size_t *n_entries, STRUCT_UTMP **utmp_buf,
+read_utmp (char const *file, size_t *n_entries, STRUCT_UTMP **utmp_buf,
           int options)
 {
   size_t n_read = 0;
   size_t n_alloc = 0;
   STRUCT_UTMP *utmp = NULL;
   int saved_errno;
-  FILE *f = fopen (filename, "r");
+  FILE *f = fopen (file, "r");
 
   if (! f)
     return -1;
Index: lib/readutmp.h
===================================================================
RCS file: /fetish/cu/lib/readutmp.h,v
retrieving revision 1.20
diff -p -u -r1.20 readutmp.h
--- lib/readutmp.h      14 May 2005 07:58:07 -0000      1.20
+++ lib/readutmp.h      2 Jun 2005 04:54:32 -0000
@@ -205,7 +205,7 @@ enum
   };
 
 char *extract_trimmed_name (const STRUCT_UTMP *ut);
-int read_utmp (const char *filename, size_t *n_entries, STRUCT_UTMP **utmp_buf,
+int read_utmp (char const *file, size_t *n_entries, STRUCT_UTMP **utmp_buf,
               int options);
 
 #endif /* __READUTMP_H__ */
Index: lib/rename.c
===================================================================
RCS file: /fetish/cu/lib/rename.c,v
retrieving revision 1.22
diff -p -u -r1.22 rename.c
--- lib/rename.c        14 May 2005 07:58:07 -0000      1.22
+++ lib/rename.c        2 Jun 2005 04:54:32 -0000
@@ -1,7 +1,7 @@
 /* Work around the bug in some systems whereby rename fails when the source
-   path has a trailing slash.  The rename functions of SunOS 4.1.1_U1 and
+   file has a trailing slash.  The rename functions of SunOS 4.1.1_U1 and
    mips-dec-ultrix4.4 have this bug.
-   Copyright (C) 2001-2003 Free Software Foundation, Inc.
+   Copyright (C) 2001, 2002, 2003, 2005 Free Software Foundation, Inc.
 
    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
@@ -31,27 +31,27 @@
 #include "dirname.h"
 #include "xalloc.h"
 
-/* Rename the file SRC_PATH to DST_PATH, removing any trailing
-   slashes from SRC_PATH.  Needed for SunOS 4.1.1_U1.  */
+/* Rename the file SRC to DST, removing any trailing
+   slashes from SRC.  Needed for SunOS 4.1.1_U1.  */
 
 int
-rpl_rename (const char *src_path, const char *dst_path)
+rpl_rename (char const *src, char const *dst)
 {
   char *src_temp;
   int ret_val;
-  size_t s_len = strlen (src_path);
+  size_t s_len = strlen (src);
 
-  if (s_len && src_path[s_len - 1] == '/')
+  if (s_len && src[s_len - 1] == '/')
     {
-      src_temp = xstrdup (src_path);
+      src_temp = xstrdup (src);
       strip_trailing_slashes (src_temp);
     }
   else
-    src_temp = (char *) src_path;
+    src_temp = (char *) src;
 
-  ret_val = rename (src_temp, dst_path);
+  ret_val = rename (src_temp, dst);
 
-  if (src_temp != src_path)
+  if (src_temp != src)
     free (src_temp);
 
   return ret_val;
Index: lib/rmdir.c
===================================================================
RCS file: /fetish/cu/lib/rmdir.c,v
retrieving revision 1.14
diff -p -u -r1.14 rmdir.c
--- lib/rmdir.c 14 May 2005 07:58:07 -0000      1.14
+++ lib/rmdir.c 2 Jun 2005 04:54:32 -0000
@@ -1,6 +1,7 @@
 /* BSD compatible remove directory function for System V
 
-   Copyright (C) 1988, 1990, 1999, 2003, 2004 Free Software Foundation, Inc.
+   Copyright (C) 1988, 1990, 1999, 2003, 2004, 2005 Free Software
+   Foundation, Inc.
 
    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
@@ -28,17 +29,17 @@
 
 /* rmdir adapted from GNU tar.  */
 
-/* Remove directory DPATH.
+/* Remove directory DIR.
    Return 0 if successful, -1 if not.  */
 
 int
-rmdir (char const *dpath)
+rmdir (char const *dir)
 {
   pid_t cpid;
   int status;
   struct stat statbuf;
 
-  if (stat (dpath, &statbuf) != 0)
+  if (stat (dir, &statbuf) != 0)
     return -1;                 /* errno already set */
 
   if (!S_ISDIR (statbuf.st_mode))
@@ -54,7 +55,7 @@ rmdir (char const *dpath)
       return -1;               /* errno already set */
 
     case 0:                    /* child process */
-      execl ("/bin/rmdir", "rmdir", dpath, (char *) 0);
+      execl ("/bin/rmdir", "rmdir", dir, (char *) 0);
       _exit (1);
 
     default:                   /* parent process */
Index: lib/same.c
===================================================================
RCS file: /fetish/cu/lib/same.c,v
retrieving revision 1.15
diff -p -u -r1.15 same.c
--- lib/same.c  14 May 2005 07:58:07 -0000      1.15
+++ lib/same.c  2 Jun 2005 04:54:32 -0000
@@ -1,6 +1,6 @@
 /* Determine whether two file names refer to the same file.
 
-   Copyright (C) 1997, 1998, 1999, 2000, 2002, 2003, 2004 Free
+   Copyright (C) 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005 Free
    Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
@@ -72,7 +72,7 @@ same_name (const char *source, const cha
   bool same = false;
 
 #if ! _POSIX_NO_TRUNC && HAVE_PATHCONF && defined _PC_NAME_MAX
-  /* This implementation silently truncates pathname components.  If
+  /* This implementation silently truncates components of file names.  If
      the base names might be truncated, check whether the truncated
      base names are the same, while checking the directories.  */
   size_t slen_max = HAVE_LONG_FILE_NAMES ? 255 : _POSIX_NAME_MAX;
Index: lib/savedir.c
===================================================================
RCS file: /fetish/cu/lib/savedir.c,v
retrieving revision 1.25
diff -p -u -r1.25 savedir.c
--- lib/savedir.c       14 May 2005 07:58:07 -0000      1.25
+++ lib/savedir.c       2 Jun 2005 04:54:32 -0000
@@ -1,6 +1,6 @@
 /* savedir.c -- save the list of files in a directory in a string
 
-   Copyright 1990, 1997, 1998, 1999, 2000, 2001, 2003, 2004 Free
+   Copyright 1990, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005 Free
    Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
@@ -57,7 +57,7 @@
 
 #include "xalloc.h"
 
-/* Return a freshly allocated string containing the filenames
+/* Return a freshly allocated string containing the file names
    in directory DIR, separated by '\0' characters;
    the end is marked by two '\0' characters in a row.
    Return NULL (setting errno) if DIR cannot be opened, read, or closed.  */
Index: lib/stripslash.c
===================================================================
RCS file: /fetish/cu/lib/stripslash.c,v
retrieving revision 1.13
diff -p -u -r1.13 stripslash.c
--- lib/stripslash.c    14 May 2005 07:58:07 -0000      1.13
+++ lib/stripslash.c    2 Jun 2005 04:54:32 -0000
@@ -1,5 +1,6 @@
 /* stripslash.c -- remove redundant trailing slashes from a file name
-   Copyright (C) 1990, 2001, 2003, 2004 Free Software Foundation, Inc.
+
+   Copyright (C) 1990, 2001, 2003, 2004, 2005 Free Software Foundation, Inc.
 
    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
@@ -21,17 +22,17 @@
 
 #include "dirname.h"
 
-/* Remove trailing slashes from PATH.
+/* Remove trailing slashes from FILE.
    Return true if a trailing slash was removed.
-   This is useful when using filename completion from a shell that
+   This is useful when using file name completion from a shell that
    adds a "/" after directory names (such as tcsh and bash), because
    the Unix rename and rmdir system calls return an "Invalid argument" error
-   when given a path that ends in "/" (except for the root directory).  */
+   when given a file that ends in "/" (except for the root directory).  */
 
 bool
-strip_trailing_slashes (char *path)
+strip_trailing_slashes (char *file)
 {
-  char *base = base_name (path);
+  char *base = base_name (file);
   char *base_lim = base + base_len (base);
   bool had_slash = (*base_lim != '\0');
   *base_lim = '\0';
Index: lib/tempname.c
===================================================================
RCS file: /fetish/cu/lib/tempname.c,v
retrieving revision 1.13
diff -p -u -r1.13 tempname.c
--- lib/tempname.c      14 May 2005 07:58:07 -0000      1.13
+++ lib/tempname.c      2 Jun 2005 04:54:32 -0000
@@ -78,8 +78,8 @@
 # define __mkdir mkdir
 # define __open open
 # define __open64 open
-# define __lxstat64(version, path, buf) lstat (path, buf)
-# define __xstat64(version, path, buf) stat (path, buf)
+# define __lxstat64(version, file, buf) lstat (file, buf)
+# define __xstat64(version, file, buf) stat (file, buf)
 #endif
 
 #if ! (HAVE___SECURE_GETENV || _LIBC)
@@ -185,7 +185,7 @@ __path_search (char *tmpl, size_t tmpl_l
   return 0;
 }
 
-/* These are the characters used in temporary filenames.  */
+/* These are the characters used in temporary file names.  */
 static const char letters[] =
 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 
Index: lib/xreadlink.c
===================================================================
RCS file: /fetish/cu/lib/xreadlink.c,v
retrieving revision 1.17
diff -p -u -r1.17 xreadlink.c
--- lib/xreadlink.c     14 May 2005 07:58:07 -0000      1.17
+++ lib/xreadlink.c     2 Jun 2005 04:54:32 -0000
@@ -1,6 +1,6 @@
 /* xreadlink.c -- readlink wrapper to return the link name in malloc'd storage
 
-   Copyright (C) 2001, 2003, 2004 Free Software Foundation, Inc.
+   Copyright (C) 2001, 2003, 2004, 2005 Free Software Foundation, Inc.
 
    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
@@ -45,7 +45,7 @@
 
 #include "xalloc.h"
 
-/* Call readlink to get the symbolic link value of FILENAME.
+/* Call readlink to get the symbolic link value of FILE.
    SIZE is a hint as to how long the link is expected to be;
    typically it is taken from st_size.  It need not be correct.
    Return a pointer to that NUL-terminated string in malloc'd storage.
@@ -54,7 +54,7 @@
    give a diagnostic and exit.  */
 
 char *
-xreadlink (char const *filename, size_t size)
+xreadlink (char const *file, size_t size)
 {
   /* The initial buffer size for the link value.  A power of 2
      detects arithmetic overflow earlier, but is not required.  */
@@ -63,7 +63,7 @@ xreadlink (char const *filename, size_t 
   while (1)
     {
       char *buffer = xmalloc (buf_size);
-      ssize_t r = readlink (filename, buffer, buf_size);
+      ssize_t r = readlink (file, buffer, buf_size);
       size_t link_length = r;
 
       /* On AIX 5L v5.3 and HP-UX 11i v2 04/09, readlink returns -1
Index: m4/getcwd-path-max.m4
===================================================================
RCS file: /fetish/cu/m4/getcwd-path-max.m4,v
retrieving revision 1.16
diff -p -u -r1.16 getcwd-path-max.m4
--- m4/getcwd-path-max.m4       29 Mar 2005 07:18:58 -0000      1.16
+++ m4/getcwd-path-max.m4       2 Jun 2005 04:54:32 -0000
@@ -1,5 +1,5 @@
-#serial 8
-# Check for several getcwd bugs with long paths.
+#serial 9
+# Check for several getcwd bugs with long file names.
 # If so, arrange to compile the wrapper function.
 
 # This is necessary for at least GNU libc on linux-2.4.19 and 2.4.20.
Index: m4/prereq.m4
===================================================================
RCS file: /fetish/cu/m4/prereq.m4,v
retrieving revision 1.113
diff -p -u -r1.113 prereq.m4
--- m4/prereq.m4        27 May 2005 20:35:07 -0000      1.113
+++ m4/prereq.m4        2 Jun 2005 04:54:32 -0000
@@ -1,4 +1,4 @@
-#serial 56
+#serial 57
 
 dnl We use gl_ for non Autoconf macros.
 m4_pattern_forbid([^gl_[ABCDEFGHIJKLMNOPQRSTUVXYZ]])dnl
@@ -48,6 +48,7 @@ AC_DEFUN([gl_PREREQ],
   AC_REQUIRE([gl_EXITFAIL])
   AC_REQUIRE([gl_FILEBLOCKS])
   AC_REQUIRE([gl_FILEMODE])
+  AC_REQUIRE([gl_FILE_NAME_CONCAT])
   AC_REQUIRE([gl_FILE_TYPE])
   AC_REQUIRE([gl_FSUSAGE])
   AC_REQUIRE([gl_FUNC_ALLOCA])
@@ -104,15 +105,14 @@ AC_DEFUN([gl_PREREQ],
   AC_REQUIRE([gl_LINEBUFFER])
   AC_REQUIRE([gl_LOCALCHARSET])
   AC_REQUIRE([gl_LONG_OPTIONS])
-  AC_REQUIRE([gl_MAKEPATH])
   AC_REQUIRE([gl_MBSWIDTH])
   AC_REQUIRE([gl_MD5])
   AC_REQUIRE([gl_MEMCOLL])
+  AC_REQUIRE([gl_MKDIR_PARENTS])
   AC_REQUIRE([gl_MODECHANGE])
   AC_REQUIRE([gl_MOUNTLIST])
   AC_REQUIRE([gl_OBSTACK])
   AC_REQUIRE([gl_PATHMAX])
-  AC_REQUIRE([gl_PATH_CONCAT])
   AC_REQUIRE([gl_PHYSMEM])
   AC_REQUIRE([gl_POSIXTM])
   AC_REQUIRE([gl_POSIXVER])
Index: m4/rename.m4
===================================================================
RCS file: /fetish/cu/m4/rename.m4,v
retrieving revision 1.9
diff -p -u -r1.9 rename.m4
--- m4/rename.m4        23 Jan 2005 09:07:57 -0000      1.9
+++ m4/rename.m4        2 Jun 2005 04:54:32 -0000
@@ -1,12 +1,12 @@
-#serial 7
+#serial 8
 
-# Copyright (C) 2001, 2003 Free Software Foundation, Inc.
+# Copyright (C) 2001, 2003, 2005 Free Software Foundation, Inc.
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
 # with or without modifications, as long as this notice is preserved.
 
 dnl From Volker Borchert.
-dnl Determine whether rename works for source paths with a trailing slash.
+dnl Determine whether rename works for source file names with a trailing slash.
 dnl The rename from SunOS 4.1.1_U1 doesn't.
 dnl
 dnl If it doesn't, then define RENAME_TRAILING_SLASH_BUG and arrange
@@ -41,8 +41,8 @@ AC_DEFUN([vb_FUNC_RENAME],
     AC_DEFINE(rename, rpl_rename,
       [Define to rpl_rename if the replacement function should be used.])
     AC_DEFINE(RENAME_TRAILING_SLASH_BUG, 1,
-      [Define if rename does not work for source paths with a trailing slash,
-       like the one from SunOS 4.1.1_U1.])
+      [Define if rename does not work for source file names with a trailing
+       slash, like the one from SunOS 4.1.1_U1.])
     gl_PREREQ_RENAME
   fi
 ])
Index: src/basename.c
===================================================================
RCS file: /fetish/cu/src/basename.c,v
retrieving revision 1.62
diff -p -u -r1.62 basename.c
--- src/basename.c      14 May 2005 07:58:36 -0000      1.62
+++ src/basename.c      2 Jun 2005 04:54:32 -0000
@@ -1,4 +1,4 @@
-/* basename -- strip directory and suffix from filenames
+/* basename -- strip directory and suffix from file names
    Copyright (C) 1990-1997, 1999-2005 Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
@@ -16,7 +16,7 @@
    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
 
 /* Usage: basename name [suffix]
-   NAME is a pathname; SUFFIX is a suffix to strip from it.
+   NAME is a file name; SUFFIX is a suffix to strip from it.
 
    basename /usr/foo/lossage/functions.l
    => functions.l
Index: src/copy.c
===================================================================
RCS file: /fetish/cu/src/copy.c,v
retrieving revision 1.184
diff -p -u -r1.184 copy.c
--- src/copy.c  31 May 2005 07:06:23 -0000      1.184
+++ src/copy.c  2 Jun 2005 04:54:33 -0000
@@ -36,11 +36,11 @@
 #include "dirname.h"
 #include "euidaccess.h"
 #include "error.h"
+#include "filenamecat.h"
 #include "full-write.h"
 #include "getpagesize.h"
 #include "hash.h"
 #include "hash-pjw.h"
-#include "path-concat.h"
 #include "quote.h"
 #include "same.h"
 #include "savedir.h"
@@ -77,7 +77,7 @@ struct F_triple
 /* Initial size of the above hash table.  */
 #define DEST_INFO_INITIAL_CAPACITY 61
 
-static bool copy_internal (const char *src_path, const char *dst_path,
+static bool copy_internal (char const *src_name, char const *dst_name,
                           bool new_dst, dev_t device,
                           struct dir_list *ancestors,
                           const struct cp_options *x,
@@ -87,8 +87,8 @@ static bool copy_internal (const char *s
 
 /* Pointers to the file names:  they're used in the diagnostic that is issued
    when we detect the user is trying to copy a directory into itself.  */
-static char const *top_level_src_path;
-static char const *top_level_dst_path;
+static char const *top_level_src_name;
+static char const *top_level_dst_name;
 
 /* The invocation name of this program.  */
 extern char *program_name;
@@ -130,16 +130,16 @@ is_ancestor (const struct stat *sb, cons
   return false;
 }
 
-/* Read the contents of the directory SRC_PATH_IN, and recursively
-   copy the contents to DST_PATH_IN.  NEW_DST is true if
-   DST_PATH_IN is a directory that was created previously in the
-   recursion.   SRC_SB and ANCESTORS describe SRC_PATH_IN.
-   Set *COPY_INTO_SELF if SRC_PATH_IN is a parent of
-   (or the same as) DST_PATH_IN; otherwise, clear it.
+/* Read the contents of the directory SRC_NAME_IN, and recursively
+   copy the contents to DST_NAME_IN.  NEW_DST is true if
+   DST_NAME_IN is a directory that was created previously in the
+   recursion.   SRC_SB and ANCESTORS describe SRC_NAME_IN.
+   Set *COPY_INTO_SELF if SRC_NAME_IN is a parent of
+   (or the same as) DST_NAME_IN; otherwise, clear it.
    Return true if successful.  */
 
 static bool
-copy_dir (const char *src_path_in, const char *dst_path_in, bool new_dst,
+copy_dir (char const *src_name_in, char const *dst_name_in, bool new_dst,
          const struct stat *src_sb, struct dir_list *ancestors,
          const struct cp_options *x, bool *copy_into_self)
 {
@@ -148,12 +148,12 @@ copy_dir (const char *src_path_in, const
   struct cp_options non_command_line_options = *x;
   bool ok = true;
 
-  name_space = savedir (src_path_in);
+  name_space = savedir (src_name_in);
   if (name_space == NULL)
     {
       /* This diagnostic is a bit vague because savedir can fail in
          several different ways.  */
-      error (0, errno, _("cannot access %s"), quote (src_path_in));
+      error (0, errno, _("cannot access %s"), quote (src_name_in));
       return false;
     }
 
@@ -166,16 +166,16 @@ copy_dir (const char *src_path_in, const
   while (*namep != '\0')
     {
       bool local_copy_into_self;
-      char *src_path = path_concat (src_path_in, namep, NULL);
-      char *dst_path = path_concat (dst_path_in, namep, NULL);
+      char *src_name = file_name_concat (src_name_in, namep, NULL);
+      char *dst_name = file_name_concat (dst_name_in, namep, NULL);
 
-      ok &= copy_internal (src_path, dst_path, new_dst, src_sb->st_dev,
+      ok &= copy_internal (src_name, dst_name, new_dst, src_sb->st_dev,
                           ancestors, &non_command_line_options, false,
                           &local_copy_into_self, NULL);
       *copy_into_self |= local_copy_into_self;
 
-      free (dst_path);
-      free (src_path);
+      free (dst_name);
+      free (src_name);
 
       namep += strlen (namep) + 1;
     }
@@ -183,7 +183,7 @@ copy_dir (const char *src_path_in, const
   return ok;
 }
 
-/* Copy a regular file from SRC_PATH to DST_PATH.
+/* Copy a regular file from SRC_NAME to DST_NAME.
    If the source file contains holes, copies holes and blocks of zeros
    in the source file as holes in the destination file.
    (Holes are read as zeroes by the `read' system call.)
@@ -191,10 +191,10 @@ copy_dir (const char *src_path_in, const
    X provides many option settings.
    Return true if successful.
    *NEW_DST is as in copy_internal.  SRC_SB is the result
-   of calling xstat (aka stat in this case) on SRC_PATH.  */
+   of calling xstat (aka stat in this case) on SRC_NAME.  */
 
 static bool
-copy_reg (const char *src_path, const char *dst_path,
+copy_reg (char const *src_name, char const *dst_name,
          const struct cp_options *x, mode_t dst_mode, bool *new_dst,
          struct stat const *src_sb)
 {
@@ -212,17 +212,17 @@ copy_reg (const char *src_path, const ch
   bool last_write_made_hole = false;
   bool make_holes = false;
 
-  source_desc = open (src_path, O_RDONLY);
+  source_desc = open (src_name, O_RDONLY);
   source_desc = fd_safer (source_desc);
   if (source_desc < 0)
     {
-      error (0, errno, _("cannot open %s for reading"), quote (src_path));
+      error (0, errno, _("cannot open %s for reading"), quote (src_name));
       return false;
     }
 
   if (fstat (source_desc, &src_open_sb))
     {
-      error (0, errno, _("cannot fstat %s"), quote (src_path));
+      error (0, errno, _("cannot fstat %s"), quote (src_name));
       return_val = false;
       goto close_src_desc;
     }
@@ -233,7 +233,7 @@ copy_reg (const char *src_path, const ch
     {
       error (0, 0,
             _("skipping file %s, as it was replaced while being copied"),
-            quote (src_path));
+            quote (src_name));
       return_val = false;
       goto close_src_desc;
     }
@@ -242,17 +242,17 @@ copy_reg (const char *src_path, const ch
      The if-block will be taken in move_mode.  */
   if (*new_dst)
     {
-      dest_desc = open (dst_path, O_WRONLY | O_CREAT, dst_mode);
+      dest_desc = open (dst_name, O_WRONLY | O_CREAT, dst_mode);
     }
   else
     {
-      dest_desc = open (dst_path, O_WRONLY | O_TRUNC, dst_mode);
+      dest_desc = open (dst_name, O_WRONLY | O_TRUNC, dst_mode);
 
       if (dest_desc < 0 && x->unlink_dest_after_failed_open)
        {
-         if (unlink (dst_path))
+         if (unlink (dst_name) != 0)
            {
-             error (0, errno, _("cannot remove %s"), quote (dst_path));
+             error (0, errno, _("cannot remove %s"), quote (dst_name));
              return_val = false;
              goto close_src_desc;
            }
@@ -261,14 +261,14 @@ copy_reg (const char *src_path, const ch
          *new_dst = true;
 
          /* Try the open again, but this time with different flags.  */
-         dest_desc = open (dst_path, O_WRONLY | O_CREAT, dst_mode);
+         dest_desc = open (dst_name, O_WRONLY | O_CREAT, dst_mode);
        }
     }
 
   dest_desc = fd_safer (dest_desc);
   if (dest_desc < 0)
     {
-      error (0, errno, _("cannot create regular file %s"), quote (dst_path));
+      error (0, errno, _("cannot create regular file %s"), quote (dst_name));
       return_val = false;
       goto close_src_desc;
     }
@@ -278,7 +278,7 @@ copy_reg (const char *src_path, const ch
 
   if (fstat (dest_desc, &sb))
     {
-      error (0, errno, _("cannot fstat %s"), quote (dst_path));
+      error (0, errno, _("cannot fstat %s"), quote (dst_name));
       return_val = false;
       goto close_src_and_dst_desc;
     }
@@ -293,12 +293,12 @@ copy_reg (const char *src_path, const ch
 #if HAVE_STRUCT_STAT_ST_BLOCKS
   if (x->sparse_mode == SPARSE_AUTO && S_ISREG (sb.st_mode))
     {
-      /* Use a heuristic to determine whether SRC_PATH contains any
+      /* Use a heuristic to determine whether SRC_NAME contains any
         sparse blocks. */
 
       if (fstat (source_desc, &sb))
        {
-         error (0, errno, _("cannot fstat %s"), quote (src_path));
+         error (0, errno, _("cannot fstat %s"), quote (src_name));
          return_val = false;
          goto close_src_and_dst_desc;
        }
@@ -327,7 +327,7 @@ copy_reg (const char *src_path, const ch
          if (errno == EINTR)
            continue;
 #endif
-         error (0, errno, _("reading %s"), quote (src_path));
+         error (0, errno, _("reading %s"), quote (src_name));
          return_val = false;
          goto close_src_and_dst_desc;
        }
@@ -361,7 +361,7 @@ copy_reg (const char *src_path, const ch
              /* Make a hole.  */
              if (lseek (dest_desc, (off_t) n_read, SEEK_CUR) < 0L)
                {
-                 error (0, errno, _("cannot lseek %s"), quote (dst_path));
+                 error (0, errno, _("cannot lseek %s"), quote (dst_name));
                  return_val = false;
                  goto close_src_and_dst_desc;
                }
@@ -376,7 +376,7 @@ copy_reg (const char *src_path, const ch
          size_t n = n_read;
          if (full_write (dest_desc, buf, n) != n)
            {
-             error (0, errno, _("writing %s"), quote (dst_path));
+             error (0, errno, _("writing %s"), quote (dst_name));
              return_val = false;
              goto close_src_and_dst_desc;
            }
@@ -400,7 +400,7 @@ copy_reg (const char *src_path, const ch
          || full_write (dest_desc, "", 1) != 1)
 #endif
        {
-         error (0, errno, _("writing %s"), quote (dst_path));
+         error (0, errno, _("writing %s"), quote (dst_name));
          return_val = false;
        }
     }
@@ -408,13 +408,13 @@ copy_reg (const char *src_path, const ch
 close_src_and_dst_desc:
   if (close (dest_desc) < 0)
     {
-      error (0, errno, _("closing %s"), quote (dst_path));
+      error (0, errno, _("closing %s"), quote (dst_name));
       return_val = false;
     }
 close_src_desc:
   if (close (source_desc) < 0)
     {
-      error (0, errno, _("closing %s"), quote (src_path));
+      error (0, errno, _("closing %s"), quote (src_name));
       return_val = false;
     }
 
@@ -439,8 +439,8 @@ close_src_desc:
    successfully.  */
 
 static bool
-same_file_ok (const char *src_path, const struct stat *src_sb,
-             const char *dst_path, const struct stat *dst_sb,
+same_file_ok (char const *src_name, struct stat const *src_sb,
+             char const *dst_name, struct stat const *dst_sb,
              const struct cp_options *x, bool *return_now, bool *unlink_src)
 {
   const struct stat *src_sb_link;
@@ -473,7 +473,7 @@ same_file_ok (const char *src_path, cons
         know this here IFF preserving symlinks (aka xstat == lstat),
         then it's ok -- as long as they are distinct.  */
       if (S_ISLNK (src_sb->st_mode) && S_ISLNK (dst_sb->st_mode))
-       return ! same_name (src_path, dst_path);
+       return ! same_name (src_name, dst_name);
 
       src_sb_link = src_sb;
       dst_sb_link = dst_sb;
@@ -483,8 +483,8 @@ same_file_ok (const char *src_path, cons
       if (!same)
        return true;
 
-      if (lstat (dst_path, &tmp_dst_sb)
-         || lstat (src_path, &tmp_src_sb))
+      if (lstat (dst_name, &tmp_dst_sb) != 0
+         || lstat (src_name, &tmp_src_sb) != 0)
        return true;
 
       src_sb_link = &tmp_src_sb;
@@ -536,17 +536,17 @@ same_file_ok (const char *src_path, cons
          return true;
        }
 
-      return ! same_name (src_path, dst_path);
+      return ! same_name (src_name, dst_name);
     }
 
 #if 0
   /* FIXME: use or remove */
 
   /* If we're making a backup, we'll detect the problem case in
-     copy_reg because SRC_PATH will no longer exist.  Allowing
+     copy_reg because SRC_NAME will no longer exist.  Allowing
      the test to be deferred lets cp do some useful things.
-     But when creating hardlinks and SRC_PATH is a symlink
-     but DST_PATH is not we must test anyway.  */
+     But when creating hardlinks and SRC_NAME is a symlink
+     but DST_NAME is not we must test anyway.  */
   if (x->hard_link
       || !S_ISLNK (src_sb_link->st_mode)
       || S_ISLNK (dst_sb_link->st_mode))
@@ -559,7 +559,7 @@ same_file_ok (const char *src_path, cons
   /* They may refer to the same file if we're in move mode and the
      target is a symlink.  That is ok, since we remove any existing
      destination file before opening it -- via `rename' if they're on
-     the same file system, via `unlink (DST_PATH)' otherwise.
+     the same file system, via `unlink (DST_NAME)' otherwise.
      It's also ok if they're distinct hard links to the same file.  */
   if (x->move_mode || x->unlink_dest_before_opening)
     {
@@ -568,7 +568,7 @@ same_file_ok (const char *src_path, cons
 
       if (same_link
          && 1 < dst_sb_link->st_nlink
-         && ! same_name (src_path, dst_path))
+         && ! same_name (src_name, dst_name))
        {
          if (x->move_mode)
            {
@@ -605,12 +605,12 @@ same_file_ok (const char *src_path, cons
     {
       if ( ! S_ISLNK (src_sb_link->st_mode))
        tmp_src_sb = *src_sb_link;
-      else if (stat (src_path, &tmp_src_sb))
+      else if (stat (src_name, &tmp_src_sb) != 0)
        return true;
 
       if ( ! S_ISLNK (dst_sb_link->st_mode))
        tmp_dst_sb = *dst_sb_link;
-      else if (stat (dst_path, &tmp_dst_sb))
+      else if (stat (dst_name, &tmp_dst_sb) != 0)
        return true;
 
       if ( ! SAME_INODE (tmp_src_sb, tmp_dst_sb))
@@ -628,19 +628,19 @@ same_file_ok (const char *src_path, cons
 }
 
 static void
-overwrite_prompt (char const *dst_path, struct stat const *dst_sb)
+overwrite_prompt (char const *dst_name, struct stat const *dst_sb)
 {
-  if (euidaccess (dst_path, W_OK) != 0)
+  if (euidaccess (dst_name, W_OK) != 0)
     {
       fprintf (stderr,
               _("%s: overwrite %s, overriding mode %04lo? "),
-              program_name, quote (dst_path),
+              program_name, quote (dst_name),
               (unsigned long int) (dst_sb->st_mode & CHMOD_MODE_BITS));
     }
   else
     {
       fprintf (stderr, _("%s: overwrite %s? "),
-              program_name, quote (dst_path));
+              program_name, quote (dst_name));
     }
 }
 
@@ -728,9 +728,9 @@ src_info_init (struct cp_options *x)
 }
 
 /* Return true if there is an entry in hash table, HT,
-   for the file described by FILENAME and STATS.  */
+   for the file described by FILE and STATS.  */
 static bool
-seen_file (Hash_table const *ht, char const *filename,
+seen_file (Hash_table const *ht, char const *file,
           struct stat const *stats)
 {
   struct F_triple new_ent;
@@ -738,20 +738,20 @@ seen_file (Hash_table const *ht, char co
   if (ht == NULL)
     return false;
 
-  new_ent.name = (char *) filename;
+  new_ent.name = (char *) file;
   new_ent.st_ino = stats->st_ino;
   new_ent.st_dev = stats->st_dev;
 
   return !!hash_lookup (ht, &new_ent);
 }
 
-/* Record destination filename, FILENAME, and dev/ino from *STATS,
+/* Record destination file, FILE, and dev/ino from *STATS,
    in the hash table, HT.  If HT is NULL, return immediately.
-   If STATS is NULL, call lstat on FILENAME to get the device
+   If STATS is NULL, call lstat on FILE to get the device
    and inode numbers.  If that lstat fails, simply return.
    If memory allocation fails, exit immediately.  */
 static void
-record_file (Hash_table *ht, char const *filename,
+record_file (Hash_table *ht, char const *file,
             struct stat const *stats)
 {
   struct F_triple *ent;
@@ -760,7 +760,7 @@ record_file (Hash_table *ht, char const 
     return;
 
   ent = xmalloc (sizeof *ent);
-  ent->name = xstrdup (filename);
+  ent->name = xstrdup (file);
   if (stats)
     {
       ent->st_ino = stats->st_ino;
@@ -769,7 +769,7 @@ record_file (Hash_table *ht, char const 
   else
     {
       struct stat sb;
-      if (lstat (filename, &sb))
+      if (lstat (file, &sb) != 0)
        return;
       ent->st_ino = sb.st_ino;
       ent->st_dev = sb.st_dev;
@@ -792,15 +792,15 @@ record_file (Hash_table *ht, char const 
   }
 }
 
-/* When effecting a move (e.g., for mv(1)), and given the name DST_PATH
+/* When effecting a move (e.g., for mv(1)), and given the name DST_NAME
    of the destination and a corresponding stat buffer, DST_SB, return
    true if the logical `move' operation should _not_ proceed.
    Otherwise, return false.
    Depending on options specified in X, this code may issue an
-   interactive prompt asking whether it's ok to overwrite DST_PATH.  */
+   interactive prompt asking whether it's ok to overwrite DST_NAME.  */
 static bool
 abandon_move (const struct cp_options *x,
-              char const *dst_path,
+              char const *dst_name,
               struct stat const *dst_sb)
 {
   assert (x->move_mode);
@@ -808,25 +808,25 @@ abandon_move (const struct cp_options *x
           || ((x->interactive == I_ASK_USER
                || (x->interactive == I_UNSPECIFIED
                    && x->stdin_tty
-                   && UNWRITABLE (dst_path, dst_sb->st_mode)))
-              && (overwrite_prompt (dst_path, dst_sb), 1)
+                   && UNWRITABLE (dst_name, dst_sb->st_mode)))
+              && (overwrite_prompt (dst_name, dst_sb), 1)
               && ! yesno ()));
 }
 
-/* Copy the file SRC_PATH to the file DST_PATH.  The files may be of
-   any type.  NEW_DST should be true if the file DST_PATH cannot
+/* Copy the file SRC_NAME to the file DST_NAME.  The files may be of
+   any type.  NEW_DST should be true if the file DST_NAME cannot
    exist because its parent directory was just created; NEW_DST should
-   be false if DST_PATH might already exist.  DEVICE is the device
+   be false if DST_NAME might already exist.  DEVICE is the device
    number of the parent directory, or 0 if the parent of this file is
    not known.  ANCESTORS points to a linked, null terminated list of
-   devices and inodes of parent directories of SRC_PATH.  COMMAND_LINE_ARG
-   is true iff SRC_PATH was specified on the command line.
-   Set *COPY_INTO_SELF if SRC_PATH is a parent of (or the
-   same as) DST_PATH; otherwise, clear it.
+   devices and inodes of parent directories of SRC_NAME.  COMMAND_LINE_ARG
+   is true iff SRC_NAME was specified on the command line.
+   Set *COPY_INTO_SELF if SRC_NAME is a parent of (or the
+   same as) DST_NAME; otherwise, clear it.
    Return true if successful.  */
 
 static bool
-copy_internal (const char *src_path, const char *dst_path,
+copy_internal (char const *src_name, char const *dst_name,
               bool new_dst,
               dev_t device,
               struct dir_list *ancestors,
@@ -852,9 +852,9 @@ copy_internal (const char *src_path, con
 
   *copy_into_self = false;
 
-  if (XSTAT (x, src_path, &src_sb))
+  if (XSTAT (x, src_name, &src_sb) != 0)
     {
-      error (0, errno, _("cannot stat %s"), quote (src_path));
+      error (0, errno, _("cannot stat %s"), quote (src_name));
       return false;
     }
 
@@ -864,7 +864,7 @@ copy_internal (const char *src_path, con
 
   if (S_ISDIR (src_type) && !x->recursive)
     {
-      error (0, 0, _("omitting directory %s"), quote (src_path));
+      error (0, 0, _("omitting directory %s"), quote (src_name));
       return false;
     }
 
@@ -876,23 +876,23 @@ copy_internal (const char *src_path, con
     {
       if ( ! S_ISDIR (src_sb.st_mode)
           && x->backup_type == no_backups
-          && seen_file (x->src_info, src_path, &src_sb))
+          && seen_file (x->src_info, src_name, &src_sb))
        {
          error (0, 0, _("warning: source file %s specified more than once"),
-                quote (src_path));
+                quote (src_name));
          return true;
        }
 
-      record_file (x->src_info, src_path, &src_sb);
+      record_file (x->src_info, src_name, &src_sb);
     }
 
   if (!new_dst)
     {
-      if (XSTAT (x, dst_path, &dst_sb))
+      if (XSTAT (x, dst_name, &dst_sb) != 0)
        {
          if (errno != ENOENT)
            {
-             error (0, errno, _("cannot stat %s"), quote (dst_path));
+             error (0, errno, _("cannot stat %s"), quote (dst_name));
              return false;
            }
          else
@@ -904,17 +904,17 @@ copy_internal (const char *src_path, con
        {
          bool return_now;
          bool unlink_src;
-         bool ok = same_file_ok (src_path, &src_sb, dst_path, &dst_sb,
+         bool ok = same_file_ok (src_name, &src_sb, dst_name, &dst_sb,
                                  x, &return_now, &unlink_src);
          if (unlink_src)
            {
-             if (!abandon_move (x, dst_path, &dst_sb)
-                 && unlink (src_path))
+             if (!abandon_move (x, dst_name, &dst_sb)
+                 && unlink (src_name) != 0)
                {
-                 error (0, errno, _("cannot remove %s"), quote (src_path));
+                 error (0, errno, _("cannot remove %s"), quote (src_name));
                  return false;
                }
-             /* Tell the caller that there's no need to remove src_path.  */
+             /* Tell the caller that there's no need to remove src_name.  */
              if (rename_succeeded)
                *rename_succeeded = true;
            }
@@ -925,7 +925,7 @@ copy_internal (const char *src_path, con
          if (! ok)
            {
              error (0, 0, _("%s and %s are the same file"),
-                    quote_n (0, src_path), quote_n (1, dst_path));
+                    quote_n (0, src_name), quote_n (1, dst_name));
              return false;
            }
 
@@ -935,7 +935,7 @@ copy_internal (const char *src_path, con
                {
                  error (0, 0,
                     _("cannot overwrite non-directory %s with directory %s"),
-                        quote_n (0, dst_path), quote_n (1, src_path));
+                        quote_n (0, dst_name), quote_n (1, src_name));
                  return false;
                }
 
@@ -948,11 +948,11 @@ copy_internal (const char *src_path, con
                 Note that it works fine if you use --backup=numbered.  */
              if (command_line_arg
                  && x->backup_type != numbered_backups
-                 && seen_file (x->dest_info, dst_path, &dst_sb))
+                 && seen_file (x->dest_info, dst_name, &dst_sb))
                {
                  error (0, 0,
                         _("will not overwrite just-created %s with %s"),
-                        quote_n (0, dst_path), quote_n (1, src_path));
+                        quote_n (0, dst_name), quote_n (1, src_name));
                  return false;
                }
            }
@@ -963,7 +963,7 @@ copy_internal (const char *src_path, con
                {
                  error (0, 0,
                       _("cannot overwrite directory %s with non-directory"),
-                        quote (dst_path));
+                        quote (dst_name));
                  return false;
                }
 
@@ -979,7 +979,7 @@ copy_internal (const char *src_path, con
                                 ? UTIMECMP_TRUNCATE_SOURCE
                                 : 0);
 
-                 if (0 <= utimecmp (dst_path, &dst_sb, &src_sb, options))
+                 if (0 <= utimecmp (dst_name, &dst_sb, &src_sb, options))
                    {
                      /* We're using --update and the destination is not older
                         than the source, so do not copy or move.  Pretend the
@@ -1002,7 +1002,7 @@ copy_internal (const char *src_path, con
              /* cp and mv treat -i and -f differently.  */
              if (x->move_mode)
                {
-                 if (abandon_move (x, dst_path, &dst_sb))
+                 if (abandon_move (x, dst_name, &dst_sb))
                    {
                      /* Pretend the rename succeeded, so the caller (mv)
                         doesn't end up removing the source file.  */
@@ -1015,7 +1015,7 @@ copy_internal (const char *src_path, con
                {
                  if (x->interactive == I_ALWAYS_NO
                      || (x->interactive == I_ASK_USER
-                         && (overwrite_prompt (dst_path, &dst_sb), 1)
+                         && (overwrite_prompt (dst_name, &dst_sb), 1)
                          && ! yesno ()))
                    {
                      return true;
@@ -1029,7 +1029,7 @@ copy_internal (const char *src_path, con
              if (S_ISDIR (dst_sb.st_mode))
                {
                  error (0, 0, _("cannot overwrite directory %s"),
-                        quote (dst_path));
+                        quote (dst_name));
                  return false;
                }
 
@@ -1038,14 +1038,14 @@ copy_internal (const char *src_path, con
                {
                  error (0, 0,
                       _("cannot move directory onto non-directory: %s -> %s"),
-                        quote_n (0, src_path), quote_n (0, dst_path));
+                        quote_n (0, src_name), quote_n (0, dst_name));
                  return false;
                }
            }
 
          if (x->backup_type != no_backups && !S_ISDIR (dst_sb.st_mode))
            {
-             char *tmp_backup = find_backup_file_name (dst_path,
+             char *tmp_backup = find_backup_file_name (dst_name,
                                                        x->backup_type);
 
              /* Detect (and fail) when creating the backup file would
@@ -1054,31 +1054,31 @@ copy_internal (const char *src_path, con
                 would leave two zero-length files: a and a~.  */
              /* FIXME: but simply change e.g., the final a~ to `./a~'
                 and the source will still be destroyed.  */
-             if (STREQ (tmp_backup, src_path))
+             if (STREQ (tmp_backup, src_name))
                {
                  const char *fmt;
                  fmt = (x->move_mode
                 ? _("backing up %s would destroy source;  %s not moved")
                 : _("backing up %s would destroy source;  %s not copied"));
                  error (0, 0, fmt,
-                        quote_n (0, dst_path),
-                        quote_n (1, src_path));
+                        quote_n (0, dst_name),
+                        quote_n (1, src_name));
                  free (tmp_backup);
                  return false;
                }
 
              /* FIXME: use fts:
-                Using alloca for a pathname that may be (in theory) arbitrarily
+                Using alloca for a file name that may be arbitrarily
                 long is not recommended.  In fact, even forming such a name
                 should be discouraged.  Eventually, this code will be rewritten
                 to use fts, so using alloca here will be less of a problem.  */
              ASSIGN_STRDUPA (dst_backup, tmp_backup);
              free (tmp_backup);
-             if (rename (dst_path, dst_backup))
+             if (rename (dst_name, dst_backup) != 0)
                {
                  if (errno != ENOENT)
                    {
-                     error (0, errno, _("cannot backup %s"), quote (dst_path));
+                     error (0, errno, _("cannot backup %s"), quote (dst_name));
                      return false;
                    }
                  else
@@ -1098,9 +1098,9 @@ copy_internal (const char *src_path, con
                       || (x->dereference == DEREF_NEVER
                           && S_ISLNK (src_sb.st_mode))))
            {
-             if (unlink (dst_path) && errno != ENOENT)
+             if (unlink (dst_name) != 0 && errno != ENOENT)
                {
-                 error (0, errno, _("cannot remove %s"), quote (dst_path));
+                 error (0, errno, _("cannot remove %s"), quote (dst_name));
                  return false;
                }
              new_dst = true;
@@ -1113,13 +1113,13 @@ copy_internal (const char *src_path, con
      sure we'll create a directory. */
   if (x->verbose && !S_ISDIR (src_type))
     {
-      printf ("%s -> %s", quote_n (0, src_path), quote_n (1, dst_path));
+      printf ("%s -> %s", quote_n (0, src_name), quote_n (1, dst_name));
       if (backup_succeeded)
        printf (_(" (backup: %s)"), quote (dst_backup));
       putchar ('\n');
     }
 
-  /* Associate the destination path with the source device and inode
+  /* Associate the destination file name with the source device and inode
      so that if we encounter a matching dev/ino pair in the source tree
      we can arrange to create a hard link between the corresponding names
      in the destination tree.
@@ -1161,7 +1161,7 @@ copy_internal (const char *src_path, con
                || x->dereference == DEREF_ALWAYS))
           || (x->recursive && S_ISDIR (src_type)))
     {
-      earlier_file = remember_copied (dst_path, src_sb.st_ino, src_sb.st_dev);
+      earlier_file = remember_copied (dst_name, src_sb.st_ino, src_sb.st_dev);
     }
 
   /* Did we copy this inode somewhere else (in this command line argument)
@@ -1174,43 +1174,43 @@ copy_internal (const char *src_path, con
         directories).  */
       if (S_ISDIR (src_type))
        {
-         /* If src_path and earlier_file refer to the same directory entry,
+         /* If src_name and earlier_file refer to the same directory entry,
             then warn about copying a directory into itself.  */
-         if (same_name (src_path, earlier_file))
+         if (same_name (src_name, earlier_file))
            {
              error (0, 0, _("cannot copy a directory, %s, into itself, %s"),
-                    quote_n (0, top_level_src_path),
-                    quote_n (1, top_level_dst_path));
+                    quote_n (0, top_level_src_name),
+                    quote_n (1, top_level_dst_name));
              *copy_into_self = true;
            }
          else
            {
              error (0, 0, _("will not create hard link %s to directory %s"),
-                    quote_n (0, dst_path), quote_n (1, earlier_file));
+                    quote_n (0, dst_name), quote_n (1, earlier_file));
            }
 
          goto un_backup;
        }
 
       {
-       bool link_failed = (link (earlier_file, dst_path) != 0);
+       bool link_failed = (link (earlier_file, dst_name) != 0);
 
        /* If the link failed because of an existing destination,
           remove that file and then call link again.  */
        if (link_failed && errno == EEXIST)
          {
-           if (unlink (dst_path))
+           if (unlink (dst_name) != 0)
              {
-               error (0, errno, _("cannot remove %s"), quote (dst_path));
+               error (0, errno, _("cannot remove %s"), quote (dst_name));
                goto un_backup;
              }
-           link_failed = (link (earlier_file, dst_path) != 0);
+           link_failed = (link (earlier_file, dst_name) != 0);
          }
 
        if (link_failed)
          {
            error (0, errno, _("cannot create hard link %s to %s"),
-                  quote_n (0, dst_path), quote_n (1, earlier_file));
+                  quote_n (0, dst_name), quote_n (1, earlier_file));
            goto un_backup;
          }
 
@@ -1220,23 +1220,23 @@ copy_internal (const char *src_path, con
 
   if (x->move_mode)
     {
-      if (rename (src_path, dst_path) == 0)
+      if (rename (src_name, dst_name) == 0)
        {
          if (x->verbose && S_ISDIR (src_type))
-           printf ("%s -> %s\n", quote_n (0, src_path), quote_n (1, dst_path));
+           printf ("%s -> %s\n", quote_n (0, src_name), quote_n (1, dst_name));
          if (rename_succeeded)
            *rename_succeeded = true;
 
          if (command_line_arg)
            {
-             /* Record destination dev/ino/filename, so that if we are asked
+             /* Record destination dev/ino/name, so that if we are asked
                 to overwrite that file again, we can detect it and fail.  */
              /* It's fine to use the _source_ stat buffer (src_sb) to get the
                 _destination_ dev/ino, since the rename above can't have
                 changed those, and `mv' always uses lstat.
                 We could limit it further by operating
                 only on non-directories.  */
-             record_file (x->dest_info, dst_path, &src_sb);
+             record_file (x->dest_info, dst_name, &src_sb);
            }
 
          return true;
@@ -1249,7 +1249,7 @@ copy_internal (const char *src_path, con
         subdirectory of itself.  */
       if (errno == EINVAL
 
-         /* When src_path is on an NFS file system, some types of
+         /* When src_name is on an NFS file system, some types of
             clients, e.g., SunOS4.1.4 and IRIX-5.3, set errno to EIO
             instead.  Testing for this here risks misinterpreting a real
             I/O error as an attempt to move a directory into itself, so
@@ -1264,8 +1264,8 @@ copy_internal (const char *src_path, con
             failing with a specific errno value.  Expect problems on
             non-POSIX systems.  */
          error (0, 0, _("cannot move %s to a subdirectory of itself, %s"),
-                quote_n (0, top_level_src_path),
-                quote_n (1, top_level_dst_path));
+                quote_n (0, top_level_src_name),
+                quote_n (1, top_level_dst_name));
 
          /* Note that there is no need to call forget_created here,
             (compare with the other calls in this file) since the
@@ -1307,7 +1307,7 @@ copy_internal (const char *src_path, con
             fail.  Etc.  */
          error (0, errno,
                 _("cannot move %s to %s"),
-                quote_n (0, src_path), quote_n (1, dst_path));
+                quote_n (0, src_name), quote_n (1, dst_name));
          forget_created (src_sb.st_ino, src_sb.st_dev);
          return false;
        }
@@ -1315,11 +1315,11 @@ copy_internal (const char *src_path, con
       /* The rename attempt has failed.  Remove any existing destination
         file so that a cross-device `mv' acts as if it were really using
         the rename syscall.  */
-      if (unlink (dst_path) && errno != ENOENT)
+      if (unlink (dst_name) != 0 && errno != ENOENT)
        {
          error (0, errno,
             _("inter-device move failed: %s to %s; unable to remove target"),
-                quote_n (0, src_path), quote_n (1, dst_path));
+                quote_n (0, src_name), quote_n (1, dst_name));
          forget_created (src_sb.st_ino, src_sb.st_dev);
          return false;
        }
@@ -1347,7 +1347,7 @@ copy_internal (const char *src_path, con
       if (is_ancestor (&src_sb, ancestors))
        {
          error (0, 0, _("cannot copy cyclic symbolic link %s"),
-                quote (src_path));
+                quote (src_name));
          goto un_backup;
        }
 
@@ -1363,10 +1363,10 @@ copy_internal (const char *src_path, con
          /* Create the new directory writable and searchable, so
              we can create new entries in it.  */
 
-         if (mkdir (dst_path, (src_mode & x->umask_kill) | S_IRWXU))
+         if (mkdir (dst_name, (src_mode & x->umask_kill) | S_IRWXU) != 0)
            {
              error (0, errno, _("cannot create directory %s"),
-                    quote (dst_path));
+                    quote (dst_name));
              goto un_backup;
            }
 
@@ -1374,11 +1374,11 @@ copy_internal (const char *src_path, con
              numbers into the search structure, so that we can
              avoid copying it again.  */
 
-         if (! remember_created (dst_path))
+         if (! remember_created (dst_name))
            goto un_backup;
 
          if (x->verbose)
-           printf ("%s -> %s\n", quote_n (0, src_path), quote_n (1, dst_path));
+           printf ("%s -> %s\n", quote_n (0, src_name), quote_n (1, dst_name));
        }
 
       /* Are we crossing a file system boundary?  */
@@ -1387,7 +1387,7 @@ copy_internal (const char *src_path, con
 
       /* Copy the contents of the directory.  */
 
-      if (! copy_dir (src_path, dst_path, new_dst, &src_sb, dir, x,
+      if (! copy_dir (src_name, dst_name, new_dst, &src_sb, dir, x,
                      copy_into_self))
        {
          /* Don't just return here -- otherwise, the failure to read a
@@ -1401,19 +1401,19 @@ copy_internal (const char *src_path, con
     {
       preserve_metadata = false;
 
-      if (*src_path != '/')
+      if (*src_name != '/')
        {
-         /* Check that DST_PATH denotes a file in the current directory.  */
+         /* Check that DST_NAME denotes a file in the current directory.  */
          struct stat dot_sb;
          struct stat dst_parent_sb;
          char *dst_parent;
          bool in_current_dir;
 
-         dst_parent = dir_name (dst_path);
+         dst_parent = dir_name (dst_name);
 
          in_current_dir = (STREQ (".", dst_parent)
                            /* If either stat call fails, it's ok not to report
-                              the failure and say dst_path is in the current
+                              the failure and say dst_name is in the current
                               directory.  Other things will fail later.  */
                            || stat (".", &dot_sb)
                            || stat (dst_parent, &dst_parent_sb)
@@ -1424,14 +1424,14 @@ copy_internal (const char *src_path, con
            {
              error (0, 0,
           _("%s: can make relative symbolic links only in current directory"),
-                    quote (dst_path));
+                    quote (dst_name));
              goto un_backup;
            }
        }
-      if (symlink (src_path, dst_path))
+      if (symlink (src_name, dst_name) != 0)
        {
          error (0, errno, _("cannot create symbolic link %s to %s"),
-                quote_n (0, dst_path), quote_n (1, src_path));
+                quote_n (0, dst_name), quote_n (1, src_name));
          goto un_backup;
        }
     }
@@ -1439,9 +1439,9 @@ copy_internal (const char *src_path, con
   else if (x->hard_link)
     {
       preserve_metadata = false;
-      if (link (src_path, dst_path))
+      if (link (src_name, dst_name))
        {
-         error (0, errno, _("cannot create link %s"), quote (dst_path));
+         error (0, errno, _("cannot create link %s"), quote (dst_name));
          goto un_backup;
        }
     }
@@ -1453,7 +1453,7 @@ copy_internal (const char *src_path, con
       /* POSIX says the permission bits of the source file must be
         used as the 3rd argument in the open call, but that's not consistent
         with historical practice.  */
-      if (! copy_reg (src_path, dst_path, x,
+      if (! copy_reg (src_name, dst_name, x,
                      get_dest_mode (x, src_mode), &new_dst, &src_sb))
        goto un_backup;
     }
@@ -1461,9 +1461,9 @@ copy_internal (const char *src_path, con
 #ifdef S_ISFIFO
   if (S_ISFIFO (src_type))
     {
-      if (mkfifo (dst_path, get_dest_mode (x, src_mode)))
+      if (mkfifo (dst_name, get_dest_mode (x, src_mode)))
        {
-         error (0, errno, _("cannot create fifo %s"), quote (dst_path));
+         error (0, errno, _("cannot create fifo %s"), quote (dst_name));
          goto un_backup;
        }
     }
@@ -1472,10 +1472,10 @@ copy_internal (const char *src_path, con
     if (S_ISBLK (src_type) || S_ISCHR (src_type)
        || S_ISSOCK (src_type))
     {
-      if (mknod (dst_path, get_dest_mode (x, src_mode), src_sb.st_rdev))
+      if (mknod (dst_name, get_dest_mode (x, src_mode), src_sb.st_rdev))
        {
          error (0, errno, _("cannot create special file %s"),
-                quote (dst_path));
+                quote (dst_name));
          goto un_backup;
        }
     }
@@ -1483,14 +1483,14 @@ copy_internal (const char *src_path, con
 #ifdef S_ISLNK
   if (S_ISLNK (src_type))
     {
-      char *src_link_val = xreadlink (src_path, src_sb.st_size);
+      char *src_link_val = xreadlink (src_name, src_sb.st_size);
       if (src_link_val == NULL)
        {
-         error (0, errno, _("cannot read symbolic link %s"), quote (src_path));
+         error (0, errno, _("cannot read symbolic link %s"), quote (src_name));
          goto un_backup;
        }
 
-      if (!symlink (src_link_val, dst_path))
+      if (symlink (src_link_val, dst_name) == 0)
        free (src_link_val);
       else
        {
@@ -1503,7 +1503,7 @@ copy_internal (const char *src_path, con
                 FIXME: This behavior isn't documented, and seems wrong
                 in some cases, e.g., if the destination symlink has the
                 wrong ownership, permissions, or time stamps.  */
-             char *dest_link_val = xreadlink (dst_path, dst_sb.st_size);
+             char *dest_link_val = xreadlink (dst_name, dst_sb.st_size);
              if (STREQ (dest_link_val, src_link_val))
                same_link = true;
              free (dest_link_val);
@@ -1513,7 +1513,7 @@ copy_internal (const char *src_path, con
          if (! same_link)
            {
              error (0, saved_errno, _("cannot create symbolic link %s"),
-                    quote (dst_path));
+                    quote (dst_name));
              goto un_backup;
            }
        }
@@ -1526,11 +1526,11 @@ copy_internal (const char *src_path, con
          /* Preserve the owner and group of the just-`copied'
             symbolic link, if possible.  */
 # if HAVE_LCHOWN
-         if (lchown (dst_path, src_sb.st_uid, src_sb.st_gid) != 0
+         if (lchown (dst_name, src_sb.st_uid, src_sb.st_gid) != 0
              && ! chown_failure_ok (x))
            {
              error (0, errno, _("failed to preserve ownership for %s"),
-                    dst_path);
+                    dst_name);
              goto un_backup;
            }
 # else
@@ -1544,12 +1544,12 @@ copy_internal (const char *src_path, con
   else
 #endif
     {
-      error (0, 0, _("%s has unknown file type"), quote (src_path));
+      error (0, 0, _("%s has unknown file type"), quote (src_name));
       goto un_backup;
     }
 
   if (command_line_arg)
-    record_file (x->dest_info, dst_path, NULL);
+    record_file (x->dest_info, dst_name, NULL);
 
   if ( ! preserve_metadata)
     return true;
@@ -1575,9 +1575,9 @@ copy_internal (const char *src_path, con
       timespec[1].tv_sec = src_sb.st_mtime;
       timespec[1].tv_nsec = TIMESPEC_NS (src_sb.st_mtim);
 
-      if (utimens (dst_path, timespec))
+      if (utimens (dst_name, timespec) != 0)
        {
-         error (0, errno, _("preserving times for %s"), quote (dst_path));
+         error (0, errno, _("preserving times for %s"), quote (dst_name));
          if (x->require_preserve)
            return false;
        }
@@ -1587,12 +1587,12 @@ copy_internal (const char *src_path, con
   if (x->preserve_ownership
       && (new_dst || !SAME_OWNER_AND_GROUP (src_sb, dst_sb)))
     {
-      if (chown (dst_path, src_sb.st_uid, src_sb.st_gid) == 0)
+      if (chown (dst_name, src_sb.st_uid, src_sb.st_gid) == 0)
        chown_succeeded = true;
       else if (! chown_failure_ok (x))
        {
          error (0, errno, _("failed to preserve ownership for %s"),
-                quote (dst_path));
+                quote (dst_name));
          if (x->require_preserve)
            return false;
        }
@@ -1601,15 +1601,15 @@ copy_internal (const char *src_path, con
 #if HAVE_STRUCT_STAT_ST_AUTHOR
   /* Preserve the st_author field.  */
   {
-    file_t file = file_name_lookup (dst_path, 0, 0);
+    file_t file = file_name_lookup (dst_name, 0, 0);
     if (file == MACH_PORT_NULL)
-      error (0, errno, _("failed to lookup file %s"), quote (dst_path));
+      error (0, errno, _("failed to lookup file %s"), quote (dst_name));
     else
       {
        error_t err = file_chauthor (file, src_sb.st_author);
        if (err)
          error (0, err, _("failed to preserve authorship for %s"),
-                quote (dst_path));
+                quote (dst_name));
        mach_port_deallocate (mach_task_self (), file);
       }
   }
@@ -1625,9 +1625,9 @@ copy_internal (const char *src_path, con
   if ((x->preserve_mode || new_dst)
       && (x->copy_as_regular || S_ISREG (src_type) || S_ISDIR (src_type)))
     {
-      if (chmod (dst_path, get_dest_mode (x, src_mode)))
+      if (chmod (dst_name, get_dest_mode (x, src_mode)) != 0)
        {
-         error (0, errno, _("setting permissions for %s"), quote (dst_path));
+         error (0, errno, _("setting permissions for %s"), quote (dst_name));
          if (x->set_mode || x->require_preserve)
            return false;
        }
@@ -1648,13 +1648,13 @@ un_backup:
 
   if (dst_backup)
     {
-      if (rename (dst_backup, dst_path))
-       error (0, errno, _("cannot un-backup %s"), quote (dst_path));
+      if (rename (dst_backup, dst_name) != 0)
+       error (0, errno, _("cannot un-backup %s"), quote (dst_name));
       else
        {
          if (x->verbose)
            printf (_("%s -> %s (unbackup)\n"),
-                   quote_n (0, dst_backup), quote_n (1, dst_path));
+                   quote_n (0, dst_backup), quote_n (1, dst_name));
        }
     }
   return false;
@@ -1670,17 +1670,17 @@ valid_options (const struct cp_options *
   return true;
 }
 
-/* Copy the file SRC_PATH to the file DST_PATH.  The files may be of
-   any type.  NONEXISTENT_DST should be true if the file DST_PATH
+/* Copy the file SRC_NAME to the file DST_NAME.  The files may be of
+   any type.  NONEXISTENT_DST should be true if the file DST_NAME
    is known not to exist (e.g., because its parent directory was just
-   created);  NONEXISTENT_DST should be false if DST_PATH might already
+   created);  NONEXISTENT_DST should be false if DST_NAME might already
    exist.  OPTIONS is ... FIXME-describe
-   Set *COPY_INTO_SELF if SRC_PATH is a parent of (or the
-   same as) DST_PATH; otherwise, set clear it.
+   Set *COPY_INTO_SELF if SRC_NAME is a parent of (or the
+   same as) DST_NAME; otherwise, set clear it.
    Return true if successful.  */
 
 extern bool
-copy (const char *src_path, const char *dst_path,
+copy (char const *src_name, char const *dst_name,
       bool nonexistent_dst, const struct cp_options *options,
       bool *copy_into_self, bool *rename_succeeded)
 {
@@ -1693,10 +1693,10 @@ copy (const char *src_path, const char *
      top level source and destination directory names where they're used.
      An alternative is to use COPY_INTO_SELF and print the diagnostic
      from every caller -- but I don't want to do that.  */
-  top_level_src_path = src_path;
-  top_level_dst_path = dst_path;
+  top_level_src_name = src_name;
+  top_level_dst_name = dst_name;
 
-  return copy_internal (src_path, dst_path, nonexistent_dst, 0, NULL,
+  return copy_internal (src_name, dst_name, nonexistent_dst, 0, NULL,
                        options, true, copy_into_self, rename_succeeded);
 }
 
Index: src/copy.h
===================================================================
RCS file: /fetish/cu/src/copy.h,v
retrieving revision 1.32
diff -p -u -r1.32 copy.h
--- src/copy.h  31 May 2005 06:15:18 -0000      1.32
+++ src/copy.h  2 Jun 2005 04:54:33 -0000
@@ -192,10 +192,10 @@ struct cp_options
   Hash_table *src_info;
 };
 
-# define XSTAT(X, Src_path, Src_sb) \
+# define XSTAT(X, Src_name, Src_sb) \
   ((X)->dereference == DEREF_NEVER \
-   ? lstat (Src_path, Src_sb) \
-   : stat (Src_path, Src_sb))
+   ? lstat (Src_name, Src_sb) \
+   : stat (Src_name, Src_sb))
 
 /* Arrange to make lstat calls go through the wrapper function
    on systems with an lstat function that does not dereference symlinks
@@ -207,7 +207,7 @@ int rpl_lstat (const char *, struct stat
 # endif
 
 /* Arrange to make rename calls go through the wrapper function
-   on systems with a rename function that fails for a source path
+   on systems with a rename function that fails for a source file name
    specified with a trailing slash.  */
 # if RENAME_TRAILING_SLASH_BUG
 int rpl_rename (const char *, const char *);
@@ -215,7 +215,7 @@ int rpl_rename (const char *, const char
 #  define rename rpl_rename
 # endif
 
-bool copy (const char *src_path, const char *dst_path,
+bool copy (char const *src_name, char const *dst_name,
           bool nonexistent_dst, const struct cp_options *options,
           bool *copy_into_self, bool *rename_succeeded);
 
Index: src/cp-hash.c
===================================================================
RCS file: /fetish/cu/src/cp-hash.c,v
retrieving revision 1.36
diff -p -u -r1.36 cp-hash.c
--- src/cp-hash.c       14 May 2005 07:58:36 -0000      1.36
+++ src/cp-hash.c       2 Jun 2005 04:54:33 -0000
@@ -1,5 +1,5 @@
 /* cp-hash.c  -- file copying (hash search routines)
-   Copyright (C) 89, 90, 91, 1995-2004 Free Software Foundation.
+   Copyright (C) 89, 90, 91, 1995-2005 Free Software Foundation.
 
    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
@@ -31,7 +31,7 @@
 #include "cp-hash.h"
 
 /* Use ST_DEV and ST_INO as the key, FILENAME as the value.
-   These are used e.g., in copy.c to associate the destination path with
+   These are used e.g., in copy.c to associate the destination name with
    the source device/inode pair so that if we encounter a matching dev/ino
    pair in the source tree we can arrange to create a hard link between
    the corresponding names in the destination tree.  */
@@ -39,8 +39,8 @@ struct Src_to_dest
 {
   ino_t st_ino;
   dev_t st_dev;
-  /* Destination path name (of non-directory or pre-existing directory)
-     corresponding to the dev/ino of a copied file, or the destination path
+  /* Destination file name (of non-directory or pre-existing directory)
+     corresponding to the dev/ino of a copied file, or the destination file
      name corresponding to a dev/ino pair for a newly-created directory. */
   char *name;
 };
@@ -98,21 +98,21 @@ forget_created (ino_t ino, dev_t dev)
     src_to_dest_free (ent);
 }
 
-/* Add PATH to the list of files that we have created.
+/* Add FILE to the list of files that we have created.
    Return true if successful.  */
 
 extern bool
-remember_created (const char *path)
+remember_created (char const *file)
 {
   struct stat sb;
 
-  if (stat (path, &sb) < 0)
+  if (stat (file, &sb) < 0)
     {
-      error (0, errno, "%s", quote (path));
+      error (0, errno, "%s", quote (file));
       return false;
     }
 
-  remember_copied (path, sb.st_ino, sb.st_dev);
+  remember_copied (file, sb.st_ino, sb.st_dev);
   return true;
 }
 
@@ -130,7 +130,7 @@ src_to_dest_lookup (ino_t ino, dev_t dev
   return e ? e->name : NULL;
 }
 
-/* Add path NAME, copied from inode number INO and device number DEV,
+/* Add file NAME, copied from inode number INO and device number DEV,
    to the list of files we have copied.
    Return NULL if inserted, otherwise non-NULL. */
 
Index: src/cp-hash.h
===================================================================
RCS file: /fetish/cu/src/cp-hash.h,v
retrieving revision 1.8
diff -p -u -r1.8 cp-hash.h
--- src/cp-hash.h       30 Jul 2004 07:55:33 -0000      1.8
+++ src/cp-hash.h       2 Jun 2005 04:54:33 -0000
@@ -2,5 +2,5 @@ void hash_init (void);
 void forget_all (void);
 void forget_created (ino_t ino, dev_t dev);
 char *remember_copied (const char *node, ino_t ino, dev_t dev);
-bool remember_created (const char *path);
+bool remember_created (char const *file);
 char *src_to_dest_lookup (ino_t ino, dev_t dev);
Index: src/cp.c
===================================================================
RCS file: /fetish/cu/src/cp.c,v
retrieving revision 1.210
diff -p -u -r1.210 cp.c
--- src/cp.c    31 May 2005 06:15:48 -0000      1.210
+++ src/cp.c    2 Jun 2005 04:54:33 -0000
@@ -30,7 +30,7 @@
 #include "cp-hash.h"
 #include "error.h"
 #include "dirname.h"
-#include "path-concat.h"
+#include "filenamecat.h"
 #include "quote.h"
 #include "quotearg.h"
 #include "utimens.h"
@@ -50,7 +50,7 @@
 
 #define AUTHORS "Torbjorn Granlund", "David MacKenzie", "Jim Meyering"
 
-/* Used by do_copy, make_path_private, and re_protect
+/* Used by do_copy, make_dir_parents_private, and re_protect
    to keep a list of leading directories whose protections
    need to be fixed after copying. */
 struct dir_attr
@@ -85,7 +85,7 @@ char *program_name;
 
 /* If true, the command "cp x/e_file e_dir" uses "e_dir/x/e_file"
    as its destination instead of the usual "e_dir/e_file." */
-static bool flag_path = false;
+static bool parents_option = false;
 
 /* Remove any trailing slashes from each SOURCE argument.  */
 static bool remove_trailing_slashes;
@@ -193,7 +193,7 @@ Mandatory arguments to long options are 
 "), stdout);
       fputs (_("\
       --no-preserve=ATTR_LIST  don't preserve the specified attributes\n\
-      --parents                append source path to DIRECTORY\n\
+      --parents                use full source file name under DIRECTORY\n\
 "), stdout);
       fputs (_("\
   -R, -r, --recursive          copy directories recursively\n\
@@ -254,47 +254,47 @@ regular file.\n\
   exit (status);
 }
 
-/* Ensure that the parent directories of CONST_DST_PATH have the
+/* Ensure that the parent directories of CONST_DST_NAME have the
    correct protections, for the --parents option.  This is done
    after all copying has been completed, to allow permissions
    that don't include user write/execute.
 
-   SRC_OFFSET is the index in CONST_DST_PATH of the beginning of the
+   SRC_OFFSET is the index in CONST_DST_NAME of the beginning of the
    source directory name.
 
    ATTR_LIST is a null-terminated linked list of structures that
    indicates the end of the filename of each intermediate directory
-   in CONST_DST_PATH that may need to have its attributes changed.
+   in CONST_DST_NAME that may need to have its attributes changed.
    The command `cp --parents --preserve a/b/c d/e_dir' changes the
    attributes of the directories d/e_dir/a and d/e_dir/a/b to match
    the corresponding source directories regardless of whether they
    existed before the `cp' command was given.
 
-   Return true if the parent of CONST_DST_PATH and any intermediate
+   Return true if the parent of CONST_DST_NAME and any intermediate
    directories specified by ATTR_LIST have the proper permissions
    when done.  */
 
 static bool
-re_protect (const char *const_dst_path, size_t src_offset,
+re_protect (char const *const_dst_name, size_t src_offset,
            struct dir_attr *attr_list, const struct cp_options *x)
 {
   struct dir_attr *p;
-  char *dst_path;              /* A copy of CONST_DST_PATH we can change. */
-  char *src_path;              /* The source name in `dst_path'. */
+  char *dst_name;              /* A copy of CONST_DST_NAME we can change. */
+  char *src_name;              /* The source name in `dst_name'. */
 
-  ASSIGN_STRDUPA (dst_path, const_dst_path);
-  src_path = dst_path + src_offset;
+  ASSIGN_STRDUPA (dst_name, const_dst_name);
+  src_name = dst_name + src_offset;
 
   for (p = attr_list; p; p = p->next)
     {
       struct stat src_sb;
 
-      dst_path[p->slash_offset] = '\0';
+      dst_name[p->slash_offset] = '\0';
 
-      if (XSTAT (x, src_path, &src_sb))
+      if (XSTAT (x, src_name, &src_sb))
        {
          error (0, errno, _("failed to get attributes of %s"),
-                quote (src_path));
+                quote (src_name));
          return false;
        }
 
@@ -311,45 +311,45 @@ re_protect (const char *const_dst_path, 
          timespec[1].tv_sec = src_sb.st_mtime;
          timespec[1].tv_nsec = TIMESPEC_NS (src_sb.st_mtim);
 
-         if (utimens (dst_path, timespec))
+         if (utimens (dst_name, timespec))
            {
              error (0, errno, _("failed to preserve times for %s"),
-                    quote (dst_path));
+                    quote (dst_name));
              return false;
            }
        }
 
       if (x->preserve_ownership)
        {
-         if (chown (dst_path, src_sb.st_uid, src_sb.st_gid) != 0
+         if (chown (dst_name, src_sb.st_uid, src_sb.st_gid) != 0
              && ! chown_failure_ok (x))
            {
              error (0, errno, _("failed to preserve ownership for %s"),
-                    quote (dst_path));
+                    quote (dst_name));
              return false;
            }
        }
 
       if (x->preserve_mode | p->is_new_dir)
        {
-         if (chmod (dst_path, src_sb.st_mode & x->umask_kill))
+         if (chmod (dst_name, src_sb.st_mode & x->umask_kill))
            {
              error (0, errno, _("failed to preserve permissions for %s"),
-                    quote (dst_path));
+                    quote (dst_name));
              return false;
            }
        }
 
-      dst_path[p->slash_offset] = '/';
+      dst_name[p->slash_offset] = '/';
     }
   return true;
 }
 
-/* Ensure that the parent directory of CONST_DIRPATH exists, for
+/* Ensure that the parent directory of CONST_DIR exists, for
    the --parents option.
 
-   SRC_OFFSET is the index in CONST_DIRPATH (which is a destination
-   path) of the beginning of the source directory name.
+   SRC_OFFSET is the index in CONST_DIR (which is a destination
+   directory) of the beginning of the source directory name.
    Create any leading directories that don't already exist,
    giving them permissions MODE.
    If VERBOSE_FMT_STRING is nonzero, use it as a printf format
@@ -358,38 +358,39 @@ re_protect (const char *const_dst_path, 
    source and destination directories.
    Creates a linked list of attributes of intermediate directories,
    *ATTR_LIST, for re_protect to use after calling copy.
-   Sets *NEW_DST if this function creates parent of CONST_DIRPATH.
+   Sets *NEW_DST if this function creates parent of CONST_DIR.
 
-   Return true if parent of CONST_DIRPATH exists as a directory with the proper
+   Return true if parent of CONST_DIR exists as a directory with the proper
    permissions when done.  */
 
-/* FIXME: find a way to synch this function with the one in lib/makepath.c. */
+/* FIXME: Synch this function with the one in ../lib/mkdir-p.c.  */
 
 static bool
-make_path_private (const char *const_dirpath, size_t src_offset, mode_t mode,
-                  const char *verbose_fmt_string, struct dir_attr **attr_list,
-                  bool *new_dst, int (*xstat)())
+make_dir_parents_private (char const *const_dir, size_t src_offset,
+                         mode_t mode, char const *verbose_fmt_string,
+                         struct dir_attr **attr_list, bool *new_dst,
+                         int (*xstat) ())
 {
   struct stat stats;
-  char *dirpath;               /* A copy of CONST_DIRPATH we can change. */
-  char *src;                   /* Source name in `dirpath'. */
-  char *dst_dirname;           /* Leading path of `dirpath'. */
-  size_t dirlen;               /* Length of leading path of `dirpath'. */
-
-  ASSIGN_STRDUPA (dirpath, const_dirpath);
-
-  src = dirpath + src_offset;
-
-  dirlen = dir_len (dirpath);
-  dst_dirname = alloca (dirlen + 1);
-  memcpy (dst_dirname, dirpath, dirlen);
-  dst_dirname[dirlen] = '\0';
+  char *dir;           /* A copy of CONST_DIR we can change.  */
+  char *src;           /* Source name in DIR.  */
+  char *dst_dir;       /* Leading directory of DIR.  */
+  size_t dirlen;       /* Length of DIR.  */
+
+  ASSIGN_STRDUPA (dir, const_dir);
+
+  src = dir + src_offset;
+
+  dirlen = dir_len (dir);
+  dst_dir = alloca (dirlen + 1);
+  memcpy (dst_dir, dir, dirlen);
+  dst_dir[dirlen] = '\0';
 
   *attr_list = NULL;
 
-  if ((*xstat) (dst_dirname, &stats))
+  if ((*xstat) (dst_dir, &stats))
     {
-      /* Parent of CONST_DIRNAME does not exist.
+      /* A parent of CONST_DIR does not exist.
         Make all missing intermediate directories. */
       char *slash;
 
@@ -401,36 +402,36 @@ make_path_private (const char *const_dir
          /* Add this directory to the list of directories whose modes need
             fixing later. */
          struct dir_attr *new = xmalloc (sizeof *new);
-         new->slash_offset = slash - dirpath;
+         new->slash_offset = slash - dir;
          new->next = *attr_list;
          *attr_list = new;
 
          *slash = '\0';
-         if ((*xstat) (dirpath, &stats))
+         if ((*xstat) (dir, &stats))
            {
-             /* This element of the path does not exist.  We must set
+             /* This component does not exist.  We must set
                 *new_dst and new->is_new_dir inside this loop because,
                 for example, in the command `cp --parents ../a/../b/c e_dir',
-                make_path_private creates only e_dir/../a if ./b already
-                exists. */
+                make_dir_parents_private creates only e_dir/../a if
+                ./b already exists. */
              *new_dst = true;
              new->is_new_dir = true;
-             if (mkdir (dirpath, mode))
+             if (mkdir (dir, mode))
                {
                  error (0, errno, _("cannot make directory %s"),
-                        quote (dirpath));
+                        quote (dir));
                  return false;
                }
              else
                {
                  if (verbose_fmt_string != NULL)
-                   printf (verbose_fmt_string, src, dirpath);
+                   printf (verbose_fmt_string, src, dir);
                }
            }
          else if (!S_ISDIR (stats.st_mode))
            {
              error (0, 0, _("%s exists but is not a directory"),
-                    quote (dirpath));
+                    quote (dir));
              return false;
            }
          else
@@ -441,17 +442,17 @@ make_path_private (const char *const_dir
          *slash++ = '/';
 
          /* Avoid unnecessary calls to `stat' when given
-            pathnames containing multiple adjacent slashes.  */
+            file names containing multiple adjacent slashes.  */
          while (*slash == '/')
            slash++;
        }
     }
 
-  /* We get here if the parent of `dirpath' already exists. */
+  /* We get here if the parent of DIR already exists.  */
 
   else if (!S_ISDIR (stats.st_mode))
     {
-      error (0, 0, _("%s exists but is not a directory"), quote (dst_dirname));
+      error (0, 0, _("%s exists but is not a directory"), quote (dst_dir));
       return false;
     }
   else
@@ -554,8 +555,8 @@ do_copy (int n_files, char **file, const
 
       for (i = 0; i < n_files; i++)
        {
-         char *dst_path;
-         bool parent_exists = true;  /* True if dir_name (dst_path) exists. */
+         char *dst_name;
+         bool parent_exists = true;  /* True if dir_name (dst_name) exists. */
          struct dir_attr *attr_list;
          char *arg_in_concat = NULL;
          char *arg = file[i];
@@ -565,7 +566,7 @@ do_copy (int n_files, char **file, const
          if (remove_trailing_slashes)
            strip_trailing_slashes (arg);
 
-         if (flag_path)
+         if (parents_option)
            {
              char *arg_no_trailing_slash;
 
@@ -578,19 +579,18 @@ do_copy (int n_files, char **file, const
              strip_trailing_slashes (arg_no_trailing_slash);
 
              /* Append all of `arg' (minus any trailing slash) to `dest'.  */
-             dst_path = path_concat (target_directory, arg_no_trailing_slash,
-                                     &arg_in_concat);
+             dst_name = file_name_concat (target_directory,
+                                          arg_no_trailing_slash,
+                                          &arg_in_concat);
 
              /* For --parents, we have to make sure that the directory
-                dir_name (dst_path) exists.  We may have to create a few
+                dir_name (dst_name) exists.  We may have to create a few
                 leading directories. */
-             parent_exists = make_path_private (dst_path,
-                                                arg_in_concat - dst_path,
-                                                S_IRWXU,
-                                                (x->verbose
-                                                 ? "%s -> %s\n" : NULL),
-                                                &attr_list, &new_dst,
-                                                xstat);
+             parent_exists =
+               (make_dir_parents_private
+                (dst_name, arg_in_concat - dst_name, S_IRWXU,
+                 (x->verbose ? "%s -> %s\n" : NULL),
+                 &attr_list, &new_dst, xstat));
            }
          else
            {
@@ -599,27 +599,29 @@ do_copy (int n_files, char **file, const
 
              ASSIGN_BASENAME_STRDUPA (arg_base, arg);
              /* For `cp -R source/.. dest', don't copy into `dest/..'. */
-             dst_path = (STREQ (arg_base, "..")
+             dst_name = (STREQ (arg_base, "..")
                          ? xstrdup (target_directory)
-                         : path_concat (target_directory, arg_base, NULL));
+                         : file_name_concat (target_directory, arg_base,
+                                             NULL));
            }
 
          if (!parent_exists)
            {
-             /* make_path_private failed, so don't even attempt the copy. */
+             /* make_dir_parents_private failed, so don't even
+                attempt the copy.  */
              ok = false;
            }
          else
            {
              bool copy_into_self;
-             ok &= copy (arg, dst_path, new_dst, x, &copy_into_self, NULL);
+             ok &= copy (arg, dst_name, new_dst, x, &copy_into_self, NULL);
 
-             if (flag_path)
-               ok &= re_protect (dst_path, arg_in_concat - dst_path,
+             if (parents_option)
+               ok &= re_protect (dst_name, arg_in_concat - dst_name,
                                  attr_list, x);
            }
 
-         free (dst_path);
+         free (dst_name);
        }
     }
   else /* !target_directory */
@@ -629,10 +631,10 @@ do_copy (int n_files, char **file, const
       char const *dest = file[1];
       bool unused;
 
-      if (flag_path)
+      if (parents_option)
        {
          error (0, 0,
-              _("when preserving paths, the destination must be a directory"));
+                _("with --parents, the destination must be a directory"));
          usage (EXIT_FAILURE);
        }
 
@@ -903,7 +905,7 @@ main (int argc, char **argv)
          break;
 
        case PARENTS_OPTION:
-         flag_path = true;
+         parents_option = true;
          break;
 
        case 'r':
Index: src/df.c
===================================================================
RCS file: /fetish/cu/src/df.c,v
retrieving revision 1.166
diff -p -u -r1.166 df.c
--- src/df.c    14 May 2005 07:58:37 -0000      1.166
+++ src/df.c    2 Jun 2005 04:54:33 -0000
@@ -33,7 +33,6 @@
 #include "human.h"
 #include "inttostr.h"
 #include "mountlist.h"
-#include "path-concat.h"
 #include "quote.h"
 #include "save-cwd.h"
 #include "xgetcwd.h"
@@ -251,8 +250,8 @@ df_readable (bool negative, uintmax_t n,
     }
 }
 
-/* Display a space listing for the disk device with absolute path DISK.
-   If MOUNT_POINT is non-NULL, it is the path of the root of the
+/* Display a space listing for the disk device with absolute file name DISK.
+   If MOUNT_POINT is non-NULL, it is the name of the root of the
    file system on DISK.
    If FSTYPE is non-NULL, it is the type of the file system on DISK.
    If MOUNT_POINT is non-NULL, then DISK may be NULL -- certain systems may
@@ -438,7 +437,7 @@ find_mount_point (const char *file, cons
 {
   struct saved_cwd cwd;
   struct stat last_stat;
-  char *mp = NULL;             /* The malloced mount point path.  */
+  char *mp = NULL;             /* The malloced mount point.  */
 
   if (save_cwd (&cwd) != 0)
     {
@@ -550,7 +549,7 @@ show_point (const char *point, const str
   struct mount_entry *me;
   struct mount_entry const *best_match = NULL;
 
-  /* If POINT is an absolute path name, see if we can find the
+  /* If POINT is an absolute file name, see if we can find the
      mount point without performing any extra stat calls at all.  */
   if (*point == '/')
     {
@@ -563,7 +562,7 @@ show_point (const char *point, const str
          best_match = me;
     }
 
-  /* Calculate the real absolute path for POINT, and use that to find
+  /* Calculate the real absolute file name for POINT, and use that to find
      the mount point.  This avoids statting unavailable mount points,
      which can hang df.  */
   if (! best_match)
@@ -647,17 +646,17 @@ show_point (const char *point, const str
     }
 }
 
-/* Determine what kind of node PATH is and show the disk usage
-   for it.  STATP is the results of `stat' on PATH.  */
+/* Determine what kind of node NAME is and show the disk usage
+   for it.  STATP is the results of `stat' on NAME.  */
 
 static void
-show_entry (const char *path, const struct stat *statp)
+show_entry (char const *name, struct stat const *statp)
 {
   if ((S_ISBLK (statp->st_mode) || S_ISCHR (statp->st_mode))
-      && show_disk (path))
+      && show_disk (name))
     return;
 
-  show_point (path, statp);
+  show_point (name, statp);
 }
 
 /* Show all mounted file systems, except perhaps those that are of
Index: src/dirname.c
===================================================================
RCS file: /fetish/cu/src/dirname.c,v
retrieving revision 1.68
diff -p -u -r1.68 dirname.c
--- src/dirname.c       14 May 2005 07:58:37 -0000      1.68
+++ src/dirname.c       2 Jun 2005 04:54:33 -0000
@@ -1,4 +1,4 @@
-/* dirname -- strip filename suffix from pathname
+/* dirname -- strip suffix from file name
 
    Copyright (C) 1990-1997, 1999-2002, 2004, 2005 Free Software
    Foundation, Inc.
Index: src/du.c
===================================================================
RCS file: /fetish/cu/src/du.c,v
retrieving revision 1.202
diff -p -u -r1.202 du.c
--- src/du.c    14 May 2005 07:58:37 -0000      1.202
+++ src/du.c    2 Jun 2005 04:54:33 -0000
@@ -336,7 +336,7 @@ process_file (FTS *fts, FTSENT *ent)
   bool skip;
 
   /* If necessary, set FTS_SKIP before returning.  */
-  skip = excluded_filename (exclude, ent->fts_path);
+  skip = excluded_file_name (exclude, ent->fts_path);
   if (skip)
     fts_set (fts, ent, FTS_SKIP);
 
Index: src/install.c
===================================================================
RCS file: /fetish/cu/src/install.c,v
retrieving revision 1.178
diff -p -u -r1.178 install.c
--- src/install.c       31 May 2005 06:16:09 -0000      1.178
+++ src/install.c       2 Jun 2005 04:54:33 -0000
@@ -31,9 +31,9 @@
 #include "cp-hash.h"
 #include "copy.h"
 #include "dirname.h"
-#include "makepath.h"
+#include "filenamecat.h"
+#include "mkdir-p.h"
 #include "modechange.h"
-#include "path-concat.h"
 #include "quote.h"
 #include "utimens.h"
 #include "xstrtol.h"
@@ -65,17 +65,17 @@
 #define READ_SIZE (32 * 1024)
 
 static bool change_timestamps (const char *from, const char *to);
-static bool change_attributes (const char *path);
+static bool change_attributes (char const *name);
 static bool copy_file (const char *from, const char *to,
                       const struct cp_options *x);
-static bool install_file_to_path (const char *from, const char *to,
-                                 const struct cp_options *x);
+static bool install_file_in_file_parents (char const *from, char const *to,
+                                         struct cp_options const *x);
 static bool install_file_in_dir (const char *from, const char *to_dir,
                                 const struct cp_options *x);
 static bool install_file_in_file (const char *from, const char *to,
                                  const struct cp_options *x);
 static void get_ids (void);
-static void strip (const char *path);
+static void strip (char const *name);
 void usage (int status);
 
 /* The name this program was run with, for error messages. */
@@ -360,8 +360,8 @@ main (int argc, char **argv)
       for (i = 0; i < n_files; i++)
        {
          ok &=
-           make_path (file[i], mode, mode, owner_id, group_id, false,
-                      (x.verbose ? _("creating directory %s") : NULL));
+           make_dir_parents (file[i], mode, mode, owner_id, group_id, false,
+                             (x.verbose ? _("creating directory %s") : NULL));
        }
     }
   else
@@ -373,7 +373,7 @@ main (int argc, char **argv)
       if (!target_directory)
         {
           if (mkdir_and_install)
-           ok = install_file_to_path (file[0], file[1], &x);
+           ok = install_file_in_file_parents (file[0], file[1], &x);
          else
            ok = install_file_in_file (file[0], file[1], &x);
        }
@@ -395,8 +395,8 @@ main (int argc, char **argv)
    Return true if successful.  */
 
 static bool
-install_file_to_path (const char *from, const char *to,
-                     const struct cp_options *x)
+install_file_in_file_parents (char const *from, char const *to,
+                             struct cp_options const *x)
 {
   char *dest_dir = dir_name (to);
   bool ok = true;
@@ -408,9 +408,10 @@ install_file_to_path (const char *from, 
         owner, group, and permissions for parent directories.  Remember
         that this option is intended mainly to help installers when the
         distribution doesn't provide proper install rules.  */
-#define DIR_MODE (S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)
-      ok = make_path (dest_dir, DIR_MODE, DIR_MODE, owner_id, group_id, true,
-                     (x->verbose ? _("creating directory %s") : NULL));
+      mode_t dir_mode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
+      ok = make_dir_parents (dest_dir, dir_mode, dir_mode,
+                            owner_id, group_id, true,
+                            (x->verbose ? _("creating directory %s") : NULL));
     }
 
   free (dest_dir);
@@ -449,7 +450,7 @@ install_file_in_dir (const char *from, c
                     const struct cp_options *x)
 {
   const char *from_base = base_name (from);
-  char *to = path_concat (to_dir, from_base, NULL);
+  char *to = file_name_concat (to_dir, from_base, NULL);
   bool ret = install_file_in_file (from, to, x);
   free (to);
   return ret;
@@ -472,11 +473,11 @@ copy_file (const char *from, const char 
   return copy (from, to, false, x, &copy_into_self, NULL);
 }
 
-/* Set the attributes of file or directory PATH.
+/* Set the attributes of file or directory NAME.
    Return true if successful.  */
 
 static bool
-change_attributes (const char *path)
+change_attributes (char const *name)
 {
   bool ok = true;
 
@@ -493,19 +494,19 @@ change_attributes (const char *path)
      want to know.  But AFS returns EPERM when you try to change a
      file's group; thus the kludge.  */
 
-  if (chown (path, owner_id, group_id)
+  if (chown (name, owner_id, group_id) != 0
 #ifdef AFS
       && errno != EPERM
 #endif
       )
     {
-      error (0, errno, _("cannot change ownership of %s"), quote (path));
+      error (0, errno, _("cannot change ownership of %s"), quote (name));
       ok = false;
     }
 
-  if (ok && chmod (path, mode))
+  if (ok && chmod (name, mode) != 0)
     {
-      error (0, errno, _("cannot change permissions of %s"), quote (path));
+      error (0, errno, _("cannot change permissions of %s"), quote (name));
       ok = false;
     }
 
@@ -539,14 +540,14 @@ change_timestamps (const char *from, con
   return true;
 }
 
-/* Strip the symbol table from the file PATH.
+/* Strip the symbol table from the file NAME.
    We could dig the magic number out of the file first to
    determine whether to strip it, but the header files and
    magic numbers vary so much from system to system that making
    it portable would be very difficult.  Not worth the effort. */
 
 static void
-strip (const char *path)
+strip (char const *name)
 {
   int status;
   pid_t pid = fork ();
@@ -557,7 +558,7 @@ strip (const char *path)
       error (EXIT_FAILURE, errno, _("fork system call failed"));
       break;
     case 0:                    /* Child. */
-      execlp ("strip", "strip", path, NULL);
+      execlp ("strip", "strip", name, NULL);
       error (EXIT_FAILURE, errno, _("cannot run strip"));
       break;
     default:                   /* Parent. */
Index: src/ln.c
===================================================================
RCS file: /fetish/cu/src/ln.c,v
retrieving revision 1.148
diff -p -u -r1.148 ln.c
--- src/ln.c    14 May 2005 07:58:37 -0000      1.148
+++ src/ln.c    2 Jun 2005 04:54:33 -0000
@@ -1,5 +1,5 @@
 /* `ln' program to create links between files.
-   Copyright (C) 86, 89, 90, 91, 1995-2004 Free Software Foundation, Inc.
+   Copyright (C) 86, 89, 90, 91, 1995-2005 Free Software Foundation, Inc.
 
    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
@@ -56,7 +56,7 @@
 /* Construct a string NEW_DEST by concatenating DEST, a slash, and
    basename(SOURCE) in alloca'd memory.  Don't modify DEST or SOURCE.  */
 
-#define PATH_BASENAME_CONCAT(new_dest, dest, source)                   \
+#define FILE_BASENAME_CONCAT(new_dest, dest, source)                   \
     do                                                                 \
       {                                                                        
\
        const char *source_base;                                        \
@@ -193,7 +193,7 @@ do_link (const char *source, const char 
     {
       /* Treat DEST as a directory; build the full filename.  */
       char *new_dest;
-      PATH_BASENAME_CONCAT (new_dest, dest, source);
+      FILE_BASENAME_CONCAT (new_dest, dest, source);
       dest = new_dest;
     }
 
Index: src/ls.c
===================================================================
RCS file: /fetish/cu/src/ls.c,v
retrieving revision 1.387
diff -p -u -r1.387 ls.c
--- src/ls.c    14 May 2005 07:58:37 -0000      1.387
+++ src/ls.c    2 Jun 2005 04:54:33 -0000
@@ -108,6 +108,7 @@ int wcwidth ();
 #include "dirname.h"
 #include "dirfd.h"
 #include "error.h"
+#include "filenamecat.h"
 #include "hard-locale.h"
 #include "hash.h"
 #include "human.h"
@@ -116,7 +117,6 @@ int wcwidth ();
 #include "ls.h"
 #include "mbswidth.h"
 #include "obstack.h"
-#include "path-concat.h"
 #include "quote.h"
 #include "quotearg.h"
 #include "same.h"
@@ -232,7 +232,7 @@ char *getuser ();
 static size_t quote_name (FILE *out, const char *name,
                          struct quoting_options const *options,
                          size_t *width);
-static char *make_link_path (const char *path, const char *linkname);
+static char *make_link_name (char const *name, char const *linkname);
 static int decode_switches (int argc, char **argv);
 static bool file_ignored (char const *name);
 static uintmax_t gobble_file (char const *name, enum filetype type,
@@ -269,7 +269,7 @@ static void sort_files (void);
 static void parse_ls_color (void);
 void usage (int status);
 
-/* The name the program was run with, stripped of any leading path.  */
+/* The name this program was run with.  */
 char *program_name;
 
 /* Initial size of hash table.
@@ -2470,7 +2470,6 @@ gobble_file (char const *name, enum file
             char const *dirname)
 {
   uintmax_t blocks;
-  char *path;
   struct fileinfo *f;
 
   if (files_index == nfiles)
@@ -2507,21 +2506,23 @@ gobble_file (char const *name, enum file
                                     )))))
 
     {
-      /* `path' is the absolute pathname of this file.  */
+      /* Absolute name of this file.  */
+      char *absolute_name;
+
       int err;
 
       if (name[0] == '/' || dirname[0] == 0)
-       path = (char *) name;
+       absolute_name = (char *) name;
       else
        {
-         path = alloca (strlen (name) + strlen (dirname) + 2);
-         attach (path, dirname, name);
+         absolute_name = alloca (strlen (name) + strlen (dirname) + 2);
+         attach (absolute_name, dirname, name);
        }
 
       switch (dereference)
        {
        case DEREF_ALWAYS:
-         err = stat (path, &f->stat);
+         err = stat (absolute_name, &f->stat);
          break;
 
        case DEREF_COMMAND_LINE_ARGUMENTS:
@@ -2529,7 +2530,7 @@ gobble_file (char const *name, enum file
          if (command_line_arg)
            {
              bool need_lstat;
-             err = stat (path, &f->stat);
+             err = stat (absolute_name, &f->stat);
 
              if (dereference == DEREF_COMMAND_LINE_ARGUMENTS)
                break;
@@ -2541,46 +2542,46 @@ gobble_file (char const *name, enum file
                break;
 
              /* stat failed because of ENOENT, maybe indicating a dangling
-                symlink.  Or stat succeeded, PATH does not refer to a
+                symlink.  Or stat succeeded, ABSOLUTE_NAME does not refer to a
                 directory, and --dereference-command-line-symlink-to-dir is
                 in effect.  Fall through so that we call lstat instead.  */
            }
 
        default: /* DEREF_NEVER */
-         err = lstat (path, &f->stat);
+         err = lstat (absolute_name, &f->stat);
          break;
        }
 
       if (err < 0)
        {
-         file_failure (command_line_arg, "%s", path);
+         file_failure (command_line_arg, "%s", absolute_name);
          return 0;
        }
 
 #if HAVE_ACL
       if (format == long_format)
        {
-         int n = file_has_acl (path, &f->stat);
+         int n = file_has_acl (absolute_name, &f->stat);
          f->have_acl = (0 < n);
          if (n < 0)
-           error (0, errno, "%s", quotearg_colon (path));
+           error (0, errno, "%s", quotearg_colon (absolute_name));
        }
 #endif
 
       if (S_ISLNK (f->stat.st_mode)
          && (format == long_format || check_symlink_color))
        {
-         char *linkpath;
+         char *linkname;
          struct stat linkstats;
 
-         get_link_name (path, f, command_line_arg);
-         linkpath = make_link_path (path, f->linkname);
+         get_link_name (absolute_name, f, command_line_arg);
+         linkname = make_link_name (absolute_name, f->linkname);
 
          /* Avoid following symbolic links when possible, ie, when
             they won't be traced and when no indicator is needed.  */
-         if (linkpath
+         if (linkname
              && (file_type <= indicator_style || check_symlink_color)
-             && stat (linkpath, &linkstats) == 0)
+             && stat (linkname, &linkstats) == 0)
            {
              f->linkok = true;
 
@@ -2596,7 +2597,7 @@ gobble_file (char const *name, enum file
                  f->linkok = true;
                }
            }
-         free (linkpath);
+         free (linkname);
        }
 
       if (S_ISLNK (f->stat.st_mode))
@@ -2710,13 +2711,13 @@ get_link_name (char const *filename, str
                  filename);
 }
 
-/* If `linkname' is a relative path and `path' contains one or more
+/* If `linkname' is a relative name and `name' contains one or more
    leading directories, return `linkname' with those directories
    prepended; otherwise, return a copy of `linkname'.
    If `linkname' is zero, return zero.  */
 
 static char *
-make_link_path (const char *path, const char *linkname)
+make_link_name (char const *name, char const *linkname)
 {
   char *linkbuf;
   size_t bufsiz;
@@ -2727,15 +2728,15 @@ make_link_path (const char *path, const 
   if (*linkname == '/')
     return xstrdup (linkname);
 
-  /* The link is to a relative path.  Prepend any leading path
-     in `path' to the link name.  */
-  linkbuf = strrchr (path, '/');
+  /* The link is to a relative name.  Prepend any leading directory
+     in `name' to the link name.  */
+  linkbuf = strrchr (name, '/');
   if (linkbuf == 0)
     return xstrdup (linkname);
 
-  bufsiz = linkbuf - path + 1;
+  bufsiz = linkbuf - name + 1;
   linkbuf = xmalloc (bufsiz + strlen (linkname) + 1);
-  strncpy (linkbuf, path, bufsiz);
+  strncpy (linkbuf, name, bufsiz);
   strcpy (linkbuf + bufsiz, linkname);
   return linkbuf;
 }
@@ -2788,9 +2789,9 @@ extract_dirs_from_files (char const *dir
          }
        else
          {
-           char *path = path_concat (dirname, files[i].name, NULL);
-           queue_directory (path, files[i].linkname, command_line_arg);
-           free (path);
+           char *name = file_name_concat (dirname, files[i].name, NULL);
+           queue_directory (name, files[i].linkname, command_line_arg);
+           free (name);
          }
        if (files[i].filetype == arg_directory)
          free (files[i].name);
@@ -3895,7 +3896,7 @@ indent (size_t from, size_t to)
 
 /* Put DIRNAME/NAME into DEST, handling `.' and `/' properly.  */
 /* FIXME: maybe remove this function someday.  See about using a
-   non-malloc'ing version of path_concat.  */
+   non-malloc'ing version of file_name_concat.  */
 
 static void
 attach (char *dest, const char *dirname, const char *name)
Index: src/mkdir.c
===================================================================
RCS file: /fetish/cu/src/mkdir.c,v
retrieving revision 1.96
diff -p -u -r1.96 mkdir.c
--- src/mkdir.c 14 May 2005 07:58:37 -0000      1.96
+++ src/mkdir.c 2 Jun 2005 04:54:33 -0000
@@ -25,7 +25,7 @@
 #include "system.h"
 #include "dirname.h"
 #include "error.h"
-#include "makepath.h"
+#include "mkdir-p.h"
 #include "modechange.h"
 #include "quote.h"
 
@@ -152,8 +152,8 @@ main (int argc, char **argv)
       if (create_parents)
        {
          char *dir = argv[optind];
-         ok = make_path (dir, newmode, parent_mode,
-                         -1, -1, true, verbose_fmt_string);
+         ok = make_dir_parents (dir, newmode, parent_mode,
+                                -1, -1, true, verbose_fmt_string);
        }
       else
        {
Index: src/mv.c
===================================================================
RCS file: /fetish/cu/src/mv.c,v
retrieving revision 1.166
diff -p -u -r1.166 mv.c
--- src/mv.c    31 May 2005 06:16:18 -0000      1.166
+++ src/mv.c    2 Jun 2005 04:54:33 -0000
@@ -30,7 +30,7 @@
 #include "cp-hash.h"
 #include "dirname.h"
 #include "error.h"
-#include "path-concat.h"
+#include "filenamecat.h"
 #include "quote.h"
 #include "remove.h"
 
@@ -274,7 +274,7 @@ movefile (char *source, char *dest, bool
     {
       /* Treat DEST as a directory; build the full filename.  */
       char const *src_basename = base_name (source);
-      char *new_dest = path_concat (dest, src_basename, NULL);
+      char *new_dest = file_name_concat (dest, src_basename, NULL);
       strip_trailing_slashes (new_dest);
       ok = do_move (source, new_dest, x);
       free (new_dest);
Index: src/nohup.c
===================================================================
RCS file: /fetish/cu/src/nohup.c,v
retrieving revision 1.28
diff -p -u -r1.28 nohup.c
--- src/nohup.c 26 May 2005 19:30:04 -0000      1.28
+++ src/nohup.c 2 Jun 2005 04:54:33 -0000
@@ -27,8 +27,8 @@
 
 #include "cloexec.h"
 #include "error.h"
+#include "filenamecat.h"
 #include "long-options.h"
-#include "path-concat.h"
 #include "quote.h"
 #include "unistd-safer.h"
 
@@ -114,7 +114,7 @@ main (int argc, char **argv)
          char const *home = getenv ("HOME");
          if (home)
            {
-             in_home = path_concat (home, file, NULL);
+             in_home = file_name_concat (home, file, NULL);
              fd = open (in_home, flags, mode);
            }
          if (fd < 0)
Index: src/pinky.c
===================================================================
RCS file: /fetish/cu/src/pinky.c,v
retrieving revision 1.48
diff -p -u -r1.48 pinky.c
--- src/pinky.c 14 May 2005 07:58:37 -0000      1.48
+++ src/pinky.c 2 Jun 2005 04:54:33 -0000
@@ -219,8 +219,8 @@ print_entry (const STRUCT_UTMP *utmp_ent
   char line[sizeof (utmp_ent->ut_line) + DEV_DIR_LEN + 1];
 
   /* Copy ut_line into LINE, prepending `/dev/' if ut_line is not
-     already an absolute pathname.  Some system may put the full,
-     absolute pathname in ut_line.  */
+     already an absolute file name.  Some system may put the full,
+     absolute file name in ut_line.  */
   if (utmp_ent->ut_line[0] == '/')
     {
       strncpy (line, utmp_ent->ut_line, sizeof (utmp_ent->ut_line));
Index: src/pr.c
===================================================================
RCS file: /fetish/cu/src/pr.c,v
retrieving revision 1.147
diff -p -u -r1.147 pr.c
--- src/pr.c    14 May 2005 07:58:37 -0000      1.147
+++ src/pr.c    2 Jun 2005 04:54:34 -0000
@@ -29,7 +29,7 @@
 
    Improve the printing of control prefixes.
 
-   Expand the filename in the centered header line to a full pathname.
+   Expand the file name in the centered header line to a full file name.
 
 
    Concept:
Index: src/pwd.c
===================================================================
RCS file: /fetish/cu/src/pwd.c,v
retrieving revision 1.56
diff -p -u -r1.56 pwd.c
--- src/pwd.c   14 May 2005 07:58:37 -0000      1.56
+++ src/pwd.c   2 Jun 2005 04:54:34 -0000
@@ -33,7 +33,7 @@
 
 #define AUTHORS "Jim Meyering"
 
-struct Path
+struct file_name
 {
   char *buf;
   size_t n_alloc;
@@ -77,16 +77,16 @@ Print the full filename of the current w
 }
 
 static void
-path_free (struct Path *p)
+file_name_free (struct file_name *p)
 {
   free (p->buf);
   free (p);
 }
 
-static struct Path *
-path_init (void)
+static struct file_name *
+file_name_init (void)
 {
-  struct Path *p = xmalloc (sizeof *p);
+  struct file_name *p = xmalloc (sizeof *p);
 
   /* Start with a buffer larger than PATH_MAX, but beware of systems
      on which PATH_MAX is very large -- e.g., INT_MAX.  */
@@ -98,9 +98,9 @@ path_init (void)
   return p;
 }
 
-/* Prepend the name S of length S_LEN, to the growing path, P.  */
+/* Prepend the name S of length S_LEN, to the growing file_name, P.  */
 static void
-path_prepend (struct Path *p, char const *s, size_t s_len)
+file_name_prepend (struct file_name *p, char const *s, size_t s_len)
 {
   size_t n_free = p->start - p->buf;
   if (n_free < 1 + s_len)
@@ -142,10 +142,10 @@ nth_parent (size_t n)
 }
 
 /* Determine the basename of the current directory, where DOT_SB is the
-   result of lstat'ing "." and prepend that to the file name in *PATH.
+   result of lstat'ing "." and prepend that to the file name in *FILE_NAME.
    Find the directory entry in `..' that matches the dev/i-node of DOT_SB.
    Upon success, update *DOT_SB with stat information of `..', chdir to `..',
-   and prepend "/basename" to PATH.
+   and prepend "/basename" to FILE_NAME.
    Otherwise, exit with a diagnostic.
    PARENT_HEIGHT is the number of levels `..' is above the starting directory.
    The first time this function is called (from the initial directory),
@@ -153,7 +153,8 @@ nth_parent (size_t n)
    Exit nonzero upon error.  */
 
 static void
-find_dir_entry (struct stat *dot_sb, struct Path *path, size_t parent_height)
+find_dir_entry (struct stat *dot_sb, struct file_name *file_name,
+               size_t parent_height)
 {
   DIR *dirp;
   int fd;
@@ -224,7 +225,7 @@ find_dir_entry (struct stat *dot_sb, str
         match is enough.  */
       if ( ! use_lstat || ent_sb.st_dev == dot_sb->st_dev)
        {
-         path_prepend (path, dp->d_name, NLENGTH (dp));
+         file_name_prepend (file_name, dp->d_name, NLENGTH (dp));
          found = true;
          break;
        }
@@ -247,7 +248,7 @@ find_dir_entry (struct stat *dot_sb, str
 }
 
 /* Construct the full, absolute name of the current working
-   directory and store it in *PATH.
+   directory and store it in *FILE_NAME.
    The getcwd function performs nearly the same task, but is typically
    unable to handle names longer than PATH_MAX.  This function has
    no such limitation.  However, this function *can* fail due to
@@ -270,7 +271,7 @@ find_dir_entry (struct stat *dot_sb, str
    getcwd works from there.  */
 
 static void
-robust_getcwd (struct Path *path)
+robust_getcwd (struct file_name *file_name)
 {
   size_t height = 1;
   struct dev_ino dev_ino_buf;
@@ -290,11 +291,11 @@ robust_getcwd (struct Path *path)
       if (SAME_INODE (dot_sb, *root_dev_ino))
        break;
 
-      find_dir_entry (&dot_sb, path, height++);
+      find_dir_entry (&dot_sb, file_name, height++);
     }
 
-  if (path->start[0] == '\0')
-    path_prepend (path, "/", 1);
+  if (file_name->start[0] == '\0')
+    file_name_prepend (file_name, "/", 1);
 }
 
 int
@@ -326,10 +327,10 @@ main (int argc, char **argv)
     }
   else
     {
-      struct Path *path = path_init ();
-      robust_getcwd (path);
-      puts (path->start);
-      path_free (path);
+      struct file_name *file_name = file_name_init ();
+      robust_getcwd (file_name);
+      puts (file_name->start);
+      file_name_free (file_name);
     }
 
   exit (EXIT_SUCCESS);
Index: src/readlink.c
===================================================================
RCS file: /fetish/cu/src/readlink.c,v
retrieving revision 1.19
diff -p -u -r1.19 readlink.c
--- src/readlink.c      14 May 2005 07:58:37 -0000      1.19
+++ src/readlink.c      2 Jun 2005 04:54:34 -0000
@@ -69,13 +69,13 @@ usage (int status)
             stdout);
       fputs (_("\
   -f, --canonicalize            canonicalize by following every symlink in\n\
-                                every component of the given path 
recursively;\n\
-                                all but the last path component must exist\n\
+                                every component of the given name 
recursively;\n\
+                                all but the last component must exist\n\
   -e, --canonicalize-existing   canonicalize by following every symlink in\n\
-                                every component of the given path 
recursively,\n\
-                                all path components must exist\n\
+                                every component of the given name 
recursively,\n\
+                                all components must exist\n\
   -m, --canonicalize-missing    canonicalize by following every symlink in\n\
-                                every component of the given path 
recursively,\n\
+                                every component of the given name 
recursively,\n\
                                 without requirements on components existence\n\
   -n, --no-newline              do not output the trailing newline\n\
   -q, --quiet,\n\
Index: src/remove.c
===================================================================
RCS file: /fetish/cu/src/remove.c,v
retrieving revision 1.127
diff -p -u -r1.127 remove.c
--- src/remove.c        19 May 2005 10:37:40 -0000      1.127
+++ src/remove.c        2 Jun 2005 04:54:34 -0000
@@ -231,7 +231,7 @@ pop_dir (Dirstack_state *ds)
   top_len = length[n_lengths - 1];
   assert (top_len >= 2);
 
-  /* Pop off the specified length of pathname.  */
+  /* Pop the specified length of file name.  */
   assert (obstack_object_size (&ds->dir_stack) >= top_len);
   obstack_blank (&ds->dir_stack, -top_len);
 
@@ -271,7 +271,7 @@ right_justify (char *dst, size_t dst_len
   return dst_len - src_len;
 }
 
-/* Using the global directory name obstack, create the full path to FILENAME.
+/* Using the global directory name obstack, create the full name FILENAME.
    Return it in sometimes-realloc'd space that should not be freed by the
    caller.  Realloc as necessary.  If realloc fails, use a static buffer
    and put as long a suffix in that buffer as possible.  */
Index: src/rmdir.c
===================================================================
RCS file: /fetish/cu/src/rmdir.c,v
retrieving revision 1.80
diff -p -u -r1.80 rmdir.c
--- src/rmdir.c 14 May 2005 07:58:37 -0000      1.80
+++ src/rmdir.c 2 Jun 2005 04:54:34 -0000
@@ -1,5 +1,5 @@
 /* rmdir -- remove directories
-   Copyright (C) 90, 91, 1995-2002, 2004 Free Software Foundation, Inc.
+   Copyright (C) 90, 91, 1995-2002, 2004, 2005 Free Software Foundation, Inc.
 
    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
@@ -49,7 +49,7 @@
 char *program_name;
 
 /* If true, remove empty parent directories.  */
-static bool empty_paths;
+static bool remove_empty_parents;
 
 /* If true, don't treat failure to remove a nonempty directory
    as an error.  */
@@ -72,7 +72,7 @@ static struct option const longopts[] =
   {"ignore-fail-on-non-empty", no_argument, NULL,
    IGNORE_FAIL_ON_NON_EMPTY_OPTION},
 
-  {"path", no_argument, NULL, 'p'},
+  {"path", no_argument, NULL, 'p'},  /* Deprecated.  */
   {"parents", no_argument, NULL, 'p'},
   {"verbose", no_argument, NULL, 'v'},
   {GETOPT_HELP_OPTION_DECL},
@@ -89,34 +89,34 @@ errno_rmdir_non_empty (int error_number)
   return (error_number == RMDIR_ERRNO_NOT_EMPTY);
 }
 
-/* Remove any empty parent directories of PATH.
-   If PATH contains slash characters, at least one of them
+/* Remove any empty parent directories of DIR.
+   If DIR contains slash characters, at least one of them
    (beginning with the rightmost) is replaced with a NUL byte.
    Return true if successful.  */
 
 static bool
-remove_parents (char *path)
+remove_parents (char *dir)
 {
   char *slash;
   bool ok = true;
 
-  strip_trailing_slashes (path);
+  strip_trailing_slashes (dir);
   while (1)
     {
-      slash = strrchr (path, '/');
+      slash = strrchr (dir, '/');
       if (slash == NULL)
        break;
       /* Remove any characters after the slash, skipping any extra
         slashes in a row. */
-      while (slash > path && *slash == '/')
+      while (slash > dir && *slash == '/')
        --slash;
       slash[1] = 0;
 
       /* Give a diagnostic for each attempted removal if --verbose.  */
       if (verbose)
-       error (0, 0, _("removing directory, %s"), path);
+       error (0, 0, _("removing directory, %s"), dir);
 
-      ok = (rmdir (path) == 0);
+      ok = (rmdir (dir) == 0);
 
       if (!ok)
        {
@@ -128,7 +128,7 @@ remove_parents (char *path)
            }
          else
            {
-             error (0, errno, "%s", quote (path));
+             error (0, errno, "%s", quote (dir));
            }
          break;
        }
@@ -153,8 +153,7 @@ Remove the DIRECTORY(ies), if they are e
                   is non-empty\n\
 "), stdout);
       fputs (_("\
-  -p, --parents   remove DIRECTORY, then try to remove each directory\n\
-                  component of that path name.  E.g., `rmdir -p a/b/c' is\n\
+  -p, --parents   Remove DIRECTORY and its ancestors.  E.g., `rmdir -p a/b/c' 
is\n\
                   similar to `rmdir a/b/c a/b a'.\n\
   -v, --verbose   output a diagnostic for every directory processed\n\
 "), stdout);
@@ -179,14 +178,14 @@ main (int argc, char **argv)
 
   atexit (close_stdout);
 
-  empty_paths = false;
+  remove_empty_parents = false;
 
   while ((optc = getopt_long (argc, argv, "pv", longopts, NULL)) != -1)
     {
       switch (optc)
        {
        case 'p':
-         empty_paths = true;
+         remove_empty_parents = true;
          break;
        case IGNORE_FAIL_ON_NON_EMPTY_OPTION:
          ignore_fail_on_non_empty = true;
@@ -224,7 +223,7 @@ main (int argc, char **argv)
          error (0, errno, "%s", quote (dir));
          ok = false;
        }
-      else if (empty_paths)
+      else if (remove_empty_parents)
        {
          ok &= remove_parents (dir);
        }
Index: src/sort.c
===================================================================
RCS file: /fetish/cu/src/sort.c,v
retrieving revision 1.312
diff -p -u -r1.312 sort.c
--- src/sort.c  27 May 2005 20:36:40 -0000      1.312
+++ src/sort.c  2 Jun 2005 04:54:34 -0000
@@ -700,7 +700,7 @@ default_sort_size (void)
 }
 
 /* Return the sort buffer size to use with the input files identified
-   by FPS and FILES, which are alternate paths to the same files.
+   by FPS and FILES, which are alternate names of the same files.
    NFILES gives the number of input files; NFPS may be less.  Assume
    that each input line requires LINE_BYTES extra bytes' worth of line
    information.  Do not exceed a bound on the size: if the bound is
Index: src/system.h
===================================================================
RCS file: /fetish/cu/src/system.h,v
retrieving revision 1.119
diff -p -u -r1.119 system.h
--- src/system.h        30 May 2005 07:33:55 -0000      1.119
+++ src/system.h        2 Jun 2005 04:54:34 -0000
@@ -1,4 +1,4 @@
-/* system-dependent definitions for fileutils, textutils, and sh-utils 
packages.
+/* system-dependent definitions for coreutils
    Copyright (C) 1989, 1991-2005 Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
@@ -28,7 +28,7 @@ you must include <sys/types.h> before in
 #include <sys/stat.h>
 
 #if !defined HAVE_MKFIFO
-# define mkfifo(path, mode) (mknod ((path), (mode) | S_IFIFO, 0))
+# define mkfifo(name, mode) mknod (name, (mode) | S_IFIFO, 0)
 #endif
 
 #if HAVE_SYS_PARAM_H
Index: src/tty.c
===================================================================
RCS file: /fetish/cu/src/tty.c,v
retrieving revision 1.59
diff -p -u -r1.59 tty.c
--- src/tty.c   14 May 2005 07:58:37 -0000      1.59
+++ src/tty.c   2 Jun 2005 04:54:34 -0000
@@ -1,5 +1,5 @@
-/* tty -- print the path of the terminal connected to standard input
-   Copyright (C) 1990-2004 Free Software Foundation, Inc.
+/* tty -- print the name of the terminal connected to standard input
+   Copyright (C) 1990-2005 Free Software Foundation, Inc.
 
    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
Index: src/who.c
===================================================================
RCS file: /fetish/cu/src/who.c,v
retrieving revision 1.109
diff -p -u -r1.109 who.c
--- src/who.c   14 May 2005 07:58:37 -0000      1.109
+++ src/who.c   2 Jun 2005 04:54:34 -0000
@@ -333,8 +333,8 @@ print_user (const STRUCT_UTMP *utmp_ent,
   PIDSTR_DECL_AND_INIT (pidstr, utmp_ent);
 
   /* Copy ut_line into LINE, prepending `/dev/' if ut_line is not
-     already an absolute pathname.  Some system may put the full,
-     absolute pathname in ut_line.  */
+     already an absolute file name.  Some systems may put the full,
+     absolute file name in ut_line.  */
   if (utmp_ent->ut_line[0] == '/')
     {
       strncpy (line, utmp_ent->ut_line, sizeof (utmp_ent->ut_line));




reply via email to

[Prev in Thread] Current Thread [Next in Thread]