dmake/dbug/malloc/memory.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 #ifndef lint
   8 static
   9 char rcs_hdr[] = "$Id: memory.c,v 1.2 2006-07-25 10:09:19 rt Exp $";
  10 #endif
  11
  12 void malloc_check_data();
  13
  14 char *
  15 memccpy(ptr1, ptr2, ch, len)
  16     register char       * ptr1;
  17     register char       * ptr2;
  18     int           len;
  19     int           ch;
  20 {
  21     int           check;
  22     register int          i;
  23     char                * rtn;
  24
  25     /*
  26      * I know that the assignment could be done in the following, but
  27      * I wanted to perform a check before any assignment, so first I
  28      * determine the length, check the pointers and then do the assignment.
  29      */
  30     for( i=0; (i < len) && (ptr2[i] != ch); i++)
  31     {
  32     }
  33     if( ptr2[i] == ch )
  34     {
  35         check = i+1;
  36     }
  37     else
  38     {
  39         check = len;
  40     }
  41
  42     malloc_check_data("memccpy", ptr1, check);
  43     malloc_check_data("memccpy", ptr2, check);
  44
  45     /*
  46      * if we found the character...
  47       */
  48
  49     if( i < len )
  50     {
  51         rtn = ptr1+i+1;
  52         i++;
  53     }
  54     else
  55     {
  56         rtn = (char *) 0;
  57     }
  58
  59      while( i-- )
  60     {
  61         *(ptr1++) = *(ptr2++);
  62     }
  63
  64     return(rtn);
  65 }
  66
  67 char *
  68 memchr(ptr1,ch,len)
  69     register char       * ptr1;
  70     register int          ch;
  71     int           len;
  72 {
  73     int           i;
  74
  75     for( i=0; (i < len) && (ptr1[i] != (char) ch); i++)
  76     {
  77     }
  78
  79     malloc_check_data("memchr", ptr1, i);
  80
  81     if( i < len )
  82     {
  83         return( ptr1+i );
  84     }
  85     else
  86     {
  87         return( (char *) 0);
  88     }
  89 }
  90
  91 char *
  92 memcpy(ptr1, ptr2, len)
  93     register char       * ptr1;
  94     register char       * ptr2;
  95     register int          len;
  96 {
  97     char                * rtn = ptr1;
  98
  99     malloc_check_data("memcpy", ptr1, len);
 100     malloc_check_data("memcpy", ptr2, len);
 101
 102     /*
 103      * while the normal memcpy does not guarrantee that it will
 104      * handle overlapping memory correctly, we will try...
 105      */
 106     if( ptr1 > ptr2  && ptr1 < (ptr2+len))
 107     {
 108         ptr1 += (len-1);
 109         ptr2 += (len-1);
 110         while( len-- > 0 )
 111         {
 112             *(ptr1--) = *(ptr2--);
 113         }
 114     }
 115     else
 116     {
 117         while( len-- > 0 )
 118         {
 119             *(ptr1++) = *(ptr2++);
 120         }
 121     }
 122
 123     return(rtn);
 124 }
 125
 126 int
 127 memcmp(ptr1, ptr2, len)
 128     register char       * ptr1;
 129     register char       * ptr2;
 130     register int          len;
 131 {
 132     malloc_check_data("memcpy", ptr1, len);
 133     malloc_check_data("memcpy", ptr2, len);
 134
 135     while( --len >= 0  && (*ptr1 == *ptr2) )
 136     {
 137         ptr1++;
 138         ptr2++;
 139     }
 140
 141     /*
 142      * If stopped by len, return zero
 143      */
 144     if( len < 0 )
 145     {
 146         return(0);
 147     }
 148
 149     return( *ptr1 - *ptr2 );
 150 }
 151
 152 char *
 153 memset(ptr1, ch, len)
 154     register char       * ptr1;
 155     register int          ch;
 156     register int          len;
 157 {
 158     char                * rtn = ptr1;
 159
 160     malloc_check_data("memcpy", ptr1, len);
 161
 162     while( len-- )
 163     {
 164         *(ptr1++) = ch;
 165     }
 166
 167     return(rtn);
 168 }
 169
 170 char *
 171 bcopy(ptr2,ptr1,len)
 172     char                * ptr2;
 173     char                * ptr1;
 174     int           len;
 175 {
 176     return(memcpy(ptr1,ptr2,len));
 177 }
 178
 179 char *
 180 bzero(ptr1,len)
 181     char                * ptr1;
 182     int           len;
 183 {
 184     return(memset(ptr1,'\0',len));
 185 }
 186
 187 int
 188 bcmp(ptr2, ptr1, len)
 189     char                * ptr1;
 190     char                * ptr2;
 191     int           len;
 192 {
 193     return( memcmp(ptr1,ptr2,len) );
 194 }
 195