dir.c

Go to the documentation of this file.

#ifndef CTL_UNIT

#include "ctl/ctldef.h"
#include "ctl/dir.h"
#ifdef WIN32
#include <Windows.h>
#include <io.h>
#include <fcntl.h>
#else
#include <unistd.h>
#include <fcntl.h>
#include <dirent.h>
#include <sys/stat.h>
#endif
#include <stdio.h>

#ifndef _MAX_PATH
#define _MAX_PATH 256
#endif

#ifndef O_BINARY
#define O_BINARY 0
#endif

char* ctl_cwd( char* buffer, size_t cMax )
{
    char* result;
    assertptr(buffer,cMax);
#ifdef WIN32
    GetCurrentDirectory( (DWORD)cMax, buffer );
#else
    result = getcwd( buffer, cMax );
#endif
    if( NULL != result )
    {
        char* p = ctl_eattrailingslash( buffer );
#ifdef WIN32
        if( (size_t)(p - buffer) < cMax )
            *p++ = '\\';
#else
        if( (size_t)(p - buffer) < cMax )
            *p++ = '/';
#endif
        if( (size_t)(p - buffer) < cMax )
            *p = 0;
    }
    return result;
}


bool ctl_chdir( const char* path )
{
    assertconst(path,1);
#ifdef WIN32
    return (bool)SetCurrentDirectory(path);
#else
    return (bool)(0 != chdir(path));
#endif
}


void ctl_move( const char* src, const char* dst )
{
    assertconst(src,1);
    assertconst(dst,1);
#ifdef WIN32
    MoveFileEx( src, dst, MOVEFILE_COPY_ALLOWED|MOVEFILE_REPLACE_EXISTING );
#else
    rename( src, dst );
#endif
}


void ctl_copy( const char* src, const char* dst )
{
    assertconst(src,1);
    assertconst(dst,1);
#ifdef WIN32
    CopyFile( src, dst, FALSE );
#else
    int srcfd = open ( src, O_RDONLY|O_BINARY );
    if (srcfd >= 0)
    {
        int destfd = open( dst, O_CREAT|O_TRUNC|O_RDWR|O_BINARY, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH );
        if (destfd >= 0)
        {
            char buff[32768];
            ssize_t nread = read(srcfd, buff, sizeof (buff));
            ssize_t nwrote;
            while (nread > 0)
            {
                nwrote = write(destfd, buff, nread);
                if( nwrote != nread )
                    break;
                nread = read(srcfd, buff, sizeof (buff));
            }
            close(destfd);
        }
        close(srcfd);
    }
#endif
}


void ctl_unlink( const char* path )
{
    assertconst(path,1);
#ifdef WIN32
    DeleteFile( path );
#else
    unlink( path );
#endif
}


void ctl_rmdir( const char* path )
{
    assertconst(path,1);
#ifdef WIN32
    RemoveDirectory(path);
#else
    rmdir(path);
#endif
}


void ctl_mkdir( const char* path )
{
    assertconst(path,1);
#ifdef WIN32
    CreateDirectory(path,NULL);
#else
    /* Let this user and his whole group play with it (assuming umask permits it) */
    mkdir( path, S_IRWXU | S_IRWXG );
#endif
}


void ctl_iterate( const char* path, const char* szmatch, ctl_dircallback callback, void* instance )
{
#ifdef WIN32
    WIN32_FIND_DATA FileData;
    char szPath[_MAX_PATH];
    HANDLE hFind;
    assertconst(path,1);
    assertconst(szmatch,1);
    assertcodeptr(callback);
    strncpy( szPath, path, _MAX_PATH );
    ctl_eattrailingslash( szPath );
    if( !*szPath )
        strcat( szPath, "." );
    strncat( szPath, "/*.*", _MAX_PATH );
    szPath[_MAX_PATH-1] = 0;
    hFind = FindFirstFile( szPath, &FileData );
    if ( INVALID_HANDLE_VALUE != hFind )
    {
        do
        {
            if( *FileData.cFileName != '.' && (!szmatch || strwild( FileData.cFileName, sizeof FileData.cFileName, szmatch )) )
            {
                char szCBPath[_MAX_PATH];
                strncpy( szCBPath, path, countof(szCBPath) );
                if( *szCBPath )
                {
                    ctl_eattrailingslash( szCBPath );
                    strncat( szCBPath, "/", countof(szCBPath) );
                }
                strncat( szCBPath, FileData.cFileName, countof(szCBPath) );
                if ( (FileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)  )
                {
                    if ( callback( szCBPath, true, instance ) )
                        break;
                }
                else
                {
                    if ( 0 != (FileData.dwFileAttributes & (FILE_ATTRIBUTE_NORMAL|FILE_ATTRIBUTE_ARCHIVE)) && callback( szCBPath, 0 != (FileData.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY), instance ) )
                        break;
                }
            }
        }
        while ( FindNextFile( hFind, &FileData ) );
        FindClose( hFind );
    }
#else
    DIR* dir;
    assertconst(path,1);
    assertconst(szmatch,1);
    assertcodeptr(callback);
    dir = opendir( path );
    if ( dir )
    {
        struct dirent* dp;
        while ( NULL != (dp = readdir(dir) ) )
        {
            if ( *dp->d_name != '.' && (!szmatch || strwild( dp->d_name, sizeof dp->d_name, szmatch )) )
            {
                char szCBPath[256];
                struct stat status;
                strncpy( szCBPath, path, countof(szCBPath) );
                ctl_eattrailingslash( szCBPath );
                strncat( szCBPath, "/", countof(szCBPath) );
                strncat( szCBPath, dp->d_name, countof(szCBPath)-1 );
                stat( szCBPath, &status );
                if ( S_ISDIR(status.st_mode) )
                {
                    if ( callback( szCBPath, true, instance ) )
                        break;
                }
                else
                {
                    if ( S_ISREG(status.st_mode) && callback( szCBPath, false, instance ) )
                        break;
                }
            }
        }
        closedir(dir);
    }
#endif
}

void ctl_iterate_path( const char* path, ctl_dircallback callback, void* instance )
{
    char szPath[256];
    const char* fileMatch;
    size_t len;
    assertconst(path,1);
    assertcodeptr(callback);
    fileMatch = ctl_filename( path );
    len = fileMatch - path;
    memcpy( szPath, path, len );
    szPath[len] = 0;
    ctl_iterate( szPath, fileMatch, callback, instance );
}


void ctl_fullpath( const char* basePath, const char* relPath, char* buff, size_t length )
{
    assertconst( basePath, 1 );
    assertconst( relPath, 1 );
    assertptr( buff, length );
    assert( length <= _MAX_PATH );
    {
        size_t baseLength = strlen( basePath );
        size_t relLength = strlen( relPath );
        size_t totalLength = baseLength + relLength + 1;
        char lastBase;
        char firstRel = relPath[0];
        bool addSlash = false;

        /* To be linux compatible, use '/' for directories, not backslash - preferably throughout the code */
        assert( !strchr( basePath, '\\' ) && !strchr( relPath, '\\' ) );

        if( baseLength != 0 )
        {
            lastBase = basePath[baseLength-1]; 
            /* Determine what the final length will be and determine if a backslash must be added */
            if( lastBase == '/' && firstRel == '/' )
            {
                /*skip the leading '/' of relPath */
                totalLength--;
                relPath++;
            } 
            else if( lastBase != '/' && firstRel != '/' )
            {
                /*We will need to put a '/' between basePath and RelPath */
                addSlash = true;
                totalLength++;
            }
        }

        if( totalLength > length )
        {
            throwassert("Target buffer too small");
            *buff = 0;
        }
        else
        {
            /* Do the deed */
            memcpy( buff, basePath, baseLength );
            if( true == addSlash )
                buff[baseLength++] = '/';
            strcpy( buff+baseLength, relPath );
        }
    }
}

char* ctl_eattrailingslash( char* szPath )
{
    size_t len;
    assertptr( szPath, 1 );
    len = cstrlen(char)(szPath);
    if( 0 != len && ('/' == szPath[len-1] || '\\' == szPath[len-1]) )
    {
        char* ret = szPath + len-1;
        *ret = 0;
        return ret;
    }
    return szPath + len;
}

char* ctl_eatextension( char* szPath )
{
    char* found;
    assertptr(szPath,1);
    found = (char*)ctl_extension( szPath );
    *found = 0;
    return found;
}


char* ctl_eatfilename( char* szPath )
{
    char* found;
    assertptr(szPath,1);
    found = (char*)ctl_filename( szPath );
    *found = 0;
    return found;
}

const char* ctl_filename( const char* szPath )
{
    size_t len;
    assertconst(szPath,1);
    len = cstrlen(char)(szPath);
    if( len )
    {
        const char* p = szPath + len-1;
        while( p > szPath && *p != '/' && *p != '\\' )
            p--;
        if( *p == '/' || *p == '\\' )
            return p+1;
    }
    return szPath;
}

const char* ctl_extension( const char* szPath )
{
    size_t len;
    assertconst(szPath,1);
    len = cstrlen(char)(szPath);
    if( len )
    {
        const char* p = szPath + len-1;
        while( *p != '.' && p > szPath && *p != '/' && *p != '\\' )
            p--;
        if( *p == '.' )
            return p;
    }
    return szPath+len;
}

bool ctl_pathsearch( char* pathbuff, size_t buffmax, const char* searchpath, const char* filename )
{
    size_t filelen;
    assertptr( pathbuff, buffmax );
    assertconst( searchpath, 1 );
    assertconst( filename, 1 );
    filename = ctl_filename( filename );
    filelen = strlen(filename);
    while( *searchpath )
    {
        const char* scan = searchpath;
        while( *scan && *scan != ';' )
            ++scan;
        if( filelen + (scan-searchpath) < buffmax )
        {
            size_t pathlen = scan-searchpath;
            memcpy( pathbuff, searchpath, pathlen );
            if( pathbuff[pathlen-1] != '/' && pathbuff[pathlen-1] != '\\' )
            {
                pathbuff[pathlen++] = '/';
            }
            memcpy( pathbuff+pathlen, filename, filelen );
            pathbuff[pathlen+filelen] = 0;
#ifdef WIN32
            {
                int fd = _open ( pathbuff, O_RDONLY|O_BINARY );
                if( fd >= 0 )
                {
                    _close(fd);
                    return true;
                }
            }
#else
            {
                int fd = open ( pathbuff, O_RDONLY|O_BINARY );
                if( fd >= 0 )
                {
                    close(fd);
                    return true;
                }
            }
#endif
            if( *scan )
            {
                searchpath = scan + 1;
            }
            else
            {
                break;
            }
        }
    }
    *pathbuff = 0;
    return false;
}

bool strwild( const char* sz, size_t maxsz, const char* szmatch )
{
    const char* strend;
    assertconst( sz, 1 );
    assertconst( szmatch, 1 );
    strend = sz+cstrnlen(char)(sz,maxsz);
    while( *szmatch && sz < strend )
    {
        switch( *szmatch )
        {
        case chconst(char,'*'): /* Match any range of characters */
            ++szmatch;
            if( *szmatch )
            {
                const char* smatch = szmatch;
                size_t matchlen;
                {
                    /* Find length of current match */
                    const char* smatchend = smatch;
                    while( *smatchend && *smatchend != chconst(char,'?') && *smatchend != chconst(char,'*') )
                        smatchend++;
                    matchlen = smatchend - smatch;
                }
                /* Now scan string until we find match after '*' */
                while( sz + matchlen <= strend )
                {
                    if( !cstrncmp(char)( sz, smatch, matchlen ) )
                    {
                        sz += matchlen;
                        szmatch += matchlen;
                        break;
                    }
                    sz++;
                }
            }
            else
            {
                /* Ended with '*', so whatever's left of str 'matches' */
                return true;
            }
            break;
        case chconst(char,'?'): /* Match any single character */
            sz++;
            szmatch++;
            break;
        default:    /* Characters must match */
            if( *sz++ != *szmatch++ )
                return false;
            break;
        }
    }
    /* Should have reached the end of both */
    return sz == strend && !*szmatch;
}
bool wcswild( const wchar_t* sz, size_t maxsz, const wchar_t* szmatch )
{
    const wchar_t* strend;
    assertconst( sz, sizeof(wchar_t) );
    assertconst( szmatch, sizeof(wchar_t) );
    strend = sz+cstrnlen(wchar_t)(sz,maxsz);
    while( *szmatch && sz < strend )
    {
        switch( *szmatch )
        {
        case chconst(wchar_t,'*'):  /* Match any range of wchar_tacters */
            ++szmatch;
            if( *szmatch )
            {
                const wchar_t* smatch = szmatch;
                size_t matchlen;
                {
                    /* Find length of current match */
                    const wchar_t* smatchend = smatch;
                    while( *smatchend && *smatchend != chconst(wchar_t,'?') && *smatchend != chconst(wchar_t,'*') )
                        smatchend++;
                    matchlen = smatchend - smatch;
                }
                /* Now scan string until we find match after '*' */
                while( sz + matchlen <= strend )
                {
                    if( !cstrncmp(wchar_t)( sz, smatch, matchlen ) )
                    {
                        sz += matchlen;
                        szmatch += matchlen;
                        break;
                    }
                    sz++;
                }
            }
            else
            {
                /* Ended with '*', so whatever's left of str 'matches' */
                return true;
            }
            break;
        case chconst(wchar_t,'?'):  /* Match any single wchar_tacter */
            sz++;
            szmatch++;
            break;
        default:    /* Characters must match */
            if( *sz++ != *szmatch++ )
                return false;
            break;
        }
    }
    /* Should have reached the end of both */
    return sz == strend && !*szmatch;
}


#else /* CTL_UNIT */

#include "ctl/ctldef.h"
#include "ctl/ctlstring.h"
#include "unit/unit.h"
#include "dir.h"

void Test_Dir(void)
{
    const char* szPath = "/foo/bar/baz.c";
    const char* szPathW = "C:\\foo\\bar\\baz.c";
    /* Parse up unix-like path */
    Test_Error( !strcmp( ctl_filename( szPath ), "baz.c" ) );
    Test_Error( !strcmp( ctl_extension( szPath ), ".c" ) );
    /* Parse up windows-like path */
    Test_Error( !strcmp( ctl_filename( szPathW ), "baz.c" ) );
    Test_Error( !strcmp( ctl_extension( szPathW ), ".c" ) );
    {
        char buff[256];
        /* Parse up unix-like path */
        strcpy( buff, szPath );
        ctl_eatextension( buff );
        Test_Error( !strcmp( buff, "/foo/bar/baz" ) );;
        ctl_eatfilename( buff );
        Test_Error( !strcmp( buff, "/foo/bar/" ) );
        ctl_eattrailingslash( buff );
        Test_Error( !strcmp( buff, "/foo/bar" ) );
        /* Parse up windows-like path */
        strcpy( buff, szPathW );
        ctl_eatextension( buff );
        Test_Error( !strcmp( buff, "C:\\foo\\bar\\baz" ) );;
        ctl_eatfilename( buff );
        Test_Error( !strcmp( buff, "C:\\foo\\bar\\" ) );
        ctl_eattrailingslash( buff );
        Test_Error( !strcmp( buff, "C:\\foo\\bar" ) );
    }
    {
        /* Test wildcard compare */
        #define MFG_TestStrings(tchar)\
        {\
            const tchar* const sz = szconst(tchar,"I could have been your daddy.");\
            Test_Error( cstrwild(tchar)( sz, ~0u, szconst(tchar,"I could*") ) );\
            Test_Error( cstrwild(tchar)( sz, ~0u, szconst(tchar,"I cou?d*been*.") ) );\
            Test_Error( cstrwild(tchar)( sz, ~0u, szconst(tchar,"*daddy.") ) );\
            Test_Error( cstrwild(tchar)( sz, 7, szconst(tchar,"I could") ) );\
            Test_Error( !cstrwild(tchar)( sz, 7, szconst(tchar,"I would") ) );\
        }
        MFG_TestStrings(char);
        MFG_TestStrings(wchar_t);
    }
}

#endif /* CTL_UNIT */