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

dkcSJISFileSystem.h

ShiftJISを考慮したファイルシステム. [詳細]

#include "dkcOSIndependent.h"
#include "dkcMemoryStream.h"
#include "dkcString.h"
#include "dkcStack.h"
#include "dirent.h"
#include "unistd.h"
#include "fcntl.h"
#include "utime.h"

dkcSJISFileSystem.hのインクルード依存関係図

Include dependency graph

このグラフは、どのファイルから直接、間接的にインクルードされているかを示しています。

Included by dependency graph

ソースコードを見る。

構成

struct  dkc_PathString
struct  dkc_FileFinder
 Fileを検索するための機構の状態を保存する構造体. [詳細]

struct  dkc_FindFile

型定義

typedef dkc_PathString DKC_PATHSTRING
typedef dkc_FileFinder DKC_FILE_FINDER
 Fileを検索するための機構の状態を保存する構造体.

typedef dkc_FindFile DKC_FINDFILE

関数

DKC_EXTERN char *WINAPI dkcGetFileExtension (const char *PathName)
 パス名から、拡張子の開始位置を取得する ファイル名の末尾からファイル名の最後の '.' までを、拡張子と判断する

DKC_EXTERN int WINAPI dkcIsShiftJIS (const char *str, int nPos)
DKC_EXTERN BOOL WINAPI dkcIsEffectivePath (const char *path, size_t size)
DKC_EXTERN BOOL WINAPI dkcIsRelativityPath (const char *path)
DKC_EXTERN BOOL WINAPI dkcIsAbsolutelyPath (const char *path)
DKC_EXTERN int WINAPI dkcCurrentDirectoryConcatenate (char *dest, size_t dsize, const char *src)
DKC_EXTERN int WINAPI dkcDirectoryConcatenate (char *dest, size_t dlen, size_t dsize, const char *src)
DKC_EXTERN BOOL WINAPI dkcIsTailPathSep (const char *src, size_t dlen)
 srcの一番後ろににがついていたらTRUE

DKC_EXTERN BOOL WINAPI dkcPushBackPathSep (char *dest, size_t dlen, size_t size)
 path separatorを挿入する必要があり、挿入出来たらTRUE

DKC_EXTERN int WINAPI dkcToAbsolutelyPath (char *dest, size_t dsize, const char *src, size_t ssize)
 パスを正規化(相対パスから絶対パス)する関数

DKC_EXTERN DKC_PATHSTRING
*WINAPI 
dkcAllocPathString (const char *path)
DKC_EXTERN int WINAPI dkcFreePathString (DKC_PATHSTRING **)
DKC_EXTERN size_t WINAPI dkcPathStringSize (const DKC_PATHSTRING *)
DKC_EXTERN const char *WINAPI dkcPathStringPointer (const DKC_PATHSTRING *)
DKC_EXTERN int WINAPI dkcPathStringDevideBegin (DKC_PATHSTRING *, char *buff, size_t size)
DKC_EXTERN int WINAPI dkcPathStringDevideNext (DKC_PATHSTRING *, char *buff, size_t size)
DKC_EXTERN void WINAPI dkcPathStringDevideEnd (DKC_PATHSTRING *)
DKC_EXTERN int WINAPI dkcPathStringCopy (DKC_PATHSTRING *, const char *buff, size_t size)
 パスを正規化して入れる。

DKC_EXTERN int WINAPI dkcPathStringConcatenate (DKC_PATHSTRING *, const char *buff, size_t size)
 パスを正規化して繋げる。

DKC_EXTERN int WINAPI dkcPathStringNormalizeConcatenateLogic (DKC_PATHSTRING *ptr, const char *buff, size_t size)
DKC_EXTERN int WINAPI dkcPathStringGetDrive (DKC_PATHSTRING *, char *buff, size_t size)
DKC_EXTERN int WINAPI dkcPathStringGetFileExtension (DKC_PATHSTRING *, char *buff, size_t size)
DKC_EXTERN int WINAPI dkcPathStringGetFileName (DKC_PATHSTRING *, char *buff, size_t size)
DKC_EXTERN int WINAPI dkcPathStringGetDirectory (DKC_PATHSTRING *, char *buff, size_t size)
DKC_EXTERN int WINAPI dkcPathStringDevideBegin_Logic (DKC_PATHSTRING *, size_t *count, char *buff, size_t size)
 dkcPathStringDevideBegin()

DKC_EXTERN int WINAPI dkcPathStringDevideNext_Logic (DKC_PATHSTRING *, size_t *count, char *buff, size_t size)
 dkcPathStringDevideNext()

DKC_EXTERN void WINAPI dkcPathStringDevideEnd_Logic (size_t *count)
 dkcPathStringDevideEnd()

DKC_EXTERN int WINAPI dkcPathStringElementInsert_Logic (DKC_PATHSTRING *, size_t count, const char *src, size_t len)
 パスの要素を挿入する。(正規化はしない lenは文字数

DKC_EXTERN int WINAPI dkcPathStringElementErase_Logic (DKC_PATHSTRING *, size_t count)
DKC_EXTERN int WINAPI dkcPathStringElementReplace_Logic (DKC_PATHSTRING *, size_t count, const char *, size_t len)
 パスの要素を置換する。(正規化はしない lenは文字数

DKC_EXTERN BOOL WINAPI dkcSetCurrentDirectory (const char *filename)
DKC_EXTERN BOOL WINAPI dkcGetCurrentDirectory (char *buff, size_t size)
DKC_EXTERN int WINAPI dkcCreateDirectory (const char *pPath)
DKC_EXTERN BOOL WINAPI dkcFileCopy (const char *dest, const char *src)
DKC_EXTERN BOOL WINAPI dkcFileCopyEx (const char *dest, const char *src, size_t inner_buffer_size, BOOL bThreadLock)
DKC_EXTERN BOOL WINAPI dkcFileRemove (const char *filename)
DKC_EXTERN BOOL WINAPI dkcFileRename (const char *oldname, const char *newname)
DKC_EXTERN BOOL WINAPI dkcFileExist (const char *filename)
DKC_EXTERN ULONG WINAPI dkcFileSize (const char *filename)
DKC_EXTERN BOOL WINAPI dkcFileSize64 (const char *filename, DWORD *high, DWORD *low)
DKC_EXTERN BOOL WINAPI dkcCreateZeroByteFile (const char *filename, BOOL rewrite)
DKC_EXTERN int WINAPI dkcFileBinaryCompare (const char *filename1, const char *filename2)
DKC_EXTERN int WINAPI dkcMemoryToFile (const char *filename, const void *buff, size_t size, UINT flag)
 buffの内容をfilenameファイルに書きこむ

DKC_EXTERN int WINAPI dkcFileToMemory (const char *filename, void *buff, size_t size)
 filenameの内容をbuffに読みこむ

DKC_EXTERN DKC_FINDFILE *WINAPI dkcAllocFindFile ()
DKC_EXTERN int WINAPI dkcFreeFindFile (DKC_FINDFILE **)
DKC_EXTERN int WINAPI dkcFindFirstFile (DKC_FINDFILE *ptr, const char *target)
DKC_EXTERN int WINAPI dkcFindNextFile (DKC_FINDFILE *ptr)
DKC_EXTERN int WINAPI dkcFindClose (DKC_FINDFILE *ptr)
DKC_EXTERN int WINAPI dkcFindFileGetFileName (DKC_FINDFILE *ptr, char *buff, size_t buffsize)
DKC_EXTERN BOOL WINAPI dkcFindFileIsFolder (DKC_FINDFILE *ptr)
DKC_EXTERN BOOL WINAPI dkcFindFileIsDot (DKC_FINDFILE *ptr)
DKC_EXTERN BOOL WINAPI dkcFindFileIsNormalFile (DKC_FINDFILE *ptr)
DKC_EXTERN BOOL WINAPI dkcFindFileIsReadOnly (DKC_FINDFILE *ptr)
DKC_EXTERN void WINAPI dkcFindFileSize (DKC_FINDFILE *ptr, ULONG *, ULONG *)


説明

ShiftJISを考慮したファイルシステム.

作者:
d金魚
覚え書き:
Licence is "BSD Licence"
dkc_PathStringはパスを相対パスでも必ず絶対パスにして格納します。
dkc_FileFinderはSJIS問題に対応しています。(多分^^;;)

dkcSJISFileSystem.h で定義されています。


型定義

typedef struct dkc_FileFinder DKC_FILE_FINDER
 

Fileを検索するための機構の状態を保存する構造体.

typedef struct dkc_FindFile DKC_FINDFILE
 

参照元 dkcAllocFindFile(), dkcFindClose(), dkcFindFileGetFileName(), dkcFindFileIsDot(), dkcFindFileIsFolder(), dkcFindFileIsNormalFile(), dkcFindFileIsReadOnly(), dkcFindFileSize(), dkcFindFirstFile(), dkcFindNextFile(), と dkcFreeFindFile().

typedef struct dkc_PathString DKC_PATHSTRING
 

覚え書き:
仕様: mStringにディレクトリを入れる。 内部で必ず絶対パスに変換してからmStringに入れる。

TODO:
Releaseモード時にバグってしまう問題をどうにかする。

参照元 dkcAllocPathString(), dkcFreePathString(), dkcPathStringConcatenate(), dkcPathStringCopy(), dkcPathStringDevideBegin(), dkcPathStringDevideBegin_Logic(), dkcPathStringDevideEnd(), dkcPathStringDevideNext(), dkcPathStringDevideNext_Logic(), dkcPathStringElementErase_Logic(), dkcPathStringElementInsert_Logic(), dkcPathStringElementReplace_Logic(), dkcPathStringGetDirectory(), dkcPathStringGetDrive(), dkcPathStringGetFileExtension(), dkcPathStringGetFileName(), dkcPathStringNormalizeConcatenateLogic(), dkcPathStringNormalizeCopyLogic(), dkcPathStringPointer(), と dkcPathStringSize().


関数

DKC_EXTERN DKC_FINDFILE* WINAPI dkcAllocFindFile  ) 
 

dkcSJISFileSystem.c1620 行で定義されています。

参照先 DKC_FINDFILE, と dkcAllocate().

01621 {
01622     DKC_FINDFILE *p;
01623     p = (DKC_FINDFILE *)dkcAllocate(sizeof(DKC_FINDFILE));
01624     return p;
01625 }

DKC_EXTERN DKC_PATHSTRING* WINAPI dkcAllocPathString const char *  path  ) 
 

引数:
path[in] ファイル、ディレクトリへのパスを入れる。
戻り値:
無効な文字列が使われていたり、上手く割り当て出来なかったらNULL
覚え書き:
パスが相対パスだった場合、内部で勝手に絶対パスに変換される。

dkcSJISFileSystem.c327 行で定義されています。

参照先 DKC_PATHSTRING, dkcAllocate(), dkcAllocString(), dkcdMAXPATH_BUFFER, dkcFree(), dkcFreeString(), dkcIsNativePathString(), dkcPathStringCopy(), FALSE, dkc_PathString::mIterateCount, dkc_PathString::mString, と NULL.

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 }

DKC_EXTERN int WINAPI dkcCreateDirectory const char *  pPath  ) 
 

覚え書き:
Thread safe ではありません。(多分safeでなくても大丈夫だと思いますが。

dkcSJISFileSystem.c828 行で定義されています。

参照先 BOOL, dkcCreateDirectoryLogic(), dkcdMAXPATH_BUFFER, dkcdMAXPATH_LEN, dkcdPATH_SEP, dkcmIS_INVALID_FOLDERNAME_CHAR, dkcmIS_PATH_SEP, dkcmIsSJIS1, dkcmIsSJIS2, dkcmNOT_ASSERT, dkcmNOT_ASSERT_MESSAGE, FALSE, と NULL.

00829 {
00830     BOOL result;
00831     char work[dkcdMAXPATH_BUFFER];
00832     unsigned long n = 0;
00833     unsigned long len = strlen(pPath);
00834 
00835 #ifdef WIN32//sjis support
00836     SECURITY_ATTRIBUTES attr;
00837     
00838     DKUTIL_STRUCTURE_INIT(attr);
00839     NULL_CHAR_ARRAY(work);
00840 
00841     //error check
00842     if(dkcdMAXPATH_LEN < len){
00843         dkcmNOT_ASSERT_MESSAGE("pathが長すぎる。",pPath);
00844         return edk_FAILED;
00845     }
00846     if(0==len ){
00847         return edk_ArgumentException;
00848     }
00849 
00850     //まずは一つ目を撃破
00851     if ( dkcmIsSJIS1(pPath[n]) || ! dkcmIS_INVALID_FOLDERNAME_CHAR(pPath[n]) )
00852     {//SJISの1文字目かINVALIDな値では無かったら。
00853         work[n] = pPath[n];
00854         if(1==len){
00855             //フォルダ作成
00856             attr.nLength = sizeof(SECURITY_ATTRIBUTES);
00857             attr.lpSecurityDescriptor = NULL;
00858             attr.bInheritHandle = FALSE;
00859 
00860             result = dkcCreateDirectoryLogic( work, &attr );
00861             
00862             dkcmNOT_ASSERT(FALSE==result && "directoryを作れなかった" );
00863             return edk_SUCCEEDED;
00864         }
00865     }
00866     n++;
00867     //二つ目から開始
00868     while ( n < len )
00869     {
00870          //フォルダ名取得
00871         while ( n < len )
00872         {
00873             
00874             if(! dkcmIsSJIS1(pPath[n - 1]) && ! dkcmIsSJIS2(pPath[n]) )
00875             {//SJISではない!!
00876                 if ( ( dkcmIS_PATH_SEP(pPath[n]) ) /*&& pPath[n] != '\0'*//*(n != '\0')*/ )
00877                 {
00878                     if ( work[n-1] != ':' )
00879                     {//driveを読み込ませたくないらしい。
00880                         break;
00881                     }
00882                 }
00883                 else if(dkcmIS_INVALID_FOLDERNAME_CHAR(pPath[n]))
00884                 {//SJIS問題をクリアしたのに間違いだった
00885                     return edk_FAILED;
00886                 }
00887             }
00888             
00889             work[n] = pPath[n];
00890             n++;
00891         }
00892         work[n] = '\0';
00893 
00894         //フォルダ作成
00895         attr.nLength = sizeof(SECURITY_ATTRIBUTES);
00896         attr.lpSecurityDescriptor = NULL;
00897         attr.bInheritHandle = FALSE;
00898 
00899         result = dkcCreateDirectoryLogic( work, &attr );
00900         
00901         //dkcmNOT_ASSERT("directoryを作れなかった" && FALSE==result);
00902         if(FALSE==result){
00903             return edk_FAILED;
00904         }
00905         work[n++] = dkcdPATH_SEP;
00906     }
00907 #else //no support sjis
00908     NULL_CHAR_ARRAY(work);
00909     
00910         //error check
00911     if(dkcdMAXPATH_LEN < len){
00912         dkcmNOT_ASSERT_MESSAGE("pathが長すぎる。",pPath);
00913         return edk_FAILED;
00914     }
00915     if(0==len ){
00916         return edk_ArgumentException;
00917     }
00918 
00919     while ( n < len )
00920     {
00921          //フォルダ名取得
00922         while ( n < len )
00923         {
00924             if ( ( dkcmIS_PATH_SEP(pPath[n]) ) && (n != '\0') )
00925             {
00926                 if ( work[n-1] != ':' )//Linuxのドライブのパスはコレデいいのかな?
00927                 {
00928                     break;
00929                 }
00930             }
00931             work[n] = pPath[n];
00932             n++;
00933         }
00934         work[n] = '\0';
00935 
00936         result = dkcCreateDirectoryLogic( work,NULL );
00937 
00938         //dkcmNOT_ASSERT("directoryを作れなかった" && FALSE==result);
00939         if(FALSE==result){
00940             return edk_FAILED;
00941         }
00942         work[n++] = dkcdPATH_SEP;
00943     }
00944 
00945 #endif
00946 
00947     return edk_SUCCEEDED;
00948 }

DKC_EXTERN BOOL WINAPI dkcCreateZeroByteFile const char *  filename,
BOOL  rewrite
 

引数:
filename[in] ファイル名
rewrite[in] 上書き保存を許可するかどうか? zerobyteのファイルを作る

dkcSJISFileSystem.c1075 行で定義されています。

参照先 BOOL, dkcFileExist(), FALSE, と TRUE.

01076 {
01077     FILE *fp;
01078     int r = FALSE;
01079     if(FALSE==dkcFileExist(filename) || TRUE==rewrite){
01080         fp = fopen(filename,"wb");
01081         if(!fp){
01082             return r;
01083         }
01084         fclose(fp);
01085         r = TRUE;
01086     }
01087     return r;
01088 }

DKC_EXTERN int WINAPI dkcCurrentDirectoryConcatenate char *  dest,
size_t  dsize,
const char *  src
 

引数:
dest[out] バッファへのポインタ
dsize[in] destのサイズ
src[in] ファイルの文字列 無条件でsrcに入れた文字列をカレントディレクトリ+srcとしてdestに出力する。
覚え書き:
dsizeがdkcdMAXPATH_LEN以下だと失敗する。
戻り値:
edk_SUCCEEDEDで成功

dkcSJISFileSystem.c169 行で定義されています。

参照先 dkcDirectoryConcatenate(), dkcdMAXPATH_LEN, dkcGetCurrentDirectory(), と dkcmNOT_ASSERT.

参照元 dkcToAbsolutelyPath().

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 }

DKC_EXTERN int WINAPI dkcDirectoryConcatenate char *  dest,
size_t  dlen,
size_t  dsize,
const char *  src
 

引数:
dest[in] カレントディレクトリの文字列が入っているバッファへのポインタ
dlen[in] destの文字数
dsize[in] destのサイズ
src[in] 元文字列
戻り値:
dlen + 2 > dsizeだとバッファオーバーフローする可能性があるので失敗する。

dkcSJISFileSystem.c147 行で定義されています。

参照先 dkc_strcat_amap(), dkcmNOT_ASSERT, と dkcPushBackPathSep().

参照元 dkcCurrentDirectoryConcatenate().

00147                                                                                        {
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 }

DKC_EXTERN int WINAPI dkcFileBinaryCompare const char *  filename1,
const char *  filename2
 

引数:
filename1[in] 比較したいファイル名(フルパスが望ましい)
filename2[in] 比較したいファイル名(フルパスが望ましい) バイナリレベルで一致したらedk_SUCCEEDED edk_FAILEDで一致しない その他は 引数などの呼び出し側のエラー

dkcSJISFileSystem.c1091 行で定義されています。

参照先 BOOL, BYTE, dkc_memcmp(), DKC_STREAM, dkcAllocStreamFileType(), dkcFileExist(), dkcFileSize64(), dkcFreeStream(), dkcmNOT_ASSERT, dkcStreamEOF(), dkcStreamError(), dkcStreamRead(), DWORD, edkcStreamDefaultEndian, edkcStreamProcessAsOrdered, FALSE, と NULL.

01092 {
01093     BOOL r = FALSE;
01094     
01095     //ファイルの存在を確かめる
01096     r = dkcFileExist(filename1);
01097     if(r==FALSE){
01098         return edk_ArgumentException;
01099     }
01100     r = dkcFileExist(filename2);
01101     if(r==FALSE){
01102         return edk_ArgumentException;
01103     }
01104 
01105     //ファイルのサイズを確かめる
01106     {
01107         DWORD high,low,high2,low2;
01108         r = dkcFileSize64(filename1,&high,&low);
01109         if(r==FALSE){
01110             return edk_ArgumentException;
01111         }
01112         r = dkcFileSize64(filename2,&high2,&low2);
01113         if(r==FALSE){
01114             return edk_ArgumentException;
01115         }
01116         r = (high==high2 && low==low2);
01117         if(FALSE==r){//ファイルサイズが違った
01118             return edk_FAILED;
01119         }
01120 
01121     }
01122 
01123 
01124     {
01125         DKC_STREAM *s1 = NULL,*s2=NULL;
01126         BYTE *buffer1 = NULL,*buffer2 = NULL;
01127         size_t buffsize = 1024 * 52;
01128 
01129 
01130         //initialize
01131 
01132         //ファイルをオープン
01133         r = edk_LogicError;
01134 
01135         s1 = dkcAllocStreamFileType( 
01136             edkcStreamDefaultEndian | edkcStreamProcessAsOrdered,
01137             filename1,"rb");
01138         if(NULL==s1){
01139             return edk_LogicError;
01140         }
01141 
01142         s2 = dkcAllocStreamFileType( 
01143             edkcStreamDefaultEndian | edkcStreamProcessAsOrdered,
01144             filename2,"rb");
01145 
01146         if(NULL==s2){
01147             goto Error;
01148         }
01149 
01150         //バッファを用意
01151         r = edk_OutOfMemory;
01152 
01153         buffer1 = malloc(buffsize);
01154         if(NULL==buffer1){
01155             
01156             goto Error;
01157         }
01158         buffer2 = malloc(buffsize);
01159         if(NULL==buffer2){
01160             goto Error;
01161         }
01162 
01163         //process
01164 
01165         for(;;){
01166             size_t readsize1,readsize2;
01167             BOOL re1,re2;
01168 
01169             dkcStreamRead(s1,buffer1,buffsize,&readsize1);
01170             dkcStreamRead(s2,buffer2,buffsize,&readsize2);
01171             
01172             re1 = dkcStreamError(s1);
01173             re2 = dkcStreamError(s2);
01174             if(re1 || re2){
01175                 r = edk_LogicError;
01176                 goto Error;
01177             }
01178 
01179 
01180             dkcmNOT_ASSERT(readsize1 != readsize2);
01181             
01182 
01183             r = dkc_memcmp(buffer1,buffsize,buffer2,buffsize);
01184             if(DKUTIL_FAILED(r)){
01185                 r = edk_FAILED;
01186                 break;
01187             }
01188             re1 = dkcStreamEOF(s1);
01189             re2 = dkcStreamEOF(s2);
01190             if(re1 && re2){
01191                 r = edk_SUCCEEDED;
01192                 break;
01193             }
01194             else if(FALSE==re1 && FALSE==re2)
01195             {
01196                 continue;
01197             }
01198             else
01199             {
01200                 r = edk_LogicError;
01201                 goto Error;
01202             }
01203         }
01204 Error:
01205         if(buffer2){
01206             free(buffer2);
01207         }
01208         if(buffer1){
01209             free(buffer1);
01210         }
01211         dkcFreeStream(&s2);
01212         dkcFreeStream(&s1);
01213     }
01214 
01215     return r;
01216 }

DKC_EXTERN BOOL WINAPI dkcFileCopy const char *  dest,
const char *  src
 

覚え書き:
thread safe ではありません。(気になる方はdkcFileCopyExをお使いください。) 何故ならコピーするファイルがデカいと処理が止まったままになってしまうからです。

dkcSJISFileSystem.c950 行で定義されています。

参照先 BOOL, dkcFileCopyEx(), と FALSE.

00950                                                          {
00951     return dkcFileCopyEx(dest,src,1024 * 64,FALSE);
00952 }

DKC_EXTERN BOOL WINAPI dkcFileCopyEx const char *  dest,
const char *  src,
size_t  inner_buffer_size,
BOOL  bThreadLock
 

引数:
inner_buffer_size[in] 内部のコピーで使うバッファのサイズを設定する。
bThreadLock[in] TRUEだとスレッドをロックする。(大きいファイルの場合は危険)
戻り値:
TRUEだと成功

TODO:
HDのサイズ等を取得してコピーするのが安全かどうかを調べなければならない。 スレッド生成してすぐに処理を返すとか? スレッドをロックするオプションは廃止する。

dkcSJISFileSystem.c954 行で定義されています。

参照先 BOOL, dkcAllocThreadLock(), dkcCreateEmptyFile(), dkcFClose(), dkcFileSize(), dkcFOpen(), dkcFreeThreadLock(), dkcLoadBinary(), dkcmFORCE_NOT_ASSERT, dkcSaveBinary(), dkcThreadLock_Lock(), dkcThreadLock_Unlock(), FALSE, NULL, ODS, と TRUE.

参照元 dkcFileCopy().

00956 {
00957     void *buff;
00958     FILE *srcf,*destf;
00959     size_t filesize;//ファイルサイズ
00960     size_t readed;//読み込んだデータ
00961     size_t count;//count
00962     size_t i;
00963     size_t rest;//残り
00964     int result = FALSE;//戻り値
00965     DKC_THREAD_LOCK *lock = NULL;
00966 
00967 
00968     if(NULL==dest || NULL==src){
00969         return FALSE;
00970     }
00971     if(inner_buffer_size <= 1024){
00972         inner_buffer_size = 1024;
00973     }
00974 
00975     //バッファの準備
00976     buff = malloc(inner_buffer_size);
00977     if(NULL==buff){
00978         inner_buffer_size = 1024 * 256;
00979         buff = malloc(inner_buffer_size);
00980         if(NULL==buff)
00981             return FALSE;
00982     }
00983     //thread lock
00984     if(bThreadLock){
00985         lock = dkcAllocThreadLock();
00986         if(NULL==lock){
00987             goto Error;
00988         }
00989         dkcThreadLock_Lock(lock);
00990     }
00991     //ちっちゃい場合
00992     filesize = dkcFileSize(src);
00993     for(;;)
00994     {//non loop 
00995         if(0 == filesize)
00996         {//ファイルサイズが0の場合
00997             dkcCreateEmptyFile(dest);
00998             break;
00999         }
01000         if(filesize < inner_buffer_size)
01001         {//ファイルサイズがバッファに収まってしまう場合。
01002             if(DKUTIL_FAILED(dkcLoadBinary(buff,filesize,src,&readed)))
01003             {
01004                 goto Error;
01005             }
01006 #   ifdef DEBUG
01007             if(readed != filesize){
01008                 ODS("readed != filesize why?\n");
01009             }
01010 #   endif
01011             dkcSaveBinary(buff,filesize,dest);
01012             break;
01013         }
01014         //バッファを使わなければコピーできない場合。
01015 
01016         srcf = dkcFOpen(src,"rb");
01017         if(NULL==srcf) goto Error;
01018         destf = dkcFOpen(dest,"wb");
01019         if(NULL==destf) goto Error;
01020 
01021         //ループする回数を計算
01022         count = filesize / inner_buffer_size;
01023 
01024         for(i=0;i<count;i++){
01025             dkcmFORCE_NOT_ASSERT(1 != fread(buff,inner_buffer_size,1,srcf));
01026             dkcmFORCE_NOT_ASSERT(1 != fwrite(buff,inner_buffer_size,1,destf));
01027         }
01028 
01029         rest = filesize - (count * inner_buffer_size);
01030 
01031         //残りを出力
01032         dkcmFORCE_NOT_ASSERT(rest != fread(buff,1,rest,srcf));
01033         dkcmFORCE_NOT_ASSERT(rest != fwrite(buff,1,rest,destf));
01034 
01035         //close
01036         dkcFClose(&srcf);
01037         dkcFClose(&destf);
01038 
01039         break;
01040     }//end of for
01041 
01042 
01043     result = TRUE;
01044 Error:
01045     if(bThreadLock){
01046         if(lock){
01047             dkcThreadLock_Unlock(lock);
01048             dkcFreeThreadLock(&lock);
01049         }
01050     }
01051     if(buff){
01052         free(buff);buff=NULL;
01053     }
01054     return result;
01055 }

DKC_EXTERN BOOL WINAPI dkcFileExist const char *  filename  ) 
 

戻り値:
TRUEだとファイルが存在する

dkcSJISFileSystem.c737 行で定義されています。

参照先 BOOL, と FALSE.

参照元 dkcCreateZeroByteFile(), dkcFileBinaryCompare(), dkcIsEffectivePath(), と dkcMemoryToFile().

00737                                               {
00738     struct stat s;
00739     if(!filename) return FALSE;
00740     //return (stat(filename,&s)==0) ? TRUE : FALSE;
00741     return (stat(filename,&s)==0);
00742 }

DKC_EXTERN BOOL WINAPI dkcFileRemove const char *  filename  ) 
 

ファイルを削除する。

戻り値:
削除できたらTRUE
引数:
filename[in] ファイル名

dkcSJISFileSystem.c1057 行で定義されています。

参照先 BOOL.

01058 {
01059 #ifdef WIN32
01060     return (0 != DeleteFile(filename));
01061     //return (0==remove(filename));
01062 #else
01063     return (0==remove(filename));
01064 #endif
01065 }

DKC_EXTERN BOOL WINAPI dkcFileRename const char *  oldname,
const char *  newname
 

引数:
oldname[in] 古い名前へのポインタ
newname[in] 新しい名前へのポインタ

dkcSJISFileSystem.c1067 行で定義されています。

参照先 BOOL.

01067                                                                   {
01068 #ifdef WIN32
01069     return (0==rename(oldname,newname));
01070 #else
01071     return (0==rename(oldname,newname));
01072 #endif
01073 }

DKC_EXTERN ULONG WINAPI dkcFileSize const char *  filename  ) 
 

戻り値:
0だとファイルサイズが0 または 内部エラー また はファイルが存在しない

dkcSJISFileSystem.c744 行で定義されています。

参照元 dkcAllocDeserialize(), と dkcFileCopyEx().

00744                                               {
00745     struct stat s;//s
00746     if(!filename) return 0;
00747   return (stat(filename,&s)==0) ? (ULONG)s.st_size : 0;
00748 }

DKC_EXTERN BOOL WINAPI dkcFileSize64 const char *  filename,
DWORD *  high,
DWORD *  low
 

戻り値:
FALSEだと失敗

dkcSJISFileSystem.c749 行で定義されています。

参照先 BOOL, FALSE, NULL, と TRUE.

参照元 dkcFileBinaryCompare(), と dkcFileToMemory().

00749                                                                  {
00750 #ifdef WIN32
00751     WIN32_FIND_DATA findData;
00752     HANDLE hFind=NULL;
00753     // ファイルサイズ取得
00754     if((hFind = FindFirstFile(str,&findData)) == INVALID_HANDLE_VALUE){
00755         return FALSE;
00756     }
00757 
00758     //ファイルのサイズをヴちこむ
00759     *high = findData.nFileSizeHigh;
00760     *low = findData.nFileSizeLow;
00761     FindClose(hFind);
00762     return TRUE;
00763 #else
00764 
00765 #endif
00766 }

DKC_EXTERN int WINAPI dkcFileToMemory const char *  filename,
void *  buff,
size_t  size
 

filenameの内容をbuffに読みこむ

引数:
filename[in] 読みこみたいファイル名
buff[in] バッファへのアドレス
size[in] buffのサイズ
戻り値:
edkResultのどれか

dkcSJISFileSystem.c1251 行で定義されています。

参照先 DKC_STREAM, dkcAllocStreamFileType(), dkcFileSize64(), dkcFreeStream(), dkcStreamRead(), DWORD, edkcStreamDefaultEndian, edkcStreamProcessAsOrdered, FALSE, と NULL.

01252 {
01253     DWORD h,l;
01254     DKC_STREAM *p;
01255     int r = edk_FAILED;
01256     if(FALSE==dkcFileSize64(filename,&h,&l)){
01257         return edk_FileNotFound;
01258     }
01259 
01260     if(h != 0 || ( (size_t)(l) > size ))
01261     {//DWORD_MAX以上のサイズのファイルをメモリには読みこめないですよ^^;
01262         return edk_BufferOverFlow;
01263     }
01264 
01265     p = dkcAllocStreamFileType( 
01266             edkcStreamDefaultEndian | edkcStreamProcessAsOrdered,
01267             filename,"rb");
01268 
01269     if(NULL==p){
01270         return edk_FAILED;
01271     }
01272     if(DKUTIL_FAILED(dkcStreamRead(p,buff,l,(size_t *)&h))){
01273         goto End;
01274     }
01275     if(h != l){
01276         goto End;
01277     }
01278     r = edk_SUCCEEDED;
01279 End:
01280     dkcFreeStream(&p);
01281     return r;
01282 }

DKC_EXTERN int WINAPI dkcFindClose DKC_FINDFILE ptr  ) 
 

FindClose()

参照:
dkcFindFirstFile()

dkcSJISFileSystem.c1682 行で定義されています。

参照先 DKC_FINDFILE, dkc_FindFile::mDirent, dkc_FindFile::mHandle, と NULL.

01683 {
01684 #ifdef WIN32
01685     if(INVALID_HANDLE_VALUE == ptr->mHandle){
01686         return edk_FAILED;
01687     }
01688     FindClose(ptr->mHandle);
01689     ptr->mHandle = INVALID_HANDLE_VALUE;//しっかりリセット
01690 #else
01691     if(0 == ptr->mHandle){
01692         return edk_FAILED;
01693     }
01694     closedir(ptr->mHandle);
01695     ptr->mHandle = 0;//しっかりリセット
01696     ptr->mDirent = NULL;
01697 #endif
01698 
01699     return edk_SUCCEEDED;
01700 
01701 }

DKC_EXTERN int WINAPI dkcFindFileGetFileName DKC_FINDFILE ptr,
char *  buff,
size_t  buffsize
 

dkcSJISFileSystem.c1703 行で定義されています。

参照先 DKC_FINDFILE, dkc_strcpy(), dkc_FindFile::mDirent, と NULL.

01704 {
01705     int r;
01706     size_t len;
01707 #ifdef WIN32
01708     len = strlen(ptr->mFindData.cFileName);
01709     if(0 == len) return edk_FAILED;
01710     r = dkc_strcpy(buff,buffsize,ptr->mFindData.cFileName,len);
01711 #else
01712     if(NULL==ptr->mDirent)
01713     {//呼び出しが間違っているよ^^;
01714         return edk_LogicError;
01715     }
01716     len = strlen(ptr->mDirent.d_name);
01717     if(0 == len) return edk_FAILED;
01718     r = dkc_strcpy(buff,buffsize,ptr->mDirent.d_name,len);
01719 #endif
01720     return r;
01721 }

DKC_EXTERN BOOL WINAPI dkcFindFileIsDot DKC_FINDFILE ptr  ) 
 

dkcSJISFileSystem.c1739 行で定義されています。

参照先 BOOL, DKC_FINDFILE, と strcmp().

01739                                                {
01740 #ifdef WIN32
01741     return (
01742         strcmp(ptr->mFindData.cFileName,"..") == 0 || 
01743         strcmp(ptr->mFindData.cFileName,".") == 0
01744     );
01745 #else
01746     
01747 
01748 #endif
01749 }

DKC_EXTERN BOOL WINAPI dkcFindFileIsFolder DKC_FINDFILE ptr  ) 
 

dkcSJISFileSystem.c1723 行で定義されています。

参照先 BOOL, DKC_FINDFILE, と strcmp().

01723                                                   {
01724 
01725 
01726 #ifdef WIN32
01727     return (
01728             ptr->mFindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY
01729             && strcmp(ptr->mFindData.cFileName,"..")!=0 
01730             && strcmp(ptr->mFindData.cFileName,".")!=0
01731             );
01732 #else
01733 
01734 
01735 #endif
01736 }

DKC_EXTERN BOOL WINAPI dkcFindFileIsNormalFile DKC_FINDFILE ptr  ) 
 

dkcSJISFileSystem.c1751 行で定義されています。

参照先 BOOL, と DKC_FINDFILE.

01752 {
01753 #ifdef WIN32
01754     return (ptr->mFindData.dwFileAttributes & FILE_ATTRIBUTE_NORMAL);
01755 #else
01756 
01757 #endif
01758 }

DKC_EXTERN BOOL WINAPI dkcFindFileIsReadOnly DKC_FINDFILE ptr  ) 
 

dkcSJISFileSystem.c1760 行で定義されています。

参照先 BOOL, と DKC_FINDFILE.

01760                                                     {
01761 #ifdef WIN32
01762     return (ptr->mFindData.dwFileAttributes & FILE_ATTRIBUTE_READONLY);
01763 #else
01764 
01765 #endif
01766 }

DKC_EXTERN void WINAPI dkcFindFileSize DKC_FINDFILE ptr,
ULONG *  ,
ULONG * 
 

dkcSJISFileSystem.c1767 行で定義されています。

参照先 DKC_FINDFILE.

01767                                                                      {
01768 #ifdef WIN32
01769     *High = ptr->mFindData.nFileSizeHigh;
01770     *Low = ptr->mFindData.nFileSizeLow;
01771 #else
01772 
01773 #endif
01774 
01775 }

DKC_EXTERN int WINAPI dkcFindFirstFile DKC_FINDFILE ptr,
const char *  target
 

Windowsで言うFindFirstFile()のラッパー UNIXやLINUXでも動くかも?

dkcSJISFileSystem.c1634 行で定義されています。

参照先 DKC_FINDFILE, dkc_FindFile::mHandle, と NULL.

01634                                                                  {
01635 #ifdef WIN32
01636     ptr->mHandle = 
01637         FindFirstFileA( target, &(ptr->mFindData) );
01638     if(ptr->mHandle == INVALID_HANDLE_VALUE){
01639         return edk_FAILED;
01640     }
01641 #else
01642     ptr->mHandle = opendir( target );
01643     if(NULL==ptr->mHandle){
01644         return edk_FAILED;
01645     }
01646 
01647 #endif
01648     return edk_SUCCEEDED;
01649 }

DKC_EXTERN int WINAPI dkcFindNextFile DKC_FINDFILE ptr  ) 
 

FindNextFile()

参照:
dkcFindFirstFile()

dkcSJISFileSystem.c1651 行で定義されています。

参照先 DKC_FINDFILE, dkc_FindFile::mDirent, と dkc_FindFile::mHandle.

01651                                              {
01652 #   ifdef WIN32
01653     if ( 0 == FindNextFileA( ptr->mHandle, &(ptr->mFindData) ))
01654     {
01655         if ( GetLastError() == ERROR_NO_MORE_FILES )
01656         {//なんだ、もう無いじゃん。
01657             return edk_EndProcess;
01658         }
01659         else//最悪のパターン
01660         {
01661             return edk_FAILED;
01662         }
01663     }
01664 #   else
01665   errno = 0;
01666     ptr->mDirent = readdir( ptr->mHandle );
01667   if ( ptr->mDirent == 0 )
01668   {
01669     if ( errno == 0 )
01670     {//もう無いよ^^;
01671             return edk_EndProcess;
01672     }
01673         else//最悪のパターン
01674         {
01675             return edk_FAILED;
01676         }
01677   }
01678 #   endif
01679     return edk_SUCCEEDED;
01680 }

DKC_EXTERN int WINAPI dkcFreeFindFile DKC_FINDFILE **   ) 
 

dkcSJISFileSystem.c1626 行で定義されています。

参照先 DKC_FINDFILE, dkcFree(), と NULL.

01626                                               {
01627     if(NULL==ptr /*|| *ptr==NULL*/){
01628         return edk_FAILED;
01629     }
01630     return dkcFree((void **)ptr);
01631 }

DKC_EXTERN int WINAPI dkcFreePathString DKC_PATHSTRING **   ) 
 

dkcSJISFileSystem.c363 行で定義されています。

参照先 DKC_PATHSTRING, dkcFree(), dkcFreeString(), と NULL.

00364 {
00365     if(NULL==ptr || NULL==*ptr){
00366         return edk_ArgumentException;
00367     }
00368     dkcFreeString(&((*ptr)->mString));
00369     return dkcFree((void **)ptr);
00370 }

DKC_EXTERN BOOL WINAPI dkcGetCurrentDirectory char *  buff,
size_t  size
 

戻り値:
TRUEで成功

dkcSJISFileSystem.c783 行で定義されています。

参照先 BOOL, dkc_strcpy(), dkcdMAXPATH_BUFFER, FALSE, NULL, と TRUE.

参照元 dkcCurrentDirectoryConcatenate().

00783                                                           {
00784 #   ifdef WIN32
00785     if(0==GetCurrentDirectory(size,buff)){
00786         return FALSE;
00787     }
00788     /*if(NULL==_getcwd(path,dkcdMAXPATH_BUFFER)){
00789         return FALSE;
00790     }*/
00791 #else
00792   if(NULL==getcwd(buff,size))
00793         return FALSE;
00794 #endif
00795     return TRUE;
00796 
00797 #if 0
00798     /* どういう実装になっているか分からないのでとりあえず+1 */
00799     char path[dkcdMAXPATH_BUFFER + 1];
00800     size_t len;
00801 #   ifdef WIN32
00802     if(0==GetCurrentDirectory(size,path)){
00803         return FALSE;
00804     }
00805     /*if(NULL==_getcwd(path,dkcdMAXPATH_BUFFER)){
00806         return FALSE;
00807     }*/
00808 #else
00809   if(NULL==getcwd(path,dkcdMAXPATH_BUFFER))
00810         return FALSE;
00811 #endif
00812     len = strlen(path);
00813     return DKUTIL_SUCCEEDED(dkc_strcpy(buff,size,path,len));
00814 #endif //end of if 0
00815 }

DKC_EXTERN char* WINAPI dkcGetFileExtension const char *  PathName  ) 
 

パス名から、拡張子の開始位置を取得する ファイル名の末尾からファイル名の最後の '.' までを、拡張子と判断する

戻り値:
NULLだと拡張子は判別不能。また、与えられた文字列の最初のアドレスが返された場合も判別不能
覚え書き:
SJIS対策済み?

dkcSJISFileSystem.c71 行で定義されています。

参照先 isJMS(), と strtail().

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

DKC_EXTERN BOOL WINAPI dkcIsAbsolutelyPath const char *  path  ) 
 

戻り値:
パスが絶対パスだったらTRUE

dkcSJISFileSystem.c117 行で定義されています。

参照先 BOOL, と dkcIsRelativityPath().

00118 {
00119     return !dkcIsRelativityPath(path);
00120 }

DKC_EXTERN BOOL WINAPI dkcIsEffectivePath const char *  path,
size_t  size
 

戻り値:
pathが存在して、有効なパス名だったらTRUE

dkcSJISFileSystem.c90 行で定義されています。

参照先 BOOL, dkcdMAXPATH_BUFFER, dkcFileExist(), dkcIsNativePathString(), dkcToAbsolutelyPath(), FALSE, と TRUE.

参照元 dkcSetCurrentDirectory().

00090                                                             {
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 }

DKC_EXTERN BOOL WINAPI dkcIsRelativityPath const char *  path  ) 
 

戻り値:
パスが相対パスだったらTRUE

dkcSJISFileSystem.c109 行で定義されています。

参照先 BOOL, dkcmNOT_ASSERT, dkcSJIS_StrChrSearch(), FALSE, NULL, と TRUE.

参照元 dkcIsAbsolutelyPath(), と dkcToAbsolutelyPath().

00110 {
00111     int point;
00112     dkcmNOT_ASSERT(NULL==path);
00113     point = dkcSJIS_StrChrSearch(path,':');
00114     if(point == -1) return TRUE;
00115     return FALSE;
00116 }

DKC_EXTERN int WINAPI dkcIsShiftJIS const char *  str,
int  nPos
 

文字列 str の str[nPos] について、

戻り値:
0 …… 1バイト文字
1 …… 2バイト文字の一部(第1バイト)
2 …… 2バイト文字の一部(第2バイト)

シフトJIS文字列の判定をします。

dkcSJISFileSystem.c40 行で定義されています。

参照先 jms1(), と jms2().

参照元 isJMS().

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 }

DKC_EXTERN BOOL WINAPI dkcIsTailPathSep const char *  src,
size_t  dlen
 

srcの一番後ろににがついていたらTRUE

\

dkcSJISFileSystem.c123 行で定義されています。

参照先 BOOL, dkcSJIS_SearchPathSepLast(), FALSE, と TRUE.

参照元 dkcPathStringElementInsert_Logic(), dkcPathStringNormalizeConcatenateLogic(), と dkcPushBackPathSep().

00123                                                          {
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 }

DKC_EXTERN int WINAPI dkcMemoryToFile const char *  filename,
const void *  buff,
size_t  size,
UINT  flag
 

buffの内容をfilenameファイルに書きこむ

引数:
filename[in]保存したいファイル名 
buff[in] メモリへのアドレス
size[in] buffのサイズ
flag[in] edkcFileRewriteの組み合わせ edkcFileRewriteとか
戻り値:
edkResultのどれか

dkcSJISFileSystem.c1218 行で定義されています。

参照先 BOOL, DKC_STREAM, dkcAllocStreamFileType(), dkcFileExist(), dkcFreeStream(), dkcStreamWrite(), edkcStreamDefaultEndian, edkcStreamProcessAsOrdered, NULL, と TRUE.

01219 {
01220     BOOL r;
01221     DKC_STREAM *p;
01222     int re = edk_FAILED;
01223     if(!(edkcFileRewrite & flag))
01224     {
01225 
01226         //ファイルの存在を確かめる
01227         r = dkcFileExist(filename);
01228         if(r==TRUE){
01229             return edk_ArgumentException;
01230         }
01231     }
01232     p = dkcAllocStreamFileType( 
01233             edkcStreamDefaultEndian | edkcStreamProcessAsOrdered,
01234             filename,"wb");
01235 
01236     if(NULL==p){
01237         return edk_FAILED;
01238     }
01239     if(DKUTIL_FAILED(dkcStreamWrite(p,buff,size))){
01240         goto End;
01241     }
01242     re = edk_SUCCEEDED;
01243 End:
01244     dkcFreeStream(&p);
01245 
01246     return re;
01247 
01248 }

DKC_EXTERN int WINAPI dkcPathStringConcatenate DKC_PATHSTRING ,
const char *  buff,
size_t  size
 

パスを正規化して繋げる。

dkcSJISFileSystem.c643 行で定義されています。

参照先 DKC_PATHSTRING, dkcdMAXPATH, dkcmNOT_ASSERT, dkcPathStringCopy(), dkcPathStringNormalizeConcatenateLogic(), dkc_String::mByteSize, と dkc_PathString::mString.

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 }

DKC_EXTERN int WINAPI dkcPathStringCopy DKC_PATHSTRING ,
const char *  buff,
size_t  size
 

パスを正規化して入れる。

dkcSJISFileSystem.c604 行で定義されています。

参照先 DKC_PATHSTRING, dkcdMAXPATH, dkcmNOT_ASSERT, dkcPathStringNormalizeCopyLogic(), dkcStringCopy(), dkc_String::mByteSize, と dkc_PathString::mString.

参照元 dkcAllocPathString(), dkcPathStringConcatenate(), と dkcPathStringNormalizeConcatenateLogic().

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 }

DKC_EXTERN int WINAPI dkcPathStringDevideBegin DKC_PATHSTRING ,
char *  buff,
size_t  size
 

dkcSJISFileSystem.c386 行で定義されています。

参照先 DKC_PATHSTRING, dkcPathStringDevideBegin_Logic(), と dkc_PathString::mIterateCount.

00387 {
00388     return dkcPathStringDevideBegin_Logic(ptr,&ptr->mIterateCount,buff,size);
00389 }

DKC_EXTERN int WINAPI dkcPathStringDevideBegin_Logic DKC_PATHSTRING ,
size_t *  count,
char *  buff,
size_t  size
 

dkcPathStringDevideBegin()

dkcSJISFileSystem.c402 行で定義されています。

参照先 DKC_PATHSTRING, dkc_strcpy(), dkcmNOT_ASSERT, dkcPathStringPointer(), dkcSJIS_StrChrSearch(), と NULL.

参照元 dkcPathStringDevideBegin().

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 }

DKC_EXTERN void WINAPI dkcPathStringDevideEnd DKC_PATHSTRING  ) 
 

dkcSJISFileSystem.c397 行で定義されています。

参照先 DKC_PATHSTRING, dkcPathStringDevideEnd_Logic(), と dkc_PathString::mIterateCount.

00397                                                        {
00398     dkcPathStringDevideEnd_Logic(&ptr->mIterateCount);
00399 }

DKC_EXTERN void WINAPI dkcPathStringDevideEnd_Logic size_t *  count  ) 
 

dkcPathStringDevideEnd()

dkcSJISFileSystem.c475 行で定義されています。

参照元 dkcPathStringDevideEnd().

00475                                                        {
00476     *count = 0;
00477 }

DKC_EXTERN int WINAPI dkcPathStringDevideNext DKC_PATHSTRING ,
char *  buff,
size_t  size
 

戻り値:
edk_EndProcessが返ってきたらdkcPathStringDevideEnd()を呼び出して終了する

dkcSJISFileSystem.c391 行で定義されています。

参照先 DKC_PATHSTRING, dkcPathStringDevideNext_Logic(), と dkc_PathString::mIterateCount.

00392 {
00393     return dkcPathStringDevideNext_Logic(ptr,&ptr->mIterateCount,buff,size);
00394 
00395 }

DKC_EXTERN int WINAPI dkcPathStringDevideNext_Logic DKC_PATHSTRING ,
size_t *  count,
char *  buff,
size_t  size
 

dkcPathStringDevideNext()

dkcSJISFileSystem.c438 行で定義されています。

参照先 DKC_PATHSTRING, dkc_strcpy(), dkcPathStringPointer(), dkcSJIS_StrChrSearch(), dkcStringSize(), と dkc_PathString::mString.

参照元 dkcPathStringDevideNext().

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 }

DKC_EXTERN int WINAPI dkcPathStringElementErase_Logic DKC_PATHSTRING ,
size_t  count
 

dkcSJISFileSystem.c506 行で定義されています。

参照先 DKC_PATHSTRING, dkcPathStringPointer(), dkcPathStringSize(), dkcSJIS_SearchPathSep(), dkcStringErase(), と dkc_PathString::mString.

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 }

DKC_EXTERN int WINAPI dkcPathStringElementInsert_Logic DKC_PATHSTRING ,
size_t  count,
const char *  src,
size_t  len
 

パスの要素を挿入する。(正規化はしない lenは文字数

dkcSJISFileSystem.c479 行で定義されています。

参照先 DKC_PATHSTRING, dkcIsNativePathString(), dkcIsTailPathSep(), dkcPushBackPathSep(), dkcStringInsert(), FALSE, と dkc_PathString::mString.

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 }

DKC_EXTERN int WINAPI dkcPathStringElementReplace_Logic DKC_PATHSTRING ,
size_t  count,
const char *  ,
size_t  len
 

パスの要素を置換する。(正規化はしない lenは文字数

dkcSJISFileSystem.c523 行で定義されています。

参照先 DKC_PATHSTRING, dkcIsNativePathString(), dkcPathStringPointer(), dkcPathStringSize(), dkcSJIS_SearchPathSep(), dkcStringReplace(), FALSE, と dkc_PathString::mString.

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 }

DKC_EXTERN int WINAPI dkcPathStringGetDirectory DKC_PATHSTRING ,
char *  buff,
size_t  size
 

覚え書き:
取得した文字列の最後尾に\を付加させる。

dkcSJISFileSystem.c720 行で定義されています。

参照先 DKC_PATHSTRING, dkc_strcpy(), dkcdPATH_SEP, dkcSJIS_StrChrSearchTail(), dkcStringPointer(), dkcStringSize(), と dkc_PathString::mString.

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 }

DKC_EXTERN int WINAPI dkcPathStringGetDrive DKC_PATHSTRING ,
char *  buff,
size_t  size
 

dkcSJISFileSystem.c667 行で定義されています。

参照先 DKC_PATHSTRING, dkc_strcpy(), dkcSJIS_StrChrSearch(), dkcStringPointer(), と dkc_PathString::mString.

00667                                                                             {
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 }

DKC_EXTERN int WINAPI dkcPathStringGetFileExtension DKC_PATHSTRING ,
char *  buff,
size_t  size
 

dkcSJISFileSystem.c675 行で定義されています。

参照先 DKC_PATHSTRING, dkc_strcpy(), dkcSJIS_SearchPathSep(), dkcSJIS_StrChrSearchLast(), dkcStringPointer(), dkcStringSize(), と dkc_PathString::mString.

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 }

DKC_EXTERN int WINAPI dkcPathStringGetFileName DKC_PATHSTRING ,
char *  buff,
size_t  size
 

dkcSJISFileSystem.c696 行で定義されています。

参照先 DKC_PATHSTRING, dkc_strcpy(), dkcmFORCE_NOT_ASSERT, dkcSJIS_SearchPathSepLast(), dkcStringPointer(), dkcStringSize(), dkc_PathString::mString, と NULL.

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 }

DKC_EXTERN int WINAPI dkcPathStringNormalizeConcatenateLogic DKC_PATHSTRING ptr,
const char *  buff,
size_t  size
 

dkcSJISFileSystem.c615 行で定義されています。

参照先 DKC_PATHSTRING, dkcdMAXPATH_BUFFER, dkcdPATH_SEP_STR, dkcIsTailPathSep(), dkcPathStringCopy(), dkcPathStringPointer(), dkcPathStringSize(), dkcStringConcatenate(), FALSE, dkc_PathString::mString, と ToAbsolutelyLogic().

参照元 dkcPathStringConcatenate().

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 }

DKC_EXTERN const char* WINAPI dkcPathStringPointer const DKC_PATHSTRING  ) 
 

dkcSJISFileSystem.c378 行で定義されています。

参照先 DKC_PATHSTRING, dkcStringPointer(), と dkc_PathString::mString.

参照元 dkcPathStringDevideBegin_Logic(), dkcPathStringDevideNext_Logic(), dkcPathStringElementErase_Logic(), dkcPathStringElementReplace_Logic(), と dkcPathStringNormalizeConcatenateLogic().

00379 {
00380     return dkcStringPointer(p->mString);
00381 }

DKC_EXTERN size_t WINAPI dkcPathStringSize const DKC_PATHSTRING  ) 
 

dkcSJISFileSystem.c373 行で定義されています。

参照先 DKC_PATHSTRING, dkcStringSize(), と dkc_PathString::mString.

参照元 dkcPathStringElementErase_Logic(), dkcPathStringElementReplace_Logic(), と dkcPathStringNormalizeConcatenateLogic().

00374 {
00375     return dkcStringSize(p->mString);
00376 }

DKC_EXTERN BOOL WINAPI dkcPushBackPathSep char *  dest,
size_t  dlen,
size_t  size
 

path separatorを挿入する必要があり、挿入出来たらTRUE

引数:
dest[in] バッファ
dlen[in] destの文字数
size[in] destのサイズ
戻り値:
edk_SUCCEEDEDなら成功
edk_OutputBufferWasLostはバッファが足りなかった
その他は入れる必要が無かった。

dkcSJISFileSystem.c135 行で定義されています。

参照先 dkcdPATH_SEP, dkcIsTailPathSep(), と FALSE.

参照元 dkcDirectoryConcatenate(), と dkcPathStringElementInsert_Logic().

00135                                                                  {
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 }

DKC_EXTERN BOOL WINAPI dkcSetCurrentDirectory const char *  filename  ) 
 

戻り値:
TRUEで成功

dkcSJISFileSystem.c769 行で定義されています。

参照先 BOOL, dkcIsEffectivePath(), dkcmNOT_ASSERT, と FALSE.

00769                                                         {
00770 #ifdef DEBUG
00771     size_t len = strlen(filename);
00772     dkcmNOT_ASSERT(0==len || FALSE==dkcIsEffectivePath(filename,len));
00773 #endif
00774 #   ifdef WIN32
00775     return(0 != SetCurrentDirectory(filename));
00776     //return (_chdir(filename)==0);
00777 #   else
00778     return (chdir(filename)==0);
00779 #   endif
00780 }

DKC_EXTERN int WINAPI dkcToAbsolutelyPath char *  dest,
size_t  dsize,
const char *  src,
size_t  ssize
 

パスを正規化(相対パスから絶対パス)する関数

dkcSJISFileSystem.c208 行で定義されています。

参照先 dkcCurrentDirectoryConcatenate(), dkcdMAXPATH_BUFFER, dkcIsRelativityPath(), MAX_PATH_CHECK, NULL, ToAbsolutelyLogic(), と TRUE.

参照元 dkcIsEffectivePath(), と dkcPathStringNormalizeCopyLogic().

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 }


dkutil_cに対してTue Feb 22 02:03:08 2005に生成されました。 doxygen 1.3.6