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
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
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
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
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
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
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
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158 size_t dkcReallocateSizeFunction(size_t OldSize,size_t ExpandSize){
00159
00160
00161
00162
00163
00164
00165 if(OldSize <= 1024 * 5){
00166 return OldSize * 2;
00167 }else if(OldSize >= 1024 * 1024 * 10 || 0==OldSize)
00168 {
00169 return OldSize + ExpandSize;
00170 }
00171
00172 return OldSize + ExpandSize * 3;
00173
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
00190
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 == *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)){
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){
00249 FILE *fp ;
00250 if(NULL==readsize || NULL==data || NULL==fname || NULL==mode){
00251 return edk_FAILED;
00252 }
00253 fp = fopen( fname , mode ) ;
00254 if(fp==NULL)return edk_FAILED;
00255 *readsize = fread( data , 1 , size , fp ) ;
00256
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 ) ;
00269 if(fp==NULL) return edk_FAILED;
00270 fwrite( data , size , 1 , fp ) ;
00271
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
00294 tsize = size;
00295
00296 tc = 0;
00297
00298 count = 0;
00299
00300 tbuffer = (BYTE *)buffer;
00301 for(;;)
00302 {
00303
00304 if(ferror(fp) ){
00305 break;
00306 }
00307 if(feof(fp)){
00308 break;
00309 }
00310
00311 tc = fread(&tbuffer[count],1,tsize,fp);
00312
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
00337 tsize = size;
00338
00339 tc = 0;
00340
00341 count = 0;
00342
00343 tbuffer = (BYTE *)buffer;
00344 for(;;)
00345 {
00346
00347 if(ferror(fp) ){
00348 break;
00349 }
00350 if(feof(fp)){
00351 break;
00352 }
00353
00354 tc = fwrite(&tbuffer[count],1,tsize,fp);
00355
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
00377 int WINAPI dkcSaveBinary(const void *data,size_t size,const char *fname){
00378 return dkcSaveFile(data,size,fname,"wb");
00379 }
00380
00381 BOOL WINAPI dkcCreateEmptyFile(const char *filename){
00382 FILE *fp;
00383 fp = fopen( filename , "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){
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
00412
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 #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
00457 for(i=0;i<cnt;i++){
00458 SWAP_NUM(p1[i],p2[i]);
00459 }
00460 for(i=0;i<mod_;i++){
00461
00462
00463
00464
00465
00466
00467
00468
00469
00470
00471
00472
00473
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
00495 *dest = (ULONGLONG)high << 32;
00496 *dest += low;
00497
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
00641 i++;
00642 }
00643
00644 while( less(x,get_offset(a,j * width)) > 0){
00645
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
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
00699 size_t i,j,left, right;
00700
00701
00702 void *x = malloc(width);
00703 void *a = malloc(n * width);
00704 if(NULL==x || NULL==a){
00705 return edk_ArgumentException;
00706 }
00707
00708
00709 memcpy(a,a_src,width * n);
00710
00711
00712 left = 0; right = n - 1;
00713
00714
00715
00716
00717
00718
00719
00720
00721
00722
00723
00724
00725 while (left < right)
00726 {
00727
00728
00729
00730
00731 memcpy(x, (const void *)get_offset(a,k * width),width);
00732 i = left;
00733 j = right;
00734
00735 for ( ; ; ) {
00736
00737
00738
00739
00740 while( less(get_offset(a,i * width),x) ){
00741 i++;
00742 }
00743
00744
00745
00746
00747
00748
00749
00750
00751
00752
00753
00754
00755
00756
00757
00758
00759
00760
00761 while( less(x,get_offset(a,j * width)) ){
00762 j--;
00763 }
00764
00765 if (i > j){
00766 break;
00767 }
00768
00769
00770
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
00792
00793 memcpy(dest,x,width);
00794 }
00795 free(x);
00796 free(a);
00797
00798 return edk_SUCCEEDED;
00799
00800 }
00801 #endif