add directory bin

bin/old/bash-1.11/getcwd.c

@@ -0,0 +1,181 @@
+/* Copyright (C) 1991 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+The GNU C Library is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 1, or (at your option)
+any later version.
+
+The GNU C Library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the GNU C Library; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include <errno.h>
+#include <limits.h>
+#include <stddef.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include "maxpath.h"
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if !defined (PATH_MAX)
+#  if defined (_POSIX_PATH_MAX)
+#    define PATH_MAX _POSIX_PATH_MAX
+#  else
+#    if defined (MAXPATHLEN)
+#      define PATH_MAX MAXPATHLEN
+#    else
+#      define PATH_MAX 255
+#    endif
+#  endif
+#endif
+
+/* Get the pathname 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, unless SIZE <= 0, in which case it is as
+   big as necessary.  */
+#ifdef __STDC__
+char *getcwd(char *buf, int size) /* from <sys/unistd.h> */
+#else
+char *
+getcwd (buf, size)
+     char *buf;
+     size_t size;
+#endif
+{
+  dev_t rootdev, thisdev;
+  ino_t rootino, thisino;
+  char path[PATH_MAX + 1];
+  register char *pathp;
+  struct stat st;
+
+  pathp = &path[sizeof (path)];
+  *--pathp = '\0';
+
+  if (stat (".", &st) < 0)
+    return (NULL);
+
+  thisdev = st.st_dev;
+  thisino = st.st_ino;
+
+  if (stat ("/", &st) < 0)
+    return (NULL);
+
+  rootdev = st.st_dev;
+  rootino = st.st_ino;
+
+  while (!(thisdev == rootdev && thisino == rootino))
+    {
+      register DIR *dirstream;
+      register struct dirent *d;
+      dev_t dotdev;
+      ino_t dotino;
+      char mount_point;
+
+      /* Move up a directory.  */
+      if (chdir ("..") < 0)
+	{
+	  if (pathp != &path[sizeof (path) - 1])
+	    {
+	      /* Try to get back to the original directory.
+		 This is the only place where this is possible.  */
+	      int save = errno;
+	      (void) chdir (pathp);
+	      errno = save;
+	    }
+	  return (NULL);
+	}
+
+      /* Figure out if this directory is a mount point.  */
+      if (stat(".", &st) < 0)
+	return (NULL);
+
+      dotdev = st.st_dev;
+      dotino = st.st_ino;
+      mount_point = (dotdev != thisdev);
+
+      /* Search for the last directory.  */
+      dirstream = opendir(".");
+      if (dirstream == NULL)
+	return (NULL);
+
+      while ((d = readdir(dirstream)) != NULL)
+	{
+	  if (d->d_name[0] == '.' &&
+	      (d->d_name[1] == 0 ||
+	       (d->d_name[2] == 0 && d->d_name[1] == '.')))
+	    continue;
+
+	  /* if (mount_point || d->d_fileno == thisino) */
+	  if (mount_point || d->d_ino == thisino)
+	    {
+	      if (stat(d->d_name, &st) < 0)
+		{
+		  int save = errno;
+		  (void) closedir(dirstream);
+		  errno = save;
+		  return (NULL);
+		}
+
+	      if (st.st_dev == thisdev && st.st_ino == thisino)
+		break;
+	    }
+	}
+
+      if (d == NULL)
+	{
+	  int save = errno;
+	  (void) closedir (dirstream);
+	  errno = save;
+	  return (NULL);
+	}
+      else
+	{
+	  int d_namlen=strlen(d->d_name); /* new line */
+	  pathp -= d_namlen;
+	  (void) memcpy(pathp, d->d_name, d_namlen);
+	  *--pathp = '/';
+	  (void) closedir (dirstream);
+	}
+
+      thisdev = dotdev;
+      thisino = dotino;
+    }
+
+  if (pathp == &path[sizeof (path) - 1])
+    *--pathp = '/';
+
+  if (chdir (pathp) < 0)
+    return (NULL);
+
+  {
+    size_t len = &path[sizeof (path)] - pathp;
+    if (buf == NULL)
+      {
+	if (len < (size_t) size)
+	  len = size;
+	buf = (char *) malloc (len);
+	if (buf == NULL)
+	  return (NULL);
+      }
+    else if ((size_t) size < len)
+      {
+	errno = ERANGE;
+	return (NULL);
+      }
+    (void) memcpy ((char *) buf, (char *) pathp, len);
+  }
+
+  return (buf);
+}