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

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

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