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

dkcStream.c

#include "dkcOSIndependent.h"
#include "dkcStream.h"
#include "dkcStdio.h"
#include "dkcMemoryStream.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 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みたいなもの
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)
DKC_INLINE int WINAPI dkcStreamWrite (DKC_STREAM *ptr, const void *buffer, size_t size)
 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.c7 行で定義されています。


関数

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.c120 行で定義されています。

参照先 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_STREAM* WINAPI dkcAllocStreamEncouragementFileType const char *  filename,
const char *  mode,
BOOL  OrderFlag
 

ファイル用ストリームの領域を得る時の奨励版の関数

引数:
OrderFlag[in] 指定した通りに読みこむタイプならTRUE (edkcStreamProcessAsOrdered)
覚え書き:
仕様:強制的に吐き出すファイルのエンディアンはリトルエンディアン

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

参照先 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_STREAM* WINAPI dkcAllocStreamFileType UINT  flag,
const char *  filename,
const char *  mode
 

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

参照先 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_STREAM* WINAPI dkcAllocStreamMemoryAdapterType UINT  flag,
void *  adapt_buffer,
size_t  size
 

覚え書き:
adapt_bufferに入れたメモリ領域は自動的に開放されませんので各自で開放してください。

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

参照先 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_STREAM* WINAPI dkcAllocStreamMemoryType UINT  flag,
const void *  default_data,
size_t  size
 

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

参照先 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 }

int WINAPI dkcFreeStream DKC_STREAM **  ptr  ) 
 

dkcAllocNewStream()で確保したストリーム領域を開放する

引数:
ptr[in][out] 削除するストリームデータ。入れたデータはNULLになる。
覚え書き:

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

参照先 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 }

int WINAPI dkcStreamClear DKC_STREAM ptr  ) 
 

stream内をmemset(0)する。(seek位置も最初に戻される。

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

参照先 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 }

BOOL WINAPI dkcStreamEOF DKC_STREAM ptr  ) 
 

戻り値:
EOFだとTRUE

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

参照先 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 }

BOOL WINAPI dkcStreamError DKC_STREAM ptr  ) 
 

戻り値:
エラーだとTRUE

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

参照先 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 }

int WINAPI dkcStreamFlush DKC_STREAM ptr  ) 
 

ストリーム内をフラッシュ(完全に書きこむ処理)する。

戻り値:
edk_Resultのどれか

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

参照先 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 }

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

TODO:
各ストリームプロセスのmalloc部を高速化するにはMemoryPoolを使う。

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

参照元 dkcFileWithSignatureWrite(), dkcFileWithSignatureWrite16(), dkcFileWithSignatureWrite32(), dkcFileWithSignatureWrite64(), と FileWithSignatureReadLogic().

00660 {
00661     return write_t(ptr,buffer,size,data);
00662 }

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

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

参照先 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 }

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

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

参照先 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 }

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

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

参照先 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_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.c349 行で定義されています。

参照先 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 }

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

覚え書き:
sizeは2byte単位でないといけない
引数:
flag[in] edkcStreamProcessAsOrdered 指定したサイズで読みこめない時は edkcStreamProcessDefault
TODO:
test

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

参照先 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 }

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

覚え書き:
sizeは4byte単位でないといけない

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

参照先 dkcStreamProcess32(), と StreamRead().

参照元 dkcStreamRef32().

00457                                                                                      {
00458     return dkcStreamProcess32(ptr,buffer,size,StreamRead,(void *)readsize);
00459 }

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

覚え書き:
sizeは8byte単位でないといけない

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

参照先 dkcStreamProcess64(), と StreamRead().

参照元 dkcStreamRef64().

00461                                                                                      {
00462     return dkcStreamProcess64(ptr,buffer,size,StreamRead,(void *)readsize);
00463 }

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

sizeは1byte単位・・・ ぶっちゃけdkcStreamRead()と同じ動作。 エンディアン問題に積極的に取り組む為に edkcStreamWriteErrorWhenEndianChangeが指定されている場合は明示的にこちらを使用する。

TODO:
仕様を満たしていないバグがあるかも または仕様、実装変更

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

参照先 dkcStreamRead().

00403                                                                                     {
00404     return dkcStreamRead(ptr,buffer,size,readsize);
00405 }

static DKC_INLINE int dkcStreamReadObayAnOrder DKC_STREAM ptr,
void *  buffer,
size_t  size,
size_t *  readsize
[static]
 

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

参照先 BYTE, dkcmNOT_ASSERT, dkc_Stream::mSig, と NULL.

参照元 dkcStreamRead().

00290 {
00291     int r = edk_FAILED;
00292     size_t readsize_ = 0;
00293     size_t count;
00294     size_t tc,tsize;
00295     BYTE *tbuffer;
00296     FILE *fp = (FILE *)ptr->mSig;
00297 
00298     if(NULL==readsize){
00299         readsize = &readsize_;
00300     }
00301 
00302     //1,sizeの引数を入れ替えるとどうか?
00303     //1 = fread(buffer,size,1,ptr->mfp);
00304     //read size
00305     tsize = size;
00306     //temp variable
00307     tc = 0;
00308     //offset counter
00309     count = 0;
00310     //byte type pointer
00311     tbuffer = (BYTE *)buffer;
00312     for(;;)
00313     {
00314         //error check
00315         if(ferror(fp) ){
00316             //*readsize = count;
00317             r = edk_FAILED;
00318             break;
00319         }
00320         if(feof(fp)){
00321             //*readsize = count;
00322             r = edk_BufferOverFlow;
00323             break;
00324         }
00325         //read
00326         tc = fread(&tbuffer[count],1,tsize,fp);
00327         //update
00328         tsize -= tc;
00329         count += tc;
00330 
00331         if(count == size){
00332             r = edk_SUCCEEDED;
00333             break;
00334         }
00335 #   ifdef DEBUG
00336         //ありえないエラーチェック
00337         dkcmNOT_ASSERT(count > size);
00338 #   else
00339         if(count > size){
00340             break;
00341         }
00342 #   endif
00343     }
00344     *readsize = count;
00345     return r;
00346 
00347 }

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

streamの中身を見る。

tとして保存していた物を指定して 元の位置に戻す

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

参照先 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 }

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

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

参照先 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 }

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

覚え書き:
sizeは4byte単位でないといけない

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

参照先 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 }

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

覚え書き:
sizeは8byte単位でないといけない

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

参照先 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 }

int WINAPI dkcStreamSeek DKC_STREAM ptr,
int  offset,
int  origin
 

streamをシークする。fseekみたいなもの

戻り値:
edk_SUCCEEDEDで成功 それ以外はエラー

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

参照先 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         //成功したら0 == 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 }

long WINAPI dkcStreamTell DKC_STREAM ptr  ) 
 

streamの位置を取得する。

戻り値:
edkcStreamSeekSetからのオフセット値。edk_FAILEDだとエラー

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

参照先 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_INLINE int WINAPI dkcStreamWrite DKC_STREAM ptr,
const void *  buffer,
size_t  size
 

streamをライトする。fwriteみたいなもの

書き込み指定がこうなっているので・・・。

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

参照先 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 }

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

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

参照先 dkcStreamProcess16(), NULL, と StreamWrite().

参照元 dkcFileWithSignatureWrite16().

00640                                                                             {
00641     return dkcStreamProcess16(ptr,(void *)buffer,size,StreamWrite,NULL);
00642 }

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

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

参照先 dkcStreamProcess32(), NULL, と StreamWrite().

参照元 dkcFileWithSignatureWrite32().

00644                                                                             {
00645     return dkcStreamProcess32(ptr,(void *)buffer,size,StreamWrite,NULL);
00646 
00647 }

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

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

参照先 dkcStreamProcess64(), NULL, と StreamWrite().

参照元 dkcFileWithSignatureWrite64().

00651                                                                             {
00652     return dkcStreamProcess64(ptr,(void *)buffer,size,StreamWrite,NULL);        
00653 }

int WINAPI dkcStreamWrite8 DKC_STREAM ptr,
void *  buffer,
size_t  size
 

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

参照先 dkcStreamWrite().

00637                                                                     {
00638     return dkcStreamWrite(ptr,buffer,size);
00639 }

static DKC_INLINE int dkcStreamWriteObayAnOrder DKC_STREAM ptr,
const void *  buffer,
size_t  size
[static]
 

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

参照先 BYTE, dkcmNOT_ASSERT, と dkc_Stream::mSig.

参照元 dkcStreamWrite().

00532                                                                                                {
00533     int r = edk_FAILED;
00534     size_t tc,tsize;
00535     size_t count;
00536     const BYTE *tbuffer = (const BYTE *)buffer;
00537     FILE *fp;
00538 
00539     tc = 0;
00540     count = 0;
00541     tsize = size;
00542     fp =  (FILE *)ptr->mSig;
00543 
00544     for(;;){
00545         //error check
00546         if(ferror(fp)){
00547             return edk_FAILED;
00548         }
00549         if(feof(fp)){
00550             return edk_BufferOverFlow;
00551         }
00552         //write
00553         tc = fwrite(&tbuffer[count],1,tsize,fp);
00554         //update
00555         tsize -= tc;
00556         count += tc;
00557 
00558         if(count == size){
00559             r = edk_SUCCEEDED;
00560             break;
00561         }
00562 #   ifdef DEBUG
00563         //ありえないエラーチェック
00564         dkcmNOT_ASSERT(count > size);
00565 #   else
00566         if(count > size){
00567 
00568             break;
00569         }
00570 #   endif
00571 
00572     }
00573 
00574 
00575     return r;
00576 }

static DKC_INLINE int SetStreamInfo DKC_STREAM p,
UINT  flag
[static]
 

ストリームの種類をきめる

エンディアンをきめる

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

参照先 BYTE, dkcIsLittleEndian(), dkcmNOT_ASSERT, edkcStreamBigEndian, edkcStreamInitFile, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, edkcStreamLittleEndian, edkcStreamProcessAsOrdered, edkcStreamProcessDefault, edkcStreamWriteErrorWhenEndianChange, FALSE, dkc_Stream::mChangeEndian, dkc_Stream::mMode, dkc_Stream::mProcessMode, と TRUE.

参照元 dkcAllocStream().

00015                                                             {
00016     UINT stream_mode = 0;
00017     BYTE endian_mode = 0;
00018     UINT proc_mode = 0;
00019 
00020     BOOL isLittle = dkcIsLittleEndian();
00021 
00022 
00024     if(flag & edkcStreamInitMemory){
00025         stream_mode = edkcStreamInitMemory;
00026     }else if(flag & edkcStreamInitFile){
00027         stream_mode = edkcStreamInitFile;
00028     }else if(flag & edkcStreamInitMemoryAdapter){
00029         stream_mode = edkcStreamInitMemoryAdapter;
00030     }else{
00031         goto Error;
00032     }
00033 
00034 
00035     endian_mode = FALSE;
00037     if(flag & edkcStreamBigEndian){
00038         //endianmode = edkcStreamBigEndian;
00039         if(isLittle){
00040             endian_mode = TRUE;
00041         }
00042     }else if(flag & edkcStreamLittleEndian){
00043         //endianmode = edkcStreamLittleEndian;
00044         if(!isLittle){
00045             endian_mode = TRUE;
00046         }
00047     }else /*if(flag & edkcStreamInitDefaultEndian)*/{
00048         if(isLittle){
00049             //endianmode = edkcStreamLittleEndian;
00050         }else{
00051             //endianmode = edkcStreamBigEndian;
00052         }
00053     }
00054 
00055     //プロセスの詳細 設定
00056     proc_mode |= (flag & edkcStreamProcessDefault);
00057     if(0==proc_mode){
00058         proc_mode |= (flag &    edkcStreamProcessAsOrdered);
00059         
00060         if(0==proc_mode){
00061             proc_mode |=    edkcStreamProcessAsOrdered;
00062         }
00063     }
00064     proc_mode |= (flag &    edkcStreamWriteErrorWhenEndianChange );
00065 
00066     //update
00067     p->mMode = stream_mode;
00068 
00069     dkcmNOT_ASSERT(proc_mode > UCHAR_MAX);
00070     p->mProcessMode = (BYTE)proc_mode;
00071 
00072     p->mChangeEndian = endian_mode;
00073 
00074     return edk_SUCCEEDED;
00075 Error:
00076     return edk_FAILED;
00077 
00078 }

static int WINAPI StreamRead DKC_STREAM ptr,
void *  buffer,
size_t  size,
void *  hoge
[static]
 

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

参照先 dkcStreamRead().

参照元 dkcStreamRead16(), dkcStreamRead32(), と dkcStreamRead64().

00398                                                                                   {
00399     return dkcStreamRead(ptr,buffer,size,(size_t *)hoge);   
00400 }

static int WINAPI StreamWrite DKC_STREAM ptr,
void *  buffer,
size_t  size,
void *  hoge
[static]
 

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

参照先 dkcStreamWrite().

参照元 dkcStreamWrite16(), dkcStreamWrite32(), と dkcStreamWrite64().

00606                                                                                    {
00607     return dkcStreamWrite(ptr,buffer,size); 
00608 }


dkutil_cに対してSat Sep 10 09:25:16 2005に生成されました。  doxygen 1.4.4