file.cxx

Go to the documentation of this file.

//
// Copyright 2002, Lowell Boggs Jr.
//
// This file or directory, containing source code for a computer program,
// is Copyrighted by Lowell Boggs, Jr.  987 Regency Drive, Lewisville
// TX (USA), 75067.  You may use, copy, modify, and distribute this
// source file without charge or obligation so long as you agree to
// the following:
//
//  1.  You must indemnify Lowell Boggs against any and all financial
//      obligations caused by its use, misuse, function, or malfunction.
//      Further, you acknowledge that there is no warranty of any kind,
//      whatsoever.
//
//  2.  You agree not to attempt to patent any portion of this original
//      work -- though you may attempt to patent your own extensions to
//      it if you so choose.
//
//  3.  You keep this copyright notice with the file and all copies
//      of the file and do not change it anyway except language translation.
//
// You are responsible for enforcing your own compliance with these
// conditions and may not use this source file if you cannot agree to the
// above terms and conditions.


#include <cxxtls/file.h>
#include <cxxtls/options.h>
#include <cxxtls/strtool.h>
#include <portable_io.h>

#include <time.h>
#include <errno.h>
#include <algorithm>
#include <fcntl.h>
#include <memory.h>
#include <string.h>
#include <cxxtls/user.h>
#include <set>

using namespace std;

namespace cxxtls
{

#ifdef _MSC_VER
#  include <io.h>
#  include <direct.h>
#  define R_OK    4       /* Test for Read permission    */
#  define W_OK    2       /* Test for Write permission   */
#  define X_OK    1       /* Test for eXecute permission */
#  define F_OK    0       /* Test for existence of File  */
#  define lstat   stat    /* no such beast on nt         */
#  define S_ISLNK(x)   0  /* ditto                       */
#  define S_IFLNK      0  /* more ditto                  */
# include <wchar.h>
# include <wtypes.h>
# include <direct.h>
# include <process.h>

#  define  SET_MODE(a,b)  setmode(a,b)


#ifndef NAME_MAX
#  define NAME_MAX 255
#endif

#define __DIRENT_COOKIE 0xfefeabab



struct dirent
{
  ino_t d_ino;                  /* unused - no equivalent on WIN32 */
  char d_name[NAME_MAX+1];
};
                
typedef struct dir_struct
{
  ULONG   dir_ulCookie;
  HANDLE  dir_hDirHandle;
  DWORD   dir_nNumFiles;
  char    dir_pDirectoryName[NAME_MAX+1];
  struct dirent dir_sdReturn;
}DIR;
                                        
DIR *opendir(const char *);
struct dirent *readdir(DIR *);
void closedir(DIR *);

struct passwd { char* pw_name; };

struct passwd* getpwuid(int) { return 0; }
                                                        
#else
#  include <dirent.h>
#  include <unistd.h>
#  include <pwd.h>
#  include <grp.h>
#  define  O_BINARY  0 /* not needed on unix */
#  define  SET_MODE(a,b)
#endif

#include <sys/stat.h>
#include <time.h>
#include <portable_io.h>

extern "C"
{
#include <fnmatch.h>
};

typedef FileName::rep_t rep_t;


FileTime::
operator string() const
{
  char buffer[256];

  sprintf(buffer, "%02d/%02d/%02d %02d:%02d:%02d",
          year % 100,
          month +1,  // so as not to confuse people who are used to a 1 based month system
          day,
          hour,
          minute,
          second
         );
        
  return buffer;

}

char const *months[]=
{
  "Jan",
  "Feb",
  "Mar",
  "Apr",
  "May",
  "Jun",
  "Jul",
  "Aug",
  "Sep",
  "Oct",
  "Nov",
  "Dec"
};

string
FileTime::
short_string() const
{

   time_t curtime;

   time(&curtime);

   struct tm *p = localtime(&curtime);

   if(p)
   {
     long operand_month = year * 12 + month;

     long current_month = p->tm_year * 12 + p->tm_mon;

     long delta = current_month - operand_month;

     if(delta < -6 || delta > 6)
     {
       char buffer[256];

       sprintf(buffer, "%s %2d  %d", months[month], day, year + 1900);

       return buffer;

     }
     else
     {
       char buffer[256];

       sprintf(buffer, "%s %2d %02d:%02d", months[month], day, hour, minute);

       return buffer;
     }

   }
   else
   {
     char buffer[256];

     sprintf(buffer, "%s %2d  %d", months[month], day, year + 1900);

     return buffer;

   }
}


bool
FileTime::
construct_from_string(string s)
{
  // looking for MMM DD (YYYY/HR::MM)

  char month_buf[2048];
  int  day_buf        ;
  char year_buf [2048];

  if(3 != sscanf(s.c_str(), "%s %d %s", month_buf, &day_buf, year_buf))
    return true;

  int i;

  for(i=0; i < 12; ++i)
  {
    if(strcmp(month_buf, months[i]) == 0)
    {
      break;
    }
  }

  if(i == 12)
    return true;

  month = i;

  day = day_buf;

  if(year_buf[1] != ':' && year_buf[2] != ':')
  {
    // user specified   MMM DD year

    if(1 != sscanf(year_buf, "%d", &day_buf) )
      return true;

    hour   = 0;
    minute = 0;
    second = 0;

    year = day_buf - 1900;

    return false;  //  !! yeah !!


  }

  // user did not specify the year but did give the hour and minute

  struct tm *buf;

  time_t curtime;

  time(&curtime);

  if(  0 != (buf = localtime( &curtime )) )
  {
     year = buf->tm_year;

  }
  else
    return true;

  if(2 != sscanf(year_buf, "%d:%d", &day_buf, &i))
    return true;

  second = 0;
  hour   = day_buf;
  minute = i;

  return false;

}



FileTime::
FileTime(struct tm const *p)
{
  if(p == 0)
  {
    year    = 0;
    month   = 0;
    day     = 0;
    hour    = 0;
    minute  = 0;
    second  = 0;
  }
  else
  {
    year    = p->tm_year;
    month   = p->tm_mon;
    day     = p->tm_mday;
    hour    = p->tm_hour;
    minute  = p->tm_min;
    second  = p->tm_sec;
  }

}

FileMode::
operator string() const
  {
    char buffer[40];

    char *scan = buffer;

    *scan++ = ( (mode&FileMode::link)            ? 'L' : ' ' );
    *scan++ = ( (mode&FileMode::directory)       ? 'd' : '-' );
    *scan++ = ( (mode&FileMode::user_readable)   ? 'r' : '-' );
    *scan++ = ( (mode&FileMode::user_writeable)  ? 'w' : '-' );
    *scan++ = ( (mode&FileMode::user_executable) ? (mode &FileMode:: set_uid ? 'S' : 'x' ) : ('-') );
    *scan++ = ( (mode&FileMode::group_readable)   ? 'r' : '-' );
    *scan++ = ( (mode&FileMode::group_writeable)  ? 'w' : '-' );
    *scan++ = ( (mode&FileMode::group_executable) ? (mode &FileMode:: set_gid ? 'S' : 'x' ) : ('-') );
    *scan++ = ( (mode&FileMode::world_readable)   ? 'r' : '-' );
    *scan++ = ( (mode&FileMode::world_writeable)  ? 'w' : '-' );
    *scan++ = ( (mode&FileMode::world_executable) ? 'x' : '-' );

    *scan   = 0;

    return buffer;
  }

void
FileMode::
construct_from_string(char const *permissions)
{
  int l = strlen(permissions);

  mode=0;

  if(l >= 10)
  {
    //
    // explicit detail specified
    //

    if(permissions[0] == 'l' || permissions[0] == 'L' )
      mode = FileMode::link;

    if(l == 10)
      --permissions;  // first char was missing

    if(permissions[1] == 'd')
      mode = FileMode::directory;


    if(permissions[2] == 'r') mode += FileMode::user_readable;
    if(permissions[3] == 'w') mode += FileMode::user_writeable;
    if(permissions[4] == 'x') mode += FileMode::user_executable;
    if(permissions[4] == 's') mode += FileMode::user_executable + FileMode::set_uid;
    if(permissions[4] == 'S') mode += FileMode::user_executable + FileMode::set_uid;

    if(permissions[5] == 'r') mode += FileMode::group_readable;
    if(permissions[6] == 'w') mode += FileMode::group_writeable;
    if(permissions[7] == 'x') mode += FileMode::group_executable;
    if(permissions[7] == 's') mode += FileMode::group_executable + FileMode::set_gid;
    if(permissions[7] == 'S') mode += FileMode::group_executable + FileMode::set_gid;

    if(permissions[8] == 'r') mode += FileMode::world_readable;
    if(permissions[9] == 'w') mode += FileMode::world_writeable;
    if(permissions[10] == 'x') mode += FileMode::world_executable;
  }
  else
  {
    while(*permissions == ' ')
      ++permissions;

    if(*permissions == '0')
    {
      int value=0;

      sscanf(permissions, "%o", &value);

      int user   = (value >> 6) & 7;
      int group  = (value >> 3) & 7;
      int world  = (value     ) & 7;

      if(user & 4) mode |= FileMode::user_readable;
      if(user & 2) mode |= FileMode::user_writeable;
      if(user & 1) mode |= FileMode::user_executable;

      if(group & 4) mode |= FileMode::group_readable;
      if(group & 2) mode |= FileMode::group_writeable;
      if(group & 1) mode |= FileMode::group_executable;

      if(world & 4) mode |= FileMode::world_readable;
      if(world & 2) mode |= FileMode::world_writeable;
      if(world & 1) mode |= FileMode::world_executable;

    }
  }

}


FileMode::
FileMode(int m)
  // m is assumed to be a struct stat member st_mode
{
  mode = 0;

#if _MSC_VER

  if(m & _S_IFDIR)     mode |= directory     | user_executable| group_executable | world_executable;
  if(m & _S_IREAD)     mode |= user_readable | group_readable | world_readable;
  if(m & _S_IWRITE)    mode |= user_writeable| group_writeable| world_writeable;

#else
  if(S_ISLNK(m))      mode |= link;
  if(S_ISDIR(m))      mode |= directory;
  if(m & S_ISUID)     mode |= set_uid;
  if(m & S_ISGID)     mode |= set_gid;

  if(m & S_IRUSR)     mode |= user_readable;
  if(m & S_IWUSR)     mode |= user_writeable;
  if(m & S_IXUSR)     mode |= user_executable;

  if(m & S_IRGRP)     mode |= group_readable;
  if(m & S_IWGRP)     mode |= group_writeable;
  if(m & S_IXGRP)     mode |= group_executable;

  if(m & S_IROTH)     mode |= world_readable;
  if(m & S_IWOTH)     mode |= world_writeable;
  if(m & S_IXOTH)     mode |= world_executable;
#endif
}



rep_t
FileName::
basename(bool remove_extension) const
  // return the file name, without the directory part -- and optionally
  // without the file name extension
{

  const_iterator first = begin();
  const_iterator last  = end();

  while(last != first)
  {
    --last;

    if(*last == '/' || *last == '\\')
    {
      ++last;
      const_iterator tail = end();

      if(remove_extension)
      {
         // code duplicated below, sigh.

         while(tail != last)
         {
           --tail;

           if(*tail == '.')
             break;

         }

         if(tail == last)
           tail = end();  // no '.' was found

      }

      return rep_t(last, tail);
    }

  }

  // no pathname was included return all that's left or 
  // optionally remove the file name extension

  {
      if(remove_extension)
      {
         // code duplicated above, sigh.

         const_iterator last = begin();
         const_iterator tail = end();

         while(tail != last)
         {
           --tail;

           if(*tail == '.')
             break;

         }

         if(tail == last)
           tail = end();  // no '.' was found

         return rep_t(last, tail);

      }

  }

  return *this;

}

rep_t
FileName::
dirname() const
  // return only the directory part of the file name (trailing / is include)
{
  const_iterator first = begin();
  const_iterator last  = end();

  while(last != first)
  {
    --last;

    if(*last == '/' || *last == '\\')
    {
      return rep_t(first, ++last);
    }

  }

  // file has no directory specified -- return './' because all directories
  // from this function must end in a valid path separator

  return rep_t("./");

}

//[ FileStatus

string
FileStatus::
convert_to_string(bool resolve_id_names) const
     //- convert_to_string()  Convert the FileStatus to a string.
{
   string rv;


   rv.append(mode);
   rv.append(" ");
   rv.append(time);

   char buffer[256];


   if(resolve_id_names)
   {
      sprintf(buffer, " %-12.12s %-12.12s %12d",
                      id2string(owner_id).c_str(),
                      group2string(group_id).c_str(),
                      (int)(size)
             );

   }
   else
   {
     sprintf(buffer, " %12d %12d %12d", owner_id, group_id, (int)(size));
   }

   rv.append(buffer);

   return rv;

}


void
FileName::
convert_to_absolute_path()
  // if this is not an absolute path, make it one by adding the
  // current directory to it -- and normalize to unix style pathnames
{

  iterator first;
  iterator last ;


  // if the first character is a path separator, then we already have one

  size_t siz = size();

  char c = siz < 1 ? 0 : begin()[0];
  char d = siz < 2 ? 0 : begin()[1];
  char e = siz < 3 ? 0 : begin()[2];

  bool is_full_path =   (c == '/') 
                     || (c == '\\') 
                     || (     (d == ':') 
                          &&  ( e == '/' || (e == '\\') )
                        );


  if( ! is_full_path  )
  {
    // otherwise, read the current directory name

    char buffer[2048];


    if(0 == ::getcwd(buffer, 2048) )
    {
        buffer[0] = '.';
        buffer[1] = '/';
        buffer[2] = 0;
    }

    string new_name(buffer);

    new_name.append("/");
    new_name.append(*this);

    *this = new_name;

  }

  // remove dosifications

  first = begin();
  last  = end();

  while(first != last)
  {
    char c = *first;

    if(c == '\\')
    {
      size_t offset = first - begin();
      erase(first);
      insert(begin() + offset, '/');
      first = begin() + offset;
    }

    ++first;
  }

  // remove ../ and ./ crapola

  { // first ./

    first = begin();
    last  = end();

    while(first != last)
    {
        char const *scan = "/./";
        
        first = search(first, last, scan, scan + 3);
        
        if(first != last)
        {
          size_t off = first - begin();
        
          erase(first, first + 2);
        
          first = begin() + off;
          last  = end();
        
        }
    }

    //
    // now, remove trailing /.
    //

    first = begin();
    last  = end();

    while( last - first > 2 )
    {
      --last;
      --last;

      if(last[0] == '/' && last[1] == '.')
      {
        erase(last, end());
      }
      else
        break;

    }


  }
  {
    first = begin();
    last  = end();

    while(first != last)
    {
        char const *scan = "/../";
        
        first = search(first, last, scan, scan + 4);
        
        if(first != last)
        {
          // we have found /../, but can we remove it?
        
          iterator scan = first - 1;
        
          while(scan != begin())
          {
            if(*scan == '/')
              break;
        
            --scan;
          }
        
          size_t off = scan - begin();
        
          erase(scan, first + 3);
        
          first = begin() + off;
          last  = end();
        
        }
    }

    //
    // now, remove trailing /..
    //

    first = begin();
    last  = end();

    while( last - first > 3 )
    {
      --last;
      --last;
      --last;

      if(last[0] == '/' && last[1] == '.' && last[2] == '.')
      {
        erase(last, end());
        *this = this->dirname();
        if(size())
          erase(begin() + size()-1);
      }
      else
        break;

    }
  }

#ifdef _MSC_VER

  if(this->operator[](0) == '/')
  {
    *this = "c:" + *this;
  }
#endif


}

bool
FileName::
is_syntactically_valid() const
  // contains only valid characters and is of the right length
{
  if(size() < 1)
    return false;

  if(size() > 2048)
    return false;

  const_iterator first = begin();
  const_iterator last  = end();

  while(first != last)
  {
    char c = *first++;

    if(c < ' ' || c > 0x7e)
      return false;

  }

  return true;
}

bool
FileName::
exists() const
  // return true if file by this name exists
{
  char const *name = c_str();
  int  check_mode = F_OK;
  int  access_code = access(name, check_mode);

   return 0 == access_code;
}

bool
FileName::
file_stat(FileStatus* s, bool read_link_info) const
  // Get file stat from os -- return true if error
  // If 'read_link_info' is true, read the symbolic link info
  // or just the file info if the named file is not a symbolic
  // link.
{

  string fixedName = *this;  // remove trailing / or \ because windows is screwed up (stat malfunctions on windows in this case)

  size_t nameLength = fixedName.size();

  if(nameLength)
  {
    char lastChar = fixedName[nameLength-1];

    if(lastChar == '/' || lastChar == '\\')
    {
      // remove trailing / unless that would make the name be empty

      if(nameLength != 1)
      {
        char secondChar = fixedName[1];

        if(secondChar == ':')
        {
          if(nameLength >4)
          {
            fixedName.erase(nameLength-1, 1);
          }
        }
        else
        if(nameLength > 2)
        {
          fixedName.erase(nameLength-1, 1);
        }

      }
    }
  }

  char const *p = fixedName.c_str();

  struct stat buf;

  memset(&buf, 0, sizeof(buf));


  s->mode.mode = 0;
  s->size      = -1;
  s->owner_id  = -1;
  s->group_id  = -1;


  bool is_a_link = false;

  if(read_link_info && lstat(p, &buf))
  {
    // error reading the status

    return true;

  }
  else
  {
     is_a_link = S_ISLNK(buf.st_mode);
  }

  // if we get here it means either we did not try to read the status of the
  // link using lstat, OR, it means that we did read it successfully.

  if(     (    (!read_link_info)
           ||  is_a_link
          )
      &&  stat(p,&buf) 
    )
  {
    return true;  // we called stat and it failed
  }

  // if we get here, we are in one of the following states:
  //
  //   read_link_info was false and we read buf using stat()
  //
  //   read_link_info was true and we have read the link using lstat()
  //   with the following optional situation:
  //
  //      if lstat() was successful and tells us that we have read a 
  //      symbolic link file, then we want to read the same status using
  //      stat() and we are going to OR INTO the mode the fact that this 
  //      is link file.



  s->size = buf.st_size;

  (&s->mode)->~FileMode();   new (&s->mode) FileMode(buf.st_mode);
  (&s->time)->~FileTime();   new (&s->time) FileTime(localtime(&buf.st_mtime));

  s->group_id = buf.st_gid;
  s->owner_id  = buf.st_uid;

  if(is_a_link)
    s->mode.mode |= FileMode::link;   // here are creating an un-unix like file mode.
                                      // in unix, the is-link bit is not compatible with
                                      // other bits such as the is-directory bit.  You
                                      // can, in unix parlance, have a directory OR you can
                                      // have a symbolic link.  But here, we make no such
                                      // rules.  If the link bit is set, then the rest of the
                                      // status tells us the permisions of the thing pointed
                                      // to by the link.




  return false;
}


bool
FileName::
is_dir() const
  // return true if there is a directory by this name
{
  FileStatus s;

  if(file_stat(&s))
    return false;

  return s.mode.is_dir();

}


bool
FileName::
is_executable() const
  // return true if there is an executable by this name
{
  return 0 == access( c_str(), X_OK);

}

bool
FileName::
is_writeable() const
  // return true if the file exists and is writeable
{
  return 0 == access( c_str(), W_OK);
}

bool
FileName::
is_readable() const
  // return true if the file exists and is writeable
{
  return 0 == access( c_str(), R_OK);
}

bool
FileName::
is_createable() const
  // return true if the file exists and is writeable
{
   if( is_writeable() )
     return true;

   FileName dir(dirname());

   if(dir.is_writeable())
     return true;

   return false;


}

FileMode
FileName::
file_mode() const
  // get the corresponding file's mode bits as defined in FileName::mode_bits.
  // a value of 0 means that the file doesn't exist -- it is highly unlikely that
  // a useful file has 0 as its mode.
{
  FileStatus  s;

  if(file_stat(&s))
    return 0;

  return s.mode;

}

FileName::off_t
FileName::
file_size() const
  // get the length of the file corresponding to this name
{
  FileStatus s;

  if(file_stat(&s))
    return -1;

  return s.size;

}

bool
FileName::
file_time(FileTime *rv) const
{
  FileStatus s;

  if(file_stat(&s))
    return true;

  *rv = s.time;

  return false;

}

bool
FileName::
matches(char const *pattern) const
{
   char *p = const_cast<char*>(pattern);
   char *s = const_cast<char*>(c_str());

    return FNM_NOMATCH != fnmatch(p, s, FNM_PATHNAME);
}



string
FileStatus::id2string(int id)
{
  passwd *p = getpwuid(id);

  if(p)
  {
     return p->pw_name;
  }

  char buffer[20];

  sprintf(buffer, "%d", id);

  return buffer;

}


string
FileStatus::group2string(int id)
{
#ifdef _MSC_VER
  return "group";
#else
  struct group *p = getgrgid(id);

  if(p)
  {
     return p->gr_name;
  }

  char buffer[20];

  sprintf(buffer, "%d", id);

  return buffer;
#endif

}

int
FileName::
find_matching(char const *pattern, sorted_names_t *l, int options)
{
  int count=0;

  enum flags { include_paths=1,
               only_dirs=    2,
               not_dirs=     4
             };

  FileName f(pattern);

  string dir = f.dirname();
  string base= f.basename();


  if(dir.size() > 1 && dir[dir.size()-1] == '/')
  {
    dir.erase( dir.begin() + dir.size() - 1 );
  }

#ifdef _MSC_VER

  if(dir.size() == 2 && dir[dir.size()-1] == ':')
  {
    dir += '/';
  }

  if(dir.size() == 0 || dir == "/")
  {
    dir = "c:/";
  }

#else

  if(dir.size() == 0)
  {
    dir = "/";
  }

#endif



  DIR    *d   = opendir(dir.c_str());
  dirent *e;

  while(d && (e = readdir(d) ) )
  {
    char *pat = const_cast<char*>(base.c_str());

    if( fnmatch(pat, e->d_name, FNM_PATHNAME) == 0 )
    {
       FileName rv(e->d_name);
       FileName path(rv);

       if(dir.size() != 0)
          path = dir + string("/") + rv;

       FileStatus fs;

       path.file_stat(&fs);

       if(fs.mode.is_dir())
       {
         if( options & not_dirs )
         {
            continue;  // skipping dirs
         }

         if( options & include_paths )
           rv = path;


       }
       else
       {
         if( options & only_dirs )
         {
            continue;  // skipping non-dirs
         }

         if( options & include_paths )
           rv = path;
       }

       l->insert(rv);

       ++count;

    }
  }

  if(d)
    closedir(d);

  return count;
}

#ifdef _MSC_VER
DIR*
opendir(const char* pDirName)
{
        struct stat sb;
        DIR*    pDir;
        char*   pEndDirName;
        int     nBufferLen;

        std::string adjustedDirName(pDirName);

        size_t dirNameLength = adjustedDirName.size();

        if(dirNameLength)
        {

           // remove trailing \ unless we are looking at c:\, in which casae
           // you have to leave it on.

           if(adjustedDirName[dirNameLength-1] == '/' ||
              adjustedDirName[dirNameLength-1] == '\\'
             )
           {
              adjustedDirName.erase(dirNameLength-1);

              --dirNameLength;

              if(dirNameLength == 2 && adjustedDirName[1] == ':')
              {
                 adjustedDirName += '\\';
                 ++dirNameLength;
              }

           }
        }

        pDirName = adjustedDirName.c_str();


        /* sanity checks */
        if (!pDirName) {
                errno = EINVAL;
                return NULL;
        }
        if (stat(pDirName, &sb) != 0) {
                errno = ENOENT;
                return NULL;
        }
        if ((sb.st_mode & S_IFMT) != S_IFDIR) {
                errno = ENOTDIR;
                return NULL;
        }

        /* allocate a DIR structure to return */
        pDir = (DIR *) malloc(sizeof (DIR));

        if (!pDir)
                return NULL;

        /* input directory name length */
        nBufferLen = strlen(pDirName);

        /* copy input directory name to DIR buffer */
        strcpy(pDir->dir_pDirectoryName, pDirName);

        /* point to end of the copied directory name */
        pEndDirName = &pDir->dir_pDirectoryName[nBufferLen - 1];

        /* if directory name did not end in '/' or '\', add '/' */
        if ((*pEndDirName != '/') && (*pEndDirName != '\\')) {
                pEndDirName++;
                *pEndDirName = '/';
        }

        /* now append the wildcard character to the buffer */
        pEndDirName++;
        *pEndDirName = '*';
        pEndDirName++;
        *pEndDirName = '\0';

        /* other values defaulted */
        pDir->dir_nNumFiles = 0;
        pDir->dir_hDirHandle = INVALID_HANDLE_VALUE;
        pDir->dir_ulCookie = __DIRENT_COOKIE;

        return pDir;
}

void
closedir(DIR *pDir)
{
        /* got a valid pointer? */
        if (!pDir) {
                errno = EINVAL;
                return;
        }

        /* sanity check that this is a DIR pointer */
        if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
                errno = EINVAL;
                return;
        }

        /* close the WIN32 directory handle */
        if (pDir->dir_hDirHandle != INVALID_HANDLE_VALUE)
                FindClose(pDir->dir_hDirHandle);

        free(pDir);

        return;
}

struct dirent *
readdir(DIR* pDir)
{
        WIN32_FIND_DATA wfdFindData;

        if (!pDir) {
                errno = EINVAL;
                return NULL;
        }

        /* sanity check that this is a DIR pointer */
        if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
                errno = EINVAL;
                return NULL;
        }

        if (pDir->dir_nNumFiles == 0) {
                pDir->dir_hDirHandle = FindFirstFile(pDir->dir_pDirectoryName, &wfdFindData);
                if (pDir->dir_hDirHandle == INVALID_HANDLE_VALUE)
                        return NULL;
        } else if (!FindNextFile(pDir->dir_hDirHandle, &wfdFindData))
                        return NULL;

        /* bump count for next call to readdir() or telldir() */
        pDir->dir_nNumFiles++;

        /* fill in struct dirent values */
        pDir->dir_sdReturn.d_ino = -1;
        strcpy(pDir->dir_sdReturn.d_name, wfdFindData.cFileName);

        return &pDir->dir_sdReturn;
}

#endif

void
FileName::
slurp(FileContents *c) const
  // read the named file into c
{
  FILE *f = fopen(c_str(), "rb");

  if(!f)
  {
    c->set_error("fopen failed");
  }
  else
  {
     FileStatus s;

     if(file_stat(&s))
     {
       c->set_error("couldn't get file status");
     }
     else
     {
        c->reserve(s.size);
        
        long size = fread(c->begin(), 1, s.size, f);

        if(size != s.size)
        {
          c->reserve(0);
        
          c->set_error("reading file resulted in fewer bytes that the file status indicated");
        }
        else
        {
          c->clear_error();
        }
        
     }

     fclose(f);

  }

}

FileName
FileName::
mktemp(FileName dir)
{
  char buffer[40];

  int count;

  for(count=1; count < 100; ++count)
  {
    if(count > 1)
      sprintf(buffer, "%d.tmp.%d", getpid(), count);
    else
      sprintf(buffer, "%d.tmp", getpid());

    FileName rv = dir + buffer;

    if(! rv.exists() )
      return rv;
  }

  static int badcount=0;

  sprintf(buffer, "%d-%d", getpid(), badcount++);

  return dir + buffer;

}

struct Is_Path_Space
{
  bool operator() (char c) const
  {
    return c == ' '  ||
           c == '\t' ||
           c == '\n' ||
           c == '\r' ||
           c == FileName::PATH_separator
           ;
  }

};


FileName
FileName::
find_executable(string progname, string path)
{
  //
  // make sure that 'path' has something it in
  //

  if(path.size() == 0)
  {

    char const *p;

    if(ProgramOptions::global_options_)
      p = ProgramOptions::global_options_->getenv("PATH").c_str();
    else
      p = getenv("PATH"); // if it doesn't, use the path
                                    // environment variable
    if(p)
      path = p;
  }

  StrTool::stringlist_t splitpath;

  Is_Path_Space functor;


  StrTool::parse_words(path,
                       &splitpath,
                       2000000000U,
                       functor
                      );

  StrTool::stringlist_t::iterator f = splitpath.begin();
  StrTool::stringlist_t::iterator l = splitpath.end();

  while(f != l)
  {
#ifdef _MSC_VER

     FileName progpath(*f++);

     progpath += "\\";
     progpath += progname;

     for(size_t i=0; i < progpath.size(); ++i)
       if(progpath[i] == '/')
          progpath[i] = '\\';

     if(progpath.exists())  // this really should check for is executable...
     {
       return progpath;
     }

     FileName exefile(progpath + ".exe");

     if(exefile.exists())
     {
       return exefile;
     }

     FileName batfile(progpath + ".bat");

     if(batfile.exists())
     {
       return batfile;
     }

     FileName cmdfile(progpath + ".cmd");

     if(cmdfile.exists())  // this really should check for is executable...
     {
       return cmdfile;
     }

     FileName comfile(progpath + ".com");

     if(comfile.exists())  // this really should check for is executable...
     {
       return comfile;
     }

#else
     FileName progpath(*f++);

     progpath += "/";
     progpath += progname;

     if(progpath.exists())  // this really should check for is executable...
     {
       return progpath;
     }
#endif

  }

  return "";  // not found
                                
}


FileName
FileName::
find_file_in_path(string progname, string path)
{
  //
  // make sure that 'path' has something it in
  //

  if(path.size() == 0)
  {

    // if it doesn't, use the path environment variable

    char const *p;

    if(ProgramOptions::global_options_)
      p = ProgramOptions::global_options_->getenv("PATH").c_str();
    else
      p = getenv("PATH");

    if(p)
      path = p;
  }


  StrTool::stringlist_t splitpath;

  Is_Path_Space functor;

  StrTool::parse_words(path,
                       &splitpath,
                       2000000000U,
                       functor
                      );

  StrTool::stringlist_t::iterator f = splitpath.begin();
  StrTool::stringlist_t::iterator l = splitpath.end();

  StrTool::stringlist_t  expandedList; // a copy of the splitpath with * and ? expanded

  {
    // expand * and ? in the input path so that things like this work:
    //
    //  /home/lboggs/*
    //
    // Becomes all the directories underneath /home/lboggs (top level only)

    while(f != l)
    {
      if(f->find_first_of("*?") < f->size())
      {
        sorted_names_t matches;

        find_matching(f->c_str(), &matches, 3); // find only dirs and include the paths

        sorted_names_t::iterator a = matches.begin(), b = matches.end();

        while(a != b) expandedList.push_back(*a++);


      }
      else
        expandedList.push_back(*f);

      ++f;

    }

    // setup for the next algorithm to search for files in the directory list
    // just computed

    f = expandedList.begin();
    l = expandedList.end();

  }


  while(f != l)
  {
     FileName progpath(*f++);

     progpath += "/";
     progpath += progname;

     if(progpath.exists())
     {
       progpath.convert_to_absolute_path();
       return progpath;
     }

  }

  return "";  // not found
                                
}


#ifdef _MSC_VER
char FileName::PATH_separator = ';';
#else
char FileName::PATH_separator = ':';
#endif


bool
FileName::
remove() const
{
  char const *n = c_str();

  if(access(n, W_OK) != 0)
    return true;

  return 0 != unlink(n);
}

bool
FileName::
rmdir() const
{
  errno = 0;
  return 0 != ::rmdir(c_str()) || errno != 0;
}

bool
FileName::
mkdir( FileMode permissions ) const
{
#ifdef _MSC_VER
   return 0 != ::mkdir(c_str());
#else
   return 0 != ::mkdir(c_str(), permissions.os_mode());
#endif
}

int
FileMode::
os_mode() const
{
  int rv=0;

#if _MSC_VER

  if(mode & directory)      rv |= _S_IFDIR;
  if(mode & user_readable)  rv |= _S_IREAD;
  if(mode & user_writeable) rv |= _S_IWRITE;

#else

  if(mode & link)           rv |= S_IFLNK;
  if(mode & directory)      rv |= S_IFDIR;
  if(mode & set_uid)        rv |= S_ISUID;
  if(mode & set_gid)        rv |= S_ISGID;
  if(mode & user_readable)  rv |= S_IRUSR;
  if(mode & user_writeable) rv |= S_IWUSR;
  if(mode & user_executable)rv |= S_IXUSR;
  if(mode & group_readable)  rv |= S_IRGRP;
  if(mode & group_writeable) rv |= S_IWGRP;
  if(mode & group_executable)rv |= S_IXGRP;
  if(mode & world_readable)  rv |= S_IROTH;
  if(mode & world_writeable) rv |= S_IWOTH;
  if(mode & world_executable)rv |= S_IXOTH;

#endif

  return rv;

}

bool
FileName::
copy(FileName const &destination) const
{
  char buffer[32768];

  FileStatus stat;

  if(file_stat(&stat))
    return true;   // error reading source file attributes

  int fh_in = open(c_str(), O_RDONLY | O_BINARY);

  if(fh_in < 0)
    return true;

  destination.remove();  // make sure its gone

  int fh  = creat(destination.c_str(), stat.mode.os_mode());
                
  if(fh < 0)
    return true;

  SET_MODE(fh, O_BINARY);

  int bytes_read;
  int bytes_written;

  bool rv = false;

  for(;;)
  {
    bytes_read = read(fh_in, buffer, sizeof(buffer));

    if(bytes_read == 0)
      break;

    bytes_written = ::write(fh, buffer, bytes_read);

    if(bytes_written != bytes_read)
    {
      rv = true;
      break;
    }

  }

  close(fh);
  close(fh_in);


  return rv;
}

bool
FileName::
chmod( FileMode mode ) const
{
   int err = ::chmod( c_str(), mode.os_mode() );

   if(err)
     return true;

   return false;

}

bool
FileName::
rename( FileName const &destination ) const
{
   if(destination.exists() && !destination.is_writeable())
   {
     return true;
   }

   int err = ::rename( c_str(), destination.c_str() );

   if(err)
     return true;

   return false;

}

string
FileName::
extension() const
{
  const_iterator first = begin(),
                 last  = end();
                
  while(last != first)
  {
    --last;

    char c = *last;

    if(c == '.')
      return string(last, end());
    else
    if(c == '/')
      break;
    else
    if(c == '\\')
      break;
  }

  return "";
                
}

size_t
FileName::
slurp(list<string> *lines) const
{
  //
  // This function reads the file into a list of strings.  A
  // list of strings was chosen over vector so as to guarantee O(1) inserts
  // at the rear of the container.
  //
  // To achieve high speed, the readline function is not employed.  Readline
  // uses the string operator += method on each character in the file.  This is a
  // lot of overhead on large files.  To reduce that overhead, instead of invoking
  // one string method call per character, we reduce that to one per line -- often
  // an 80 to one reduction, more likely a 40 to one.  This is accomplished by
  // reading big blocks from the file and parsing the data into lines then appending
  // the entire line to the file in a single string method call.  Of course, you have
  // handle the occaisional partial line which occurs when an end of block occurrs
  // that is not exactly matched to the end of a line (ie the new line character).
  //
  // Now, I could have chosen to slurp the entire file into memory then parse the
  // in-memory image -- thus never needing to handle partial lines.  But this would
  // double the memory requirements.
  //
  // Parsing the data into lines is done using the memchr() function which is often
  // written in assembly language.  It will give maximum performance across multiple
  // machines and os's.


  bool incomplete_line=false;    // flag indicating part of line parsed in one block
                                 // and the rest resides in the next block

  size_t line_count=0;

  int fh = open(c_str(), O_RDONLY);

  for(;;)
  {
    //
    // Read blocks from the file, parse the lines in the block, append each
    // line into the target list.
    //
    char buffer[32768];

    int bytes_read = read(fh, buffer, sizeof(buffer));

    if(bytes_read < 1)
      break;

    char const *next = buffer;
    char const *end  = buffer + bytes_read;

    while(next < end)
    {
      char * eol = (char*)memchr(next, '\n', end - next);

      if(eol == 0)
      {
        // no complete line exists, put the rest of the
        // next in a partial line

        if(incomplete_line)
          lines->back().append(next, end - next);
        else
        {
          lines->push_back(string(next, end-next));
          incomplete_line = true;
        }
        
        break;
      }
      else
      {
         int line_fragment_length = eol - next + 1 ; // put the \n in the data
        
         if(incomplete_line)
         {
           lines->back().append(next, line_fragment_length);
           incomplete_line = false;
         }
         else
         {
          lines->push_back(string(next, line_fragment_length));
         }
        
         next = eol + 1; // skip the \n
        
         ++line_count;
      }
    }
  }

  return line_count;

}

bool
FileName::
is_absolute_path() const
{
  string::const_iterator first = begin();

  size_t len = size();

  if(len < 1)
    return false;

  if( first[0] == '/' || first[0] == '\\')
    return true;

  if(len < 3)
    return false;

  return first[1] == ':' && (first[2] == '\\' || first[2] == '/');

}

bool
FileName::
is_root_dir() const
{
  string::const_iterator first = begin();

  size_t len = size();

  if(   len == 1 
     && (*first == '/' || *first == '\\') 
    )
  {
     return true;
  }

  if(   len == 3
     && operator[](1) == ':'
     && (   operator[](2) == '/'
         || operator[](2) == '\\'
        )
    )
  {
     return true;  // windows top dir
  }



  return false;



}


string
FileName::
shorten(int length) const
{
  size_t s = size();

  // if source is small enough, just return it

  if( s <= (size_t) length )
    return *this;

  // ok, its too big -- shorten it.

  string me = *this;

  if(length < 5)
  {
     me.erase(0, me.size() - length); // not enough room to beautify shortened
                                      // version, just return short version as is
     return me;
  }

  // shorten the return value to the desired size and include elipsis
  // to beautify (so to speak) the plug taken out

  length -= 3;  // the elipses

  static string elipsis("...");

  size_t excess = s - length;

  size_t start = s - excess;  start /= 2;

  me.erase(start, excess);

  me.insert(start, elipsis);

  return me;

}


string
FileName::
read_lines(FileName::accumulate_lines& accum, size_t* line_count_ptr, bool removeCR)
{
  bool incomplete_line=false;

  size_t line_count=0;

  if(line_count_ptr) *line_count_ptr = 0;

  int fh = open(c_str(), O_RDONLY);  // on dos this is not binary!

  if(fh < 0)
    return string(strerror(errno));

  int partial_lines=0;

  for(;;)
  {
    char buffer[32768];

    int bytes_read = read(fh, buffer, sizeof(buffer));

    if(bytes_read < 1)
    {
      if(bytes_read == 0)
        break;
        
      string rv(strerror(errno));

      close(fh);

      return rv;
    }

    char const *next = buffer;
    char const *end  = buffer + bytes_read;

    while(next < end)
    {
      char * eol = (char*)memchr(next, '\n', end - next);

      if(eol == 0)
      {
        // no complete line exists, put the rest of the
        // next in a partial line
        
        ++partial_lines;

        if(incomplete_line)
          accum.back().append(next, end - next);
        else
        {
          accum.push_back(string(next, end-next));
          incomplete_line = true;
        }
        
        break;
      }
      else
      {
         int line_fragment_length = eol - next;

         bool hasRemovedCR = false;

         if(   removeCR 
            && line_fragment_length >= 1
            && eol[-1] == '\r'
           )
         {
             hasRemovedCR = true;
             --line_fragment_length;
         }

        
         if(incomplete_line)
         {
           accum.back().append(next, line_fragment_length);
           incomplete_line = false;
         }
         else
         {
           accum.push_back(string(next, line_fragment_length));
         }

         if(hasRemovedCR)
         {
           accum.setBackHasCR(true);  // tell the accumulator that 
                                      // we have removed a trailing
                                      // CR -- presumably only on unix/linux
                                      // because on windows we will never
                                      // see \r at the end of the line because
                                      // the read() call removes them.
         }

        
         next = eol + 1; // skip the \n
        
         ++line_count;
      }
    }
  }

  if(close(fh) < 0)
  {
     return strerror(errno);
  }

  if(line_count_ptr) *line_count_ptr = line_count;


  return string();
}

FileName
FileName::
getcwd()
{
  char buffer[2048];

  if(::getcwd(buffer, sizeof(buffer)) == 0)
  {
    return ".";
  }

  return buffer;
}

bool
FileName::
write(string const &file_contents, bool binary_mode)
{
   return write(file_contents.data(),
                file_contents.data() + file_contents.size(),
                binary_mode
               );
}

bool
FileName::
write(char const* begin, char const* end, bool binary_mode)
{
  size_t bytes = (end - begin);

  FILE * f = fopen(c_str(), binary_mode ? "wb" : "w");

  if(!f)
    return true;

  if(1 != fwrite(begin, bytes, 1, f))
    return true;

  if(fflush(f))
    return true;

  fclose(f);

  return false;
}


std::auto_ptr<FileName::Tree>
FileName::
tree_helper(string const &path_string, bool only_dirs, int depth) const
  //
  //  Tree helper is invoked with two pathnames.  '*this' is a pathname
  //  that will be given to the tree node returned.  The 'parent' refers
  //  to the 'real' physical pathname referred to by *this.  Note that they
  //  may not be the same.  parent may include more of the path.  For example,
  //  suppose we are in the middle of a deep recursive directory, *this, will
  //  refer to the current node, whose children we will discover, but parent
  //  will refer to the full pathname to this point.
  //
{
  Tree* tree = new Tree;
  
  tree->name_ = *this;
  tree->depth_ = depth;

  FileName path(path_string);

  path.file_stat(&tree->status_);

  if(tree->status_.mode.is_dir())
  {
     // read the subtree and append it to tree

     sorted_names_t children;

     FileName child_pattern(path);  child_pattern.convertToDirectorySearchPattern();

     find_matching(child_pattern, &children);

     sorted_names_t::iterator f=children.begin(), l=children.end();

     FileName me(".");
     FileName mommy("..");

     while(f != l)
     {
       FileName const& curname = *f++;

       if( (curname[0] == '.') && (curname == me || curname == mommy) )
       {
         continue;
       }

       FileName child(path);  
       
       if(child == ".")
         child = "";
       else
       if(child[child.size()-1] != '/')
         child += "/"; 
         
       child += curname;

       FileStatus status;

       if(only_dirs)
          child.file_stat(&status);

       std::auto_ptr<Tree> tmp(0);

       if(!only_dirs || status.mode.is_dir())
       {
         tmp.reset(curname.tree_helper(child, only_dirs, depth+1).release());

         tmp->parent_ = tree;

         tree->add_child(tmp.release());
       }

     }
  }

  return std::auto_ptr<Tree>(tree);
}

std::auto_ptr<FileName::Tree>
FileName::
tree(bool only_dirs) const
{
  return tree_helper(*this, only_dirs);
}

FileName::Tree::
~Tree()
{
  children_t::iterator f =children_.begin(), l = children_.end();

  while(f != l)
  {
    delete *f++;
  }
}

FileName::Tree::
Tree(Tree const &r)
: status_(r.status_),
  name_(r.name_),
  parent_(r.parent_),
  depth_(r.depth_)
{
  children_t::iterator f =children_.begin(), l = children_.end();

  while(f != l)
  {
    Tree* t = *f++;
    children_.push_back( new Tree(*t) );
  }
  
}


void 
FileName::Tree::
remove_child(FileName const &name)
{
  children_t::iterator f =children_.begin(), l = children_.end();

  while(f != l)
  {
    Tree* cur = *f;

    if(cur->name_ == name)
    {
      delete cur;

      children_.erase(f);
      return;
    }
    ++f;
  }

}

FileName
FileName::Tree::
path() const
{
  FileName rv = name();

  Tree const* scan = this;

  while(scan->parent_)
  {
    string pname = scan->parent_->name();

    char c=' ';

    if(pname.size())
      c = pname[ pname.size() -1 ];

    if(c != '/')
      rv.insert(0, "/");

    rv.insert(0, pname);
    scan = scan->parent_;
  }

  return rv;

}

using namespace std;                         

static set<string> tilde_cache;

static string gethomepath()
{
  {
    char const *home = getenv("HOME");

#ifdef _MSC_VER
    // ignore HOME variable on nt
    {
      char const *homepathp= getenv("HOMEPATH");

      string homepath;

      if(homepathp)
      {
        homepath = homepathp;
        
        char const *homedrive= getenv("HOMEDRIVE");

        if(homedrive)
        {
          char buffer[1024];

          sprintf(buffer, "%s%s", homedrive, homepath.c_str());

          set<string>::iterator f = tilde_cache.find(buffer);

          if(f == tilde_cache.end())
          {
            tilde_cache.insert(buffer);
            f = tilde_cache.find(buffer);
          }

          return f->c_str();

        }
        else
          return homepath;
      }
    }
#endif

    if(home == 0)
      home=".";

    return home;
  }
}


FileName
FileName::
expand_tildes() const
{
  if(size() < 1 ||  *begin() != '~')
    return *this;

  // at this point, we know that the first character of the current filename
  // is '~'.

  FileName const &me = *this;

  if(size() == 1 )
  {
    return gethomepath();
  }
  else
  {
    // size() > 1


    if(me[1] == '/' || me[1] == '\\')
    {
      // home directory relative path

      string home = gethomepath();

      FileName prefix;
      FileName homevalue;

      homevalue = home;

      homevalue += me.substr(1,me.size());

      return homevalue; 
      
    }
    else
    {
      // random user home directorty relative path

      string user;

      size_t i;

      for(i=1; i < me.size(); ++i)
      {
        char c = me[i];

        if(c == '/' || c == '\\')
          break;
        else
          user += c;
      }

      string rest = me.substr(i, me.size());

#ifdef _MSC_VER

      {
        FileName homepath = gethomepath();
        FileName parent = homepath.dirname();

        return parent + user + rest;
      }

#else
      UserInfo ui = UserInfo::get(user);
      return ui.home_dir_ + rest;
#endif



    }
  }

  return *this;

}

void
FileName::
convertToDirectorySearchPattern(char const *pattern)
{
  if(size() == 0)
    *this = pattern;
  else
  {
    char lastChar = (*this)[size()-1];

    if(lastChar == '/' || lastChar == '\\' || is_dir())
    {
      if(lastChar != '/' && lastChar != '\\')
        (*this) += '/';

      *this += pattern;
    }

  }
}


FileName
FileName::
readlink(int *mode) const
{
#ifdef _MSC_VER
   return ""; 
#else
   
   char const *p = this->c_str();

   char buffer[3000];


   ssize_t rv = ::readlink(p, buffer, sizeof(buffer));

   if(rv < 1)
      return "";

   if(rv == sizeof(buffer))
   {
      // name truncation is almost guaranteed.

      return "";  

   }

   buffer[rv]=0;

   FileName tmp(buffer);

   tmp.convert_to_absolute_path();

   if(mode)
   {
       struct stat buf;
       
       if(lstat(p, &buf))
       {
           *mode=0;
       }
       else
       {
          *mode = buf.st_mode;
       }
   }

   return tmp;
#endif

}




void
FileMode::
unpackPermissions(string &user, string &group, string &world)
{
  //
  //  turn the file mode into 3 strings -- each of which represents the file permissions.  One each for the
  //  user, group, and world permissions.
  //

  user="";
  group="";
  world="";

  if(mode & user_readable)    user  += 'r';
  if(mode & user_writeable)   user  += 'w';
  if(mode & user_executable)  user  += 'x';

  if(mode & group_readable)   group += 'r';
  if(mode & group_writeable)  group += 'w';
  if(mode & group_executable) group += 'x';

  if(mode & world_readable)   world += 'r';
  if(mode & world_writeable)  world += 'w';
  if(mode & world_executable) world += 'x';
  
}


static int unpackPermString(string const &s, int readable, int writeable, int executable)
{
  // this function takes a string of the form rwx and returns an integer which is an "oring" of the
  // specified readable, writeable, and executable bits passed in.  

  string::const_iterator begin = s.begin(), end = s.end();

  int rv = 0;

  while(begin != end)
  {
    char c = *begin++;

    switch(c)
    {
      case 'r':
      case 'R':
        rv |= readable;
        break;

      case 'w':
      case 'W':
        rv |= writeable;
        break;

      case 'x':
      case 'X':
        rv |= executable;
        break;
    }

  }

  return rv;

}

void
FileMode::
packPermissions(string const &user, string const &group, string const &world)
{
  int userMode  = unpackPermString(user,  user_readable,  user_writeable,  user_executable);
  int groupMode = unpackPermString(group, group_readable, group_writeable, group_executable);
  int worldMode = unpackPermString(world, world_readable, world_writeable, world_executable);

  mode &= ~(
              user_readable    |
              user_writeable   | 
              user_executable  |
              group_readable   |
              group_writeable  | 
              group_executable |
              world_readable   |
              world_writeable  | 
              world_executable 
           );

  mode |= userMode | groupMode | worldMode;


}


bool
FileMode::
permStringValid(string const &s)
{

  int rcount = 0;
  int wcount = 0;
  int xcount = 0;

  string::const_iterator begin = s.begin(), end = s.end();

  while(begin != end)
  {
    char c = *begin++;

    switch(c)
    {
      case 'r':
      case 'R':
        ++rcount;
        if(rcount > 1)
          return false;
        break;

      case 'w':
      case 'W':
        ++wcount;
        if(wcount > 1)
          return false;
        break;

      case 'x':
      case 'X':
        ++xcount;
        if(xcount > 1)
          return false;
        break;

      default:
        return false;
        break;

    }

  }

  return true;
}

} // namespace cxxtls