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

dkcStream.c

#include "dkcOSIndependent.h"
#include "dkcStream.h"
#include "dkcStdio.h"
#include <limits.h>

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

Include dependency graph

ソースコードを見る。

マクロ定義

#define DKUTIL_C_STREAM_C

関数

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 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みたいなもの edk_SUCCEEDEDで成功 それ以外はエラー

long WINAPI dkcStreamTell (DKC_STREAM *ptr)
 streamの位置を取得する。 edkcStreamSeekSetからのオフセット値。edk_FAILEDだとエラー

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

BOOL WINAPI dkcStreamEOF (DKC_STREAM *ptr)
 EOFだとTRUE.

BOOL WINAPI dkcStreamError (DKC_STREAM *ptr)
 エラーだとTRUE

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みたいなもの

int WINAPI StreamRead (DKC_STREAM *ptr, void *buffer, size_t size, void *hoge)
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)
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みたいなもの

int WINAPI StreamWrite (DKC_STREAM *ptr, void *buffer, size_t size, void *hoge)
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.c108 行で定義されています。

参照先 DKC_STREAM, dkcAllocate(), dkcAllocMemoryStream(), dkcFOpen(), dkcFree(), dkcStreamWrite(), edkcStreamInitFile, edkcStreamInitMemory, dkc_Stream::mMode, dkc_Stream::mSig, NULL, と SetStreamInfo().

参照元 dkcAllocReplace(), dkcAllocStreamEncouragementFileType(), dkcAllocStreamFileType(), dkcAllocStreamMemoryType(), と dkcNewCircularStream().

00111 {
00112     
00113     DKC_STREAM *p;
00114     void *psig;
00115 
00116 
00117     p = (DKC_STREAM *)dkcAllocate(sizeof(DKC_STREAM));
00118     if(NULL==p){
00119         return NULL;
00120     }
00121 
00122     if(DKUTIL_FAILED(SetStreamInfo(p,flag))){
00123         goto Error;
00124     }
00125 
00126     switch(p->mMode){
00127     case edkcStreamInitMemory:
00128         psig = (void *)dkcAllocMemoryStream(size);
00129         if(NULL==psig){
00130             goto Error;
00131         }
00132         //update    
00133         p->mSig = psig;
00134         //write default data
00135         dkcStreamWrite(p,default_data,size);
00136         break;
00137     case edkcStreamInitFile:
00138         psig = (void *)dkcFOpen(filename,mode);
00139         if(NULL==psig){
00140             goto Error;
00141         }
00142         //update
00143         p->mSig = psig;
00144         
00145         break;
00146     default:
00147         goto Error;
00148     }
00149 
00150     
00151     //p->mEndianMode = endianmode
00152 
00153     return p;
00154 Error:
00155     dkcFree((void **)&p);
00156     return NULL;
00157 }

DKC_STREAM* WINAPI dkcAllocStreamEncouragementFileType const char *  filename,
const char *  mode,
BOOL  OrderFlag
 

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

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

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

参照先 BOOL, DKC_STREAM, dkcAllocStream(), edkcStreamBigEndian, edkcStreamInitFile, edkcStreamLittleEndian, edkcStreamProcessAsOrdered, edkcStreamProcessDefault, と NULL.

00094 {
00095     UINT flag = 0;
00096     DKUTIL_FLAG_UP(flag,edkcStreamInitFile);
00097     DKUTIL_FLAG_UP(flag,edkcStreamLittleEndian);
00098     DKUTIL_FLAG_DOWN(flag,edkcStreamBigEndian);
00099     if(OrderFlag){
00100         DKUTIL_FLAG_UP(flag,edkcStreamProcessAsOrdered );
00101     }else{
00102         DKUTIL_FLAG_UP(flag,edkcStreamProcessDefault);
00103     }
00104     return dkcAllocStream(flag,NULL,0,filename,mode);
00105 }

DKC_STREAM* WINAPI dkcAllocStreamFileType UINT  flag,
const char *  filename,
const char *  mode
 

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

参照先 DKC_STREAM, dkcAllocStream(), edkcStreamInitFile, edkcStreamInitMemory, と NULL.

参照元 dkcFileBinaryCompare(), dkcFileToMemory(), dkcMemoryToFile(), と dkcOpenFileWithSignature().

00087                                                                                           {
00088     DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemory);
00089     DKUTIL_FLAG_UP(flag,edkcStreamInitFile);
00090     return dkcAllocStream(flag,NULL,0,filename,mode);
00091 }

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

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

参照先 DKC_STREAM, dkcAllocStream(), edkcStreamInitFile, edkcStreamInitMemory, と NULL.

00080                                                                                            {
00081     DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile);
00082     DKUTIL_FLAG_UP(flag,edkcStreamInitMemory);
00083     return dkcAllocStream(flag,default_data,size,NULL,NULL);
00084 
00085 }

int WINAPI dkcFreeStream DKC_STREAM **  ptr  ) 
 

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

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

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

参照先 DKC_MEMORYSTREAM, DKC_STREAM, dkcFClose(), dkcFree(), dkcFreeMemoryStream(), dkcmNOT_ASSERT, edkcStreamInitFile, edkcStreamInitMemory, dkc_Stream::mMode, dkc_Stream::mSig, と NULL.

参照元 dkcAllocReplace(), dkcCloseFileWithSignature(), dkcFileBinaryCompare(), dkcFileToMemory(), dkcFreeReplace(), dkcMemoryToFile(), と dkcOpenFileWithSignature().

00160                                         {
00161     DKC_STREAM *t;
00162     if(NULL==p){
00163         return edk_FAILED;
00164     }
00165     t = *p;
00166     if(NULL==t){
00167         return edk_FAILED;
00168     }
00169 
00170     switch(t->mMode){
00171     case edkcStreamInitMemory:
00172         dkcFreeMemoryStream((DKC_MEMORYSTREAM **)&(t->mSig));
00173         break;
00174     case edkcStreamInitFile:
00175         dkcFClose((FILE **)&(t->mSig));
00176         break;
00177 #ifdef DEBUG
00178         default:
00179             dkcmNOT_ASSERT("dkcFreeStream FAILED");
00180 #endif
00181     }
00182     return dkcFree((void **)p);
00183 }

int WINAPI dkcStreamClear DKC_STREAM ptr  ) 
 

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

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

参照先 DKC_MEMORYSTREAM, DKC_STREAM, dkcMemoryStreamClear(), dkcStreamWrite(), edkcStreamInitFile, edkcStreamInitMemory, dkc_Stream::mMode, と dkc_Stream::mSig.

参照元 dkcCircularStreamZero().

00738                                           {
00739     //file size
00740     size_t fsize;
00741     //temp size
00742     size_t tsize;
00743     size_t write_size;
00744     FILE *fp;
00745     int r = edk_FAILED;
00746     char null_array[1024];
00747 
00748 
00749     switch(ptr->mMode){
00750     case edkcStreamInitMemory:
00751         r = dkcMemoryStreamClear( (DKC_MEMORYSTREAM *)ptr->mSig );
00752         break;
00753     case edkcStreamInitFile:
00754         
00755         memset(null_array,0,sizeof(null_array));
00756         fp =(FILE *) ptr->mSig;
00757 
00758 
00759         fseek( fp, 0, SEEK_END ) ;
00760         fsize = ftell( fp ) ;
00761         fseek( fp, 0, SEEK_SET ) ;
00762         
00763         if(fsize > sizeof(null_array))
00764         {//ファイルのサイズがNULL配列より大きい場合
00765             
00766             tsize = 0;
00767             write_size = sizeof(null_array);
00768             for(;;){
00769                 
00770                 r = dkcStreamWrite(ptr,null_array,write_size);
00771                 
00772                 if(DKUTIL_FAILED(r)){
00773                     return r;
00774                 }
00775                 if(tsize >= fsize){
00776                     r = edk_SUCCEEDED;
00777                     break;
00778                 }
00779 
00780                 if(tsize + write_size > fsize){
00781                     write_size = fsize - tsize;
00782                 }else{
00783                     tsize += write_size;
00784 
00785                     //こいつはいらないけど一応・・・
00786                     write_size = sizeof(null_array);
00787                 }
00788             }
00789         }else{//ちっこいなら上書き上書き・・・
00790             r = dkcStreamWrite(ptr,null_array,fsize);
00791         }
00792 
00793         break;
00794     }
00795     return r;
00796 }

BOOL WINAPI dkcStreamEOF DKC_STREAM ptr  ) 
 

EOFだとTRUE.

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

参照先 BOOL, DKC_STREAM, edkcStreamInitFile, FALSE, dkc_Stream::mMode, dkc_Stream::mSig, と TRUE.

参照元 dkcFileBinaryCompare().

00234                                          {
00235     if(edkcStreamInitFile != ptr->mMode){
00236         goto Exit;
00237     }
00238     if(0 != feof((FILE *)ptr->mSig)){
00239         return TRUE;
00240     }
00241 Exit:
00242     return FALSE;
00243 }

BOOL WINAPI dkcStreamError DKC_STREAM ptr  ) 
 

エラーだとTRUE

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

参照先 BOOL, DKC_STREAM, edkcStreamInitFile, FALSE, dkc_Stream::mMode, dkc_Stream::mSig, と TRUE.

参照元 dkcFileBinaryCompare().

00245                                            {
00246     if(edkcStreamInitFile != ptr->mMode){
00247         goto Exit;
00248     }
00249     if(0 != ferror((FILE *)ptr->mSig)){
00250         return TRUE;
00251     }
00252 Exit:
00253     return FALSE;
00254 }

int WINAPI dkcStreamFlush DKC_STREAM ptr  ) 
 

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

戻り値:
edk_Resultのどれか

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

参照先 DKC_STREAM, edkcStreamInitFile, dkc_Stream::mMode, と dkc_Stream::mSig.

00219                                           {
00220     int r = edk_SUCCEEDED;
00221     //filter
00222     if(edkcStreamInitFile!=ptr->mMode){
00223         return edk_FAILED;
00224     }
00225 
00226     r = fflush((FILE *)ptr->mSig);
00227 
00228     if(r==EOF){
00229         return edk_FAILED;
00230     }
00231     return edk_SUCCEEDED;
00232 }

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

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

参照先 DKC_STREAM, と DKC_STREAM_PROCESS_TYPE.

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

00612 {
00613     return write_t(ptr,buffer,size,data);
00614 }

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

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

参照先 DKC_STREAM, DKC_STREAM_PROCESS_TYPE, dkcReverseEndian16(), dkc_Stream::mChangeEndian, と NULL.

参照元 dkcStreamRead16(), と dkcStreamWrite16().

00619                                                                                                                         {
00620     int r;
00621     USHORT *pb;
00622     size_t elem_num,pause = 16;
00623     size_t i;
00624 
00625     if(size % pause != 0){
00626         return edk_ArgumentException;
00627     }
00628     if(ptr->mChangeEndian)
00629     {//エンディアンチェンジが必要
00630         pb = (USHORT *)malloc(size);
00631         if(NULL==pb){
00632             //return edk_FAILED;
00633             return edk_OutOfMemory;
00634         }
00635         
00636         //メモリコピー
00637         memcpy(pb,buffer,size);
00638         elem_num = size / pause;
00639 
00640         //エンディアンをチェンジさせる。
00641         for(i=0;i<elem_num;i++){
00642             pb[i] = dkcReverseEndian16(pb[i]);
00643         }
00644         //書き込む
00645         r = write_t(ptr,pb,size,data);
00646 
00647         free(pb);
00648     }else{
00649         r = write_t(ptr,buffer,size,data);
00650     }
00651     return r;
00652 }

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

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

参照先 DKC_STREAM, DKC_STREAM_PROCESS_TYPE, dkcReverseEndian32(), dkc_Stream::mChangeEndian, と NULL.

参照元 dkcStreamRead32(), と dkcStreamWrite32().

00656                                                                                                                         {
00657     int r;
00658     ULONG *pb;
00659     size_t elem_num,pause = 32;
00660     size_t i;
00661 
00662     if(size % pause != 0){
00663         return edk_ArgumentException;
00664     }
00665     if(ptr->mChangeEndian)
00666     {//エンディアンチェンジが必要
00667         pb = (ULONG *)malloc(size);
00668         if(NULL==pb){
00669             return edk_OutOfMemory;
00670         }
00671         
00672         //メモリコピー
00673         memcpy(pb,buffer,size);
00674         elem_num = size / pause;
00675 
00676         //エンディアンをチェンジさせる。
00677         for(i=0;i<elem_num;i++){
00678             pb[i] = dkcReverseEndian32(pb[i]);
00679         }
00680         //書き込む
00681         r = write_t(ptr,pb,size,data);
00682 
00683         free(pb);
00684     }else{
00685         r = write_t(ptr,buffer,size,data);
00686     }
00687     return r;
00688 
00689 }

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

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

参照先 DKC_STREAM, DKC_STREAM_PROCESS_TYPE, dkcReverseEndian64(), dkc_Stream::mChangeEndian, NULL, と ULONGLONG.

参照元 dkcStreamRead64(), と dkcStreamWrite64().

00701                                                                                                                         {
00702     int r;
00703     ULONGLONG *pb;
00704     size_t elem_num,pause = 64;
00705     size_t i;
00706 
00707     if(size % pause != 0){
00708         return edk_ArgumentException;
00709     }
00710     if(ptr->mChangeEndian)
00711     {//エンディアンチェンジが必要
00712         pb = (ULONGLONG *)malloc(size);
00713         if(NULL==pb){
00714             return edk_OutOfMemory;
00715         }
00716         
00717         //メモリコピー
00718         memcpy(pb,buffer,size);
00719         elem_num = size / pause;
00720 
00721         //エンディアンをチェンジさせる。
00722         for(i=0;i<elem_num;i++){
00723             pb[i] = dkcReverseEndian64(pb[i]);
00724         }
00725         //書き込む
00726         r = write_t(ptr,pb,size,data);
00727 
00728         free(pb);
00729     }else{
00730         r = write_t(ptr,buffer,size,data);
00731     }
00732     return r;
00733 }

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

参照先 DKC_MEMORYSTREAM, DKC_STREAM, dkcMemoryStreamRead(), dkcStreamReadObayAnOrder(), edkcStreamInitFile, edkcStreamInitMemory, edkcStreamProcessDefault, dkc_Stream::mMode, dkc_Stream::mProcessMode, dkc_Stream::mSig, と NULL.

参照元 dkcFileBinaryCompare(), dkcFileToMemory(), dkcStreamRef(), ReadCallback(), と StreamRead().

00318                                                                                               {
00319     int r = edk_FAILED;
00320     FILE *fp = (FILE *)ptr->mSig;
00321     size_t redsize = 0;
00322 
00323     //readsize filter
00324     if(NULL==readsize){
00325         readsize = &redsize;
00326     }
00327 
00328     //エンディアンチェンジ指定されているよ〜〜。
00329     /*if(flag & edkcStreamReadErrorWhenEndianChange){
00330         if(ptr->mChangeEndian){
00331             return edk_Not_Satisfactory;
00332         }
00333     }*/
00334 
00335     switch(ptr->mMode){
00336     case edkcStreamInitMemory:
00337         r = dkcMemoryStreamRead((DKC_MEMORYSTREAM *)ptr->mSig,
00338             buffer,size,readsize);
00339         break;
00340     case edkcStreamInitFile:
00341 
00342         if(ptr->mProcessMode & edkcStreamProcessDefault){
00343             
00344             *readsize = fread(buffer,1,size,fp);
00345             
00346             //set result 
00347             if(feof(fp)){
00348                 r = edk_BufferOverFlow;
00349             }else if(!ferror(fp)){
00350                 r = edk_SUCCEEDED;
00351             }
00352             
00353         }else{
00354             r = dkcStreamReadObayAnOrder(ptr,buffer,size,readsize);
00355         }
00356 
00357 
00358         break;
00359     }
00360     return r;
00361 }

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

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

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

参照先 DKC_STREAM, dkcStreamProcess16(), と StreamRead().

参照元 dkcStreamRef16().

00368 {
00369     return dkcStreamProcess16(ptr,buffer,size,StreamRead,(void *)readsize);
00370     /*
00371     size_t sentinel = size / 2;
00372     size_t i = 0;
00373     size_t t_rs = 0;
00374 
00375     USHORT *pus;
00376 
00377     size_t real_readsize = 0;
00378     int result;
00379 
00380     //filter
00381     if(size_t % 2 != 0){
00382         return edk_ArgumentException;
00383     }
00384 
00385     pus = (USHORT *)buffer;
00386     
00387     for(;i<sentinel;i++){
00388         //process
00389         result = dkcStreamRead(ptr,&pus[i],2,&t_rs);
00390         
00391 
00392         //update data
00393         real_readsize += t_rs;
00394 
00395 
00396         //process state update check
00397         switch(result){
00398         case edkSUCCEEDED:
00399             continue;
00400         case edk_FAILED:
00401         case edk_BufferOverFlow:
00402             goto End;
00403         default:
00404             dkcmNOT_ASSERT("dkcStreamSwapRead16 Error");
00405             goto End;
00406         }
00407     }//end of for
00408 End:
00409     if(readsize){//set readsize
00410         *readsize = real_readsize;
00411     }
00412     //process result
00413     return result;
00414     */
00415 }

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

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

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

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

参照元 dkcStreamRef32().

00417                                                                                      {
00418     return dkcStreamProcess32(ptr,buffer,size,StreamRead,(void *)readsize);
00419 }

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

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

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

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

参照元 dkcStreamRef64().

00421                                                                                      {
00422     return dkcStreamProcess64(ptr,buffer,size,StreamRead,(void *)readsize);
00423 }

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

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

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

参照元 dkcStreamRead().

00259 {
00260     int r = edk_FAILED;
00261     size_t readsize_ = 0;
00262     size_t count;
00263     size_t tc,tsize;
00264     BYTE *tbuffer;
00265     FILE *fp = (FILE *)ptr->mSig;
00266 
00267     if(NULL==readsize){
00268         readsize = &readsize_;
00269     }
00270 
00271     //1,sizeの引数を入れ替えるとどうか?
00272     //1 = fread(buffer,size,1,ptr->mfp);
00273     //read size
00274     tsize = size;
00275     //temp variable
00276     tc = 0;
00277     //offset counter
00278     count = 0;
00279     //byte type pointer
00280     tbuffer = (BYTE *)buffer;
00281     for(;;)
00282     {
00283         //error check
00284         if(ferror(fp) ){
00285             //*readsize = count;
00286             r = edk_FAILED;
00287             break;
00288         }
00289         if(feof(fp)){
00290             //*readsize = count;
00291             r = edk_BufferOverFlow;
00292             break;
00293         }
00294         //read
00295         tc = fread(&tbuffer[count],1,tsize,fp);
00296         //update
00297         tsize -= tc;
00298         count += tc;
00299 
00300         if(count == size){
00301             r = edk_SUCCEEDED;
00302             break;
00303         }
00304 #   ifdef DEBUG
00305         //ありえないエラーチェック
00306         dkcmNOT_ASSERT(count > size);
00307 #   else
00308         if(count > size){
00309             break;
00310         }
00311 #   endif
00312     }
00313     *readsize = count;
00314     return r;
00315 
00316 }

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

streamの中身を見る。

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

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

参照先 DKC_STREAM, dkcStreamRead(), dkcStreamSeek(), dkcStreamTell(), と edkcStreamSeekSet.

00427 {
00428     //位置を記憶
00429     long t = dkcStreamTell(ptr);
00430     //読みこむ(内部で位置がsize分(readsize分)ずらされる)
00431     int r = dkcStreamRead(ptr,buffer,size,readsize);
00432     
00433     
00434     /*
00435     if(readsize > INT_MAX){
00436         dkcmNOT_ASSEERT("INT_MAX byteも一気に読みこむな!ヽ(`Д´)ノムキィ");
00437         return edk_FAILED;
00438     }
00439     t = (*readsize) - t;
00440     
00441     //この条件はありえない。
00442     dkcmNOT_ASSERT(t < 0);*/
00443 
00444 
00446     dkcStreamSeek(ptr,t,edkcStreamSeekSet);
00447     return r;
00448 }

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

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

参照先 DKC_STREAM, dkcStreamRead16(), dkcStreamSeek(), dkcStreamTell(), と edkcStreamSeekSet.

00450                                                                                     {
00451     long t = dkcStreamTell(ptr);
00452     int r = dkcStreamRead16(ptr,buffer,size,readsize);
00453     dkcStreamSeek(ptr,t,edkcStreamSeekSet);
00454     return r;
00455 }

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

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

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

参照先 DKC_STREAM, dkcStreamRead32(), dkcStreamSeek(), dkcStreamTell(), と edkcStreamSeekSet.

00461                                                                                     {
00462     long t = dkcStreamTell(ptr);
00463     int r = dkcStreamRead32(ptr,buffer,size,readsize);
00464     dkcStreamSeek(ptr,t,edkcStreamSeekSet);
00465     return r;
00466 }

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

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

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

参照先 DKC_STREAM, dkcStreamRead64(), dkcStreamSeek(), dkcStreamTell(), と edkcStreamSeekSet.

00471                                                                                     {
00472     long t = dkcStreamTell(ptr);
00473     int r = dkcStreamRead64(ptr,buffer,size,readsize);
00474     dkcStreamSeek(ptr,t,edkcStreamSeekSet);
00475     return r;
00476 
00477 }

int WINAPI dkcStreamSeek DKC_STREAM ptr,
int  offset,
int  origin
 

streamをシークする。fseekみたいなもの edk_SUCCEEDEDで成功 それ以外はエラー

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

参照先 DKC_MEMORYSTREAM, DKC_STREAM, dkcMemoryStreamSeek(), edkcStreamInitFile, edkcStreamInitMemory, dkc_Stream::mMode, と dkc_Stream::mSig.

参照元 dkcCircularStreamWrite(), dkcCloseFileWithSignature(), dkcOpenFileWithSignature(), dkcStreamRef(), dkcStreamRef16(), dkcStreamRef32(), と dkcStreamRef64().

00188                                                                {
00189     int r = edk_FAILED;
00190     switch(ptr->mMode){
00191     case edkcStreamInitMemory:
00192         r = dkcMemoryStreamSeek((DKC_MEMORYSTREAM *)ptr->mSig,offset,origin);
00193         break;
00194     case edkcStreamInitFile:
00195         //成功したら0 == edk_SUCCEEDED;
00196         r = fseek((FILE *)ptr->mSig,offset,origin);
00197         break;
00198     }
00199     return r;
00200 
00201 }

long WINAPI dkcStreamTell DKC_STREAM ptr  ) 
 

streamの位置を取得する。 edkcStreamSeekSetからのオフセット値。edk_FAILEDだとエラー

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

参照先 DKC_MEMORYSTREAM, DKC_STREAM, dkcMemoryStreamTell, edkcStreamInitFile, edkcStreamInitMemory, dkc_Stream::mMode, と dkc_Stream::mSig.

参照元 dkcCloseFileWithSignature(), dkcFileWithSignatureCheckCheat(), dkcFileWithSignatureRead(), dkcStreamRef(), dkcStreamRef16(), dkcStreamRef32(), dkcStreamRef64(), と ReadEOFCheck().

00204                                           {
00205     int r = edk_FAILED;
00206     switch(ptr->mMode){
00207     case edkcStreamInitMemory:
00208         r =  dkcMemoryStreamTell((DKC_MEMORYSTREAM *)ptr->mSig);
00209     case edkcStreamInitFile:
00210         r = ftell((FILE *)ptr->mSig);
00211         if(r==-1){
00212             return edk_FAILED;
00213         }
00214     }
00215     return r;
00216     //dkcmNOT_ASSERT("dkcStreamTell failed");
00217 }

DKC_INLINE int WINAPI dkcStreamWrite DKC_STREAM ptr,
const void *  buffer,
size_t  size
 

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

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

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

参照先 DKC_MEMORYSTREAM, DKC_STREAM, dkcMemoryStreamWrite(), dkcStreamWriteObayAnOrder(), edkcStreamInitFile, edkcStreamInitMemory, edkcStreamWriteErrorWhenEndianChange, dkc_Stream::mChangeEndian, dkc_Stream::mMode, dkc_Stream::mProcessMode, と dkc_Stream::mSig.

参照元 dkcAllocStream(), dkcCircularStreamWrite(), dkcFileWithSignatureWrite(), dkcMemoryToFile(), dkcOpenFileWithSignature(), dkcStreamClear(), HeaderWrite(), と StreamWrite().

00539 {
00540     int r = edk_FAILED;
00541 
00542     UINT proc_flag = ptr->mProcessMode;
00544     if(proc_flag & edkcStreamWriteErrorWhenEndianChange){
00545         if(ptr->mChangeEndian){
00546             return edk_Not_Satisfactory;
00547         }
00548     }
00549 
00550     switch(ptr->mMode){
00551     case edkcStreamInitMemory:
00552         r =  dkcMemoryStreamWrite((DKC_MEMORYSTREAM *)ptr->mSig,buffer,size);
00553         break;
00554     case edkcStreamInitFile:
00555         r = dkcStreamWriteObayAnOrder(ptr,buffer,size);
00556         break;
00557     }
00558 
00559     return r;
00560 }

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

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

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

参照元 dkcFileWithSignatureWrite16().

00592                                                                             {
00593     return dkcStreamProcess16(ptr,(void *)buffer,size,StreamWrite,NULL);
00594 }

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

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

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

参照元 dkcFileWithSignatureWrite32().

00596                                                                             {
00597     return dkcStreamProcess32(ptr,(void *)buffer,size,StreamWrite,NULL);
00598 
00599 }

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

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

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

参照元 dkcFileWithSignatureWrite64().

00603                                                                             {
00604     return dkcStreamProcess64(ptr,(void *)buffer,size,StreamWrite,NULL);        
00605 }

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

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

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

参照元 dkcStreamWrite().

00492                                                                                                {
00493     int r = edk_FAILED;
00494     size_t tc,tsize;
00495     size_t count;
00496     const BYTE *tbuffer = (const BYTE *)buffer;
00497     FILE *fp;
00498 
00499     tc = 0;
00500     count = 0;
00501     tsize = size;
00502     fp =  (FILE *)ptr->mSig;
00503 
00504     for(;;){
00505         //error check
00506         if(ferror(fp)){
00507             return edk_FAILED;
00508         }
00509         if(feof(fp)){
00510             return edk_BufferOverFlow;
00511         }
00512         //write
00513         tc = fwrite(&tbuffer[count],1,tsize,fp);
00514         //update
00515         tsize -= tc;
00516         count += tc;
00517 
00518         if(count == size){
00519             r = edk_SUCCEEDED;
00520             break;
00521         }
00522 #   ifdef DEBUG
00523         //ありえないエラーチェック
00524         dkcmNOT_ASSERT(count > size);
00525 #   else
00526         if(count > size){
00527 
00528             break;
00529         }
00530 #   endif
00531 
00532     }
00533 
00534 
00535     return r;
00536 }

DKC_INLINE int SetStreamInfo DKC_STREAM p,
UINT  flag
[static]
 

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

エンディアンをきめる

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

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

参照元 dkcAllocStream().

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

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

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

参照先 DKC_STREAM, と dkcStreamRead().

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

00363                                                                                   {
00364     return dkcStreamRead(ptr,buffer,size,(size_t *)hoge);   
00365 }

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

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

参照先 DKC_STREAM, と dkcStreamWrite().

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

00562                                                                                    {
00563     return dkcStreamWrite(ptr,buffer,size); 
00564 }


dkutil_cに対してTue Feb 22 02:03:16 2005に生成されました。 doxygen 1.3.6