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

dkcStream.c

説明を見る。
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         //endianmode = edkcStreamBigEndian;
00036         if(isLittle){
00037             endian_mode = TRUE;
00038         }
00039     }else if(flag & edkcStreamLittleEndian){
00040         //endianmode = edkcStreamLittleEndian;
00041         if(!isLittle){
00042             endian_mode = TRUE;
00043         }
00044     }else /*if(flag & edkcStreamInitDefaultEndian)*/{
00045         if(isLittle){
00046             //endianmode = edkcStreamLittleEndian;
00047         }else{
00048             //endianmode = edkcStreamBigEndian;
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     //update
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         //update    
00133         p->mSig = psig;
00134         //write default data
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         //update
00143         p->mSig = psig;
00144         
00145         break;
00146     default:
00147         goto Error;
00148     }
00149 
00150     
00151     //p->mEndianMode = endianmode
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         //成功したら0 == edk_SUCCEEDED;
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     //dkcmNOT_ASSERT("dkcStreamTell failed");
00217 }
00218 
00219 int WINAPI dkcStreamFlush(DKC_STREAM *ptr){
00220     int r = edk_SUCCEEDED;
00221     //filter
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     //1,sizeの引数を入れ替えるとどうか?
00272     //1 = fread(buffer,size,1,ptr->mfp);
00273     //read size
00274     tsize = size;
00275     //temp variable
00276     tc = 0;
00277     //offset counter
00278     count = 0;
00279     //byte type pointer
00280     tbuffer = (BYTE *)buffer;
00281     for(;;)
00282     {
00283         //error check
00284         if(ferror(fp) ){
00285             //*readsize = count;
00286             r = edk_FAILED;
00287             break;
00288         }
00289         if(feof(fp)){
00290             //*readsize = count;
00291             r = edk_BufferOverFlow;
00292             break;
00293         }
00294         //read
00295         tc = fread(&tbuffer[count],1,tsize,fp);
00296         //update
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     //readsize filter
00324     if(NULL==readsize){
00325         readsize = &redsize;
00326     }
00327 
00328     //エンディアンチェンジ指定されているよ〜〜。
00329     /*if(flag & edkcStreamReadErrorWhenEndianChange){
00330         if(ptr->mChangeEndian){
00331             return edk_Not_Satisfactory;
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             //set result 
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     size_t sentinel = size / 2;
00372     size_t i = 0;
00373     size_t t_rs = 0;
00374 
00375     USHORT *pus;
00376 
00377     size_t real_readsize = 0;
00378     int result;
00379 
00380     //filter
00381     if(size_t % 2 != 0){
00382         return edk_ArgumentException;
00383     }
00384 
00385     pus = (USHORT *)buffer;
00386     
00387     for(;i<sentinel;i++){
00388         //process
00389         result = dkcStreamRead(ptr,&pus[i],2,&t_rs);
00390         
00391 
00392         //update data
00393         real_readsize += t_rs;
00394 
00395 
00396         //process state update check
00397         switch(result){
00398         case edkSUCCEEDED:
00399             continue;
00400         case edk_FAILED:
00401         case edk_BufferOverFlow:
00402             goto End;
00403         default:
00404             dkcmNOT_ASSERT("dkcStreamSwapRead16 Error");
00405             goto End;
00406         }
00407     }//end of for
00408 End:
00409     if(readsize){//set readsize
00410         *readsize = real_readsize;
00411     }
00412     //process result
00413     return result;
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     //読みこむ(内部で位置がsize分(readsize分)ずらされる)
00431     int r = dkcStreamRead(ptr,buffer,size,readsize);
00432     
00433     
00434     /*
00435     if(readsize > INT_MAX){
00436         dkcmNOT_ASSEERT("INT_MAX byteも一気に読みこむな!ヽ(`Д´)ノムキィ");
00437         return edk_FAILED;
00438     }
00439     t = (*readsize) - t;
00440     
00441     //この条件はありえない。
00442     dkcmNOT_ASSERT(t < 0);*/
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         //error check
00506         if(ferror(fp)){
00507             return edk_FAILED;
00508         }
00509         if(feof(fp)){
00510             return edk_BufferOverFlow;
00511         }
00512         //write
00513         tc = fwrite(&tbuffer[count],1,tsize,fp);
00514         //update
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 /*int WINAPI dkcStreamRef8(DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize){
00566     //dkcStream
00567     
00568 }*/
00569 
00570 /*static DKC_INLINE dkcStreamWriteChangeEndian(DKC_STREAM *ptr,const void *buffer,size_t size){
00571     USHORT *pb;
00572     size_t elem_num;
00573     size_t i;
00574 
00575     pb = (USHORT)malloc(size);
00576     if(NULL==pb){
00577         return edk_FAILED;
00578     }
00579 
00580     memcpy(pb,buffer,size);
00581     elem_num = size / 16;
00582 
00583     //エンディアンをチェンジさせる。
00584     for(i=0;i<elem_num;i++){
00585         pb[i] = dkcReverseEndian16(pb[i]);
00586     }
00587     r = dkcStreamWrite(ptr,pb,size);
00588 
00589     free(pb);
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             //return edk_FAILED;
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 //stream内をmemset(0)する。(seek位置も最初に戻される。
00738 int WINAPI dkcStreamClear(DKC_STREAM *ptr){
00739     //file size
00740     size_t fsize;
00741     //temp size
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         {//ファイルのサイズがNULL配列より大きい場合
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 

dkutil_cに対してTue Feb 22 02:01:49 2005に生成されました。 doxygen 1.3.6