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 /userland/string.c (Article 7.5) and /userland/string.c (Article 9.5)


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 "string.h"                               020 #include "string.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, siz    045 int memcmp(const void *s1, const void *s2, 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, size_t co    071 unsigned int strnlen(const char * s, 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 */continue;
077                                                   077 
078   return sc - s;                                  078   return sc - s;
079 }                                                 079 }
080                                                   080 
081                                                   081 
082 char *strzcpy(register char *dst, register con    082 char *strzcpy(register char *dst, register const char *src, register int len)
083 {                                                 083 {
084   int i;                                          084   int i;
085                                                   085 
086   if (len <= 0)                                   086   if (len <= 0)
087     return dst;                                   087     return dst;
088                                                   088   
089   for (i = 0; i < len; i++)                       089   for (i = 0; i < len; i++)
090     {                                             090     {
091       dst[i] = src[i];                            091       dst[i] = src[i];
092       if(src[i] == '\0')                          092       if(src[i] == '\0')
093         return dst;                               093         return dst;
094     }                                             094     }
095                                                   095   
096   dst[len-1] = '\0';                              096   dst[len-1] = '\0'; 
097   return dst;                                     097   return dst;
098 }                                                 098 }
099                                                   099 
100                                                   100 
101 char *strzcat (char *dest, const char *src, si    101 char *strzcat (char *dest, const char *src, size_t n)
102 {                                                 102 {
103   char *res = dest;                               103   char *res = dest;
104                                                   104   
105   for ( ; *dest ; dest++);                        105   for ( ; *dest ; dest++);
106                                                   106   
107   for ( ; *src ; src++, dest++) {                 107   for ( ; *src ; src++, dest++) {
108     *dest = *src;                                 108     *dest = *src;
109     n--;                                          109     n--;
110     if (n <= 0)                                   110     if (n <= 0)
111       break;                                      111       break;
112   }                                               112   }
113                                                   113 
114   *dest = '\0';                                   114   *dest = '\0';
115   return res;                                     115   return res;
116 }                                                 116 }
117                                                   117 
118 int strcmp(register const char *s1, register c    118 int strcmp(register const char *s1, register const char *s2)
119 {                                                 119 {
120   while (*s1 == *s2++)                            120   while (*s1 == *s2++)
121     if (*s1++ == 0)                               121     if (*s1++ == 0)
122       return (0);                                 122       return (0);
123                                                   123   
124   return (*(const unsigned char *)s1 - *(const    124   return (*(const unsigned char *)s1 - *(const unsigned char *)(s2 - 1));
125 }                                                 125 }
126                                                   126 
127                                                   127 
128 int strncmp(register const char *s1, register     128 int strncmp(register const char *s1, register const char *s2, register int len)
129 {                                                 129 {
130   char c1 = '\0', c2 = '\0';                      130   char c1 = '\0', c2 = '\0';
131                                                   131   
132   while (len > 0)                                 132   while (len > 0)
133     {                                             133     {
134       c1 = (unsigned char) *s1++;                 134       c1 = (unsigned char) *s1++;
135       c2 = (unsigned char) *s2++;                 135       c2 = (unsigned char) *s2++;
136       if (c1 == '\0' || c1 != c2)                 136       if (c1 == '\0' || c1 != c2)
137         return c1 - c2;                           137         return c1 - c2;
138       len--;                                      138       len--;
139     }                                             139     }
140                                                   140   
141   return c1 - c2;                                 141   return c1 - c2;
142 }                                                 142 }
                                                   >> 143 
                                                   >> 144 
                                                   >> 145 long long int strtoll(const char *nptr, char **endptr, int base)
                                                   >> 146 {
                                                   >> 147   long long int result;
                                                   >> 148 
                                                   >> 149 #define RETURN(res) ({ if (endptr) *endptr = (char*)nptr; return res; })
                                                   >> 150 
                                                   >> 151   if (base > 36)
                                                   >> 152     {
                                                   >> 153       RETURN(0);
                                                   >> 154     }
                                                   >> 155 
                                                   >> 156   /* Skip leading  spaces */
                                                   >> 157   for ( ; *nptr != '\0' && isspace(*nptr) ; nptr++)
                                                   >> 158     continue;
                                                   >> 159 
                                                   >> 160   if (nptr[0] == '0')
                                                   >> 161     {
                                                   >> 162       if (nptr[1] == 'x')
                                                   >> 163         {
                                                   >> 164           base = 16;
                                                   >> 165           nptr += 2;
                                                   >> 166         }
                                                   >> 167       else
                                                   >> 168         {
                                                   >> 169           base = 8;
                                                   >> 170           nptr ++;
                                                   >> 171         }
                                                   >> 172     }
                                                   >> 173 
                                                   >> 174   result = 0;
                                                   >> 175   for ( ; *nptr != '\0' ; nptr ++)
                                                   >> 176     {
                                                   >> 177       int digit;
                                                   >> 178       if (*nptr >= '0' && *nptr <=  '9')
                                                   >> 179         digit = *nptr - '0';
                                                   >> 180       else if (*nptr >= 'a' && *nptr <=  'z')
                                                   >> 181         digit = 10 + *nptr - 'a';
                                                   >> 182       else if (*nptr >= 'A' && *nptr <=  'Z')
                                                   >> 183         digit = 10 + *nptr - 'A';
                                                   >> 184       else
                                                   >> 185         RETURN(result);
                                                   >> 186       if (digit >= base)
                                                   >> 187         {
                                                   >> 188           RETURN(result);
                                                   >> 189         }
                                                   >> 190       result *= base;
                                                   >> 191       result += digit;
                                                   >> 192     }
                                                   >> 193 
                                                   >> 194   RETURN(result);
                                                   >> 195 }
                                                   >> 196 
                                                   >> 197 long int strtol(const char *nptr, char **endptr, int base)
                                                   >> 198 {
                                                   >> 199   return strtoll(nptr, endptr, base);
                                                   >> 200 }
                                                   >> 201 
                                                   >> 202 long long atoll(const char *nptr)
                                                   >> 203 {
                                                   >> 204   return strtoll(nptr, NULL, 10);
                                                   >> 205 }
                                                   >> 206 
                                                   >> 207 long atol(const char *nptr)
                                                   >> 208 {
                                                   >> 209   return strtol(nptr, NULL, 10);
                                                   >> 210 }
                                                   >> 211 
                                                   >> 212 
                                                      

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