home *** CD-ROM | disk | FTP | other *** search
/ linuxmafia.com 2016 / linuxmafia.com.tar / linuxmafia.com / pub / palmos / pippy-0.6beta-src.tar.gz / pippy-0.6beta-src.tar / pippy-0.6beta-src / src / Palm / libc / string.c < prev    next >
C/C++ Source or Header  |  2000-12-21  |  6KB  |  370 lines
  1. /*
  2.  *  linux/lib/string.c
  3.  *
  4.  *  Copyright (C) 1991, 1992  Linus Torvalds
  5.  */
  6.  
  7. /*
  8.  * stupid library routines.. The optimized versions should generally be found
  9.  * as inline code in <asm-xx/string.h>
  10.  *
  11.  * These are buggy as well..
  12.  */
  13.  
  14. /* Adapted for the use in the 332 kernel 
  15.  * D. Jeff Dionne, 1995.
  16.  */
  17.  
  18. /* Additional hole filled: strtol
  19.  * M. Schlifer, NOV 1995.
  20. */
  21.  
  22. #include <sys/types.h>
  23. #include <string.h>
  24. #include <ctype.h>
  25.  
  26. char * ___strtok = NULL;
  27.  
  28. #ifndef __HAVE_ARCH_STRTOUL
  29. unsigned long strtoul(const char *cp,char **endp,unsigned int base)
  30. {
  31.   unsigned long result = 0,value;
  32.   
  33.   if (!base) {
  34.     base = 10;
  35.     if (*cp == '0') {
  36.       base = 8;
  37.       cp++;
  38.       if ((*cp == 'x') && isxdigit(cp[1])) {
  39.     cp++;
  40.     base = 16;
  41.       }
  42.     }
  43.   }
  44.   while (isxdigit(*cp) && (value = isdigit(*cp) ? *cp-'0' : (islower(*cp) ? toupper(*cp) : *cp)-'A'+10) < base) {
  45.     result = result*base + value;
  46.     cp++;
  47.   }
  48.   if (endp)
  49.     *endp = (char *)cp;
  50.   return result;
  51. }
  52. #endif
  53.  
  54. #ifndef __HAVE_ARCH_STRTOL
  55. signed long strtol(const char *cp,char **endp,unsigned int base)
  56. {
  57.   signed long sign;
  58.   signed long result = 0,value;
  59.   if (!isdigit(*cp))
  60.     {
  61.       if ((*cp) == '-')
  62.     sign = -1;
  63.       else
  64.     sign = 1;
  65.       cp++;
  66.     }
  67.   else sign = 1;
  68.   if (!base) {
  69.     base = 10;
  70.     if (*cp == '0') {
  71.       base = 8;
  72.       cp++;
  73.       if ((*cp == 'x') && isxdigit(cp[1])) {
  74.     cp++;
  75.     base = 16;
  76.       }
  77.     }
  78.   }
  79.   while (isxdigit(*cp) && (value = isdigit(*cp) ? *cp-'0' : (islower(*cp)
  80.                                  ? toupper(*cp) : *cp)-'A'+10) < base) {
  81.     result = result*base + value;
  82.     cp++;
  83.   }
  84.   if (endp)
  85.     *endp = (char *)cp;
  86.   return (result * sign);
  87. }
  88. #endif
  89.  
  90. #ifndef __HAVE_ARCH_STRCPY
  91. char * strcpy(char * dest,const char *src)
  92. {
  93.   char *tmp = dest;
  94.   
  95.   while ((*dest++ = *src++) != '\0')
  96.     /* nothing */;
  97.   return tmp;
  98. }
  99. #endif
  100.  
  101. #ifndef __HAVE_ARCH_STRNCPY
  102. char * strncpy(char * dest,const char *src,size_t count)
  103. {
  104.   char *tmp = dest;
  105.   
  106.   while (count-- && (*dest++ = *src++) != '\0')
  107.     /* nothing */;
  108.   
  109.   return tmp;
  110. }
  111. #endif
  112.  
  113. #ifndef __HAVE_ARCH_STRCAT
  114. char * strcat(char * dest, const char * src)
  115. {
  116.   char *tmp = dest;
  117.   
  118.   while (*dest)
  119.     dest++;
  120.   while ((*dest++ = *src++) != '\0');
  121.  
  122.   return tmp;
  123. }
  124. #endif
  125.  
  126. #ifndef __HAVE_ARCH_STRNCAT
  127. char * strncat(char *dest, const char *src, size_t count)
  128. {
  129.   char *tmp = dest;
  130.   
  131.   if (count) {
  132.     while (*dest)
  133.       dest++;
  134.     while ((*dest++ = *src++)) {
  135.       if (--count == 0)
  136.     break;
  137.     }
  138.   }
  139.   
  140.   return tmp;
  141. }
  142. #endif
  143.  
  144. #ifndef __HAVE_ARCH_STRCMP
  145. int strcmp(const char * cs,const char * ct)
  146. {
  147.   register signed char __res;
  148.   
  149.   while (1) {
  150.     if ((__res = *cs - *ct++) != 0 || !*cs++)
  151.       break;
  152.   }
  153.   
  154.   return __res;
  155. }
  156. #endif
  157.  
  158. #ifndef __HAVE_ARCH_STRNCMP
  159. int strncmp(const char * cs,const char * ct,size_t count)
  160. {
  161.   register signed char __res = 0;
  162.   
  163.   while (count) {
  164.     if ((__res = *cs - *ct++) != 0 || !*cs++)
  165.       break;
  166.     count--;
  167.   }
  168.   
  169.   return __res;
  170. }
  171. #endif
  172.  
  173. #ifndef __HAVE_ARCH_STRCHR
  174. char * strchr(const char * s, int c)
  175. {
  176.   for(; *s != (char) c; ++s)
  177.     if (*s == '\0')
  178.       return NULL;
  179.   return (char *) s;
  180. }
  181. #endif
  182.  
  183. #ifndef __HAVE_ARCH_STRLEN
  184. size_t strlen(const char * s)
  185. {
  186.   const char *sc;
  187.   
  188.   for (sc = s; *sc != '\0'; ++sc)
  189.     /* nothing */;
  190.   return sc - s;
  191. }
  192. #endif
  193.  
  194. #ifndef __HAVE_ARCH_STRNLEN
  195. size_t strnlen(const char * s, size_t count)
  196. {
  197.   const char *sc;
  198.   
  199.   for (sc = s; count-- && *sc != '\0'; ++sc)
  200.     /* nothing */;
  201.   return sc - s;
  202. }
  203. #endif
  204.  
  205. #ifndef __HAVE_ARCH_STRSPN
  206. size_t strspn(const char *s, const char *accept)
  207. {
  208.   const char *p;
  209.   const char *a;
  210.   size_t count = 0;
  211.   
  212.   for (p = s; *p != '\0'; ++p) {
  213.     for (a = accept; *a != '\0'; ++a) {
  214.       if (*p == *a)
  215.     break;
  216.     }
  217.     if (*a == '\0')
  218.       return count;
  219.     ++count;
  220.   }
  221.  
  222.   return count;
  223. }
  224. #endif
  225.  
  226. #ifndef __HAVE_ARCH_STRPBRK
  227. char * strpbrk(const char * cs,const char * ct)
  228. {
  229.   const char *sc1,*sc2;
  230.   
  231.   for( sc1 = cs; *sc1 != '\0'; ++sc1) {
  232.     for( sc2 = ct; *sc2 != '\0'; ++sc2) {
  233.       if (*sc1 == *sc2)
  234.     return (char *) sc1;
  235.     }
  236.   }
  237.   return NULL;
  238. }
  239. #endif
  240.  
  241. #ifndef __HAVE_ARCH_STRTOK
  242. char * strtok(char * s,const char * ct)
  243. {
  244.   char *sbegin, *send;
  245.   
  246.   sbegin  = s ? s : ___strtok;
  247.   if (!sbegin) {
  248.     return NULL;
  249.   }
  250.   sbegin += strspn(sbegin,ct);
  251.   if (*sbegin == '\0') {
  252.     ___strtok = NULL;
  253.     return( NULL );
  254.   }
  255.   send = strpbrk( sbegin, ct);
  256.   if (send && *send != '\0')
  257.     *send++ = '\0';
  258.   ___strtok = send;
  259.   return (sbegin);
  260. }
  261. #endif
  262.  
  263. #ifndef __HAVE_ARCH_MEMSET
  264. void * memset(void * s,char c,size_t count)
  265. {
  266.   char *xs = (char *) s;
  267.  
  268.   while (count--)
  269.     *xs++ = c;
  270.   
  271.   return s;
  272. }
  273. #endif
  274.  
  275. #ifndef __HAVE_ARCH_BCOPY
  276. char * bcopy(const char * src, char * dest, int count)
  277. {
  278.   char *tmp = dest;
  279.   
  280.   while (count--)
  281.     *tmp++ = *src++;
  282.   
  283.   return dest;
  284. }
  285. #endif
  286.  
  287. #ifndef __HAVE_ARCH_MEMCPY
  288. void * memcpy(void * dest,const void *src,size_t count)
  289. {
  290.   char *tmp = (char *) dest, *s = (char *) src;
  291.   
  292.   while (count--)
  293.     *tmp++ = *s++;
  294.   
  295.   return dest;
  296. }
  297. #endif
  298.  
  299. #ifndef __HAVE_ARCH_MEMMOVE
  300. void * memmove(void * dest,const void *src,size_t count)
  301. {
  302.   char *tmp, *s;
  303.  
  304.   if (dest <= src) {
  305.     tmp = (char *) dest;
  306.     s = (char *) src;
  307.     while (count--)
  308.       *tmp++ = *s++;
  309.   }
  310.   else {
  311.     tmp = (char *) dest + count;
  312.     s = (char *) src + count;
  313.     while (count--)
  314.       *--tmp = *--s;
  315.   }
  316.   
  317.   return dest;
  318. }
  319. #endif
  320.  
  321. #ifndef __HAVE_ARCH_MEMCMP
  322. int memcmp(const void * cs,const void * ct,size_t count)
  323. {
  324.   const unsigned char *su1, *su2;
  325.   signed char res = 0;
  326.   
  327.   for( su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
  328.     if ((res = *su1 - *su2) != 0)
  329.       break;
  330.   return res;
  331. }
  332. #endif
  333.  
  334. /*
  335.  * find the first occurrence of byte 'c', or 1 past the area if none
  336.  */
  337. #ifndef __HAVE_ARCH_MEMSCAN
  338. void * memscan(void * addr, int c, size_t size)
  339. {
  340.   unsigned char * p = (unsigned char *) addr;
  341.  
  342.   while (size) {
  343.     if (*p == c)
  344.       return (void *) p;
  345.     p++;
  346.     size--;
  347.   }
  348.   return (void *) p;
  349. }
  350. #endif
  351.  
  352. #ifndef __HAVE_ARCH_STRSTR
  353. char * strstr(const char * s1,const char * s2)
  354. {
  355.   int l1, l2;
  356.   
  357.   l2 = strlen(s2);
  358.   if (!l2)
  359.     return (char *) s1;
  360.   l1 = strlen(s1);
  361.   while (l1 >= l2) {
  362.     l1--;
  363.     if (!memcmp(s1,s2,l2))
  364.       return (char *) s1;
  365.     s1++;
  366.   }
  367.   return NULL;
  368. }
  369. #endif
  370.