Diff markup
001 001
002 002
003 003
004 004
005 005
006 006
007 007
008 008
009 009
010 010
011 011
012 012
013 013
014 014
015 015
016 016
017 017
018 018
019 019
020 #include "klibc.h" 020 #include "klibc.h"
021 021
022 022
023 void *memcpy(void *dst0, const void *src0, reg 023 void *memcpy(void *dst0, const void *src0, register unsigned int size)
024 { 024 {
025 char *dst; 025 char *dst;
026 const char *src; 026 const char *src;
027 for (dst = (char*)dst0, src = (const char*)s 027 for (dst = (char*)dst0, src = (const char*)src0 ;
028 size > 0 ; 028 size > 0 ;
029 dst++, src++, size--) 029 dst++, src++, size--)
030 *dst = *src; 030 *dst = *src;
031 return dst0; 031 return dst0;
032 } 032 }
033 033
034 034
035 void *memset(void *dst0, register int c, regis 035 void *memset(void *dst0, register int c, register unsigned int length)
036 { 036 {
037 char *dst; 037 char *dst;
038 for (dst = (char*) dst0 ; 038 for (dst = (char*) dst0 ;
039 length > 0 ; 039 length > 0 ;
040 dst++, length --) 040 dst++, length --)
041 *dst = (char)c; 041 *dst = (char)c;
042 return dst0; 042 return dst0;
043 } 043 }
044 044
045 int memcmp(const void *s1, const void *s2, sos 045 int memcmp(const void *s1, const void *s2, sos_size_t len)
046 { 046 {
047 const unsigned char *c1, *c2; 047 const unsigned char *c1, *c2;
048 unsigned int i; 048 unsigned int i;
049 049
050 for (i = 0, c1 = s1, c2 = s2; i < len; i++, 050 for (i = 0, c1 = s1, c2 = s2; i < len; i++, c1++, c2++)
051 { 051 {
052 if(*c1 != *c2) 052 if(*c1 != *c2)
053 return *c1 - *c2; 053 return *c1 - *c2;
054 } 054 }
055 055
056 return 0; 056 return 0;
057 } 057 }
058 058
059 059
060 unsigned int strlen(register const char *str) 060 unsigned int strlen(register const char *str)
061 { 061 {
062 unsigned int retval = 0; 062 unsigned int retval = 0;
063 063
064 while (*str++) 064 while (*str++)
065 retval++; 065 retval++;
066 066
067 return retval; 067 return retval;
068 } 068 }
069 069
070 070
071 unsigned int strnlen(const char * s, sos_size_ 071 unsigned int strnlen(const char * s, sos_size_t count)
072 { 072 {
073 const char *sc; 073 const char *sc;
074 074
075 for (sc = s; count-- && *sc != '\0'; ++sc) 075 for (sc = s; count-- && *sc != '\0'; ++sc)
076 ; !! 076 continue;
>> 077
077 return sc - s; 078 return sc - s;
078 } 079 }
079 080
080 081
081 char *strzcpy(register char *dst, register con 082 char *strzcpy(register char *dst, register const char *src, register int len)
082 { 083 {
083 int i; 084 int i;
>> 085
>> 086 if (len <= 0)
>> 087 return dst;
084 088
085 for (i = 0; i < len; i++) 089 for (i = 0; i < len; i++)
086 { 090 {
087 dst[i] = src[i]; 091 dst[i] = src[i];
088 if(src[i] == '\0') 092 if(src[i] == '\0')
089 return dst; 093 return dst;
090 } 094 }
091 095
092 dst[len-1] = '\0'; 096 dst[len-1] = '\0';
093 return dst; 097 return dst;
094 } 098 }
095 099
>> 100
096 char *strzcat (char *dest, const char *src, so 101 char *strzcat (char *dest, const char *src, sos_size_t n)
097 { 102 {
098 char *res = dest; 103 char *res = dest;
099 104
100 for ( ; *dest ; dest++); 105 for ( ; *dest ; dest++);
101 106
102 for ( ; *src ; src++, dest++) { 107 for ( ; *src ; src++, dest++) {
103 *dest = *src; 108 *dest = *src;
104 n--; 109 n--;
105 if (n <= 0) 110 if (n <= 0)
106 break; 111 break;
107 } 112 }
108 113
109 *dest = '\0'; 114 *dest = '\0';
110 return res; 115 return res;
111 } 116 }
112 117
113 int strcmp(register const char *s1, register c 118 int strcmp(register const char *s1, register const char *s2)
114 { 119 {
115 while (*s1 == *s2++) 120 while (*s1 == *s2++)
116 if (*s1++ == 0) 121 if (*s1++ == 0)
117 return (0); 122 return (0);
118 123
119 return (*(const unsigned char *)s1 - *(const 124 return (*(const unsigned char *)s1 - *(const unsigned char *)(s2 - 1));
120 } 125 }
121 126
122 127
123 int strncmp(register const char *s1, register 128 int strncmp(register const char *s1, register const char *s2, register int len)
124 { 129 {
125 char c1 = '\0', c2 = '\0'; 130 char c1 = '\0', c2 = '\0';
126 131
127 while (len > 0) 132 while (len > 0)
128 { 133 {
129 c1 = (unsigned char) *s1++; 134 c1 = (unsigned char) *s1++;
130 c2 = (unsigned char) *s2++; 135 c2 = (unsigned char) *s2++;
131 if (c1 == '\0' || c1 != c2) 136 if (c1 == '\0' || c1 != c2)
132 return c1 - c2; 137 return c1 - c2;
133 len--; 138 len--;
134 } 139 }
135 140
136 return c1 - c2; 141 return c1 - c2;
137 } 142 }
138 143
139 144
>> 145 static unsigned long int _random_seed = 93186752;
>> 146
>> 147
>> 148
>> 149
>> 150
>> 151
>> 152 unsigned long int random (void)
>> 153 {
>> 154
>> 155
>> 156
>> 157
>> 158 static unsigned int a = 1588635695, q = 2, r = 1117695901;
>> 159
>> 160
>> 161
>> 162
>> 163
>> 164
>> 165
>> 166
>> 167
>> 168 _random_seed = a*(_random_seed % q) - r*(_random_seed / q);
>> 169 return _random_seed;
>> 170 }
>> 171
>> 172
>> 173 void srandom (unsigned long int seed)
>> 174 {
>> 175 _random_seed = seed;
>> 176 }
>> 177
>> 178
140 179
141 180
142 int vsnprintf(char *buff, sos_size_t len, cons 181 int vsnprintf(char *buff, sos_size_t len, const char * format, va_list ap)
143 { 182 {
144 sos_size_t i, result; 183 sos_size_t i, result;
>> 184 sos_bool_t fmt_modifiers = FALSE;
>> 185 sos_bool_t prefix_long = FALSE;
>> 186 sos_bool_t prefix_long_long = FALSE;
145 187
146 if (!buff || !format || (len < 0)) !! 188 if (!buff || !format || (len <= 0))
147 return -1; 189 return -1;
148 190
149 #define PUTCHAR(thechar) \ 191 #define PUTCHAR(thechar) \
150 do { \ 192 do { \
151 if (result < len-1) \ 193 if (result < len-1) \
152 *buff++ = (thechar); \ 194 *buff++ = (thechar); \
153 result++; \ 195 result++; \
154 } while (0) 196 } while (0)
155 197
156 result = 0; 198 result = 0;
157 for(i=0 ; format[i] != '\0' ; i++){ !! 199 for(i=0 ; format[i] != '\0' ; i++)
158 switch (format[i]) !! 200 {
159 { !! 201 if (!fmt_modifiers && (format[i] != '%'))
160 case '%': !! 202 {
161 i++; !! 203 PUTCHAR(format[i]);
162 switch(format[i]) !! 204 continue;
163 { !! 205 }
164 case '%': !! 206
>> 207 switch (format[i])
>> 208 {
>> 209 case '%':
>> 210 if (fmt_modifiers)
165 { 211 {
166 PUTCHAR('%'); 212 PUTCHAR('%');
>> 213 fmt_modifiers = FALSE;
167 break; 214 break;
168 } 215 }
169 case 'i':; !! 216
170 case 'd': !! 217 fmt_modifiers = TRUE;
171 { !! 218 prefix_long = FALSE;
172 int integer = va_arg(ap,int); !! 219 prefix_long_long = FALSE;
173 int cpt2 = 0; !! 220 break;
174 char buff_int[16]; !! 221
175 !! 222 case 'l':
176 if (integer<0) !! 223 if (prefix_long)
177 PUTCHAR('-'); !! 224 prefix_long_long = TRUE;
178 !! 225 else
179 !! 226 prefix_long = TRUE;
180 !! 227 break;
181 do { !! 228
182 int m10 = integer%10; !! 229 case 'u':
183 m10 = (m10 < 0)? -m10:m10; !! 230 {
184 buff_int[cpt2++]=(char)('0'+ m !! 231 if (! prefix_long_long)
185 integer=integer/10; !! 232 {
186 } while(integer!=0); !! 233 unsigned int integer = va_arg(ap,unsigned int);
187 !! 234 int cpt2 = 0;
188 for(cpt2 = cpt2 - 1 ; cpt2 >= 0 !! 235 char buff_int[16];
189 PUTCHAR(buff_int[cpt2]); !! 236
190 !! 237 do {
191 break; !! 238 int m10 = integer%10;
192 } !! 239 buff_int[cpt2++]=(char)('0'+ m10);
>> 240 integer=integer/10;
>> 241 } while(integer!=0);
193 242
194 case 'c': !! 243 for(cpt2 = cpt2 - 1 ; cpt2 >= 0 ; cpt2--)
195 { !! 244 PUTCHAR(buff_int[cpt2]);
196 int value = va_arg(ap,int); !! 245 }
197 PUTCHAR((char)value); !! 246 else
198 break; !! 247 {
199 } !! 248 unsigned long long int integer
>> 249 = va_arg(ap,unsigned long long int);
>> 250 int cpt2 = 0;
>> 251 char buff_int[32];
>> 252
>> 253 do {
>> 254 int m10 = integer%10;
>> 255 buff_int[cpt2++]=(char)('0'+ m10);
>> 256 integer=integer/10;
>> 257 } while(integer!=0);
200 258
201 case 's': !! 259 for(cpt2 = cpt2 - 1 ; cpt2 >= 0 ; cpt2--)
202 { !! 260 PUTCHAR(buff_int[cpt2]);
203 char *string = va_arg(ap,char *) !! 261 }
204 if (! string) !! 262 }
205 string = "(null)"; !! 263 fmt_modifiers = FALSE;
206 for( ; *string != '\0' ; string+ !! 264 break;
207 PUTCHAR(*string); <<
208 break; <<
209 } <<
210 265
211 case 'x': !! 266 case 'i':
212 { !! 267 case 'd':
213 unsigned int hexa = va_arg(ap,in !! 268 {
214 unsigned int nb; !! 269 if (! prefix_long_long)
215 int i, had_nonzero = 0; !! 270 {
216 for(i=0 ; i < 8 ; i++) !! 271 int integer = va_arg(ap,int);
217 { !! 272 int cpt2 = 0;
218 nb = (unsigned int)(hexa << !! 273 char buff_int[16];
219 nb = (nb >> 28) & 0xf; !! 274
220 !! 275 if (integer<0)
221 if (nb == 0) !! 276 PUTCHAR('-');
222 { !! 277
223 if (had_nonzero) !! 278
224 PUTCHAR('0'); !! 279
225 } !! 280 do {
226 else !! 281 int m10 = integer%10;
227 { !! 282 m10 = (m10 < 0)? -m10:m10;
228 had_nonzero = 1; !! 283 buff_int[cpt2++]=(char)('0'+ m10);
229 if (nb < 10) !! 284 integer=integer/10;
230 PUTCHAR('0'+nb); !! 285 } while(integer!=0);
231 else !! 286
232 PUTCHAR('a'+(nb-10)); !! 287 for(cpt2 = cpt2 - 1 ; cpt2 >= 0 ; cpt2--)
233 } !! 288 PUTCHAR(buff_int[cpt2]);
234 } !! 289 }
235 if (! had_nonzero) !! 290 else
236 PUTCHAR('0'); !! 291 {
237 break; !! 292 long long int integer = va_arg(ap,long long int);
238 } !! 293 int cpt2 = 0;
>> 294 char buff_int[32];
>> 295
>> 296 if (integer<0)
>> 297 PUTCHAR('-');
>> 298
>> 299
>> 300
>> 301 do {
>> 302 int m10 = integer%10;
>> 303 m10 = (m10 < 0)? -m10:m10;
>> 304 buff_int[cpt2++]=(char)('0'+ m10);
>> 305 integer=integer/10;
>> 306 } while(integer!=0);
>> 307
>> 308 for(cpt2 = cpt2 - 1 ; cpt2 >= 0 ; cpt2--)
>> 309 PUTCHAR(buff_int[cpt2]);
>> 310 }
>> 311 }
>> 312 fmt_modifiers = FALSE;
>> 313 break;
>> 314
>> 315 case 'c':
>> 316 {
>> 317 int value = va_arg(ap,int);
>> 318 PUTCHAR((char)value);
>> 319 fmt_modifiers = FALSE;
239 break; 320 break;
240 <<
241 default: <<
242 PUTCHAR('%'); <<
243 PUTCHAR(format[i]); <<
244 } 321 }
245 break; !! 322
246 !! 323 case 's':
247 default: !! 324 {
248 PUTCHAR(format[i]); !! 325 char const*string = va_arg(ap,char const*);
249 } !! 326 if (! string)
250 } !! 327 string = "(null)";
251 !! 328 for( ; *string != '\0' ; string++)
>> 329 PUTCHAR(*string);
>> 330 fmt_modifiers = FALSE;
>> 331 break;
>> 332 }
>> 333
>> 334 case 'p':
>> 335 PUTCHAR('0');
>> 336 PUTCHAR('x');
>> 337 case 'x':
>> 338 {
>> 339 unsigned long long int hexa;
>> 340 unsigned long long int nb;
>> 341 int x, had_nonzero = 0;
>> 342
>> 343 if (prefix_long_long)
>> 344 hexa = va_arg(ap,unsigned long long int);
>> 345 else
>> 346 hexa = va_arg(ap,unsigned int);
>> 347
>> 348 for(x=0 ; x < 16 ; x++)
>> 349 {
>> 350 nb = (unsigned long long int)(hexa << (x*4));
>> 351 nb = (nb >> 60) & 0xf;
>> 352
>> 353 if (nb == 0)
>> 354 {
>> 355 if (had_nonzero)
>> 356 PUTCHAR('0');
>> 357 }
>> 358 else
>> 359 {
>> 360 had_nonzero = 1;
>> 361 if (nb < 10)
>> 362 PUTCHAR('0'+nb);
>> 363 else
>> 364 PUTCHAR('a'+(nb-10));
>> 365 }
>> 366 }
>> 367 if (! had_nonzero)
>> 368 PUTCHAR('0');
>> 369 }
>> 370 fmt_modifiers = FALSE;
>> 371 break;
>> 372
>> 373 default:
>> 374 PUTCHAR('%');
>> 375 if (prefix_long)
>> 376 PUTCHAR('l');
>> 377 if (prefix_long_long)
>> 378 PUTCHAR('l');
>> 379 PUTCHAR(format[i]);
>> 380 fmt_modifiers = FALSE;
>> 381 }
>> 382 }
>> 383
252 *buff = '\0'; 384 *buff = '\0';
253 return result; 385 return result;
254 } 386 }
255 387
256 388
257 int snprintf(char * buff, sos_size_t len, cons 389 int snprintf(char * buff, sos_size_t len, const char *format, ...)
258 { 390 {
259 va_list ap; 391 va_list ap;
260 392
261 va_start(ap, format); 393 va_start(ap, format);
262 len = vsnprintf(buff, len, format, ap); 394 len = vsnprintf(buff, len, format, ap);
263 va_end(ap); 395 va_end(ap);
264 396
265 return len; 397 return len;
266 } 398 }