SimpleOS

LXR

Navigation



Site hébergé par : enix

The LXR Cross Referencer for SOS

source navigation ]
diff markup ]
identifier search ]
general search ]
 
 
Article:1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ] [ 6.5 ] [ 7 ] [ 7.5 ] [ 8 ] [ 9 ] [ 9.5 ]

001 /* Copyright (C) 2004  David Decotigny (with INSA Rennes for vsnprintf)
002    Copyright (C) 2003  The KOS Team
003    Copyright (C) 1999  Free Software Foundation
004 
005    This program is free software; you can redistribute it and/or
006    modify it under the terms of the GNU General Public License
007    as published by the Free Software Foundation; either version 2
008    of the License, or (at your option) any later version.
009    
010    This program is distributed in the hope that it will be useful,
011    but WITHOUT ANY WARRANTY; without even the implied warranty of
012    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
013    GNU General Public License for more details.
014    
015    You should have received a copy of the GNU General Public License
016    along with this program; if not, write to the Free Software
017    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
018    USA. 
019 */
020 #include "klibc.h"
021 
022 /* For an optimized version, see BSD sources ;) */
023 void *memcpy(void *dst0, const void *src0, register unsigned int size)
024 {
025   char *dst;
026   const char *src;
027   for (dst = (char*)dst0, src = (const char*)src0 ;
028        size > 0 ;
029        dst++, src++, size--)
030     *dst = *src;
031   return dst0;
032 }
033 
034 /* ditto */
035 void *memset(void *dst0, register int c, register unsigned int length)
036 {
037   char *dst;
038   for (dst = (char*) dst0 ;
039        length > 0 ;
040        dst++, length --)
041     *dst = (char)c;
042   return dst0;
043 }
044 
045 int memcmp(const void *s1, const void *s2, sos_size_t len)
046 {
047   const unsigned char *c1, *c2;
048   unsigned int i;
049  
050   for (i = 0, c1 = s1, c2 = s2; i < len; i++, c1++, c2++)
051     {
052       if(*c1 != *c2)
053         return *c1 - *c2;
054     }
055  
056   return 0;
057 }
058 
059 
060 unsigned int strlen(register const char *str)
061 {
062   unsigned int retval = 0;
063   
064   while (*str++)
065     retval++;
066   
067   return retval;
068 }
069 
070 
071 unsigned int strnlen(const char * s, sos_size_t count)
072 {
073   const char *sc;
074   
075   for (sc = s; count-- && *sc != '\0'; ++sc)
076     /* nothing */continue;
077 
078   return sc - s;
079 }
080 
081 
082 char *strzcpy(register char *dst, register const char *src, register int len)
083 {
084   int i;
085 
086   if (len <= 0)
087     return dst;
088   
089   for (i = 0; i < len; i++)
090     {
091       dst[i] = src[i];
092       if(src[i] == '\0')
093         return dst;
094     }
095   
096   dst[len-1] = '\0'; 
097   return dst;
098 }
099 
100 
101 char *strzcat (char *dest, const char *src, sos_size_t n)
102 {
103   char *res = dest;
104   
105   for ( ; *dest ; dest++);
106   
107   for ( ; *src ; src++, dest++) {
108     *dest = *src;
109     n--;
110     if (n <= 0)
111       break;
112   }
113 
114   *dest = '\0';
115   return res;
116 }
117 
118 int strcmp(register const char *s1, register const char *s2)
119 {
120   while (*s1 == *s2++)
121     if (*s1++ == 0)
122       return (0);
123   
124   return (*(const unsigned char *)s1 - *(const unsigned char *)(s2 - 1));
125 }
126 
127 
128 int strncmp(register const char *s1, register const char *s2, register int len)
129 {
130   char c1 = '\0', c2 = '\0';
131   
132   while (len > 0)
133     {
134       c1 = (unsigned char) *s1++;
135       c2 = (unsigned char) *s2++;
136       if (c1 == '\0' || c1 != c2)
137         return c1 - c2;
138       len--;
139     }
140   
141   return c1 - c2;
142 }
143 
144 
145 static unsigned long int _random_seed = 93186752;
146 
147 /**
148  * The following code is borrowed from Glenn Rhoads.
149  * http://remus.rutgers.edu/~rhoads/Code/code.html
150  * License to be defined...
151  */
152 unsigned long int random (void)
153 {
154 /* The following parameters are recommended settings based on research
155    uncomment the one you want. */
156 
157 /* For RAND_MAX == 4294967291 */
158    static unsigned int a = 1588635695, q = 2, r = 1117695901;
159 /* static unsigned int a = 1223106847, m = 4294967291U, q = 3, r = 625646750;*/
160 /* static unsigned int a = 279470273, m = 4294967291U, q = 15, r = 102913196;*/
161 
162 /* For RAND_MAX == 2147483647 */
163 /* static unsigned int a = 1583458089, m = 2147483647, q = 1, r = 564025558; */
164 /* static unsigned int a = 784588716, m = 2147483647, q = 2, r = 578306215;  */
165 /* static unsigned int a = 16807, m = 2147483647, q = 127773, r = 2836;      */
166 /* static unsigned int a = 950706376, m = 2147483647, q = 2, r = 246070895;  */
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 
179 /* I (d2) borrowed and rewrote this for Nachos/INSA Rennes. Thanks to
180    them for having kindly allowed me to do so. */
181 int vsnprintf(char *buff, sos_size_t len, const char * format, va_list ap)
182 {
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;
187   
188   if (!buff || !format || (len < 0))
189     return -1;
190   
191 #define PUTCHAR(thechar) \
192   do { \
193     if (result < len-1) \
194       *buff++ = (thechar);  \
195     result++; \
196   } while (0)
197   
198   result = 0;
199   for(i=0 ; format[i] != '\0' ; i++)
200     {
201       if (!fmt_modifiers && (format[i] != '%'))
202         {
203           PUTCHAR(format[i]);
204           continue;
205         }
206         
207       switch (format[i])
208         {
209         case '%':
210           if (fmt_modifiers)
211             {
212               PUTCHAR('%');
213               fmt_modifiers = FALSE;
214               break;
215             }
216           
217           fmt_modifiers    = TRUE;
218           prefix_long      = FALSE;
219           prefix_long_long = FALSE;
220           break;
221           
222         case 'l':
223           if (prefix_long)
224             prefix_long_long = TRUE;
225           else
226             prefix_long = TRUE;
227           break;
228           
229         case 'u':
230           {
231             if (! prefix_long_long)
232               {
233                 unsigned int integer = va_arg(ap,unsigned int);
234                 int cpt2 = 0;
235                 char buff_int[16];
236                 
237                 do {
238                   int m10 = integer%10;
239                   buff_int[cpt2++]=(char)('0'+ m10);
240                   integer=integer/10;
241                 } while(integer!=0);
242             
243                 for(cpt2 = cpt2 - 1 ; cpt2 >= 0 ; cpt2--)
244                   PUTCHAR(buff_int[cpt2]);
245               }
246             else
247               {
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);
258             
259                 for(cpt2 = cpt2 - 1 ; cpt2 >= 0 ; cpt2--)
260                   PUTCHAR(buff_int[cpt2]);
261               }
262           }
263           fmt_modifiers = FALSE;
264           break;
265 
266         case 'i':
267         case 'd':
268           {
269             if (! prefix_long_long)
270               {
271                 int integer = va_arg(ap,int);
272                 int cpt2 = 0;
273                 char buff_int[16];
274                 
275                 if (integer<0)
276                   PUTCHAR('-');
277                 /* Ne fait pas integer = -integer ici parce que INT_MIN
278                    n'a pas d'equivalent positif (int = [-2^31, 2^31-1]) */
279                 
280                 do {
281                   int m10 = integer%10;
282                   m10 = (m10 < 0)? -m10:m10;
283                   buff_int[cpt2++]=(char)('0'+ m10);
284                   integer=integer/10;
285                 } while(integer!=0);
286             
287                 for(cpt2 = cpt2 - 1 ; cpt2 >= 0 ; cpt2--)
288                   PUTCHAR(buff_int[cpt2]);
289               }
290             else
291               {
292                 long long int integer = va_arg(ap,long long int);
293                 int cpt2 = 0;
294                 char buff_int[32];
295                 
296                 if (integer<0)
297                   PUTCHAR('-');
298                 /* Ne fait pas integer = -integer ici parce que INT_MIN
299                    n'a pas d'equivalent positif (int = [-2^63, 2^63-1]) */
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;
320             break;
321           }
322           
323         case 's':
324           {
325             char *string = va_arg(ap,char *);
326             if (! string)
327               string = "(null)";
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 i, 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(i=0 ; i < 16 ; i++)
349               {
350                 nb = (unsigned long long int)(hexa << (i*4));
351                 nb = (nb >> 60) & 0xf;
352                 // Skip the leading zeros
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 
384   *buff = '\0';
385   return result;
386 }
387 
388 
389 int snprintf(char * buff, sos_size_t len, const char *format, ...)
390 {
391   va_list ap;
392  
393   va_start(ap, format);
394   len = vsnprintf(buff, len, format, ap);
395   va_end(ap);
396  
397   return len;
398 }

source navigation ] diff markup ] identifier search ] general search ]