メインページ | アルファベット順一覧 | 構成 | ファイル一覧 | 構成メンバ | ファイルメンバ | 関連ページ

dkcSJISFileSystem.c

説明を見る。
00001 
00008 #define DKUTIL_C_SJIS_FILESYSTEM_C
00009 
00010 #ifdef WIN32
00011 #include <SYS/STAT.H>
00012 #endif
00013 #include "dkcOSIndependent.h"
00014 #include "dkcSJISFileSystem.h"
00015 #include "dkcStdio.h"
00016 #include "dkcString.h"
00017 #include "dkcThreadLock.h"
00018 #include "dkcSingleList.h"
00019 #include "dkcStream.h"
00020 
00021 
00022 
00023 static DKC_INLINE BOOL jms1(int c){
00024     return (((((unsigned char)(c))>=0x81)&&(((unsigned char)(c))<=0x9F))||((((unsigned char)(c))>=0xE0)&&(((unsigned char)(c))<=0xFC)));
00025 }
00026 static DKC_INLINE BOOL jms2(int c){
00027     return ((((unsigned char)(c))!=0x7F)&&(((unsigned char)(c))>=0x40)&&(((unsigned char)(c))<=0xFC));
00028 }
00029 
00040 DKC_EXTERN int WINAPI dkcIsShiftJIS( const char *str, int nPos )
00041 {
00042     int i;
00043     int state; // { 0, 1, 2 } = { 1バイト文字, 2バイト文字の第1バイト, 2バイト文字の第2バイト }
00044 
00045     state = 0;
00046     for( i = 0; str[i] != '\0'; i++ )
00047     {
00048         if      ( ( state == 0 ) && ( jms1( str[i] ) ) ) state = 1; // 0 -> 1
00049         else if ( ( state == 1 ) && ( jms2( str[i] ) ) ) state = 2; // 1 -> 2
00050         else if ( ( state == 2 ) && ( jms1( str[i] ) ) ) state = 1; // 2 -> 1
00051         else                                             state = 0; // 2 -> 0, その他
00052 
00053         // str[nPos] での状態を返す。
00054         if ( i == nPos ) return state;
00055     }
00056     return 0;
00057 }
00058 static DKC_INLINE int isJMS(const char *str, int nPos ){
00059     return dkcIsShiftJIS(str,nPos);
00060 }
00062 static DKC_INLINE char *strtail( const char *stringg )
00063 {
00064     return strchr( stringg, '\0' );
00065 }//strtail
00066 
00071 const char * WINAPI dkcGetFileExtension( const char *PathName )
00072 {
00073 
00074     char *p;
00075     char *get_tail;
00076 
00077     get_tail = strtail( PathName );
00078     for( p = get_tail; p >= PathName; p-- ) // 文字列の最後から最初まで
00079     {
00080         if ( ('\\'==*p) && !isJMS(PathName,p-PathName) )
00081             return get_tail; // ファイル名はここまで
00082 
00083         if ( '.' == *p )
00084             return p+1; // '.' を発見
00085     }
00086     return get_tail; // 拡張子なし
00087 }//GetFileExtension
00088 
00089 
00090 BOOL WINAPI dkcIsEffectivePath(const char *path,size_t size){
00091     char dest[dkcdMAXPATH_BUFFER];
00092     const size_t dsize = dkcdMAXPATH_BUFFER;
00093 
00094     //相対パス?絶対パス?でもそのファイルが存在するか?
00095     if(FALSE==dkcFileExist(path)){
00096         return FALSE;
00097     }
00098     //pathを正規化
00099     if(DKUTIL_FAILED(dkcToAbsolutelyPath(dest,dsize,path,size))){
00100         return FALSE;
00101     }
00102     //正規化して、ファイルに使用して良い文字列を使っているか?
00103     if(FALSE==dkcIsNativePathString(dest,strlen(dest))){
00104         return FALSE;
00105     }
00106 
00107     return TRUE;
00108 }
00109 BOOL WINAPI dkcIsRelativityPath(const char *path)
00110 {
00111     int point;
00112     dkcmNOT_ASSERT(NULL==path);
00113     point = dkcSJIS_StrChrSearch(path,':');
00114     if(point == -1) return TRUE;
00115     return FALSE;
00116 }
00117 BOOL WINAPI dkcIsAbsolutelyPath(const char *path)
00118 {
00119     return !dkcIsRelativityPath(path);
00120 }
00121 
00123 BOOL WINAPI dkcIsTailPathSep(const char *src,size_t dlen){
00124     int point;
00125     point = dkcSJIS_SearchPathSepLast(src);
00126     //if(point != -1 && (size_t)point == dlen - 1/*&& (size_t)point != dlen*/)
00127     if((size_t)point == dlen - 1)
00128     {   //みつかった。
00129         return TRUE;
00130     }
00131     //みつからない。
00132     return FALSE;
00133 }
00135 int WINAPI dkcPushBackPathSep(char *dest,size_t dlen,size_t size){
00136     if(FALSE==dkcIsTailPathSep(dest,dlen)){
00137         if(size < dlen + 2){
00138             return edk_OutputBufferWasLost;//バッファが足らんよ!
00139         }
00140         dest[dlen ] = dkcdPATH_SEP;
00141         dest[dlen + 1] = '\0';//こいつを忘れてはいけない。
00142         return edk_SUCCEEDED;
00143     }
00144     return edk_EndProcess;
00145 }
00146 
00147 int WINAPI dkcDirectoryConcatenate(char *dest,size_t dlen,size_t dsize,const char *src){
00148     //int point;
00149     //error check
00150     dkcmNOT_ASSERT(dlen + 2 > dsize);
00151     if(dlen + 2 > dsize){
00152         return edk_FAILED;
00153     }
00154     
00155     /*point = dkcSJIS_StrChrSearchTail(dest,dlen,dkcdPATH_SEP);
00156     if(point != -1 && (size_t)point != dlen)
00157     {//path separatorが見つかり、それがdestの最期に無い時
00158         if(!dkcmIS_PATH_SEP(src[0]) )
00159         {//path separatorで無い時
00160             //path 区切り文字を付加してやる。
00161             dest[dlen ] = dkcdPATH_SEP;
00162             dest[dlen + 1] = '\0';//こいつを忘れてはいけない。
00163         }
00164     }*/
00165     dkcPushBackPathSep(dest,dlen,dsize);
00166     return dkc_strcat_amap(dest,dsize,dlen,src,strlen(src));
00167 }
00168 
00169 int WINAPI dkcCurrentDirectoryConcatenate(char *dest,size_t dsize,const char *src)
00170 {
00171     //size_t len;
00172     //int point;
00173     
00174     dkcmNOT_ASSERT(dsize <= dkcdMAXPATH_LEN);//<=はNULL文字も含むため。
00175     
00176     dkcGetCurrentDirectory(dest,dsize);
00177     
00178     
00179     return dkcDirectoryConcatenate(dest,strlen(dest),dsize,src);
00180 }
00181 #define MAX_PATH_CHECK(dsize) \
00182 {\
00183     dkcmNOT_ASSERT(dsize < dkcdMAXPATH_BUFFER);\
00184     if(dsize < dkcdMAXPATH_BUFFER){\
00185         return edk_BufferOverFlow;\
00186     }\
00187 }
00188 
00189 static int ToAbsolutelyLogic(char *dest,size_t dsize,const char *src)
00190 {
00191     /*if(dsize < dkcdMAXPATH_BUFFER){//こんなバッファじゃどうなるか分からないよ^^;
00192         return edk_BufferOverFlow;
00193     }*/
00194     MAX_PATH_CHECK(dsize);
00195 #   ifdef WIN32
00196 
00197     if(NULL==_fullpath(dest,src,dsize)){
00198         return edk_FAILED;
00199     }
00200 #   else//unix or linux ??
00201     if(NULL==__realpath(src,dest)){
00202         return edk_FAILED;
00203     }
00204 #   endif
00205     return edk_SUCCEEDED;   
00206 }
00207 //パスを正規化する関数
00208 int WINAPI dkcToAbsolutelyPath(char *dest,size_t dsize,const char *src,size_t ssize)
00209 {
00210     char *tp = NULL;
00211     int r;
00212     MAX_PATH_CHECK(dsize);
00213 
00214     
00215     if(NULL==dest) return edk_FAILED;
00216 
00217     if(dkcIsRelativityPath(src)==TRUE)
00218     {//カレントディレクトリを付加する。
00219 
00220         tp = (char *)malloc(dkcdMAXPATH_BUFFER);
00221         if(NULL==tp) return edk_OutOfMemory;
00222 
00223         dkcCurrentDirectoryConcatenate(tp,dkcdMAXPATH_BUFFER,src);
00224         r =  ToAbsolutelyLogic(dest,dsize,tp);
00225         free(tp);
00226         return r;
00227 
00228     }
00229     return ToAbsolutelyLogic(dest,dsize,src);
00230 
00231 
00232     
00233     /*
00234     状態繊維
00235     PATH_SEP
00236     .
00237     sjis
00238 
00240     .....
00241     ../../
00242     /././
00243 
00244     */
00245         /*
00246     size_t i,di;
00247 //  size_t j;
00248     int point;
00249     //char prev;
00250     const char *pathsep="\\/";
00251     DKC_SINGLELIST_OBJECT *plo = NULL;
00252     DKC_SINGLELIST *lit = NULL;
00253     
00254     
00255     di = 0;
00256 
00257     if(dsize < ssize){
00258         return edk_ArgumentException;
00259     }
00260     //list確保
00261     plo = dkcAllocSingleListObject(NULL,20);
00262     if(NULL==plo) return edk_FAILED;
00263 
00264     //directoryをパース
00265     for(i=0;;){
00266         point = dkcSJIS_StrChrSearchInStr(&src[i],pathsep);
00267         if(point < 0){
00268             if(i != ssize){
00269                 if(FALSE==plo->push_back(plo,&src[i],size - i)){
00270                     return edk_FAILED;
00271                 }
00272             }
00273             break;
00274         }
00275         
00276         if(FALSE
00277             ==plo->push_back(plo,&src[i],point - 1)//見つかったところまでだから-1
00278             )
00279         {
00280             return edk_FAILED;
00281         }
00282 
00283         i += point;
00284     }
00285 
00286     for(i=0;i<ssize;){
00287 
00288 
00289         if(dkcmIsSJIS1(src[i]) && dkcmIsSJIS2(src[i + 1]))
00290         {//SJIS抜かし
00291             i++;
00292             i++;
00293             continue;
00294         }
00295         // src == //
00296         if(prev==dkcdPATH_SEP && src[i] == dkcdPATH_SEP)
00297         {
00298             i++;
00299             continue;
00300         }
00301         // src == ..
00302         if(prev=='.' && src[i] == '.')
00303         {
00304             while(src[i] != '.') i++;
00305             if(dkcdPATH_SEP==src[i]) i++;
00306             point = dkcSJIS_StrChrSearch(&src[i],dkcdPATH_SEP);
00307 
00308             if(point == -1){
00309                 break;
00310             }
00311             i += point;
00312 
00313             continue;
00314         }
00315 
00316         dest[di] = src[i];
00317         di++;
00318         i++;
00319         prev = src[i];
00320     }
00321 
00322     
00323     return edk_SUCCEEDED;   */
00324 }
00325 
00326 
00327 DKC_PATHSTRING * WINAPI dkcAllocPathString(const char *path)
00328 {
00329     DKC_PATHSTRING *p;
00330     size_t len;
00331     /*if(NULL==path){
00332         return NULL;
00333     }*/
00334 
00335     p = (DKC_PATHSTRING *)dkcAllocate(sizeof(DKC_PATHSTRING));
00336     if(NULL==p) return NULL;
00337 
00338     p->mString = dkcAllocString(dkcdMAXPATH_BUFFER + 1);//このサイズじゃないとダメ
00339     if(NULL==p->mString) goto Error;
00340 
00341     //パス名をコピー
00342     if(path){
00343         len = strlen(path);
00344         //ネイティブなパスを入れる。
00345         if(FALSE==dkcIsNativePathString(path,len)){
00346             goto Error;
00347         }
00348         if(DKUTIL_FAILED(dkcPathStringCopy(p,path,len))){
00349             goto Error;
00350         }
00351     }
00352     p->mIterateCount = 0;
00353 
00354     return p;
00355 Error:
00356     if(p){
00357         dkcFreeString(&p->mString);
00358     }
00359     dkcFree((void **)&p);
00360     return NULL;
00361 }
00362 
00363 int WINAPI dkcFreePathString(DKC_PATHSTRING **ptr)
00364 {
00365     if(NULL==ptr || NULL==*ptr){
00366         return edk_ArgumentException;
00367     }
00368     dkcFreeString(&((*ptr)->mString));
00369     return dkcFree((void **)ptr);
00370 }
00371 
00372 //パスのデータを得る。
00373 size_t WINAPI dkcPathStringSize(const DKC_PATHSTRING *p)
00374 {
00375     return dkcStringSize(p->mString);
00376 }
00377 
00378 const char *WINAPI dkcPathStringPointer(const DKC_PATHSTRING *p)
00379 {
00380     return dkcStringPointer(p->mString);
00381 }
00382 
00383 
00384 //パスを区切る。
00385 
00386 int WINAPI dkcPathStringDevideBegin(DKC_PATHSTRING *ptr,char *buff,size_t size)
00387 {
00388     return dkcPathStringDevideBegin_Logic(ptr,&ptr->mIterateCount,buff,size);
00389 }
00390 
00391 int WINAPI dkcPathStringDevideNext(DKC_PATHSTRING *ptr,char *buff,size_t size)
00392 {
00393     return dkcPathStringDevideNext_Logic(ptr,&ptr->mIterateCount,buff,size);
00394 
00395 }
00396 
00397 void WINAPI dkcPathStringDevideEnd(DKC_PATHSTRING *ptr){
00398     dkcPathStringDevideEnd_Logic(&ptr->mIterateCount);
00399 }
00400 
00401 
00402 int WINAPI dkcPathStringDevideBegin_Logic(DKC_PATHSTRING *ptr,size_t *count,char *buff,size_t size)
00403 {
00404     int i,point;
00405     const char *p;
00406     dkcmNOT_ASSERT(NULL==ptr || NULL==buff || 0==size);
00407     
00408     //len = dkcPathStringSize(ptr);
00409     p = dkcPathStringPointer(ptr);
00410 
00411     point = dkcSJIS_StrChrSearch(p,'\\');
00412     if(-1==point){return edk_EndProcess;}
00413 
00414     for(i=0;i<point;i++){//drive指定のものがあるかどうか。
00415         if(':'==p[i]){
00416             if(DKUTIL_FAILED(dkc_strcpy(
00417                 buff,size,p,(size_t)i//-1
00418                 )))
00419             {
00420                 return edk_BufferOverFlow;
00421             }
00422             point = dkcSJIS_StrChrSearch(&p[i],'\\');//次の物を見つける。
00423             //(まぁ:の次は\\と言う事が決まっているけど、いちおう。
00424             *count = (size_t)i + point + 1;//次に始めるのは
00425             return edk_SUCCEEDED;
00426         }
00427     }
00428     if(DKUTIL_FAILED(dkc_strcpy(
00429         buff,size,p,(size_t)point-1
00430         )))
00431     {
00432         return edk_FAILED;
00433     }
00434     *count = (size_t)point + 1;//次に始めるのは
00435     return edk_SUCCEEDED;
00436 }
00437 
00438 int WINAPI dkcPathStringDevideNext_Logic(DKC_PATHSTRING *ptr,size_t *count,char *buff,size_t size)
00439 {
00440     int point;
00441     const char *p;
00442     size_t len;
00443     //len = dkcPathStringSize(ptr);
00444     p = dkcPathStringPointer(ptr);
00445     len = dkcStringSize(ptr->mString);
00446     if(len <= *count)
00447     {//もうこの関数を呼び出すのは終わりだっちゅうに!!
00448         return edk_EndProcess;
00449     }
00450     point = dkcSJIS_StrChrSearch(&p[*count],'\\');
00451     if(-1==point)
00452     {//最後まで来ちまった。
00453 
00454     
00455         len -= *count;
00456         if(DKUTIL_FAILED(dkc_strcpy(//残り物を全部コピー
00457             buff,size,&p[*count],len
00458         )))
00459         {
00460             return edk_FAILED;
00461         }
00462         *count += len;
00463         return edk_SUCCEEDED;//out
00464     }
00465     if(DKUTIL_FAILED(dkc_strcpy(
00466         buff,size,&p[*count],(size_t)point
00467         )))
00468     {
00469         return edk_FAILED;
00470     }
00471     *count += (size_t)point + 1;//次に始めるのは
00472     return edk_SUCCEEDED;//out
00473 }
00474 
00475 void WINAPI dkcPathStringDevideEnd_Logic(size_t *count){
00476     *count = 0;
00477 }
00478 
00479 int WINAPI dkcPathStringElementInsert_Logic(DKC_PATHSTRING *ptr,size_t count,
00480                     const char *src,size_t len)
00481 {
00482     int r;
00483     size_t size = len + 5;
00484     
00485     char *p;
00486     if(len==0 || FALSE==dkcIsNativePathString(src,len))
00487     {
00488         return edk_FAILED;
00489     }
00490     if(FALSE==dkcIsTailPathSep(src,len))//後ろにPathSeparatorが無い!!
00491     {
00492         p = (char *)malloc(size);
00493     
00494         if(!p) return edk_OutOfMemory;
00495         strcpy(p,src);//あまり使いたくないけどすでにバッファは保証されているのでstrcpy
00496         dkcPushBackPathSep(p,len,size);
00497 
00498         r = dkcStringInsert(ptr->mString,count,p,strlen(p));
00499         free(p);
00500     }else{
00501         r = dkcStringInsert(ptr->mString,count,src,len);
00502     }
00503     return r;
00504 }
00505 
00506 int WINAPI dkcPathStringElementErase_Logic(
00507     DKC_PATHSTRING *ptr,size_t count)
00508 {
00509     const char *p = dkcPathStringPointer(ptr);
00510     int endlen = dkcSJIS_SearchPathSep(&p[count]);
00511 
00512     if(-1==endlen){
00513         endlen = dkcPathStringSize(ptr);
00514         endlen = endlen - count;
00515     }else{
00516         //endlen;//マイナスしておく \\をReplaceしないため
00517     }
00518     return dkcStringErase(ptr->mString,count - 1,(size_t)endlen + 1);//count -1は前の\\を消すためendlen + 1は-1した為
00519 }
00520 
00521 
00522 
00523 int WINAPI dkcPathStringElementReplace_Logic(DKC_PATHSTRING *ptr,size_t count,
00524                                                                             const char *src,size_t len)
00525 {
00526     const char *p = dkcPathStringPointer(ptr);
00527     int endlen;
00528     if(len==0 || FALSE==dkcIsNativePathString(src,len))
00529     {
00530         return edk_FAILED;
00531     }
00532     endlen = dkcSJIS_SearchPathSep(&p[count]);//countから検索している
00533     if(-1==endlen){
00534         endlen = dkcPathStringSize(ptr);
00535         endlen = endlen - count;
00536     }else{
00537         if(0 != endlen)
00538             endlen--;//マイナスしておく \\をReplaceしないため
00539     }
00540     return dkcStringReplace(ptr->mString,count,count + endlen,src,len);
00541     /*
00542     size_t size = len + 5;
00543     int r;
00544 //  int point;
00545     const char *pointer;
00546     char *p ;
00547     if(FALSE==dkcIsTailPathSep(src,len))//後ろにPathSeparatorが無い!!
00548     {
00549         //文字列をちと変更
00550         p = malloc(size);
00551         if(!p) return edk_OutOfMemory;
00552         strcpy(p,src);
00553         r = dkcPushBackPathSep(p,len,size);
00554     }else{
00555         p = (char *)src;
00556     }
00557     pointer = dkcPathStringPointer(ptr);
00558     //countから調べる。
00559     dkcSJIS_SearchPathSep(&pointer[count]);
00560     */
00561     
00562 
00563 
00564     
00565 
00566 }
00567 
00568 
00569 
00570 
00571 
00572 //パスを正規化して入れる。
00573 static int dkcPathStringNormalizeCopyLogic(DKC_PATHSTRING *ptr,const char *buff,size_t size,
00574                                                                                          int (WINAPI *function__)(DKC_STRING *,const char *,size_t))
00575 {
00576     //const size_t bsize = dkcdMAXPATH_BUFFER + 1;
00577     size_t len;
00578     int result;
00579     //char *pb = malloc(bsize);
00580     //if(NULL== pb) return edk_OutOfMemory;
00581     char pb[dkcdMAXPATH_BUFFER];
00582     size_t bsize = sizeof(pb);
00583 
00584     result =    dkcToAbsolutelyPath(pb,bsize,buff,size);
00585     
00586 
00587     len = strlen(pb);
00588 
00589 #   ifdef DEBUG //ありえないよ〜エラーチェック
00590     dkcmNOT_ASSERT(DKUTIL_FAILED(result));  
00591     dkcmNOT_ASSERT(len >= bsize);// >=にするのはNULL文字が潰されているかどうか。
00592     dkcmNOT_ASSERT(NULL==function__);
00593 #   endif
00594     if(DKUTIL_FAILED(result)){
00595         goto Error;
00596     }
00597     result = function__(ptr->mString,pb,len);
00598 
00599 Error:
00600     //if(pb){free(pb);pb=NULL;}
00601     return result;
00602 }
00603 //パスを正規化して入れる。
00604 int WINAPI dkcPathStringCopy(DKC_PATHSTRING *ptr,const char *buff,size_t size)
00605 {
00606     
00607     dkcmNOT_ASSERT(ptr->mString->mByteSize + size >= dkcdMAXPATH);
00608     if(ptr->mString->mByteSize + size >= dkcdMAXPATH)
00609     {//これ以上は入れられない。
00610         return edk_FAILED;
00611     }
00612     return dkcPathStringNormalizeCopyLogic(ptr,buff,size,dkcStringCopy);
00613 }
00614 
00615 int WINAPI dkcPathStringNormalizeConcatenateLogic(
00616     DKC_PATHSTRING *ptr,const char *buff,size_t size)
00617 {
00618     char dest[dkcdMAXPATH_BUFFER];
00619 
00620 
00621     if(FALSE==dkcIsTailPathSep(dkcPathStringPointer(ptr),dkcPathStringSize(ptr)))
00622     {
00623         dkcStringConcatenate(ptr->mString,dkcdPATH_SEP_STR,1);
00624     }
00625     dkcStringConcatenate(ptr->mString,buff,size);
00626     
00627     size = dkcPathStringSize(ptr) + 1;
00628 
00629     //p = malloc(dkcPathStringSize(ptr));
00630     //if(!p) return edk_OutOfMemory;
00631 
00632 
00633     if(DKUTIL_FAILED(
00634         ToAbsolutelyLogic(dest,sizeof(dest),dkcPathStringPointer(ptr))
00635         )){
00636         return edk_FAILED;
00637     }
00638 
00639     return dkcPathStringCopy(ptr,dest,strlen(dest));
00640 }
00641 
00642 //パスを正規化して繋げる。
00643 int WINAPI dkcPathStringConcatenate(DKC_PATHSTRING *ptr,const char *buff,size_t size)
00644 {
00645     int result;
00646 
00647     dkcmNOT_ASSERT(ptr->mString->mByteSize + size >= dkcdMAXPATH);
00648     if(ptr->mString->mByteSize + size >= dkcdMAXPATH)
00649     {//これ以上は入れられない。
00650         return edk_FAILED;
00651     }
00652 
00653     if(ptr->mString->mByteSize)
00654     {//すでに入っているものがある。
00655         result = dkcPathStringNormalizeConcatenateLogic(ptr,buff,size);
00656     }
00657     else
00658     {//何も無い時はこちらで
00659         result =  dkcPathStringCopy(ptr,buff,size);
00660     }
00661     //return dkcPathStringNormalizeInsertLogic(ptr,buff,size,dkcStringConcatenate); 
00662     return result;
00663 }
00664 
00665 
00666 
00667 int WINAPI dkcPathStringGetDrive(DKC_PATHSTRING *ptr,char *buff,size_t size){
00668     const char *p = dkcStringPointer(ptr->mString);
00669     int point = dkcSJIS_StrChrSearch(p,':');
00670     if(-1 == point) return edk_Not_Found;//見つからない。
00671     //return dkc_memcpy(buff,size,p,(size_t)point - 1);
00672     return dkc_strcpy(buff,size,p,(size_t)1);//driveなら1文字で十分だよね^^;
00673 }
00674 
00675 int WINAPI dkcPathStringGetFileExtension(DKC_PATHSTRING *ptr,char *buff,size_t size)
00676 {
00677     int point2;
00678     size_t len;
00679     const char *p = dkcStringPointer(ptr->mString);
00680     int point = dkcSJIS_StrChrSearchLast(p,'.');
00681 
00682     if(point < 0) return edk_Not_Found;//見つからない。
00683     
00684     point2 = dkcSJIS_SearchPathSep(&p[point]);
00685     if(point < point2){//C:\ok.OK\folderのような状況になっている。
00686         return edk_Not_Found;
00687     }
00688     len = dkcStringSize(ptr->mString);
00689     //if(point - 1 <= 0) return edk_FAILED;
00690 
00691     if((size_t)(point + 1) > len) return edk_FAILED;//Logicalなエラー??
00692     return dkc_strcpy(buff,size,&p[point + 1],(size_t)len - (size_t)point );
00693 
00694 }
00695 
00696 int WINAPI dkcPathStringGetFileName(DKC_PATHSTRING *ptr,char *buff,size_t size)
00697 {
00698     const char *p = dkcStringPointer(ptr->mString);
00699     //int point = dkcSJIS_StrChrSearchLast(p,dkcdPATH_SEP);
00700     int point = dkcSJIS_SearchPathSepLast(p);
00701     size_t len = dkcStringSize(ptr->mString);
00702     //if(point - 1 <= 0) return edk_FAILED;
00703 #if 0
00704     if(point < 0) return edk_Not_Found;//見つからない。
00705     if((size_t)(point + 1) > len) return edk_FAILED;
00706     if((size_t)point == len) return edk_FAILED;//ファイル名が無い。
00707 
00708 #else
00709     printf("%d",point);
00710 
00711     dkcmFORCE_NOT_ASSERT(NULL==p);
00712     dkcmFORCE_NOT_ASSERT(point < 0);
00713     dkcmFORCE_NOT_ASSERT((size_t)(point + 1) > len);
00714     dkcmFORCE_NOT_ASSERT((size_t)point == len);
00715 
00716 #endif
00717     return dkc_strcpy(buff,size,&p[point + 1],(size_t)len - (size_t)point );
00718 }
00719 
00720 int WINAPI dkcPathStringGetDirectory(DKC_PATHSTRING *ptr,char *buff,size_t size)
00721 {
00722     const char *p = dkcStringPointer(ptr->mString);
00723     int point = dkcSJIS_StrChrSearchTail(p,strlen(p),dkcdPATH_SEP);
00724     size_t len = dkcStringSize(ptr->mString);
00725     //if(point - 1 <= 0) return edk_FAILED;
00726     if(point < 0) return edk_FAILED;
00727     if((size_t)(point + 1) > len) return edk_FAILED;
00728     //if((size_t)point == len) return edk_FAILED;//ファイル名が無い。
00729     return dkc_strcpy(buff,size,p,point);//\\も含める。
00730 
00731 }
00732 
00733 
00734 /*
00735 BOOL WINAPI dkcFileAndFolderExist(const char *filename)
00736 {
00737     struct stat s;
00738     if(!filename) return FALSE;
00739     return (stat(filename,&s)==0);
00740 }
00741 */
00742 static DKC_INLINE file_exist_base(const char *filename,BOOL with_file,BOOL with_folder){
00743     struct stat s;
00744     if(!filename) return FALSE;
00745     if(!(stat(filename,&s)==0)) return FALSE;
00746     //from MSDN //folder
00747     if(s.st_mode & S_IFDIR){
00748         return with_folder;
00749     }
00750     return with_file;
00751 }
00752 
00753 BOOL WINAPI dkcFileExist(const char *filename)
00754 {
00755     return file_exist_base(filename,TRUE,FALSE);
00756 }
00757 
00758 BOOL WINAPI dkcFileAndFolderExist(const char *filename)
00759 {
00760     return file_exist_base(filename,TRUE,TRUE);
00761 }
00762 
00763 BOOL WINAPI dkcFolderExist(const char *filename)
00764 {
00765     return file_exist_base(filename,FALSE,TRUE);
00766 }
00767 
00768 
00769 
00770 ULONG WINAPI dkcFileSize(const char *filename){
00771     struct stat s;//s
00772     if(!filename) return 0;
00773   return (stat(filename,&s)==0) ? (ULONG)s.st_size : 0;
00774 }
00775 BOOL WINAPI dkcFileSize64(const char *str,DWORD *high,DWORD *low){
00776 #ifdef WIN32
00777     WIN32_FIND_DATA findData;
00778     HANDLE hFind=NULL;
00779     // ファイルサイズ取得
00780     if((hFind = FindFirstFile(str,&findData)) == INVALID_HANDLE_VALUE){
00781         return FALSE;
00782     }
00783 
00784     //ファイルのサイズをヴちこむ
00785     *high = findData.nFileSizeHigh;
00786     *low = findData.nFileSizeLow;
00787     FindClose(hFind);
00788     return TRUE;
00789 #else
00790 
00791 #endif
00792 }
00793 
00794 
00795 BOOL WINAPI dkcSetCurrentDirectory(const char *filename){
00796 #ifdef DEBUG
00797     size_t len = strlen(filename);
00798     dkcmNOT_ASSERT(0==len || FALSE==dkcIsEffectivePath(filename,len));
00799 #endif
00800 #   ifdef WIN32
00801     return(0 != SetCurrentDirectory(filename));
00802     //return (_chdir(filename)==0);
00803 #   else
00804     return (chdir(filename)==0);
00805 #   endif
00806 }
00807 
00808 
00809 BOOL WINAPI dkcGetCurrentDirectory(char *buff,size_t size){
00810 #   ifdef WIN32
00811     if(0==GetCurrentDirectory(size,buff)){
00812         return FALSE;
00813     }
00814     /*if(NULL==_getcwd(path,dkcdMAXPATH_BUFFER)){
00815         return FALSE;
00816     }*/
00817 #else
00818   if(NULL==getcwd(buff,size))
00819         return FALSE;
00820 #endif
00821     return TRUE;
00822 
00823 #if 0
00824     /* どういう実装になっているか分からないのでとりあえず+1 */
00825     char path[dkcdMAXPATH_BUFFER + 1];
00826     size_t len;
00827 #   ifdef WIN32
00828     if(0==GetCurrentDirectory(size,path)){
00829         return FALSE;
00830     }
00831     /*if(NULL==_getcwd(path,dkcdMAXPATH_BUFFER)){
00832         return FALSE;
00833     }*/
00834 #else
00835   if(NULL==getcwd(path,dkcdMAXPATH_BUFFER))
00836         return FALSE;
00837 #endif
00838     len = strlen(path);
00839     return DKUTIL_SUCCEEDED(dkc_strcpy(buff,size,path,len));
00840 #endif //end of if 0
00841 }
00842 
00843 static BOOL WINAPI dkcCreateDirectoryLogic(const char *dir,const void *ptr){
00844 #ifdef WIN32
00845      //return (0 == _mkdir( dir ));
00846      return (0 != CreateDirectory(dir,(SECURITY_ATTRIBUTES *)ptr));
00847 #else
00848      return (0 == mkdir( dir ));
00849 #endif
00850 }
00851 
00852 
00853 
00854 int WINAPI dkcCreateDirectory(const char *pPath)
00855 {
00856     BOOL result;
00857     char work[dkcdMAXPATH_BUFFER];
00858     unsigned long n = 0;
00859     unsigned long len = strlen(pPath);
00860 
00861 #ifdef WIN32//sjis support
00862     SECURITY_ATTRIBUTES attr;
00863     
00864     DKUTIL_STRUCTURE_INIT(attr);
00865     NULL_CHAR_ARRAY(work);
00866 
00867     //error check
00868     if(dkcdMAXPATH_LEN < len){
00869         dkcmNOT_ASSERT_MESSAGE("pathが長すぎる。",pPath);
00870         return edk_FAILED;
00871     }
00872     if(0==len ){
00873         return edk_ArgumentException;
00874     }
00875 
00876     //まずは一つ目を撃破
00877     if ( dkcmIsSJIS1(pPath[n]) || ! dkcmIS_INVALID_FOLDERNAME_CHAR(pPath[n]) )
00878     {//SJISの1文字目かINVALIDな値では無かったら。
00879         work[n] = pPath[n];
00880         if(1==len){
00881             //フォルダ作成
00882             attr.nLength = sizeof(SECURITY_ATTRIBUTES);
00883             attr.lpSecurityDescriptor = NULL;
00884             attr.bInheritHandle = FALSE;
00885 
00886             result = dkcCreateDirectoryLogic( work, &attr );
00887             
00888             dkcmNOT_ASSERT(FALSE==result && "directoryを作れなかった" );
00889             return edk_SUCCEEDED;
00890         }
00891     }
00892     n++;
00893     //二つ目から開始
00894     while ( n < len )
00895     {
00896          //フォルダ名取得
00897         while ( n < len )
00898         {
00899             
00900             if(! dkcmIsSJIS1(pPath[n - 1]) && ! dkcmIsSJIS2(pPath[n]) )
00901             {//SJISではない!!
00902                 if ( ( dkcmIS_PATH_SEP(pPath[n]) ) /*&& pPath[n] != '\0'*//*(n != '\0')*/ )
00903                 {
00904                     if ( work[n-1] != ':' )
00905                     {//driveを読み込ませたくないらしい。
00906                         break;
00907                     }
00908                 }
00909                 else if(dkcmIS_INVALID_FOLDERNAME_CHAR(pPath[n]))
00910                 {//SJIS問題をクリアしたのに間違いだった
00911                     return edk_FAILED;
00912                 }
00913             }
00914             
00915             work[n] = pPath[n];
00916             n++;
00917         }
00918         work[n] = '\0';
00919 
00920         //フォルダ作成
00921         attr.nLength = sizeof(SECURITY_ATTRIBUTES);
00922         attr.lpSecurityDescriptor = NULL;
00923         attr.bInheritHandle = FALSE;
00924 
00925 
00926 
00927         result = dkcCreateDirectoryLogic( work, &attr );
00928         
00929         //dkcmNOT_ASSERT("directoryを作れなかった" && FALSE==result);
00930         if(FALSE==result){
00931             return edk_FAILED;
00932         }
00933         work[n++] = dkcdPATH_SEP;
00934     }
00935 #else //no support sjis
00936     NULL_CHAR_ARRAY(work);
00937     
00938         //error check
00939     if(dkcdMAXPATH_LEN < len){
00940         dkcmNOT_ASSERT_MESSAGE("pathが長すぎる。",pPath);
00941         return edk_FAILED;
00942     }
00943     if(0==len ){
00944         return edk_ArgumentException;
00945     }
00946 
00947     while ( n < len )
00948     {
00949          //フォルダ名取得
00950         while ( n < len )
00951         {
00952             if ( ( dkcmIS_PATH_SEP(pPath[n]) ) && (n != '\0') )
00953             {
00954                 if ( work[n-1] != ':' )//Linuxのドライブのパスはコレデいいのかな?
00955                 {
00956                     break;
00957                 }
00958             }
00959             work[n] = pPath[n];
00960             n++;
00961         }
00962         work[n] = '\0';
00963 
00964         result = dkcCreateDirectoryLogic( work,NULL );
00965 
00966         //dkcmNOT_ASSERT("directoryを作れなかった" && FALSE==result);
00967         if(FALSE==result){
00968             return edk_FAILED;
00969         }
00970         work[n++] = dkcdPATH_SEP;
00971     }
00972 
00973 #endif
00974 
00975     return edk_SUCCEEDED;
00976 }
00977 
00978 BOOL WINAPI dkcFileCopy(const char *dest,const char *src,BOOL bReWrite){
00979     return dkcFileCopyEx(dest,src,1024 * 64,bReWrite,FALSE,NULL,NULL);
00980 }
00981 
00982 BOOL WINAPI dkcFileCopyEx(const char *dest,const char *src,
00983                                                                         size_t inner_buffer_size,BOOL bReWrite,
00984                                                                         BOOL bThreadLock,
00985                                                                         DKC_STD_CALLBACK pfcallback,void *parg)
00986 {
00987     void *buff;
00988     FILE *srcf,*destf;
00989     size_t filesize;//ファイルサイズ
00990     size_t readed;//読み込んだデータ
00991     size_t count;//count
00992     size_t i;
00993     size_t rest;//残り
00994     int result = FALSE;//戻り値
00995     DKC_THREAD_LOCK *lock = NULL;
00996     DKC_FILECOPY_CALLBACK_STRUCT cbdata;
00997 
00998 
00999     if(NULL==dest || NULL==src){
01000         return FALSE;
01001     }
01002     if(inner_buffer_size <= 1024){
01003         inner_buffer_size = 1024;
01004     }
01005 
01006     //バッファの準備
01007     buff = malloc(inner_buffer_size);
01008     if(NULL==buff){
01009         inner_buffer_size = 1024 * 256;
01010         buff = malloc(inner_buffer_size);
01011         if(NULL==buff)
01012             return FALSE;
01013     }
01014     //thread lock
01015     if(bThreadLock){
01016         lock = dkcAllocThreadLock();
01017         if(NULL==lock){
01018             goto Error;
01019         }
01020         dkcThreadLock_Lock(lock);
01021     }
01022     //ちっちゃい場合
01023     filesize = dkcFileSize(src);
01024     //destが存在する
01025     if(FALSE==bReWrite && TRUE==dkcFileExist(dest)){
01026         goto Error;
01027     }
01028     cbdata.filesize = filesize;
01029     cbdata.count = 0;
01030     for(;;)
01031     {//non loop 
01032         if(0 == filesize)
01033         {//ファイルサイズが0の場合
01034             if(TRUE==dkcCreateEmptyFile(dest))
01035             {
01036                 result = TRUE;
01037             }
01038             break;
01039         }
01040         if(filesize < inner_buffer_size)
01041         {//ファイルサイズがバッファに収まってしまう場合。
01042             if(DKUTIL_FAILED(dkcLoadBinary(buff,filesize,src,&readed)))
01043             {
01044                 goto Error;
01045             }
01046 #   ifdef DEBUG
01047             if(readed != filesize){
01048                 ODS("readed != filesize why?\n");
01049             }
01050 #   endif
01051             if(DKUTIL_SUCCEEDED(dkcSaveBinary(buff,filesize,dest)))
01052             {
01053                 result = TRUE;
01054             }
01055             break;
01056         }
01057         //バッファを使わなければコピーできない場合。
01058 
01059         srcf = dkcFOpen(src,"rb");
01060         if(NULL==srcf) goto Error;
01061         destf = dkcFOpen(dest,"wb");
01062         if(NULL==destf) goto Close;
01063 
01064         //ループする回数を計算
01065         count = filesize / inner_buffer_size;
01066 
01067         for(i=0;i<count;i++){
01068             dkcmFORCE_NOT_ASSERT(1 != fread(buff,inner_buffer_size,1,srcf));
01069             dkcmFORCE_NOT_ASSERT(1 != fwrite(buff,inner_buffer_size,1,destf));
01070             
01071             cbdata.count += inner_buffer_size;
01072             if(pfcallback){//コールバックで相手方に伝える。
01073                 if(FALSE==pfcallback(&cbdata,parg)){
01074                     goto Close;
01075                 }
01076             }
01077         }
01078 
01079         rest = filesize - (count * inner_buffer_size);
01080         
01081         //残りを出力
01082         dkcmFORCE_NOT_ASSERT(rest != fread(buff,1,rest,srcf));
01083         dkcmFORCE_NOT_ASSERT(rest != fwrite(buff,1,rest,destf));
01084         
01085         
01086         cbdata.count += rest;
01087         dkcmNOT_ASSERT(cbdata.count != cbdata.filesize);
01088         if(pfcallback){//コールバックで相手方に伝える。
01089             if(FALSE==pfcallback(&cbdata,parg)){
01090                 goto Close;
01091             }
01092         }
01093         result = TRUE;
01094 Close:
01095         //close
01096         dkcFClose(&srcf);
01097         dkcFClose(&destf);
01098 
01099         break;
01100     }//end of for
01101 
01102 
01103 
01104 
01105 Error:
01106     if(bThreadLock){
01107         if(lock){
01108             dkcThreadLock_Unlock(lock);
01109             dkcFreeThreadLock(&lock);
01110         }
01111     }
01112     if(buff){
01113         free(buff);buff=NULL;
01114     }
01115     return result;
01116 }
01117 
01118 BOOL WINAPI dkcFileRemove(const char *filename)
01119 {
01120 #ifdef WIN32
01121     return (0 != DeleteFile(filename));
01122     //return (0==remove(filename));
01123 #else
01124     return (0==remove(filename));
01125 #endif
01126 }
01127 
01128 BOOL WINAPI dkcFileRename(const char *oldname,const char *newname){
01129 #ifdef WIN32
01130     return (0==rename(oldname,newname));
01131 #else
01132     return (0==rename(oldname,newname));
01133 #endif
01134 }
01135 
01136 BOOL WINAPI dkcCreateZeroByteFile(const char *filename,BOOL rewrite)
01137 {
01138     FILE *fp;
01139     int r = FALSE;
01140     if(FALSE==dkcFileExist(filename) || TRUE==rewrite){
01141         fp = fopen(filename,"wb");
01142         if(!fp){
01143             return r;
01144         }
01145         fclose(fp);
01146         r = TRUE;
01147     }
01148     return r;
01149 }
01150 
01151 
01152 int WINAPI dkcFileBinaryCompare(const char *filename1,const char *filename2)
01153 {
01154     BOOL r = FALSE;
01155     
01156     //ファイルの存在を確かめる
01157     r = dkcFileExist(filename1);
01158     if(r==FALSE){
01159         return edk_ArgumentException;
01160     }
01161     r = dkcFileExist(filename2);
01162     if(r==FALSE){
01163         return edk_ArgumentException;
01164     }
01165 
01166     //ファイルのサイズを確かめる
01167     {
01168         DWORD high = 0,low = 0,high2 = 0,low2 = 0;
01169         r = dkcFileSize64(filename1,&high,&low);
01170         if(r==FALSE){
01171             return edk_ArgumentException;
01172         }
01173         r = dkcFileSize64(filename2,&high2,&low2);
01174         if(r==FALSE){
01175             return edk_ArgumentException;
01176         }
01177         r = (high==high2 && low==low2);
01178         if(FALSE==r){//ファイルサイズが違った
01179             return edk_FAILED;
01180         }
01181 
01182     }
01183 
01184 
01185     {
01186         DKC_STREAM *s1 = NULL,*s2=NULL;
01187         BYTE *buffer1 = NULL,*buffer2 = NULL;
01188         size_t buffsize = 1024 * 52;
01189 
01190 
01191         //initialize
01192 
01193         //ファイルをオープン
01194         r = edk_LogicError;
01195 
01196         s1 = dkcAllocStreamFileType( 
01197             edkcStreamDefaultEndian | edkcStreamProcessAsOrdered,
01198             filename1,"rb");
01199         if(NULL==s1){
01200             return edk_LogicError;
01201         }
01202 
01203         s2 = dkcAllocStreamFileType( 
01204             edkcStreamDefaultEndian | edkcStreamProcessAsOrdered,
01205             filename2,"rb");
01206 
01207         if(NULL==s2){
01208             goto Error;
01209         }
01210 
01211         //バッファを用意
01212         r = edk_OutOfMemory;
01213 
01214         buffer1 = malloc(buffsize);
01215         if(NULL==buffer1){
01216             
01217             goto Error;
01218         }
01219         buffer2 = malloc(buffsize);
01220         if(NULL==buffer2){
01221             goto Error;
01222         }
01223 
01224         //process
01225 
01226         for(;;){
01227             size_t readsize1,readsize2;
01228             BOOL re1,re2;
01229 
01230             dkcStreamRead(s1,buffer1,buffsize,&readsize1);
01231             dkcStreamRead(s2,buffer2,buffsize,&readsize2);
01232             
01233             re1 = dkcStreamError(s1);
01234             re2 = dkcStreamError(s2);
01235             if(re1 || re2){
01236                 r = edk_LogicError;
01237                 goto Error;
01238             }
01239 
01240 
01241             dkcmNOT_ASSERT(readsize1 != readsize2);
01242             
01243 
01244             r = dkc_memcmp(buffer1,buffsize,buffer2,buffsize);
01245             if(DKUTIL_FAILED(r)){
01246                 r = edk_FAILED;
01247                 break;
01248             }
01249             re1 = dkcStreamEOF(s1);
01250             re2 = dkcStreamEOF(s2);
01251             if(re1 && re2){
01252                 r = edk_SUCCEEDED;
01253                 break;
01254             }
01255             else if(FALSE==re1 && FALSE==re2)
01256             {
01257                 continue;
01258             }
01259             else
01260             {
01261                 r = edk_LogicError;
01262                 goto Error;
01263             }
01264         }
01265 Error:
01266         if(buffer2){
01267             free(buffer2);
01268         }
01269         if(buffer1){
01270             free(buffer1);
01271         }
01272         dkcFreeStream(&s2);
01273         dkcFreeStream(&s1);
01274     }
01275 
01276     return r;
01277 }
01278 
01279 int WINAPI dkcMemoryToFile(const char *filename,const void *buff,size_t size,UINT flag)
01280 {
01281     BOOL r;
01282     DKC_STREAM *p;
01283     int re = edk_FAILED;
01284     if(!(edkcFileRewrite & flag))
01285     {
01286 
01287         //ファイルの存在を確かめる
01288         r = dkcFileExist(filename);
01289         if(r==TRUE){
01290             return edk_ArgumentException;
01291         }
01292     }
01293     p = dkcAllocStreamFileType( 
01294             edkcStreamDefaultEndian | edkcStreamProcessAsOrdered,
01295             filename,"wb");
01296 
01297     if(NULL==p){
01298         return edk_FAILED;
01299     }
01300     if(DKUTIL_FAILED(dkcStreamWrite(p,buff,size))){
01301         goto End;
01302     }
01303     re = edk_SUCCEEDED;
01304 End:
01305     dkcFreeStream(&p);
01306 
01307     return re;
01308 
01309 }
01310 
01311 
01312 int WINAPI dkcFileToMemory(const char *filename,void *buff,size_t size)
01313 {
01314     DWORD h = 0,l = 0;
01315     DKC_STREAM *p;
01316     int r = edk_FAILED;
01317     if(FALSE==dkcFileSize64(filename,&h,&l)){
01318         return edk_FileNotFound;
01319     }
01320 
01321     if(h != 0 || ( (size_t)(l) > size ))
01322     {//DWORD_MAX以上のサイズのファイルをメモリには読みこめないですよ^^;
01323         return edk_BufferOverFlow;
01324     }
01325 
01326     p = dkcAllocStreamFileType( 
01327             edkcStreamDefaultEndian | edkcStreamProcessAsOrdered,
01328             filename,"rb");
01329 
01330     if(NULL==p){
01331         return edk_FAILED;
01332     }
01333     if(DKUTIL_FAILED(dkcStreamRead(p,buff,l,(size_t *)&h))){
01334         goto End;
01335     }
01336     if(h != l){
01337         goto End;
01338     }
01339     r = edk_SUCCEEDED;
01340 End:
01341     dkcFreeStream(&p);
01342     return r;
01343 }
01344 
01345 /*
01346 int WINAPI dkcMemoryToTextFile(const char *filename,const void *buff,size_t size)
01347 {
01348     
01349     
01350 
01351 }
01352 
01353 size_t WINAPI dkcTextFileToMemorySize(const char *filename)
01354 {
01355 
01356 
01357 }
01358 
01359 int WINAPI dkcTextFileToMemory(const char *filename,void *buff,size_t size)
01360 {
01361 
01362 
01363 }
01364 */
01365 
01366 //**********************************************************
01367 
01368 
01369 #if 0
01370 
01371 DKC_FILE_FINDER * WINAPI dkcAllocFileFinder(
01372             const char *target,const char *dir,BOOL bSubDir
01373             ){
01374 
01375     DKC_FILE_FINDER *p;
01376     p = dkcAllocate(sizeof(DKC_FILE_FINDER));
01377     if(NULL==p) return NULL;
01378 
01379     //ディレクトリ
01380     p->mDir = dkcAllocPathString(dir);//allocate and copy 
01381     if(NULL==p->mDir){
01382         goto Error;
01383     }
01384     //再帰用スタック
01385     p->mStack = dkcAllocStack(10,sizeof(DKC_PATHSTRING *));
01386     if(NULL==p->mStack){
01387         goto Error;
01388     }
01389     //target文字列
01390     p->mTarget = dkcAllocString(128);
01391     if(NULL==p->mTarget){
01392         goto Error;
01393     }
01394     //target文字列をコピー
01395     dkcStringCopy(p->mTarget,target,strlen(target));
01396 
01397     p->mState = edkcFileFinderEmpty;//何もしていない。
01398     p->mbSubDir = bSubDir;//サブdirectoryも検索するかどうか
01399 
01400     return p;
01401 Error:
01402     if(p){
01403         dkcFreeString(&(p->mTarget));
01404         dkcFreeStack(&(p->mStack));
01405         dkcFreePathString(&(p->mDir));
01406     }
01407     dkcFree((void **)&p);
01408     return NULL;
01409 }
01410 
01411 
01412 int WINAPI dkcFreeFileFinder(DKC_FILE_FINDER **p){
01413     if(NULL==p || NULL==(*p)){
01414         return edk_ArgumentException;
01415     }
01416     dkcFreeString(&(*p)->mTarget);
01417     dkcFreeStack(&(*p)->mStack);
01418     dkcFreePathString(&(*p)->mDir);
01419     return dkcFree((void **)p);
01420 }
01421 
01422 static BOOL isDot(DKC_FILE_FINDER *ptr){
01423 
01424 #ifdef WIN32
01425     return (
01426         strcmp(ptr->mFindData.cFileName,"..") == 0 || 
01427         strcmp(ptr->mFindData.cFileName,".") == 0
01428     );
01429 #else
01430     
01431 
01432 #endif
01433 
01434 }
01435 static BOOL isFolder(DKC_FILE_FINDER *ptr){
01436 #ifdef WIN32
01437     return (
01438             ptr->mFindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY
01439             && strcmp(ptr->mFindData.cFileName,"..")!=0 
01440             && strcmp(ptr->mFindData.cFileName,".")!=0
01441             );
01442 #else
01443 
01444 
01445 #endif
01446 }
01447 static int FFPushStack(DKC_FILE_FINDER *p){
01448     DKC_PATHSTRING *tp;
01449     int r;
01450     char buff[dkcdMAXPATH_BUFFER];
01451 
01452 #ifdef WIN32
01453     
01454     dkcCurrentDirectoryConcatenate(buff,sizeof(buff),p->mFindData.cFileName);
01455 #else
01456     dkcCurrentDirectoryConcatenate(buff,sizeof(buff),ptr->mDirent.d_name);
01457 #endif
01458 
01459     tp = dkcAllocPathString(buff);
01460     if(NULL==tp){
01461         return edk_FAILED;
01462     }
01463     r = dkcStackDynamicPush(p->mStack,tp);
01464     return r;
01465 }
01466 
01467 static BOOL FFIsStackEmpty(DKC_FILE_FINDER *p){
01468     return dkcStackIsEmpty(p->mStack);
01469 }
01470 
01471 
01472 static int FFPopStack(DKC_FILE_FINDER *p){
01473     int r;
01474     DKC_PATHSTRING *tp;
01475     r = dkcStackTop(p->mStack,&tp);
01476     if(DKUTIL_FAILED(r)){return r;}
01477 
01478     dkcFreePathString( &(p->mDir));
01479     dkcStackPop(p->mStack);
01480     
01481     p->mDir = tp;
01482     return r;
01483 }
01484 
01485 static void FFReSearch(DKC_FILE_FINDER *p){
01486     dkcFindClose(p);
01487     FFPopStack(p);
01488     p->mState = edkcFileFinderEmpty;
01489     DKUTIL_STRUCTURE_INIT(p->mFindData);
01490 }
01491 /*
01492 static int FFEndSearch(DKC_FILE_FINDER *p){
01493 
01494 }
01495 */
01496 
01498 static int ReflexiveSearch(DKC_FILE_FINDER *p,DKC_PATHSTRING *path,BOOL *bCopySucceeded)
01499 {
01500 
01501 }
01502 /*static int FFCheckingLogic(DKC_FILE_FINDER *p,DKC_PATHSTRING *path,BOOL *bCopySucceeded)
01503 {*/
01504 #define FFCHECKING(p,path,bCopySucceeded)\
01505     if(TRUE==isDot(p))\
01506     {/*こんなのじゃ文字列はいただけないなぁ。*/\
01507         p->mState = edkcFileFinderSearching;\
01508         return WithFolderSearch(p,path,bCopySucceeded);\
01509     }\
01510     if(TRUE==isFolder(p))\
01511     {/*おや?フォルダーだ。*/\
01512         dkcFileFinderReferenceFileName(p,path);\
01513         p->mState = edkcFileFinderSearching;\
01514         FFPushStack(p);/*folderをスタックに詰める。*/\
01515         return WithFolderSearch(p,path,bCopySucceeded);\
01516     }
01517 /*}*/
01518 
01519 static int WithFolderSearch(DKC_FILE_FINDER *p,DKC_PATHSTRING *path,BOOL *bCopySucceeded)
01520 {
01521     int r;
01522 //  DKC_PATHSTRING *pps = NULL;
01523 //  DKC_FILE_FINDER *
01524 
01525     r = 0;
01526     *bCopySucceeded = FALSE;
01527 
01528     if(edkcFileFinderEmpty == p->mState)
01529     {//呼び出して最初だったら、
01530         r = dkcFindFirstFile(p);
01531         if(DKUTIL_FAILED(r)) return edk_FAILED;
01532 #   ifdef WIN32 //windowsの場合は内部に格納している・・・。
01533         if(TRUE==isDot(p))
01534         {//こんなのじゃ文字列はいただけないなぁ。
01535             p->mState = edkcFileFinderSearching;
01536             return WithFolderSearch(p,path,bCopySucceeded);
01537         }
01538         if(TRUE==isFolder(p))
01539         {//おや?フォルダーだ。
01540             dkcFileFinderReferenceFileName(p,path);
01541             p->mState = edkcFileFinderSearching;
01542             FFPushStack(p);//folderをスタックに詰める。
01543             return WithFolderSearch(p,path,bCopySucceeded);
01544         }
01545         //FFCHECKING(p,path,bCopySucceeded)
01546 
01547         r = dkcFileFinderReferenceFileName(p,path);
01548             
01549         if(DKUTIL_SUCCEEDED(r)){//コピーも成功
01550             *bCopySucceeded = TRUE;
01551         }
01552 #   endif
01553         p->mState = edkcFileFinderSearching;
01554         return r;
01555     }else if(edkcFileFinderSearching == p->mState)
01556     {//検索中だったら。
01557         r = dkcFindNextFile(p);
01558         if(edk_SUCCEEDED == r)
01559         {//成功だ。
01560             if(TRUE==isDot(p))
01561             {//こんなのじゃ文字列はいただけないなぁ。
01562                 p->mState = edkcFileFinderSearching;
01563                 return WithFolderSearch(p,path,bCopySucceeded);
01564             }
01565             if(TRUE==isFolder(p))
01566             {//おや?フォルダーだ。
01567                 dkcFileFinderReferenceFileName(p,path);
01568                 p->mState = edkcFileFinderSearching;
01569                 FFPushStack(p);//folderをスタックに詰める。
01570                 return WithFolderSearch(p,path,bCopySucceeded);
01571             }
01572 
01573             r = dkcFileFinderReferenceFileName(p,path);
01574             
01575             if(DKUTIL_SUCCEEDED(r)){//コピーも成功
01576                 *bCopySucceeded = TRUE;
01577             }/*else{//コピー失敗!??
01578                 *bCopySucceeded = FALSE;
01579             }*/
01580         }else if(edk_EndProcess == r)
01581         {//検索が終わった。
01582             if(FALSE==FFIsStackEmpty(p))
01583             {//空ではない。
01584                 FFReSearch(p);
01585                 return WithFolderSearch(p,path,bCopySucceeded);
01586             }else{
01587                 dkcFindClose(p);//終了ナリ。(内部でp->mState = edkcFileFinderFinish;をやっている。
01588             }
01589         }else{
01590             dkcmNOT_ASSERT("そんなばかな〜");
01591         }
01592         return r;
01593     }else if(edkcFileFinderFinish == p->mState)
01594     {
01595         return edk_EndProcess;
01596     }
01597     dkcmNOT_ASSERT("dkcFileFinderNextのプログラムがおかしい。チートされているかも!?");
01598     return edk_FAILED;
01599 
01600 }
01601 
01602 
01603 static int NormalSearch(DKC_FILE_FINDER *p,DKC_PATHSTRING *path,BOOL *bCopySucceeded)
01604 {
01605     int r;
01606     r = 0;
01607     *bCopySucceeded = FALSE;
01608 
01609     if(edkcFileFinderEmpty == p->mState)
01610     {//呼び出して最初だったら、
01611         r = dkcFindFirstFile(p);
01612         if(DKUTIL_FAILED(r)) return edk_FAILED;
01613 #   ifdef WIN32 //windowsの場合は内部に格納している・・・。
01614         if(TRUE==isDot(p) || TRUE==isFolder(p))
01615         {//こんなのじゃ文字列はいただけないなぁ。
01616             p->mState = edkcFileFinderSearching;
01617             return NormalSearch(p,path,bCopySucceeded);
01618         }
01619         r = dkcFileFinderReferenceFileName(p,path);
01620             
01621         if(DKUTIL_SUCCEEDED(r)){//コピーも成功
01622             *bCopySucceeded = TRUE;
01623         }
01624 #   endif
01625         p->mState = edkcFileFinderSearching;
01626         return r;
01627     }else if(edkcFileFinderSearching == p->mState)
01628     {//検索中だったら。
01629         r = dkcFindNextFile(p);
01630         if(edk_SUCCEEDED == r)
01631         {//成功だ。
01632             if(TRUE==isDot(p) || TRUE==isFolder(p))
01633             {//こんなのじゃ文字列はいただけないなぁ。
01634 
01635 
01636 
01637                 //p->mState = edkcFileFinderSearching;
01638                 return NormalSearch(p,path,bCopySucceeded);
01639             }
01640             r = dkcFileFinderReferenceFileName(p,path);
01641             
01642             if(DKUTIL_SUCCEEDED(r)){//コピーも成功
01643                 *bCopySucceeded = TRUE;
01644             }/*else{//コピー失敗!??
01645                 *bCopySucceeded = FALSE;
01646             }*/
01647         }else if(edk_EndProcess == r)
01648         {//検索が終わった。
01649             dkcFindClose(p);//終了ナリ。(内部でp->mState = edkcFileFinderFinish;をやっている。
01650         }else{
01651             dkcmNOT_ASSERT("そんなばかな〜");
01652         }
01653         return r;
01654     }else if(edkcFileFinderFinish == p->mState)
01655     {
01656         return edk_EndProcess;
01657     }/*else{
01658         return edk_FAILED;
01659     }*/
01660     dkcmNOT_ASSERT("dkcFileFinderNextのプログラムがおかしい。チートされているかも!?");
01661     return edk_FAILED;
01662 
01663 }
01664 
01670 int WINAPI dkcFileFinderNext(DKC_FILE_FINDER *p,DKC_PATHSTRING *path,BOOL *bCopySucceeded)
01671 {
01672     if(FALSE==p->mbSubDir){
01673         return NormalSearch(p,path,bCopySucceeded);
01674     }else{//sub directoryも検索
01675         return WithFolderSearch(p,path,bCopySucceeded);
01676     }
01677     //return ReflexiveSearch(p,path,bCopySucceeded);
01678 }
01679 #endif
01680 
01681 DKC_FINDFILE *WINAPI dkcAllocFindFile()
01682 {
01683     DKC_FINDFILE *p;
01684     p = (DKC_FINDFILE *)dkcAllocate(sizeof(DKC_FINDFILE));
01685     return p;
01686 }
01687 int WINAPI dkcFreeFindFile(DKC_FINDFILE **ptr){
01688     if(NULL==ptr /*|| *ptr==NULL*/){
01689         return edk_FAILED;
01690     }
01691     return dkcFree((void **)ptr);
01692 }
01693 
01694 
01695 int WINAPI dkcFindFirstFile(DKC_FINDFILE *ptr,const char *target){
01696 #ifdef WIN32
01697     ptr->mHandle = 
01698         FindFirstFileA( target, &(ptr->mFindData) );
01699     if(ptr->mHandle == INVALID_HANDLE_VALUE){
01700         return edk_FAILED;
01701     }
01702 #else
01703     ptr->mHandle = opendir( target );
01704     if(NULL==ptr->mHandle){
01705         return edk_FAILED;
01706     }
01707 
01708 #endif
01709     return edk_SUCCEEDED;
01710 }
01711 
01712 int WINAPI dkcFindNextFile(DKC_FINDFILE *ptr){
01713 #   ifdef WIN32
01714     if ( 0 == FindNextFileA( ptr->mHandle, &(ptr->mFindData) ))
01715     {
01716         if ( GetLastError() == ERROR_NO_MORE_FILES )
01717         {//なんだ、もう無いじゃん。
01718             return edk_EndProcess;
01719         }
01720         else//最悪のパターン
01721         {
01722             return edk_FAILED;
01723         }
01724     }
01725 #   else
01726   errno = 0;
01727     ptr->mDirent = readdir( ptr->mHandle );
01728   if ( ptr->mDirent == 0 )
01729   {
01730     if ( errno == 0 )
01731     {//もう無いよ^^;
01732             return edk_EndProcess;
01733     }
01734         else//最悪のパターン
01735         {
01736             return edk_FAILED;
01737         }
01738   }
01739 #   endif
01740     return edk_SUCCEEDED;
01741 }
01742 
01743 int WINAPI dkcFindClose(DKC_FINDFILE *ptr)
01744 {
01745 #ifdef WIN32
01746     if(INVALID_HANDLE_VALUE == ptr->mHandle){
01747         return edk_FAILED;
01748     }
01749     FindClose(ptr->mHandle);
01750     ptr->mHandle = INVALID_HANDLE_VALUE;//しっかりリセット
01751 #else
01752     if(0 == ptr->mHandle){
01753         return edk_FAILED;
01754     }
01755     closedir(ptr->mHandle);
01756     ptr->mHandle = 0;//しっかりリセット
01757     ptr->mDirent = NULL;
01758 #endif
01759 
01760     return edk_SUCCEEDED;
01761 
01762 }
01763 
01764 int WINAPI dkcFindFileGetFileName(DKC_FINDFILE *ptr,char *buff,size_t buffsize)
01765 {
01766     int r;
01767     size_t len;
01768 #ifdef WIN32
01769     len = strlen(ptr->mFindData.cFileName);
01770     if(0 == len) return edk_FAILED;
01771     r = dkc_strcpy(buff,buffsize,ptr->mFindData.cFileName,len);
01772 #else
01773     if(NULL==ptr->mDirent)
01774     {//呼び出しが間違っているよ^^;
01775         return edk_LogicError;
01776     }
01777     len = strlen(ptr->mDirent.d_name);
01778     if(0 == len) return edk_FAILED;
01779     r = dkc_strcpy(buff,buffsize,ptr->mDirent.d_name,len);
01780 #endif
01781     return r;
01782 }
01783 
01784 BOOL WINAPI dkcFindFileIsFolder(DKC_FINDFILE *ptr){
01785 
01786 
01787 #ifdef WIN32
01788     return (
01789             ptr->mFindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY
01790             && strcmp(ptr->mFindData.cFileName,"..")!=0 
01791             && strcmp(ptr->mFindData.cFileName,".")!=0
01792             );
01793 #else
01794 
01795 
01796 #endif
01797 }
01798 
01799 
01800 BOOL WINAPI dkcFindFileIsDot(DKC_FINDFILE *ptr){
01801 #ifdef WIN32
01802     return (
01803         strcmp(ptr->mFindData.cFileName,"..") == 0 || 
01804         strcmp(ptr->mFindData.cFileName,".") == 0
01805     );
01806 #else
01807     
01808 
01809 #endif
01810 }
01811 
01812 BOOL WINAPI dkcFindFileIsNormalFile(DKC_FINDFILE *ptr)
01813 {
01814 #ifdef WIN32
01815     return (ptr->mFindData.dwFileAttributes & FILE_ATTRIBUTE_NORMAL);
01816 #else
01817 
01818 #endif
01819 }
01820 
01821 BOOL WINAPI dkcFindFileIsReadOnly(DKC_FINDFILE *ptr){
01822 #ifdef WIN32
01823     return (ptr->mFindData.dwFileAttributes & FILE_ATTRIBUTE_READONLY);
01824 #else
01825 
01826 #endif
01827 }
01828 void WINAPI dkcFindFileSize(DKC_FINDFILE *ptr,ULONG *High,ULONG *Low){
01829 #ifdef WIN32
01830     *High = ptr->mFindData.nFileSizeHigh;
01831     *Low = ptr->mFindData.nFileSizeLow;
01832 #else
01833 
01834 #endif
01835 
01836 }
01837 /*
01838 int WINAPI dkcFindFirstFile(DKC_FILE_FINDER *ptr){
01839 
01840 #ifdef WIN32
01841     ptr->mHandle = 
01842         FindFirstFileA( dkcPathStringPointer(ptr->mDir), &(ptr->mFindData) );
01843     if(ptr->mHandle == INVALID_HANDLE_VALUE){
01844         return edk_FAILED;
01845     }
01846 #else
01847     ptr->mHandle = opendir( dkcPathStringPointer(ptr->mDir) );
01848     if(NULL==ptr->mHandle){
01849         return edk_FAILED;
01850     }
01851 
01852 #endif
01853     return edk_SUCCEEDED;
01854 }
01855 
01856 int WINAPI dkcFindNextFile(DKC_FILE_FINDER *ptr)
01857 {
01858     if(edkcFileFinderFinish == ptr->mState){
01859         return edk_LogicError;//呼び出しが間違っているナリ!
01860     }
01861 #   ifdef WIN32
01862     if ( 0 == FindNextFileA( ptr->mHandle, &(ptr->mFindData) ))
01863     {
01864         if ( GetLastError() == ERROR_NO_MORE_FILES )
01865         {//なんだ、もう無いじゃん。
01866             return edk_EndProcess;
01867         }
01868         else//最悪のパターン
01869         {
01870             return edk_FAILED;
01871         }
01872     }
01873 #   else
01874   errno = 0;
01875     ptr->mDirent = readdir( ptr->mHandle );
01876   if ( ptr->mDirent == 0 )
01877   {
01878     if ( errno == 0 )
01879     {//もう無いよ^^;
01880             return edk_EndProcess;
01881     }
01882         else//最悪のパターン
01883         {
01884             return edk_FAILED;
01885         }
01886   }
01887 #   endif
01888     return edk_SUCCEEDED;
01889 }
01890 
01891 int WINAPI dkcFindClose(DKC_FILE_FINDER *ptr){
01892 #ifdef WIN32
01893     if(INVALID_HANDLE_VALUE == ptr->mHandle){
01894         return edk_FAILED;
01895     }
01896     FindClose(ptr->mHandle);
01897     ptr->mHandle = INVALID_HANDLE_VALUE;//しっかりリセット
01898 #else
01899     if(0 == ptr->mHandle){
01900         return edk_FAILED;
01901     }
01902     closedir(ptr->mHandle);
01903     ptr->mHandle = 0;//しっかりリセット
01904     ptr->mDirent = NULL;
01905 #endif
01906     //終了!!
01907     ptr->mState = edkcFileFinderFinish;
01908 
01909     return edk_SUCCEEDED;
01910 }
01911 
01912 
01913 int WINAPI dkcFileFinderReferenceFileName(DKC_FILE_FINDER *ptr,DKC_PATHSTRING *path)
01914 {
01915     int r;
01916     size_t len;
01917 #ifdef WIN32
01918     len = strlen(ptr->mFindData.cFileName);
01919     if(0 == len) return edk_FAILED;
01920     r = dkcPathStringCopy(path,ptr->mFindData.cFileName,len);
01921 #else
01922     if(NULL==ptr->mDirent)
01923     {//呼び出しが間違っているよ^^;
01924         return edk_LogicError;
01925     }
01926     len = strlen(ptr->mDirent.d_name);
01927     if(0 == len) return edk_FAILED;
01928     r = dkcPathStringCopy(path,ptr->mDirent.d_name,len);
01929 #endif
01930     return r;
01931 }
01932 */

dkutil_cに対してMon Jan 16 00:39:52 2006に生成されました。  doxygen 1.4.4