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 ]

Diff markup

Differences between /sos/klibc.c (Article 7.5) and /sos/klibc.c (Article 2)


001 /* Copyright (C) 2004  David Decotigny (with I    001 /* Copyright (C) 2004  David Decotigny (with INSA Rennes for vsnprintf)
002    Copyright (C) 2003  The KOS Team               002    Copyright (C) 2003  The KOS Team
003    Copyright (C) 1999  Free Software Foundatio    003    Copyright (C) 1999  Free Software Foundation
004                                                   004 
005    This program is free software; you can redi    005    This program is free software; you can redistribute it and/or
006    modify it under the terms of the GNU Genera    006    modify it under the terms of the GNU General Public License
007    as published by the Free Software Foundatio    007    as published by the Free Software Foundation; either version 2
008    of the License, or (at your option) any lat    008    of the License, or (at your option) any later version.
009                                                   009    
010    This program is distributed in the hope tha    010    This program is distributed in the hope that it will be useful,
011    but WITHOUT ANY WARRANTY; without even the     011    but WITHOUT ANY WARRANTY; without even the implied warranty of
012    MERCHANTABILITY or FITNESS FOR A PARTICULAR    012    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
013    GNU General Public License for more details    013    GNU General Public License for more details.
014                                                   014    
015    You should have received a copy of the GNU     015    You should have received a copy of the GNU General Public License
016    along with this program; if not, write to t    016    along with this program; if not, write to the Free Software
017    Foundation, Inc., 59 Temple Place - Suite 3    017    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
018    USA.                                           018    USA. 
019 */                                                019 */
020 #include "klibc.h"                                020 #include "klibc.h"
021                                                   021 
022 /* For an optimized version, see BSD sources ;    022 /* For an optimized version, see BSD sources ;) */
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 /* ditto */                                       034 /* ditto */
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     /* nothing */continue;                     !! 076     /* nothing */;
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  * The following code is borrowed from Glenn R << 
149  * http://remus.rutgers.edu/~rhoads/Code/code. << 
150  * License to be defined...                    << 
151  */                                            << 
152 unsigned long int random (void)                << 
153 {                                              << 
154 /* The following parameters are recommended se << 
155    uncomment the one you want. */              << 
156                                                << 
157 /* For RAND_MAX == 4294967291 */               << 
158    static unsigned int a = 1588635695, q = 2,  << 
159 /* static unsigned int a = 1223106847, m = 429 << 
160 /* static unsigned int a = 279470273, m = 4294 << 
161                                                << 
162 /* For RAND_MAX == 2147483647 */               << 
163 /* static unsigned int a = 1583458089, m = 214 << 
164 /* static unsigned int a = 784588716, m = 2147 << 
165 /* static unsigned int a = 16807, m = 21474836 << 
166 /* static unsigned int a = 950706376, m = 2147 << 
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 /* I (d2) borrowed and rewrote this for Nachos    140 /* I (d2) borrowed and rewrote this for Nachos/INSA Rennes. Thanks to
180    them for having kindly allowed me to do so.    141    them for having kindly allowed me to do so. */
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   sos_bool_t fmt_modifiers = FALSE;            << 
185   sos_bool_t prefix_long = FALSE;              << 
186   sos_bool_t prefix_long_long = FALSE;         << 
187                                                   145   
188   if (!buff || !format || (len < 0))              146   if (!buff || !format || (len < 0))
189     return -1;                                    147     return -1;
190                                                   148   
191 #define PUTCHAR(thechar) \                        149 #define PUTCHAR(thechar) \
192   do { \                                          150   do { \
193     if (result < len-1) \                         151     if (result < len-1) \
194       *buff++ = (thechar);  \                     152       *buff++ = (thechar);  \
195     result++; \                                   153     result++; \
196   } while (0)                                     154   } while (0)
197                                                   155   
198   result = 0;                                     156   result = 0;
199   for(i=0 ; format[i] != '\0' ; i++)           !! 157   for(i=0 ; format[i] != '\0' ; i++){
200     {                                          !! 158     switch (format[i])
201       if (!fmt_modifiers && (format[i] != '%') !! 159       {
202         {                                      !! 160       case '%':
203           PUTCHAR(format[i]);                  !! 161         i++;
204           continue;                            !! 162         switch(format[i])
205         }                                      !! 163           {
206                                                !! 164           case '%':
207       switch (format[i])                       << 
208         {                                      << 
209         case '%':                              << 
210           if (fmt_modifiers)                   << 
211             {                                     165             {
212               PUTCHAR('%');                       166               PUTCHAR('%');
213               fmt_modifiers = FALSE;           << 
214               break;                              167               break;
215             }                                     168             }
216                                                !! 169           case 'i':;
217           fmt_modifiers    = TRUE;             !! 170           case 'd':
218           prefix_long      = FALSE;            !! 171             {
219           prefix_long_long = FALSE;            !! 172               int integer = va_arg(ap,int);
220           break;                               !! 173               int cpt2 = 0;
221                                                !! 174               char buff_int[16];
222         case 'l':                              !! 175               
223           if (prefix_long)                     !! 176               if (integer<0)
224             prefix_long_long = TRUE;           !! 177                 PUTCHAR('-');
225           else                                 !! 178               /* Ne fait pas integer = -integer ici parce que INT_MIN
226             prefix_long = TRUE;                !! 179                  n'a pas d'equivalent positif (int = [-2^31, 2^31-1]) */
227           break;                               !! 180               
228                                                !! 181               do {
229         case 'u':                              !! 182                 int m10 = integer%10;
230           {                                    !! 183                 m10 = (m10 < 0)? -m10:m10;
231             if (! prefix_long_long)            !! 184                 buff_int[cpt2++]=(char)('0'+ m10);
232               {                                !! 185                 integer=integer/10;
233                 unsigned int integer = va_arg( !! 186               } while(integer!=0);
234                 int cpt2 = 0;                  !! 187               
235                 char buff_int[16];             !! 188               for(cpt2 = cpt2 - 1 ; cpt2 >= 0 ; cpt2--)
236                                                !! 189                 PUTCHAR(buff_int[cpt2]);
237                 do {                           !! 190               
238                   int m10 = integer%10;        !! 191               break;
239                   buff_int[cpt2++]=(char)('0'+ !! 192             }
240                   integer=integer/10;          << 
241                 } while(integer!=0);           << 
242                                                   193             
243                 for(cpt2 = cpt2 - 1 ; cpt2 >=  !! 194           case 'c':
244                   PUTCHAR(buff_int[cpt2]);     !! 195             {
245               }                                !! 196               int value = va_arg(ap,int);
246             else                               !! 197               PUTCHAR((char)value);
247               {                                !! 198               break;
248                 unsigned long long int integer !! 199             }
249                   = va_arg(ap,unsigned long lo << 
250                 int cpt2 = 0;                  << 
251                 char buff_int[32];             << 
252                                                << 
253                 do {                           << 
254                   int m10 = integer%10;        << 
255                   buff_int[cpt2++]=(char)('0'+ << 
256                   integer=integer/10;          << 
257                 } while(integer!=0);           << 
258                                                   200             
259                 for(cpt2 = cpt2 - 1 ; cpt2 >=  !! 201           case 's':
260                   PUTCHAR(buff_int[cpt2]);     !! 202             {
261               }                                !! 203               char *string = va_arg(ap,char *);
262           }                                    !! 204               if (! string)
263           fmt_modifiers = FALSE;               !! 205                 string = "(null)";
264           break;                               !! 206               for( ; *string != '\0' ; string++)
                                                   >> 207                 PUTCHAR(*string);
                                                   >> 208               break;
                                                   >> 209             }
265                                                   210 
266         case 'i':                              !! 211           case 'x':
267         case 'd':                              !! 212             {
268           {                                    !! 213               unsigned int hexa = va_arg(ap,int);
269             if (! prefix_long_long)            !! 214               unsigned int nb;
270               {                                !! 215               int i, had_nonzero = 0;
271                 int integer = va_arg(ap,int);  !! 216               for(i=0 ; i < 8 ; i++)
272                 int cpt2 = 0;                  !! 217                 {
273                 char buff_int[16];             !! 218                   nb = (unsigned int)(hexa << (i*4));
274                                                !! 219                   nb = (nb >> 28) & 0xf;
275                 if (integer<0)                 !! 220                   // Skip the leading zeros
276                   PUTCHAR('-');                !! 221                   if (nb == 0)
277                 /* Ne fait pas integer = -inte !! 222                     {
278                    n'a pas d'equivalent positi !! 223                       if (had_nonzero)
279                                                !! 224                         PUTCHAR('0');
280                 do {                           !! 225                     }
281                   int m10 = integer%10;        !! 226                   else
282                   m10 = (m10 < 0)? -m10:m10;   !! 227                     {
283                   buff_int[cpt2++]=(char)('0'+ !! 228                       had_nonzero = 1;
284                   integer=integer/10;          !! 229                       if (nb < 10)
285                 } while(integer!=0);           !! 230                         PUTCHAR('0'+nb);
286                                                !! 231                       else
287                 for(cpt2 = cpt2 - 1 ; cpt2 >=  !! 232                         PUTCHAR('a'+(nb-10));
288                   PUTCHAR(buff_int[cpt2]);     !! 233                     }
289               }                                !! 234                 }
290             else                               !! 235               if (! had_nonzero)
291               {                                !! 236                 PUTCHAR('0');
292                 long long int integer = va_arg !! 237               break;
293                 int cpt2 = 0;                  !! 238             }
294                 char buff_int[32];             << 
295                                                << 
296                 if (integer<0)                 << 
297                   PUTCHAR('-');                << 
298                 /* Ne fait pas integer = -inte << 
299                    n'a pas d'equivalent positi << 
300                                                << 
301                 do {                           << 
302                   int m10 = integer%10;        << 
303                   m10 = (m10 < 0)? -m10:m10;   << 
304                   buff_int[cpt2++]=(char)('0'+ << 
305                   integer=integer/10;          << 
306                 } while(integer!=0);           << 
307                                                << 
308                 for(cpt2 = cpt2 - 1 ; 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;                                239             break;
                                                   >> 240         
                                                   >> 241           default:
                                                   >> 242             PUTCHAR('%');
                                                   >> 243             PUTCHAR(format[i]);
332           }                                       244           }
333                                                !! 245         break;
334         case 'p':                              !! 246         
335           PUTCHAR('0');                        !! 247       default:
336           PUTCHAR('x');                        !! 248         PUTCHAR(format[i]);
337         case 'x':                              !! 249       }
338           {                                    !! 250   }
339             unsigned long long int hexa;       !! 251   
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 l << 
345             else                               << 
346               hexa = va_arg(ap,unsigned int);  << 
347                                                << 
348             for(i=0 ; i < 16 ; i++)            << 
349               {                                << 
350                 nb = (unsigned long long int)( << 
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';                                   252   *buff = '\0';
385   return result;                                  253   return result;
386 }                                                 254 }
387                                                   255 
388                                                   256 
389 int snprintf(char * buff, sos_size_t len, cons    257 int snprintf(char * buff, sos_size_t len, const char *format, ...)
390 {                                                 258 {
391   va_list ap;                                     259   va_list ap;
392                                                   260  
393   va_start(ap, format);                           261   va_start(ap, format);
394   len = vsnprintf(buff, len, format, ap);         262   len = vsnprintf(buff, len, format, ap);
395   va_end(ap);                                     263   va_end(ap);
396                                                   264  
397   return len;                                     265   return len;
398 }                                                 266 }
                                                      

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