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

# 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_ADAPTER * | dkcAllocMemoryStreamAdapterCopy (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.c の 6 行で定義されています。

## 関数

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.c の 16 行で定義されています。 参照先 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.c の 362 行で定義されています。 参照先 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.c の 373 行で定義されています。 参照先 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.c の 284 行で定義されています。 参照先 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.c の 36 行で定義されています。 参照先 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.c の 369 行で定義されています。 参照先 dkcFree(). 参照元 dkcFreeStream().
    00370 {
    00371     return dkcFree(p);
    00372 }

DKC_INLINE void WINAPI dkcMemoryStreamAdapterInit | ( | DKC_MEMORYSTREAM_ADAPTER * | p,
|  | BYTE * | buff,
|  | size_t | size
| ) |

| dkcMemoryStream.c の 355 行で定義されています。 参照先 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.c の 172 行で定義されています。 参照先 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;//なんとなく＋１
    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.c の 267 行で定義されています。 参照先 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.c の 415 行で定義されています。 参照先 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.c の 242 行で定義されています。 参照先 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.c の 452 行で定義されています。 参照先 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.c の 96 行で定義されています。 参照先 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.c の 476 行で定義されています。 参照先 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.c の 520 行で定義されています。 参照先 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.c の 275 行で定義されています。 参照先 dkc_MemoryStream::mNowOffset. 参照元 dkcFree2TreeWithVector().
    00275                                                                       {
    00276     return p->mNowOffset;
    00277 }

DKC_INLINE BYTE* WINAPI dkcMemoryStreamPointer | ( | DKC_MEMORYSTREAM * | p | ) |

| 戻り値: 内部バッファへのポインタを取得 dkcMemoryStream.c の 279 行で定義されています。 参照先 dkc_MemoryStream::mBuffer. 参照元 dkcFree2TreeWithVector().
    00279                                                                    {
    00280     return p->mBuffer;
    00281
    00282 }

DKC_INLINE int WINAPI dkcMemoryStreamPopBack | ( | DKC_MEMORYSTREAM_ADAPTER * | p,
|  | size_t | size
| ) |

| dkcMemoryStream.c の 306 行で定義されています。 参照先 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.c の 457 行で定義されています。 参照先 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.c の 101 行で定義されています。 参照先 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.c の 142 行で定義されています。 参照先 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.c の 73 行で定義されています。 参照先 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.c の 47 行で定義されています。 参照先 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.c の 217 行で定義されています。 参照先 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.c の 425 行で定義されています。 参照先 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 }