00001
00007 #define DKUTIL_C_STREAM_C
00008 #include "dkcOSIndependent.h"
00009 #include "dkcStream.h"
00010 #include "dkcStdio.h"
00011 #include <limits.h>
00012
00013
00014 static DKC_INLINE int SetStreamInfo(DKC_STREAM *p,UINT flag){
00015 UINT stream_mode = 0;
00016 BYTE endian_mode = 0;
00017 UINT proc_mode = 0;
00018
00019 BOOL isLittle = dkcIsLittleEndian();
00020
00021
00023 if(flag & edkcStreamInitMemory){
00024 stream_mode = edkcStreamInitMemory;
00025 }else if(flag & edkcStreamInitFile){
00026 stream_mode = edkcStreamInitFile;
00027 }else{
00028 goto Error;
00029 }
00030
00031
00032 endian_mode = FALSE;
00034 if(flag & edkcStreamBigEndian){
00035
00036 if(isLittle){
00037 endian_mode = TRUE;
00038 }
00039 }else if(flag & edkcStreamLittleEndian){
00040
00041 if(!isLittle){
00042 endian_mode = TRUE;
00043 }
00044 }else {
00045 if(isLittle){
00046
00047 }else{
00048
00049 }
00050 }
00051
00052
00053 proc_mode |= (flag & edkcStreamProcessDefault);
00054 if(0==proc_mode){
00055 proc_mode |= (flag & edkcStreamProcessAsOrdered);
00056
00057 if(0==proc_mode){
00058 proc_mode |= edkcStreamProcessAsOrdered;
00059 }
00060 }
00061 proc_mode |= (flag & edkcStreamWriteErrorWhenEndianChange );
00062
00063
00064 p->mMode = stream_mode;
00065
00066 dkcmNOT_ASSERT(proc_mode > UCHAR_MAX);
00067 p->mProcessMode = (BYTE)proc_mode;
00068
00069 p->mChangeEndian = endian_mode;
00070
00071 return edk_SUCCEEDED;
00072 Error:
00073 return edk_FAILED;
00074
00075 }
00076
00077
00078
00079
00080 DKC_STREAM *WINAPI dkcAllocStreamMemoryType(UINT flag,const void *default_data,size_t size){
00081 DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile);
00082 DKUTIL_FLAG_UP(flag,edkcStreamInitMemory);
00083 return dkcAllocStream(flag,default_data,size,NULL,NULL);
00084
00085 }
00086
00087 DKC_STREAM *WINAPI dkcAllocStreamFileType(UINT flag,const char *filename,const char *mode){
00088 DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemory);
00089 DKUTIL_FLAG_UP(flag,edkcStreamInitFile);
00090 return dkcAllocStream(flag,NULL,0,filename,mode);
00091 }
00092
00093 DKC_STREAM *WINAPI dkcAllocStreamEncouragementFileType(const char *filename,const char *mode,BOOL OrderFlag)
00094 {
00095 UINT flag = 0;
00096 DKUTIL_FLAG_UP(flag,edkcStreamInitFile);
00097 DKUTIL_FLAG_UP(flag,edkcStreamLittleEndian);
00098 DKUTIL_FLAG_DOWN(flag,edkcStreamBigEndian);
00099 if(OrderFlag){
00100 DKUTIL_FLAG_UP(flag,edkcStreamProcessAsOrdered );
00101 }else{
00102 DKUTIL_FLAG_UP(flag,edkcStreamProcessDefault);
00103 }
00104 return dkcAllocStream(flag,NULL,0,filename,mode);
00105 }
00106
00107
00108 DKC_STREAM * WINAPI dkcAllocStream(UINT flag,
00109 const void *default_data,size_t size,
00110 const char *filename,const char *mode)
00111 {
00112
00113 DKC_STREAM *p;
00114 void *psig;
00115
00116
00117 p = (DKC_STREAM *)dkcAllocate(sizeof(DKC_STREAM));
00118 if(NULL==p){
00119 return NULL;
00120 }
00121
00122 if(DKUTIL_FAILED(SetStreamInfo(p,flag))){
00123 goto Error;
00124 }
00125
00126 switch(p->mMode){
00127 case edkcStreamInitMemory:
00128 psig = (void *)dkcAllocMemoryStream(size);
00129 if(NULL==psig){
00130 goto Error;
00131 }
00132
00133 p->mSig = psig;
00134
00135 dkcStreamWrite(p,default_data,size);
00136 break;
00137 case edkcStreamInitFile:
00138 psig = (void *)dkcFOpen(filename,mode);
00139 if(NULL==psig){
00140 goto Error;
00141 }
00142
00143 p->mSig = psig;
00144
00145 break;
00146 default:
00147 goto Error;
00148 }
00149
00150
00151
00152
00153 return p;
00154 Error:
00155 dkcFree((void **)&p);
00156 return NULL;
00157 }
00158
00159
00160 int WINAPI dkcFreeStream(DKC_STREAM **p){
00161 DKC_STREAM *t;
00162 if(NULL==p){
00163 return edk_FAILED;
00164 }
00165 t = *p;
00166 if(NULL==t){
00167 return edk_FAILED;
00168 }
00169
00170 switch(t->mMode){
00171 case edkcStreamInitMemory:
00172 dkcFreeMemoryStream((DKC_MEMORYSTREAM **)&(t->mSig));
00173 break;
00174 case edkcStreamInitFile:
00175 dkcFClose((FILE **)&(t->mSig));
00176 break;
00177 #ifdef DEBUG
00178 default:
00179 dkcmNOT_ASSERT("dkcFreeStream FAILED");
00180 #endif
00181 }
00182 return dkcFree((void **)p);
00183 }
00184
00185
00186
00187
00188 int WINAPI dkcStreamSeek(DKC_STREAM *ptr,int offset,int origin){
00189 int r = edk_FAILED;
00190 switch(ptr->mMode){
00191 case edkcStreamInitMemory:
00192 r = dkcMemoryStreamSeek((DKC_MEMORYSTREAM *)ptr->mSig,offset,origin);
00193 break;
00194 case edkcStreamInitFile:
00195
00196 r = fseek((FILE *)ptr->mSig,offset,origin);
00197 break;
00198 }
00199 return r;
00200
00201 }
00202
00204 long WINAPI dkcStreamTell(DKC_STREAM *ptr){
00205 int r = edk_FAILED;
00206 switch(ptr->mMode){
00207 case edkcStreamInitMemory:
00208 r = dkcMemoryStreamTell((DKC_MEMORYSTREAM *)ptr->mSig);
00209 case edkcStreamInitFile:
00210 r = ftell((FILE *)ptr->mSig);
00211 if(r==-1){
00212 return edk_FAILED;
00213 }
00214 }
00215 return r;
00216
00217 }
00218
00219 int WINAPI dkcStreamFlush(DKC_STREAM *ptr){
00220 int r = edk_SUCCEEDED;
00221
00222 if(edkcStreamInitFile!=ptr->mMode){
00223 return edk_FAILED;
00224 }
00225
00226 r = fflush((FILE *)ptr->mSig);
00227
00228 if(r==EOF){
00229 return edk_FAILED;
00230 }
00231 return edk_SUCCEEDED;
00232 }
00233
00234 BOOL WINAPI dkcStreamEOF(DKC_STREAM *ptr){
00235 if(edkcStreamInitFile != ptr->mMode){
00236 goto Exit;
00237 }
00238 if(0 != feof((FILE *)ptr->mSig)){
00239 return TRUE;
00240 }
00241 Exit:
00242 return FALSE;
00243 }
00244
00245 BOOL WINAPI dkcStreamError(DKC_STREAM *ptr){
00246 if(edkcStreamInitFile != ptr->mMode){
00247 goto Exit;
00248 }
00249 if(0 != ferror((FILE *)ptr->mSig)){
00250 return TRUE;
00251 }
00252 Exit:
00253 return FALSE;
00254 }
00255
00256
00257 static DKC_INLINE int dkcStreamReadObayAnOrder(
00258 DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize)
00259 {
00260 int r = edk_FAILED;
00261 size_t readsize_ = 0;
00262 size_t count;
00263 size_t tc,tsize;
00264 BYTE *tbuffer;
00265 FILE *fp = (FILE *)ptr->mSig;
00266
00267 if(NULL==readsize){
00268 readsize = &readsize_;
00269 }
00270
00271
00272
00273
00274 tsize = size;
00275
00276 tc = 0;
00277
00278 count = 0;
00279
00280 tbuffer = (BYTE *)buffer;
00281 for(;;)
00282 {
00283
00284 if(ferror(fp) ){
00285
00286 r = edk_FAILED;
00287 break;
00288 }
00289 if(feof(fp)){
00290
00291 r = edk_BufferOverFlow;
00292 break;
00293 }
00294
00295 tc = fread(&tbuffer[count],1,tsize,fp);
00296
00297 tsize -= tc;
00298 count += tc;
00299
00300 if(count == size){
00301 r = edk_SUCCEEDED;
00302 break;
00303 }
00304 # ifdef DEBUG
00305
00306 dkcmNOT_ASSERT(count > size);
00307 # else
00308 if(count > size){
00309 break;
00310 }
00311 # endif
00312 }
00313 *readsize = count;
00314 return r;
00315
00316 }
00317
00318 DKC_INLINE int WINAPI dkcStreamRead(DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize){
00319 int r = edk_FAILED;
00320 FILE *fp = (FILE *)ptr->mSig;
00321 size_t redsize = 0;
00322
00323
00324 if(NULL==readsize){
00325 readsize = &redsize;
00326 }
00327
00328
00329
00330
00331
00332
00333
00334
00335 switch(ptr->mMode){
00336 case edkcStreamInitMemory:
00337 r = dkcMemoryStreamRead((DKC_MEMORYSTREAM *)ptr->mSig,
00338 buffer,size,readsize);
00339 break;
00340 case edkcStreamInitFile:
00341
00342 if(ptr->mProcessMode & edkcStreamProcessDefault){
00343
00344 *readsize = fread(buffer,1,size,fp);
00345
00346
00347 if(feof(fp)){
00348 r = edk_BufferOverFlow;
00349 }else if(!ferror(fp)){
00350 r = edk_SUCCEEDED;
00351 }
00352
00353 }else{
00354 r = dkcStreamReadObayAnOrder(ptr,buffer,size,readsize);
00355 }
00356
00357
00358 break;
00359 }
00360 return r;
00361 }
00362
00363 static int WINAPI StreamRead(DKC_STREAM *ptr, void *buffer,size_t size,void *hoge){
00364 return dkcStreamRead(ptr,buffer,size,(size_t *)hoge);
00365 }
00366
00367 int WINAPI dkcStreamRead16(DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize)
00368 {
00369 return dkcStreamProcess16(ptr,buffer,size,StreamRead,(void *)readsize);
00370
00371
00372
00373
00374
00375
00376
00377
00378
00379
00380
00381
00382
00383
00384
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415 }
00416
00417 int WINAPI dkcStreamRead32(DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize){
00418 return dkcStreamProcess32(ptr,buffer,size,StreamRead,(void *)readsize);
00419 }
00420
00421 int WINAPI dkcStreamRead64(DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize){
00422 return dkcStreamProcess64(ptr,buffer,size,StreamRead,(void *)readsize);
00423 }
00424
00425
00426 int WINAPI dkcStreamRef(DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize)
00427 {
00428
00429 long t = dkcStreamTell(ptr);
00430
00431 int r = dkcStreamRead(ptr,buffer,size,readsize);
00432
00433
00434
00435
00436
00437
00438
00439
00440
00441
00442
00443
00444
00446 dkcStreamSeek(ptr,t,edkcStreamSeekSet);
00447 return r;
00448 }
00449
00450 int WINAPI dkcStreamRef16(DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize){
00451 long t = dkcStreamTell(ptr);
00452 int r = dkcStreamRead16(ptr,buffer,size,readsize);
00453 dkcStreamSeek(ptr,t,edkcStreamSeekSet);
00454 return r;
00455 }
00461 int WINAPI dkcStreamRef32(DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize){
00462 long t = dkcStreamTell(ptr);
00463 int r = dkcStreamRead32(ptr,buffer,size,readsize);
00464 dkcStreamSeek(ptr,t,edkcStreamSeekSet);
00465 return r;
00466 }
00471 int WINAPI dkcStreamRef64(DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize){
00472 long t = dkcStreamTell(ptr);
00473 int r = dkcStreamRead64(ptr,buffer,size,readsize);
00474 dkcStreamSeek(ptr,t,edkcStreamSeekSet);
00475 return r;
00476
00477 }
00478
00479
00480
00481
00482
00483
00484
00485
00486
00487
00488
00489
00490
00491
00492 static DKC_INLINE int dkcStreamWriteObayAnOrder(DKC_STREAM *ptr,const void *buffer,size_t size){
00493 int r = edk_FAILED;
00494 size_t tc,tsize;
00495 size_t count;
00496 const BYTE *tbuffer = (const BYTE *)buffer;
00497 FILE *fp;
00498
00499 tc = 0;
00500 count = 0;
00501 tsize = size;
00502 fp = (FILE *)ptr->mSig;
00503
00504 for(;;){
00505
00506 if(ferror(fp)){
00507 return edk_FAILED;
00508 }
00509 if(feof(fp)){
00510 return edk_BufferOverFlow;
00511 }
00512
00513 tc = fwrite(&tbuffer[count],1,tsize,fp);
00514
00515 tsize -= tc;
00516 count += tc;
00517
00518 if(count == size){
00519 r = edk_SUCCEEDED;
00520 break;
00521 }
00522 # ifdef DEBUG
00523
00524 dkcmNOT_ASSERT(count > size);
00525 # else
00526 if(count > size){
00527
00528 break;
00529 }
00530 # endif
00531
00532 }
00533
00534
00535 return r;
00536 }
00537
00538 DKC_INLINE int WINAPI dkcStreamWrite(DKC_STREAM *ptr,const void *buffer,size_t size)
00539 {
00540 int r = edk_FAILED;
00541
00542 UINT proc_flag = ptr->mProcessMode;
00544 if(proc_flag & edkcStreamWriteErrorWhenEndianChange){
00545 if(ptr->mChangeEndian){
00546 return edk_Not_Satisfactory;
00547 }
00548 }
00549
00550 switch(ptr->mMode){
00551 case edkcStreamInitMemory:
00552 r = dkcMemoryStreamWrite((DKC_MEMORYSTREAM *)ptr->mSig,buffer,size);
00553 break;
00554 case edkcStreamInitFile:
00555 r = dkcStreamWriteObayAnOrder(ptr,buffer,size);
00556 break;
00557 }
00558
00559 return r;
00560 }
00561
00562 static int WINAPI StreamWrite(DKC_STREAM *ptr, void *buffer,size_t size,void *hoge){
00563 return dkcStreamWrite(ptr,buffer,size);
00564 }
00565
00566
00567
00568
00569
00570
00571
00572
00573
00574
00575
00576
00577
00578
00579
00580
00581
00582
00583
00584
00585
00586
00587
00588
00589
00590
00591
00592 int WINAPI dkcStreamWrite16(DKC_STREAM *ptr, const void *buffer,size_t size){
00593 return dkcStreamProcess16(ptr,(void *)buffer,size,StreamWrite,NULL);
00594 }
00595
00596 int WINAPI dkcStreamWrite32(DKC_STREAM *ptr, const void *buffer,size_t size){
00597 return dkcStreamProcess32(ptr,(void *)buffer,size,StreamWrite,NULL);
00598
00599 }
00600
00601
00602
00603 int WINAPI dkcStreamWrite64(DKC_STREAM *ptr, const void *buffer,size_t size){
00604 return dkcStreamProcess64(ptr,(void *)buffer,size,StreamWrite,NULL);
00605 }
00606
00607
00608
00609
00610 int WINAPI dkcStreamProcess(DKC_STREAM *ptr,void *buffer,size_t size,
00611 DKC_STREAM_PROCESS_TYPE write_t,void *data)
00612 {
00613 return write_t(ptr,buffer,size,data);
00614 }
00615
00616
00617
00618 int WINAPI dkcStreamProcess16(DKC_STREAM *ptr,void *buffer,size_t size,
00619 DKC_STREAM_PROCESS_TYPE write_t,void *data){
00620 int r;
00621 USHORT *pb;
00622 size_t elem_num,pause = 16;
00623 size_t i;
00624
00625 if(size % pause != 0){
00626 return edk_ArgumentException;
00627 }
00628 if(ptr->mChangeEndian)
00629 {
00630 pb = (USHORT *)malloc(size);
00631 if(NULL==pb){
00632
00633 return edk_OutOfMemory;
00634 }
00635
00636
00637 memcpy(pb,buffer,size);
00638 elem_num = size / pause;
00639
00640
00641 for(i=0;i<elem_num;i++){
00642 pb[i] = dkcReverseEndian16(pb[i]);
00643 }
00644
00645 r = write_t(ptr,pb,size,data);
00646
00647 free(pb);
00648 }else{
00649 r = write_t(ptr,buffer,size,data);
00650 }
00651 return r;
00652 }
00653
00654
00655 int WINAPI dkcStreamProcess32(DKC_STREAM *ptr,void *buffer,size_t size,
00656 DKC_STREAM_PROCESS_TYPE write_t,void *data){
00657 int r;
00658 ULONG *pb;
00659 size_t elem_num,pause = 32;
00660 size_t i;
00661
00662 if(size % pause != 0){
00663 return edk_ArgumentException;
00664 }
00665 if(ptr->mChangeEndian)
00666 {
00667 pb = (ULONG *)malloc(size);
00668 if(NULL==pb){
00669 return edk_OutOfMemory;
00670 }
00671
00672
00673 memcpy(pb,buffer,size);
00674 elem_num = size / pause;
00675
00676
00677 for(i=0;i<elem_num;i++){
00678 pb[i] = dkcReverseEndian32(pb[i]);
00679 }
00680
00681 r = write_t(ptr,pb,size,data);
00682
00683 free(pb);
00684 }else{
00685 r = write_t(ptr,buffer,size,data);
00686 }
00687 return r;
00688
00689 }
00690
00691
00692
00693
00694
00695
00696
00697
00698
00699
00700 int WINAPI dkcStreamProcess64(DKC_STREAM *ptr,void *buffer,size_t size,
00701 DKC_STREAM_PROCESS_TYPE write_t,void *data){
00702 int r;
00703 ULONGLONG *pb;
00704 size_t elem_num,pause = 64;
00705 size_t i;
00706
00707 if(size % pause != 0){
00708 return edk_ArgumentException;
00709 }
00710 if(ptr->mChangeEndian)
00711 {
00712 pb = (ULONGLONG *)malloc(size);
00713 if(NULL==pb){
00714 return edk_OutOfMemory;
00715 }
00716
00717
00718 memcpy(pb,buffer,size);
00719 elem_num = size / pause;
00720
00721
00722 for(i=0;i<elem_num;i++){
00723 pb[i] = dkcReverseEndian64(pb[i]);
00724 }
00725
00726 r = write_t(ptr,pb,size,data);
00727
00728 free(pb);
00729 }else{
00730 r = write_t(ptr,buffer,size,data);
00731 }
00732 return r;
00733 }
00734
00735
00736
00737
00738 int WINAPI dkcStreamClear(DKC_STREAM *ptr){
00739
00740 size_t fsize;
00741
00742 size_t tsize;
00743 size_t write_size;
00744 FILE *fp;
00745 int r = edk_FAILED;
00746 char null_array[1024];
00747
00748
00749 switch(ptr->mMode){
00750 case edkcStreamInitMemory:
00751 r = dkcMemoryStreamClear( (DKC_MEMORYSTREAM *)ptr->mSig );
00752 break;
00753 case edkcStreamInitFile:
00754
00755 memset(null_array,0,sizeof(null_array));
00756 fp =(FILE *) ptr->mSig;
00757
00758
00759 fseek( fp, 0, SEEK_END ) ;
00760 fsize = ftell( fp ) ;
00761 fseek( fp, 0, SEEK_SET ) ;
00762
00763 if(fsize > sizeof(null_array))
00764 {
00765
00766 tsize = 0;
00767 write_size = sizeof(null_array);
00768 for(;;){
00769
00770 r = dkcStreamWrite(ptr,null_array,write_size);
00771
00772 if(DKUTIL_FAILED(r)){
00773 return r;
00774 }
00775 if(tsize >= fsize){
00776 r = edk_SUCCEEDED;
00777 break;
00778 }
00779
00780 if(tsize + write_size > fsize){
00781 write_size = fsize - tsize;
00782 }else{
00783 tsize += write_size;
00784
00785
00786 write_size = sizeof(null_array);
00787 }
00788 }
00789 }else{
00790 r = dkcStreamWrite(ptr,null_array,fsize);
00791 }
00792
00793 break;
00794 }
00795 return r;
00796 }
00797