メインページ | 構成 | ファイル一覧 | 構成メンバ | ファイルメンバ | 関連ページ

dkcStream.c

説明を見る。
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){//ポインタがNULL
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;//succeeded
00032 }
00033 
00034 
00035 //streamを初期化
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     //p = calloc(gInitSize,gInitSize);
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     //clear foepn mode
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;//max!!!
00082     ptr->mMode =    edkcStreamInitFile;//for file
00083     
00084     //copy fopen mode
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     offset + succeeded
00099     offset - succeeded
00100     offset + length error
00101     offset - length error
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     //default://要らないので・・・
00119         //return edk_FAILED;
00120     }
00121 
00122     //common...
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 /*- 1*/,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     //int result = edk_FAILED;
00156     int Read = 0;
00157     size_t f_read = 0;
00158     
00159     
00160     if(NULL==ptr){
00161         return edk_FAILED;
00162     }
00163     //if(dkcForFlagErrorCheck(ptr)) return edk_FAILED;
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     //size_t ReallocateSize = 0;
00250     size_t f_write = 0;
00251     //void *NewPtr,*OldPtr;
00252 
00253     if(NULL==ptr) return edk_FAILED;
00254 
00255     //OldPtr = ptr->mBuffer;
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         //none
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((void **)&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     //memset(ptr,0,sizeof(*ptr));
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     //if(t){free(t);t=NULL;}
00351     return t;
00352 }
00353 //dkcAllocNewStream()と対
00354 int WINAPI dkcFreeDeleteStream(DKC_STREAM **ptr){
00355     int r;
00356     r = dkcDeleteStream(*ptr);
00357     if(DKUTIL_FAILED(r)) return r;
00358 
00359     dkcFree((void **)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,//want_start は - であろう。
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     //FILE *fp = NULL;
00403     //void *tbuf = NULL;
00404     //size_t tsize = 0;
00405 
00406     if(NULL==ptr) return NULL;
00407     //ファイルオープンモードなんて知らない!!!
00408     if(tp->mMode == edkcStreamInitFile) return NULL;
00409     /*
00410     char mstr[3];
00411     mstr[0] = ptr->mMode[0];
00412     mstr[1] = ptr->mMode[1];
00413     mstr[2] = '\0';
00414 
00415     tp = dkcAllocNewStream(ptr->mMode,ptr->mSize,filename,mstr);
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{//file
00423     
00424         /*tsize = ptr->mSize;
00425         tbuf =  dkcAllocate(tsize);
00426         
00427         fp = (FILE *)ptr->mBuffer;
00428         fseek(fp,0,edkcStreamSeekSet);//同じだから。
00429         fread(tbuf,1,UINT_MAX,fp);//とりあえず読めるだけ。
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 //int WINAPI dkcSTreamDeserialize(DKC_STREAM *ptr,const char *filename){}
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     //+1は最低のバッファのサイズ。
00468     //if(buffsize < sizeof(DKC_STREAM) + 1) return edk_FAILED;
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((void **)alloced_buffer);
00504 }
00505 
00506 
00507 #endif

dkutil_cに対してTue Oct 19 03:34:56 2004に生成されました。 doxygen 1.3.6