00001
00010 #define DKUTIL_C_STDIO_C
00011
00012 #include "dkcStdio.h"
00013
00014
00015 int WINAPI dkc_memcpy(void *dest,size_t size1,const void *src,size_t size2){
00016 if(size1 < size2) return edk_FAILED;
00017 memcpy(dest,src,size2);
00018 return edk_SUCCEEDED;
00019 }
00020
00021 int WINAPI dkc_memmove( void *dest,size_t size1,const void *src, size_t size2 )
00022 {
00023 if(size1 < size2){
00024 return edk_FAILED;
00025 }
00026 memmove(dest,src,size2);
00027 return edk_SUCCEEDED;
00028 }
00029
00030 int WINAPI dkc_strcpy(char *dest,size_t size1,const char *src,size_t srclen){
00031 if(size1 <= srclen) return edk_FAILED;
00032 strncpy(dest,src,srclen);
00033
00034 dest[srclen] = '\0';
00035 return edk_SUCCEEDED;
00036 }
00037
00038
00039 int WINAPI dkc_strcpy_amap(char *dest,size_t size1,const char *src,size_t srclen){
00040 # ifndef NDEBUG
00041 if(!(0 == size1 && 0 == srclen)){
00042 return edk_FAILED;
00043 }
00044 # endif
00045 if(size1 <= srclen){
00046 strncpy(dest,src,size1);
00047 dest[size1 - 1] = '\0';
00048 return edk_Not_Satisfactory;
00049 }else{
00050 strncpy(dest,src,srclen);
00051 dest[srclen] = '\0';
00052 return edk_SUCCEEDED;
00053 }
00054 }
00055 int WINAPI dkc_strcpy_amap2(char *dest,size_t size1,const char *src){
00056 return dkc_strcpy_amap(dest,size1,src,strlen(src));
00057 }
00058
00059 int WINAPI dkc_strcat(char *dest,size_t destsize,size_t destlen,
00060 const char *src,size_t srclen)
00061 {
00062
00063 if(destsize < destlen + srclen + 1) return edk_FAILED;
00064 strncat(dest,src,srclen);
00065 return edk_SUCCEEDED;
00066 }
00067
00068 int WINAPI dkc_strcat2(char *dest,size_t destsize,const char *src){
00069 return dkc_strcat(dest,destsize,strlen(dest),src,strlen(src));
00070 }
00071
00072 int WINAPI dkc_strcat_amap(char *dest,size_t destsize,size_t destlen,
00073 const char *src,size_t srclen)
00074 {
00075
00076 int result = edk_SUCCEEDED;
00077 size_t lsize = destlen + srclen + 1;
00078 if(destsize < lsize)
00079 {
00080 srclen = lsize - destsize - 1;
00081 result = edk_Not_Satisfactory;
00082 }
00083 strncat(dest,src,srclen);
00084
00085 return result;
00086 }
00087
00088 int WINAPI dkc_strcat_amap2(char *dest,size_t destsize,const char *src){
00089 return dkc_strcat_amap(dest,destsize,strlen(dest),src,strlen(src));
00090 }
00091
00092 int WINAPI dkc_memcmp( const void *buf1,size_t buf1PermitSize,
00093 const void *buf2, size_t count )
00094 {
00095 if(buf1PermitSize < count)return edk_LogicError;
00096 if(0 !=memcmp(buf1,buf2,count))return edk_FAILED;
00097 return edk_SUCCEEDED;
00098 }
00099
00100 int WINAPI dkc_strcmp(const char *b1,size_t b1size,const char *b2,size_t b2size)
00101 {
00102 int result = edk_SUCCEEDED;
00103 size_t i = 0;
00104
00105 if(b1size < b2size) return edk_LogicError;
00106
00107
00108
00109 for(i=0;i<b2size;i++)
00110 {
00111 if(b1[i] != b2[i])
00112 {
00113 result = edk_FAILED;
00114 break;
00115 }
00116 }
00117 return result;
00118 }
00119
00120 size_t dkc_beam(int num){
00121 size_t b = 0 ;
00122 int i=0;
00123 for(i = 10 ; num >= i ; i *= 10 ){
00124 b ++ ;
00125 }
00126 return b;
00127 }
00128
00129
00130 int dkc_stream_swap(char *memory,size_t size,size_t point)
00131 {
00132 char *p;
00133 size_t big;
00134 size_t small__;
00135 BOOL isLeft = FALSE;
00136 if(size <= 1){
00137 return edk_FAILED;
00138 }
00139
00140
00141 if(size - point < point){
00142 big = point;
00143 small__ = size - point;
00144 isLeft = TRUE;
00145 }else{
00146 big = size - point;
00147 small__ = point;
00148 }
00149
00150 p = (char *)malloc(big);
00151 if(!p) return edk_OutOfMemory;
00152
00153 if(isLeft)
00154 {
00155 memcpy(p,memory,big);
00156 memcpy(memory,&memory[big],small__);
00157 memcpy(&memory[small__],p,big);
00158 }else{
00159 memcpy(p,&memory[small__],big);
00160 memcpy(&memory[big],memory,small__);
00161 memcpy(memory,p,big);
00162 }
00163
00164 free(p);
00165 return edk_SUCCEEDED;
00166 }
00167
00168
00169
00171 void dkc_memswap( void *va, void *vb, size_t size )
00172 {
00173 char *ca;
00174 char *cb;
00175 char cTmp;
00176 for( ca = (char *)va, cb = (char *)vb; size > 0; size--, ca++, cb++ )
00177 {
00178 cTmp = *ca;
00179 *ca = *cb;
00180 *cb = cTmp;
00181 }
00182 }
00183
00184
00185
00188 void dkc_memreverse( void *array, size_t num, size_t size )
00189 {
00190 char *l;
00191 char *r;
00192
00193 l = (char *)array;
00194 r = (char *)array + ((num-1) * size);
00195 for( ; l < r; l = l+size, r = r-size )
00196 dkc_memswap( l, r, size );
00197 }
00198
00199
00202 void dkc_memrrotate( void *array, size_t shift, size_t num, size_t size )
00203 {
00204 dkc_memreverse( array, num, size );
00205 dkc_memreverse( array, shift, size );
00206 dkc_memreverse( (char *)array+(size*shift), num-shift, size );
00207 }
00208
00209
00212 void dkc_memlrotate( void *array, size_t shift, size_t num, size_t size )
00213 {
00214 dkc_memreverse( array, shift, size );
00215 dkc_memreverse( (char *)array+(size*shift), num-shift, size );
00216 dkc_memreverse( array, num, size );
00217 }
00218
00219
00220 #if 0
00221
00222 int WINAPI strnicmp(
00223 const char *string1, const char *string2, size_t count)
00224 {
00225 int c1, c2;
00226
00227 --count;
00228
00229 for (; count ; --count){
00230 c1 = string1[count];
00231 c2 = string2[count];
00232
00233
00234 if (!c1) return 1;
00235 if (!c2) return 1;
00236
00237
00238 if ('A' <= c1 && c1 <= 'Z') c1 += 'a' - 'A';
00239 if ('A' <= c2 && c2 <= 'Z') c2 += 'a' - 'A';
00240
00241
00242 if (c1 != c2) return 1;
00243 }
00244
00245 return 0;
00246 }
00247
00248 #endif