usr/src/cmd/mailx/stralloc.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22
  23 /*
  24  * Copyright 1997 Sun Microsystems, Inc.  All rights reserved.
  25  * Use is subject to license terms.
  26  */
  27
  28 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  29 /*        All Rights Reserved   */
  30
  31
  32 /*
  33  * University Copyright- Copyright (c) 1982, 1986, 1988
  34  * The Regents of the University of California
  35  * All Rights Reserved
  36  *
  37  * University Acknowledgment- Portions of this document are derived from
  38  * software developed by the University of California, Berkeley, and its
  39  * contributors.
  40  */
  41
  42 #pragma ident   "%Z%%M% %I%     %E% SMI"
  43
  44 /*
  45  * mailx -- a modified version of a University of California at Berkeley
  46  *      mail program
  47  *
  48  * Memory allocation routines.
  49  * Memory handed out here are reclaimed at the top of the command
  50  * loop each time, so they need not be freed.
  51  */
  52
  53 #include "rcv.h"
  54 #include <locale.h>
  55
  56 static void             *lastptr;       /* addr of last buffer allocated */
  57 static struct strings   *lastsp;        /* last string space allocated from */
  58
  59 /*
  60  * Allocate size more bytes of space and return the address of the
  61  * first byte to the caller.  An even number of bytes are always
  62  * allocated so that the space will always be on a word boundary.
  63  * The string spaces are of exponentially increasing size, to satisfy
  64  * the occasional user with enormous string size requests.
  65  */
  66
  67 void *
  68 salloc(unsigned size)
  69 {
  70         register char *t;
  71         register unsigned s;
  72         register struct strings *sp;
  73         int index;
  74
  75         s = size;
  76 #if defined(u3b) || defined(sparc)
  77         s += 3;         /* needs alignment on quad boundary */
  78         s &= ~03;
  79 #elif defined(i386)
  80         s++;
  81         s &= ~01;
  82 #else
  83 #error Unknown architecture!
  84 #endif
  85         index = 0;
  86         for (sp = &stringdope[0]; sp < &stringdope[NSPACE]; sp++) {
  87                 if (sp->s_topFree == NOSTR && (STRINGSIZE << index) >= s)
  88                         break;
  89                 if (sp->s_nleft >= s)
  90                         break;
  91                 index++;
  92         }
  93         if (sp >= &stringdope[NSPACE])
  94                 panic("String too large");
  95         if (sp->s_topFree == NOSTR) {
  96                 index = sp - &stringdope[0];
  97                 sp->s_topFree = (char *) calloc(STRINGSIZE << index,
  98                     (unsigned) 1);
  99                 if (sp->s_topFree == NOSTR) {
 100                         fprintf(stderr, gettext("No room for space %d\n"),
 101                             index);
 102                         panic("Internal error");
 103                 }
 104                 sp->s_nextFree = sp->s_topFree;
 105                 sp->s_nleft = STRINGSIZE << index;
 106         }
 107         sp->s_nleft -= s;
 108         t = sp->s_nextFree;
 109         sp->s_nextFree += s;
 110         lastptr = t;
 111         lastsp = sp;
 112         return(t);
 113 }
 114
 115 /*
 116  * Reallocate size bytes of space and return the address of the
 117  * first byte to the caller.  The old data is copied into the new area.
 118  */
 119
 120 void *
 121 srealloc(void *optr, unsigned size)
 122 {
 123         void *nptr;
 124
 125         /* if we just want to expand the last allocation, that's easy */
 126         if (optr == lastptr) {
 127                 register unsigned s, delta;
 128                 register struct strings *sp = lastsp;
 129
 130                 s = size;
 131 #if defined(u3b) || defined(sparc)
 132                 s += 3;         /* needs alignment on quad boundary */
 133                 s &= ~03;
 134 #elif defined(i386)
 135                 s++;
 136                 s &= ~01;
 137 #else
 138 #error Unknown architecture!
 139 #endif /* defined(u3b) || defined(sparc) */
 140                 delta = s - (sp->s_nextFree - (char *)optr);
 141                 if (delta <= sp->s_nleft) {
 142                         sp->s_nextFree += delta;
 143                         sp->s_nleft -= delta;
 144                         return (optr);
 145                 }
 146         }
 147         nptr = salloc(size);
 148         if (nptr)
 149                 memcpy(nptr, optr, size);       /* XXX - copying too much */
 150         return nptr;
 151 }
 152
 153 /*
 154  * Reset the string area to be empty.
 155  * Called to free all strings allocated
 156  * since last reset.
 157  */
 158 void
 159 sreset(void)
 160 {
 161         register struct strings *sp;
 162         register int index;
 163
 164         if (noreset)
 165                 return;
 166         minit();
 167         index = 0;
 168         for (sp = &stringdope[0]; sp < &stringdope[NSPACE]; sp++) {
 169                 if (sp->s_topFree == NOSTR)
 170                         continue;
 171                 sp->s_nextFree = sp->s_topFree;
 172                 sp->s_nleft = STRINGSIZE << index;
 173                 index++;
 174         }
 175         lastptr = NULL;
 176         lastsp = NULL;
 177 }