Return to pa_dir.C CVS log

Up to [parser3project] / parser3 / src / main

Annotation of parser3/src/main/pa_dir.C, revision 1.22

1.1       paf         1: /** @file
                      2:        Parser: directory scanning for different OS-es.
                      3: 
1.21      moko        4:        Copyright (c) 2000-2012 Art. Lebedev Studio (http://www.artlebedev.com)
1.11      paf         5:        Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
1.12      paf         6: */
1.1       paf         7: 
1.9       paf         8: #include "pa_common.h"
1.1       paf         9: #include "pa_dir.h"
                     10: 
1.22    ! moko       11: volatile const char * IDENT_PA_DIR_C="$Id: pa_dir.C,v 1.21 2012-03-16 09:24:13 moko Exp $" IDENT_PA_DIR_H;
1.21      moko       12: 
1.1       paf        13: #ifdef WIN32
                     14: 
1.22    ! moko       15: #define TICKS_PER_SECOND 10000000ULL
        !            16: #define EPOCH_DIFFERENCE 11644473600ULL
        !            17: time_t filetime_to_timet(FILETIME const& ft){
        !            18:        ULARGE_INTEGER ull;
        !            19:        ull.LowPart = ft.dwLowDateTime;
        !            20:        ull.HighPart = ft.dwHighDateTime;
        !            21:        long long secs=(ull.QuadPart / TICKS_PER_SECOND - EPOCH_DIFFERENCE);
        !            22:        time_t t =(time_t)secs;
        !            23:        return (secs == (long long)t) ? t : 0;
        !            24: }
        !            25: 
1.16      paf        26: bool findfirst(const char* _pathname, struct ffblk *_ffblk, int /*_attrib*/) {
1.1       paf        27:        char mask[MAXPATH];
                     28:        snprintf(mask, MAXPATH, "%s/*.*", _pathname);
                     29: 
                     30:        _ffblk->handle=FindFirstFile(mask, (_WIN32_FIND_DATAA *)_ffblk);
                     31:        return _ffblk->handle==INVALID_HANDLE_VALUE;
                     32: }
                     33: 
                     34: bool findnext(struct ffblk *_ffblk) {
1.22    ! moko       35:        return !FindNextFile(_ffblk->handle, (_WIN32_FIND_DATAA *)_ffblk);
        !            36: }
1.1       paf        37: 
                     38: void findclose(struct ffblk *_ffblk) {
                     39:        FindClose(_ffblk->handle);
                     40: }
                     41: 
1.22    ! moko       42: bool ffblk::is_dir() {
        !            43:        return (ff_attrib & FILE_ATTRIBUTE_DIRECTORY) != 0;
        !            44: }
        !            45: 
        !            46: double ffblk::size() {
        !            47:        ULARGE_INTEGER ull;
        !            48:        ull.LowPart = nFileSizeLow;
        !            49:        ull.HighPart = nFileSizeHigh;
        !            50:        return (double)ull.QuadPart;
        !            51: }
        !            52: 
        !            53: time_t ffblk::c_timestamp() {
        !            54:        return filetime_to_timet(ftCreationTime);
        !            55: }
        !            56: 
        !            57: time_t ffblk::m_timestamp() {
        !            58:        return filetime_to_timet(ftLastWriteTime);
        !            59: }
        !            60: 
        !            61: time_t ffblk::a_timestamp() {
        !            62:        return filetime_to_timet(ftLastAccessTime);
        !            63: }
        !            64: 
1.1       paf        65: #else
                     66: 
1.18      paf        67: bool findfirst(const char* _pathname, struct ffblk *_ffblk, int /*_attrib*/) {
1.22    ! moko       68:     strncpy(_ffblk->filePath, _pathname, MAXPATH-1);
        !            69:        _ffblk->filePath[MAXPATH-1]=0;
1.1       paf        70:        if(!(_ffblk->dir=opendir(_ffblk->filePath)))
                     71:         return true;
                     72: 
                     73:        return findnext(_ffblk);
                     74: }
                     75: 
                     76: bool findnext(struct ffblk *_ffblk) {
                     77:     while(true) {
                     78:         struct dirent *entry=readdir(_ffblk->dir);
                     79:         if(!entry)
                     80:             return true;
                     81: 
                     82:                int maxsize=sizeof(_ffblk->ff_name)-1;
1.22    ! moko       83:                strncpy(_ffblk->ff_name, entry->d_name, maxsize-1);
        !            84:                _ffblk->ff_name[maxsize]=0;
1.1       paf        85:                
1.22    ! moko       86: #ifdef HAVE_STRUCT_DIRENT_D_TYPE
        !            87:                // http://www.gnu.org/software/libc/manual/html_node/Directory-Entries.html
        !            88:                _ffblk->_d_type=entry->d_type;
        !            89: #endif
1.1       paf        90:                return false;
                     91:     }
                     92: }
                     93: 
                     94: void findclose(struct ffblk *_ffblk) {
                     95:        closedir(_ffblk->dir);
                     96: }
                     97: 
1.22    ! moko       98: #ifdef HAVE_STRUCT_DIRENT_D_TYPE
        !            99: void ffblk::stat_file() {
        !           100: #else
        !           101: void ffblk::real_stat_file() {
        !           102: #endif
        !           103:        char fileSpec[MAXPATH];
        !           104:        snprintf(fileSpec, MAXPATH, "%s/%s", filePath, ff_name);
        !           105:        
        !           106:        if(stat(fileSpec, &_st) != 0) {
        !           107:                memset(&_st,0,sizeof(_st));
        !           108:        }
        !           109: }
        !           110: 
        !           111: bool ffblk::is_dir() {
        !           112: #ifdef HAVE_STRUCT_DIRENT_D_TYPE
        !           113:        return (_d_type & DT_DIR) != 0;
        !           114: #else
        !           115:        real_stat_file();
        !           116:        return S_ISDIR(_st.st_mode) != 0;
        !           117: #endif
        !           118: }
        !           119: 
        !           120: double ffblk::size() {
        !           121:        return (double)_st.st_size;
        !           122: }
        !           123: 
        !           124: time_t ffblk::c_timestamp() {
        !           125:        return _st.st_ctime;
        !           126: }
        !           127: 
        !           128: time_t ffblk::m_timestamp() {
        !           129:        return _st.st_mtime;
        !           130: }
        !           131: 
        !           132: time_t ffblk::a_timestamp() {
        !           133:        return _st.st_atime;
        !           134: }
        !           135: 
1.1       paf       136: #endif