00001
00006 #define DKUTIL_C_MEMORYSTREAM_C
00007 #include <limits.h>
00008 #include "dkcMemoryStream.h"
00009 #include "dkcSJISFileSystem.h"
00010 #include "dkcStdio.h"
00011
00012
00013
00014
00015
00016 DKC_MEMORYSTREAM * WINAPI dkcAllocMemoryStream(size_t size){
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 }
00034
00035
00036 int WINAPI dkcFreeMemoryStream(DKC_MEMORYSTREAM **ptr){
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 }
00043
00044
00045
00046
00047 static int WINAPI dkcMemoryStreamSeekLogic(DKC_MEMORYSTREAM *ptr,int offset,int point,int origin){
00048
00049
00050
00051
00052
00053
00054
00055 size_t change = (size_t)(point + offset);
00056
00057 if(TRUE==dkcCheckOverflow32(point,offset)){
00058 return edk_FAILED;
00059 }
00060
00061 if(!(ptr->mSize >= change)){
00062 return edk_FAILED;
00063 }
00064
00065
00066
00067 ptr->mNowOffset = change;
00068
00069
00070 return edk_SUCCEEDED;
00071 }
00072
00073 int WINAPI dkcMemoryStreamSeek(DKC_MEMORYSTREAM *ptr,int offset,int origin){
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
00083 result = dkcMemoryStreamSeekLogic(ptr,offset,ptr->mSize ,origin);
00084 break;
00085 case edkcMemoryStreamSeekSet:
00086
00087 result = dkcMemoryStreamSeekLogic(ptr,offset,0,origin);
00088 break;
00089 default:
00090
00091 return edk_ArgumentException;
00092 }
00093 return result;
00094 }
00095
00096 size_t WINAPI dkcMemoryStreamGetSeekPoint(DKC_MEMORYSTREAM *ptr)
00097 {
00098 return ptr->mNowOffset;
00099 }
00100
00101 DKC_INLINE int WINAPI dkcMemoryStreamRead(DKC_MEMORYSTREAM *ptr,void *buffer,size_t size,size_t *readsize){
00102
00103
00104 size_t f_read = 0;
00105
00106
00107 if(NULL==ptr || NULL==readsize) return edk_ArgumentException;
00108
00109
00110
00111
00112
00113
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
00127
00128
00129 if(DKUTIL_FAILED(dkc_memcpy(buffer,size,ptr->mBuffer + ptr->mNowOffset,f_read)))
00130 {
00131 return edk_FAILED;
00132 }
00133
00134
00135 ptr->mNowOffset += f_read;
00136 *readsize = f_read;
00137
00138 return edk_SUCCEEDED;
00139 }
00140
00141
00142 int WINAPI dkcMemoryStreamResize(DKC_MEMORYSTREAM *ptr,size_t want_size)
00143 {
00144 int ra_r = 0;
00145 void *NewPtr = NULL;
00146 void *OldPtr = NULL;
00147
00148
00149 if(NULL==ptr) return edk_ArgumentException;
00150
00151
00152
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
00161 ptr->mBuffer = (BYTE *)NewPtr;
00162 ptr->mSize = want_size;
00163
00164
00165 return edk_SUCCEEDED;
00166 }
00167
00172 static int WINAPI dkcMemoryStreamAutoExpandResize(DKC_MEMORYSTREAM *ptr,size_t expand_size){
00173 int ra_r = 0;
00174 void *NewPtr = NULL;
00175 void *OldPtr = NULL;
00176 size_t ReallocatedSize = 0;
00177 size_t want_size;
00178
00179
00180 if(NULL==ptr) return edk_ArgumentException;
00181
00182 OldPtr = ptr->mBuffer;
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
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 }
00216
00217 DKC_INLINE int WINAPI dkcMemoryStreamWrite(DKC_MEMORYSTREAM *ptr,const void *buffer,size_t size){
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
00227
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 }
00240
00241
00242 int WINAPI dkcMemoryStreamDynamicWrite(DKC_MEMORYSTREAM *ptr,const void *buffer,size_t size){
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
00254 if(DKUTIL_FAILED(result)) return edk_FAILED;
00255 }
00256
00257 return dkcMemoryStreamWrite(ptr,buffer,size);
00258 }
00259
00260
00261
00262
00263
00264
00265
00266
00267 DKC_INLINE int WINAPI dkcMemoryStreamClear(DKC_MEMORYSTREAM *ptr){
00268 dkcmNOT_ASSERT(NULL==ptr);
00269
00270 memset(ptr->mBuffer,0,ptr->mSize);
00271 ptr->mNowOffset = 0;
00272 return edk_SUCCEEDED;
00273 }
00274
00275 DKC_INLINE size_t WINAPI dkcMemoryStreamNowOffset(DKC_MEMORYSTREAM *p){
00276 return p->mNowOffset;
00277 }
00278
00279 DKC_INLINE BYTE *WINAPI dkcMemoryStreamPointer(DKC_MEMORYSTREAM *p){
00280 return p->mBuffer;
00281
00282 }
00283
00284 DKC_MEMORYSTREAM * WINAPI dkcAllocMemoryStreamCopy(const DKC_MEMORYSTREAM *ptr)
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 }
00299
00300
00301
00302
00303
00304
00305
00306 DKC_INLINE int WINAPI dkcMemoryStreamPopBack(DKC_MEMORYSTREAM_ADAPTER *p,size_t size)
00307 {
00308
00309
00310
00311
00312
00313 int t;
00314 if(size > (size_t)(-(INT_MIN))){
00315 return edk_ArgumentException;
00316 }
00317 t = (int)size;
00318 t = -t;
00319 return dkcMemoryStreamSeek(p,t,SEEK_CUR);
00320 }
00321
00322
00323
00324
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335
00336
00337
00338
00339
00340
00341
00342
00343
00344
00345
00346
00347
00348
00349
00350
00351
00352
00353
00354
00355 DKC_INLINE void WINAPI dkcMemoryStreamAdapterInit(DKC_MEMORYSTREAM_ADAPTER *p,BYTE *buff,size_t size)
00356 {
00357 p->mBuffer = buff;
00358 p->mSize = size;
00359 p->mNowOffset = 0;
00360
00361 }
00362 DKC_MEMORYSTREAM_ADAPTER *WINAPI dkcAllocMemoryStreamAdapter(BYTE *buff,size_t size){
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 }
00368
00369 int WINAPI dkcFreeMemoryStreamAdapter(DKC_MEMORYSTREAM_ADAPTER **p)
00370 {
00371 return dkcFree(p);
00372 }
00373 DKC_MEMORYSTREAM_ADAPTER *dkcAllocMemoryStreamAdapterCopy(DKC_MEMORYSTREAM_ADAPTER *p)
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 }
00380
00381
00382 #if 0
00383 DKC_INLINE int WINAPI dkcMemoryStreamAdapterSetOffset(DKC_MEMORYSTREAM_ADAPTER *p,size_t offset){
00384 if(offset > p->mSize){
00385 return edk_FAILED;
00386 }
00387 p->mNowOffset = offset;
00388 return edk_SUCCEEDED;
00389 }
00390 DKC_INLINE size_t WINAPI dkcMemoryStreamAdapterGetOffset(DKC_MEMORYSTREAM_ADAPTER *p){
00391 return p->mNowOffset;
00392 }
00393
00394 DKC_INLINE int WINAPI dkcMemoryStreamAdapterRead(DKC_MEMORYSTREAM_ADAPTER *p,void *buff,size_t buffsize,size_t *readsize)
00395 {
00396 return msa_rw_proc(p,(BYTE *)buff,buffsize,TRUE);
00397 }
00398 DKC_INLINE int WINAPI dkcMemoryStreamAdapterGetChar(DKC_MEMORYSTREAM_ADAPTER *p,BYTE *t)
00399 {
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410 size_t rs;
00411 return dkcMemoryStreamAdapterRead(p,t,1,&rs);
00412 }
00413 #endif
00414
00415 int WINAPI dkcMemoryStreamDump(DKC_MEMORYSTREAM *ptr,const char *filename,UINT flag){
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 }
00424
00425 int WINAPI dkcMemoryStreamWriteToMemory(const DKC_MEMORYSTREAM *ptr,void *buffer,size_t buffsize,UINT flag)
00426 {
00427 int r=edk_FAILED;
00428
00429
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:
00447 return edk_FAILED;
00448 }
00449 return r;
00450 }
00451
00452 int WINAPI dkcMemoryStreamGet8(DKC_MEMORYSTREAM *ptr,BYTE *t){
00453 size_t rs;
00454 return dkcMemoryStreamRead(ptr,t,1,&rs);
00455
00456 }
00457 int WINAPI dkcMemoryStreamPut8(DKC_MEMORYSTREAM *ptr,BYTE t){
00458 return dkcMemoryStreamWrite(ptr,&t,1);
00459 }
00460
00461
00462
00463
00464
00465
00466
00467
00468
00469
00470
00471
00472
00473
00474
00475
00476 DKC_INLINE int WINAPI dkcMemoryStreamLoadFromFile(DKC_MEMORYSTREAM *ptr,const char *filename,size_t permit_size,UINT flag)
00477 {
00478 size_t size;
00479
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 }
00520 DKC_INLINE int WINAPI dkcMemoryStreamLoadFromMemory(DKC_MEMORYSTREAM *ptr,
00521 const void *buffer,size_t buffsize)
00522 {
00523
00524 int r;
00525
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
00532 End:
00533 return r;
00534 }