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

dkcStream.c

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

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

ソースコードを見る。

マクロ定義

#define DKUTIL_C_STREAM_C

関数

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


マクロ定義

#define DKUTIL_C_STREAM_C
 

作者:
d金魚
覚え書き:
licence:BSD Licence

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

参照先 dkcAllocate(), dkcAllocFile64(), dkcAllocMemoryStream(), dkcAllocMemoryStreamAdapter(), dkcFOpen(), dkcFree(), dkcStreamSeek(), dkcStreamWrite(), edkcStreamInitFile, edkcStreamInitFile64, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, edkcStreamSeekSet, dkc_Stream::mMode, dkc_Stream::mSig, NULL, SetStreamInfo(), と uint32.

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

00166 {
00167     
00168     DKC_STREAM *p;
00169     void *psig;
00170     const uint32 *use_flag = (const uint32 *)mode;
00171 
00172     p = (DKC_STREAM *)dkcAllocate(sizeof(DKC_STREAM));
00173     if(NULL==p){
00174         return NULL;
00175     }
00176 
00177     if(DKUTIL_FAILED(SetStreamInfo(p,flag))){
00178         goto Error;
00179     }
00180 
00181     switch(p->mMode){
00182     case edkcStreamInitMemory:
00183         psig = (void *)dkcAllocMemoryStream(size);
00184         if(NULL==psig){
00185             goto Error;
00186         }
00187         //update    
00188         p->mSig = psig;
00189         //write default data
00190         dkcStreamWrite(p,default_data,size);
00191         dkcStreamSeek(p,0,edkcStreamSeekSet);
00192         break;
00193     case edkcStreamInitFile:
00194         psig = (void *)dkcFOpen(filename,mode);
00195         if(NULL==psig){
00196             goto Error;
00197         }
00198         //update
00199         p->mSig = psig;
00200         
00201         break;
00202     case edkcStreamInitMemoryAdapter:
00203         psig = dkcAllocMemoryStreamAdapter((void *)default_data,size);
00204         if(NULL==psig){
00205             goto Error;
00206         }
00207         p->mSig = psig;
00208     case edkcStreamInitFile64:
00209         psig = dkcAllocFile64(*use_flag,filename);
00210         if(NULL==psig){
00211             goto Error;
00212         }
00213         p->mSig = psig;
00214         break;
00215     default:
00216         goto Error;
00217     }
00218 
00219     
00220     //p->mEndianMode = endianmode
00221 
00222     return p;
00223 Error:
00224     dkcFree((void **)&p);
00225     return NULL;
00226 }

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

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

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

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

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

00121 {
00122     UINT flag = 0;
00123     DKUTIL_FLAG_UP(flag,edkcStreamInitFile);
00124     DKUTIL_FLAG_UP(flag,edkcStreamLittleEndian);
00125     DKUTIL_FLAG_DOWN(flag,edkcStreamBigEndian);
00126     if(OrderFlag){
00127         DKUTIL_FLAG_UP(flag,edkcStreamProcessAsOrdered );
00128     }else{
00129         DKUTIL_FLAG_UP(flag,edkcStreamProcessDefault);
00130     }
00131     return dkcAllocStream(flag,NULL,0,filename,mode);
00132 }

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

引数:
mode[in] edkc_FileModeのどれかを入れる。

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

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

参照元 dkcAllocDCF01(), dkcDCF01ToFile(), と dkcFileToDCF01().

00111                                                                                        {
00112     DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemory);
00113     DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile);
00114     DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemoryAdapter);
00115     DKUTIL_FLAG_UP(flag,edkcStreamInitFile64);
00116     return dkcAllocStream(flag,NULL,0,filename,(const char *)&mode);
00117 
00118 }

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

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

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

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

00095                                                                                           {
00096     DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemory);
00097     DKUTIL_FLAG_UP(flag,edkcStreamInitFile);
00098     DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemoryAdapter);
00099     DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile64);
00100     return dkcAllocStream(flag,NULL,0,filename,mode);
00101 }

DKC_STREAM* WINAPI dkcAllocStreamMemoryAdapterType UINT  flag,
void *  adapt_buffer,
size_t  size
 

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

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

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

00103                                                                                             {
00104     DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemory);
00105     DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile);
00106     DKUTIL_FLAG_UP(flag,edkcStreamInitMemoryAdapter);
00107     DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile64);
00108     return dkcAllocStream(flag,adapt_buffer,size,NULL,NULL);
00109 }

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

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

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

00086                                                                                            {
00087     DKUTIL_FLAG_UP(flag,edkcStreamInitMemory);
00088     DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile);
00089     DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemoryAdapter);
00090     DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile64);
00091     return dkcAllocStream(flag,default_data,size,NULL,NULL);
00092 
00093 }

int WINAPI dkcFreeStream DKC_STREAM **  ptr  ) 
 

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

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

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

参照先 dkcFClose(), dkcFree(), dkcFreeFile64(), dkcFreeMemoryStream(), dkcFreeMemoryStreamAdapter(), dkcmNOT_ASSERT, edkcStreamInitFile, edkcStreamInitFile64, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, dkc_Stream::mMode, dkc_Stream::mSig, と NULL.

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

00229                                         {
00230     DKC_STREAM *t;
00231     if(NULL==p){
00232         return edk_FAILED;
00233     }
00234     t = *p;
00235     if(NULL==t){
00236         return edk_FAILED;
00237     }
00238 
00239     switch(t->mMode){
00240     case edkcStreamInitMemory:
00241         dkcFreeMemoryStream((DKC_MEMORYSTREAM **)&(t->mSig));
00242         break;
00243     case edkcStreamInitFile:
00244         dkcFClose((FILE **)&(t->mSig));
00245         break;
00246     case edkcStreamInitMemoryAdapter:
00247         dkcFreeMemoryStreamAdapter((DKC_MEMORYSTREAM_ADAPTER **)&(t->mSig));
00248         break;
00249     case edkcStreamInitFile64:
00250         dkcFreeFile64((DKC_FILE64 **)&(t->mSig));
00251         break;
00252 #ifdef DEBUG
00253         default:
00254             dkcmNOT_ASSERT("dkcFreeStream FAILED");
00255 #endif
00256     }
00257     return dkcFree((void **)p);
00258 }

int WINAPI dkcStreamClear DKC_STREAM ptr  ) 
 

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

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

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

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

BOOL WINAPI dkcStreamEOF DKC_STREAM ptr  ) 
 

戻り値:
EOFだとTRUE

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

参照先 dkcFile64EOF(), edkcStreamInitFile, edkcStreamInitFile64, FALSE, dkc_Stream::mMode, dkc_Stream::mSig, と TRUE.

参照元 dkcDCF01Read(), dkcFileBinaryCompare(), と dkcFileToDCF01().

00359                                          {
00360     
00361     //filter
00362     if(edkcStreamInitFile64==ptr->mMode){
00363         return dkcFile64EOF((DKC_FILE64 *)ptr->mSig);   
00364     }
00365     if(edkcStreamInitFile != ptr->mMode){
00366         goto Exit;
00367     }
00368     if(0 != feof((FILE *)ptr->mSig)){
00369         return TRUE;
00370     }
00371 Exit:
00372     return FALSE;
00373 }

BOOL WINAPI dkcStreamError DKC_STREAM ptr  ) 
 

戻り値:
エラーだとTRUE

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

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

参照元 dkcFileBinaryCompare().

00375                                            {
00376     //filter
00377     if(edkcStreamInitFile != ptr->mMode){
00378         goto Exit;
00379     }
00380     if(0 != ferror((FILE *)ptr->mSig)){
00381         return TRUE;
00382     }
00383 Exit:
00384     return FALSE;
00385 }

int WINAPI dkcStreamFlush DKC_STREAM ptr  ) 
 

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

戻り値:
edk_Resultのどれか

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

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

00340                                           {
00341     int r = edk_SUCCEEDED;
00342     //filter
00343     if(edkcStreamInitFile64==ptr->mMode){
00344         _flushall();
00345         return edk_SUCCEEDED;
00346     }
00347     if(edkcStreamInitFile!=ptr->mMode){
00348         return edk_FAILED;
00349     }
00350 
00351     r = fflush((FILE *)ptr->mSig);
00352 
00353     if(r==EOF){
00354         return edk_FAILED;
00355     }
00356     return edk_SUCCEEDED;
00357 }

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

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

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

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

00768 {
00769     return write_t(ptr,buffer,size,data);
00770 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

streamをリードする。freadみたいなもの

引数:
readsize[out] 実際に読んだサイズを返す。NULLを渡してもOK.
覚え書き:
指定したサイズ(size)よりもストリームバッファのサイズが小さかった場合 readsizeに実際に読んだサイズを入れます。
戻り値:
edkcStreamInitMemoryが指定されていた場合、 dkcMemoryStreamRead()を見てください。 edkcStreamInitFileが指定されていた場合、 ferror()だったらedk_FAILED , feof()だったらedk_BufferOverFlow, edkcStreamWriteErrorWhenEndianChangeが指定されていた場合、 edk_Not_Satisfactoryを返す。この場合はdkcStreamRead8()を使用する事

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

参照先 dkcFile64Read(), dkcMemoryStreamAdapterRead, dkcMemoryStreamRead(), dkcStreamReadObayAnOrder(), edkcStreamInitFile, edkcStreamInitFile64, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, edkcStreamProcessDefault, dkc_Stream::mMode, dkc_Stream::mProcessMode, dkc_Stream::mSig, と NULL.

参照元 dkcDCF01Read(), dkcDCF01ReadFinal(), dkcFileBinaryCompare(), dkcFileToDCF01(), dkcFileToMemory(), dkcStreamRead8(), dkcStreamRef(), ReadCallback(), と StreamRead().

00449                                                                                               {
00450     int r = edk_FAILED;
00451     FILE *fp = (FILE *)ptr->mSig;
00452     size_t redsize = 0;
00453 
00454     //readsize filter
00455     if(NULL==readsize){
00456         readsize = &redsize;
00457     }
00458 
00459     //エンディアンチェンジ指定されているよ〜〜。
00460     /*if(flag & edkcStreamReadErrorWhenEndianChange){
00461         if(ptr->mChangeEndian){
00462             return edk_Not_Satisfactory;
00463         }
00464     }*/
00465 
00466     switch(ptr->mMode){
00467     case edkcStreamInitMemory:
00468         r = dkcMemoryStreamRead((DKC_MEMORYSTREAM *)ptr->mSig,
00469             buffer,size,readsize);
00470         break;
00471     case edkcStreamInitFile:
00472 
00473         if(ptr->mProcessMode & edkcStreamProcessDefault){
00474             
00475             *readsize = fread(buffer,1,size,fp);
00476             
00477             //set result 
00478             if(feof(fp)){
00479                 r = edk_BufferOverFlow;
00480             }else if(!ferror(fp)){
00481                 r = edk_SUCCEEDED;
00482             }
00483             
00484         }else{
00485             r = dkcStreamReadObayAnOrder(ptr,buffer,size,readsize);
00486         }
00487 
00488 
00489         break;
00490     case edkcStreamInitMemoryAdapter:
00491         r = dkcMemoryStreamAdapterRead((DKC_MEMORYSTREAM_ADAPTER *)
00492             ptr->mSig,buffer,size,readsize);
00493         break;
00494     case edkcStreamInitFile64:
00495         r = dkcFile64Read((DKC_FILE64*)ptr->mSig,buffer,size,readsize);
00496         
00497         break;
00498     }
00499     return r;
00500 }

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

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

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

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

参照元 dkcStreamRef16().

00512 {
00513     return dkcStreamProcess16(ptr,buffer,size,StreamRead,(void *)readsize);
00514     /*
00515     size_t sentinel = size / 2;
00516     size_t i = 0;
00517     size_t t_rs = 0;
00518 
00519     USHORT *pus;
00520 
00521     size_t real_readsize = 0;
00522     int result;
00523 
00524     //filter
00525     if(size_t % 2 != 0){
00526         return edk_ArgumentException;
00527     }
00528 
00529     pus = (USHORT *)buffer;
00530     
00531     for(;i<sentinel;i++){
00532         //process
00533         result = dkcStreamRead(ptr,&pus[i],2,&t_rs);
00534         
00535 
00536         //update data
00537         real_readsize += t_rs;
00538 
00539 
00540         //process state update check
00541         switch(result){
00542         case edkSUCCEEDED:
00543             continue;
00544         case edk_FAILED:
00545         case edk_BufferOverFlow:
00546             goto End;
00547         default:
00548             dkcmNOT_ASSERT("dkcStreamSwapRead16 Error");
00549             goto End;
00550         }
00551     }//end of for
00552 End:
00553     if(readsize){//set readsize
00554         *readsize = real_readsize;
00555     }
00556     //process result
00557     return result;
00558     */
00559 }

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

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

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

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

参照元 dkcStreamRef32().

00561                                                                                      {
00562     return dkcStreamProcess32(ptr,buffer,size,StreamRead,(void *)readsize);
00563 }

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

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

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

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

参照元 dkcStreamRef64().

00565                                                                                      {
00566     return dkcStreamProcess64(ptr,buffer,size,StreamRead,(void *)readsize);
00567 }

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

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

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

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

参照先 dkcStreamRead().

00507                                                                                     {
00508     return dkcStreamRead(ptr,buffer,size,readsize);
00509 }

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

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

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

参照元 dkcStreamRead().

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

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

streamの中身を見る。

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

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

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

00571 {
00572     //位置を記憶
00573     long t = dkcStreamTell(ptr);
00574     //読みこむ(内部で位置がsize分(readsize分)ずらされる)
00575     int r = dkcStreamRead(ptr,buffer,size,readsize);
00576     
00577     
00578     /*
00579     if(readsize > INT_MAX){
00580         dkcmNOT_ASSEERT("INT_MAX byteも一気に読みこむな!ヽ(`Д´)ノムキィ");
00581         return edk_FAILED;
00582     }
00583     t = (*readsize) - t;
00584     
00585     //この条件はありえない。
00586     dkcmNOT_ASSERT(t < 0);*/
00587 
00588 
00590     dkcStreamSeek(ptr,t,edkcStreamSeekSet);
00591     return r;
00592 }

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

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

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

00594                                                                                     {
00595     long t = dkcStreamTell(ptr);
00596     int r = dkcStreamRead16(ptr,buffer,size,readsize);
00597     dkcStreamSeek(ptr,t,edkcStreamSeekSet);
00598     return r;
00599 }

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

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

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

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

00605                                                                                     {
00606     long t = dkcStreamTell(ptr);
00607     int r = dkcStreamRead32(ptr,buffer,size,readsize);
00608     dkcStreamSeek(ptr,t,edkcStreamSeekSet);
00609     return r;
00610 }

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

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

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

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

00615                                                                                     {
00616     long t = dkcStreamTell(ptr);
00617     int r = dkcStreamRead64(ptr,buffer,size,readsize);
00618     dkcStreamSeek(ptr,t,edkcStreamSeekSet);
00619     return r;
00620 
00621 }

int WINAPI dkcStreamSeek DKC_STREAM ptr,
int  offset,
int  origin
 

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

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

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

参照先 dkcFile64Seek(), dkcMemoryStreamSeek(), dkcMemroyStreamAdapterSeek, edkcStreamInitFile, edkcStreamInitFile64, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, dkc_Stream::mMode, と dkc_Stream::mSig.

参照元 dkcAllocStream(), dkcCloseFileWithSignature(), dkcDCF01Init(), dkcDCF01ReadFinal(), dkcDCF01WriteFinal(), dkcOpenFileWithSignature(), dkcStreamRef(), dkcStreamRef16(), dkcStreamRef32(), と dkcStreamRef64().

00263                                                                {
00264     int r = edk_FAILED;
00265     switch(ptr->mMode){
00266     case edkcStreamInitMemory:
00267         r = dkcMemoryStreamSeek((DKC_MEMORYSTREAM *)ptr->mSig,offset,origin);
00268         break;
00269     case edkcStreamInitFile:
00270         //成功したら0 == edk_SUCCEEDED;
00271         r = fseek((FILE *)ptr->mSig,offset,origin);
00272         break;  
00273     case edkcStreamInitMemoryAdapter:
00274         r = dkcMemroyStreamAdapterSeek((DKC_MEMORYSTREAM_ADAPTER *)ptr->mSig,offset,origin);
00275         break;
00276     case edkcStreamInitFile64:
00277         r = dkcFile64Seek((DKC_FILE64 *)ptr->mSig,offset,origin);
00278         break;
00279     }
00280     return r;
00281 
00282 }

long WINAPI dkcStreamTell DKC_STREAM ptr  ) 
 

streamの位置を取得する。

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

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

参照先 dkcFile64Tell(), dkcMemoryStreamAdapterTell, dkcMemoryStreamTell, edkcStreamInitFile, edkcStreamInitFile64, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, dkc_Stream::mMode, と dkc_Stream::mSig.

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

00312                                           {
00313     int r = -1;
00314     uint64 t;
00315     switch(ptr->mMode){
00316     case edkcStreamInitMemory:
00317         r =  dkcMemoryStreamTell((DKC_MEMORYSTREAM *)ptr->mSig);
00318         break;
00319     case edkcStreamInitFile:
00320         r = ftell((FILE *)ptr->mSig);
00321         if(r==-1){
00322             return edk_FAILED;
00323         }
00324         break;
00325     case edkcStreamInitFile64:
00326         dkcFile64Tell((DKC_FILE64 *)ptr->mSig,&t);
00327         if(t > LONG_MAX){
00328             return -1;
00329         }
00330         r = (long)t;
00331         break;
00332     case edkcStreamInitMemoryAdapter:
00333         r = dkcMemoryStreamAdapterTell((DKC_MEMORYSTREAM_ADAPTER *)ptr->mSig);
00334         break;
00335     }
00336     return r;
00337     //dkcmNOT_ASSERT("dkcStreamTell failed");
00338 }

int WINAPI dkcStreamTell64 DKC_STREAM ptr,
uint64 *  pv
 

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

参照先 dkcFile64Tell(), dkcMemoryStreamAdapterTell, dkcMemoryStreamTell, edkcStreamInitFile, edkcStreamInitFile64, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, dkc_Stream::mMode, と dkc_Stream::mSig.

00285                                                       {
00286     int r = edk_FAILED;
00287     switch(ptr->mMode){
00288     case edkcStreamInitMemory:
00289         r =  dkcMemoryStreamTell((DKC_MEMORYSTREAM *)ptr->mSig);
00290         *pv = r;
00291         break;
00292     case edkcStreamInitFile:
00293         r = ftell((FILE *)ptr->mSig);
00294         if(r==-1){
00295             return edk_FAILED;
00296         }
00297         *pv = r;
00298         break;
00299     case edkcStreamInitFile64:
00300         r = dkcFile64Tell((DKC_FILE64 *)ptr->mSig,pv);
00301         if(DKUTIL_FAILED(r)) return r;
00302         break;
00303     case edkcStreamInitMemoryAdapter:
00304         r = dkcMemoryStreamAdapterTell((DKC_MEMORYSTREAM_ADAPTER *)ptr->mSig);
00305         *pv = r;
00306         break;
00307     }
00308     
00309     return edk_SUCCEEDED;
00310 }

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

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

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

参照元 dkcFileWithSignatureWrite16().

00748                                                                             {
00749     return dkcStreamProcess16(ptr,(void *)buffer,size,StreamWrite,NULL);
00750 }

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

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

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

参照元 dkcFileWithSignatureWrite32().

00752                                                                             {
00753     return dkcStreamProcess32(ptr,(void *)buffer,size,StreamWrite,NULL);
00754 
00755 }

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

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

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

参照元 dkcFileWithSignatureWrite64().

00759                                                                             {
00760     return dkcStreamProcess64(ptr,(void *)buffer,size,StreamWrite,NULL);        
00761 }

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

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

参照先 dkcStreamWrite().

00745                                                                     {
00746     return dkcStreamWrite(ptr,buffer,size);
00747 }

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

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

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

参照元 dkcStreamWriteWithWriteSize().

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

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

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

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

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

参照先 dkcFile64Write(), dkcMemoryStreamAdapterWrite, dkcMemoryStreamWrite(), dkcStreamWriteObayAnOrder(), edkcStreamInitFile, edkcStreamInitFile64, edkcStreamInitMemory, edkcStreamInitMemoryAdapter, edkcStreamWriteErrorWhenEndianChange, dkc_Stream::mChangeEndian, dkc_Stream::mMode, dkc_Stream::mProcessMode, と dkc_Stream::mSig.

参照元 dkcDCF01Write(), と dkcStreamWrite().

00684 {
00685     int r = edk_FAILED;
00686     UINT proc_flag = ptr->mProcessMode;
00688     if(proc_flag & edkcStreamWriteErrorWhenEndianChange){
00689         if(ptr->mChangeEndian){
00690             return edk_Not_Satisfactory;
00691         }
00692     }
00693 
00694     switch(ptr->mMode){
00695     case edkcStreamInitMemory:
00696         r =  dkcMemoryStreamWrite((DKC_MEMORYSTREAM *)ptr->mSig,buffer,size);
00697         break;
00698     case edkcStreamInitFile:
00699         r = dkcStreamWriteObayAnOrder(ptr,buffer,size);
00700         break;
00701     case edkcStreamInitMemoryAdapter:
00702         r = dkcMemoryStreamAdapterWrite((DKC_MEMORYSTREAM_ADAPTER *)ptr->mSig,buffer,size);     
00703         break;
00704     case edkcStreamInitFile64:
00705         r = dkcFile64Write((DKC_FILE64*)ptr->mSig,buffer,size,ws);
00706         
00707         break;
00708     }
00709 
00710     return r;
00711 
00712 }

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

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

エンディアンをきめる

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

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

参照元 dkcAllocStream().

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

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

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

参照先 dkcStreamRead().

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

00502                                                                                   {
00503     return dkcStreamRead(ptr,buffer,size,(size_t *)hoge);   
00504 }

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

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

参照先 dkcStreamWrite().

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

00714                                                                                    {
00715     return dkcStreamWrite(ptr,buffer,size); 
00716 }


dkutil_cに対してMon Jan 16 00:45:50 2006に生成されました。  doxygen 1.4.4