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