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 }
>> 099
095 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
140 145
141 146
142 int vsnprintf(char *buff, sos_size_t len, cons 147 int vsnprintf(char *buff, sos_size_t len, const char * format, va_list ap)
143 { 148 {
144 sos_size_t i, result; 149 sos_size_t i, result;
145 150
146 if (!buff || !format || (len < 0)) 151 if (!buff || !format || (len < 0))
147 return -1; 152 return -1;
148 153
149 #define PUTCHAR(thechar) \ 154 #define PUTCHAR(thechar) \
150 do { \ 155 do { \
151 if (result < len-1) \ 156 if (result < len-1) \
152 *buff++ = (thechar); \ 157 *buff++ = (thechar); \
153 result++; \ 158 result++; \
154 } while (0) 159 } while (0)
155 160
156 result = 0; 161 result = 0;
157 for(i=0 ; format[i] != '\0' ; i++){ 162 for(i=0 ; format[i] != '\0' ; i++){
158 switch (format[i]) 163 switch (format[i])
159 { 164 {
160 case '%': 165 case '%':
161 i++; 166 i++;
162 switch(format[i]) 167 switch(format[i])
163 { 168 {
164 case '%': 169 case '%':
165 { 170 {
166 PUTCHAR('%'); 171 PUTCHAR('%');
167 break; 172 break;
168 } 173 }
169 case 'i':; 174 case 'i':;
170 case 'd': 175 case 'd':
171 { 176 {
172 int integer = va_arg(ap,int); 177 int integer = va_arg(ap,int);
173 int cpt2 = 0; 178 int cpt2 = 0;
174 char buff_int[16]; 179 char buff_int[16];
175 180
176 if (integer<0) 181 if (integer<0)
177 PUTCHAR('-'); 182 PUTCHAR('-');
178 183
179 184
180 185
181 do { 186 do {
182 int m10 = integer%10; 187 int m10 = integer%10;
183 m10 = (m10 < 0)? -m10:m10; 188 m10 = (m10 < 0)? -m10:m10;
184 buff_int[cpt2++]=(char)('0'+ m 189 buff_int[cpt2++]=(char)('0'+ m10);
185 integer=integer/10; 190 integer=integer/10;
186 } while(integer!=0); 191 } while(integer!=0);
187 192
188 for(cpt2 = cpt2 - 1 ; cpt2 >= 0 193 for(cpt2 = cpt2 - 1 ; cpt2 >= 0 ; cpt2--)
189 PUTCHAR(buff_int[cpt2]); 194 PUTCHAR(buff_int[cpt2]);
190 195
191 break; 196 break;
192 } 197 }
193 198
194 case 'c': 199 case 'c':
195 { 200 {
196 int value = va_arg(ap,int); 201 int value = va_arg(ap,int);
197 PUTCHAR((char)value); 202 PUTCHAR((char)value);
198 break; 203 break;
199 } 204 }
200 205
201 case 's': 206 case 's':
202 { 207 {
203 char *string = va_arg(ap,char *) 208 char *string = va_arg(ap,char *);
204 if (! string) 209 if (! string)
205 string = "(null)"; 210 string = "(null)";
206 for( ; *string != '\0' ; string+ 211 for( ; *string != '\0' ; string++)
207 PUTCHAR(*string); 212 PUTCHAR(*string);
208 break; 213 break;
209 } 214 }
210 215
211 case 'x': 216 case 'x':
212 { 217 {
213 unsigned int hexa = va_arg(ap,in 218 unsigned int hexa = va_arg(ap,int);
214 unsigned int nb; 219 unsigned int nb;
215 int i, had_nonzero = 0; 220 int i, had_nonzero = 0;
216 for(i=0 ; i < 8 ; i++) 221 for(i=0 ; i < 8 ; i++)
217 { 222 {
218 nb = (unsigned int)(hexa << 223 nb = (unsigned int)(hexa << (i*4));
219 nb = (nb >> 28) & 0xf; 224 nb = (nb >> 28) & 0xf;
220 225
221 if (nb == 0) 226 if (nb == 0)
222 { 227 {
223 if (had_nonzero) 228 if (had_nonzero)
224 PUTCHAR('0'); 229 PUTCHAR('0');
225 } 230 }
226 else 231 else
227 { 232 {
228 had_nonzero = 1; 233 had_nonzero = 1;
229 if (nb < 10) 234 if (nb < 10)
230 PUTCHAR('0'+nb); 235 PUTCHAR('0'+nb);
231 else 236 else
232 PUTCHAR('a'+(nb-10)); 237 PUTCHAR('a'+(nb-10));
233 } 238 }
234 } 239 }
235 if (! had_nonzero) 240 if (! had_nonzero)
236 PUTCHAR('0'); 241 PUTCHAR('0');
237 break; 242 break;
238 } 243 }
239 break; 244 break;
240 245
241 default: 246 default:
242 PUTCHAR('%'); 247 PUTCHAR('%');
243 PUTCHAR(format[i]); 248 PUTCHAR(format[i]);
244 } 249 }
245 break; 250 break;
246 251
247 default: 252 default:
248 PUTCHAR(format[i]); 253 PUTCHAR(format[i]);
249 } 254 }
250 } 255 }
251 256
252 *buff = '\0'; 257 *buff = '\0';
253 return result; 258 return result;
254 } 259 }
255 260
256 261
257 int snprintf(char * buff, sos_size_t len, cons 262 int snprintf(char * buff, sos_size_t len, const char *format, ...)
258 { 263 {
259 va_list ap; 264 va_list ap;
260 265
261 va_start(ap, format); 266 va_start(ap, format);
262 len = vsnprintf(buff, len, format, ap); 267 len = vsnprintf(buff, len, format, ap);
263 va_end(ap); 268 va_end(ap);
264 269
265 return len; 270 return len;
266 } 271 }