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

# dkcSJISFileSystem.c

`#include "dkcOSIndependent.h"`
`#include "dkcSJISFileSystem.h"`
`#include "dkcStdio.h"`
`#include "dkcString.h"`
`#include "dkcThreadLock.h"`
`#include "dkcSingleList.h"`
`#include "dkcStream.h"`

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

ソースコードを見る。

## マクロ定義
#define | DKUTIL_C_SJIS_FILESYSTEM_C
#define | MAX_PATH_CHECK(dsize)
## 関数
static DKC_INLINE BOOL | jms1 (int c)
static DKC_INLINE BOOL | jms2 (int c)
DKC_EXTERN int WINAPI | dkcIsShiftJIS (const char *str, int nPos)
static DKC_INLINE int | isJMS (const char *str, int nPos)
static DKC_INLINE char * | strtail (const char *stringg)
| 文字列末尾の文字 '' の位置を返す
char *WINAPI | dkcGetFileExtension (const char *PathName)
| パス名から、拡張子の開始位置を取得する ファイル名の末尾からファイル名の最後の '.
BOOL WINAPI | dkcIsEffectivePath (const char *path, size_t size)
BOOL WINAPI | dkcIsRelativityPath (const char *path)
BOOL WINAPI | dkcIsAbsolutelyPath (const char *path)
BOOL WINAPI | dkcIsTailPathSep (const char *src, size_t dlen)
| 文字列の後ろがPathSeparatorだったらTRUE
int WINAPI | dkcPushBackPathSep (char *dest, size_t dlen, size_t size)
int WINAPI | dkcDirectoryConcatenate (char *dest, size_t dlen, size_t dsize, const char *src)
int WINAPI | dkcCurrentDirectoryConcatenate (char *dest, size_t dsize, const char *src)
static int | ToAbsolutelyLogic (char *dest, size_t dsize, const char *src)
int WINAPI | dkcToAbsolutelyPath (char *dest, size_t dsize, const char *src, size_t ssize)
| パスを正規化(相対パスから絶対パス)する関数
DKC_PATHSTRING *WINAPI | dkcAllocPathString (const char *path)
int WINAPI | dkcFreePathString (DKC_PATHSTRING **ptr)
size_t WINAPI | dkcPathStringSize (const DKC_PATHSTRING *p)
const char *WINAPI | dkcPathStringPointer (const DKC_PATHSTRING *p)
int WINAPI | dkcPathStringDevideBegin (DKC_PATHSTRING *ptr, char *buff, size_t size)
int WINAPI | dkcPathStringDevideNext (DKC_PATHSTRING *ptr, char *buff, size_t size)
void WINAPI | dkcPathStringDevideEnd (DKC_PATHSTRING *ptr)
int WINAPI | dkcPathStringDevideBegin_Logic (DKC_PATHSTRING *ptr, size_t *count, char *buff, size_t size)
int WINAPI | dkcPathStringDevideNext_Logic (DKC_PATHSTRING *ptr, size_t *count, char *buff, size_t size)
void WINAPI | dkcPathStringDevideEnd_Logic (size_t *count)
int WINAPI | dkcPathStringElementInsert_Logic (DKC_PATHSTRING *ptr, size_t count, const char *src, size_t len)
| パスの要素を挿入する。(正規化はしない lenは文字数
int WINAPI | dkcPathStringElementErase_Logic (DKC_PATHSTRING *ptr, size_t count)
int WINAPI | dkcPathStringElementReplace_Logic (DKC_PATHSTRING *ptr, size_t count, const char *src, size_t len)
| パスの要素を置換する。(正規化はしない lenは文字数
static int | dkcPathStringNormalizeCopyLogic (DKC_PATHSTRING *ptr, const char *buff, size_t size, int(WINAPI *function__)(DKC_STRING *, const char *, size_t))
int WINAPI | dkcPathStringCopy (DKC_PATHSTRING *ptr, const char *buff, size_t size)
| パスを正規化して入れる。
int WINAPI | dkcPathStringNormalizeConcatenateLogic (DKC_PATHSTRING *ptr, const char *buff, size_t size)
int WINAPI | dkcPathStringConcatenate (DKC_PATHSTRING *ptr, const char *buff, size_t size)
| パスを正規化して繋げる。
int WINAPI | dkcPathStringGetDrive (DKC_PATHSTRING *ptr, char *buff, size_t size)
int WINAPI | dkcPathStringGetFileExtension (DKC_PATHSTRING *ptr, char *buff, size_t size)
int WINAPI | dkcPathStringGetFileName (DKC_PATHSTRING *ptr, char *buff, size_t size)
int WINAPI | dkcPathStringGetDirectory (DKC_PATHSTRING *ptr, char *buff, size_t size)
BOOL WINAPI | dkcFileExist (const char *filename)
ULONG WINAPI | dkcFileSize (const char *filename)
BOOL WINAPI | dkcFileSize64 (const char *str, DWORD *high, DWORD *low)
BOOL WINAPI | dkcSetCurrentDirectory (const char *filename)
BOOL WINAPI | dkcGetCurrentDirectory (char *buff, size_t size)
static BOOL WINAPI | dkcCreateDirectoryLogic (const char *dir, const void *ptr)
int WINAPI | dkcCreateDirectory (const char *pPath)
BOOL WINAPI | dkcFileCopy (const char *dest, const char *src, BOOL bReWrite)
BOOL WINAPI | dkcFileCopyEx (const char *dest, const char *src, size_t inner_buffer_size, BOOL bReWrite, BOOL bThreadLock, DKC_STD_CALLBACK pfcallback, void *parg)
BOOL WINAPI | dkcFileRemove (const char *filename)
BOOL WINAPI | dkcFileRename (const char *oldname, const char *newname)
BOOL WINAPI | dkcCreateZeroByteFile (const char *filename, BOOL rewrite)
int WINAPI | dkcFileBinaryCompare (const char *filename1, const char *filename2)
int WINAPI | dkcMemoryToFile (const char *filename, const void *buff, size_t size, UINT flag)
| buffの内容をfilenameファイルに書きこむ
int WINAPI | dkcFileToMemory (const char *filename, void *buff, size_t size)
| filenameの内容をbuffに読みこむ
DKC_FINDFILE *WINAPI | dkcAllocFindFile ()
int WINAPI | dkcFreeFindFile (DKC_FINDFILE **ptr)
int WINAPI | dkcFindFirstFile (DKC_FINDFILE *ptr, const char *target)
int WINAPI | dkcFindNextFile (DKC_FINDFILE *ptr)
int WINAPI | dkcFindClose (DKC_FINDFILE *ptr)
int WINAPI | dkcFindFileGetFileName (DKC_FINDFILE *ptr, char *buff, size_t buffsize)
BOOL WINAPI | dkcFindFileIsFolder (DKC_FINDFILE *ptr)
BOOL WINAPI | dkcFindFileIsDot (DKC_FINDFILE *ptr)
BOOL WINAPI | dkcFindFileIsNormalFile (DKC_FINDFILE *ptr)
BOOL WINAPI | dkcFindFileIsReadOnly (DKC_FINDFILE *ptr)
void WINAPI | dkcFindFileSize (DKC_FINDFILE *ptr, ULONG *High, ULONG *Low)

## 説明

作者:
  d金魚 @

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

## マクロ定義

#define DKUTIL_C_SJIS_FILESYSTEM_C

| dkcSJISFileSystem.c の 8 行で定義されています。

#define MAX_PATH_CHECK | ( | dsize |  | ) |

| 値:
    {\
        dkcmNOT_ASSERT(dsize < dkcdMAXPATH_BUFFER);\
        if(dsize < dkcdMAXPATH_BUFFER){\
            return edk_BufferOverFlow;\
        }\
    }
dkcSJISFileSystem.c の 181 行で定義されています。 参照元 dkcToAbsolutelyPath(), と ToAbsolutelyLogic().

## 関数

DKC_FINDFILE* WINAPI dkcAllocFindFile | ( |  | ) |

| dkcSJISFileSystem.c の 1653 行で定義されています。 参照先 dkcAllocate().
    01654 {
    01655     DKC_FINDFILE *p;
    01656     p = (DKC_FINDFILE *)dkcAllocate(sizeof(DKC_FINDFILE));
    01657     return p;
    01658 }

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 }

int WINAPI dkcCreateDirectory | ( | const char * | pPath | ) |

| 覚え書き: Thread safe ではありません。(多分safeでなくても大丈夫だと思いますが。 dkcSJISFileSystem.c の 828 行で定義されています。 参照先 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の１文字目か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 }

static BOOL WINAPI dkcCreateDirectoryLogic | ( | const char * | dir,
|  | const void * | ptr
| ) | `[static]`

| dkcSJISFileSystem.c の 817 行で定義されています。 参照元 dkcCreateDirectory().
    00817                                                                            {
    00818 #ifdef WIN32
    00819      //return (0 == _mkdir( dir ));
    00820      return (0 != CreateDirectory(dir,(SECURITY_ATTRIBUTES *)ptr));
    00821 #else
    00822      return (0 == mkdir( dir ));
    00823 #endif
    00824 }

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

  | 引数:
  | filename[in] | ファイル名
  | rewrite[in] | 上書き保存を許可するかどうか？ zerobyteのファイルを作る
dkcSJISFileSystem.c の 1108 行で定義されています。 参照先 dkcFileExist(), FALSE, と TRUE.
    01109 {
    01110     FILE *fp;
    01111     int r = FALSE;
    01112     if(FALSE==dkcFileExist(filename) || TRUE==rewrite){
    01113         fp = fopen(filename,"wb");
    01114         if(!fp){
    01115             return r;
    01116         }
    01117         fclose(fp);
    01118         r = TRUE;
    01119     }
    01120     return r;
    01121 }

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 }

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 }

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

  | 引数:
  | filename1[in] | 比較したいファイル名（フルパスが望ましい）
  | filename2[in] | 比較したいファイル名（フルパスが望ましい） バイナリレベルで一致したらedk_SUCCEEDED edk_FAILEDで一致しない　その他は　引数などの呼び出し側のエラー
dkcSJISFileSystem.c の 1124 行で定義されています。 参照先 BYTE, dkc_memcmp(), dkcAllocStreamFileType(), dkcFileExist(), dkcFileSize64(), dkcFreeStream(), dkcmNOT_ASSERT, dkcStreamEOF(), dkcStreamError(), dkcStreamRead(), DWORD, edkcStreamDefaultEndian, edkcStreamProcessAsOrdered, FALSE, NULL, と s1().
    01125 {
    01126     BOOL r = FALSE;
    01127
    01128     //ファイルの存在を確かめる
    01129     r = dkcFileExist(filename1);
    01130     if(r==FALSE){
    01131         return edk_ArgumentException;
    01132     }
    01133     r = dkcFileExist(filename2);
    01134     if(r==FALSE){
    01135         return edk_ArgumentException;
    01136     }
    01137
    01138     //ファイルのサイズを確かめる
    01139     {
    01140         DWORD high = 0,low = 0,high2 = 0,low2 = 0;
    01141         r = dkcFileSize64(filename1,&high,&low);
    01142         if(r==FALSE){
    01143             return edk_ArgumentException;
    01144         }
    01145         r = dkcFileSize64(filename2,&high2,&low2);
    01146         if(r==FALSE){
    01147             return edk_ArgumentException;
    01148         }
    01149         r = (high==high2 && low==low2);
    01150         if(FALSE==r){//ファイルサイズが違った
    01151             return edk_FAILED;
    01152         }
    01153
    01154     }
    01155
    01156
    01157     {
    01158         DKC_STREAM *s1 = NULL,*s2=NULL;
    01159         BYTE *buffer1 = NULL,*buffer2 = NULL;
    01160         size_t buffsize = 1024 * 52;
    01161
    01162
    01163         //initialize
    01164
    01165         //ファイルをオープン
    01166         r = edk_LogicError;
    01167
    01168         s1 = dkcAllocStreamFileType(
    01169             edkcStreamDefaultEndian | edkcStreamProcessAsOrdered,
    01170             filename1,"rb");
    01171         if(NULL==s1){
    01172             return edk_LogicError;
    01173         }
    01174
    01175         s2 = dkcAllocStreamFileType(
    01176             edkcStreamDefaultEndian | edkcStreamProcessAsOrdered,
    01177             filename2,"rb");
    01178
    01179         if(NULL==s2){
    01180             goto Error;
    01181         }
    01182
    01183         //バッファを用意
    01184         r = edk_OutOfMemory;
    01185
    01186         buffer1 = malloc(buffsize);
    01187         if(NULL==buffer1){
    01188
    01189             goto Error;
    01190         }
    01191         buffer2 = malloc(buffsize);
    01192         if(NULL==buffer2){
    01193             goto Error;
    01194         }
    01195
    01196         //process
    01197
    01198         for(;;){
    01199             size_t readsize1,readsize2;
    01200             BOOL re1,re2;
    01201
    01202             dkcStreamRead(s1,buffer1,buffsize,&readsize1);
    01203             dkcStreamRead(s2,buffer2,buffsize,&readsize2);
    01204
    01205             re1 = dkcStreamError(s1);
    01206             re2 = dkcStreamError(s2);
    01207             if(re1 || re2){
    01208                 r = edk_LogicError;
    01209                 goto Error;
    01210             }
    01211
    01212
    01213             dkcmNOT_ASSERT(readsize1 != readsize2);
    01214
    01215
    01216             r = dkc_memcmp(buffer1,buffsize,buffer2,buffsize);
    01217             if(DKUTIL_FAILED(r)){
    01218                 r = edk_FAILED;
    01219                 break;
    01220             }
    01221             re1 = dkcStreamEOF(s1);
    01222             re2 = dkcStreamEOF(s2);
    01223             if(re1 && re2){
    01224                 r = edk_SUCCEEDED;
    01225                 break;
    01226             }
    01227             else if(FALSE==re1 && FALSE==re2)
    01228             {
    01229                 continue;
    01230             }
    01231             else
    01232             {
    01233                 r = edk_LogicError;
    01234                 goto Error;
    01235             }
    01236         }
    01237 Error:
    01238         if(buffer2){
    01239             free(buffer2);
    01240         }
    01241         if(buffer1){
    01242             free(buffer1);
    01243         }
    01244         dkcFreeStream(&s2);
    01245         dkcFreeStream(&s1);
    01246     }
    01247
    01248     return r;
    01249 }

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

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

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 の 954 行で定義されています。 参照先 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().
    00958 {
    00959     void *buff;
    00960     FILE *srcf,*destf;
    00961     size_t filesize;//ファイルサイズ
    00962     size_t readed;//読み込んだデータ
    00963     size_t count;//count
    00964     size_t i;
    00965     size_t rest;//残り
    00966     int result = FALSE;//戻り値
    00967     DKC_THREAD_LOCK *lock = NULL;
    00968     DKC_FILECOPY_CALLBACK_STRUCT cbdata;
    00969
    00970
    00971     if(NULL==dest || NULL==src){
    00972         return FALSE;
    00973     }
    00974     if(inner_buffer_size <= 1024){
    00975         inner_buffer_size = 1024;
    00976     }
    00977
    00978     //バッファの準備
    00979     buff = malloc(inner_buffer_size);
    00980     if(NULL==buff){
    00981         inner_buffer_size = 1024 * 256;
    00982         buff = malloc(inner_buffer_size);
    00983         if(NULL==buff)
    00984             return FALSE;
    00985     }
    00986     //thread lock
    00987     if(bThreadLock){
    00988         lock = dkcAllocThreadLock();
    00989         if(NULL==lock){
    00990             goto Error;
    00991         }
    00992         dkcThreadLock_Lock(lock);
    00993     }
    00994     //ちっちゃい場合
    00995     filesize = dkcFileSize(src);
    00996     //destが存在する
    00997     if(FALSE==bReWrite && TRUE==dkcFileExist(dest)){
    00998         goto Error;
    00999     }
    01000     cbdata.filesize = filesize;
    01001     cbdata.count = 0;
    01002     for(;;)
    01003     {//non loop
    01004         if(0 == filesize)
    01005         {//ファイルサイズが０の場合
    01006             if(TRUE==dkcCreateEmptyFile(dest))
    01007             {
    01008                 result = TRUE;
    01009             }
    01010             break;
    01011         }
    01012         if(filesize < inner_buffer_size)
    01013         {//ファイルサイズがバッファに収まってしまう場合。
    01014             if(DKUTIL_FAILED(dkcLoadBinary(buff,filesize,src,&readed)))
    01015             {
    01016                 goto Error;
    01017             }
    01018 #   ifdef DEBUG
    01019             if(readed != filesize){
    01020                 ODS("readed != filesize why?\n");
    01021             }
    01022 #   endif
    01023             if(DKUTIL_SUCCEEDED(dkcSaveBinary(buff,filesize,dest)))
    01024             {
    01025                 result = TRUE;
    01026             }
    01027             break;
    01028         }
    01029         //バッファを使わなければコピーできない場合。
    01030
    01031         srcf = dkcFOpen(src,"rb");
    01032         if(NULL==srcf) goto Error;
    01033         destf = dkcFOpen(dest,"wb");
    01034         if(NULL==destf) goto Close;
    01035
    01036         //ループする回数を計算
    01037         count = filesize / inner_buffer_size;
    01038
    01039         for(i=0;i<count;i++){
    01040             dkcmFORCE_NOT_ASSERT(1 != fread(buff,inner_buffer_size,1,srcf));
    01041             dkcmFORCE_NOT_ASSERT(1 != fwrite(buff,inner_buffer_size,1,destf));
    01042
    01043             cbdata.count += inner_buffer_size;
    01044             if(pfcallback){//コールバックで相手方に伝える。
    01045                 if(FALSE==pfcallback(&cbdata,parg)){
    01046                     goto Close;
    01047                 }
    01048             }
    01049         }
    01050
    01051         rest = filesize - (count * inner_buffer_size);
    01052
    01053         //残りを出力
    01054         dkcmFORCE_NOT_ASSERT(rest != fread(buff,1,rest,srcf));
    01055         dkcmFORCE_NOT_ASSERT(rest != fwrite(buff,1,rest,destf));
    01056
    01057
    01058         cbdata.count += rest;
    01059         dkcmNOT_ASSERT(cbdata.count != cbdata.filesize);
    01060         if(pfcallback){//コールバックで相手方に伝える。
    01061             if(FALSE==pfcallback(&cbdata,parg)){
    01062                 goto Close;
    01063             }
    01064         }
    01065         result = TRUE;
    01066 Close:
    01067         //close
    01068         dkcFClose(&srcf);
    01069         dkcFClose(&destf);
    01070
    01071         break;
    01072     }//end of for
    01073
    01074
    01075
    01076
    01077 Error:
    01078     if(bThreadLock){
    01079         if(lock){
    01080             dkcThreadLock_Unlock(lock);
    01081             dkcFreeThreadLock(&lock);
    01082         }
    01083     }
    01084     if(buff){
    01085         free(buff);buff=NULL;
    01086     }
    01087     return result;
    01088 }

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

| 戻り値: TRUEだとファイルが存在する dkcSJISFileSystem.c の 737 行で定義されています。 参照先 FALSE. 参照元 dkcCreateZeroByteFile(), dkcFileBinaryCompare(), dkcFileCopyEx(), dkcIsEffectivePath(), dkcMemoryStreamLoadFromFile(), と 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 }

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

  | ファイルを削除する。 戻り値: 削除できたらTRUE 引数:
  | filename[in] | ファイル名
dkcSJISFileSystem.c の 1090 行で定義されています。
    01091 {
    01092 #ifdef WIN32
    01093     return (0 != DeleteFile(filename));
    01094     //return (0==remove(filename));
    01095 #else
    01096     return (0==remove(filename));
    01097 #endif
    01098 }

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

  | 引数:
  | oldname[in] | 古い名前へのポインタ
  | newname[in] | 新しい名前へのポインタ
dkcSJISFileSystem.c の 1100 行で定義されています。
    01100                                                                   {
    01101 #ifdef WIN32
    01102     return (0==rename(oldname,newname));
    01103 #else
    01104     return (0==rename(oldname,newname));
    01105 #endif
    01106 }

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

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

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

| 戻り値: FALSEだと失敗 dkcSJISFileSystem.c の 749 行で定義されています。 参照先 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 }

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

  | filenameの内容をbuffに読みこむ 引数:
  | filename[in] | 読みこみたいファイル名
  | buff[in] | バッファへのアドレス
  | size[in] | buffのサイズ
戻り値: edkResultのどれか dkcSJISFileSystem.c の 1284 行で定義されています。 参照先 dkcAllocStreamFileType(), dkcFileSize64(), dkcFreeStream(), dkcStreamRead(), DWORD, edkcStreamDefaultEndian, edkcStreamProcessAsOrdered, FALSE, と NULL.
    01285 {
    01286     DWORD h = 0,l = 0;
    01287     DKC_STREAM *p;
    01288     int r = edk_FAILED;
    01289     if(FALSE==dkcFileSize64(filename,&h,&l)){
    01290         return edk_FileNotFound;
    01291     }
    01292
    01293     if(h != 0 || ( (size_t)(l) > size ))
    01294     {//DWORD_MAX以上のサイズのファイルをメモリには読みこめないですよ^^;
    01295         return edk_BufferOverFlow;
    01296     }
    01297
    01298     p = dkcAllocStreamFileType(
    01299             edkcStreamDefaultEndian | edkcStreamProcessAsOrdered,
    01300             filename,"rb");
    01301
    01302     if(NULL==p){
    01303         return edk_FAILED;
    01304     }
    01305     if(DKUTIL_FAILED(dkcStreamRead(p,buff,l,(size_t *)&h))){
    01306         goto End;
    01307     }
    01308     if(h != l){
    01309         goto End;
    01310     }
    01311     r = edk_SUCCEEDED;
    01312 End:
    01313     dkcFreeStream(&p);
    01314     return r;
    01315 }

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

| FindClose() 参照: dkcFindFirstFile() dkcSJISFileSystem.c の 1715 行で定義されています。 参照先 dkc_FindFile::mDirent, dkc_FindFile::mHandle, と NULL.
    01716 {
    01717 #ifdef WIN32
    01718     if(INVALID_HANDLE_VALUE == ptr->mHandle){
    01719         return edk_FAILED;
    01720     }
    01721     FindClose(ptr->mHandle);
    01722     ptr->mHandle = INVALID_HANDLE_VALUE;//しっかりリセット
    01723 #else
    01724     if(0 == ptr->mHandle){
    01725         return edk_FAILED;
    01726     }
    01727     closedir(ptr->mHandle);
    01728     ptr->mHandle = 0;//しっかりリセット
    01729     ptr->mDirent = NULL;
    01730 #endif
    01731
    01732     return edk_SUCCEEDED;
    01733
    01734 }

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

| dkcSJISFileSystem.c の 1736 行で定義されています。 参照先 dkc_strcpy(), dkc_FindFile::mDirent, と NULL.
    01737 {
    01738     int r;
    01739     size_t len;
    01740 #ifdef WIN32
    01741     len = strlen(ptr->mFindData.cFileName);
    01742     if(0 == len) return edk_FAILED;
    01743     r = dkc_strcpy(buff,buffsize,ptr->mFindData.cFileName,len);
    01744 #else
    01745     if(NULL==ptr->mDirent)
    01746     {//呼び出しが間違っているよ＾＾；
    01747         return edk_LogicError;
    01748     }
    01749     len = strlen(ptr->mDirent.d_name);
    01750     if(0 == len) return edk_FAILED;
    01751     r = dkc_strcpy(buff,buffsize,ptr->mDirent.d_name,len);
    01752 #endif
    01753     return r;
    01754 }

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

| dkcSJISFileSystem.c の 1772 行で定義されています。 参照先 strcmp().
    01772                                                {
    01773 #ifdef WIN32
    01774     return (
    01775         strcmp(ptr->mFindData.cFileName,"..") == 0 ||
    01776         strcmp(ptr->mFindData.cFileName,".") == 0
    01777     );
    01778 #else
    01779
    01780
    01781 #endif
    01782 }

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

| dkcSJISFileSystem.c の 1756 行で定義されています。 参照先 strcmp().
    01756                                                   {
    01757
    01758
    01759 #ifdef WIN32
    01760     return (
    01761             ptr->mFindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY
    01762             && strcmp(ptr->mFindData.cFileName,"..")!=0
    01763             && strcmp(ptr->mFindData.cFileName,".")!=0
    01764             );
    01765 #else
    01766
    01767
    01768 #endif
    01769 }

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

| dkcSJISFileSystem.c の 1784 行で定義されています。
    01785 {
    01786 #ifdef WIN32
    01787     return (ptr->mFindData.dwFileAttributes & FILE_ATTRIBUTE_NORMAL);
    01788 #else
    01789
    01790 #endif
    01791 }

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

| dkcSJISFileSystem.c の 1793 行で定義されています。
    01793                                                     {
    01794 #ifdef WIN32
    01795     return (ptr->mFindData.dwFileAttributes & FILE_ATTRIBUTE_READONLY);
    01796 #else
    01797
    01798 #endif
    01799 }

void WINAPI dkcFindFileSize | ( | DKC_FINDFILE * | ptr,
|  | ULONG * | High,
|  | ULONG * | Low
| ) |

| dkcSJISFileSystem.c の 1800 行で定義されています。
    01800                                                                      {
    01801 #ifdef WIN32
    01802     *High = ptr->mFindData.nFileSizeHigh;
    01803     *Low = ptr->mFindData.nFileSizeLow;
    01804 #else
    01805
    01806 #endif
    01807
    01808 }

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

| Windowsで言うFindFirstFile()のラッパー UNIXやLINUXでも動くかも？ dkcSJISFileSystem.c の 1667 行で定義されています。 参照先 dkc_FindFile::mHandle, と NULL.
    01667                                                                  {
    01668 #ifdef WIN32
    01669     ptr->mHandle =
    01670         FindFirstFileA( target, &(ptr->mFindData) );
    01671     if(ptr->mHandle == INVALID_HANDLE_VALUE){
    01672         return edk_FAILED;
    01673     }
    01674 #else
    01675     ptr->mHandle = opendir( target );
    01676     if(NULL==ptr->mHandle){
    01677         return edk_FAILED;
    01678     }
    01679
    01680 #endif
    01681     return edk_SUCCEEDED;
    01682 }

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

| FindNextFile() 参照: dkcFindFirstFile() dkcSJISFileSystem.c の 1684 行で定義されています。 参照先 dkc_FindFile::mDirent, と dkc_FindFile::mHandle.
    01684                                              {
    01685 #   ifdef WIN32
    01686     if ( 0 == FindNextFileA( ptr->mHandle, &(ptr->mFindData) ))
    01687     {
    01688         if ( GetLastError() == ERROR_NO_MORE_FILES )
    01689         {//なんだ、もう無いじゃん。
    01690             return edk_EndProcess;
    01691         }
    01692         else//最悪のパターン
    01693         {
    01694             return edk_FAILED;
    01695         }
    01696     }
    01697 #   else
    01698   errno = 0;
    01699     ptr->mDirent = readdir( ptr->mHandle );
    01700   if ( ptr->mDirent == 0 )
    01701   {
    01702     if ( errno == 0 )
    01703     {//もう無いよ＾＾；
    01704             return edk_EndProcess;
    01705     }
    01706         else//最悪のパターン
    01707         {
    01708             return edk_FAILED;
    01709         }
    01710   }
    01711 #   endif
    01712     return edk_SUCCEEDED;
    01713 }

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

| dkcSJISFileSystem.c の 1659 行で定義されています。 参照先 dkcFree(), と NULL.
    01659                                               {
    01660     if(NULL==ptr /*|| *ptr==NULL*/){
    01661         return edk_FAILED;
    01662     }
    01663     return dkcFree((void **)ptr);
    01664 }

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

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

BOOL WINAPI dkcGetCurrentDirectory | ( | char * | buff,
|  | size_t | size
| ) |

| 戻り値: TRUEで成功 dkcSJISFileSystem.c の 783 行で定義されています。 参照先 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 }

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

BOOL WINAPI dkcIsAbsolutelyPath | ( | const char * | path | ) |

| 戻り値: パスが絶対パスだったらTRUE dkcSJISFileSystem.c の 117 行で定義されています。 参照先 dkcIsRelativityPath().
    00118 {
    00119     return !dkcIsRelativityPath(path);
    00120 }

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 }

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 }

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 }

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 の 1251 行で定義されています。 参照先 dkcAllocStreamFileType(), dkcFileExist(), dkcFreeStream(), dkcStreamWrite(), edkcStreamDefaultEndian, edkcStreamProcessAsOrdered, NULL, と TRUE.
    01252 {
    01253     BOOL r;
    01254     DKC_STREAM *p;
    01255     int re = edk_FAILED;
    01256     if(!(edkcFileRewrite & flag))
    01257     {
    01258
    01259         //ファイルの存在を確かめる
    01260         r = dkcFileExist(filename);
    01261         if(r==TRUE){
    01262             return edk_ArgumentException;
    01263         }
    01264     }
    01265     p = dkcAllocStreamFileType(
    01266             edkcStreamDefaultEndian | edkcStreamProcessAsOrdered,
    01267             filename,"wb");
    01268
    01269     if(NULL==p){
    01270         return edk_FAILED;
    01271     }
    01272     if(DKUTIL_FAILED(dkcStreamWrite(p,buff,size))){
    01273         goto End;
    01274     }
    01275     re = edk_SUCCEEDED;
    01276 End:
    01277     dkcFreeStream(&p);
    01278
    01279     return re;
    01280
    01281 }

int WINAPI dkcPathStringConcatenate | ( | DKC_PATHSTRING * | ptr,
|  | 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 }

int WINAPI dkcPathStringCopy | ( | DKC_PATHSTRING * | ptr,
|  | 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 }

int WINAPI dkcPathStringDevideBegin | ( | DKC_PATHSTRING * | ptr,
|  | char * | buff,
|  | size_t | size
| ) |

| dkcSJISFileSystem.c の 386 行で定義されています。 参照先 dkcPathStringDevideBegin_Logic(), と dkc_PathString::mIterateCount.
    00387 {
    00388     return dkcPathStringDevideBegin_Logic(ptr,&ptr->mIterateCount,buff,size);
    00389 }

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 }

void WINAPI dkcPathStringDevideEnd | ( | DKC_PATHSTRING * | ptr | ) |

| dkcSJISFileSystem.c の 397 行で定義されています。 参照先 dkcPathStringDevideEnd_Logic(), と dkc_PathString::mIterateCount.
    00397                                                        {
    00398     dkcPathStringDevideEnd_Logic(&ptr->mIterateCount);
    00399 }

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

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

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 }

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 }

int WINAPI dkcPathStringElementErase_Logic | ( | DKC_PATHSTRING * | ptr,
|  | 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 }

int WINAPI dkcPathStringElementInsert_Logic | ( | DKC_PATHSTRING * | ptr,
|  | 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 }

int WINAPI dkcPathStringElementReplace_Logic | ( | DKC_PATHSTRING * | ptr,
|  | size_t | count,
|  | const char * | src,
|  | 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 }

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 }

int WINAPI dkcPathStringGetDrive | ( | DKC_PATHSTRING * | ptr,
|  | 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 }

int WINAPI dkcPathStringGetFileExtension | ( | DKC_PATHSTRING * | ptr,
|  | 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 }

int WINAPI dkcPathStringGetFileName | ( | DKC_PATHSTRING * | ptr,
|  | 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 }

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 }

static int dkcPathStringNormalizeCopyLogic | ( | DKC_PATHSTRING * | ptr,
|  | const char * | buff,
|  | size_t | size,
|  | int(WINAPI *function__)(DKC_STRING *, const char *, size_t) |
| ) | `[static]`

| dkcSJISFileSystem.c の 573 行で定義されています。 参照先 dkcdMAXPATH_BUFFER, dkcmNOT_ASSERT, dkcToAbsolutelyPath(), dkc_PathString::mString, と NULL. 参照元 dkcPathStringCopy().
    00575 {
    00576     //const size_t bsize = dkcdMAXPATH_BUFFER + 1;
    00577     size_t len;
    00578     int result;
    00579     //char *pb = malloc(bsize);
    00580     //if(NULL== pb) return edk_OutOfMemory;
    00581     char pb[dkcdMAXPATH_BUFFER];
    00582     size_t bsize = sizeof(pb);
    00583
    00584     result =    dkcToAbsolutelyPath(pb,bsize,buff,size);
    00585
    00586
    00587     len = strlen(pb);
    00588
    00589 #   ifdef DEBUG //ありえないよ〜エラーチェック
    00590     dkcmNOT_ASSERT(DKUTIL_FAILED(result));
    00591     dkcmNOT_ASSERT(len >= bsize);// >=にするのはNULL文字が潰されているかどうか。
    00592     dkcmNOT_ASSERT(NULL==function__);
    00593 #   endif
    00594     if(DKUTIL_FAILED(result)){
    00595         goto Error;
    00596     }
    00597     result = function__(ptr->mString,pb,len);
    00598
    00599 Error:
    00600     //if(pb){free(pb);pb=NULL;}
    00601     return result;
    00602 }

const char* WINAPI dkcPathStringPointer | ( | const DKC_PATHSTRING * | p | ) |

| dkcSJISFileSystem.c の 378 行で定義されています。 参照先 dkcStringPointer(), と dkc_PathString::mString. 参照元 dkcPathStringDevideBegin_Logic(), dkcPathStringDevideNext_Logic(), dkcPathStringElementErase_Logic(), dkcPathStringElementReplace_Logic(), と dkcPathStringNormalizeConcatenateLogic().
    00379 {
    00380     return dkcStringPointer(p->mString);
    00381 }

size_t WINAPI dkcPathStringSize | ( | const DKC_PATHSTRING * | p | ) |

| dkcSJISFileSystem.c の 373 行で定義されています。 参照先 dkcStringSize(), と dkc_PathString::mString. 参照元 dkcPathStringElementErase_Logic(), dkcPathStringElementReplace_Logic(), と dkcPathStringNormalizeConcatenateLogic().
    00374 {
    00375     return dkcStringSize(p->mString);
    00376 }

int 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 }

BOOL WINAPI dkcSetCurrentDirectory | ( | const char * | filename | ) |

| 戻り値: TRUEで成功 dkcSJISFileSystem.c の 769 行で定義されています。 参照先 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 }

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 }

static DKC_INLINE int isJMS | ( | const char * | str,
|  | int | nPos
| ) | `[static]`

| dkcSJISFileSystem.c の 58 行で定義されています。 参照先 dkcIsShiftJIS(). 参照元 dkcGetFileExtension().
    00058                                                        {
    00059     return dkcIsShiftJIS(str,nPos);
    00060 }

static DKC_INLINE BOOL jms1 | ( | int | c | ) | `[static]`

| dkcSJISFileSystem.c の 23 行で定義されています。 参照元 dkcIsShiftJIS().
    00023                                   {
    00024     return (((((unsigned char)(c))>=0x81)&&(((unsigned char)(c))<=0x9F))||((((unsigned char)(c))>=0xE0)&&(((unsigned char)(c))<=0xFC)));
    00025 }

static DKC_INLINE BOOL jms2 | ( | int | c | ) | `[static]`

| dkcSJISFileSystem.c の 26 行で定義されています。 参照元 dkcIsShiftJIS().
    00026                                   {
    00027     return ((((unsigned char)(c))!=0x7F)&&(((unsigned char)(c))>=0x40)&&(((unsigned char)(c))<=0xFC));
    00028 }

static DKC_INLINE char* strtail | ( | const char * | stringg | ) | `[static]`

| 文字列末尾の文字 '' の位置を返す dkcSJISFileSystem.c の 62 行で定義されています。 参照元 dkcGetFileExtension().
    00063 {
    00064     return strchr( stringg, '\0' );
    00065 }//strtail

static int ToAbsolutelyLogic | ( | char * | dest,
|  | size_t | dsize,
|  | const char * | src
| ) | `[static]`

| dkcSJISFileSystem.c の 189 行で定義されています。 参照先 MAX_PATH_CHECK, と NULL. 参照元 dkcPathStringNormalizeConcatenateLogic(), と dkcToAbsolutelyPath().
    00190 {
    00191     /*if(dsize < dkcdMAXPATH_BUFFER){//こんなバッファじゃどうなるか分からないよ＾＾；
    00192         return edk_BufferOverFlow;
    00193     }*/
    00194     MAX_PATH_CHECK(dsize);
    00195 #   ifdef WIN32
    00196
    00197     if(NULL==_fullpath(dest,src,dsize)){
    00198         return edk_FAILED;
    00199     }
    00200 #   else//unix or linux ??
    00201     if(NULL==__realpath(src,dest)){
    00202         return edk_FAILED;
    00203     }
    00204 #   endif
    00205     return edk_SUCCEEDED;
    00206 }