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

dkcMemoryStream.c

#include <limits.h>
#include "dkcMemoryStream.h"
#include "dkcSJISFileSystem.h"
#include "dkcStdio.h"

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

ソースコードを見る。

マクロ定義

#define DKUTIL_C_MEMORYSTREAM_C

関数

DKC_MEMORYSTREAM *WINAPI dkcAllocMemoryStream (size_t size)
 ストリーム領域を得る。
int WINAPI dkcFreeMemoryStream (DKC_MEMORYSTREAM **ptr)
 dkcAllocNewStream()で確保したストリーム領域を開放する
static int WINAPI dkcMemoryStreamSeekLogic (DKC_MEMORYSTREAM *ptr, int offset, int point, int origin)
int WINAPI dkcMemoryStreamSeek (DKC_MEMORYSTREAM *ptr, int offset, int origin)
 streamをシークする。fseekみたいなもの
size_t WINAPI dkcMemoryStreamGetSeekPoint (DKC_MEMORYSTREAM *ptr)
DKC_INLINE int WINAPI dkcMemoryStreamRead (DKC_MEMORYSTREAM *ptr, void *buffer, size_t size, size_t *readsize)
 streamをリードする。freadみたいなもの
int WINAPI dkcMemoryStreamResize (DKC_MEMORYSTREAM *ptr, size_t want_size)
 streamのバッファを拡張する。
static int WINAPI dkcMemoryStreamAutoExpandResize (DKC_MEMORYSTREAM *ptr, size_t expand_size)
DKC_INLINE int WINAPI dkcMemoryStreamWrite (DKC_MEMORYSTREAM *ptr, const void *buffer, size_t size)
 streamをライトする。fwriteみたいなもの
int WINAPI dkcMemoryStreamDynamicWrite (DKC_MEMORYSTREAM *ptr, const void *buffer, size_t size)
 streamをライトする。ライト出来なかったら内部で動的拡張する。
DKC_INLINE int WINAPI dkcMemoryStreamClear (DKC_MEMORYSTREAM *ptr)
 stream内をmemset(0)する。(seek位置も最初に戻される。
DKC_INLINE size_t WINAPI dkcMemoryStreamNowOffset (DKC_MEMORYSTREAM *p)
DKC_INLINE BYTE *WINAPI dkcMemoryStreamPointer (DKC_MEMORYSTREAM *p)
DKC_MEMORYSTREAM *WINAPI dkcAllocMemoryStreamCopy (const DKC_MEMORYSTREAM *ptr)
DKC_INLINE int WINAPI dkcMemoryStreamPopBack (DKC_MEMORYSTREAM_ADAPTER *p, size_t size)
DKC_INLINE void WINAPI dkcMemoryStreamAdapterInit (DKC_MEMORYSTREAM_ADAPTER *p, BYTE *buff, size_t size)
DKC_MEMORYSTREAM_ADAPTER
*WINAPI 
dkcAllocMemoryStreamAdapter (BYTE *buff, size_t size)
int WINAPI dkcFreeMemoryStreamAdapter (DKC_MEMORYSTREAM_ADAPTER **p)
DKC_MEMORYSTREAM_ADAPTERdkcAllocMemoryStreamAdapterCopy (DKC_MEMORYSTREAM_ADAPTER *p)
int WINAPI dkcMemoryStreamDump (DKC_MEMORYSTREAM *ptr, const char *filename, UINT flag)
int WINAPI dkcMemoryStreamWriteToMemory (const DKC_MEMORYSTREAM *ptr, void *buffer, size_t buffsize, UINT flag)
 メモリストリーム内のバッファをbufferにコピーする
int WINAPI dkcMemoryStreamGet8 (DKC_MEMORYSTREAM *ptr, BYTE *t)
int WINAPI dkcMemoryStreamPut8 (DKC_MEMORYSTREAM *ptr, BYTE t)
DKC_INLINE int WINAPI dkcMemoryStreamLoadFromFile (DKC_MEMORYSTREAM *ptr, const char *filename, size_t permit_size, UINT flag)
 ファイルからmemorystreamに読みこむ
DKC_INLINE int WINAPI dkcMemoryStreamLoadFromMemory (DKC_MEMORYSTREAM *ptr, const void *buffer, size_t buffsize)
 bufferからmemorystreamに読みこむ


マクロ定義

#define DKUTIL_C_MEMORYSTREAM_C
 

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

dkcMemoryStream.c6 行で定義されています。


関数

DKC_MEMORYSTREAM* WINAPI dkcAllocMemoryStream size_t  size  ) 
 

ストリーム領域を得る。

引数:
flag[in] edkcMemoryStreamにある、StreamInit系のものを渡す
size[in] ストリームの初期化時のサイズ
filename[in] edkcMemoryStreamInitFileをflagに渡した場合、その保存するファイルの名前 flagにedkcMemoryStreamInitFile以外の値を渡した場合はNULLでOK
mode[in] fopenのモード flagにedkcMemoryStreamInitFile以外の値を渡した場合はNULLでOK
戻り値:
DKC_MEMORYSTREAM *のストリームデータ。

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

参照先 BYTE, dkcAllocate(), dkcFree(), dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と NULL.

参照元 dkcAllocBitMemoryStream(), dkcAllocMemoryStreamCopy(), dkcAllocStream(), dkcAllocString(), dkcAllocUniqueID(), と dkcFree2TreeWithVector().

00016                                                            {
00017     DKC_MEMORYSTREAM *p;
00018     if(0==size) return NULL;
00019 
00020     p = (DKC_MEMORYSTREAM *)dkcAllocate(sizeof(DKC_MEMORYSTREAM));
00021 
00022     if(NULL==p) return NULL;
00023     p->mBuffer = (BYTE *)dkcAllocate(size);
00024     if(NULL==p->mBuffer) goto Error;
00025 
00026     p->mSize = size;
00027     p->mNowOffset = 0;
00028     return p;
00029 Error:
00030     dkcFree((void **)&p);
00031     return NULL;
00032 
00033 }

DKC_MEMORYSTREAM_ADAPTER* WINAPI dkcAllocMemoryStreamAdapter BYTE buff,
size_t  size
 

dkcMemoryStream.c362 行で定義されています。

参照先 dkcAllocate(), dkcMemoryStreamAdapterInit(), と NULL.

参照元 dkcAllocMemoryStreamAdapterCopy(), と dkcAllocStream().

00362                                                                                     {
00363     DKC_MEMORYSTREAM_ADAPTER *p = dkcAllocate(sizeof(DKC_MEMORYSTREAM_ADAPTER));
00364     if(NULL==p) return NULL;
00365     dkcMemoryStreamAdapterInit(p,buff,size);
00366     return p;
00367 }

DKC_MEMORYSTREAM_ADAPTER* dkcAllocMemoryStreamAdapterCopy DKC_MEMORYSTREAM_ADAPTER p  ) 
 

dkcMemoryStream.c373 行で定義されています。

参照先 dkcAllocMemoryStreamAdapter(), dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と NULL.

00374 {
00375     DKC_MEMORYSTREAM_ADAPTER *tp = dkcAllocMemoryStreamAdapter(p->mBuffer,p->mSize);
00376     if(!tp) return NULL;
00377     tp->mNowOffset = p->mNowOffset;
00378     return tp;
00379 }

DKC_MEMORYSTREAM* WINAPI dkcAllocMemoryStreamCopy const DKC_MEMORYSTREAM ptr  ) 
 

戻り値:
成功したらそのオブジェクトへのポインタが返る。失敗したらNULLが返る。
覚え書き:
C++で言うコピーコンストラクタ。

dkcMemoryStream.c284 行で定義されています。

参照先 dkcAllocMemoryStream(), dkcMemoryStreamSeek(), dkcMemoryStreamWrite(), dkcmNOT_ASSERT, edkcMemoryStreamSeekSet, dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と NULL.

00285 {
00286     DKC_MEMORYSTREAM *tp = NULL;
00287 
00288     dkcmNOT_ASSERT(NULL==ptr);
00289 
00290     tp = dkcAllocMemoryStream(ptr->mSize);
00291     if(NULL==tp) return NULL;
00292 
00293     dkcMemoryStreamWrite(tp,ptr->mBuffer,ptr->mSize);
00294 
00295     //内部オフセット変更                                    /* 先頭から */
00296     dkcMemoryStreamSeek(tp,ptr->mNowOffset,edkcMemoryStreamSeekSet);
00297     return tp;
00298 }

int WINAPI dkcFreeMemoryStream DKC_MEMORYSTREAM **  ptr  ) 
 

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

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

dkcMemoryStream.c36 行で定義されています。

参照先 dkcFree(), と NULL.

参照元 dkcFreeBitMemoryStream(), dkcFreeStream(), dkcFreeString(), と dkcFreeUniqueID().

00036                                                       {
00037     if(NULL==ptr || NULL==*ptr) return edk_ArgumentException;
00038     if(NULL==(*ptr)->mBuffer) return edk_FAILED;
00039 
00040     dkcFree((void **)&((*ptr)->mBuffer));
00041     return dkcFree((void **)ptr);
00042 }

int WINAPI dkcFreeMemoryStreamAdapter DKC_MEMORYSTREAM_ADAPTER **  p  ) 
 

dkcMemoryStream.c369 行で定義されています。

参照先 dkcFree().

参照元 dkcFreeStream().

00370 {
00371     return dkcFree(p);
00372 }

DKC_INLINE void WINAPI dkcMemoryStreamAdapterInit DKC_MEMORYSTREAM_ADAPTER p,
BYTE buff,
size_t  size
 

dkcMemoryStream.c355 行で定義されています。

参照先 dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, と dkc_MemoryStream::mSize.

参照元 decode_hash(), decode_tst(), dkcAllocMemoryStreamAdapter(), encode_hash(), と encode_tst().

00356 {
00357     p->mBuffer = buff;
00358     p->mSize = size;
00359     p->mNowOffset = 0;
00360 
00361 }

static int WINAPI dkcMemoryStreamAutoExpandResize DKC_MEMORYSTREAM ptr,
size_t  expand_size
[static]
 

引数:
ptr[in] 所貴下済みのDKC_MEMORYSTREAMへのポインタ
expand_size[in] 希望する拡張サイズ

dkcMemoryStream.c172 行で定義されています。

参照先 BYTE, dkcReallocate(), dkcReallocateSizeFunction(), dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と NULL.

参照元 dkcMemoryStreamDynamicWrite().

00172                                                                                            {
00173     int ra_r = 0;
00174     void *NewPtr = NULL;
00175     void *OldPtr = NULL;
00176     size_t ReallocatedSize = 0;
00177     size_t want_size;
00178     //size_t want_size = ptr->mSize + expand_size + 1;//なんとなく+1
00179     
00180     if(NULL==ptr) return edk_ArgumentException;
00181 
00182     OldPtr = ptr->mBuffer;
00183     /*
00184     ra_r = dkcReallocateAutoExpand(realloc,&NewPtr,&OldPtr,ptr->mSize,&ReallocatedSize);
00185     if(DKUTIL_FAILED(ra_r)){
00186         return edk_FAILED;
00187     }
00188     if(want_size > ReallocatedSize){
00189         OldPtr = NewPtr;
00190         ra_r = dkcReallocate(&NewPtr,want_size,&OldPtr);
00191         if(DKUTIL_FAILED(ra_r)){
00192             return edk_FAILED;
00193         }
00194         ReallocatedSize = want_size;
00195     }
00196     */
00197     want_size = dkcReallocateSizeFunction(
00198         ptr->mSize + ptr->mNowOffset,
00199         (expand_size <= 256) ? 256 : expand_size
00200     );
00201     ra_r = dkcReallocate(&NewPtr,want_size,&OldPtr);
00202     if(DKUTIL_FAILED(ra_r)){
00203         return edk_FAILED;
00204     }
00205     ReallocatedSize = want_size;
00206 
00207 
00208 
00209     ptr->mBuffer = (BYTE *)NewPtr;
00210     ptr->mSize = ReallocatedSize;
00211 
00212 
00213     return edk_SUCCEEDED;
00214 
00215 }

DKC_INLINE int WINAPI dkcMemoryStreamClear DKC_MEMORYSTREAM ptr  ) 
 

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

dkcMemoryStream.c267 行で定義されています。

参照先 dkcmNOT_ASSERT, dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と NULL.

参照元 dkcStreamClear(), と dkcStringCopy().

00267                                                                  {
00268     dkcmNOT_ASSERT(NULL==ptr);
00269     //if(NULL==ptr) return edk_ArgumentException;
00270     memset(ptr->mBuffer,0,ptr->mSize);
00271     ptr->mNowOffset = 0;
00272     return edk_SUCCEEDED;
00273 }

int WINAPI dkcMemoryStreamDump DKC_MEMORYSTREAM ptr,
const char *  filename,
UINT  flag
 

dkcMemoryStream.c415 行で定義されています。

参照先 dkcSaveBinary(), edkcDumpRegistBufferAll, dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, と dkc_MemoryStream::mSize.

00415                                                                                     {
00416     if(flag == edkcDumpRegistBufferAll){
00417 
00418         return dkcSaveBinary(ptr->mBuffer,ptr->mSize,filename);
00419     }else{
00420         
00421     }
00422     return dkcSaveBinary(ptr->mBuffer,ptr->mNowOffset,filename);
00423 }

int WINAPI dkcMemoryStreamDynamicWrite DKC_MEMORYSTREAM ptr,
const void *  buffer,
size_t  size
 

streamをライトする。ライト出来なかったら内部で動的拡張する。

dkcMemoryStream.c242 行で定義されています。

参照先 dkcMemoryStreamAutoExpandResize(), dkcMemoryStreamWrite(), dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と NULL.

参照元 dkcBitMemoryStreamWrite(), dkcBitMemoryStreamWriteLast(), dkcStringConcatenate(), と dkcStringCopy().

00242                                                                                             {
00243     int result;
00244     size_t want_size;
00245 
00246     if(NULL==ptr) return edk_ArgumentException;
00247 
00248     want_size =  ptr->mNowOffset + size;
00249 
00250     if(ptr->mSize < want_size)
00251     {
00252         result = dkcMemoryStreamAutoExpandResize(ptr,size);
00253         //result = dkcMemoryStreamResize(ptr,want_size);
00254         if(DKUTIL_FAILED(result)) return edk_FAILED;
00255     }
00256 
00257     return dkcMemoryStreamWrite(ptr,buffer,size);
00258 }

int WINAPI dkcMemoryStreamGet8 DKC_MEMORYSTREAM ptr,
BYTE t
 

dkcMemoryStream.c452 行で定義されています。

参照先 dkcMemoryStreamRead().

参照元 dkcBitMemoryStreamReadBase(), encode_hash(), と encode_tst().

00452                                                              {
00453     size_t rs;
00454     return dkcMemoryStreamRead(ptr,t,1,&rs);
00455 
00456 }

size_t WINAPI dkcMemoryStreamGetSeekPoint DKC_MEMORYSTREAM ptr  ) 
 

戻り値:
streamのシークポイントを返す。

dkcMemoryStream.c96 行で定義されています。

参照先 dkc_MemoryStream::mNowOffset.

参照元 dkcBitMemoryStreamReadBase(), dkcBitMemoryStreamWrite(), dkcBitMemoryStreamWriteLast(), と dkcStringInsert().

00097 {
00098     return ptr->mNowOffset;
00099 }

DKC_INLINE int WINAPI dkcMemoryStreamLoadFromFile DKC_MEMORYSTREAM ptr,
const char *  filename,
size_t  permit_size,
UINT  flag
 

ファイルからmemorystreamに読みこむ

dkcMemoryStream.c476 行で定義されています。

参照先 dkcFileExist(), dkcFileSize(), dkcLoadBinary(), dkcMemoryStreamResize(), edkcStreamBufferAll, edkcStreamBufferFirst, FALSE, と dkc_MemoryStream::mBuffer.

00477 {
00478     size_t size;
00479     //許容サイズよりファイルサイズが大きい条件の結果をc1に入れる
00480     int c1 ;
00481     int r = edk_FAILED;
00482     size_t readsize = 0;
00483     size_t size_temp = 0;
00484 
00485     if(FALSE==dkcFileExist(filename))
00486         return edk_FileNotFound;
00487 
00488     
00489     size  = dkcFileSize(filename);
00490     c1 = (permit_size < size);
00491     switch(flag){
00492     case edkcStreamBufferAll:
00493         if(c1){
00494             return edk_FAILED;
00495         }
00496         size_temp = size;
00497         break;
00498     case edkcStreamBufferFirst:
00499 
00500         if(c1){
00501             size_temp = permit_size;
00502         }else{
00503             size_temp = size;
00504         }
00505         break;
00506     default:
00507         return edk_ArgumentException;
00508     }
00509 
00510 
00511     r = dkcMemoryStreamResize(ptr,size_temp);
00512     if(DKUTIL_FAILED(r)) goto End;
00513     
00514     r = dkcLoadBinary(ptr->mBuffer,size_temp,filename,&readsize);
00515 
00516     if(DKUTIL_FAILED(r)) goto End;          
00517 End:
00518     return r;
00519 }

DKC_INLINE int WINAPI dkcMemoryStreamLoadFromMemory DKC_MEMORYSTREAM ptr,
const void *  buffer,
size_t  buffsize
 

bufferからmemorystreamに読みこむ

dkcMemoryStream.c520 行で定義されています。

参照先 dkc_memcpy(), dkcMemoryStreamResize(), dkc_MemoryStream::mBuffer, と dkc_MemoryStream::mSize.

00522 {//#error checkLoadFromMeory and LoadFromFile
00523     //return load(ptr,NULL,srcsize,edkcStreamBufferAll,buffer,buffsize,FALSE);
00524     int r;
00525     //size_t read_size;
00526     r = dkcMemoryStreamResize(ptr,buffsize);
00527     if(DKUTIL_FAILED(r)) goto End;
00528     
00529     r = dkc_memcpy(ptr->mBuffer,ptr->mSize,buffer,buffsize);
00530 
00531     //if(DKUTIL_FAILED(r)) goto End;            
00532 End:
00533     return r;
00534 }

DKC_INLINE size_t WINAPI dkcMemoryStreamNowOffset DKC_MEMORYSTREAM p  ) 
 

戻り値:
今、どこまで書きこんでいるかのサイズを取得

dkcMemoryStream.c275 行で定義されています。

参照先 dkc_MemoryStream::mNowOffset.

参照元 dkcFree2TreeWithVector().

00275                                                                       {
00276     return p->mNowOffset;
00277 }

DKC_INLINE BYTE* WINAPI dkcMemoryStreamPointer DKC_MEMORYSTREAM p  ) 
 

戻り値:
内部バッファへのポインタを取得

dkcMemoryStream.c279 行で定義されています。

参照先 dkc_MemoryStream::mBuffer.

参照元 dkcFree2TreeWithVector().

00279                                                                    {
00280     return p->mBuffer;
00281 
00282 }

DKC_INLINE int WINAPI dkcMemoryStreamPopBack DKC_MEMORYSTREAM_ADAPTER p,
size_t  size
 

dkcMemoryStream.c306 行で定義されています。

参照先 dkcMemoryStreamSeek().

00307 {
00308     /*if(size > p->mNowOffset){
00309         return edk_FAILED;
00310     }
00311     p->mNowOffset -= size;
00312     return edk_SUCCEEDED;*/
00313     int t;
00314     if(size > (size_t)(-(INT_MIN))){//sizeがでかい
00315         return edk_ArgumentException;
00316     }
00317     t = (int)size;
00318     t = -t;
00319     return dkcMemoryStreamSeek(p,t,SEEK_CUR);
00320 }

int WINAPI dkcMemoryStreamPut8 DKC_MEMORYSTREAM ptr,
BYTE  t
 

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

参照先 dkcMemoryStreamWrite().

参照元 decode_hash(), decode_tst(), output_hash_code(), と output_tst_code().

00457                                                             {
00458     return dkcMemoryStreamWrite(ptr,&t,1);
00459 }

DKC_INLINE int WINAPI dkcMemoryStreamRead DKC_MEMORYSTREAM ptr,
void *  buffer,
size_t  size,
size_t *  readsize
 

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

引数:
readsize[out] 実際に読んだサイズを返す。NULLを渡してもOK.
覚え書き:
指定したサイズ(size)よりもストリームバッファのサイズが小さかった場合 readsizeに実際に読んだサイズを入れます。

dkcMemoryStream.c101 行で定義されています。

参照先 dkc_memcpy(), dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と NULL.

参照元 dkcMemoryStreamGet8(), と dkcStreamRead().

00101                                                                                                           {
00102 
00103     
00104     size_t f_read = 0;
00105     //error check
00106 
00107     if(NULL==ptr || NULL==readsize) return edk_ArgumentException;
00108 
00109     //Read = (int)(ptr->mNowOffset + size); 
00110     //Read = (int)(ptr->mSize - Read); 
00111     //if(Read < 0) return edk_BufferOverFlow;
00112     
00113     //process...
00114 
00115     f_read = ptr->mNowOffset + size;
00116 
00117     if(ptr->mSize <= f_read){
00118         f_read = ptr->mSize - ptr->mNowOffset;
00119         if(0==f_read) return edk_BufferOverFlow;
00120     }else{
00121         f_read = size;
00122     }
00123 
00124 
00125     //酷バグ:まずい、酷いバグだ。
00126     /*dkcmNOT_ASSERT(edk_FAILED==dkc_memcpy(buffer,size,
00127         ptr->mBuffer + ptr->mNowOffset,f_read
00128     ));*/
00129     if(DKUTIL_FAILED(dkc_memcpy(buffer,size,ptr->mBuffer + ptr->mNowOffset,f_read)))
00130     {
00131         return edk_FAILED;
00132     }
00133 
00134     //update...
00135     ptr->mNowOffset += f_read;
00136     *readsize = f_read;
00137     
00138     return edk_SUCCEEDED;
00139 }

int WINAPI dkcMemoryStreamResize DKC_MEMORYSTREAM ptr,
size_t  want_size
 

streamのバッファを拡張する。

dkcMemoryStream.c142 行で定義されています。

参照先 BYTE, dkcReallocate(), dkc_MemoryStream::mBuffer, dkc_MemoryStream::mSize, と NULL.

参照元 dkcMemoryStreamLoadFromFile(), と dkcMemoryStreamLoadFromMemory().

00143 {
00144     int ra_r = 0;
00145     void *NewPtr = NULL;
00146     void *OldPtr = NULL;
00147     
00148     //error check
00149     if(NULL==ptr) return edk_ArgumentException;
00150 
00151 
00152     //process
00153     OldPtr = ptr->mBuffer;
00154 
00155     ra_r = dkcReallocate(&NewPtr,want_size,&OldPtr);
00156     if(DKUTIL_FAILED(ra_r)){
00157         return edk_FAILED;
00158     }
00159 
00160     //update...
00161     ptr->mBuffer = (BYTE *)NewPtr;
00162     ptr->mSize = want_size;
00163 
00164 
00165     return edk_SUCCEEDED;
00166 }

int WINAPI dkcMemoryStreamSeek DKC_MEMORYSTREAM ptr,
int  offset,
int  origin
 

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

dkcMemoryStream.c73 行で定義されています。

参照先 dkcMemoryStreamSeekLogic(), edkcMemoryStreamSeekCurrent, edkcMemoryStreamSeekEnd, edkcMemoryStreamSeekSet, dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と NULL.

参照元 dkcAllocMemoryStreamCopy(), dkcBitMemoryStreamReadBase(), dkcBitMemoryStreamSeekByte(), dkcBitMemoryStreamWrite(), dkcBitMemoryStreamWriteLast(), dkcMemoryStreamPopBack(), dkcStreamSeek(), dkcStringCopy(), と dkcStringErase().

00073                                                                            {
00074     int result = edk_FAILED;
00075     if(NULL==ptr) return edk_ArgumentException;
00076     switch(origin)
00077     {
00078     case edkcMemoryStreamSeekCurrent://今の位置からシーク
00079         result = dkcMemoryStreamSeekLogic(ptr,offset,ptr->mNowOffset,origin);
00080         break;
00081     case edkcMemoryStreamSeekEnd://最後の位置からシーク
00082         //result = dkcMemoryStreamSeekLogic(ptr,offset,0,origin);
00083         result = dkcMemoryStreamSeekLogic(ptr,offset,ptr->mSize /*- 1*/,origin);
00084         break;
00085     case edkcMemoryStreamSeekSet://最初の位置からシーク
00086         //result = dkcMemoryStreamSeekLogic(ptr,offset,ptr->mSize /*- 1*/,origin);
00087         result = dkcMemoryStreamSeekLogic(ptr,offset,0,origin);
00088         break;
00089     default:
00090         //変な引数入れるな!
00091         return edk_ArgumentException;
00092     }
00093     return result;
00094 }

static int WINAPI dkcMemoryStreamSeekLogic DKC_MEMORYSTREAM ptr,
int  offset,
int  point,
int  origin
[static]
 

dkcMemoryStream.c47 行で定義されています。

参照先 dkcCheckOverflow32, dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と TRUE.

参照元 dkcMemoryStreamSeek().

00047                                                                                                  {
00048     /*
00049     状態繊維:
00050     offset + succeeded
00051     offset - succeeded
00052     offset + length error
00053     offset - length error
00054     */
00055     size_t change = (size_t)(point + offset);
00056 
00057     if(TRUE==dkcCheckOverflow32(point,offset)){
00058         return edk_FAILED;
00059     }
00060     //if(!(ptr->mSize > change)){
00061     if(!(ptr->mSize >= change)){
00062         return edk_FAILED;
00063     }
00064 
00065     //common...
00066 
00067     ptr->mNowOffset = change;
00068         
00069 
00070     return edk_SUCCEEDED;
00071 }

DKC_INLINE int WINAPI dkcMemoryStreamWrite DKC_MEMORYSTREAM ptr,
const void *  buffer,
size_t  size
 

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

覚え書き:
内部ストリームバッファは動的拡張です。気にせずどんどんぶち込みましょう。 C言語版のSTLのstdvectorみたいなものですね。(といいますか、車輪の再開発してるし・・・。

dkcMemoryStream.c217 行で定義されています。

参照先 BYTE, dkc_memcpy(), dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と NULL.

参照元 dkcAllocMemoryStreamCopy(), dkcFree2TreeWithVector(), dkcMemoryStreamDynamicWrite(), dkcMemoryStreamPut8(), と dkcStreamWriteWithWriteSize().

00217                                                                                                 {
00218     size_t rest;
00219 
00220     if(NULL==ptr) return edk_ArgumentException;
00221     
00222 
00223     if(ptr->mSize < ptr->mNowOffset + size){return edk_FAILED;}
00224     rest = ptr->mSize - ptr->mNowOffset;
00225     
00226     //酷バグ:dkcmNOT_ASSERTはDEBUGモード時にしか展開されない。
00227     /*dkcmNOT_ASSERT(
00228     ));*/
00229     if(DKUTIL_FAILED(dkc_memcpy(
00230         (void *)((BYTE *)ptr->mBuffer + ptr->mNowOffset),
00231         rest,
00232         buffer,size))){
00233         return edk_FAILED;
00234     }
00235     
00236     ptr->mNowOffset += size;
00237     
00238     return edk_SUCCEEDED;
00239 }

int WINAPI dkcMemoryStreamWriteToMemory const DKC_MEMORYSTREAM ptr,
void *  buffer,
size_t  buffsize,
UINT  flag
 

メモリストリーム内のバッファをbufferにコピーする

引数:
flag[in] 

dkcMemoryStream.c425 行で定義されています。

参照先 dkc_memcpy(), edkcStreamBufferAll, edkcStreamBufferFirst, edkcStreamBufferToNowOffset, dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, と dkc_MemoryStream::mSize.

00426 {
00427     int r=edk_FAILED;
00428     /*if(buffsize < ptr->mSize){
00429         return edk_BufferOverFlow;  
00430     }   */
00431     size_t size_temp = 0;
00432     switch(flag){
00433     case edkcStreamBufferAll:
00434         r = dkc_memcpy(buffer,buffsize,ptr->mBuffer,ptr->mSize);
00435         break;
00436     case edkcStreamBufferToNowOffset:
00437         r = dkc_memcpy(buffer,buffsize,ptr->mBuffer,ptr->mNowOffset);
00438         break;
00439     case edkcStreamBufferFirst:
00440         if(buffsize >= ptr->mSize){//ここの条件間違って要る可能性あり
00441             size_temp = ptr->mSize;
00442         }else{
00443             size_temp = buffsize;
00444         }
00445         r = dkc_memcpy(buffer,buffsize,ptr->mBuffer,size_temp);
00446     default://todo:強制終了させてもOK
00447         return edk_FAILED;
00448     }
00449     return r;
00450 }


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