dmake/dbug/malloc/string.c

   1 /*
   2  * (c) Copyright 1990 Conor P. Cahill (uunet!virtech!cpcahil).
   3  * You may copy, distribute, and use this software as long as this
   4  * copyright statement is not removed.
   5  */
   6
   7 #include <stdio.h>
   8 #include <string.h>
   9 #include <sys/types.h>
  10 #include "malloc.h"
  11
  12 #ifndef lint
  13 static
  14 char rcs_hdr[] = "$Id: string.c,v 1.2 2006-07-25 10:10:03 rt Exp $";
  15 #endif
  16
  17 int     malloc_checking = 0;
  18
  19 char *
  20 strcat(str1,str2)
  21     register char       * str1;
  22     register char       * str2;
  23 {
  24     char                * rtn;
  25     int   len;
  26
  27     /*
  28      * check pointers agains malloc region.  The malloc* functions
  29      * will properly handle the case where a pointer does not
  30      * point into malloc space.
  31      */
  32     malloc_checking = 1;
  33
  34     len = strlen(str2);
  35     malloc_check_str("strcat", str2);
  36
  37     len += strlen(str1) + 1;
  38     malloc_checking = 0;
  39
  40     malloc_check_data("strcat", str1, len);
  41
  42     rtn = str1;
  43
  44     while( *str1 )
  45     {
  46         str1++;
  47     }
  48
  49     while( (*str1 = *str2) != '\0' )
  50     {
  51         str1++;
  52         str2++;
  53     }
  54
  55     return(rtn);
  56 }
  57
  58 char *
  59 strdup(str1)
  60     register char       * str1;
  61 {
  62     char                * malloc();
  63     char                * rtn;
  64     register char       * str2;
  65
  66     malloc_check_str("strdup", str1);
  67
  68     rtn = str2 = malloc((unsigned)strlen(str1)+1);
  69
  70     if( rtn != (char *) 0)
  71     {
  72         while( (*str2 = *str1) != '\0' )
  73         {
  74             str1++;
  75             str2++;
  76         }
  77     }
  78
  79     return(rtn);
  80 }
  81
  82 char *
  83 strncat(str1,str2,len)
  84     register char       * str1;
  85     register char       * str2;
  86     register int          len;
  87 {
  88     int                   len1;
  89     int                   len2;
  90     char                * rtn;
  91
  92     malloc_check_strn("strncat", str2, len);
  93
  94     malloc_checking = 1;
  95
  96     len2 = strlen(str2) + 1;
  97     len1 = strlen(str1);
  98
  99     malloc_checking = 0;
 100
 101
 102     if( (len+1) < len2 )
 103     {
 104         len1 += len + 1;
 105     }
 106     else
 107     {
 108         len1 += len2;
 109     }
 110     malloc_check_data("strncat", str1, len1);
 111
 112     rtn = str1;
 113
 114     while( *str1 )
 115     {
 116         str1++;
 117     }
 118
 119     while( len-- && ((*str1++ = *str2++) != '\0') )
 120     {
 121     }
 122
 123     if( ! len )
 124     {
 125         *str1 = '\0';
 126     }
 127
 128     return(rtn);
 129 }
 130
 131 int
 132 strcmp(str1,str2)
 133     register char       * str1;
 134     register char       * str2;
 135 {
 136     malloc_check_str("strcmp", str1);
 137     malloc_check_str("strcmp", str2);
 138
 139     while( *str1 && (*str1 == *str2) )
 140     {
 141         str1++;
 142         str2++;
 143     }
 144
 145
 146     /*
 147      * in order to deal with the case of a negative last char of either
 148      * string when the other string has a null
 149      */
 150     if( (*str2 == '\0') && (*str1 == '\0') )
 151     {
 152         return(0);
 153     }
 154     else if( *str2 == '\0' )
 155     {
 156         return(1);
 157     }
 158     else if( *str1 == '\0' )
 159     {
 160         return(-1);
 161     }
 162
 163     return( *str1 - *str2 );
 164 }
 165
 166 int
 167 strncmp(str1,str2,len)
 168     register char       * str1;
 169     register char       * str2;
 170     register int          len;
 171 {
 172     malloc_check_strn("strncmp", str1, len);
 173     malloc_check_strn("strncmp", str2, len);
 174
 175     while( --len >= 0 && *str1 && (*str1 == *str2) )
 176     {
 177         str1++;
 178         str2++;
 179     }
 180
 181     if( len < 0 )
 182     {
 183         return(0);
 184     }
 185     /*
 186      * in order to deal with the case of a negative last char of either
 187      * string when the other string has a null
 188      */
 189     if( (*str2 == '\0') && (*str1 == '\0') )
 190     {
 191         return(0);
 192     }
 193     else if( *str2 == '\0' )
 194     {
 195         return(1);
 196     }
 197     else if( *str1 == '\0' )
 198     {
 199         return(-1);
 200     }
 201
 202     return( *str1 - *str2 );
 203 }
 204
 205 char *
 206 strcpy(str1,str2)
 207     register char       * str1;
 208     register char       * str2;
 209 {
 210     char                * rtn;
 211     int           len;
 212
 213     malloc_checking = 1;
 214     len = strlen(str2) + 1;
 215     malloc_checking = 0;
 216
 217     malloc_check_data("strcpy", str1, len);
 218     malloc_check_data("strcpy", str2, len);
 219
 220     rtn = str1;
 221
 222     while( (*str1++ = *str2++) != '\0')
 223     {
 224     }
 225
 226     return(rtn);
 227 }
 228
 229 char *
 230 strncpy(str1,str2,len)
 231     register char       * str1;
 232     register char       * str2;
 233     register int          len;
 234 {
 235     extern int    malloc_checking;
 236     char                * rtn;
 237
 238     malloc_check_data("strncpy", str1, len);
 239     malloc_check_strn("strncpy", str2, len);
 240
 241     rtn = str1;
 242
 243     while((len-- > 0) && (*str1++ = *str2++) != '\0')
 244     {
 245     }
 246     while( (len-- > 0) )
 247     {
 248         *str1++ = '\0';
 249     }
 250
 251     return(rtn);
 252 }
 253
 254 int
 255 strlen(str1)
 256     register char       * str1;
 257 {
 258     register char       * s;
 259
 260     if(! malloc_checking )
 261     {
 262         malloc_check_str("strlen", str1);
 263     }
 264
 265     for( s = str1; *s; s++)
 266     {
 267     }
 268
 269     return( s - str1 );
 270 }
 271
 272 char *
 273 strchr(str1,c)
 274     register char       * str1;
 275     register int          c;
 276 {
 277     malloc_check_str("strchr", str1);
 278
 279     while( *str1 && (*str1 != (char) c) )
 280     {
 281         str1++;
 282     }
 283
 284     if(*str1 != (char) c)
 285     {
 286         str1 = (char *) 0;
 287     }
 288
 289     return(str1);
 290 }
 291
 292 char *
 293 strrchr(str1,c)
 294     register char       * str1;
 295     register int          c;
 296 {
 297     register char       * rtn = (char *) 0;
 298
 299     malloc_check_str("strrchr", str1);
 300
 301     while( *str1 )
 302     {
 303         if(*str1 == (char) c )
 304         {
 305             rtn = str1;
 306         }
 307         str1++;
 308     }
 309
 310     if( *str1 == (char) c)
 311     {
 312         rtn = str1;
 313     }
 314
 315     return(rtn);
 316 }
 317
 318 char *
 319 index(str1,c)
 320     char                * str1;
 321     char                  c;
 322 {
 323     return( strchr(str1,c) );
 324 }
 325
 326 char *
 327 rindex(str1,c)
 328     char                * str1;
 329     char                  c;
 330 {
 331     return( strrchr(str1,c) );
 332 }
 333
 334 char *
 335 strpbrk(str1,str2)
 336     register char       * str1;
 337     register char       * str2;
 338 {
 339     register char       * tmp;
 340
 341     malloc_check_str("strpbrk", str1);
 342     malloc_check_str("strpbrk", str2);
 343
 344     while(*str1)
 345     {
 346         for( tmp=str2; *tmp && *tmp != *str1; tmp++)
 347         {
 348         }
 349         if( *tmp )
 350         {
 351             break;
 352         }
 353         str1++;
 354     }
 355
 356     if( ! *str1 )
 357     {
 358         str1 = (char *) 0;
 359     }
 360
 361     return(str1);
 362 }
 363
 364 int
 365 strspn(str1,str2)
 366     register char       * str1;
 367     register char       * str2;
 368 {
 369     register char       * tmp;
 370     char                * orig = str1;
 371
 372     malloc_check_str("strspn", str1);
 373     malloc_check_str("strspn", str2);
 374
 375     while(*str1)
 376     {
 377         for( tmp=str2; *tmp && *tmp != *str1; tmp++)
 378         {
 379         }
 380         if(! *tmp )
 381         {
 382             break;
 383         }
 384         str1++;
 385     }
 386
 387     return( (int) (str1 - orig) );
 388 }
 389
 390 int
 391 strcspn(str1,str2)
 392     register char       * str1;
 393     register char       * str2;
 394 {
 395     register char       * tmp;
 396     char                * orig = str1;
 397
 398     malloc_check_str("strcspn", str1);
 399     malloc_check_str("strcspn", str2);
 400
 401     while(*str1)
 402     {
 403         for( tmp=str2; *tmp && *tmp != *str1; tmp++)
 404         {
 405         }
 406         if( *tmp )
 407         {
 408             break;
 409         }
 410         str1++;
 411     }
 412
 413     return( (int) (str1 - orig) );
 414 }
 415
 416 /*
 417  * strtok() source taken from that posted to comp.lang.c by Chris Torek
 418  * in Jan 1990.
 419  */
 420
 421 /*
 422  * Copyright (c) 1989 The Regents of the University of California.
 423  * All rights reserved.
 424  *
 425  * Redistribution and use in source and binary forms are permitted
 426  * provided that the above copyright notice and this paragraph are
 427  * duplicated in all such forms and that any documentation,
 428  * advertising materials, and other materials related to such
 429  * distribution and use acknowledge that the software was developed
 430  * by the University of California, Berkeley.  The name of the
 431  * University may not be used to endorse or promote products derived
 432  * from this software without specific prior written permission.
 433  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 434  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 435  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 436  */
 437
 438 /*
 439  * Get next token from string s (NULL on 2nd, 3rd, etc. calls),
 440  * where tokens are nonempty strings separated by runs of
 441  * chars from delim.  Writes NULs into s to end tokens.  delim need not
 442  * remain constant from call to call.
 443  *
 444  * Modified by cpc:     changed variable names to conform with naming
 445  *                      conventions used in rest of code.  Added malloc pointer
 446  *                      check calls.
 447  */
 448 char *
 449 strtok(str1, str2)
 450     char        * str1;
 451     char        * str2;
 452 {
 453     static char         * last;
 454     char                * strtoken();
 455
 456     if( str1 )
 457     {
 458         malloc_check_str("strtok", str1);
 459         last = str1;
 460     }
 461     malloc_check_str("strtok", str2);
 462
 463     return (strtoken(&last, str2, 1));
 464 }
 465
 466
 467 /*
 468  * Get next token from string *stringp, where tokens are (possibly empty)
 469  * strings separated by characters from delim.  Tokens are separated
 470  * by exactly one delimiter iff the skip parameter is false; otherwise
 471  * they are separated by runs of characters from delim, because we
 472  * skip over any initial `delim' characters.
 473  *
 474  * Writes NULs into the string at *stringp to end tokens.
 475  * delim will usually, but need not, remain constant from call to call.
 476  * On return, *stringp points past the last NUL written (if there might
 477  * be further tokens), or is NULL (if there are definitely no more tokens).
 478  *
 479  * If *stringp is NULL, strtoken returns NULL.
 480  */
 481 char *
 482 strtoken(stringp, delim, skip)
 483     register char **stringp;
 484     register char *delim;
 485     int skip;
 486 {
 487     register char *s;
 488     register char *spanp;
 489     register int c, sc;
 490     char *tok;
 491
 492     if ((s = *stringp) == NULL)
 493         return (NULL);
 494
 495     if (skip) {
 496         /*
 497          * Skip (span) leading delimiters (s += strspn(s, delim)).
 498          */
 499     cont:
 500         c = *s;
 501         for (spanp = delim; (sc = *spanp++) != 0;) {
 502             if (c == sc) {
 503                 s++;
 504                 goto cont;
 505             }
 506         }
 507         if (c == 0) {           /* no token found */
 508             *stringp = NULL;
 509             return (NULL);
 510         }
 511     }
 512
 513     /*
 514      * Scan token (scan for delimiters: s += strcspn(s, delim), sort of).
 515      * Note that delim must have one NUL; we stop if we see that, too.
 516      */
 517     for (tok = s;;) {
 518         c = *s++;
 519         spanp = delim;
 520         do {
 521             if ((sc = *spanp++) == c) {
 522                 if (c == 0)
 523                     s = NULL;
 524                 else
 525                     s[-1] = 0;
 526                 *stringp = s;
 527                 return (tok);
 528             }
 529         } while (sc != 0);
 530     }
 531     /* NOTREACHED */
 532 }
 533