release/src-rt-6.x.4708/cfe/cfe/lib/lib_string.c

   1 /*  *********************************************************************
   2     *  Broadcom Common Firmware Environment (CFE)
   3     *
   4     *  String routines                          File: lib_string.c
   5     *
   6     *  Some standard routines for messing with strings.
   7     *
   8     *  Author:  Mitch Lichtenberg (mpl@broadcom.com)
   9     *
  10     *********************************************************************
  11     *
  12     *  Copyright 2000,2001,2002,2003
  13     *  Broadcom Corporation. All rights reserved.
  14     *
  15     *  This software is furnished under license and may be used and
  16     *  copied only in accordance with the following terms and
  17     *  conditions.  Subject to these conditions, you may download,
  18     *  copy, install, use, modify and distribute modified or unmodified
  19     *  copies of this software in source and/or binary form.  No title
  20     *  or ownership is transferred hereby.
  21     *
  22     *  1) Any source code used, modified or distributed must reproduce
  23     *     and retain this copyright notice and list of conditions
  24     *     as they appear in the source file.
  25     *
  26     *  2) No right is granted to use any trade name, trademark, or
  27     *     logo of Broadcom Corporation.  The "Broadcom Corporation"
  28     *     name may not be used to endorse or promote products derived
  29     *     from this software without the prior written permission of
  30     *     Broadcom Corporation.
  31     *
  32     *  3) THIS SOFTWARE IS PROVIDED "AS-IS" AND ANY EXPRESS OR
  33     *     IMPLIED WARRANTIES, INCLUDING BUT NOT LIMITED TO, ANY IMPLIED
  34     *     WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  35     *     PURPOSE, OR NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT
  36     *     SHALL BROADCOM BE LIABLE FOR ANY DAMAGES WHATSOEVER, AND IN
  37     *     PARTICULAR, BROADCOM SHALL NOT BE LIABLE FOR DIRECT, INDIRECT,
  38     *     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  39     *     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  40     *     GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  41     *     BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  42     *     OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  43     *     TORT (INCLUDING NEGLIGENCE OR OTHERWISE), EVEN IF ADVISED OF
  44     *     THE POSSIBILITY OF SUCH DAMAGE.
  45     ********************************************************************* */
  46
  47
  48
  49
  50 #include "lib_types.h"
  51 #define _LIB_NO_MACROS_
  52 #include "lib_string.h"
  53
  54 char *lib_strcpy(char *dest,const char *src)
  55 {
  56     char *ptr = dest;
  57
  58     while (*src) *ptr++ = *src++;
  59     *ptr = '\0';
  60
  61     return dest;
  62 }
  63
  64 char *lib_strncpy(char *dest,const char *src,size_t cnt)
  65 {
  66     char *ptr = dest;
  67
  68     while (*src && (cnt > 0)) {
  69         *ptr++ = *src++;
  70         cnt--;
  71         }
  72     if (cnt > 0) *ptr = '\0';
  73
  74     return dest;
  75 }
  76
  77
  78 size_t lib_xstrncpy(char *dest,const char *src,size_t cnt)
  79 {
  80     char *ptr = dest;
  81     size_t copied = 0;
  82
  83     while (*src && (cnt > 1)) {
  84         *ptr++ = *src++;
  85         cnt--;
  86         copied++;
  87         }
  88     *ptr = '\0';
  89
  90     return copied;
  91 }
  92
  93 size_t lib_strlen(const char *str)
  94 {
  95     size_t cnt = 0;
  96
  97     while (*str) {
  98         str++;
  99         cnt++;
 100         }
 101
 102     return cnt;
 103 }
 104
 105
 106 int lib_strcmp(const char *dest,const char *src)
 107 {
 108     while (*src && *dest) {
 109         if (*dest < *src) return -1;
 110         if (*dest > *src) return 1;
 111         dest++;
 112         src++;
 113         }
 114
 115     if (*dest && !*src) return 1;
 116     if (!*dest && *src) return -1;
 117     return 0;
 118 }
 119
 120 int lib_strncmp(const char *dest, const char *src, size_t cnt )
 121 {
 122     while (*src && *dest && cnt) {
 123         if (*dest < *src ) return -1;
 124         if (*dest > *src) return 1;
 125         dest++;
 126         src++;
 127         cnt--;
 128         }
 129
 130     if (!cnt) return 0;
 131     if (*dest && !*src) return 1;
 132     if (!*dest && *src) return -1;
 133     return 0;
 134 }
 135
 136 int lib_strcmpi(const char *dest,const char *src)
 137 {
 138     char dc,sc;
 139
 140     while (*src && *dest) {
 141         dc = lib_toupper(*dest);
 142         sc = lib_toupper(*src);
 143         if (dc < sc) return -1;
 144         if (dc > sc) return 1;
 145         dest++;
 146         src++;
 147         }
 148
 149     if (*dest && !*src) return 1;
 150     if (!*dest && *src) return -1;
 151     return 0;
 152 }
 153
 154
 155 char *lib_strchr(const char *dest,int c)
 156 {
 157     while (*dest) {
 158         if (*dest == c) return (char *) dest;
 159         dest++;
 160         }
 161     return NULL;
 162 }
 163
 164 char *lib_strnchr(const char *dest,int c,size_t cnt)
 165 {
 166     while (*dest && (cnt > 0)) {
 167         if (*dest == c) return (char *) dest;
 168         dest++;
 169         cnt--;
 170         }
 171     return NULL;
 172 }
 173
 174 char *lib_strrchr(const char *dest,int c)
 175 {
 176     char *ret = NULL;
 177
 178     while (*dest) {
 179         if (*dest == c) ret = (char *) dest;
 180         dest++;
 181         }
 182
 183     return ret;
 184 }
 185
 186
 187 int lib_memcmp(const void *dest,const void *src,size_t cnt)
 188 {
 189     const unsigned char *d;
 190     const unsigned char *s;
 191
 192     d = (const unsigned char *) dest;
 193     s = (const unsigned char *) src;
 194
 195     while (cnt) {
 196         if (*d < *s) return -1;
 197         if (*d > *s) return 1;
 198         d++; s++; cnt--;
 199         }
 200
 201     return 0;
 202 }
 203
 204 void *lib_memcpy(void *dest,const void *src,size_t cnt)
 205 {
 206     unsigned char *d;
 207     const unsigned char *s;
 208
 209     if (src < dest) {
 210             d = (unsigned char *) dest + (cnt - 1);
 211             s = (const unsigned char *) src + (cnt - 1);
 212
 213         while (cnt) {
 214           *d-- = *s--;
 215           cnt--;
 216         }
 217     } else {
 218         d = (unsigned char *) dest;
 219         s = (const unsigned char *) src;
 220
 221         while (cnt) {
 222           *d++ = *s++;
 223           cnt--;
 224         }
 225     }
 226     return dest;
 227 }
 228
 229 void *lib_memset(void *dest,int c,size_t cnt)
 230 {
 231     unsigned char *d;
 232
 233     d = dest;
 234
 235     while (cnt) {
 236         *d++ = (unsigned char) c;
 237         cnt--;
 238         }
 239
 240     return d;
 241 }
 242
 243 #ifdef __GNUC__
 244 /* gcc may generate calls to memcmp, memset, and memcpy */
 245 int memcmp(const void *dest,const void *src,size_t cnt) __attribute__((alias("lib_memcmp")));
 246 void *memcpy(void *dest,const void *src,size_t cnt) __attribute__((alias("lib_memcpy")));
 247 void *memset(void *dest,int c,size_t cnt) __attribute__((alias("lib_memset")));
 248 #endif
 249
 250 char lib_toupper(char c)
 251 {
 252     if ((c >= 'a') && (c <= 'z')) c -= 32;
 253     return c;
 254 }
 255
 256 void lib_strupr(char *str)
 257 {
 258     while (*str) {
 259         *str = lib_toupper(*str);
 260         str++;
 261         }
 262 }
 263
 264 char *lib_strcat(char *dest,const char *src)
 265 {
 266     char *ptr = dest;
 267
 268     while (*ptr) ptr++;
 269     while (*src) *ptr++ = *src++;
 270     *ptr = '\0';
 271
 272     return dest;
 273 }
 274
 275 #define isspace(x) (((x) == ' ') || ((x) == '\t'))
 276
 277 char *lib_gettoken(char **ptr)
 278 {
 279     char *p = *ptr;
 280     char *ret;
 281
 282     /* skip white space */
 283
 284     while (*p && isspace(*p)) p++;
 285     ret = p;
 286
 287     /* check for end of string */
 288
 289     if (!*p) {
 290         *ptr = p;
 291         return NULL;
 292         }
 293
 294     /* skip non-whitespace */
 295
 296     while (*p) {
 297         if (isspace(*p)) break;
 298
 299         /* do quoted strings */
 300
 301         if (*p == '"') {
 302             p++;
 303             ret = p;
 304             while (*p && (*p != '"')) p++;
 305             if (*p == '"') *p = '\0';
 306             }
 307
 308         p++;
 309
 310         }
 311
 312     if (*p) {
 313         *p++ = '\0';
 314         }
 315     *ptr = p;
 316
 317     return ret;
 318 }
 319
 320
 321 int lib_atoi(const char *dest)
 322 {
 323     int x = 0;
 324     int digit;
 325
 326     if ((*dest == '0') && (*(dest+1) == 'x')) {
 327         return lib_xtoi(dest+2);
 328         }
 329
 330     while (*dest) {
 331         if ((*dest >= '0') && (*dest <= '9')) {
 332             digit = *dest - '0';
 333             }
 334         else {
 335             break;
 336             }
 337         x *= 10;
 338         x += digit;
 339         dest++;
 340         }
 341
 342     return x;
 343 }
 344
 345 uint64_t lib_xtoq(const char *dest)
 346 {
 347     uint64_t x = 0;
 348     unsigned int digit;
 349
 350     if ((*dest == '0') && (*(dest+1) == 'x')) dest += 2;
 351
 352     while (*dest) {
 353         if ((*dest >= '0') && (*dest <= '9')) {
 354             digit = *dest - '0';
 355             }
 356         else if ((*dest >= 'A') && (*dest <= 'F')) {
 357             digit = 10 + *dest - 'A';
 358             }
 359         else if ((*dest >= 'a') && (*dest <= 'f')) {
 360             digit = 10 + *dest - 'a';
 361             }
 362         else {
 363             break;
 364             }
 365         x *= 16;
 366         x += digit;
 367         dest++;
 368         }
 369
 370     return x;
 371 }
 372
 373 int lib_xtoi(const char *dest)
 374 {
 375     int x = 0;
 376     int digit;
 377
 378     if ((*dest == '0') && (*(dest+1) == 'x')) dest += 2;
 379
 380     while (*dest) {
 381         if ((*dest >= '0') && (*dest <= '9')) {
 382             digit = *dest - '0';
 383             }
 384         else if ((*dest >= 'A') && (*dest <= 'F')) {
 385             digit = 10 + *dest - 'A';
 386             }
 387         else if ((*dest >= 'a') && (*dest <= 'f')) {
 388             digit = 10 + *dest - 'a';
 389             }
 390         else {
 391             break;
 392             }
 393         x *= 16;
 394         x += digit;
 395         dest++;
 396         }
 397
 398     return x;
 399 }