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 continue; 076 continue;
077 077
078 return sc - s; 078 return sc - s;
079 } 079 }
080 080
081 081
082 char *strzcpy(register char *dst, register con 082 char *strzcpy(register char *dst, register const char *src, register int len)
083 { 083 {
084 int i; 084 int i;
085 085
086 if (len <= 0) 086 if (len <= 0)
087 return dst; 087 return dst;
088 088
089 for (i = 0; i < len; i++) 089 for (i = 0; i < len; i++)
090 { 090 {
091 dst[i] = src[i]; 091 dst[i] = src[i];
092 if(src[i] == '\0') 092 if(src[i] == '\0')
093 return dst; 093 return dst;
094 } 094 }
095 095
096 dst[len-1] = '\0'; 096 dst[len-1] = '\0';
097 return dst; 097 return dst;
098 } 098 }
099 099
100 100
101 char *strzcat (char *dest, const char *src, so 101 char *strzcat (char *dest, const char *src, sos_size_t n)
102 { 102 {
103 char *res = dest; 103 char *res = dest;
104 104
105 for ( ; *dest ; dest++); 105 for ( ; *dest ; dest++);
106 106
107 for ( ; *src ; src++, dest++) { 107 for ( ; *src ; src++, dest++) {
108 *dest = *src; 108 *dest = *src;
109 n--; 109 n--;
110 if (n <= 0) 110 if (n <= 0)
111 break; 111 break;
112 } 112 }
113 113
114 *dest = '\0'; 114 *dest = '\0';
115 return res; 115 return res;
116 } 116 }
117 117
118 int strcmp(register const char *s1, register c 118 int strcmp(register const char *s1, register const char *s2)
119 { 119 {
120 while (*s1 == *s2++) 120 while (*s1 == *s2++)
121 if (*s1++ == 0) 121 if (*s1++ == 0)
122 return (0); 122 return (0);
123 123
124 return (*(const unsigned char *)s1 - *(const 124 return (*(const unsigned char *)s1 - *(const unsigned char *)(s2 - 1));
125 } 125 }
126 126
127 127
128 int strncmp(register const char *s1, register 128 int strncmp(register const char *s1, register const char *s2, register int len)
129 { 129 {
130 char c1 = '\0', c2 = '\0'; 130 char c1 = '\0', c2 = '\0';
131 131
132 while (len > 0) 132 while (len > 0)
133 { 133 {
134 c1 = (unsigned char) *s1++; 134 c1 = (unsigned char) *s1++;
135 c2 = (unsigned char) *s2++; 135 c2 = (unsigned char) *s2++;
136 if (c1 == '\0' || c1 != c2) 136 if (c1 == '\0' || c1 != c2)
137 return c1 - c2; 137 return c1 - c2;
138 len--; 138 len--;
139 } 139 }
140 140
141 return c1 - c2; 141 return c1 - c2;
142 } 142 }
143 143
144 144
145 static unsigned long int _random_seed = 931867 145 static unsigned long int _random_seed = 93186752;
146 146
147 147
148 148
149 149
150 150
151 151
152 unsigned long int random (void) 152 unsigned long int random (void)
153 { 153 {
154 154
155 155
156 156
157 157
158 static unsigned int a = 1588635695, q = 2, 158 static unsigned int a = 1588635695, q = 2, r = 1117695901;
159 159
160 160
161 161
162 162
163 163
164 164
165 165
166 166
167 167
168 _random_seed = a*(_random_seed % q) - r*(_r 168 _random_seed = a*(_random_seed % q) - r*(_random_seed / q);
169 return _random_seed; 169 return _random_seed;
170 } 170 }
171 171
172 172
173 void srandom (unsigned long int seed) 173 void srandom (unsigned long int seed)
174 { 174 {
175 _random_seed = seed; 175 _random_seed = seed;
176 } 176 }
177 177
178 178
179 179
180 180
181 int vsnprintf(char *buff, sos_size_t len, cons 181 int vsnprintf(char *buff, sos_size_t len, const char * format, va_list ap)
182 { 182 {
183 sos_size_t i, result; 183 sos_size_t i, result;
184 184
185 if (!buff || !format || (len < 0)) 185 if (!buff || !format || (len < 0))
186 return -1; 186 return -1;
187 187
188 #define PUTCHAR(thechar) \ 188 #define PUTCHAR(thechar) \
189 do { \ 189 do { \
190 if (result < len-1) \ 190 if (result < len-1) \
191 *buff++ = (thechar); \ 191 *buff++ = (thechar); \
192 result++; \ 192 result++; \
193 } while (0) 193 } while (0)
194 194
195 result = 0; 195 result = 0;
196 for(i=0 ; format[i] != '\0' ; i++){ 196 for(i=0 ; format[i] != '\0' ; i++){
197 switch (format[i]) 197 switch (format[i])
198 { 198 {
199 case '%': 199 case '%':
200 i++; 200 i++;
201 switch(format[i]) 201 switch(format[i])
202 { 202 {
203 case '%': 203 case '%':
204 { 204 {
205 PUTCHAR('%'); 205 PUTCHAR('%');
206 break; 206 break;
207 } 207 }
208 case 'i':; 208 case 'i':;
209 case 'd': 209 case 'd':
210 { 210 {
211 int integer = va_arg(ap,int); 211 int integer = va_arg(ap,int);
212 int cpt2 = 0; 212 int cpt2 = 0;
213 char buff_int[16]; 213 char buff_int[16];
214 214
215 if (integer<0) 215 if (integer<0)
216 PUTCHAR('-'); 216 PUTCHAR('-');
217 217
218 218
219 219
220 do { 220 do {
221 int m10 = integer%10; 221 int m10 = integer%10;
222 m10 = (m10 < 0)? -m10:m10; 222 m10 = (m10 < 0)? -m10:m10;
223 buff_int[cpt2++]=(char)('0'+ m 223 buff_int[cpt2++]=(char)('0'+ m10);
224 integer=integer/10; 224 integer=integer/10;
225 } while(integer!=0); 225 } while(integer!=0);
226 226
227 for(cpt2 = cpt2 - 1 ; cpt2 >= 0 227 for(cpt2 = cpt2 - 1 ; cpt2 >= 0 ; cpt2--)
228 PUTCHAR(buff_int[cpt2]); 228 PUTCHAR(buff_int[cpt2]);
229 229
230 break; 230 break;
231 } 231 }
232 232
233 case 'c': 233 case 'c':
234 { 234 {
235 int value = va_arg(ap,int); 235 int value = va_arg(ap,int);
236 PUTCHAR((char)value); 236 PUTCHAR((char)value);
237 break; 237 break;
238 } 238 }
239 239
240 case 's': 240 case 's':
241 { 241 {
242 char *string = va_arg(ap,char *) 242 char *string = va_arg(ap,char *);
243 if (! string) 243 if (! string)
244 string = "(null)"; 244 string = "(null)";
245 for( ; *string != '\0' ; string+ 245 for( ; *string != '\0' ; string++)
246 PUTCHAR(*string); 246 PUTCHAR(*string);
247 break; 247 break;
248 } 248 }
249 249
250 case 'p': 250 case 'p':
251 PUTCHAR('0'); 251 PUTCHAR('0');
252 PUTCHAR('x'); 252 PUTCHAR('x');
253 case 'x': 253 case 'x':
254 { 254 {
255 unsigned int hexa = va_arg(ap,in 255 unsigned int hexa = va_arg(ap,int);
256 unsigned int nb; 256 unsigned int nb;
257 int i, had_nonzero = 0; 257 int i, had_nonzero = 0;
258 for(i=0 ; i < 8 ; i++) 258 for(i=0 ; i < 8 ; i++)
259 { 259 {
260 nb = (unsigned int)(hexa << 260 nb = (unsigned int)(hexa << (i*4));
261 nb = (nb >> 28) & 0xf; 261 nb = (nb >> 28) & 0xf;
262 262
263 if (nb == 0) 263 if (nb == 0)
264 { 264 {
265 if (had_nonzero) 265 if (had_nonzero)
266 PUTCHAR('0'); 266 PUTCHAR('0');
267 } 267 }
268 else 268 else
269 { 269 {
270 had_nonzero = 1; 270 had_nonzero = 1;
271 if (nb < 10) 271 if (nb < 10)
272 PUTCHAR('0'+nb); 272 PUTCHAR('0'+nb);
273 else 273 else
274 PUTCHAR('a'+(nb-10)); 274 PUTCHAR('a'+(nb-10));
275 } 275 }
276 } 276 }
277 if (! had_nonzero) 277 if (! had_nonzero)
278 PUTCHAR('0'); 278 PUTCHAR('0');
279 break; 279 break;
280 } 280 }
281 break; 281 break;
282 282
283 default: 283 default:
284 PUTCHAR('%'); 284 PUTCHAR('%');
285 PUTCHAR(format[i]); 285 PUTCHAR(format[i]);
286 } 286 }
287 break; 287 break;
288 288
289 default: 289 default:
290 PUTCHAR(format[i]); 290 PUTCHAR(format[i]);
291 } 291 }
292 } 292 }
293 293
294 *buff = '\0'; 294 *buff = '\0';
295 return result; 295 return result;
296 } 296 }
297 297
298 298
299 int snprintf(char * buff, sos_size_t len, cons 299 int snprintf(char * buff, sos_size_t len, const char *format, ...)
300 { 300 {
301 va_list ap; 301 va_list ap;
302 302
303 va_start(ap, format); 303 va_start(ap, format);
304 len = vsnprintf(buff, len, format, ap); 304 len = vsnprintf(buff, len, format, ap);
305 va_end(ap); 305 va_end(ap);
306 306
307 return len; 307 return len;
308 } 308 }