00001
00007 #include <limits.h>
00008 #include "dkcStream.h"
00009 #include "dkcStdio.h"
00010
00011 #if 0
00012
00013 #define dkcmIS_STREAM_ERROR_FLAG(c) \
00014 ((c)!=edkcStreamInitBuffer && (c)!= edkcStreamInitFile)
00015
00016
00017 static int WINAPI dkcForInitErrorCheck(const DKC_STREAM *ptr){
00018 if(NULL==ptr){
00019 return -1;
00020 }
00021 if(ptr->mBuffer){
00022 return -1;
00023 }
00024 return 0;
00025 }
00026
00027
00028
00029 static int WINAPI dkcForFlagErrorCheck(const DKC_STREAM *ptr){
00030 if(dkcmIS_STREAM_ERROR_FLAG(ptr->mMode)) return -1;
00031 return 0;
00032 }
00033
00034
00035
00036 int WINAPI dkcNewStream(DKC_STREAM *ptr,short flag,size_t size){
00037 void *p = NULL;
00038
00039 if(dkcForInitErrorCheck(ptr)){return edk_FAILED;}
00040 if(dkcmIS_STREAM_ERROR_FLAG(flag))
00041 {
00042 return edk_ArgumentException;
00043 }
00044
00045
00046 p = dkcAllocate(size);
00047
00048 if(NULL==p){
00049 return edk_OutOfMemory;
00050 }
00051
00052
00053
00054 ptr->mBuffer = p;
00055 ptr->mNowOffset = 0;
00056 ptr->mSize = size;
00057 ptr->mMode = flag;
00058
00059 NULL_CHAR_ARRAY(ptr->mFileMode);
00060
00061 return edk_SUCCEEDED;
00062 }
00063
00064 int WINAPI dkcNewStreamForFile(DKC_STREAM *ptr,const char *filename,
00065 const char *mode)
00066 {
00067 FILE *fp = NULL;
00068 size_t mode_len = 0;
00069
00070 if(dkcForInitErrorCheck(ptr)){return edk_FAILED;}
00071 if(NULL==mode){return edk_FAILED;}
00072 mode_len = strlen(mode);
00073 if(mode_len > 2) return edk_FAILED;
00074
00075
00076 fp = fopen(filename,mode);
00077 if(!fp){return edk_FAILED;}
00078
00079 ptr->mBuffer = (BYTE *)fp;
00080 ptr->mNowOffset = 0;
00081 ptr->mSize = UINT_MAX;
00082 ptr->mMode = edkcStreamInitFile;
00083
00084
00085 if(DKUTIL_FAILED(dkc_memcpy(ptr->mFileMode,sizeof(ptr->mFileMode),mode,mode_len))){
00086 return edk_FAILED;
00087 }
00088 return edk_SUCCEEDED;
00089 }
00090
00095 static int WINAPI dkcStreamSeekLogic(DKC_STREAM *ptr,int offset,int point,int origin){
00096
00097
00098
00099
00100
00101
00102
00103 FILE *fp = NULL;
00104 size_t change = (size_t)(point + offset);
00105
00106 switch(ptr->mMode){
00107 case edkcStreamInitBuffer:
00108 if(!(ptr->mSize > change)){
00109 return edk_FAILED;
00110 }
00111 break;
00112 case edkcStreamInitFile:
00113 fp = (FILE *)ptr->mBuffer;
00114 if(0 != fseek(fp,offset,origin)){
00115 return edk_FAILED;
00116 }
00117 break;
00118
00119
00120 }
00121
00122
00123
00124 ptr->mNowOffset = change;
00125
00126
00127
00128
00129 return edk_SUCCEEDED;
00130 }
00131
00132 int WINAPI dkcStreamSeek(DKC_STREAM *ptr,int offset,int origin){
00133 int result = edk_FAILED;
00134 if(NULL==ptr) return edk_FAILED;
00135 if(dkcForFlagErrorCheck(ptr)) return edk_FAILED;
00136 switch(origin)
00137 {
00138 case edkcStreamSeekCurrent:
00139 result = dkcStreamSeekLogic(ptr,offset,ptr->mNowOffset,origin);
00140 break;
00141 case edkcStreamSeekEnd:
00142 result = dkcStreamSeekLogic(ptr,offset,0,origin);
00143 break;
00144 case edkcStreamSeekSet:
00145 result = dkcStreamSeekLogic(ptr,offset,ptr->mSize ,origin);
00146 break;
00147 default:
00148
00149 return edk_ArgumentException;
00150 }
00151 return result;
00152 }
00153
00154 int WINAPI dkcStreamRead(DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize){
00155
00156 int Read = 0;
00157 size_t f_read = 0;
00158
00159
00160 if(NULL==ptr){
00161 return edk_FAILED;
00162 }
00163
00164
00165 switch(ptr->mMode){
00166 case edkcStreamInitBuffer:
00167 Read = (int)(ptr->mNowOffset + size);
00168 Read = (int)ptr->mSize - (int)Read;
00169 if(Read < 0) return edk_BufferOverFlow;
00170
00171 dkcmNOT_ASSERT(edk_FAILED==dkc_memcpy(buffer,size,
00172 ptr->mBuffer + ptr->mNowOffset,size
00173 ));
00174
00175 ptr->mNowOffset += size;
00176 f_read = size;
00177 break;
00178 case edkcStreamInitFile:
00179
00180 f_read = fread(buffer,1,size,(FILE *)ptr->mBuffer);
00181 ptr->mNowOffset += f_read;
00182
00183 break;
00184 default:
00185 return edk_FAILED;
00186 }
00187 if(readsize){
00188 *readsize = f_read;
00189 }
00190 return edk_SUCCEEDED;
00191 }
00192
00193
00194 int WINAPI dkcStreamResize(DKC_STREAM *ptr,size_t want_size,size_t *reallocated_size)
00195 {
00196 int ra_r = 0;
00197 void *NewPtr = NULL;
00198 void *OldPtr = NULL;
00199 size_t ReallocatedSize = want_size;
00200
00201 if(NULL==ptr) return edk_FAILED;
00202
00203 if(edkcStreamInitBuffer != ptr->mMode) return edk_FAILED;
00204
00205 OldPtr = ptr->mBuffer;
00206
00207 ra_r = dkcReallocate(&NewPtr,want_size,&OldPtr);
00208 if(DKUTIL_FAILED(ra_r)){
00209 return edk_FAILED;
00210 }
00211 if(reallocated_size){
00212 *reallocated_size = ReallocatedSize;
00213 }
00214
00215 ptr->mBuffer = NewPtr;
00216 ptr->mSize = ReallocatedSize;
00217
00218
00219 return edk_SUCCEEDED;
00220 }
00221
00222 static int WINAPI dkcStreamAutoExpandResize(DKC_STREAM *ptr){
00223 int ra_r = 0;
00224 void *NewPtr = NULL;
00225 void *OldPtr = NULL;
00226 size_t ReallocatedSize = 0;
00227
00228 if(NULL==ptr) return edk_FAILED;
00229 if(edkcStreamInitBuffer != ptr->mMode) return edk_FAILED;
00230
00231 OldPtr = ptr->mBuffer;
00232
00233 ra_r = dkcReallocateAutoExpand(realloc,&NewPtr,&OldPtr,ptr->mSize,&ReallocatedSize);
00234 if(DKUTIL_FAILED(ra_r)){
00235 return edk_FAILED;
00236 }
00237
00238 ptr->mBuffer = NewPtr;
00239 ptr->mSize = ReallocatedSize;
00240
00241
00242 return edk_SUCCEEDED;
00243
00244 }
00245
00246 int WINAPI dkcStreamWrite(DKC_STREAM *ptr,const void *buffer,size_t size){
00247 int Read = 0;
00248 int ra_r=0;
00249
00250 size_t f_write = 0;
00251
00252
00253 if(NULL==ptr) return edk_FAILED;
00254
00255
00256 switch(ptr->mMode){
00257 case edkcStreamInitBuffer:
00258 Read = (int)(ptr->mNowOffset + size);
00259 Read = (int)ptr->mSize - (int)Read;
00260 if(Read < 0){
00261 ra_r = dkcStreamAutoExpandResize(ptr);
00262 if(DKUTIL_FAILED(ra_r)){
00263 return edk_FAILED;
00264 }
00265
00266 }
00267 Read = ptr->mSize - ptr->mNowOffset;
00268
00269 dkcmNOT_ASSERT(DKUTIL_FAILED(dkc_memcpy(
00270 (void *)((BYTE *)ptr->mBuffer + ptr->mNowOffset),
00271 (size_t)Read,
00272 buffer,size)
00273 ));
00274
00275 ptr->mNowOffset += size;
00276 break;
00277 case edkcStreamInitFile:
00278 f_write = fwrite(buffer,1,size,(FILE*)ptr->mBuffer);
00279 ptr->mNowOffset += f_write;
00280 break;
00281 default:
00282 return edk_FAILED;
00283 }
00284 return edk_SUCCEEDED;
00285 }
00286
00287
00288
00289
00290
00291
00292 int WINAPI dkcStreamDump(DKC_STREAM *ptr,const char *filename){
00293 int result = edk_FAILED;
00294 if(dkcForInitErrorCheck(ptr)) return edk_FAILED;
00295 switch(ptr->mMode){
00296 case edkcStreamInitBuffer:
00297 result = dkcSaveBinary(ptr->mBuffer,ptr->mSize,filename);
00298 break;
00299 case edkcStreamInitFile:
00300
00301 break;
00302 default:
00303 return edk_FAILED;
00304 }
00305
00306 return result;
00307 }
00308
00309 int WINAPI dkcDeleteStream(DKC_STREAM *ptr){
00310 if(NULL==ptr->mBuffer) return edk_FAILED;
00311 switch(ptr->mMode){
00312 case edkcStreamInitBuffer:
00313 dkcFree(&ptr->mBuffer);
00314 break;
00315 case edkcStreamInitFile:
00316 fclose((FILE *)ptr->mBuffer);
00317 break;
00318 default:
00319 dkcmNOT_ASSERT("dkcDeleteStream invalid argument!!!");
00320 return edk_FAILED;
00321 }
00322 ptr->mBuffer = NULL;
00323 ptr->mSize = 0;
00324 ptr->mMode = 0;
00325 ptr->mNowOffset = 0;
00326 NULL_CHAR_ARRAY(ptr->mFileMode);
00327
00328 return edk_SUCCEEDED;
00329 }
00330
00331
00332 DKC_STREAM * WINAPI dkcAllocNewStream(short flag,size_t size,const char *filename,const char *mode){
00333 int r;
00334 DKC_STREAM *t = (DKC_STREAM *)dkcAllocate(sizeof(DKC_STREAM));
00335 if(!t) return NULL;
00336
00337 if(edkcStreamInitFile == flag && filename){
00338 r = dkcNewStreamForFile(t,filename,mode);
00339 if(DKUTIL_FAILED(r)){goto Error;}
00340
00341 }
00342 else
00343 {
00344 r = dkcNewStream(t,flag,size);
00345 if(DKUTIL_FAILED(r)){goto Error;}
00346 }
00347 return t;
00348 Error:
00349 dkcFree((void**)&t);
00350
00351 return t;
00352 }
00353
00354 int WINAPI dkcFreeDeleteStream(DKC_STREAM **ptr){
00355 int r;
00356 r = dkcDeleteStream(*ptr);
00357 if(DKUTIL_FAILED(r)) return r;
00358
00359 dkcFree(ptr);
00360 return edk_SUCCEEDED;
00361 }
00362
00363
00364
00365 int WINAPI dkcStreamClear(DKC_STREAM *ptr){
00366 if(NULL==ptr) return edk_FAILED;
00367 if(edkcStreamInitBuffer != ptr->mMode) return edk_FAILED;
00368 memset(ptr->mBuffer,0,ptr->mSize);
00369 ptr->mNowOffset = 0;
00370 return edk_SUCCEEDED;
00371 }
00372
00373 int WINAPI dkcStreamToBuffer(const DKC_STREAM *ptr,int seek,int want_start,int want_end,char *buff,size_t buffsize)
00374 {
00375 int r;
00376 if(NULL==ptr) return edk_FAILED;
00377
00378 if(edkcStreamInitFile==ptr->mMode) return edk_FAILED;
00379
00380 switch(seek){
00381 case edkcStreamSeekCurrent:
00382 r = dkc_memcpy(buff,buffsize,
00383 (void *)((BYTE *)ptr->mBuffer + ptr->mNowOffset + want_start),(size_t)want_end);
00384 break;
00385 case edkcStreamSeekEnd:
00386 r = dkc_memcpy(buff,buffsize,
00387 (void *)((BYTE *)ptr->mBuffer + want_start),(size_t)want_end);
00388 break;
00389 case edkcStreamSeekSet:
00390 r = dkc_memcpy(buff,buffsize,
00391 (void *)((BYTE *)ptr->mBuffer + want_start),(size_t)want_end);
00392 break;
00393 default:
00394 return edk_FAILED;
00395 }
00396 return r;
00397 }
00398
00399 DKC_STREAM * WINAPI dkcAllocNewStreamCopy(const DKC_STREAM *ptr)
00400 {
00401 DKC_STREAM *tp = NULL;
00402
00403
00404
00405
00406 if(NULL==ptr) return NULL;
00407
00408 if(tp->mMode == edkcStreamInitFile) return NULL;
00409
00410
00411
00412
00413
00414
00415
00416
00417 tp = dkcAllocNewStream(ptr->mMode,ptr->mSize,NULL,NULL);
00418 if(NULL==tp) return NULL;
00419 if(edkcStreamInitBuffer == ptr->mMode){
00420
00421 dkcStreamWrite(tp,ptr->mBuffer,ptr->mSize);
00422 }else{
00423
00424
00425
00426
00427
00428
00429
00430
00431
00432
00433 }
00434
00435 dkcStreamSeek(tp,ptr->mNowOffset,edkcStreamSeekSet);
00436 return tp;
00437 }
00438
00439
00440 int WINAPI dkcStreamSerialize(const DKC_STREAM *ptr,const char *filename){
00441 BYTE *p = NULL;
00442 size_t fsize;
00443 int result;
00444 if(NULL==ptr) return edk_ArgumentException;
00445 if(edkcStreamInitFile==ptr->mMode) return edk_FAILED;
00446
00447 dkcStreamAllocSerialize(ptr,&p,&fsize);
00448
00449 result = dkcSaveBinary(p,fsize,filename);
00450
00451 dkcStreamFreeSerialize(&p);
00452
00453 return result;
00454 }
00455
00456
00457
00458
00459
00460 DKC_STREAM * WINAPI dkcAllocNewStreamDeserializeFromBuffer(
00461 const DKC_STREAM *ptr,const BYTE *buffer,size_t buffsize)
00462 {
00463 DKC_STREAM *p;
00464
00465
00466 if( NULL==buffer) return NULL;
00467
00468
00469
00470
00471 p = dkcAllocNewStream(edkcStreamInitBuffer,ptr->mSize,NULL,NULL);
00472 dkcStreamWrite(p,buffer,buffsize);
00473 dkcStreamSeek(p,ptr->mNowOffset,edkcStreamSeekSet);
00474
00475 return p;
00476 }
00477
00478
00479 DKC_EXTERN int WINAPI dkcStreamAllocSerialize(const DKC_STREAM *ptr,
00480 BYTE **buffer_ptr,size_t *readsize)
00481 {
00482 BYTE *p;
00483 size_t fsize;
00484
00485 if(NULL==ptr || NULL==buffer_ptr || NULL==readsize) return edk_ArgumentException;
00486
00487 if(edkcStreamInitFile==ptr->mMode) return edk_FAILED;
00488
00489 fsize = sizeof(DKC_STREAM) + ptr->mSize;
00490 p = (BYTE *)dkcAllocate(fsize);
00491
00492 if(p==NULL) return edk_OutOfMemory;
00493
00494 memcpy(p,ptr,sizeof(DKC_STREAM));
00495 memcpy((void *)((BYTE *)p + sizeof(DKC_STREAM)),ptr->mBuffer,ptr->mSize);
00496
00497 return edk_SUCCEEDED;
00498 }
00499
00500
00501
00502 int WINAPI dkcStreamFreeSerialize(BYTE **alloced_buffer){
00503 return dkcFree(alloced_buffer);
00504 }
00505
00506
00507 #endif