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   
185   if (!buff || !format || (len < 0))
186     return -1;
187   
188 #define PUTCHAR(thechar) \
189   do { \
190     if (result < len-1) \
191       *buff++ = (thechar);  \
192     result++; \
193   } while (0)
194   
195   result = 0;
196   for(i=0 ; format[i] != '\0' ; i++){
197     switch (format[i])
198       {
199       case '%':
200         i++;
201         switch(format[i])
202           {
203           case '%':
204             {
205               PUTCHAR('%');
206               break;
207             }
208           case 'i':;
209           case 'd':
210             {
211               int integer = va_arg(ap,int);
212               int cpt2 = 0;
213               char buff_int[16];
214               
215               if (integer<0)
216                 PUTCHAR('-');
217               /* Ne fait pas integer = -integer ici parce que INT_MIN
218                  n'a pas d'equivalent positif (int = [-2^31, 2^31-1]) */
219               
220               do {
221                 int m10 = integer%10;
222                 m10 = (m10 < 0)? -m10:m10;
223                 buff_int[cpt2++]=(char)('0'+ m10);
224                 integer=integer/10;
225               } while(integer!=0);
226               
227               for(cpt2 = cpt2 - 1 ; cpt2 >= 0 ; cpt2--)
228                 PUTCHAR(buff_int[cpt2]);
229               
230               break;
231             }
232             
233           case 'c':
234             {
235               int value = va_arg(ap,int);
236               PUTCHAR((char)value);
237               break;
238             }
239             
240           case 's':
241             {
242               char *string = va_arg(ap,char *);
243               if (! string)
244                 string = "(null)";
245               for( ; *string != '\0' ; string++)
246                 PUTCHAR(*string);
247               break;
248             }
249 
250           case 'p':
251             PUTCHAR('0');
252             PUTCHAR('x');
253           case 'x':
254             {
255               unsigned int hexa = va_arg(ap,int);
256               unsigned int nb;
257               int i, had_nonzero = 0;
258               for(i=0 ; i < 8 ; i++)
259                 {
260                   nb = (unsigned int)(hexa << (i*4));
261                   nb = (nb >> 28) & 0xf;
262                   // Skip the leading zeros
263                   if (nb == 0)
264                     {
265                       if (had_nonzero)
266                         PUTCHAR('0');
267                     }
268                   else
269                     {
270                       had_nonzero = 1;
271                       if (nb < 10)
272                         PUTCHAR('0'+nb);
273                       else
274                         PUTCHAR('a'+(nb-10));
275                     }
276                 }
277               if (! had_nonzero)
278                 PUTCHAR('0');
279               break;
280             }
281             break;
282         
283           default:
284             PUTCHAR('%');
285             PUTCHAR(format[i]);
286           }
287         break;
288         
289       default:
290         PUTCHAR(format[i]);
291       }
292   }
293   
294   *buff = '\0';
295   return result;
296 }
297 
298 
299 int snprintf(char * buff, sos_size_t len, const char *format, ...)
300 {
301   va_list ap;
302  
303   va_start(ap, format);
304   len = vsnprintf(buff, len, format, ap);
305   va_end(ap);
306  
307   return len;
308 }

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