Subversion Repositories HelenOS

Rev

Rev 2479 | Rev 2640 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright (c) 2005 Martin Decky
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  *
  9.  * - Redistributions of source code must retain the above copyright
  10.  *   notice, this list of conditions and the following disclaimer.
  11.  * - Redistributions in binary form must reproduce the above copyright
  12.  *   notice, this list of conditions and the following disclaimer in the
  13.  *   documentation and/or other materials provided with the distribution.
  14.  * - The name of the author may not be used to endorse or promote products
  15.  *   derived from this software without specific prior written permission.
  16.  *
  17.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27.  */
  28.  
  29. /** @addtogroup libc
  30.  * @{
  31.  */
  32. /** @file
  33.  */
  34.  
  35. #include <string.h>
  36. #include <unistd.h>
  37. #include <ctype.h>
  38. #include <limits.h>
  39. #include <align.h>
  40. #include <sys/types.h>
  41.  
  42.  
  43. /* Dummy implementation of mem/ functions */
  44.  
  45. void *memset(void *s, int c, size_t n)
  46. {
  47.     char *os = s;
  48.    
  49.     while (n--)
  50.         *(os++) = c;
  51.    
  52.     return s;
  53. }
  54.  
  55. struct along {
  56.     unsigned long n;
  57. } __attribute__ ((packed));
  58.  
  59. static void *unaligned_memcpy(void *dst, const void *src, size_t n)
  60. {
  61.     int i, j;
  62.     struct along *adst = dst;
  63.     const struct along *asrc = src;
  64.  
  65.     for (i = 0; i < n / sizeof(unsigned long); i++)
  66.         adst[i].n = asrc[i].n;
  67.        
  68.     for (j = 0; j < n % sizeof(unsigned long); j++)
  69.         ((unsigned char *) (((unsigned long *) dst) + i))[j] = ((unsigned char *) (((unsigned long *) src) + i))[j];
  70.        
  71.     return (char *) src;
  72. }
  73.  
  74. void *memcpy(void *dst, const void *src, size_t n)
  75. {
  76.     int i, j;
  77.  
  78.     if (((long) dst & (sizeof(long) - 1)) || ((long) src & (sizeof(long) - 1)))
  79.         return unaligned_memcpy(dst, src, n);
  80.  
  81.     for (i = 0; i < n / sizeof(unsigned long); i++)
  82.         ((unsigned long *) dst)[i] = ((unsigned long *) src)[i];
  83.        
  84.     for (j = 0; j < n % sizeof(unsigned long); j++)
  85.         ((unsigned char *) (((unsigned long *) dst) + i))[j] = ((unsigned char *) (((unsigned long *) src) + i))[j];
  86.        
  87.     return (char *) src;
  88. }
  89.  
  90. void *memmove(void *dst, const void *src, size_t n)
  91. {
  92.     int i, j;
  93.    
  94.     if (src > dst)
  95.         return memcpy(dst, src, n);
  96.  
  97.     for (j = (n % sizeof(unsigned long)) - 1; j >= 0; j--)
  98.         ((unsigned char *) ((unsigned long *) dst))[j] = ((unsigned char *) ((unsigned long *) src))[j];
  99.  
  100.     for (i = n / sizeof(unsigned long) - 1; i >=0 ; i--)
  101.         ((unsigned long *) dst)[i] = ((unsigned long *) src)[i];
  102.        
  103.     return (char *) src;
  104. }
  105.  
  106. /** Compare two memory areas.
  107.  *
  108.  * @param s1    Pointer to the first area to compare.
  109.  * @param s2    Pointer to the second area to compare.
  110.  * @param len   Size of the first area in bytes. Both areas must have the same
  111.  *      length.
  112.  * @return  If len is 0, return zero. If the areas match, return zero.
  113.  *      Otherwise return non-zero.
  114.  */
  115. int bcmp(const char *s1, const char *s2, size_t len)
  116. {
  117.     for (; len && *s1++ == *s2++; len--)
  118.         ;
  119.     return len;
  120. }
  121.  
  122. /** Count the number of characters in the string, not including terminating 0.
  123.  * @param str string
  124.  * @return number of characters in string.
  125.  */
  126. size_t strlen(const char *str)
  127. {
  128.     size_t counter = 0;
  129.  
  130.     while (str[counter] != 0)
  131.         counter++;
  132.  
  133.     return counter;
  134. }
  135.  
  136. int strcmp(const char *a, const char *b)
  137. {
  138.     int c = 0;
  139.    
  140.     while (a[c] && b[c] && (!(a[c] - b[c])))
  141.         c++;
  142.    
  143.     return (a[c] - b[c]);
  144.    
  145. }
  146.  
  147.  
  148. /** Return pointer to the first occurence of character c in string
  149.  * @param str scanned string
  150.  * @param c searched character (taken as one byte)
  151.  * @return pointer to the matched character or NULL if it is not found in given string.
  152.  */
  153. char *strchr(const char *str, int c)
  154. {
  155.     while (*str != '\0') {
  156.         if (*str == (char) c)
  157.             return (char *) str;
  158.         str++;
  159.     }
  160.  
  161.     return NULL;
  162. }
  163.  
  164. /** Return pointer to the last occurence of character c in string
  165.  * @param str scanned string
  166.  * @param c searched character (taken as one byte)
  167.  * @return pointer to the matched character or NULL if it is not found in given string.
  168.  */
  169. char *strrchr(const char *str, int c)
  170. {
  171.     char *retval = NULL;
  172.  
  173.     while (*str != '\0') {
  174.         if (*str == (char) c)
  175.             retval = (char *) str;
  176.         str++;
  177.     }
  178.  
  179.     return (char *) retval;
  180. }
  181.  
  182. /** Convert string to a number.
  183.  * Core of strtol and strtoul functions.
  184.  * @param nptr pointer to string
  185.  * @param endptr if not NULL, function stores here pointer to the first invalid character
  186.  * @param base zero or number between 2 and 36 inclusive
  187.  * @param sgn its set to 1 if minus found
  188.  * @return result of conversion.
  189.  */
  190. static unsigned long _strtoul(const char *nptr, char **endptr, int base, char *sgn)
  191. {
  192.     unsigned char c;
  193.     unsigned long result = 0;
  194.     unsigned long a, b;
  195.     const char *str = nptr;
  196.     const char *tmpptr;
  197.    
  198.     while (isspace(*str))
  199.         str++;
  200.    
  201.     if (*str == '-') {
  202.         *sgn = 1;
  203.         ++str;
  204.     } else if (*str == '+')
  205.         ++str;
  206.    
  207.     if (base) {
  208.         if ((base == 1) || (base > 36)) {
  209.             /* FIXME: set errno to EINVAL */
  210.             return 0;
  211.         }
  212.         if ((base == 16) && (*str == '0') && ((str[1] == 'x') || (str[1] == 'X'))) {
  213.             str += 2;
  214.         }
  215.     } else {
  216.         base = 10;
  217.        
  218.         if (*str == '0') {
  219.             base = 8;
  220.             if ((str[1] == 'X') || (str[1] == 'x'))  {
  221.                 base = 16;
  222.                 str += 2;
  223.             }
  224.         }
  225.     }
  226.    
  227.     tmpptr = str;
  228.  
  229.     while (*str) {
  230.         c = *str;
  231.         c = (c >= 'a' ? c - 'a' + 10 : (c >= 'A' ? c - 'A' + 10 : (c <= '9' ? c - '0' : 0xff)));
  232.         if (c > base) {
  233.             break;
  234.         }
  235.        
  236.         a = (result & 0xff) * base + c;
  237.         b = (result >> 8) * base + (a >> 8);
  238.        
  239.         if (b > (ULONG_MAX >> 8)) {
  240.             /* overflow */
  241.             /* FIXME: errno = ERANGE*/
  242.             return ULONG_MAX;
  243.         }
  244.    
  245.         result = (b << 8) + (a & 0xff);
  246.         ++str;
  247.     }
  248.    
  249.     if (str == tmpptr) {
  250.         /* no number was found => first invalid character is the first character of the string */
  251.         /* FIXME: set errno to EINVAL */
  252.         str = nptr;
  253.         result = 0;
  254.     }
  255.    
  256.     if (endptr)
  257.         *endptr = (char *) str;
  258.  
  259.     if (nptr == str) {
  260.         /*FIXME: errno = EINVAL*/
  261.         return 0;
  262.     }
  263.  
  264.     return result;
  265. }
  266.  
  267. /** Convert initial part of string to long int according to given base.
  268.  * The number may begin with an arbitrary number of whitespaces followed by optional sign (`+' or `-').
  269.  * If the base is 0 or 16, the prefix `0x' may be inserted and the number will be taken as hexadecimal one.
  270.  * If the base is 0 and the number begin with a zero, number will be taken as octal one (as with base 8).
  271.  * Otherwise the base 0 is taken as decimal.
  272.  * @param nptr pointer to string
  273.  * @param endptr if not NULL, function stores here pointer to the first invalid character
  274.  * @param base zero or number between 2 and 36 inclusive
  275.  * @return result of conversion.
  276.  */
  277. long int strtol(const char *nptr, char **endptr, int base)
  278. {
  279.     char sgn = 0;
  280.     unsigned long number = 0;
  281.    
  282.     number = _strtoul(nptr, endptr, base, &sgn);
  283.  
  284.     if (number > LONG_MAX) {
  285.         if ((sgn) && (number == (unsigned long) (LONG_MAX) + 1)) {
  286.             /* FIXME: set 0 to errno */
  287.             return number;     
  288.         }
  289.         /* FIXME: set ERANGE to errno */
  290.         return (sgn ? LONG_MIN : LONG_MAX);
  291.     }
  292.    
  293.     return (sgn ? -number : number);
  294. }
  295.  
  296.  
  297. /** Convert initial part of string to unsigned long according to given base.
  298.  * The number may begin with an arbitrary number of whitespaces followed by optional sign (`+' or `-').
  299.  * If the base is 0 or 16, the prefix `0x' may be inserted and the number will be taken as hexadecimal one.
  300.  * If the base is 0 and the number begin with a zero, number will be taken as octal one (as with base 8).
  301.  * Otherwise the base 0 is taken as decimal.
  302.  * @param nptr pointer to string
  303.  * @param endptr if not NULL, function stores here pointer to the first invalid character
  304.  * @param base zero or number between 2 and 36 inclusive
  305.  * @return result of conversion.
  306.  */
  307. unsigned long strtoul(const char *nptr, char **endptr, int base)
  308. {
  309.     char sgn = 0;
  310.     unsigned long number = 0;
  311.    
  312.     number = _strtoul(nptr, endptr, base, &sgn);
  313.  
  314.     return (sgn ? -number : number);
  315. }
  316.  
  317. char *strcpy(char *dest, const char *src)
  318. {
  319.     char *orig = dest;
  320.    
  321.     while ((*(dest++) = *(src++)));
  322.     return orig;
  323. }
  324.  
  325. char *strncpy(char *dest, const char *src, size_t n)
  326. {
  327.     char *orig = dest;
  328.    
  329.     while ((*(dest++) = *(src++)) && --n);
  330.     return orig;
  331. }
  332.  
  333. /** @}
  334.  */
  335.