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

# dkcStream.c

`#include "dkcOSIndependent.h"`
`#include "dkcStream.h"`
`#include "dkcStdio.h"`
`#include "dkcMemoryStream.h"`
`#include "dkcGenericFileSystem.h"`
`#include <limits.h>`

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

ソースコードを見る。

## マクロ定義
#define | DKUTIL_C_STREAM_C
## 関数
static DKC_INLINE int | SetStreamInfo (DKC_STREAM *p, UINT flag)
DKC_STREAM *WINAPI | dkcAllocStreamMemoryType (UINT flag, const void *default_data, size_t size)
DKC_STREAM *WINAPI | dkcAllocStreamFileType (UINT flag, const char *filename, const char *mode)
DKC_STREAM *WINAPI | dkcAllocStreamMemoryAdapterType (UINT flag, void *adapt_buffer, size_t size)
DKC_STREAM *WINAPI | dkcAllocStreamFile64Type (UINT flag, const char *filename, uint32 mode)
DKC_STREAM *WINAPI | dkcAllocStreamEncouragementFileType (const char *filename, const char *mode, BOOL OrderFlag)
| ファイル用ストリームの領域を得る時の奨励版の関数
DKC_STREAM *WINAPI | dkcAllocStream (UINT flag, const void *default_data, size_t size, const char *filename, const char *mode)
| ストリーム領域を得る。
int WINAPI | dkcFreeStream (DKC_STREAM **p)
| dkcAllocNewStream()で確保したストリーム領域を開放する
int WINAPI | dkcStreamSeek (DKC_STREAM *ptr, int offset, int origin)
| streamをシークする。fseekみたいなもの
int WINAPI | dkcStreamTell64 (DKC_STREAM *ptr, uint64 *pv)
long WINAPI | dkcStreamTell (DKC_STREAM *ptr)
| streamの位置を取得する。
int WINAPI | dkcStreamFlush (DKC_STREAM *ptr)
| ストリーム内をフラッシュ（完全に書きこむ処理）する。
BOOL WINAPI | dkcStreamEOF (DKC_STREAM *ptr)
BOOL WINAPI | dkcStreamError (DKC_STREAM *ptr)
static DKC_INLINE int | dkcStreamReadObayAnOrder (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
DKC_INLINE int WINAPI | dkcStreamRead (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
| streamをリードする。freadみたいなもの
static int WINAPI | StreamRead (DKC_STREAM *ptr, void *buffer, size_t size, void *hoge)
int WINAPI | dkcStreamRead8 (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
| sizeは1byte単位･･･　ぶっちゃけdkcStreamRead()と同じ動作。 エンディアン問題に積極的に取り組む為に edkcStreamWriteErrorWhenEndianChangeが指定されている場合は明示的にこちらを使用する。
int WINAPI | dkcStreamRead16 (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
int WINAPI | dkcStreamRead32 (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
int WINAPI | dkcStreamRead64 (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
int WINAPI | dkcStreamRef (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
| streamの中身を見る。
int WINAPI | dkcStreamRef16 (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
int WINAPI | dkcStreamRef32 (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
int WINAPI | dkcStreamRef64 (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
static DKC_INLINE int | dkcStreamWriteObayAnOrder (DKC_STREAM *ptr, const void *buffer, size_t size)
int WINAPI | dkcStreamWriteWithWriteSize (DKC_STREAM *ptr, const void *buffer, size_t size, size_t *ws)
| streamをライトする。fwriteみたいなもの
static int WINAPI | StreamWrite (DKC_STREAM *ptr, void *buffer, size_t size, void *hoge)
int WINAPI | dkcStreamWrite8 (DKC_STREAM *ptr, void *buffer, size_t size)
int WINAPI | dkcStreamWrite16 (DKC_STREAM *ptr, const void *buffer, size_t size)
int WINAPI | dkcStreamWrite32 (DKC_STREAM *ptr, const void *buffer, size_t size)
int WINAPI | dkcStreamWrite64 (DKC_STREAM *ptr, const void *buffer, size_t size)
int WINAPI | dkcStreamProcess (DKC_STREAM *ptr, void *buffer, size_t size, DKC_STREAM_PROCESS_TYPE write_t, void *data)
int WINAPI | dkcStreamProcess16 (DKC_STREAM *ptr, void *buffer, size_t size, DKC_STREAM_PROCESS_TYPE write_t, void *data)
int WINAPI | dkcStreamProcess32 (DKC_STREAM *ptr, void *buffer, size_t size, DKC_STREAM_PROCESS_TYPE write_t, void *data)
int WINAPI | dkcStreamProcess64 (DKC_STREAM *ptr, void *buffer, size_t size, DKC_STREAM_PROCESS_TYPE write_t, void *data)
int WINAPI | dkcStreamClear (DKC_STREAM *ptr)
| stream内をmemset(0)する。(seek位置も最初に戻される。

## マクロ定義

#define DKUTIL_C_STREAM_C

| 作者: d金魚 覚え書き: licence:BSD Licence dkcStream.c の 7 行で定義されています。

## 関数

DKC_STREAM* WINAPI dkcAllocStream | ( | UINT | flag,
|  | const void * | default_data,
|  | size_t | size,
|  | const char * | filename,
|  | const char * | mode
| ) |

  | ストリーム領域を得る。 引数:
  | flag[in] | edkcStreamにある、初期化指定系のフラグを渡す(ストリームの種類とストリームのエンディアン)
  | default_data[in] | ストリームに詰め込むバッファ別にNULLでもOK
  | size[in] | ストリームの初期化時のサイズ
  | filename[in] | edkcStreamInitFileをflagに渡した場合、その保存するファイルの名前 flagにedkcStreamInitFile以外の値を渡した場合はNULLでOK
  | mode[in] | fopenのモード flagにedkcStreamInitFile以外の値を渡した場合はNULLでOK
戻り値: DKC_STREAM *のストリームデータ。 dkcStream.c の 163 行で定義されています。 参照先 dkcAllocate(), dkcAllocFile64(), dkcAllocMemoryStream(), dkcAllocMemoryStreamAdapter(), dkcFOpen(), dkcFree(), dkcStreamSeek(), dkcStreamWrite(), edkcStreamInitFile, edkcStreamInitFile64, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, edkcStreamSeekSet, dkc_Stream::mMode, dkc_Stream::mSig, NULL, SetStreamInfo(), と uint32. 参照元 dkcAllocReplace(), dkcAllocStreamEncouragementFileType(), dkcAllocStreamFile64Type(), dkcAllocStreamFileType(), dkcAllocStreamMemoryAdapterType(), と dkcAllocStreamMemoryType().
    00166 {
    00167
    00168     DKC_STREAM *p;
    00169     void *psig;
    00170     const uint32 *use_flag = (const uint32 *)mode;
    00171
    00172     p = (DKC_STREAM *)dkcAllocate(sizeof(DKC_STREAM));
    00173     if(NULL==p){
    00174         return NULL;
    00175     }
    00176
    00177     if(DKUTIL_FAILED(SetStreamInfo(p,flag))){
    00178         goto Error;
    00179     }
    00180
    00181     switch(p->mMode){
    00182     case edkcStreamInitMemory:
    00183         psig = (void *)dkcAllocMemoryStream(size);
    00184         if(NULL==psig){
    00185             goto Error;
    00186         }
    00187         //update
    00188         p->mSig = psig;
    00189         //write default data
    00190         dkcStreamWrite(p,default_data,size);
    00191         dkcStreamSeek(p,0,edkcStreamSeekSet);
    00192         break;
    00193     case edkcStreamInitFile:
    00194         psig = (void *)dkcFOpen(filename,mode);
    00195         if(NULL==psig){
    00196             goto Error;
    00197         }
    00198         //update
    00199         p->mSig = psig;
    00200
    00201         break;
    00202     case edkcStreamInitMemoryAdapter:
    00203         psig = dkcAllocMemoryStreamAdapter((void *)default_data,size);
    00204         if(NULL==psig){
    00205             goto Error;
    00206         }
    00207         p->mSig = psig;
    00208     case edkcStreamInitFile64:
    00209         psig = dkcAllocFile64(*use_flag,filename);
    00210         if(NULL==psig){
    00211             goto Error;
    00212         }
    00213         p->mSig = psig;
    00214         break;
    00215     default:
    00216         goto Error;
    00217     }
    00218
    00219
    00220     //p->mEndianMode = endianmode
    00221
    00222     return p;
    00223 Error:
    00224     dkcFree((void **)&p);
    00225     return NULL;
    00226 }

DKC_STREAM* WINAPI dkcAllocStreamEncouragementFileType | ( | const char * | filename,
|  | const char * | mode,
|  | BOOL | OrderFlag
| ) |

  | ファイル用ストリームの領域を得る時の奨励版の関数 引数:
  | OrderFlag[in] | 指定した通りに読みこむタイプならTRUE (edkcStreamProcessAsOrdered)
覚え書き: 仕様：強制的に吐き出すファイルのエンディアンはリトルエンディアン dkcStream.c の 120 行で定義されています。 参照先 dkcAllocStream(), edkcStreamBigEndian, edkcStreamInitFile, edkcStreamLittleEndian, edkcStreamProcessAsOrdered, edkcStreamProcessDefault, と NULL.
    00121 {
    00122     UINT flag = 0;
    00123     DKUTIL_FLAG_UP(flag,edkcStreamInitFile);
    00124     DKUTIL_FLAG_UP(flag,edkcStreamLittleEndian);
    00125     DKUTIL_FLAG_DOWN(flag,edkcStreamBigEndian);
    00126     if(OrderFlag){
    00127         DKUTIL_FLAG_UP(flag,edkcStreamProcessAsOrdered );
    00128     }else{
    00129         DKUTIL_FLAG_UP(flag,edkcStreamProcessDefault);
    00130     }
    00131     return dkcAllocStream(flag,NULL,0,filename,mode);
    00132 }

DKC_STREAM* WINAPI dkcAllocStreamFile64Type | ( | UINT | flag,
|  | const char * | filename,
|  | uint32 | mode
| ) |

  | 引数:
  | mode[in] | edkc_FileModeのどれかを入れる。
dkcStream.c の 111 行で定義されています。 参照先 dkcAllocStream(), edkcStreamInitFile, edkcStreamInitFile64, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, と NULL. 参照元 dkcAllocDCF01(), dkcDCF01ToFile(), と dkcFileToDCF01().
    00111                                                                                        {
    00112     DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemory);
    00113     DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile);
    00114     DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemoryAdapter);
    00115     DKUTIL_FLAG_UP(flag,edkcStreamInitFile64);
    00116     return dkcAllocStream(flag,NULL,0,filename,(const char *)&mode);
    00117
    00118 }

DKC_STREAM* WINAPI dkcAllocStreamFileType | ( | UINT | flag,
|  | const char * | filename,
|  | const char * | mode
| ) |

| dkcStream.c の 95 行で定義されています。 参照先 dkcAllocStream(), edkcStreamInitFile, edkcStreamInitFile64, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, と NULL. 参照元 dkcFileBinaryCompare(), dkcFileToMemory(), dkcMemoryToFile(), と dkcOpenFileWithSignature().
    00095                                                                                           {
    00096     DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemory);
    00097     DKUTIL_FLAG_UP(flag,edkcStreamInitFile);
    00098     DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemoryAdapter);
    00099     DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile64);
    00100     return dkcAllocStream(flag,NULL,0,filename,mode);
    00101 }

DKC_STREAM* WINAPI dkcAllocStreamMemoryAdapterType | ( | UINT | flag,
|  | void * | adapt_buffer,
|  | size_t | size
| ) |

| 覚え書き: adapt_bufferに入れたメモリ領域は自動的に開放されませんので各自で開放してください。 dkcStream.c の 103 行で定義されています。 参照先 dkcAllocStream(), edkcStreamInitFile, edkcStreamInitFile64, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, と NULL.
    00103                                                                                             {
    00104     DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemory);
    00105     DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile);
    00106     DKUTIL_FLAG_UP(flag,edkcStreamInitMemoryAdapter);
    00107     DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile64);
    00108     return dkcAllocStream(flag,adapt_buffer,size,NULL,NULL);
    00109 }

DKC_STREAM* WINAPI dkcAllocStreamMemoryType | ( | UINT | flag,
|  | const void * | default_data,
|  | size_t | size
| ) |

| dkcStream.c の 86 行で定義されています。 参照先 dkcAllocStream(), edkcStreamInitFile, edkcStreamInitFile64, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, と NULL.
    00086                                                                                            {
    00087     DKUTIL_FLAG_UP(flag,edkcStreamInitMemory);
    00088     DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile);
    00089     DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemoryAdapter);
    00090     DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile64);
    00091     return dkcAllocStream(flag,default_data,size,NULL,NULL);
    00092
    00093 }

int WINAPI dkcFreeStream | ( | DKC_STREAM ** | ptr | ) |

  | dkcAllocNewStream()で確保したストリーム領域を開放する 引数:
  | ptr[in][out] | 削除するストリームデータ。入れたデータはNULLになる。
覚え書き: dkcStream.c の 229 行で定義されています。 参照先 dkcFClose(), dkcFree(), dkcFreeFile64(), dkcFreeMemoryStream(), dkcFreeMemoryStreamAdapter(), dkcmNOT_ASSERT, edkcStreamInitFile, edkcStreamInitFile64, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, dkc_Stream::mMode, dkc_Stream::mSig, と NULL. 参照元 dkcAllocDCF01(), dkcAllocReplace(), dkcCloseFileWithSignature(), dkcDCF01ToFile(), dkcFileBinaryCompare(), dkcFileToDCF01(), dkcFileToMemory(), dkcFreeReplace(), dkcMemoryToFile(), と dkcOpenFileWithSignature().
    00229                                         {
    00230     DKC_STREAM *t;
    00231     if(NULL==p){
    00232         return edk_FAILED;
    00233     }
    00234     t = *p;
    00235     if(NULL==t){
    00236         return edk_FAILED;
    00237     }
    00238
    00239     switch(t->mMode){
    00240     case edkcStreamInitMemory:
    00241         dkcFreeMemoryStream((DKC_MEMORYSTREAM **)&(t->mSig));
    00242         break;
    00243     case edkcStreamInitFile:
    00244         dkcFClose((FILE **)&(t->mSig));
    00245         break;
    00246     case edkcStreamInitMemoryAdapter:
    00247         dkcFreeMemoryStreamAdapter((DKC_MEMORYSTREAM_ADAPTER **)&(t->mSig));
    00248         break;
    00249     case edkcStreamInitFile64:
    00250         dkcFreeFile64((DKC_FILE64 **)&(t->mSig));
    00251         break;
    00252 #ifdef DEBUG
    00253         default:
    00254             dkcmNOT_ASSERT("dkcFreeStream FAILED");
    00255 #endif
    00256     }
    00257     return dkcFree((void **)p);
    00258 }

int WINAPI dkcStreamClear | ( | DKC_STREAM * | ptr | ) |

| stream内をmemset(0)する。(seek位置も最初に戻される。 dkcStream.c の 894 行で定義されています。 参照先 dkcMemoryStreamAdapterClear, dkcMemoryStreamClear(), dkcStreamWrite(), edkcStreamInitFile, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, dkc_Stream::mMode, と dkc_Stream::mSig.
    00894                                           {
    00895     //file size
    00896     size_t fsize;
    00897     //temp size
    00898     size_t tsize;
    00899     size_t write_size;
    00900     FILE *fp;
    00901     int r = edk_FAILED;
    00902     char null_array[1024];
    00903
    00904
    00905     switch(ptr->mMode){
    00906     case edkcStreamInitMemory:
    00907         r = dkcMemoryStreamClear( (DKC_MEMORYSTREAM *)ptr->mSig );
    00908         break;
    00909     case edkcStreamInitFile:
    00910
    00911         memset(null_array,0,sizeof(null_array));
    00912         fp =(FILE *) ptr->mSig;
    00913
    00914
    00915         fseek( fp, 0, SEEK_END ) ;
    00916         fsize = ftell( fp ) ;
    00917         fseek( fp, 0, SEEK_SET ) ;
    00918
    00919         if(fsize > sizeof(null_array))
    00920         {//ファイルのサイズがNULL配列より大きい場合
    00921
    00922             tsize = 0;
    00923             write_size = sizeof(null_array);
    00924             for(;;){
    00925
    00926                 r = dkcStreamWrite(ptr,null_array,write_size);
    00927
    00928                 if(DKUTIL_FAILED(r)){
    00929                     return r;
    00930                 }
    00931                 if(tsize >= fsize){
    00932                     r = edk_SUCCEEDED;
    00933                     break;
    00934                 }
    00935
    00936                 if(tsize + write_size > fsize){
    00937                     write_size = fsize - tsize;
    00938                 }else{
    00939                     tsize += write_size;
    00940
    00941                     //こいつはいらないけど一応･･･
    00942                     write_size = sizeof(null_array);
    00943                 }
    00944             }
    00945         }else{//ちっこいなら上書き上書き･･･
    00946             r = dkcStreamWrite(ptr,null_array,fsize);
    00947         }
    00948
    00949         break;
    00950     case edkcStreamInitMemoryAdapter:
    00951         r = dkcMemoryStreamAdapterClear((DKC_MEMORYSTREAM_ADAPTER *)ptr->mSig);
    00952         break;
    00953
    00954
    00955     }
    00956     return r;
    00957 }

BOOL WINAPI dkcStreamEOF | ( | DKC_STREAM * | ptr | ) |

| 戻り値: EOFだとTRUE dkcStream.c の 359 行で定義されています。 参照先 dkcFile64EOF(), edkcStreamInitFile, edkcStreamInitFile64, FALSE, dkc_Stream::mMode, dkc_Stream::mSig, と TRUE. 参照元 dkcDCF01Read(), dkcFileBinaryCompare(), と dkcFileToDCF01().
    00359                                          {
    00360
    00361     //filter
    00362     if(edkcStreamInitFile64==ptr->mMode){
    00363         return dkcFile64EOF((DKC_FILE64 *)ptr->mSig);
    00364     }
    00365     if(edkcStreamInitFile != ptr->mMode){
    00366         goto Exit;
    00367     }
    00368     if(0 != feof((FILE *)ptr->mSig)){
    00369         return TRUE;
    00370     }
    00371 Exit:
    00372     return FALSE;
    00373 }

BOOL WINAPI dkcStreamError | ( | DKC_STREAM * | ptr | ) |

| 戻り値: エラーだとTRUE dkcStream.c の 375 行で定義されています。 参照先 edkcStreamInitFile, FALSE, dkc_Stream::mMode, dkc_Stream::mSig, と TRUE. 参照元 dkcFileBinaryCompare().
    00375                                            {
    00376     //filter
    00377     if(edkcStreamInitFile != ptr->mMode){
    00378         goto Exit;
    00379     }
    00380     if(0 != ferror((FILE *)ptr->mSig)){
    00381         return TRUE;
    00382     }
    00383 Exit:
    00384     return FALSE;
    00385 }

int WINAPI dkcStreamFlush | ( | DKC_STREAM * | ptr | ) |

| ストリーム内をフラッシュ（完全に書きこむ処理）する。 戻り値: edk_Resultのどれか dkcStream.c の 340 行で定義されています。 参照先 edkcStreamInitFile, edkcStreamInitFile64, dkc_Stream::mMode, と dkc_Stream::mSig.
    00340                                           {
    00341     int r = edk_SUCCEEDED;
    00342     //filter
    00343     if(edkcStreamInitFile64==ptr->mMode){
    00344         _flushall();
    00345         return edk_SUCCEEDED;
    00346     }
    00347     if(edkcStreamInitFile!=ptr->mMode){
    00348         return edk_FAILED;
    00349     }
    00350
    00351     r = fflush((FILE *)ptr->mSig);
    00352
    00353     if(r==EOF){
    00354         return edk_FAILED;
    00355     }
    00356     return edk_SUCCEEDED;
    00357 }

int WINAPI dkcStreamProcess | ( | DKC_STREAM * | ptr,
|  | void * | buffer,
|  | size_t | size,
|  | DKC_STREAM_PROCESS_TYPE | write_t,
|  | void * | data
| ) |

| TODO: 各ストリームプロセスのmalloc部を高速化するにはMemoryPoolを使う。 dkcStream.c の 766 行で定義されています。 参照元 dkcFileWithSignatureWrite(), dkcFileWithSignatureWrite16(), dkcFileWithSignatureWrite32(), dkcFileWithSignatureWrite64(), と FileWithSignatureReadLogic().
    00768 {
    00769     return write_t(ptr,buffer,size,data);
    00770 }

int WINAPI dkcStreamProcess16 | ( | DKC_STREAM * | ptr,
|  | void * | buffer,
|  | size_t | size,
|  | DKC_STREAM_PROCESS_TYPE | write_t,
|  | void * | data
| ) |

| dkcStream.c の 774 行で定義されています。 参照先 dkcReverseEndian16(), dkc_Stream::mChangeEndian, と NULL. 参照元 dkcStreamRead16(), と dkcStreamWrite16().
    00775                                                                                                                         {
    00776     int r;
    00777     USHORT *pb;
    00778     size_t elem_num,pause = 16;
    00779     size_t i;
    00780
    00781     if(size % pause != 0){
    00782         return edk_ArgumentException;
    00783     }
    00784     if(ptr->mChangeEndian)
    00785     {//エンディアンチェンジが必要
    00786         pb = (USHORT *)malloc(size);
    00787         if(NULL==pb){
    00788             //return edk_FAILED;
    00789             return edk_OutOfMemory;
    00790         }
    00791
    00792         //メモリコピー
    00793         memcpy(pb,buffer,size);
    00794         elem_num = size / pause;
    00795
    00796         //エンディアンをチェンジさせる。
    00797         for(i=0;i<elem_num;i++){
    00798             pb[i] = dkcReverseEndian16(pb[i]);
    00799         }
    00800         //書き込む
    00801         r = write_t(ptr,pb,size,data);
    00802
    00803         free(pb);
    00804     }else{
    00805         r = write_t(ptr,buffer,size,data);
    00806     }
    00807     return r;
    00808 }

int WINAPI dkcStreamProcess32 | ( | DKC_STREAM * | ptr,
|  | void * | buffer,
|  | size_t | size,
|  | DKC_STREAM_PROCESS_TYPE | write_t,
|  | void * | data
| ) |

| dkcStream.c の 811 行で定義されています。 参照先 dkcReverseEndian32(), dkc_Stream::mChangeEndian, と NULL. 参照元 dkcStreamRead32(), と dkcStreamWrite32().
    00812                                                                                                                         {
    00813     int r;
    00814     ULONG *pb;
    00815     size_t elem_num,pause = 32;
    00816     size_t i;
    00817
    00818     if(size % pause != 0){
    00819         return edk_ArgumentException;
    00820     }
    00821     if(ptr->mChangeEndian)
    00822     {//エンディアンチェンジが必要
    00823         pb = (ULONG *)malloc(size);
    00824         if(NULL==pb){
    00825             return edk_OutOfMemory;
    00826         }
    00827
    00828         //メモリコピー
    00829         memcpy(pb,buffer,size);
    00830         elem_num = size / pause;
    00831
    00832         //エンディアンをチェンジさせる。
    00833         for(i=0;i<elem_num;i++){
    00834             pb[i] = dkcReverseEndian32(pb[i]);
    00835         }
    00836         //書き込む
    00837         r = write_t(ptr,pb,size,data);
    00838
    00839         free(pb);
    00840     }else{
    00841         r = write_t(ptr,buffer,size,data);
    00842     }
    00843     return r;
    00844
    00845 }

int WINAPI dkcStreamProcess64 | ( | DKC_STREAM * | ptr,
|  | void * | buffer,
|  | size_t | size,
|  | DKC_STREAM_PROCESS_TYPE | write_t,
|  | void * | data
| ) |

| dkcStream.c の 856 行で定義されています。 参照先 dkcReverseEndian64(), dkc_Stream::mChangeEndian, NULL, と ULONGLONG. 参照元 dkcStreamRead64(), と dkcStreamWrite64().
    00857                                                                                                                         {
    00858     int r;
    00859     ULONGLONG *pb;
    00860     size_t elem_num,pause = 64;
    00861     size_t i;
    00862
    00863     if(size % pause != 0){
    00864         return edk_ArgumentException;
    00865     }
    00866     if(ptr->mChangeEndian)
    00867     {//エンディアンチェンジが必要
    00868         pb = (ULONGLONG *)malloc(size);
    00869         if(NULL==pb){
    00870             return edk_OutOfMemory;
    00871         }
    00872
    00873         //メモリコピー
    00874         memcpy(pb,buffer,size);
    00875         elem_num = size / pause;
    00876
    00877         //エンディアンをチェンジさせる。
    00878         for(i=0;i<elem_num;i++){
    00879             pb[i] = dkcReverseEndian64(pb[i]);
    00880         }
    00881         //書き込む
    00882         r = write_t(ptr,pb,size,data);
    00883
    00884         free(pb);
    00885     }else{
    00886         r = write_t(ptr,buffer,size,data);
    00887     }
    00888     return r;
    00889 }

DKC_INLINE int WINAPI dkcStreamRead | ( | DKC_STREAM * | ptr,
|  | void * | buffer,
|  | size_t | size,
|  | size_t * | readsize
| ) |

  | streamをリードする。freadみたいなもの 引数:
  | readsize[out] | 実際に読んだサイズを返す。NULLを渡してもOK.
覚え書き: 指定したサイズ(size)よりもストリームバッファのサイズが小さかった場合 readsizeに実際に読んだサイズを入れます。 戻り値: edkcStreamInitMemoryが指定されていた場合、 dkcMemoryStreamRead()を見てください。 edkcStreamInitFileが指定されていた場合、 ferror()だったらedk_FAILED , feof()だったらedk_BufferOverFlow, edkcStreamWriteErrorWhenEndianChangeが指定されていた場合、 edk_Not_Satisfactoryを返す。この場合はdkcStreamRead8()を使用する事 dkcStream.c の 449 行で定義されています。 参照先 dkcFile64Read(), dkcMemoryStreamAdapterRead, dkcMemoryStreamRead(), dkcStreamReadObayAnOrder(), edkcStreamInitFile, edkcStreamInitFile64, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, edkcStreamProcessDefault, dkc_Stream::mMode, dkc_Stream::mProcessMode, dkc_Stream::mSig, と NULL. 参照元 dkcDCF01Read(), dkcDCF01ReadFinal(), dkcFileBinaryCompare(), dkcFileToDCF01(), dkcFileToMemory(), dkcStreamRead8(), dkcStreamRef(), ReadCallback(), と StreamRead().
    00449                                                                                               {
    00450     int r = edk_FAILED;
    00451     FILE *fp = (FILE *)ptr->mSig;
    00452     size_t redsize = 0;
    00453
    00454     //readsize filter
    00455     if(NULL==readsize){
    00456         readsize = &redsize;
    00457     }
    00458
    00459     //エンディアンチェンジ指定されているよ〜〜。
    00460     /*if(flag & edkcStreamReadErrorWhenEndianChange){
    00461         if(ptr->mChangeEndian){
    00462             return edk_Not_Satisfactory;
    00463         }
    00464     }*/
    00465
    00466     switch(ptr->mMode){
    00467     case edkcStreamInitMemory:
    00468         r = dkcMemoryStreamRead((DKC_MEMORYSTREAM *)ptr->mSig,
    00469             buffer,size,readsize);
    00470         break;
    00471     case edkcStreamInitFile:
    00472
    00473         if(ptr->mProcessMode & edkcStreamProcessDefault){
    00474
    00475             *readsize = fread(buffer,1,size,fp);
    00476
    00477             //set result
    00478             if(feof(fp)){
    00479                 r = edk_BufferOverFlow;
    00480             }else if(!ferror(fp)){
    00481                 r = edk_SUCCEEDED;
    00482             }
    00483
    00484         }else{
    00485             r = dkcStreamReadObayAnOrder(ptr,buffer,size,readsize);
    00486         }
    00487
    00488
    00489         break;
    00490     case edkcStreamInitMemoryAdapter:
    00491         r = dkcMemoryStreamAdapterRead((DKC_MEMORYSTREAM_ADAPTER *)
    00492             ptr->mSig,buffer,size,readsize);
    00493         break;
    00494     case edkcStreamInitFile64:
    00495         r = dkcFile64Read((DKC_FILE64*)ptr->mSig,buffer,size,readsize);
    00496
    00497         break;
    00498     }
    00499     return r;
    00500 }

int WINAPI dkcStreamRead16 | ( | DKC_STREAM * | ptr,
|  | void * | buffer,
|  | size_t | size,
|  | size_t * | readsize
| ) |

  | 覚え書き: sizeは2byte単位でないといけない 引数:
  | flag[in] | edkcStreamProcessAsOrdered 指定したサイズで読みこめない時は edkcStreamProcessDefault
TODO: test dkcStream.c の 511 行で定義されています。 参照先 dkcStreamProcess16(), と StreamRead(). 参照元 dkcStreamRef16().
    00512 {
    00513     return dkcStreamProcess16(ptr,buffer,size,StreamRead,(void *)readsize);
    00514     /*
    00515     size_t sentinel = size / 2;
    00516     size_t i = 0;
    00517     size_t t_rs = 0;
    00518
    00519     USHORT *pus;
    00520
    00521     size_t real_readsize = 0;
    00522     int result;
    00523
    00524     //filter
    00525     if(size_t % 2 != 0){
    00526         return edk_ArgumentException;
    00527     }
    00528
    00529     pus = (USHORT *)buffer;
    00530
    00531     for(;i<sentinel;i++){
    00532         //process
    00533         result = dkcStreamRead(ptr,&pus[i],2,&t_rs);
    00534
    00535
    00536         //update data
    00537         real_readsize += t_rs;
    00538
    00539
    00540         //process state update check
    00541         switch(result){
    00542         case edkSUCCEEDED:
    00543             continue;
    00544         case edk_FAILED:
    00545         case edk_BufferOverFlow:
    00546             goto End;
    00547         default:
    00548             dkcmNOT_ASSERT("dkcStreamSwapRead16 Error");
    00549             goto End;
    00550         }
    00551     }//end of for
    00552 End:
    00553     if(readsize){//set readsize
    00554         *readsize = real_readsize;
    00555     }
    00556     //process result
    00557     return result;
    00558     */
    00559 }

int WINAPI dkcStreamRead32 | ( | DKC_STREAM * | ptr,
|  | void * | buffer,
|  | size_t | size,
|  | size_t * | readsize
| ) |

| 覚え書き: sizeは4byte単位でないといけない dkcStream.c の 561 行で定義されています。 参照先 dkcStreamProcess32(), と StreamRead(). 参照元 dkcStreamRef32().
    00561                                                                                      {
    00562     return dkcStreamProcess32(ptr,buffer,size,StreamRead,(void *)readsize);
    00563 }

int WINAPI dkcStreamRead64 | ( | DKC_STREAM * | ptr,
|  | void * | buffer,
|  | size_t | size,
|  | size_t * | readsize
| ) |

| 覚え書き: sizeは8byte単位でないといけない dkcStream.c の 565 行で定義されています。 参照先 dkcStreamProcess64(), と StreamRead(). 参照元 dkcStreamRef64().
    00565                                                                                      {
    00566     return dkcStreamProcess64(ptr,buffer,size,StreamRead,(void *)readsize);
    00567 }

int WINAPI dkcStreamRead8 | ( | DKC_STREAM * | ptr,
|  | void * | buffer,
|  | size_t | size,
|  | size_t * | readsize
| ) |

| sizeは1byte単位･･･　ぶっちゃけdkcStreamRead()と同じ動作。 エンディアン問題に積極的に取り組む為に edkcStreamWriteErrorWhenEndianChangeが指定されている場合は明示的にこちらを使用する。 TODO: 仕様を満たしていないバグがあるかも　または仕様、実装変更 dkcStream.c の 507 行で定義されています。 参照先 dkcStreamRead().
    00507                                                                                     {
    00508     return dkcStreamRead(ptr,buffer,size,readsize);
    00509 }

static DKC_INLINE int dkcStreamReadObayAnOrder | ( | DKC_STREAM * | ptr,
|  | void * | buffer,
|  | size_t | size,
|  | size_t * | readsize
| ) | `[static]`

| dkcStream.c の 388 行で定義されています。 参照先 BYTE, dkcmNOT_ASSERT, dkc_Stream::mSig, と NULL. 参照元 dkcStreamRead().
    00390 {
    00391     int r = edk_FAILED;
    00392     size_t readsize_ = 0;
    00393     size_t count;
    00394     size_t tc,tsize;
    00395     BYTE *tbuffer;
    00396     FILE *fp = (FILE *)ptr->mSig;
    00397
    00398     if(NULL==readsize){
    00399         readsize = &readsize_;
    00400     }
    00401
    00402     //1,sizeの引数を入れ替えるとどうか？
    00403     //1 = fread(buffer,size,1,ptr->mfp);
    00404     //read size
    00405     tsize = size;
    00406     //temp variable
    00407     tc = 0;
    00408     //offset counter
    00409     count = 0;
    00410     //byte type pointer
    00411     tbuffer = (BYTE *)buffer;
    00412     for(;;)
    00413     {
    00414         //error check
    00415         if(ferror(fp) ){
    00416             //*readsize = count;
    00417             r = edk_FAILED;
    00418             break;
    00419         }
    00420         if(feof(fp)){
    00421             //*readsize = count;
    00422             r = edk_BufferOverFlow;
    00423             break;
    00424         }
    00425         //read
    00426         tc = fread(&tbuffer[count],1,tsize,fp);
    00427         //update
    00428         tsize -= tc;
    00429         count += tc;
    00430
    00431         if(count == size){
    00432             r = edk_SUCCEEDED;
    00433             break;
    00434         }
    00435 #   ifdef DEBUG
    00436         //ありえないエラーチェック
    00437         dkcmNOT_ASSERT(count > size);
    00438 #   else
    00439         if(count > size){
    00440             break;
    00441         }
    00442 #   endif
    00443     }
    00444     *readsize = count;
    00445     return r;
    00446
    00447 }

int WINAPI dkcStreamRef | ( | DKC_STREAM * | ptr,
|  | void * | buffer,
|  | size_t | size,
|  | size_t * | readsize
| ) |

| streamの中身を見る。 tとして保存していた物を指定して　元の位置に戻す dkcStream.c の 570 行で定義されています。 参照先 dkcStreamRead(), dkcStreamSeek(), dkcStreamTell(), と edkcStreamSeekSet.
    00571 {
    00572     //位置を記憶
    00573     long t = dkcStreamTell(ptr);
    00574     //読みこむ（内部で位置がsize分（readsize分）ずらされる）
    00575     int r = dkcStreamRead(ptr,buffer,size,readsize);
    00576
    00577
    00578     /*
    00579     if(readsize > INT_MAX){
    00580         dkcmNOT_ASSEERT("INT_MAX byteも一気に読みこむな！ヽ(`Д´)ノムキィ");
    00581         return edk_FAILED;
    00582     }
    00583     t = (*readsize) - t;
    00584
    00585     //この条件はありえない。
    00586     dkcmNOT_ASSERT(t < 0);*/
    00587
    00588
    00590     dkcStreamSeek(ptr,t,edkcStreamSeekSet);
    00591     return r;
    00592 }

int WINAPI dkcStreamRef16 | ( | DKC_STREAM * | ptr,
|  | void * | buffer,
|  | size_t | size,
|  | size_t * | readsize
| ) |

| dkcStream.c の 594 行で定義されています。 参照先 dkcStreamRead16(), dkcStreamSeek(), dkcStreamTell(), と edkcStreamSeekSet.
    00594                                                                                     {
    00595     long t = dkcStreamTell(ptr);
    00596     int r = dkcStreamRead16(ptr,buffer,size,readsize);
    00597     dkcStreamSeek(ptr,t,edkcStreamSeekSet);
    00598     return r;
    00599 }

int WINAPI dkcStreamRef32 | ( | DKC_STREAM * | ptr,
|  | void * | buffer,
|  | size_t | size,
|  | size_t * | readsize
| ) |

| 覚え書き: sizeは4byte単位でないといけない dkcStream.c の 605 行で定義されています。 参照先 dkcStreamRead32(), dkcStreamSeek(), dkcStreamTell(), と edkcStreamSeekSet.
    00605                                                                                     {
    00606     long t = dkcStreamTell(ptr);
    00607     int r = dkcStreamRead32(ptr,buffer,size,readsize);
    00608     dkcStreamSeek(ptr,t,edkcStreamSeekSet);
    00609     return r;
    00610 }

int WINAPI dkcStreamRef64 | ( | DKC_STREAM * | ptr,
|  | void * | buffer,
|  | size_t | size,
|  | size_t * | readsize
| ) |

| 覚え書き: sizeは8byte単位でないといけない dkcStream.c の 615 行で定義されています。 参照先 dkcStreamRead64(), dkcStreamSeek(), dkcStreamTell(), と edkcStreamSeekSet.
    00615                                                                                     {
    00616     long t = dkcStreamTell(ptr);
    00617     int r = dkcStreamRead64(ptr,buffer,size,readsize);
    00618     dkcStreamSeek(ptr,t,edkcStreamSeekSet);
    00619     return r;
    00620
    00621 }

int WINAPI dkcStreamSeek | ( | DKC_STREAM * | ptr,
|  | int | offset,
|  | int | origin
| ) |

| streamをシークする。fseekみたいなもの 戻り値: edk_SUCCEEDEDで成功　それ以外はエラー dkcStream.c の 263 行で定義されています。 参照先 dkcFile64Seek(), dkcMemoryStreamSeek(), dkcMemroyStreamAdapterSeek, edkcStreamInitFile, edkcStreamInitFile64, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, dkc_Stream::mMode, と dkc_Stream::mSig. 参照元 dkcAllocStream(), dkcCloseFileWithSignature(), dkcDCF01Init(), dkcDCF01ReadFinal(), dkcDCF01WriteFinal(), dkcOpenFileWithSignature(), dkcStreamRef(), dkcStreamRef16(), dkcStreamRef32(), と dkcStreamRef64().
    00263                                                                {
    00264     int r = edk_FAILED;
    00265     switch(ptr->mMode){
    00266     case edkcStreamInitMemory:
    00267         r = dkcMemoryStreamSeek((DKC_MEMORYSTREAM *)ptr->mSig,offset,origin);
    00268         break;
    00269     case edkcStreamInitFile:
    00270         //成功したら０ == edk_SUCCEEDED;
    00271         r = fseek((FILE *)ptr->mSig,offset,origin);
    00272         break;
    00273     case edkcStreamInitMemoryAdapter:
    00274         r = dkcMemroyStreamAdapterSeek((DKC_MEMORYSTREAM_ADAPTER *)ptr->mSig,offset,origin);
    00275         break;
    00276     case edkcStreamInitFile64:
    00277         r = dkcFile64Seek((DKC_FILE64 *)ptr->mSig,offset,origin);
    00278         break;
    00279     }
    00280     return r;
    00281
    00282 }

long WINAPI dkcStreamTell | ( | DKC_STREAM * | ptr | ) |

| streamの位置を取得する。 戻り値: edkcStreamSeekSetからのオフセット値。edk_FAILEDだとエラー dkcStream.c の 312 行で定義されています。 参照先 dkcFile64Tell(), dkcMemoryStreamAdapterTell, dkcMemoryStreamTell, edkcStreamInitFile, edkcStreamInitFile64, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, dkc_Stream::mMode, と dkc_Stream::mSig. 参照元 dkcAllocDCF_Version01_SNOW2(), dkcCloseFileWithSignature(), dkcFileWithSignatureCheckCheat(), dkcFileWithSignatureRead(), dkcStreamRef(), dkcStreamRef16(), dkcStreamRef32(), dkcStreamRef64(), と ReadEOFCheck().
    00312                                           {
    00313     int r = -1;
    00314     uint64 t;
    00315     switch(ptr->mMode){
    00316     case edkcStreamInitMemory:
    00317         r =  dkcMemoryStreamTell((DKC_MEMORYSTREAM *)ptr->mSig);
    00318         break;
    00319     case edkcStreamInitFile:
    00320         r = ftell((FILE *)ptr->mSig);
    00321         if(r==-1){
    00322             return edk_FAILED;
    00323         }
    00324         break;
    00325     case edkcStreamInitFile64:
    00326         dkcFile64Tell((DKC_FILE64 *)ptr->mSig,&t);
    00327         if(t > LONG_MAX){
    00328             return -1;
    00329         }
    00330         r = (long)t;
    00331         break;
    00332     case edkcStreamInitMemoryAdapter:
    00333         r = dkcMemoryStreamAdapterTell((DKC_MEMORYSTREAM_ADAPTER *)ptr->mSig);
    00334         break;
    00335     }
    00336     return r;
    00337     //dkcmNOT_ASSERT("dkcStreamTell failed");
    00338 }

int WINAPI dkcStreamTell64 | ( | DKC_STREAM * | ptr,
|  | uint64 * | pv
| ) |

| dkcStream.c の 285 行で定義されています。 参照先 dkcFile64Tell(), dkcMemoryStreamAdapterTell, dkcMemoryStreamTell, edkcStreamInitFile, edkcStreamInitFile64, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, dkc_Stream::mMode, と dkc_Stream::mSig.
    00285                                                       {
    00286     int r = edk_FAILED;
    00287     switch(ptr->mMode){
    00288     case edkcStreamInitMemory:
    00289         r =  dkcMemoryStreamTell((DKC_MEMORYSTREAM *)ptr->mSig);
    00290         *pv = r;
    00291         break;
    00292     case edkcStreamInitFile:
    00293         r = ftell((FILE *)ptr->mSig);
    00294         if(r==-1){
    00295             return edk_FAILED;
    00296         }
    00297         *pv = r;
    00298         break;
    00299     case edkcStreamInitFile64:
    00300         r = dkcFile64Tell((DKC_FILE64 *)ptr->mSig,pv);
    00301         if(DKUTIL_FAILED(r)) return r;
    00302         break;
    00303     case edkcStreamInitMemoryAdapter:
    00304         r = dkcMemoryStreamAdapterTell((DKC_MEMORYSTREAM_ADAPTER *)ptr->mSig);
    00305         *pv = r;
    00306         break;
    00307     }
    00308
    00309     return edk_SUCCEEDED;
    00310 }

int WINAPI dkcStreamWrite16 | ( | DKC_STREAM * | ptr,
|  | const void * | buffer,
|  | size_t | size
| ) |

| dkcStream.c の 748 行で定義されています。 参照先 dkcStreamProcess16(), NULL, と StreamWrite(). 参照元 dkcFileWithSignatureWrite16().
    00748                                                                             {
    00749     return dkcStreamProcess16(ptr,(void *)buffer,size,StreamWrite,NULL);
    00750 }

int WINAPI dkcStreamWrite32 | ( | DKC_STREAM * | ptr,
|  | const void * | buffer,
|  | size_t | size
| ) |

| dkcStream.c の 752 行で定義されています。 参照先 dkcStreamProcess32(), NULL, と StreamWrite(). 参照元 dkcFileWithSignatureWrite32().
    00752                                                                             {
    00753     return dkcStreamProcess32(ptr,(void *)buffer,size,StreamWrite,NULL);
    00754
    00755 }

int WINAPI dkcStreamWrite64 | ( | DKC_STREAM * | ptr,
|  | const void * | buffer,
|  | size_t | size
| ) |

| dkcStream.c の 759 行で定義されています。 参照先 dkcStreamProcess64(), NULL, と StreamWrite(). 参照元 dkcFileWithSignatureWrite64().
    00759                                                                             {
    00760     return dkcStreamProcess64(ptr,(void *)buffer,size,StreamWrite,NULL);
    00761 }

int WINAPI dkcStreamWrite8 | ( | DKC_STREAM * | ptr,
|  | void * | buffer,
|  | size_t | size
| ) |

| dkcStream.c の 745 行で定義されています。 参照先 dkcStreamWrite().
    00745                                                                     {
    00746     return dkcStreamWrite(ptr,buffer,size);
    00747 }

static DKC_INLINE int dkcStreamWriteObayAnOrder | ( | DKC_STREAM * | ptr,
|  | const void * | buffer,
|  | size_t | size
| ) | `[static]`

| dkcStream.c の 636 行で定義されています。 参照先 BYTE, dkcmNOT_ASSERT, と dkc_Stream::mSig. 参照元 dkcStreamWriteWithWriteSize().
    00636                                                                                                {
    00637     int r = edk_FAILED;
    00638     size_t tc,tsize;
    00639     size_t count;
    00640     const BYTE *tbuffer = (const BYTE *)buffer;
    00641     FILE *fp;
    00642
    00643     tc = 0;
    00644     count = 0;
    00645     tsize = size;
    00646     fp =  (FILE *)ptr->mSig;
    00647
    00648     for(;;){
    00649         //error check
    00650         if(ferror(fp)){
    00651             return edk_FAILED;
    00652         }
    00653         if(feof(fp)){
    00654             return edk_BufferOverFlow;
    00655         }
    00656         //write
    00657         tc = fwrite(&tbuffer[count],1,tsize,fp);
    00658         //update
    00659         tsize -= tc;
    00660         count += tc;
    00661
    00662         if(count == size){
    00663             r = edk_SUCCEEDED;
    00664             break;
    00665         }
    00666 #   ifdef DEBUG
    00667         //ありえないエラーチェック
    00668         dkcmNOT_ASSERT(count > size);
    00669 #   else
    00670         if(count > size){
    00671
    00672             break;
    00673         }
    00674 #   endif
    00675
    00676     }
    00677
    00678
    00679     return r;
    00680 }

int WINAPI dkcStreamWriteWithWriteSize | ( | DKC_STREAM * | ptr,
|  | const void * | buffer,
|  | size_t | size,
|  | size_t * | ws
| ) |

| streamをライトする。fwriteみたいなもの 書き込み指定がこうなっているので･･･。 dkcStream.c の 683 行で定義されています。 参照先 dkcFile64Write(), dkcMemoryStreamAdapterWrite, dkcMemoryStreamWrite(), dkcStreamWriteObayAnOrder(), edkcStreamInitFile, edkcStreamInitFile64, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, edkcStreamWriteErrorWhenEndianChange, dkc_Stream::mChangeEndian, dkc_Stream::mMode, dkc_Stream::mProcessMode, と dkc_Stream::mSig. 参照元 dkcDCF01Write(), と dkcStreamWrite().
    00684 {
    00685     int r = edk_FAILED;
    00686     UINT proc_flag = ptr->mProcessMode;
    00688     if(proc_flag & edkcStreamWriteErrorWhenEndianChange){
    00689         if(ptr->mChangeEndian){
    00690             return edk_Not_Satisfactory;
    00691         }
    00692     }
    00693
    00694     switch(ptr->mMode){
    00695     case edkcStreamInitMemory:
    00696         r =  dkcMemoryStreamWrite((DKC_MEMORYSTREAM *)ptr->mSig,buffer,size);
    00697         break;
    00698     case edkcStreamInitFile:
    00699         r = dkcStreamWriteObayAnOrder(ptr,buffer,size);
    00700         break;
    00701     case edkcStreamInitMemoryAdapter:
    00702         r = dkcMemoryStreamAdapterWrite((DKC_MEMORYSTREAM_ADAPTER *)ptr->mSig,buffer,size);
    00703         break;
    00704     case edkcStreamInitFile64:
    00705         r = dkcFile64Write((DKC_FILE64*)ptr->mSig,buffer,size,ws);
    00706
    00707         break;
    00708     }
    00709
    00710     return r;
    00711
    00712 }

static DKC_INLINE int SetStreamInfo | ( | DKC_STREAM * | p,
|  | UINT | flag
| ) | `[static]`

| ストリームの種類をきめる エンディアンをきめる dkcStream.c の 16 行で定義されています。 参照先 BYTE, dkcIsLittleEndian(), dkcmNOT_ASSERT, edkcStreamBigEndian, edkcStreamInitFile, edkcStreamInitFile64, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, edkcStreamLittleEndian, edkcStreamProcessAsOrdered, edkcStreamProcessDefault, edkcStreamWriteErrorWhenEndianChange, FALSE, dkc_Stream::mChangeEndian, dkc_Stream::mMode, dkc_Stream::mProcessMode, と TRUE. 参照元 dkcAllocStream().
    00016                                                             {
    00017     UINT stream_mode = 0;
    00018     BYTE endian_mode = 0;
    00019     UINT proc_mode = 0;
    00020
    00021     BOOL isLittle = dkcIsLittleEndian();
    00022
    00023
    00025     if(flag & edkcStreamInitMemory){
    00026         stream_mode = edkcStreamInitMemory;
    00027     }else if(flag & edkcStreamInitFile){
    00028         stream_mode = edkcStreamInitFile;
    00029     }else if(flag & edkcStreamInitMemoryAdapter){
    00030         stream_mode = edkcStreamInitMemoryAdapter;
    00031     }else if(flag & edkcStreamInitFile64){
    00032         stream_mode = edkcStreamInitFile64;
    00033     }else{
    00034         goto Error;
    00035     }
    00036
    00037
    00038     endian_mode = FALSE;
    00040     if(flag & edkcStreamBigEndian){
    00041         //endianmode = edkcStreamBigEndian;
    00042         if(isLittle){
    00043             endian_mode = TRUE;
    00044         }
    00045     }else if(flag & edkcStreamLittleEndian){
    00046         //endianmode = edkcStreamLittleEndian;
    00047         if(!isLittle){
    00048             endian_mode = TRUE;
    00049         }
    00050     }else /*if(flag & edkcStreamInitDefaultEndian)*/{
    00051         if(isLittle){
    00052             //endianmode = edkcStreamLittleEndian;
    00053         }else{
    00054             //endianmode = edkcStreamBigEndian;
    00055         }
    00056     }
    00057
    00058     //プロセスの詳細 設定
    00059     proc_mode |= (flag & edkcStreamProcessDefault);
    00060     if(0==proc_mode){
    00061         proc_mode |= (flag &    edkcStreamProcessAsOrdered);
    00062
    00063         if(0==proc_mode){
    00064             proc_mode |=    edkcStreamProcessAsOrdered;
    00065         }
    00066     }
    00067     proc_mode |= (flag &    edkcStreamWriteErrorWhenEndianChange );
    00068
    00069     //update
    00070     p->mMode = stream_mode;
    00071
    00072     dkcmNOT_ASSERT(proc_mode > UCHAR_MAX);
    00073     p->mProcessMode = (BYTE)proc_mode;
    00074
    00075     p->mChangeEndian = endian_mode;
    00076
    00077     return edk_SUCCEEDED;
    00078 Error:
    00079     return edk_FAILED;
    00080
    00081 }

static int WINAPI StreamRead | ( | DKC_STREAM * | ptr,
|  | void * | buffer,
|  | size_t | size,
|  | void * | hoge
| ) | `[static]`

| dkcStream.c の 502 行で定義されています。 参照先 dkcStreamRead(). 参照元 dkcStreamRead16(), dkcStreamRead32(), と dkcStreamRead64().
    00502                                                                                   {
    00503     return dkcStreamRead(ptr,buffer,size,(size_t *)hoge);
    00504 }

static int WINAPI StreamWrite | ( | DKC_STREAM * | ptr,
|  | void * | buffer,
|  | size_t | size,
|  | void * | hoge
| ) | `[static]`

| dkcStream.c の 714 行で定義されています。 参照先 dkcStreamWrite(). 参照元 dkcStreamWrite16(), dkcStreamWrite32(), と dkcStreamWrite64().
    00714                                                                                    {
    00715     return dkcStreamWrite(ptr,buffer,size);
    00716 }