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

# dkcStream.h

`#include "dkcOSIndependent.h"`
`#include "dkcMemoryStream.h"`

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

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

ソースコードを見る。

## 構成
struct | dkc_Stream
| 汎用型ストリーム [詳細]
## 型定義
typedef dkc_Stream | DKC_STREAM
| 汎用型ストリーム
typedef int(WINAPI * | DKC_STREAM_PROCESS_TYPE )(DKC_STREAM *p, void *buffer, size_t size, void *data)
## 列挙型
enum | edkcStream { edkcStreamSeekCurrent = SEEK_CUR, edkcStreamSeekEnd = SEEK_END, edkcStreamSeekSet = SEEK_SET, edkcStreamInitMemory = 1, edkcStreamInitFile = 2, edkcStreamDefaultEndian = 4, edkcStreamBigEndian = 8, edkcStreamLittleEndian = 16, edkcStreamProcessDefault = 32, edkcStreamProcessAsOrdered = 64, edkcStreamWriteErrorWhenEndianChange = 128, edkcStreamInitMemoryAdapter = 256, edkcStreamWin32PromoteFlag = edkcStreamLittleEndian | edkcStreamProcessAsOrdered, edkcStreamMacPromoteFlag = edkcStreamBigEndian | edkcStreamProcessAsOrdered }
## 関数
DKC_EXTERN DKC_STREAM *WINAPI | dkcAllocStream (UINT flag, const void *default_data, size_t size, const char *filename, const char *mode)
| ストリーム領域を得る。
DKC_EXTERN DKC_STREAM *WINAPI | dkcAllocStreamMemoryType (UINT flag, const void *default_data, size_t size)
DKC_EXTERN DKC_STREAM *WINAPI | dkcAllocStreamFileType (UINT flag, const char *filename, const char *mode)
DKC_EXTERN DKC_STREAM *WINAPI | dkcAllocStreamMemoryAdapterType (UINT flag, void *adapt_buffer, size_t size)
DKC_EXTERN DKC_STREAM *WINAPI | dkcAllocStreamEncouragementFileType (const char *filename, const char *mode, BOOL OrderFlag)
| ファイル用ストリームの領域を得る時の奨励版の関数
DKC_EXTERN int WINAPI | dkcFreeStream (DKC_STREAM **ptr)
| dkcAllocNewStream()で確保したストリーム領域を開放する
DKC_EXTERN int WINAPI | dkcStreamSeek (DKC_STREAM *ptr, int offset, int origin)
| streamをシークする。fseekみたいなもの
DKC_EXTERN long WINAPI | dkcStreamTell (DKC_STREAM *ptr)
| streamの位置を取得する。
DKC_EXTERN int WINAPI | dkcStreamClear (DKC_STREAM *ptr)
| stream内をmemset(0)する。(seek位置も最初に戻される。
DKC_EXTERN int WINAPI | dkcStreamFlush (DKC_STREAM *ptr)
| ストリーム内をフラッシュ（完全に書きこむ処理）する。
DKC_EXTERN BOOL WINAPI | dkcStreamEOF (DKC_STREAM *ptr)
DKC_EXTERN BOOL WINAPI | dkcStreamError (DKC_STREAM *ptr)
DKC_EXTERN int WINAPI | dkcStreamRead (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
| streamをリードする。freadみたいなもの
DKC_EXTERN int WINAPI | dkcStreamRead8 (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
| sizeは1byte単位･･･　ぶっちゃけdkcStreamRead()と同じ動作。 エンディアン問題に積極的に取り組む為に edkcStreamWriteErrorWhenEndianChangeが指定されている場合は明示的にこちらを使用する。
DKC_EXTERN int WINAPI | dkcStreamRead16 (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
DKC_EXTERN int WINAPI | dkcStreamRead32 (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
DKC_EXTERN int WINAPI | dkcStreamRead64 (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
DKC_EXTERN int WINAPI | dkcStreamRef (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
| streamの中身を見る。
DKC_EXTERN int WINAPI | dkcStreamRef8 (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
DKC_EXTERN int WINAPI | dkcStreamRef16 (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
DKC_EXTERN int WINAPI | dkcStreamRef32 (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
DKC_EXTERN int WINAPI | dkcStreamRef64 (DKC_STREAM *ptr, void *buffer, size_t size, size_t *readsize)
DKC_EXTERN int WINAPI | dkcStreamWrite (DKC_STREAM *ptr, const void *buffer, size_t size)
| streamをライトする。fwriteみたいなもの
DKC_EXTERN int WINAPI | dkcStreamWrite8 (DKC_STREAM *ptr, void *buffer, size_t size)
DKC_EXTERN int WINAPI | dkcStreamWrite16 (DKC_STREAM *ptr, const void *buffer, size_t size)
DKC_EXTERN int WINAPI | dkcStreamWrite32 (DKC_STREAM *ptr, const void *buffer, size_t size)
DKC_EXTERN int WINAPI | dkcStreamWrite64 (DKC_STREAM *ptr, const void *buffer, size_t size)
DKC_EXTERN int WINAPI | dkcStreamProcess (DKC_STREAM *ptr, void *buffer, size_t size, DKC_STREAM_PROCESS_TYPE write_t, void *data)
DKC_EXTERN int WINAPI | dkcStreamProcess16 (DKC_STREAM *ptr, void *buffer, size_t size, DKC_STREAM_PROCESS_TYPE write_t, void *data)
DKC_EXTERN int WINAPI | dkcStreamProcess32 (DKC_STREAM *ptr, void *buffer, size_t size, DKC_STREAM_PROCESS_TYPE write_t, void *data)
DKC_EXTERN int WINAPI | dkcStreamProcess64 (DKC_STREAM *ptr, void *buffer, size_t size, DKC_STREAM_PROCESS_TYPE write_t, void *data)

## 説明

覚え書き:
  ファイルストリームとメモリストリームのアダプターシステム エンディアン系を考慮したメモリシステム

DKC_STREAM構造体 BYTE DKC_STREAM::mSize個分。

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

## 型定義

typedef struct dkc_Stream DKC_STREAM

| 汎用型ストリーム

typedef int(WINAPI * DKC_STREAM_PROCESS_TYPE)(DKC_STREAM *p, void *buffer, size_t size, void *data)

  | 引数:
  | p[in] | DKC_STREAM *が入る
  | buffer[in][out] | 場合によってin、outになる。バッファへのポインタ
  | size[in] | bufferのサイズ
  | data[in] | 独自データへのポインタを受け取る
dkcStream.h の 238 行で定義されています。

## 列挙型

enum edkcStream

  | 列挙型の値:
  edkcStreamSeekCurrent | 今の位置からシーク
  edkcStreamSeekEnd | 最後の位置からシーク
  edkcStreamSeekSet | 最初の位置からシーク
  edkcStreamInitMemory | バッファとして初期化
  edkcStreamInitFile | バッファはfopenで初期化
  edkcStreamDefaultEndian | エンディアンデフォルト
  edkcStreamBigEndian | ビッグエンディアンモード
  edkcStreamLittleEndian | リトルエンディアンモード
  edkcStreamProcessDefault | dkcStreamRead() dkcStreamWrite()の挙動 指定したサイズ分読み込めない場合は返す
  edkcStreamProcessAsOrdered | dkcStreamRead() dkcStreamWrite()の挙動 指定したサイズ分 処理を実行する （エラーの時だけ返す)
  edkcStreamWriteErrorWhenEndianChange | dkcStreamRead() dkcStreamWrite()の挙動 明示的なエンディアンチェンジが出来ない書き込み、系関数にて エンディアンチェンジが必要だった時の場合はedk_Not_Satisfactoryを返すように指定
  edkcStreamInitMemoryAdapter | バッファ指定のストリームを外部のメモリ領域をセットしてアダプターとして使用するときに指定。 dkcMemoryStreamAdapter系列みたいな〜。
  edkcStreamWin32PromoteFlag |
  edkcStreamMacPromoteFlag |
dkcStream.h の 39 行で定義されています。
    00039                {
    00041     edkcStreamSeekCurrent = SEEK_CUR,
    00043     edkcStreamSeekEnd = SEEK_END,
    00045     edkcStreamSeekSet = SEEK_SET,
    00047     edkcStreamInitMemory = 1,
    00049     edkcStreamInitFile = 2,
    00051     edkcStreamDefaultEndian = 4,
    00053     edkcStreamBigEndian = 8,
    00055     edkcStreamLittleEndian = 16,
    00057     edkcStreamProcessDefault = 32,
    00059     edkcStreamProcessAsOrdered = 64,
    00063     edkcStreamWriteErrorWhenEndianChange = 128,
    00064
    00067     edkcStreamInitMemoryAdapter = 256,
    00068
    00069     edkcStreamWin32PromoteFlag = edkcStreamLittleEndian | edkcStreamProcessAsOrdered,
    00070     edkcStreamMacPromoteFlag = edkcStreamBigEndian | edkcStreamProcessAsOrdered,
    00071
    00072 };

## 関数

DKC_EXTERN 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 の 120 行で定義されています。 参照先 dkcAllocate(), dkcAllocMemoryStream(), dkcAllocMemoryStreamAdapter(), dkcFOpen(), dkcFree(), dkcStreamSeek(), dkcStreamWrite(), edkcStreamInitFile, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, edkcStreamSeekSet, dkc_Stream::mMode, dkc_Stream::mSig, NULL, と SetStreamInfo(). 参照元 dkcAllocReplace(), dkcAllocStreamEncouragementFileType(), dkcAllocStreamFileType(), dkcAllocStreamMemoryAdapterType(), と dkcAllocStreamMemoryType().
    00123 {
    00124
    00125     DKC_STREAM *p;
    00126     void *psig;
    00127
    00128
    00129     p = (DKC_STREAM *)dkcAllocate(sizeof(DKC_STREAM));
    00130     if(NULL==p){
    00131         return NULL;
    00132     }
    00133
    00134     if(DKUTIL_FAILED(SetStreamInfo(p,flag))){
    00135         goto Error;
    00136     }
    00137
    00138     switch(p->mMode){
    00139     case edkcStreamInitMemory:
    00140         psig = (void *)dkcAllocMemoryStream(size);
    00141         if(NULL==psig){
    00142             goto Error;
    00143         }
    00144         //update
    00145         p->mSig = psig;
    00146         //write default data
    00147         dkcStreamWrite(p,default_data,size);
    00148         dkcStreamSeek(p,0,edkcStreamSeekSet);
    00149         break;
    00150     case edkcStreamInitFile:
    00151         psig = (void *)dkcFOpen(filename,mode);
    00152         if(NULL==psig){
    00153             goto Error;
    00154         }
    00155         //update
    00156         p->mSig = psig;
    00157
    00158         break;
    00159     case edkcStreamInitMemoryAdapter:
    00160         psig = dkcAllocMemoryStreamAdapter((void *)default_data,size);
    00161         if(NULL==psig){
    00162             goto Error;
    00163         }
    00164         p->mSig = psig;
    00165     default:
    00166         goto Error;
    00167     }
    00168
    00169
    00170     //p->mEndianMode = endianmode
    00171
    00172     return p;
    00173 Error:
    00174     dkcFree((void **)&p);
    00175     return NULL;
    00176 }

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

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

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

| dkcStream.c の 91 行で定義されています。 参照先 dkcAllocStream(), edkcStreamInitFile, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, と NULL. 参照元 dkcFileBinaryCompare(), dkcFileToMemory(), dkcMemoryToFile(), と dkcOpenFileWithSignature().
    00091                                                                                           {
    00092     DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemory);
    00093     DKUTIL_FLAG_UP(flag,edkcStreamInitFile);
    00094     DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemoryAdapter);
    00095     return dkcAllocStream(flag,NULL,0,filename,mode);
    00096 }

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

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

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

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

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

  | dkcAllocNewStream()で確保したストリーム領域を開放する 引数:
  | ptr[in][out] | 削除するストリームデータ。入れたデータはNULLになる。
覚え書き: dkcStream.c の 179 行で定義されています。 参照先 dkcFClose(), dkcFree(), dkcFreeMemoryStream(), dkcFreeMemoryStreamAdapter(), dkcmNOT_ASSERT, edkcStreamInitFile, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, dkc_Stream::mMode, dkc_Stream::mSig, と NULL. 参照元 dkcAllocReplace(), dkcCloseFileWithSignature(), dkcFileBinaryCompare(), dkcFileToMemory(), dkcFreeReplace(), dkcMemoryToFile(), と dkcOpenFileWithSignature().
    00179                                         {
    00180     DKC_STREAM *t;
    00181     if(NULL==p){
    00182         return edk_FAILED;
    00183     }
    00184     t = *p;
    00185     if(NULL==t){
    00186         return edk_FAILED;
    00187     }
    00188
    00189     switch(t->mMode){
    00190     case edkcStreamInitMemory:
    00191         dkcFreeMemoryStream((DKC_MEMORYSTREAM **)&(t->mSig));
    00192         break;
    00193     case edkcStreamInitFile:
    00194         dkcFClose((FILE **)&(t->mSig));
    00195         break;
    00196     case edkcStreamInitMemoryAdapter:
    00197         dkcFreeMemoryStreamAdapter((DKC_MEMORYSTREAM_ADAPTER **)&(t->mSig));
    00198         break;
    00199 #ifdef DEBUG
    00200         default:
    00201             dkcmNOT_ASSERT("dkcFreeStream FAILED");
    00202 #endif
    00203     }
    00204     return dkcFree((void **)p);
    00205 }

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

| stream内をmemset(0)する。(seek位置も最初に戻される。 dkcStream.c の 786 行で定義されています。 参照先 dkcMemoryStreamAdapterClear, dkcMemoryStreamClear(), dkcStreamWrite(), edkcStreamInitFile, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, dkc_Stream::mMode, と dkc_Stream::mSig.
    00786                                           {
    00787     //file size
    00788     size_t fsize;
    00789     //temp size
    00790     size_t tsize;
    00791     size_t write_size;
    00792     FILE *fp;
    00793     int r = edk_FAILED;
    00794     char null_array[1024];
    00795
    00796
    00797     switch(ptr->mMode){
    00798     case edkcStreamInitMemory:
    00799         r = dkcMemoryStreamClear( (DKC_MEMORYSTREAM *)ptr->mSig );
    00800         break;
    00801     case edkcStreamInitFile:
    00802
    00803         memset(null_array,0,sizeof(null_array));
    00804         fp =(FILE *) ptr->mSig;
    00805
    00806
    00807         fseek( fp, 0, SEEK_END ) ;
    00808         fsize = ftell( fp ) ;
    00809         fseek( fp, 0, SEEK_SET ) ;
    00810
    00811         if(fsize > sizeof(null_array))
    00812         {//ファイルのサイズがNULL配列より大きい場合
    00813
    00814             tsize = 0;
    00815             write_size = sizeof(null_array);
    00816             for(;;){
    00817
    00818                 r = dkcStreamWrite(ptr,null_array,write_size);
    00819
    00820                 if(DKUTIL_FAILED(r)){
    00821                     return r;
    00822                 }
    00823                 if(tsize >= fsize){
    00824                     r = edk_SUCCEEDED;
    00825                     break;
    00826                 }
    00827
    00828                 if(tsize + write_size > fsize){
    00829                     write_size = fsize - tsize;
    00830                 }else{
    00831                     tsize += write_size;
    00832
    00833                     //こいつはいらないけど一応･･･
    00834                     write_size = sizeof(null_array);
    00835                 }
    00836             }
    00837         }else{//ちっこいなら上書き上書き･･･
    00838             r = dkcStreamWrite(ptr,null_array,fsize);
    00839         }
    00840
    00841         break;
    00842     case edkcStreamInitMemoryAdapter:
    00843         r = dkcMemoryStreamAdapterClear((DKC_MEMORYSTREAM_ADAPTER *)ptr->mSig);
    00844         break;
    00845
    00846
    00847     }
    00848     return r;
    00849 }

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

| 戻り値: EOFだとTRUE dkcStream.c の 265 行で定義されています。 参照先 edkcStreamInitFile, FALSE, dkc_Stream::mMode, dkc_Stream::mSig, と TRUE. 参照元 dkcFileBinaryCompare().
    00265                                          {
    00266     if(edkcStreamInitFile != ptr->mMode){
    00267         goto Exit;
    00268     }
    00269     if(0 != feof((FILE *)ptr->mSig)){
    00270         return TRUE;
    00271     }
    00272 Exit:
    00273     return FALSE;
    00274 }

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

| 戻り値: エラーだとTRUE dkcStream.c の 276 行で定義されています。 参照先 edkcStreamInitFile, FALSE, dkc_Stream::mMode, dkc_Stream::mSig, と TRUE. 参照元 dkcFileBinaryCompare().
    00276                                            {
    00277     if(edkcStreamInitFile != ptr->mMode){
    00278         goto Exit;
    00279     }
    00280     if(0 != ferror((FILE *)ptr->mSig)){
    00281         return TRUE;
    00282     }
    00283 Exit:
    00284     return FALSE;
    00285 }

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

| ストリーム内をフラッシュ（完全に書きこむ処理）する。 戻り値: edk_Resultのどれか dkcStream.c の 250 行で定義されています。 参照先 edkcStreamInitFile, dkc_Stream::mMode, と dkc_Stream::mSig.
    00250                                           {
    00251     int r = edk_SUCCEEDED;
    00252     //filter
    00253     if(edkcStreamInitFile!=ptr->mMode){
    00254         return edk_FAILED;
    00255     }
    00256
    00257     r = fflush((FILE *)ptr->mSig);
    00258
    00259     if(r==EOF){
    00260         return edk_FAILED;
    00261     }
    00262     return edk_SUCCEEDED;
    00263 }

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

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

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

| dkcStream.c の 666 行で定義されています。 参照先 dkcReverseEndian16(), dkc_Stream::mChangeEndian, と NULL. 参照元 dkcStreamRead16(), と dkcStreamWrite16().
    00667                                                                                                                         {
    00668     int r;
    00669     USHORT *pb;
    00670     size_t elem_num,pause = 16;
    00671     size_t i;
    00672
    00673     if(size % pause != 0){
    00674         return edk_ArgumentException;
    00675     }
    00676     if(ptr->mChangeEndian)
    00677     {//エンディアンチェンジが必要
    00678         pb = (USHORT *)malloc(size);
    00679         if(NULL==pb){
    00680             //return edk_FAILED;
    00681             return edk_OutOfMemory;
    00682         }
    00683
    00684         //メモリコピー
    00685         memcpy(pb,buffer,size);
    00686         elem_num = size / pause;
    00687
    00688         //エンディアンをチェンジさせる。
    00689         for(i=0;i<elem_num;i++){
    00690             pb[i] = dkcReverseEndian16(pb[i]);
    00691         }
    00692         //書き込む
    00693         r = write_t(ptr,pb,size,data);
    00694
    00695         free(pb);
    00696     }else{
    00697         r = write_t(ptr,buffer,size,data);
    00698     }
    00699     return r;
    00700 }

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

| dkcStream.c の 703 行で定義されています。 参照先 dkcReverseEndian32(), dkc_Stream::mChangeEndian, と NULL. 参照元 dkcStreamRead32(), と dkcStreamWrite32().
    00704                                                                                                                         {
    00705     int r;
    00706     ULONG *pb;
    00707     size_t elem_num,pause = 32;
    00708     size_t i;
    00709
    00710     if(size % pause != 0){
    00711         return edk_ArgumentException;
    00712     }
    00713     if(ptr->mChangeEndian)
    00714     {//エンディアンチェンジが必要
    00715         pb = (ULONG *)malloc(size);
    00716         if(NULL==pb){
    00717             return edk_OutOfMemory;
    00718         }
    00719
    00720         //メモリコピー
    00721         memcpy(pb,buffer,size);
    00722         elem_num = size / pause;
    00723
    00724         //エンディアンをチェンジさせる。
    00725         for(i=0;i<elem_num;i++){
    00726             pb[i] = dkcReverseEndian32(pb[i]);
    00727         }
    00728         //書き込む
    00729         r = write_t(ptr,pb,size,data);
    00730
    00731         free(pb);
    00732     }else{
    00733         r = write_t(ptr,buffer,size,data);
    00734     }
    00735     return r;
    00736
    00737 }

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

| dkcStream.c の 748 行で定義されています。 参照先 dkcReverseEndian64(), dkc_Stream::mChangeEndian, NULL, と ULONGLONG. 参照元 dkcStreamRead64(), と dkcStreamWrite64().
    00749                                                                                                                         {
    00750     int r;
    00751     ULONGLONG *pb;
    00752     size_t elem_num,pause = 64;
    00753     size_t i;
    00754
    00755     if(size % pause != 0){
    00756         return edk_ArgumentException;
    00757     }
    00758     if(ptr->mChangeEndian)
    00759     {//エンディアンチェンジが必要
    00760         pb = (ULONGLONG *)malloc(size);
    00761         if(NULL==pb){
    00762             return edk_OutOfMemory;
    00763         }
    00764
    00765         //メモリコピー
    00766         memcpy(pb,buffer,size);
    00767         elem_num = size / pause;
    00768
    00769         //エンディアンをチェンジさせる。
    00770         for(i=0;i<elem_num;i++){
    00771             pb[i] = dkcReverseEndian64(pb[i]);
    00772         }
    00773         //書き込む
    00774         r = write_t(ptr,pb,size,data);
    00775
    00776         free(pb);
    00777     }else{
    00778         r = write_t(ptr,buffer,size,data);
    00779     }
    00780     return r;
    00781 }

DKC_EXTERN 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 の 349 行で定義されています。 参照先 dkcMemoryStreamAdapterRead, dkcMemoryStreamRead(), dkcStreamReadObayAnOrder(), edkcStreamInitFile, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, edkcStreamProcessDefault, dkc_Stream::mMode, dkc_Stream::mProcessMode, dkc_Stream::mSig, と NULL. 参照元 dkcFileBinaryCompare(), dkcFileToMemory(), dkcStreamRead8(), dkcStreamRef(), ReadCallback(), と StreamRead().
    00349                                                                                               {
    00350     int r = edk_FAILED;
    00351     FILE *fp = (FILE *)ptr->mSig;
    00352     size_t redsize = 0;
    00353
    00354     //readsize filter
    00355     if(NULL==readsize){
    00356         readsize = &redsize;
    00357     }
    00358
    00359     //エンディアンチェンジ指定されているよ〜〜。
    00360     /*if(flag & edkcStreamReadErrorWhenEndianChange){
    00361         if(ptr->mChangeEndian){
    00362             return edk_Not_Satisfactory;
    00363         }
    00364     }*/
    00365
    00366     switch(ptr->mMode){
    00367     case edkcStreamInitMemory:
    00368         r = dkcMemoryStreamRead((DKC_MEMORYSTREAM *)ptr->mSig,
    00369             buffer,size,readsize);
    00370         break;
    00371     case edkcStreamInitFile:
    00372
    00373         if(ptr->mProcessMode & edkcStreamProcessDefault){
    00374
    00375             *readsize = fread(buffer,1,size,fp);
    00376
    00377             //set result
    00378             if(feof(fp)){
    00379                 r = edk_BufferOverFlow;
    00380             }else if(!ferror(fp)){
    00381                 r = edk_SUCCEEDED;
    00382             }
    00383
    00384         }else{
    00385             r = dkcStreamReadObayAnOrder(ptr,buffer,size,readsize);
    00386         }
    00387
    00388
    00389         break;
    00390     case edkcStreamInitMemoryAdapter:
    00391         r = dkcMemoryStreamAdapterRead((DKC_MEMORYSTREAM_ADAPTER *)
    00392             ptr->mSig,buffer,size,readsize);
    00393         break;
    00394     }
    00395     return r;
    00396 }

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

  | 覚え書き: sizeは2byte単位でないといけない 引数:
  | flag[in] | edkcStreamProcessAsOrdered 指定したサイズで読みこめない時は edkcStreamProcessDefault
TODO: test dkcStream.c の 407 行で定義されています。 参照先 dkcStreamProcess16(), と StreamRead(). 参照元 dkcStreamRef16().
    00408 {
    00409     return dkcStreamProcess16(ptr,buffer,size,StreamRead,(void *)readsize);
    00410     /*
    00411     size_t sentinel = size / 2;
    00412     size_t i = 0;
    00413     size_t t_rs = 0;
    00414
    00415     USHORT *pus;
    00416
    00417     size_t real_readsize = 0;
    00418     int result;
    00419
    00420     //filter
    00421     if(size_t % 2 != 0){
    00422         return edk_ArgumentException;
    00423     }
    00424
    00425     pus = (USHORT *)buffer;
    00426
    00427     for(;i<sentinel;i++){
    00428         //process
    00429         result = dkcStreamRead(ptr,&pus[i],2,&t_rs);
    00430
    00431
    00432         //update data
    00433         real_readsize += t_rs;
    00434
    00435
    00436         //process state update check
    00437         switch(result){
    00438         case edkSUCCEEDED:
    00439             continue;
    00440         case edk_FAILED:
    00441         case edk_BufferOverFlow:
    00442             goto End;
    00443         default:
    00444             dkcmNOT_ASSERT("dkcStreamSwapRead16 Error");
    00445             goto End;
    00446         }
    00447     }//end of for
    00448 End:
    00449     if(readsize){//set readsize
    00450         *readsize = real_readsize;
    00451     }
    00452     //process result
    00453     return result;
    00454     */
    00455 }

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

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

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

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

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

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

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

| streamの中身を見る。 tとして保存していた物を指定して　元の位置に戻す dkcStream.c の 466 行で定義されています。 参照先 dkcStreamRead(), dkcStreamSeek(), dkcStreamTell(), と edkcStreamSeekSet.
    00467 {
    00468     //位置を記憶
    00469     long t = dkcStreamTell(ptr);
    00470     //読みこむ（内部で位置がsize分（readsize分）ずらされる）
    00471     int r = dkcStreamRead(ptr,buffer,size,readsize);
    00472
    00473
    00474     /*
    00475     if(readsize > INT_MAX){
    00476         dkcmNOT_ASSEERT("INT_MAX byteも一気に読みこむな！ヽ(`Д´)ノムキィ");
    00477         return edk_FAILED;
    00478     }
    00479     t = (*readsize) - t;
    00480
    00481     //この条件はありえない。
    00482     dkcmNOT_ASSERT(t < 0);*/
    00483
    00484
    00486     dkcStreamSeek(ptr,t,edkcStreamSeekSet);
    00487     return r;
    00488 }

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

| dkcStream.c の 490 行で定義されています。 参照先 dkcStreamRead16(), dkcStreamSeek(), dkcStreamTell(), と edkcStreamSeekSet.
    00490                                                                                     {
    00491     long t = dkcStreamTell(ptr);
    00492     int r = dkcStreamRead16(ptr,buffer,size,readsize);
    00493     dkcStreamSeek(ptr,t,edkcStreamSeekSet);
    00494     return r;
    00495 }

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

| 覚え書き: sizeは4byte単位でないといけない dkcStream.c の 501 行で定義されています。 参照先 dkcStreamRead32(), dkcStreamSeek(), dkcStreamTell(), と edkcStreamSeekSet.
    00501                                                                                     {
    00502     long t = dkcStreamTell(ptr);
    00503     int r = dkcStreamRead32(ptr,buffer,size,readsize);
    00504     dkcStreamSeek(ptr,t,edkcStreamSeekSet);
    00505     return r;
    00506 }

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

| 覚え書き: sizeは8byte単位でないといけない dkcStream.c の 511 行で定義されています。 参照先 dkcStreamRead64(), dkcStreamSeek(), dkcStreamTell(), と edkcStreamSeekSet.
    00511                                                                                     {
    00512     long t = dkcStreamTell(ptr);
    00513     int r = dkcStreamRead64(ptr,buffer,size,readsize);
    00514     dkcStreamSeek(ptr,t,edkcStreamSeekSet);
    00515     return r;
    00516
    00517 }

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

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

| streamをシークする。fseekみたいなもの 戻り値: edk_SUCCEEDEDで成功　それ以外はエラー dkcStream.c の 210 行で定義されています。 参照先 dkcMemoryStreamSeek(), dkcMemroyStreamAdapterSeek, edkcStreamInitFile, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, dkc_Stream::mMode, と dkc_Stream::mSig. 参照元 dkcAllocStream(), dkcCloseFileWithSignature(), dkcOpenFileWithSignature(), dkcStreamRef(), dkcStreamRef16(), dkcStreamRef32(), と dkcStreamRef64().
    00210                                                                {
    00211     int r = edk_FAILED;
    00212     switch(ptr->mMode){
    00213     case edkcStreamInitMemory:
    00214         r = dkcMemoryStreamSeek((DKC_MEMORYSTREAM *)ptr->mSig,offset,origin);
    00215         break;
    00216     case edkcStreamInitFile:
    00217         //成功したら０ == edk_SUCCEEDED;
    00218         r = fseek((FILE *)ptr->mSig,offset,origin);
    00219         break;
    00220     case edkcStreamInitMemoryAdapter:
    00221         r = dkcMemroyStreamAdapterSeek((DKC_MEMORYSTREAM_ADAPTER *)ptr->mSig,offset,origin);
    00222         break;
    00223     }
    00224     return r;
    00225
    00226 }

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

| streamの位置を取得する。 戻り値: edkcStreamSeekSetからのオフセット値。edk_FAILEDだとエラー dkcStream.c の 229 行で定義されています。 参照先 dkcMemoryStreamAdapterTell, dkcMemoryStreamTell, edkcStreamInitFile, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, dkc_Stream::mMode, と dkc_Stream::mSig. 参照元 dkcCloseFileWithSignature(), dkcFileWithSignatureCheckCheat(), dkcFileWithSignatureRead(), dkcStreamRef(), dkcStreamRef16(), dkcStreamRef32(), dkcStreamRef64(), と ReadEOFCheck().
    00229                                           {
    00230     int r = edk_FAILED;
    00231     switch(ptr->mMode){
    00232     case edkcStreamInitMemory:
    00233         r =  dkcMemoryStreamTell((DKC_MEMORYSTREAM *)ptr->mSig);
    00234         break;
    00235     case edkcStreamInitFile:
    00236         r = ftell((FILE *)ptr->mSig);
    00237         if(r==-1){
    00238             return edk_FAILED;
    00239         }
    00240         break;
    00241
    00242     case edkcStreamInitMemoryAdapter:
    00243         r = dkcMemoryStreamAdapterTell((DKC_MEMORYSTREAM_ADAPTER *)ptr->mSig);
    00244         break;
    00245     }
    00246     return r;
    00247     //dkcmNOT_ASSERT("dkcStreamTell failed");
    00248 }

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

| streamをライトする。fwriteみたいなもの 書き込み指定がこうなっているので･･･。 dkcStream.c の 578 行で定義されています。 参照先 dkcMemoryStreamAdapterWrite, dkcMemoryStreamWrite(), dkcStreamWriteObayAnOrder(), edkcStreamInitFile, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, edkcStreamWriteErrorWhenEndianChange, dkc_Stream::mChangeEndian, dkc_Stream::mMode, dkc_Stream::mProcessMode, と dkc_Stream::mSig. 参照元 dkcAllocStream(), dkcFileWithSignatureWrite(), dkcMemoryToFile(), dkcOpenFileWithSignature(), dkcStreamClear(), dkcStreamWrite8(), HeaderWrite(), と StreamWrite().
    00579 {
    00580     int r = edk_FAILED;
    00581
    00582     UINT proc_flag = ptr->mProcessMode;
    00584     if(proc_flag & edkcStreamWriteErrorWhenEndianChange){
    00585         if(ptr->mChangeEndian){
    00586             return edk_Not_Satisfactory;
    00587         }
    00588     }
    00589
    00590     switch(ptr->mMode){
    00591     case edkcStreamInitMemory:
    00592         r =  dkcMemoryStreamWrite((DKC_MEMORYSTREAM *)ptr->mSig,buffer,size);
    00593         break;
    00594     case edkcStreamInitFile:
    00595         r = dkcStreamWriteObayAnOrder(ptr,buffer,size);
    00596         break;
    00597     case edkcStreamInitMemoryAdapter:
    00598         r = dkcMemoryStreamAdapterWrite((DKC_MEMORYSTREAM_ADAPTER *)ptr->mSig,buffer,size);
    00599
    00600         break;
    00601     }
    00602
    00603     return r;
    00604 }

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

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

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

| dkcStream.c の 644 行で定義されています。 参照先 dkcStreamProcess32(), NULL, と StreamWrite(). 参照元 dkcFileWithSignatureWrite32().
    00644                                                                             {
    00645     return dkcStreamProcess32(ptr,(void *)buffer,size,StreamWrite,NULL);
    00646
    00647 }

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

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

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

| dkcStream.c の 637 行で定義されています。 参照先 dkcStreamWrite().
    00637                                                                     {
    00638     return dkcStreamWrite(ptr,buffer,size);
    00639 }