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

dkcOSIndependent.c

説明を見る。
00001 
00007 #define DKUTIL_C_OS_INDEPENDENT_C
00008 
00009 #include "dkcOSIndependent.h"
00010 #include "dkcDefined.h"
00011 
00012 #include "dkcQueue.h"
00013 
00014 
00015 #include <assert.h>
00016 #include <math.h>
00017 
00018 
00019 #ifdef WIN32
00020 
00021 #pragma warning(disable:4127)
00022 
00023 int dkcDynamicCheckEnvironment(BOOL isForceExit){
00024     int r = edk_FAILED;
00025     if((sizeof(int) != sizeof(long))) goto Error;
00026     if(sizeof(int) != 4) goto Error;
00027     
00028     if((sizeof(UINT) != sizeof(ULONG))) goto Error;
00029     if(sizeof(UINT) != 4) goto Error;
00030 
00031     if((sizeof(BYTE) != sizeof(char))) goto Error;
00032     if((sizeof(BYTE) != 1)) goto Error;
00033     if(sizeof(double) != 8) goto Error;
00034     if(sizeof(void *) != sizeof(unsigned)) goto Error;
00035     if(sizeof(void *) != sizeof(int)) goto Error;
00036     if(sizeof(short) != 2) goto Error;
00037     r = edk_SUCCEEDED;
00038 Error:
00039     if(DKUTIL_FAILED(r) && isForceExit){
00040         exit(-1);
00041     }
00042     return r;
00043 }
00044 
00045 #pragma warning(default:4127)
00046 #else
00047 int dkcDynamicCheckEnvironment(BOOL isForceExit){
00048 
00049 }
00050 
00051 #endif
00052 
00053 
00054 int WINAPI dkcIsNativePathString(const char *s,size_t size){
00055 
00056     size_t i=0;
00057     if(s==NULL) return edk_FAILED;
00058     for(;i<size;i++){
00059         if(dkcmIS_INVALID_PATH_CHAR(s[i]))
00060         {
00061             return FALSE;
00062         }
00063     }
00064     return TRUE;
00065 }
00066 
00067 
00068 int WINAPI dkcErrorMessage(const char *expression,
00069                                          const char *filename,size_t line,const char *message,...)
00070 {
00071     char s[1024];
00072     char ss[1024 * 2];
00073     
00074     int va_list_result;
00075     va_list Valist;
00076 
00077     NULL_CHAR_ARRAY(s);
00078     NULL_CHAR_ARRAY(ss);
00079     
00080     if(message){
00081         SET_VA_LIST_C(Valist,va_list_result,s,sizeof(s),message);
00082     }else{
00083         //SET_VA_LIST(s,sizeof(s),"No message");
00084         _snprintf(s,sizeof(s),"No message\n");
00085     }
00086 
00087     _snprintf(ss,sizeof(ss),
00088         "DKUTIL_ASSERT(%s):\nfile:%s / \n line:%d / \n message: %s",
00089         expression,filename,line,s);
00090 
00091 
00092 
00093 #ifdef NDEBUG//release
00094 #   ifdef WIN32
00095         ODS(ss);
00096     //::MessageBox(NULL,ss,"ERROR ASSERTION !!",MB_OK);
00097     {
00098         LPCTSTR name="ERROR_TEMP.txt";
00099         {
00100             //ファイルをオープン
00101             FILE *fp;
00102             if(NULL != (fp = fopen( name , "at" ))){
00103             
00104                 // エラーログファイルに書き出す
00105                 fputs( ss , fp ) ;
00106                 fclose( fp ) ;
00107                 Sleep(800);
00108             }
00109         }
00110         ShellExecute(NULL, "open",name, NULL, NULL, SW_SHOWNORMAL);
00111         //Sleep(1000);
00112         //DeleteFile(name);
00113     }
00114     MB("このテキストをこのソフトの開発者に渡せば、バグ発見の近道なります。\n \
00115         開発者に知らせるときはこのテキストを転記してあげましょう。");
00116     if(IDYES==MessageBox(NULL,
00117         "このままこのソフトを起動しつづけると、更なるエラーが発生する可能性があります。\n終了しますか?",
00118         "あってはいけない エラー!!!",
00119         MB_YESNO))
00120     {
00121         exit(edk_FAILED);
00122         //terminate();
00123     }else{
00124     }
00125 #   else    //else of win32
00126     
00127     fprintf(stderr,ss);
00128     exit(edk_FAILED);
00129 
00130 #   endif //end of win32
00131 
00132 #else //debug
00133 
00134 #   ifdef WIN32
00135         ODS(ss);
00136     fprintf(stderr,ss);
00137     //_CrtDebugBreak();
00138     DebugBreak();
00139 #   else //else of win32
00140 
00141     fprintf(stderr,ss);
00142     Debugger();
00143 
00144 #   endif //end of win32
00145 #endif//end of NDEBUG
00146     //assert(ss);
00147     
00148     return TRUE;
00149 }
00150 
00151 void *WINAPIV dkcMallocAdapter(size_t s){
00152     return malloc(s);
00153 }
00154 
00155 void WINAPIV dkcFreeAdapter(void *p){
00156     if(p){
00157         free(p);
00158     }
00159 }
00160 
00161 DKC_INLINE void *dkcAllocateFill(size_t size,BYTE fill){
00162     void *p = dkcAllocateFast(size);
00163     if(NULL==p) return NULL;
00164     memset(p,fill,size);
00165     return p;
00166 }
00167 DKC_INLINE void *dkcAllocateFast(size_t size){
00168     return malloc(size);
00169 }
00170 DKC_INLINE void* dkcAllocate(size_t size){
00171     return dkcAllocateFill(size,0); 
00172 /*void *ptr;
00173     ptr = dkcAllocateFast(size);
00174     if(NULL==ptr) return NULL;
00175     memset(ptr,0,size);
00176     return ptr;
00177     */
00178 }
00179 
00180 DKC_INLINE int  dkcFree(void **p){
00181     if(!*p) return edk_FAILED;
00182     free(*p);
00183     *p = NULL;
00184     return edk_SUCCEEDED;
00185 }
00186 BOOL dkcIs_foepn_mode(const char *s){
00187     /* wrtb+ */
00188     const char *ms= "wrtb+";
00189     size_t slen = strlen(s);
00190     size_t mslen = strlen(ms);
00191     size_t i,j;
00192     int flag = FALSE;
00193     for(i=0;i<slen;i++){
00194         for(j=0;j<mslen;j++){
00195             if(ms[j]==s[i]){
00196                 flag = TRUE;
00197                 break;
00198             }
00199         }
00200         if(TRUE!=flag){
00201             return FALSE;
00202         }else{
00203             flag = FALSE;
00204         }
00205     }
00206     return TRUE;
00207 }
00208 /*
00209 struct dkcDoublePoint{
00210     double x,y;
00211 }DKC_DOUBLE_POINT;
00212 
00213 int calc(DKC_DOUBLE_POINT *pa,size_t nums){
00214     pa->x   
00215 
00216 }*/
00217 /*
00218 double calc(double StartX,double StartY,double EndX,double EndY)
00219 {
00220     return  StartY - ((EndY - StartY) / (EndX - StartX)) * StartX;
00221 }
00222 */
00223 size_t dkcReallocateSizeFunction(size_t OldSize,size_t ExpandSize){
00224     //y=-25.43035 * pow(x,2) + 116.7214
00225     //y = -0.00000018 * pow(x,2) + 0.00019
00226     //y = -99.9999 * pow(OldSize,2) + 104857600;
00227     //y = 0.105263 * x * x + 10.52631
00228     //double x;
00229 //  size_t size;
00230     if(OldSize <= 1024 * 5){//5KB以内なら2倍
00231         return OldSize * 2;
00232     }else if(OldSize >= 1024 * 1024 * 10 || 0==OldSize)
00233     {//10MB以上なら + ExpandSize
00234         return OldSize + ExpandSize;
00235     }
00236     //それ以外ならExpandSize * 3
00237     return OldSize + ExpandSize * 3; 
00238     //return OldSize * 2;//ひでぇ関数だ。
00239 }
00240 
00241 int WINAPI dkcReallocate(void **NewPtr,size_t NewSize,
00242     void **OldPtr)
00243 {
00244     return dkcReallocateEx(realloc,NewPtr,NewSize,OldPtr);
00245 }
00246 
00247 int WINAPI dkcReallocateEx(
00248     DKC_REALLOC_F_TYPE your_realloc,void **NewPtr,size_t NewSize,
00249     void **OldPtr
00250 )
00251 {
00252     void *ptr = NULL;
00253 
00254     if(NULL== your_realloc  /*|| NULL == *OldPtr ||
00255         0==OldSize*/
00256     ){
00257         return edk_ArgumentException;//アホ引数入れるな!!
00258     }
00259 
00260     ptr = your_realloc(*OldPtr,NewSize);
00261     if(NULL==ptr) return edk_FAILED;
00262 
00263     //更新
00264     *OldPtr = NULL;
00265     *NewPtr = ptr;
00266     
00267     return edk_SUCCEEDED;
00268 }
00269 
00270 
00271 
00272 int WINAPI dkcReallocateAutoExpand(
00273     DKC_REALLOC_F_TYPE your_realloc,void **NewPtr,
00274     void **OldPtr,size_t OldSize,size_t *reallocated_size
00275     )
00276 {
00277     void *ptr = NULL;
00278     size_t want_size = OldSize / 8;
00279     size_t ra_size = dkcReallocateSizeFunction(OldSize,
00280          (want_size <= 20) ? 20 : want_size
00281     );
00282     size_t div = 8;
00283     size_t tmp_ra = ra_size / div;
00284     size_t i;
00285     if(NULL== your_realloc /*|| NULL==*NewPtr*/ || NULL == *OldPtr ||
00286         0==OldSize  || NULL==reallocated_size   
00287     ){
00288         return edk_ArgumentException;//アホ引数入れるな!!
00289     }
00290 
00291     for(i=0;i<div;i++){
00292         ptr = your_realloc(*OldPtr,ra_size);
00293         if(NULL==ptr){
00294             if(OldSize > (ra_size -= tmp_ra)){//とりあえずtmp_ra分を引く。
00295                 break;//こら望みなしだわ
00296             }
00297             continue;
00298         }else{
00299             break;
00300         }
00301     }
00302     if(NULL==ptr) return edk_FAILED;
00303 
00304     //更新
00305     *NewPtr = ptr;  
00306     *OldPtr = NULL;
00307 
00308     *reallocated_size = ra_size;
00309 
00310     return edk_SUCCEEDED;
00311 }
00312 
00313 static int WINAPI dkcLoadFile(void *data,size_t size,const char *fname,const char *mode,size_t *readsize){//="rb"
00314     FILE *fp ;
00315     if(NULL==readsize || NULL==data || NULL==fname || NULL==mode){
00316         return edk_FAILED;
00317     }
00318     fp = fopen( fname , mode ) ;//rb
00319     if(fp==NULL)return edk_FAILED;
00320     *readsize = fread( data , 1 , size , fp ) ;
00321     //fread( data , sizeof(size)  , 1 , fp ) ;
00322     fclose( fp ) ;
00323 
00324     return edk_SUCCEEDED;
00325 
00326 }
00327 static int WINAPI dkcSaveFile(const void *data,size_t size,const char *fname,const char *mode)
00328 {
00329     FILE *fp;
00330     if(NULL==fname || NULL==mode){
00331         return edk_FAILED;
00332     }
00333     fp = fopen( fname , mode ) ;//wb
00334     if(fp==NULL) return edk_FAILED;
00335     fwrite( data , size  , 1 , fp ) ;
00336     //fwrite( data , sizeof(size)  , 1 , fp ) ;
00337     fclose( fp ) ;
00338     return edk_SUCCEEDED;
00339 }
00340 
00341 
00342 DKC_EXTERN FILE * WINAPI dkcFOpen(const char *filename,const char *mode){
00343     return fopen(filename,mode);
00344 }
00345 
00346 DKC_EXTERN int WINAPI dkcFClose(FILE **ptr){
00347     if(NULL==ptr || NULL==*ptr) return edk_ArgumentException;
00348     fclose(*ptr);
00349     *ptr = NULL;
00350     return edk_SUCCEEDED;
00351 }
00352 DKC_EXTERN size_t WINAPI dkcFReadAll(void *buffer,size_t size,FILE *fp)
00353 {
00354     size_t count;
00355     size_t tc,tsize;
00356     BYTE *tbuffer;
00357 
00358     //read size
00359     tsize = size;
00360     //temp variable
00361     tc = 0;
00362     //offset counter
00363     count = 0;
00364     //byte type pointer
00365     tbuffer = (BYTE *)buffer;
00366     for(;;)
00367     {
00368         //error check
00369         if(ferror(fp) ){
00370             break;
00371         }
00372         if(feof(fp)){
00373             break;
00374         }
00375         //read
00376         tc = fread(&tbuffer[count],1,tsize,fp);
00377         //update
00378         tsize -= tc;
00379         count += tc;
00380 
00381         if(count == size){
00382             break;
00383         }
00384 #   ifdef DEBUG
00385         //ありえないエラーチェック
00386         dkcmNOT_ASSERT(count > size);
00387 #   else
00388         if(count > size){
00389             break;
00390         }
00391 #   endif
00392     }
00393     return count;
00394 }
00395 
00396 DKC_EXTERN size_t WINAPI dkcFWriteAll(void *buffer,size_t size,FILE *fp){
00397     size_t count;
00398     size_t tc,tsize;
00399     BYTE *tbuffer;
00400 
00401     //read size
00402     tsize = size;
00403     //temp variable
00404     tc = 0;
00405     //offset counter
00406     count = 0;
00407     //byte type pointer
00408     tbuffer = (BYTE *)buffer;
00409     for(;;)
00410     {
00411         //error check
00412         if(ferror(fp) ){
00413             break;
00414         }
00415         if(feof(fp)){
00416             break;
00417         }
00418         //read
00419         tc = fwrite(&tbuffer[count],1,tsize,fp);
00420         //update
00421         tsize -= tc;
00422         count += tc;
00423 
00424         if(count == size){
00425             break;
00426         }
00427 #   ifdef DEBUG
00428         //ありえないエラーチェック
00429         dkcmNOT_ASSERT(count > size);
00430 #   else
00431         if(count > size){
00432             break;
00433         }
00434 #   endif
00435     }
00436     return count;
00437 
00438 }
00439 
00440 
00441 //fopenのファイル関数を使ってバイナリセーブを行う。
00442 int WINAPI dkcSaveBinary(const void *data,size_t size,const char *fname){//="wb"
00443     return dkcSaveFile(data,size,fname,"wb");
00444 }
00445 
00446 BOOL WINAPI dkcCreateEmptyFile(const char *filename){
00447     FILE *fp;
00448     fp = fopen( filename , "wb" ) ;//wb
00449     if(fp==NULL) return FALSE;
00450     fclose( fp ) ;
00451     return TRUE;
00452 }
00453 
00454 
00455 int WINAPI dkcLoadBinary(void *data,size_t size,const char *fname,size_t *readsize){//="rb"
00456     return dkcLoadFile(data,size,fname,"rb",readsize);
00457 }
00458 
00459 int WINAPI dkcSaveText(const char *text,size_t length,const char *fname){
00460     return dkcSaveFile(text,length,fname,"wt");
00461 }
00462 int WINAPI dkcLoadText(char *text,size_t length,const char *fname,size_t *readsize){
00463     return dkcLoadFile(text,length,fname,"rt",readsize);
00464 }
00465 
00466 
00467 void WINAPI dkcSwapFast(void *p1,void *p2,size_t size)
00468 {
00469     void *p = malloc(size);
00470     dkcmNOT_ASSERT(NULL==p);
00471     memcpy(p,p1,size);
00472     memcpy(p1,p2,size);
00473     memcpy(p2,p,size);
00474     free(p);
00475 }
00476 /*
00477 template<typename TYPE_T>
00478 inline void dkcSwapT(TYPE_T *p1,TYPE_T *p2,size_t size){
00479     size_t i;
00480     char buf;
00481     size_t mod_ = size % sizeof(TYPE_T);
00482     size_t cnt = size / sizeof(TYPE_T);
00483     for(i=0;i<cnt;i++){
00484         SWAP_NUM(p1[i],p2[i]);
00485     }
00486     for(i=0;i<mod_;i++){
00487         buf = (((BYTE *)p1)[size - mod_ + i]);
00488         (((BYTE *)p1)[size - mod_ + i]) = 
00489             (((BYTE *)p2)[size - mod_ + i]) ;
00490         (((BYTE *)p2)[size - mod_ + i]) = buf;
00491     }
00492 
00493 }
00494 
00495 
00496 void WINAPI dkcSwapFast(int *p1,int *p2,size_t size)
00497 {
00498     size_t i;
00499     char buf;
00500     size_t mod_ = size % sizeof(int);
00501     size_t cnt = size / sizeof(int);
00502     for(i=0;i<cnt;i++){
00503         SWAP_NUM(p1[i],p2[i]);
00504     }
00505     for(i=0;i<mod_;i++){
00506         buf = (((BYTE *)p1)[size - mod_ + i]);
00507         (((BYTE *)p1)[size - mod_ + i]) = 
00508             (((BYTE *)p2)[size - mod_ + i]) ;
00509         (((BYTE *)p2)[size - mod_ + i]) = buf;
00510     }
00511 }*/
00512 
00513 #ifdef _MSC_VER
00514 #   pragma warning(disable:4244)
00515 #endif
00516 
00517 void WINAPI dkcSwap64(ULONGLONG *p1,ULONGLONG *p2,size_t size){
00518     size_t i;
00519     BYTE buf;
00520     size_t mod_ = size % sizeof(ULONGLONG);
00521     size_t cnt = size / sizeof(ULONGLONG);
00522     //char *tp1 = (char *)p1,*tp2 = (char *)p2;
00523     for(i=0;i<cnt;i++){
00524         SWAP_NUM(p1[i],p2[i]);
00525     }
00526     for(i=0;i<mod_;i++){
00527         
00528         //SWAP_NUM((char)tp1[size - mod_ + 1],(char)tp2[size - mod_ + i]);
00529         /*a = b - a ;\
00530     b -= a ;\
00531     a += b
00532         */
00533         /*( ( ((char *) p2)[size - mod_ + i]))
00534             = (char)( ( ((char *) p2)[size - mod_ + i])) - 
00535             (char)( ( ((char *) p1)[size - mod_ + i]));
00536         
00537         ( ( ((char *) p2)[size - mod_ + i])) -= ( ( ((char *) p1)[size - mod_ + i]));
00538 
00539         ( ( ((char *) p1)[size - mod_ + i])) += ( ( ((char *) p2)[size - mod_ + i]));
00540             */
00541         
00542         
00543         buf = (((BYTE *)p1)[size - mod_ + i]);
00544         (((BYTE *)p1)[size - mod_ + i]) = 
00545             (((BYTE *)p2)[size - mod_ + i]) ;
00546         (((BYTE *)p2)[size - mod_ + i]) = buf;
00547         
00548     }
00549 
00550 }
00551 
00552 void WINAPI dkcSwap(void *p1,void *p2,size_t size)
00553 {
00554     dkcSwap64((ULONGLONG *)p1,(ULONGLONG *)p2,size);
00555 }
00556 
00557 
00558 
00559 DKC_INLINE void WINAPI dkcTwoDWORDToULONGLONG(ULONGLONG *dest,DWORD high,DWORD low){
00560     //*dest = (ULONGLONG)((high << 32) + low);
00561     *dest = (ULONGLONG)high << 32;
00562     *dest += low;
00563         //( high * MAXDWORD ) + low;
00564 }
00565 
00566 DKC_INLINE void WINAPI dkcULONGLONGToTwoDWORD(DWORD *dhigh,DWORD *dlow,ULONGLONG src){
00567     DWORD *o = (DWORD *)&src;
00568     dkcmNOT_ASSERT(sizeof(DWORD) * 2 != sizeof(ULONGLONG));
00569     //エンディアン問題をどうにかしよう!
00570     *dhigh = o[0];
00571     *dlow = o[1];
00572 }
00573 
00574 DKC_INLINE void WINAPI dkcLONGLONGToTwoLONG(LONG *high,LONG *low,LONGLONG src){
00575     LONG *o = (LONG *)&src;
00576     dkcmNOT_ASSERT(sizeof(LONG) * 2 != sizeof(LONGLONG));
00577     *high = o[0];
00578     *low = o[1];
00579 }
00580 
00581 DKC_INLINE void WINAPI dkcTwoLONGToLONGLONG(LONGLONG *dest,LONG high,LONG low){
00582     //*dest = (ULONGLONG)((high << 32) + low);
00583     *dest = (LONGLONG)high << 32;
00584     *dest += low;
00585 
00586 }
00587 
00588 /*
00589 //まずい、これは難しい。
00590 DKC_INLINE int WINAPI dkcDataReplace(BYTE *dest,size_t destsize,
00591                                                                          const BYTE *src,size_t srcsize,
00592                                                                          const BYTE *target_data,size_t target_data_size,
00593                                                                          const BYTE *replace_data,size_t replace_data_size)
00594 {
00595     
00596     size_t i;
00597 
00598     //とりあえず、20個 で offsetはsize_t分
00599     DKC_QUEUE *pq = dkcAllocQueue(20,sizeof(size_t));
00600     if(NULL==pq){
00601         return edk_OutOfMemory;
00602     }
00603 
00604     //まずは置換場所を探す
00605     for(i=0;i<srcsize;i++){
00606         memcmp(&src[i],
00607 
00608 
00609 
00610 
00611 
00612 }*/
00613 
00614 
00615 
00616 #ifdef _MSC_VER
00617 #   pragma warning(default:4244)
00618 
00619 
00620 
00621 void WINAPI dkcCheckMemoryLeak(BOOL flag){
00622     if(flag){
00623         _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
00624     }else{
00625         _CrtSetDbgFlag(_CRTDBG_CHECK_ALWAYS_DF);
00626     }
00627 }
00628 
00629 #else
00630 
00631 void WINAPI dkcCheckMemoryLeak(BOOL flag){
00632 
00633 }
00634 #endif
00635 
00636 const char *WINAPI dkcGetPathSep(){
00637 #ifdef WIN32
00638     static char target[3]={dkcdPATH_SEP,'/','\0'};
00639 #else
00640     static char target[3]={dkcdPATH_SEP,'\0'};
00641 #endif
00642     return target;
00643 }
00644 #ifdef _MSC_VER
00645 BOOL WINAPI dkcIsMMX(void)
00646 {
00647     BOOL flag = FALSE;
00648 
00649     __asm{
00650         push    edx
00651         push    ecx
00652         pushfd
00653         pop     eax
00654         xor     eax, 00200000h
00655         push    eax
00656         popfd
00657         pushfd
00658         pop     ebx
00659         cmp     eax, ebx
00660         jnz     non_mmx
00661         mov     eax, 0
00662         cpuid
00663         cmp     eax, 0
00664         jz      non_mmx
00665         mov     eax, 1
00666         cpuid
00667         and     edx, 00800000h
00668         jz      non_mmx
00669         mov     flag, TRUE
00670     non_mmx:
00671         pop     ecx
00672         pop     edx
00673     }
00674     return flag;
00675 }
00676 #else
00677 BOOL WINAPI dkcIsMMX(void){
00678   return FALSE;
00679 }
00680 #endif
00681 
00682 
00683 DKC_INLINE USHORT dkcReverseEndian16(USHORT x){
00684     return (USHORT)((x >> 8) | (x << 8));
00685 }
00686 
00687 DKC_INLINE DWORD dkcReverseEndian32(DWORD x){
00688     return (x << 24) | ((x & 0x0000ff00) << 8) | ((x & 0x00ff0000) >> 8) | (x >> 24);
00689 }
00690 
00691 DKC_INLINE ULONGLONG dkcReverseEndian64(ULONGLONG x) {
00692 
00693     return (
00694         (ULONGLONG)dkcReverseEndian32((DWORD)(x & 0x00000000ffffffff)) << 32)
00695         | 
00696         dkcReverseEndian32((DWORD)(x >> 32)
00697     );
00698 
00699 }
00700 DKC_INLINE  BOOL dkcIsLittleEndian(){
00701     int x=1;
00702     return (BOOL)((*(char*)&x));
00703 }
00704 
00705 
00706 DKC_INLINE BOOL dkcCheckOverflowULONG(ULONG a1,ULONG a2){
00707     ULONG maxv = ULONG_MAX;
00708   ULONG halfv = maxv / 2 ;
00709   ULONG x = a1,y = a2;
00710   if(x < y){
00711     SWAP_NUM(x,y);
00712   }
00713   if(x > halfv + 1){
00714     if(y >= halfv){
00715       return TRUE;
00716     }
00717   }
00718   return FALSE;
00719 }
00720 
00721 DKC_INLINE size_t dkcNumOfBits(uint32 bits) {
00722   bits = (bits & 0x55555555) + (bits >> 1 & 0x55555555);
00723   bits = (bits & 0x33333333) + (bits >> 2 & 0x33333333);
00724   bits = (bits & 0x0f0f0f0f) + (bits >> 4 & 0x0f0f0f0f);
00725   bits = (bits & 0x00ff00ff) + (bits >> 8 & 0x00ff00ff);
00726   return (bits & 0x0000ffff) + (bits >>16 & 0x0000ffff);
00727 }
00728 
00729 
00730 static void *get_offset(void *p,size_t offset){
00731     BYTE *oo = (BYTE *)p;
00732     
00733     return (void *)&(oo[offset]);
00734 }
00735 
00741 int WINAPI dkcSelect(void *dest,const void *a_src,size_t n,int k,size_t width ,DKC_COMPARE_TYPE less)
00742 {
00743 
00744     int i,j,left, right;
00745 
00746     void *x = malloc(width);
00747     void *a = malloc(n * width);
00748     if(NULL==x || NULL==a){
00749         return edk_ArgumentException;
00750     }
00751     if(n > INT_MAX){
00752         return edk_FAILED;
00753     }
00754     
00755 
00756     memcpy(a,a_src,width * n);
00757 
00758 
00759     left = 0;  right = n - 1;
00760 
00761     while (left < right) 
00762     {
00763 
00764         memcpy(x,   (const void *)get_offset(a,k * width),width);
00765         i = left;
00766         j = right;
00767 
00768         for ( ; ; ) {
00769 
00770             while( less(get_offset(a,i * width),x) > 0){
00771             //while( *(int *)get_offset(a,i * width) < *(int *)x){
00772                 i++;
00773             }
00774 
00775             while( less(x,get_offset(a,j * width)) > 0){
00776             //while( *(int *)x < *(int *)get_offset(a,j * width) ){
00777                 j--;
00778             }
00779 
00780             if (i > j){
00781                 break;
00782             }
00783             
00784 
00785             dkcSwapFast(
00786                 get_offset(a,i * width),
00787                 get_offset(a,j * width),
00788                 width
00789                 );
00790             
00791             i++;
00792             j--;
00793         }
00794         if (j < k){
00795             left  = i;
00796         }
00797         if (k < i){
00798             right = j;
00799         }
00800     }
00801 
00802     //ゲットする
00803     {
00804         //printf("%d",*(int *)get_offset(a,k * width));
00805 
00806         memcpy(dest,(const void *)get_offset(a,k * width),width);
00807 
00808     }
00809     free(x);
00810     free(a);
00811 
00812     return edk_SUCCEEDED;
00813 
00814 }
00815 
00816 
00817 DKC_INLINE int WINAPI dkcSelectMax(void *a,const void *a_src, size_t n,size_t width ,DKC_COMPARE_TYPE less){
00818     if(n-1 > INT_MAX){
00819         return edk_FAILED;
00820     }
00821     return dkcSelect(a,a_src,n,(int)n-1,width,less);
00822 }
00823 DKC_INLINE int WINAPI dkcSelectMin(void *a,const void *a_src, size_t n,size_t width ,DKC_COMPARE_TYPE less){
00824     return dkcSelect(a,a_src,n,(int)0,width,less);
00825 }
00826 #if 0
00827 int WINAPI dkcSelect(void *dest,const void *a_src,size_t n,size_t k,size_t width ,DKC_COMPARE_TYPE less)
00828 {
00829     //int i, j, left, right;
00830     size_t i,j,left, right;
00831     //keytype x, t;
00832     //size_t x,t;
00833     void *x = malloc(width);
00834     void *a = malloc(n * width);
00835     if(NULL==x || NULL==a){
00836         return edk_ArgumentException;
00837     }
00838     
00839     //void *t = malloc(width);
00840     memcpy(a,a_src,width * n);
00841 
00842 
00843     left = 0;  right = n - 1;
00844     /*
00845     x = a[k];  i = left;  j = right;
00846         for ( ; ; ) {
00847             while (a[i] < x) i++;
00848             while (x < a[j]) j--;
00849             if (i > j) break;
00850             t = a[i];  a[i] = a[j];  a[j] = t;
00851             i++;  j--;
00852         }
00853         if (j < k) left  = i;
00854         if (k < i) right = j;
00855     */
00856     while (left < right) 
00857     {
00858         //x = a[k];  i = left;  j = right;
00859         //offset_temp = (BYTE *)a;
00860     
00861         //memcpy(x, (const void *)&offset_temp[k * width],width);
00862         memcpy(x,   (const void *)get_offset(a,k * width),width);
00863         i = left;
00864         j = right;
00865 
00866         for ( ; ; ) {
00867             //while (a[i] < x) i++;
00868             //while(less(a[i],x)) i++;
00869 //#error less じゃなくて greater でも、qsortと同じ仕様にするため・・・。スマン
00870             //while( less(get_offset(a,i * width),x) < 0){
00871             while( less(get_offset(a,i * width),x) ){
00872                 i++;
00873             }
00874 
00875             /*void *p = get_offset(a,i * width);
00876             BYTE *ma = (BYTE *)get_offset(a,n * width);
00877             dkcmNOT_ASSERT(p < a);
00878             dkcmNOT_ASSERT(p > ((BYTE *)a) + n * width);
00879             dkcmNOT_ASSERT((ma - (BYTE *)p) % width != 0);
00880             while(less(p,x) > 0){
00881                 i++;
00882                 p = get_offset(a,i * width);
00883                 ma = (BYTE *)get_offset(a,n * width);
00884                 dkcmNOT_ASSERT(p < a);
00885                 dkcmNOT_ASSERT(p > ma - width);
00886                 dkcmNOT_ASSERT((ma - p) % width != 0);
00887             }*/
00888 
00889             //while (x < a[j]) j--;
00890             //while(less(x,a[j]) j--;
00891             //while( less(x,get_offset(a,j * width)) < 0){
00892             while( less(x,get_offset(a,j * width)) ){
00893                 j--;
00894             }
00895 
00896             if (i > j){
00897                 break;
00898             }
00899             
00900             //t = a[i];  a[i] = a[j];  a[j] = t;
00901             //dkcSwap(&a[i],&a[j],width);
00902             dkcSwap(
00903                 get_offset(a,i * width),
00904                 get_offset(a,j * width),
00905                 width
00906                 );
00907             
00908             i++;
00909             j--;
00910         }
00911         if (j < k){
00912             left  = i;
00913         }
00914         if (k < i){
00915             right = j;
00916         }
00917     }
00918 
00919     //ゲットする
00920     {
00921         printf("%d",*(int *)get_offset(a,k * width));
00922         //memcpy(,  (const void *)get_offset(a,k * width),width);
00923         //memcpy(dest,(const void *)get_offset(a,k * width),width);
00924         memcpy(dest,x,width);
00925     }
00926     free(x);
00927     free(a);
00928     //free(t);
00929     return edk_SUCCEEDED;
00930     //return a[k];
00931 }
00932 #endif
00933 
00934 DKC_INLINE int dkcRotateShiftRightMemoryLogic(void *d,size_t size,size_t n,void *workbuff,size_t worksize)
00935 {
00936     BYTE *dest = (BYTE *)d;
00937     size_t temp;
00938 
00939     if(n > worksize){
00940         return edk_FAILED;
00941     }
00942     for(;;){
00943         if(n < size){
00944             break;
00945         }
00946         n -= size;
00947     }
00948     temp = size - n;
00949     memcpy(workbuff,dest + temp,n);
00950     memmove(dest + n,dest,temp);
00951     memcpy(dest,workbuff,n);
00952     return edk_SUCCEEDED;
00953 
00954 }
00955 
00956 int WINAPI dkcRotateShiftRightMemory(void *d,size_t size,size_t num){
00957     //size_t i = 0;
00958     void *pd = NULL;
00959     int r = edk_FAILED;
00960 
00961     pd = malloc(num);
00962     if(NULL==pd){
00963         return edk_OutOfMemory;
00964     }
00965     if(DKUTIL_SUCCEEDED(dkcRotateShiftRightMemoryLogic(d,size,num,pd,num))){
00966         r = edk_SUCCEEDED;
00967     }
00968 
00969     free(pd);
00970     
00971     return r;
00972 
00973 }

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