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

# 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のインクルード依存関係図

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

ソースコードを見る。

## 構成
struct | dkc_PathString
struct | dkc_FileCopyExCallbackData
struct | dkc_FileFinder
| Fileを検索するための機構の状態を保存する構造体 [詳細]
struct | dkc_FindFile
## 型定義
typedef dkc_PathString | DKC_PATHSTRING
typedef dkc_FileCopyExCallbackData | DKC_FILECOPY_CALLBACK_STRUCT
typedef dkc_FileFinder | DKC_FILE_FINDER
| Fileを検索するための機構の状態を保存する構造体
typedef dkc_FindFile | DKC_FINDFILE
## 関数
DKC_EXTERN const 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)
| 文字列の後ろがPathSeparatorだったらTRUE
DKC_EXTERN BOOL WINAPI | dkcPushBackPathSep (char *dest, size_t dlen, size_t size)
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)
DKC_EXTERN int WINAPI | dkcPathStringDevideNext_Logic (DKC_PATHSTRING *, size_t *count, char *buff, size_t size)
DKC_EXTERN void WINAPI | dkcPathStringDevideEnd_Logic (size_t *count)
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, BOOL bReWrite)
DKC_EXTERN BOOL WINAPI | dkcFileCopyEx (const char *dest, const char *src, size_t inner_buffer_size, BOOL bReWrite, BOOL bThreadLock, DKC_STD_CALLBACK pcallback, void *parg)
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 BOOL WINAPI | dkcFileAndFolderExist (const char *filename)
DKC_EXTERN BOOL WINAPI | dkcFolderExist (const char *filename)
DKC_EXTERN ULONG WINAPI | dkcFileSize (const char *filename)
DKC_EXTERN BOOL WINAPI | dkcFileSize64 (const char *filename, DWORD *high, DWORD *low)
DKC_INLINE BOOL | dkcFileSize64V (const char *filename, uint64 *pv)
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_FileCopyExCallbackData DKC_FILECOPY_CALLBACK_STRUCT

typedef struct dkc_FindFile DKC_FINDFILE

typedef struct dkc_PathString DKC_PATHSTRING

| 覚え書き: 仕様： mStringにディレクトリを入れる。 内部で必ず絶対パスに変換してからmStringに入れる。 TODO: Releaseモード時にバグってしまう問題をどうにかする。

## 関数

DKC_EXTERN DKC_FINDFILE* WINAPI dkcAllocFindFile | ( |  | ) |

| dkcSJISFileSystem.c の 1681 行で定義されています。 参照先 dkcAllocate().
    01682 {
    01683     DKC_FINDFILE *p;
    01684     p = (DKC_FINDFILE *)dkcAllocate(sizeof(DKC_FINDFILE));
    01685     return p;
    01686 }

DKC_EXTERN DKC_PATHSTRING* WINAPI dkcAllocPathString | ( | const char * | path | ) |

  | 引数:
  | path[in] | ファイル、ディレクトリへのパスを入れる。
戻り値: 無効な文字列が使われていたり、上手く割り当て出来なかったらNULL 覚え書き: パスが相対パスだった場合、内部で勝手に絶対パスに変換される。 dkcSJISFileSystem.c の 327 行で定義されています。 参照先 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.c の 854 行で定義されています。 参照先 dkcCreateDirectoryLogic(), dkcdMAXPATH_BUFFER, dkcdMAXPATH_LEN, dkcdPATH_SEP, dkcmIS_INVALID_FOLDERNAME_CHAR, dkcmIS_PATH_SEP, dkcmIsSJIS1, dkcmIsSJIS2, dkcmNOT_ASSERT, dkcmNOT_ASSERT_MESSAGE, FALSE, と NULL.
    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の１文字目か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 }

DKC_EXTERN BOOL WINAPI dkcCreateZeroByteFile | ( | const char * | filename,
|  | BOOL | rewrite
| ) |

  | 引数:
  | filename[in] | ファイル名
  | rewrite[in] | 上書き保存を許可するかどうか？ zerobyteのファイルを作る
dkcSJISFileSystem.c の 1136 行で定義されています。 参照先 dkcFileExist(), FALSE, と TRUE.
    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 }

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.c の 169 行で定義されています。 参照先 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.c の 147 行で定義されています。 参照先 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 BOOL WINAPI dkcFileAndFolderExist | ( | const char * | filename | ) |

| dkcSJISFileSystem.c の 758 行で定義されています。 参照先 file_exist_base(), と TRUE.
    00759 {
    00760     return file_exist_base(filename,TRUE,TRUE);
    00761 }

DKC_EXTERN int WINAPI dkcFileBinaryCompare | ( | const char * | filename1,
|  | const char * | filename2
| ) |

  | 引数:
  | filename1[in] | 比較したいファイル名（フルパスが望ましい）
  | filename2[in] | 比較したいファイル名（フルパスが望ましい） バイナリレベルで一致したらedk_SUCCEEDED edk_FAILEDで一致しない　その他は　引数などの呼び出し側のエラー
dkcSJISFileSystem.c の 1152 行で定義されています。 参照先 BYTE, dkc_memcmp(), dkcAllocStreamFileType(), dkcFileExist(), dkcFileSize64(), dkcFreeStream(), dkcmNOT_ASSERT, dkcStreamEOF(), dkcStreamError(), dkcStreamRead(), DWORD, edkcStreamDefaultEndian, edkcStreamProcessAsOrdered, FALSE, NULL, と s1().
    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 }

DKC_EXTERN BOOL WINAPI dkcFileCopy | ( | const char * | dest,
|  | const char * | src,
|  | BOOL | bReWrite
| ) |

| 覚え書き: thread safe ではありません。（気になる方はdkcFileCopyExをお使いください。) 何故ならコピーするファイルがデカいと処理が止まったままになってしまうからです。 dkcSJISFileSystem.c の 978 行で定義されています。 参照先 dkcFileCopyEx(), FALSE, と NULL.
    00978                                                                        {
    00979     return dkcFileCopyEx(dest,src,1024 * 64,bReWrite,FALSE,NULL,NULL);
    00980 }

DKC_EXTERN BOOL WINAPI dkcFileCopyEx | ( | const char * | dest,
|  | const char * | src,
|  | size_t | inner_buffer_size,
|  | BOOL | bReWrite,
|  | BOOL | bThreadLock,
|  | DKC_STD_CALLBACK | pcallback,
|  | void * | parg
| ) |

  | 引数:
  | inner_buffer_size[in] | 内部のコピーで使うバッファのサイズを設定する。
  | bRewrite[in] | 上書きOKな場合はこれを指定する。
  | bThreadLock[in] | TRUEだとスレッドをロックする。(大きいファイルの場合は危険)
  | pfCallback[in] | DKC_STD_CALLBACK型の関数 Callback関数を指定する NULLでもかまわない
  | parg[in][out] | Callbackに渡すvoid *型ポインタ
戻り値: TRUEだと成功 TODO: HDのサイズ等を取得してコピーするのが安全かどうかを調べなければならない。 スレッド生成してすぐに処理を返すとか？ スレッドをロックするオプションは廃止する。 dkcSJISFileSystem.c の 982 行で定義されています。 参照先 dkc_FileCopyExCallbackData::count, dkcAllocThreadLock(), dkcCreateEmptyFile(), dkcFClose(), dkcFileExist(), dkcFileSize(), dkcFOpen(), dkcFreeThreadLock(), dkcLoadBinary(), dkcmFORCE_NOT_ASSERT, dkcmNOT_ASSERT, dkcSaveBinary(), dkcThreadLock_Lock(), dkcThreadLock_Unlock(), FALSE, dkc_FileCopyExCallbackData::filesize, NULL, ODS, と TRUE. 参照元 dkcFileCopy().
    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         {//ファイルサイズが０の場合
    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 }

DKC_EXTERN BOOL WINAPI dkcFileExist | ( | const char * | filename | ) |

| 戻り値: TRUEだとファイルが存在する なお、Directory(folder)は存在しないことになる。 dkcSJISFileSystem.c の 753 行で定義されています。 参照先 FALSE, file_exist_base(), と TRUE. 参照元 dkcCreateZeroByteFile(), dkcDCFFileSizeExpect(), dkcFileBinaryCompare(), dkcFileCopyEx(), dkcIsEffectivePath(), dkcMemoryStreamLoadFromFile(), と dkcMemoryToFile().
    00754 {
    00755     return file_exist_base(filename,TRUE,FALSE);
    00756 }

DKC_EXTERN BOOL WINAPI dkcFileRemove | ( | const char * | filename | ) |

  | ファイルを削除する。 戻り値: 削除できたらTRUE 引数:
  | filename[in] | ファイル名
dkcSJISFileSystem.c の 1118 行で定義されています。
    01119 {
    01120 #ifdef WIN32
    01121     return (0 != DeleteFile(filename));
    01122     //return (0==remove(filename));
    01123 #else
    01124     return (0==remove(filename));
    01125 #endif
    01126 }

DKC_EXTERN BOOL WINAPI dkcFileRename | ( | const char * | oldname,
|  | const char * | newname
| ) |

  | 引数:
  | oldname[in] | 古い名前へのポインタ
  | newname[in] | 新しい名前へのポインタ
dkcSJISFileSystem.c の 1128 行で定義されています。
    01128                                                                   {
    01129 #ifdef WIN32
    01130     return (0==rename(oldname,newname));
    01131 #else
    01132     return (0==rename(oldname,newname));
    01133 #endif
    01134 }

DKC_EXTERN ULONG WINAPI dkcFileSize | ( | const char * | filename | ) |

| 戻り値: 0だとファイルサイズが０　または　内部エラー また　はファイルが存在しない dkcSJISFileSystem.c の 770 行で定義されています。 参照元 dkcFileCopyEx(), と dkcMemoryStreamLoadFromFile().
    00770                                               {
    00771     struct stat s;//s
    00772     if(!filename) return 0;
    00773   return (stat(filename,&s)==0) ? (ULONG)s.st_size : 0;
    00774 }

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

| 戻り値: FALSEだと失敗 dkcSJISFileSystem.c の 775 行で定義されています。 参照先 FALSE, NULL, と TRUE. 参照元 dkcFileBinaryCompare(), dkcFileSize64V(), と dkcFileToMemory().
    00775                                                                  {
    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 }

DKC_INLINE BOOL dkcFileSize64V | ( | const char * | filename,
|  | uint64 * | pv
| ) |

| dkcSJISFileSystem.h の 244 行で定義されています。 参照先 dkcFileSize64(), dkcTwoDWORDToULONGLONG(), DWORD, FALSE, と TRUE.
    00244                                                                {
    00245     DWORD high,low;
    00246     if(FALSE==dkcFileSize64(filename,&high,&low)){
    00247         return FALSE;
    00248     }
    00249     dkcTwoDWORDToULONGLONG(pv,high,low);
    00250     return TRUE;
    00251 }

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

  | filenameの内容をbuffに読みこむ 引数:
  | filename[in] | 読みこみたいファイル名
  | buff[in] | バッファへのアドレス
  | size[in] | buffのサイズ
戻り値: edkResultのどれか dkcSJISFileSystem.c の 1312 行で定義されています。 参照先 dkcAllocStreamFileType(), dkcFileSize64(), dkcFreeStream(), dkcStreamRead(), DWORD, edkcStreamDefaultEndian, edkcStreamProcessAsOrdered, FALSE, と NULL.
    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 }

DKC_EXTERN int WINAPI dkcFindClose | ( | DKC_FINDFILE * | ptr | ) |

| FindClose() 参照: dkcFindFirstFile() dkcSJISFileSystem.c の 1743 行で定義されています。 参照先 dkc_FindFile::mDirent, dkc_FindFile::mHandle, と NULL.
    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 }

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

| dkcSJISFileSystem.c の 1764 行で定義されています。 参照先 dkc_strcpy(), dkc_FindFile::mDirent, と NULL.
    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 }

DKC_EXTERN BOOL WINAPI dkcFindFileIsDot | ( | DKC_FINDFILE * | ptr | ) |

| dkcSJISFileSystem.c の 1800 行で定義されています。 参照先 strcmp().
    01800                                                {
    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 }

DKC_EXTERN BOOL WINAPI dkcFindFileIsFolder | ( | DKC_FINDFILE * | ptr | ) |

| dkcSJISFileSystem.c の 1784 行で定義されています。 参照先 strcmp().
    01784                                                   {
    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 }

DKC_EXTERN BOOL WINAPI dkcFindFileIsNormalFile | ( | DKC_FINDFILE * | ptr | ) |

| dkcSJISFileSystem.c の 1812 行で定義されています。
    01813 {
    01814 #ifdef WIN32
    01815     return (ptr->mFindData.dwFileAttributes & FILE_ATTRIBUTE_NORMAL);
    01816 #else
    01817
    01818 #endif
    01819 }

DKC_EXTERN BOOL WINAPI dkcFindFileIsReadOnly | ( | DKC_FINDFILE * | ptr | ) |

| dkcSJISFileSystem.c の 1821 行で定義されています。
    01821                                                     {
    01822 #ifdef WIN32
    01823     return (ptr->mFindData.dwFileAttributes & FILE_ATTRIBUTE_READONLY);
    01824 #else
    01825
    01826 #endif
    01827 }

DKC_EXTERN void WINAPI dkcFindFileSize | ( | DKC_FINDFILE * | ptr,
|  | ULONG * | ,
|  | ULONG * |
| ) |

| dkcSJISFileSystem.c の 1828 行で定義されています。
    01828                                                                      {
    01829 #ifdef WIN32
    01830     *High = ptr->mFindData.nFileSizeHigh;
    01831     *Low = ptr->mFindData.nFileSizeLow;
    01832 #else
    01833
    01834 #endif
    01835
    01836 }

DKC_EXTERN int WINAPI dkcFindFirstFile | ( | DKC_FINDFILE * | ptr,
|  | const char * | target
| ) |

| Windowsで言うFindFirstFile()のラッパー UNIXやLINUXでも動くかも？ dkcSJISFileSystem.c の 1695 行で定義されています。 参照先 dkc_FindFile::mHandle, と NULL.
    01695                                                                  {
    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 }

DKC_EXTERN int WINAPI dkcFindNextFile | ( | DKC_FINDFILE * | ptr | ) |

| FindNextFile() 参照: dkcFindFirstFile() dkcSJISFileSystem.c の 1712 行で定義されています。 参照先 dkc_FindFile::mDirent, と dkc_FindFile::mHandle.
    01712                                              {
    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 }

DKC_EXTERN BOOL WINAPI dkcFolderExist | ( | const char * | filename | ) |

| dkcSJISFileSystem.c の 763 行で定義されています。 参照先 FALSE, file_exist_base(), と TRUE.
    00764 {
    00765     return file_exist_base(filename,FALSE,TRUE);
    00766 }

DKC_EXTERN int WINAPI dkcFreeFindFile | ( | DKC_FINDFILE ** |  | ) |

| dkcSJISFileSystem.c の 1687 行で定義されています。 参照先 dkcFree(), と NULL.
    01687                                               {
    01688     if(NULL==ptr /*|| *ptr==NULL*/){
    01689         return edk_FAILED;
    01690     }
    01691     return dkcFree((void **)ptr);
    01692 }

DKC_EXTERN int WINAPI dkcFreePathString | ( | DKC_PATHSTRING ** |  | ) |

| dkcSJISFileSystem.c の 363 行で定義されています。 参照先 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.c の 809 行で定義されています。 参照先 dkc_strcpy(), dkcdMAXPATH_BUFFER, FALSE, NULL, と TRUE. 参照元 dkcCurrentDirectoryConcatenate().
    00809                                                           {
    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 }

DKC_EXTERN const char* WINAPI dkcGetFileExtension | ( | const char * | PathName | ) |

| パス名から、拡張子の開始位置を取得する ファイル名の末尾からファイル名の最後の '. ' までを、拡張子と判断する 戻り値: NULLだと拡張子は判別不能。また、与えられた文字列の最初のアドレスが返された場合も判別不能 覚え書き: SJIS対策済み？ dkcSJISFileSystem.c の 71 行で定義されています。 参照先 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.c の 117 行で定義されています。 参照先 dkcIsRelativityPath().
    00118 {
    00119     return !dkcIsRelativityPath(path);
    00120 }

DKC_EXTERN BOOL WINAPI dkcIsEffectivePath | ( | const char * | path,
|  | size_t | size
| ) |

| 戻り値: pathが存在して、有効なパス名だったらTRUE dkcSJISFileSystem.c の 90 行で定義されています。 参照先 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.c の 109 行で定義されています。 参照先 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] について、 戻り値: ０ …… １バイト文字 １ …… ２バイト文字の一部（第１バイト） ２ …… ２バイト文字の一部（第２バイト） シフトＪＩＳ文字列の判定をします。 dkcSJISFileSystem.c の 40 行で定義されています。 参照先 jms1(), と jms2(). 参照元 isJMS().
    00041 {
    00042     int i;
    00043     int state; // { 0, 1, 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
| ) |

| 文字列の後ろがPathSeparatorだったらTRUE 戻り値: srcの一番後ろにに\がついていたらTRUE dkcSJISFileSystem.c の 123 行で定義されています。 参照先 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.c の 1279 行で定義されています。 参照先 dkcAllocStreamFileType(), dkcFileExist(), dkcFreeStream(), dkcStreamWrite(), edkcStreamDefaultEndian, edkcStreamProcessAsOrdered, NULL, と TRUE.
    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 }

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

| パスを正規化して繋げる。 dkcSJISFileSystem.c の 643 行で定義されています。 参照先 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.c の 604 行で定義されています。 参照先 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.c の 386 行で定義されています。 参照先 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.c の 402 行で定義されています。 参照先 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.c の 397 行で定義されています。 参照先 dkcPathStringDevideEnd_Logic(), と dkc_PathString::mIterateCount.
    00397                                                        {
    00398     dkcPathStringDevideEnd_Logic(&ptr->mIterateCount);
    00399 }

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

| 参照: dkcPathStringDevideEnd() dkcSJISFileSystem.c の 475 行で定義されています。 参照元 dkcPathStringDevideEnd().
    00475                                                        {
    00476     *count = 0;
    00477 }

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

| 戻り値: edk_EndProcessが返ってきたらdkcPathStringDevideEnd()を呼び出して終了する dkcSJISFileSystem.c の 391 行で定義されています。 参照先 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.c の 438 行で定義されています。 参照先 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.c の 506 行で定義されています。 参照先 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.c の 479 行で定義されています。 参照先 dkcIsNativePathString(), dkcIsTailPathSep(), dkcPushBackPathSep(), dkcStringInsert(), FALSE, dkc_PathString::mString, と dkc_SingleListObject::size.
    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.c の 523 行で定義されています。 参照先 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.c の 720 行で定義されています。 参照先 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.c の 667 行で定義されています。 参照先 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.c の 675 行で定義されています。 参照先 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.c の 696 行で定義されています。 参照先 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.c の 615 行で定義されています。 参照先 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.c の 378 行で定義されています。 参照先 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.c の 373 行で定義されています。 参照先 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 dkcSJISFileSystem.c の 135 行で定義されています。 参照先 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.c の 795 行で定義されています。 参照先 dkcIsEffectivePath(), dkcmNOT_ASSERT, と FALSE.
    00795                                                         {
    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 }

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

| パスを正規化(相対パスから絶対パス)する関数 dkcSJISFileSystem.c の 208 行で定義されています。 参照先 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 }