file.cpp

Go to the documentation of this file.

/*
 * file.cpp
 *
 * Copyright (C) 2003-2010  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Helpful file/filename utilities.  See file.h
 */

// includes --------------------------------------------------------------------
#include "file.h"       // always include our own header first
#include "common/wave_ex.h"

#include <ctype.h>
#include <sstream>



static const char s_separator =
#ifdef WIN32
        '/';
//      '\\';
#else
        '/';
#endif  // WIN32


////////////////////////////////////////////////////////////////////////////////
//
//      Public APIs
//
////////////////////////////////////////////////////////////////////////////////

const char *
GetExtension
(
IN const char * filename
)
throw()
{
        const char * p = filename;
        if (!p)
                return p;

        // go to end of string
        while (*p) {
                p++;
        }

        // back up until we hit a period
        while (*p != '.' && p > filename) {
                p--;
        }

        if (*p == '.') {
                return p + 1;
        }

        ASSERT(p == filename, "Should be at beginning of string");
        return NULL;
}



bool
hasExtension
(
IN const char * filename,
IN const char * extension
)
throw()
{
        ASSERT(filename, "null");
        ASSERT(extension, "null");

        const char * ext = GetExtension(filename);
        if (!ext)
                return false;   // no extension in filename

        return !strcasecmp(ext, extension);
}



void
GetFileRoot
(
IN const char * filename,
OUT std::string& root_name
)
{
        ASSERT(filename, "NULL filename");

        const char * start = NULL;
        const char * end = NULL;
        const char * p = filename;

        // go to the end of the string
        while (*p) {
                p++;
        }

        // back up, looking for slash or dot
        while (!start) {
                p--;
                if (p < filename)
                        start = filename;

                if (!end && '.' == *p)
                        end = p;
                else if (s_separator == *p)
                        start = p + 1;
        }

        ASSERT(start, "never found a root filename: %s", filename);

        // if end!=null, it points to the last period
        // if start!=null, it points to the first root filename character

        root_name = "";
        while (*start && start != end) {
                root_name += *start;
                ++start;
        }
}


void
GetParentDirectory
(
IN const char * filename,
OUT std::string& directory
)
throw()
{
        ASSERT(filename, "NULL filename");
        ASSERT(*filename, "empty file");
        directory.clear();

        const char * p = filename;

        // go to end
        while (*p) {
                p++;
        }

        // back up, look for first separator
        while (p > filename && *p != s_separator) {
                --p;
        }

        if (s_separator != *p) {
                // no separators at all!
                return;
        }

        if (p == filename) {
                // this is the root!
                directory = s_separator;
                return;
        }

        // have an interesting parent path (not root or empty)
        while (filename < p) {
                directory += *filename;
                filename++;
        }
}



const char *
getTopDirectory
(
IN const char * filename,
OUT std::string& topDir
)
{
        ASSERT(filename, "null");
        topDir.clear();

        // look for first slash
        const char * p = filename;
        while (*p && *p != s_separator) {
                topDir += *p;
                ++p;

        }
        if (!*p) {
                // no slashes!
                topDir.clear();
                return filename;
        }

        return p + 1;
}



const char *
GetFilename
(
IN const char * path
)
throw()
{
        const char * p = path;

        ASSERT(path, "NULL path");
        ASSERT(*path, "empty path");

        // go to end
        while (*p) {
                p++;
        }

        // back up to first separator
        while (p > path && *p != s_separator) {
                --p;
        }

        // walk forward if on separator
        if (s_separator == *p)
                p++;

        // this is it
        return p;
}



void
getTempfile
(
IN const char * filename,
OUT std::string& tempfile
)
throw()
{
        ASSERT(filename, "null");

        // get the directory
        std::string directory;
        GetParentDirectory(filename, directory);

        int x = rand() % 10000;

        // convoluted casting to get a process ID
        // note that this is broken!  For all I know, the
        // first 4 bytes of a pthread aren't unique at all!
        dword_t thread_id =
#ifdef WIN32
                GetCurrentThreadId();
#else   // WIN32
                pthread_self();
#endif  // WIN32
        long pid = *(long *)(&thread_id);

        // create a temp filename (prepend a tilde, append process ID, random x, and .tmp)
        std::ostringstream temp;
        temp << directory << "~" << GetFilename(filename);
        temp << "." << pid << "-" << x << ".tmp";
        tempfile = temp.str();

        // DPRINTF("tempfile: %s", tempfile.c_str());
}



void
getUserHomePath
(
OUT std::string& path
)
{
#ifdef WIN32
        path = "c:/Users/";
#else   // WIN32
        // initialize
        path = "/home/";

        // attempt to determine username
        const char * login = getenv("LOGNAME"); // prefer environment variable
        if (!login)
                login = getlogin();             // fallback is controlling terminal

        // if we have a username, append it
        if (login)
                path += login;
#endif  // WIN32
}



bool
ContainsWhitespace
(
IN const char * test
)
throw()
{
        if (!test)
                return false;   // edge case

        const char * p = test;
        while (*p) {
                if (isspace(*p))
                        return true;
                ++p;
        }
        return false;
}



/*
error_t
appendLogfile
(
IN const char * filename,
IN const char * logline
)
throw()
{
        ASSERT(filename, "NULL filename");
        ASSERT(logline, "NULL logline");

        FILE * file = fopen(filename, "a+");
        if (!file) {
                error_t error = errno;
                DPRINTF("Failed to open logfile %s : %d (%s)", filename,
                    error, strerror(error));
                return error;
        }
        fprintf(file, "%s\n", logline);
        fclose(file);
        return 0;
}
*/


#ifdef WIN32
#include <sys/stat.h>
#define stat(path, ptr) _stat(path, ptr)
typedef struct _stat stat_t;
#else   // WIN32
typedef struct stat stat_t;
#endif  // WIN32


bool
doesPathExist
(
IN const char * path
)
throw()
{
        ASSERT(path, "null");

        stat_t buf;
        int retval = stat(path, &buf);
        //DPRINTF("stat('%s') = %d", path, retval);
        //DPRINTF("  st_dev = 0x%08lx", (dword_t) buf.st_dev);
        //DPRINTF("  st_ino = 0x%08lx", (dword_t) buf.st_ino);
        if (-1 == retval) {
                return false;           // does not exist!
        }
        return true;
}



void
createEmptyFileIfDoesNotExist
(
IN const char * path
)
throw()
{
        ASSERT(path, "null");

        if (doesPathExist(path))
                return;         // nothing to do!
        // does not exist, create it
        //DPRINTF("Attempting to create empty file '%s'", path);
        std::string cmd = "/bin/touch ";
        cmd += path;
        system(cmd.c_str());
}



bool
matchesExtension
(
IN const char * filename,
IN const char * extension
)
throw()
{
        ASSERT(filename, "null");
        // ASSERT(extension) -- can be null!

        if (!extension)
                return true;    // NULL extension means "match everything"

        // do last characters of filename match extension?
        int extLen = strlen(extension);
        int fileLen = strlen(filename);

        int delta = fileLen - extLen;
        if (delta <= 0)
                return false;   // filename is too short!

        const char * fileExt = filename + delta;
        return !strcasecmp(fileExt, extension);
}



void
walkDirectoryTree
(
IN const char * rootDir,
IN const char * matchExt,
OUT VecString& paths
)
{
        ASSERT(rootDir, "null");
        // ASSERT(matchExt) -- can be null!
        paths.clear();

        DPRINTF("Walking directory: %s", rootDir);

        SetString all;

        // first walk directory, save files, and remember directories
        DIR * dir = opendir(rootDir);
        THROW(dir , "Failed to open directory: " << rootDir);
        while (true) {
                dirent * entry = readdir(dir);
                if (!entry) {
                        DPRINTF("  end of directory!");
                        break;
                }
                if ('.' == entry->d_name[0]) {
                        continue;       // skip all paths beginning with '.'
                }
                all.insert(entry->d_name);
        }
        closedir(dir);

        // now walk everything (in lexigraphical order) and investigate
        VecString children;
        for (SetString::iterator i = all.begin(); i != all.end(); ++i) {
                const char * name = i->c_str();

                std::string full_path = rootDir;
                full_path += s_separator;
                full_path += name;

                DPRINTF("  Examining %s", full_path.c_str());

                // is this a directory?
                stat_t sb;
                if (!stat(full_path.c_str(), &sb)) {
                        if (S_IFDIR & sb.st_mode) {
                                // this is a directory!
                                children.push_back(name);
                        } else if (matchesExtension(name, matchExt)) {
                                // this is a file
                                DPRINTF("    File!  %s", name);
                                paths.push_back(name);
                        }
                }
        }

        // now walk all child directories
        for (VecString::const_iterator i = children.begin();
             i != children.end(); ++i) {
                const char * name = i->c_str();

                std::string newRoot = rootDir;
                newRoot += s_separator;
                newRoot += name;

                VecString subEntries;
                walkDirectoryTree(newRoot.c_str(), matchExt, subEntries);

                // update subEntries
                for (VecString::const_iterator j = subEntries.begin();
                     j != subEntries.end(); ++j) {
                        const char * subName = j->c_str();

                        std::string relPath = name;
                        relPath += s_separator;
                        relPath += subName;

                        DPRINTF("  Adding sub-entry: %s", relPath.c_str());
                        paths.push_back(relPath.c_str());
                }
        }
}



std::string
getPathRelativeTo
(
IN const char * startFile,
IN const char * relPath
)
{
        ASSERT(startFile, "null");
        ASSERT(relPath, "null");

        std::string path;
        if (*startFile) {
                GetParentDirectory(startFile, path);
        }
        if (path.length() > 0) {
                path += s_separator;
        }
        path += relPath;

        return path;
}



void
appendPath
(
IN const char * parentDirectory,
IN const char * nextPath,
OUT std::string& path
)
{
        ASSERT(parentDirectory, "null");
        ASSERT(nextPath, "null");

        path = parentDirectory;

        // only append if necessary!
        int len = strlen(parentDirectory);
        if (len > 0 &&
            s_separator != parentDirectory[len - 1] &&
            nextPath[0] &&
            s_separator != nextPath[0]) {
                path += s_separator;
        }
        path += nextPath;
}



#ifdef WIN32

DIR *
opendir
(
IN const char * path
)
{
        ASSERT(path, "null");

        DIR * pdir = new DIR;
        ASSERT(pdir, "out of memory");
        pdir->path = path;
        ASSERT(!pdir->h, "should be null");

        return pdir;
}



struct dirent *
readdir
(
IO DIR * dir
)
{
        ASSERT(dir, "null");

        // DPRINTF("calling readdir()...");
        static dirent s_d;
        WIN32_FIND_DATA wfd;
        if (!dir->h) {
                // no handle yet!  find first file
                std::string search = dir->path;
                search += "\\*";        // wildcard
                dir->h = FindFirstFile(search.c_str(), &wfd);
                if (INVALID_HANDLE_VALUE == dir->h ||
                    ERROR_FILE_NOT_FOUND == (long) dir->h) {
                        DPRINTF("Failed to find first file: %s",
                            search.c_str());
                        return NULL;
                }
                strncpy(s_d.d_name, wfd.cFileName, MAX_PATH);
                return &s_d;
        } else {
                // have a handle!  find next file
                int retval = FindNextFile(dir->h, &wfd);
                if (!retval || ERROR_NO_MORE_FILES == retval) {
                        return NULL;
                }
                strncpy(s_d.d_name, wfd.cFileName, MAX_PATH);
                return &s_d;
        }
}



int
closedir
(
IN DIR * dir
)
{
        ASSERT(dir, "null");

        if (dir->h) {
                FindClose(dir->h);
        }
        delete dir;
        return 0;
}



#endif  // WIN32