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
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
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
00112
00113 }
00114 MB("このテキストをこのソフトの開発者に渡せば、バグ発見の近道なります。\n \
00115 開発者に知らせるときはこのテキストを転記してあげましょう。");
00116 if(IDYES==MessageBox(NULL,
00117 "このままこのソフトを起動しつづけると、更なるエラーが発生する可能性があります。\n終了しますか?",
00118 "あってはいけない エラー!!!",
00119 MB_YESNO))
00120 {
00121 exit(edk_FAILED);
00122
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
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
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
00173
00174
00175
00176
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
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
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223 size_t dkcReallocateSizeFunction(size_t OldSize,size_t ExpandSize){
00224
00225
00226
00227
00228
00229
00230 if(OldSize <= 1024 * 5){
00231 return OldSize * 2;
00232 }else if(OldSize >= 1024 * 1024 * 10 || 0==OldSize)
00233 {
00234 return OldSize + ExpandSize;
00235 }
00236
00237 return OldSize + ExpandSize * 3;
00238
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
00255
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 == *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)){
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){
00314 FILE *fp ;
00315 if(NULL==readsize || NULL==data || NULL==fname || NULL==mode){
00316 return edk_FAILED;
00317 }
00318 fp = fopen( fname , mode ) ;
00319 if(fp==NULL)return edk_FAILED;
00320 *readsize = fread( data , 1 , size , fp ) ;
00321
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 ) ;
00334 if(fp==NULL) return edk_FAILED;
00335 fwrite( data , size , 1 , fp ) ;
00336
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
00359 tsize = size;
00360
00361 tc = 0;
00362
00363 count = 0;
00364
00365 tbuffer = (BYTE *)buffer;
00366 for(;;)
00367 {
00368
00369 if(ferror(fp) ){
00370 break;
00371 }
00372 if(feof(fp)){
00373 break;
00374 }
00375
00376 tc = fread(&tbuffer[count],1,tsize,fp);
00377
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
00402 tsize = size;
00403
00404 tc = 0;
00405
00406 count = 0;
00407
00408 tbuffer = (BYTE *)buffer;
00409 for(;;)
00410 {
00411
00412 if(ferror(fp) ){
00413 break;
00414 }
00415 if(feof(fp)){
00416 break;
00417 }
00418
00419 tc = fwrite(&tbuffer[count],1,tsize,fp);
00420
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
00442 int WINAPI dkcSaveBinary(const void *data,size_t size,const char *fname){
00443 return dkcSaveFile(data,size,fname,"wb");
00444 }
00445
00446 BOOL WINAPI dkcCreateEmptyFile(const char *filename){
00447 FILE *fp;
00448 fp = fopen( filename , "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){
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
00478
00479
00480
00481
00482
00483
00484
00485
00486
00487
00488
00489
00490
00491
00492
00493
00494
00495
00496
00497
00498
00499
00500
00501
00502
00503
00504
00505
00506
00507
00508
00509
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
00523 for(i=0;i<cnt;i++){
00524 SWAP_NUM(p1[i],p2[i]);
00525 }
00526 for(i=0;i<mod_;i++){
00527
00528
00529
00530
00531
00532
00533
00534
00535
00536
00537
00538
00539
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
00561 *dest = (ULONGLONG)high << 32;
00562 *dest += low;
00563
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
00583 *dest = (LONGLONG)high << 32;
00584 *dest += low;
00585
00586 }
00587
00588
00589
00590
00591
00592
00593
00594
00595
00596
00597
00598
00599
00600
00601
00602
00603
00604
00605
00606
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
00772 i++;
00773 }
00774
00775 while( less(x,get_offset(a,j * width)) > 0){
00776
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
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
00830 size_t i,j,left, right;
00831
00832
00833 void *x = malloc(width);
00834 void *a = malloc(n * width);
00835 if(NULL==x || NULL==a){
00836 return edk_ArgumentException;
00837 }
00838
00839
00840 memcpy(a,a_src,width * n);
00841
00842
00843 left = 0; right = n - 1;
00844
00845
00846
00847
00848
00849
00850
00851
00852
00853
00854
00855
00856 while (left < right)
00857 {
00858
00859
00860
00861
00862 memcpy(x, (const void *)get_offset(a,k * width),width);
00863 i = left;
00864 j = right;
00865
00866 for ( ; ; ) {
00867
00868
00869
00870
00871 while( less(get_offset(a,i * width),x) ){
00872 i++;
00873 }
00874
00875
00876
00877
00878
00879
00880
00881
00882
00883
00884
00885
00886
00887
00888
00889
00890
00891
00892 while( less(x,get_offset(a,j * width)) ){
00893 j--;
00894 }
00895
00896 if (i > j){
00897 break;
00898 }
00899
00900
00901
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
00923
00924 memcpy(dest,x,width);
00925 }
00926 free(x);
00927 free(a);
00928
00929 return edk_SUCCEEDED;
00930
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
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 }