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

# dkcMemoryStream.h

可変長な配列をぶち込める。stdvectorみたいなもの。 [詳細]

`#include "dkcOSIndependent.h"`
`#include "dkcDefined.h"`
`#include "dkcBuffer.h"`

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

このグラフは、どのファイルから直接、間接的にインクルードされているかを示しています。

ソースコードを見る。

## 構成
struct | dkc_MemoryStream
## マクロ定義
#define | dkcMemoryStreamTell(tt) dkcMemoryStreamGetSeekPoint(tt)
#define | dkcMemoryStreamPushBackMacro(type, p, x)
| バッファオーバーフローする可能性があります。内部構造を知らないと危険です。
#define | dkcMemoryStreamIsEnd(p) ( (p)->mNowOffset >= (p)->mSize )
#define | dkcMemoryStreamAdapterWrite(a, b, c) dkcMemoryStreamWrite(a,b,c)
#define | dkcMemoryStreamAdapterRead(a, b, c, d) dkcMemoryStreamRead(a,b,c,d)
#define | dkcMemroyStreamAdapterSeek(a, b, c) dkcMemoryStreamSeek(a,b,c)
#define | dkcMemoryStreamAdapterTell(a) dkcMemoryStreamTell(a)
#define | dkcMemoryStreamAdapterClear(a) dkcMemoryStreamClear(a)
## 型定義
typedef dkc_MemoryStream | DKC_MEMORYSTREAM
typedef DKC_MEMORYSTREAM | DKC_MEMORYSTREAM_ADAPTER
| 同じ構造だったのでtypedefで十分
## 列挙型
enum | edkcMemoryStream { edkcMemoryStreamSeekCurrent = edkcSeekCurrent, edkcMemoryStreamSeekEnd = edkcSeekEnd, edkcMemoryStreamSeekSet = edkcSeekSet }
enum | { edkcDumpRegistBufferAll = 0, edkcDumpNowOffset = 1 }
## 関数
DKC_EXTERN DKC_MEMORYSTREAM *WINAPI | dkcAllocMemoryStream (size_t size)
| ストリーム領域を得る。
DKC_EXTERN int WINAPI | dkcFreeMemoryStream (DKC_MEMORYSTREAM **ptr)
| dkcAllocNewStream()で確保したストリーム領域を開放する
DKC_EXTERN int WINAPI | dkcMemoryStreamSeek (DKC_MEMORYSTREAM *ptr, int offset, int origin)
| streamをシークする。fseekみたいなもの
DKC_EXTERN size_t WINAPI | dkcMemoryStreamGetSeekPoint (DKC_MEMORYSTREAM *ptr)
DKC_EXTERN int WINAPI | dkcMemoryStreamRead (DKC_MEMORYSTREAM *ptr, void *buffer, size_t size, size_t *readsize)
| streamをリードする。freadみたいなもの
DKC_EXTERN int WINAPI | dkcMemoryStreamWrite (DKC_MEMORYSTREAM *ptr, const void *buffer, size_t size)
| streamをライトする。fwriteみたいなもの
DKC_EXTERN int WINAPI | dkcMemoryStreamDynamicWrite (DKC_MEMORYSTREAM *ptr, const void *buffer, size_t size)
| streamをライトする。ライト出来なかったら内部で動的拡張する。
DKC_EXTERN int WINAPI | dkcMemoryStreamResize (DKC_MEMORYSTREAM *ptr, size_t want_size)
| streamのバッファを拡張する。
DKC_EXTERN size_t WINAPI | dkcMemoryStreamNowOffset (DKC_MEMORYSTREAM *p)
DKC_EXTERN BYTE *WINAPI | dkcMemoryStreamPointer (DKC_MEMORYSTREAM *p)
DKC_EXTERN int WINAPI | dkcMemoryStreamClear (DKC_MEMORYSTREAM *ptr)
| stream内をmemset(0)する。(seek位置も最初に戻される。
DKC_EXTERN DKC_MEMORYSTREAM *WINAPI | dkcAllocMemoryStreamCopy (const DKC_MEMORYSTREAM *ptr)
DKC_EXTERN int WINAPI | dkcMemoryStreamPopBack (DKC_MEMORYSTREAM *p, size_t size)
DKC_EXTERN void WINAPI | dkcMemoryStreamAdapterInit (DKC_MEMORYSTREAM_ADAPTER *p, BYTE *buff, size_t size)
DKC_EXTERN DKC_MEMORYSTREAM_ADAPTER *WINAPI | dkcAllocMemoryStreamAdapter (BYTE *buff, size_t size)
DKC_EXTERN int WINAPI | dkcFreeMemoryStreamAdapter (DKC_MEMORYSTREAM_ADAPTER **)
DKC_EXTERN int WINAPI | dkcMemoryStreamDump (DKC_MEMORYSTREAM *ptr, const char *filename, UINT flag)
DKC_EXTERN int WINAPI | dkcMemoryStreamWriteToMemory (const DKC_MEMORYSTREAM *ptr, void *buffer, size_t buffsize, UINT flag)
| メモリストリーム内のバッファをbufferにコピーする
DKC_EXTERN int WINAPI | dkcMemoryStreamLoadFromMemory (DKC_MEMORYSTREAM *ptr, const void *buffer, size_t buffsize)
| bufferからmemorystreamに読みこむ
DKC_EXTERN int WINAPI | dkcMemoryStreamLoadFromFile (DKC_MEMORYSTREAM *ptr, const char *filename, size_t permit_size, UINT flag)
| ファイルからmemorystreamに読みこむ
DKC_EXTERN int WINAPI | dkcMemoryStreamGet8 (DKC_MEMORYSTREAM *ptr, BYTE *t)
DKC_EXTERN int WINAPI | dkcMemoryStreamPut8 (DKC_MEMORYSTREAM *Ptr, BYTE t)

## 説明

可変長な配列をぶち込める。stdvectorみたいなもの。

覚え書き:
  dkcMemoryStreamSerializeのシリアライズ済みファイルデータ構造

DKC_MEMORYSTREAM構造体 BYTE DKC_MEMORYSTREAM::mSize個分。

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

## マクロ定義

#define dkcMemoryStreamAdapterClear | ( | a |  | ) | dkcMemoryStreamClear(a)

| dkcMemoryStream.h の 158 行で定義されています。 参照元 dkcStreamClear().

#define dkcMemoryStreamAdapterRead | ( | a,
|  | b,
|  | c,
|  | d |  | ) | dkcMemoryStreamRead(a,b,c,d)

| dkcMemoryStream.h の 155 行で定義されています。 参照元 dkcStreamRead().

#define dkcMemoryStreamAdapterTell | ( | a |  | ) | dkcMemoryStreamTell(a)

| dkcMemoryStream.h の 157 行で定義されています。 参照元 dkcStreamTell().

#define dkcMemoryStreamAdapterWrite | ( | a,
|  | b,
|  | c |  | ) | dkcMemoryStreamWrite(a,b,c)

| dkcMemoryStream.h の 154 行で定義されています。 参照元 dkcStreamWrite().

#define dkcMemoryStreamIsEnd | ( | p |  | ) | ( (p)->mNowOffset >= (p)->mSize )

| dkcMemoryStream.h の 130 行で定義されています。 参照元 encode_hash(), と encode_tst().

#define dkcMemoryStreamPushBackMacro | ( | type,
|  | p,
|  | x |  | ) |

| 値:
    {\
        *((type *)&( (p)->mBuff[(p)->mNowOffset])) = (type)x;(p)->mNowOffset += sizeof(type);\
    }
バッファオーバーフローする可能性があります。内部構造を知らないと危険です。 dkcMemoryStream.h の 126 行で定義されています。

#define dkcMemoryStreamTell | ( | tt |  | ) | dkcMemoryStreamGetSeekPoint(tt)

| dkcMemoryStream.h の 79 行で定義されています。 参照元 decode_hash(), と dkcStreamTell().

#define dkcMemroyStreamAdapterSeek | ( | a,
|  | b,
|  | c |  | ) | dkcMemoryStreamSeek(a,b,c)

| dkcMemoryStream.h の 156 行で定義されています。 参照元 dkcStreamSeek().

## 型定義

typedef struct dkc_MemoryStream DKC_MEMORYSTREAM

| メモリストリーム構造体。fopen fwrite freadをメモリ城で行うようなストリーム。 C言語でstdvectorみたいな感じで使う。

typedef DKC_MEMORYSTREAM DKC_MEMORYSTREAM_ADAPTER

| 同じ構造だったのでtypedefで十分 dkcMemoryStream.h の 145 行で定義されています。

## 列挙型

anonymous enum

  | 列挙型の値:
  edkcDumpRegistBufferAll |
  edkcDumpNowOffset |
dkcMemoryStream.h の 188 行で定義されています。
    00188     {
    00189     edkcDumpRegistBufferAll = 0,
    00190     edkcDumpNowOffset = 1,
    00191 };

enum edkcMemoryStream

  | 列挙型の値:
  edkcMemoryStreamSeekCurrent | 今の位置からシーク
  edkcMemoryStreamSeekEnd | 最後の位置からシーク
  edkcMemoryStreamSeekSet | 最初の位置からシーク
dkcMemoryStream.h の 40 行で定義されています。
    00040                      {
    00042     edkcMemoryStreamSeekCurrent = edkcSeekCurrent,
    00044     edkcMemoryStreamSeekEnd = edkcSeekEnd,
    00046     edkcMemoryStreamSeekSet = edkcSeekSet,
    00047
    00048
    00049 };

## 関数

DKC_EXTERN 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_EXTERN DKC_MEMORYSTREAM_ADAPTER* WINAPI dkcAllocMemoryStreamAdapter | ( | BYTE * | buff,
|  | size_t | size
| ) |

| dkcMemoryStream.c の 362 行で定義されています。 参照先 dkcAllocate(), dkcMemoryStreamAdapterInit(), と NULL. 参照元 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_EXTERN 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 }

DKC_EXTERN 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 }

DKC_EXTERN int WINAPI dkcFreeMemoryStreamAdapter | ( | DKC_MEMORYSTREAM_ADAPTER ** |  | ) |

| dkcMemoryStream.c の 369 行で定義されています。 参照先 dkcFree(). 参照元 dkcFreeStream().
    00370 {
    00371     return dkcFree(p);
    00372 }

DKC_EXTERN 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 }

DKC_EXTERN 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 }

DKC_EXTERN int WINAPI dkcMemoryStreamDump | ( | DKC_MEMORYSTREAM * | ptr,
|  | const char * | filename,
|  | UINT | flag
| ) |

| dkcMemoryStream.c の 407 行で定義されています。 参照先 dkcSaveBinary(), edkcDumpRegistBufferAll, dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, と dkc_MemoryStream::mSize.
    00407                                                                                     {
    00408     if(flag == edkcDumpRegistBufferAll){
    00409
    00410         return dkcSaveBinary(ptr->mBuffer,ptr->mSize,filename);
    00411     }else{
    00412
    00413     }
    00414     return dkcSaveBinary(ptr->mBuffer,ptr->mNowOffset,filename);
    00415 }

DKC_EXTERN 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 }

DKC_EXTERN int WINAPI dkcMemoryStreamGet8 | ( | DKC_MEMORYSTREAM * | ptr,
|  | BYTE * | t
| ) |

| dkcMemoryStream.c の 444 行で定義されています。 参照先 dkcMemoryStreamRead(). 参照元 dkcBitMemoryStreamReadBase(), encode_hash(), と encode_tst().
    00444                                                              {
    00445     size_t rs;
    00446     return dkcMemoryStreamRead(ptr,t,1,&rs);
    00447
    00448 }

DKC_EXTERN 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_EXTERN int WINAPI dkcMemoryStreamLoadFromFile | ( | DKC_MEMORYSTREAM * | ptr,
|  | const char * | filename,
|  | size_t | permit_size,
|  | UINT | flag
| ) |

| ファイルからmemorystreamに読みこむ dkcMemoryStream.c の 468 行で定義されています。 参照先 dkcFileExist(), dkcFileSize(), dkcLoadBinary(), dkcMemoryStreamResize(), edkcStreamBufferAll, edkcStreamBufferFirst, FALSE, と dkc_MemoryStream::mBuffer.
    00469 {
    00470     size_t size;
    00471     //許容サイズよりファイルサイズが大きい条件の結果をc1に入れる
    00472     int c1 ;
    00473     int r = edk_FAILED;
    00474     size_t readsize = 0;
    00475     size_t size_temp = 0;
    00476
    00477     if(FALSE==dkcFileExist(filename))
    00478         return edk_FileNotFound;
    00479
    00480
    00481     size  = dkcFileSize(filename);
    00482     c1 = (permit_size < size);
    00483     switch(flag){
    00484     case edkcStreamBufferAll:
    00485         if(c1){
    00486             return edk_FAILED;
    00487         }
    00488         size_temp = size;
    00489         break;
    00490     case edkcStreamBufferFirst:
    00491
    00492         if(c1){
    00493             size_temp = permit_size;
    00494         }else{
    00495             size_temp = size;
    00496         }
    00497         break;
    00498     default:
    00499         return edk_ArgumentException;
    00500     }
    00501
    00502
    00503     r = dkcMemoryStreamResize(ptr,size_temp);
    00504     if(DKUTIL_FAILED(r)) goto End;
    00505
    00506     r = dkcLoadBinary(ptr->mBuffer,size_temp,filename,&readsize);
    00507
    00508     if(DKUTIL_FAILED(r)) goto End;
    00509 End:
    00510     return r;
    00511 }

DKC_EXTERN int WINAPI dkcMemoryStreamLoadFromMemory | ( | DKC_MEMORYSTREAM * | ptr,
|  | const void * | buffer,
|  | size_t | buffsize
| ) |

| bufferからmemorystreamに読みこむ dkcMemoryStream.c の 512 行で定義されています。 参照先 dkc_memcpy(), dkcMemoryStreamResize(), dkc_MemoryStream::mBuffer, と dkc_MemoryStream::mSize.
    00514 {//#error checkLoadFromMeory and LoadFromFile
    00515     //return load(ptr,NULL,srcsize,edkcStreamBufferAll,buffer,buffsize,FALSE);
    00516     int r;
    00517     //size_t read_size;
    00518     r = dkcMemoryStreamResize(ptr,buffsize);
    00519     if(DKUTIL_FAILED(r)) goto End;
    00520
    00521     r = dkc_memcpy(ptr->mBuffer,ptr->mSize,buffer,buffsize);
    00522
    00523     //if(DKUTIL_FAILED(r)) goto End;
    00524 End:
    00525     return r;
    00526 }

DKC_EXTERN size_t WINAPI dkcMemoryStreamNowOffset | ( | DKC_MEMORYSTREAM * | p | ) |

| 戻り値: 今、どこまで書きこんでいるかのサイズを取得 dkcMemoryStream.c の 275 行で定義されています。 参照先 dkc_MemoryStream::mNowOffset. 参照元 dkcFree2TreeWithVector().
    00275                                                                       {
    00276     return p->mNowOffset;
    00277 }

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

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

DKC_EXTERN int WINAPI dkcMemoryStreamPopBack | ( | DKC_MEMORYSTREAM * | 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 }

DKC_EXTERN int WINAPI dkcMemoryStreamPut8 | ( | DKC_MEMORYSTREAM * | Ptr,
|  | BYTE | t
| ) |

| dkcMemoryStream.c の 449 行で定義されています。 参照先 dkcMemoryStreamWrite(). 参照元 decode_hash(), decode_tst(), output_hash_code(), と output_tst_code().
    00449                                                             {
    00450     return dkcMemoryStreamWrite(ptr,&t,1);
    00451 }

DKC_EXTERN 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 }

DKC_EXTERN 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 }

DKC_EXTERN 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 }

DKC_EXTERN 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(), と dkcStreamWrite().
    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 }

DKC_EXTERN int WINAPI dkcMemoryStreamWriteToMemory | ( | const DKC_MEMORYSTREAM * | ptr,
|  | void * | buffer,
|  | size_t | buffsize,
|  | UINT | flag
| ) |

  | メモリストリーム内のバッファをbufferにコピーする 引数:
  | flag[in] |
dkcMemoryStream.c の 417 行で定義されています。 参照先 dkc_memcpy(), edkcStreamBufferAll, edkcStreamBufferFirst, edkcStreamBufferToNowOffset, dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, と dkc_MemoryStream::mSize.
    00418 {
    00419     int r=edk_FAILED;
    00420     /*if(buffsize < ptr->mSize){
    00421         return edk_BufferOverFlow;
    00422     }   */
    00423     size_t size_temp = 0;
    00424     switch(flag){
    00425     case edkcStreamBufferAll:
    00426         r = dkc_memcpy(buffer,buffsize,ptr->mBuffer,ptr->mSize);
    00427         break;
    00428     case edkcStreamBufferToNowOffset:
    00429         r = dkc_memcpy(buffer,buffsize,ptr->mBuffer,ptr->mNowOffset);
    00430         break;
    00431     case edkcStreamBufferFirst:
    00432         if(buffsize >= ptr->mSize){//ここの条件間違って要る可能性あり
    00433             size_temp = ptr->mSize;
    00434         }else{
    00435             size_temp = buffsize;
    00436         }
    00437         r = dkc_memcpy(buffer,buffsize,ptr->mBuffer,size_temp);
    00438     default://todo:強制終了させてもOK
    00439         return edk_FAILED;
    00440     }
    00441     return r;
    00442 }