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
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
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
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
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
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
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
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162 size_t dkcReallocateSizeFunction(size_t OldSize,size_t ExpandSize){
00163
00164
00165
00166
00167
00168
00169 if(OldSize <= 1024 * 5){
00170 return OldSize * 2;
00171 }else if(OldSize >= 1024 * 1024 * 10 || 0==OldSize)
00172 {
00173 return OldSize + ExpandSize;
00174 }
00175
00176 return OldSize + ExpandSize * 3;
00177
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
00194
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 == *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)){
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){
00253 FILE *fp ;
00254 if(NULL==readsize || NULL==data || NULL==fname || NULL==mode){
00255 return edk_FAILED;
00256 }
00257 fp = fopen( fname , mode ) ;
00258 if(fp==NULL)return edk_FAILED;
00259 *readsize = fread( data , 1 , size , fp ) ;
00260
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 ) ;
00273 if(fp==NULL) return edk_FAILED;
00274 fwrite( data , size , 1 , fp ) ;
00275
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
00298 tsize = size;
00299
00300 tc = 0;
00301
00302 count = 0;
00303
00304 tbuffer = (BYTE *)buffer;
00305 for(;;)
00306 {
00307
00308 if(ferror(fp) ){
00309 break;
00310 }
00311 if(feof(fp)){
00312 break;
00313 }
00314
00315 tc = fread(&tbuffer[count],1,tsize,fp);
00316
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
00341 tsize = size;
00342
00343 tc = 0;
00344
00345 count = 0;
00346
00347 tbuffer = (BYTE *)buffer;
00348 for(;;)
00349 {
00350
00351 if(ferror(fp) ){
00352 break;
00353 }
00354 if(feof(fp)){
00355 break;
00356 }
00357
00358 tc = fwrite(&tbuffer[count],1,tsize,fp);
00359
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
00381 int WINAPI dkcSaveBinary(const void *data,size_t size,const char *fname){
00382 return dkcSaveFile(data,size,fname,"wb");
00383 }
00384
00385 BOOL WINAPI dkcCreateEmptyFile(const char *filename){
00386 FILE *fp;
00387 fp = fopen( filename , "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){
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
00416
00417
00418
00419
00420
00421
00422
00423
00424
00425
00426
00427
00428
00429
00430
00431
00432
00433
00434
00435
00436
00437
00438
00439
00440
00441
00442
00443
00444
00445
00446
00447
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
00461 for(i=0;i<cnt;i++){
00462 SWAP_NUM(p1[i],p2[i]);
00463 }
00464 for(i=0;i<mod_;i++){
00465
00466
00467
00468
00469
00470
00471
00472
00473
00474
00475
00476
00477
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
00499 *dest = (ULONGLONG)high << 32;
00500 *dest += low;
00501
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
00521 *dest = (LONGLONG)high << 32;
00522 *dest += low;
00523
00524 }
00525
00526
00527
00528
00529
00530
00531
00532
00533
00534
00535
00536
00537
00538
00539
00540
00541
00542
00543
00544
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
00702 i++;
00703 }
00704
00705 while( less(x,get_offset(a,j * width)) > 0){
00706
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
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
00760 size_t i,j,left, right;
00761
00762
00763 void *x = malloc(width);
00764 void *a = malloc(n * width);
00765 if(NULL==x || NULL==a){
00766 return edk_ArgumentException;
00767 }
00768
00769
00770 memcpy(a,a_src,width * n);
00771
00772
00773 left = 0; right = n - 1;
00774
00775
00776
00777
00778
00779
00780
00781
00782
00783
00784
00785
00786 while (left < right)
00787 {
00788
00789
00790
00791
00792 memcpy(x, (const void *)get_offset(a,k * width),width);
00793 i = left;
00794 j = right;
00795
00796 for ( ; ; ) {
00797
00798
00799
00800
00801 while( less(get_offset(a,i * width),x) ){
00802 i++;
00803 }
00804
00805
00806
00807
00808
00809
00810
00811
00812
00813
00814
00815
00816
00817
00818
00819
00820
00821
00822 while( less(x,get_offset(a,j * width)) ){
00823 j--;
00824 }
00825
00826 if (i > j){
00827 break;
00828 }
00829
00830
00831
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
00853
00854 memcpy(dest,x,width);
00855 }
00856 free(x);
00857 free(a);
00858
00859 return edk_SUCCEEDED;
00860
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
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 }