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