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_memcpy_zc(void *dest,size_t size1,const void *src,size_t size2){
00022 if(size1 == 0 || size2 == 0) return edk_FAILED;
00023 if(NULL==dest || NULL==src) return edk_FAILED;
00024 return dkc_memcpy(dest,size1,src,size2);
00025 }
00026
00027
00028 int WINAPI dkc_memmove( void *dest,size_t size1,const void *src, size_t size2 )
00029 {
00030 if(size1 < size2){
00031 return edk_FAILED;
00032 }
00033 memmove(dest,src,size2);
00034 return edk_SUCCEEDED;
00035 }
00036
00037 int WINAPI dkc_strcpy(char *dest,size_t size1,const char *src,size_t srclen){
00038 if(size1 <= srclen) return edk_FAILED;
00039 strncpy(dest,src,srclen);
00040
00041 dest[srclen] = '\0';
00042 return edk_SUCCEEDED;
00043 }
00044
00045
00046 int WINAPI dkc_strcpy_amap(char *dest,size_t size1,const char *src,size_t srclen){
00047 # ifndef NDEBUG
00048 if(!(0 == size1 && 0 == srclen)){
00049 return edk_FAILED;
00050 }
00051 # endif
00052 if(size1 <= srclen){
00053 strncpy(dest,src,size1);
00054 dest[size1 - 1] = '\0';
00055 return edk_Not_Satisfactory;
00056 }else{
00057 strncpy(dest,src,srclen);
00058 dest[srclen] = '\0';
00059 return edk_SUCCEEDED;
00060 }
00061 }
00062 int WINAPI dkc_strcpy_amap2(char *dest,size_t size1,const char *src){
00063 return dkc_strcpy_amap(dest,size1,src,strlen(src));
00064 }
00065
00066 int WINAPI dkc_strcat(char *dest,size_t destsize,size_t destlen,
00067 const char *src,size_t srclen)
00068 {
00069
00070 if(destsize < destlen + srclen + 1) return edk_FAILED;
00071 strncat(dest,src,srclen);
00072 return edk_SUCCEEDED;
00073 }
00074
00075 int WINAPI dkc_strcat2(char *dest,size_t destsize,const char *src){
00076 return dkc_strcat(dest,destsize,strlen(dest),src,strlen(src));
00077 }
00078
00079 int WINAPI dkc_strcat_amap(char *dest,size_t destsize,size_t destlen,
00080 const char *src,size_t srclen)
00081 {
00082
00083 int result = edk_SUCCEEDED;
00084 size_t lsize = destlen + srclen + 1;
00085 if(destsize < lsize)
00086 {
00087 srclen = lsize - destsize - 1;
00088 result = edk_Not_Satisfactory;
00089 }
00090 strncat(dest,src,srclen);
00091
00092 return result;
00093 }
00094
00095 int WINAPI dkc_strcat_amap2(char *dest,size_t destsize,const char *src){
00096 return dkc_strcat_amap(dest,destsize,strlen(dest),src,strlen(src));
00097 }
00098
00099 int WINAPI dkc_memcmp( const void *buf1,size_t buf1PermitSize,
00100 const void *buf2, size_t count )
00101 {
00102 if(buf1PermitSize < count)return edk_LogicError;
00103 if(0 !=memcmp(buf1,buf2,count))return edk_FAILED;
00104 return edk_SUCCEEDED;
00105 }
00106
00107 int WINAPI dkc_strcmp(const char *b1,size_t b1size,const char *b2,size_t b2size)
00108 {
00109 int result = edk_SUCCEEDED;
00110 size_t i = 0;
00111
00112 if(b1size < b2size) return edk_LogicError;
00113
00114
00115
00116 for(i=0;i<b2size;i++)
00117 {
00118 if(b1[i] != b2[i])
00119 {
00120 result = edk_FAILED;
00121 break;
00122 }
00123 }
00124 return result;
00125 }
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141 DKC_INLINE int WINAPI dkc_wcscat2( wchar_t *dest,size_t destsize,
00142 const wchar_t *src )
00143 {
00144 size_t dlen = wcslen(dest);
00145 size_t slen = wcslen(src);
00146
00147 if(destsize / sizeof(wchar_t) < dlen + slen + 1) return edk_FAILED;
00148
00149 wcsncpy(&dest[dlen],src,slen);
00150 return edk_SUCCEEDED;
00151 }
00152
00153 DKC_INLINE size_t dkc_beam(int num){
00154 size_t b = 0 ;
00155 int i=0;
00156 for(i = 10 ; num >= i ; i *= 10 ){
00157 b ++ ;
00158 }
00159 return b;
00160 }
00161
00162
00163 int dkc_stream_swap(char *memory,size_t size,size_t point)
00164 {
00165 char *p;
00166 size_t big;
00167 size_t small__;
00168 BOOL isLeft = FALSE;
00169 if(size <= 1){
00170 return edk_FAILED;
00171 }
00172
00173
00174 if(size - point < point){
00175 big = point;
00176 small__ = size - point;
00177 isLeft = TRUE;
00178 }else{
00179 big = size - point;
00180 small__ = point;
00181 }
00182
00183 p = (char *)malloc(big);
00184 if(!p) return edk_OutOfMemory;
00185
00186 if(isLeft)
00187 {
00188 memcpy(p,memory,big);
00189 memcpy(memory,&memory[big],small__);
00190 memcpy(&memory[small__],p,big);
00191 }else{
00192 memcpy(p,&memory[small__],big);
00193 memcpy(&memory[big],memory,small__);
00194 memcpy(memory,p,big);
00195 }
00196
00197 free(p);
00198 return edk_SUCCEEDED;
00199 }
00200
00201
00202
00204 void dkc_memswap( void *va, void *vb, size_t size )
00205 {
00206 char *ca;
00207 char *cb;
00208 char cTmp;
00209 for( ca = (char *)va, cb = (char *)vb; size > 0; size--, ca++, cb++ )
00210 {
00211 cTmp = *ca;
00212 *ca = *cb;
00213 *cb = cTmp;
00214 }
00215 }
00216
00217
00218
00221 void dkc_memreverse( void *array, size_t num, size_t size )
00222 {
00223 char *l;
00224 char *r;
00225
00226 l = (char *)array;
00227 r = (char *)array + ((num-1) * size);
00228 for( ; l < r; l = l+size, r = r-size )
00229 dkc_memswap( l, r, size );
00230 }
00231
00232
00235 void dkc_memrrotate( void *array, size_t shift, size_t num, size_t size )
00236 {
00237 dkc_memreverse( array, num, size );
00238 dkc_memreverse( array, shift, size );
00239 dkc_memreverse( (char *)array+(size*shift), num-shift, size );
00240 }
00241
00242
00245 void dkc_memlrotate( void *array, size_t shift, size_t num, size_t size )
00246 {
00247 dkc_memreverse( array, shift, size );
00248 dkc_memreverse( (char *)array+(size*shift), num-shift, size );
00249 dkc_memreverse( array, num, size );
00250 }
00251
00252
00253 #if 0
00254
00255 int WINAPI strnicmp(
00256 const char *string1, const char *string2, size_t count)
00257 {
00258 int c1, c2;
00259
00260 --count;
00261
00262 for (; count ; --count){
00263 c1 = string1[count];
00264 c2 = string2[count];
00265
00266
00267 if (!c1) return 1;
00268 if (!c2) return 1;
00269
00270
00271 if ('A' <= c1 && c1 <= 'Z') c1 += 'a' - 'A';
00272 if ('A' <= c2 && c2 <= 'Z') c2 += 'a' - 'A';
00273
00274
00275 if (c1 != c2) return 1;
00276 }
00277
00278 return 0;
00279 }
00280
00281 #endif