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

dkcOSIndependent.c

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

dkutil_cに対してSun Jul 18 22:45:21 2004に生成されました。 doxygen 1.3.6