path.cpp

Go to the documentation of this file.

 
#ifndef _WIN32
#  ifdef __linux__
     // for symlink()
#    ifndef _XOPEN_SOURCE
#      define _XOPEN_SOURCE
#    endif
#    ifndef _XOPEN_SOURCE_EXTENDED
#      define _XOPEN_SOURCE_EXTENDED
#    endif
#  endif   // __linux__
 
#  include <unistd.h>      // for getcwd()
#  include <sys/stat.h>    // for struct stat, stat()
#else
#  include <direct.h>      // for struct _stat
#  include <io.h>
#  include <windows.h>     // for _getcwd()
#  include <sys/types.h>
#  include <sys/stat.h>    // for struct stat, stat()
#endif  // _WIN32
 
 
#include "path.h"
 
#include "diagnostic.h"   // for issue_diag()
 
#include <cassert>        // for assert()
#include <cerrno>         // for ERANGE
#include <cstdlib>        // for getenv()
#include <cstring>        // for strerror()
#include <string>         // for string
 
 
static char* get_cwd (char* s, std::size_t l)
{
#if !defined (_MSC_VER)
    return getcwd (s, l);
#else
    return _getcwd (s, l);
#endif
}
 
 
#if !defined (_WIN32) && !defined (__CYGWIN__)
 
void
create_symlink (const std::string &dir, 
                const std::string &xname, 
                const std::string &sname)
{
    int   ret  = 0;
    char* pret = 0;
    char  buf [1024];
 
    if (dir.size ()) {
        pret = get_cwd (buf, 1024);
        if (pret == 0) {
            issue_diag (213, true, 0, 
                        "could not retrieve current working directory\n") ;
        }
    
        ret = chdir (dir.c_str ());
        if (ret == -1)
            issue_diag (214, false, 0, "could not change directory to %s\n", 
                        dir.c_str ()) ;
    }
 
    ret = symlink(xname.c_str(), sname.c_str());
 
#ifdef EEXIST
 
    if (ret == -1 && errno != EEXIST) {
        issue_diag (215, false, 0,
                    "could not create symbolic link to %s "
                    "locale database (%s)\n", 
                    xname.c_str (), std::strerror (errno)) ;
    }
 
#endif   // EEXIST
 
    // go back to previous wd
    if (dir.size ()) {
        chdir (pret);
    }
}
 
#endif  // !_WIN32 && !__CYGWIN__
 
 
inline int
filemode (const char *path)
{
    assert (0 != path);
 
    struct stat buf;
    return stat (path, &buf) ? 0 : buf.st_mode;
}
 
 
std::string
get_pathname (const std::string &fname,
              const std::string &other /* = std::string () */)
{
    // use absolute path as given by fname
#if !defined (_WIN32)
    if (fname.size () && _RWSTD_PATH_SEP == fname [0]) 
#else
    if (fname.size () && 
        fname [1] && fname [1] == ':' && 
        fname [2] && fname [2] == _RWSTD_PATH_SEP) 
#endif
        return fname;
 
    std::string pathname;
    std::string dir_other (
        other.substr (0,other.rfind (_RWSTD_PATH_SEP) + 1));
 
    // OR use the path given through "other", be it relative or absolute
#if !defined (_WIN32)
    if (other.size () && _RWSTD_PATH_SEP == other [0]) {
#else
    if (other.size () && 
        other [1] && other [1] == ':' && 
        other [2] && other [2] == _RWSTD_PATH_SEP) {
#endif
        // other is an absolute path; compose dirname(other) + fname
        (pathname += dir_other) += fname;
 
    } else {
        pathname.resize (1024);
 
        // other is a relative path; compose cwd() + dirname(other) + fname
        while (!get_cwd (&pathname [0], pathname.size ())) {
            if (ERANGE != errno) {
                issue_diag (213, true, 0, 
                            "could not retrieve current working directory\n");
                return fname;
            }
            // buffer too small, reallocate
            pathname.resize (pathname.size () * 2);
        }
        
        pathname.resize (std::strlen (pathname.data ()));
 
        if (pathname.size() && 
            pathname [pathname.size () - 1] != _RWSTD_PATH_SEP)
            pathname += _RWSTD_PATH_SEP;
 
        (pathname += dir_other) += fname;
    }
 
#if !defined (_MSC_VER)
    if (S_ISREG (filemode (pathname.c_str ())))
#else
    if (S_IFREG & filemode (pathname.c_str ()))
#endif // !defined (_MSC_VER)
        return pathname;
 
 
    // use the value of RWSTD_SRC_ROOT
    const char* const src_root = std::getenv ("RWSTD_SRC_ROOT");
    if (src_root && *src_root) {
        // if the environment variable is not empty, append `fname'
        // to it and see if the file exists and names a regular file
        // if so, return its pathname
        pathname = src_root;
        (((pathname += _RWSTD_PATH_SEP) += "src") += _RWSTD_PATH_SEP) += fname;
 
#if !defined (_MSC_VER)
                if (S_ISREG (filemode (pathname.c_str ())))
#else
                if (S_IFREG & filemode (pathname.c_str ()))
#endif // !defined (_MSC_VER)
            return pathname;
    }
 
    // allocate a sufficiently large buffer for the cwd
    pathname.resize (1024);
 
    // use current working directory
    while (!get_cwd (&pathname [0], pathname.size ())) {
 
        if (ERANGE != errno) {
            issue_diag (213, true, 0, 
                        "could not retrieve current working directory\n");
            return fname;
        }
 
        // buffer too small, reallocate
        pathname.resize (pathname.size () * 2);
    }
 
    // chop off everything past the terminating NUL
    pathname.resize (std::strlen (pathname.data ()));
    pathname += fname;
 
#if !defined (_MSC_VER)
    if (S_ISREG (filemode (pathname.c_str ())))
#else
    if (S_IFREG & filemode (pathname.c_str ()))
#endif // !defined (_MSC_VER)
        return pathname;
 
    return fname;
}
 
 
int makedir (const char *name)
{
#ifdef _WIN32
 
   if (   0 == CreateDirectory (name, NULL)
        && GetLastError () != ERROR_ALREADY_EXISTS) {
 
        LPVOID lpMsgBuf;
 
        FormatMessage (  FORMAT_MESSAGE_ALLOCATE_BUFFER
                       | FORMAT_MESSAGE_FROM_SYSTEM
                       | FORMAT_MESSAGE_IGNORE_INSERTS,
                       0,
                       GetLastError (),
                       MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                       (LPTSTR)&lpMsgBuf,
                       0,
                       0);
 
        issue_diag (E_CALL, true, 0, (char*)lpMsgBuf);
 
        return -1;
    }
    
#else   // ifndef _WIN32
 
   if (-1 == mkdir (name, 0755)) {
 
#  ifdef EEXIST
 
       if (errno != EEXIST) {
           issue_diag (E_CALL, true, 0, "failed to create directory %s: %s\n",
                       name, std::strerror (errno));
 
           return -1;
       }
 
#  endif   // EEXIST 
 
   }
 
#endif   // _WIN32
 
    return 0;
}