Home | History | Annotate | Download | only in sh
      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 (the "License").
      6  * You may not use this file except in compliance with the License.
      7  *
      8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
      9  * or http://www.opensolaris.org/os/licensing.
     10  * See the License for the specific language governing permissions
     11  * and limitations under the License.
     12  *
     13  * When distributing Covered Code, include this CDDL HEADER in each
     14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
     15  * If applicable, add the following below this CDDL HEADER, with the
     16  * fields enclosed by brackets "[]" replaced with your own identifying
     17  * information: Portions Copyright [yyyy] [name of copyright owner]
     18  *
     19  * CDDL HEADER END
     20  */
     21 /*
     22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
     23  * Use is subject to license terms.
     24  */
     25 
     26 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
     27 /*	  All Rights Reserved  	*/
     28 
     29 #pragma ident	"%Z%%M%	%I%	%E% SMI"
     30 /*
     31  * UNIX shell
     32  */
     33 
     34 #include	"defs.h"
     35 
     36 
     37 /* ========	storage allocation	======== */
     38 
     39 unsigned char *
     40 getstak(asize)			/* allocate requested stack */
     41 int	asize;
     42 {
     43 	unsigned char	*oldstak;
     44 	int		size;
     45 
     46 	size = round(asize, BYTESPERWORD);
     47 	oldstak = stakbot;
     48 	staktop = stakbot += size;
     49 	if (staktop >= brkend)
     50 		growstak(staktop);
     51 	return(oldstak);
     52 }
     53 
     54 /*
     55  * set up stack for local use
     56  * should be followed by `endstak'
     57  */
     58 unsigned char *
     59 locstak()
     60 {
     61 	if (brkend - stakbot < BRKINCR)
     62 	{
     63 		if (setbrk(brkincr) == -1)
     64 			error(nostack);
     65 		if (brkincr < BRKMAX)
     66 			brkincr += 256;
     67 	}
     68 	return(stakbot);
     69 }
     70 
     71 void
     72 growstak(newtop)
     73 unsigned char	*newtop;
     74 {
     75 	unsigned	incr;
     76 
     77 	incr = (unsigned)round(newtop - brkend + 1, BYTESPERWORD);
     78 	if (brkincr > incr)
     79 		incr = brkincr;
     80 	if (setbrk(incr) == -1)
     81 		error(nospace);
     82 }
     83 
     84 unsigned char *
     85 savstak()
     86 {
     87 	assert(staktop == stakbot);
     88 	return(stakbot);
     89 }
     90 
     91 unsigned char *
     92 endstak(unsigned char *argp)		/* tidy up after `locstak' */
     93 {
     94 	unsigned char	*oldstak;
     95 
     96 	if (argp >= brkend)
     97 		growstak(argp);
     98 	*argp++ = 0;
     99 	oldstak = stakbot;
    100 	stakbot = staktop = (unsigned char *)round(argp, BYTESPERWORD);
    101 	if (staktop >= brkend)
    102 		growstak(staktop);
    103 	return(oldstak);
    104 }
    105 
    106 void
    107 tdystak(unsigned char	*x)		/* try to bring stack back to x */
    108 {
    109 	struct blk *next;
    110 
    111 	while ((unsigned char *)stakbsy > x)
    112 	{
    113 		next = stakbsy->word;
    114 		free(stakbsy);
    115 		stakbsy = next;
    116 	}
    117 	staktop = stakbot = max(x, stakbas);
    118 	rmtemp(x);
    119 }
    120 
    121 void
    122 stakchk(void)
    123 {
    124 	if ((brkend - stakbas) > BRKINCR + BRKINCR)
    125 		setbrk(-BRKINCR);
    126 }
    127 
    128 unsigned char *
    129 cpystak(x)
    130 unsigned char	*x;
    131 {
    132 	return(endstak(movstrstak(x, locstak())));
    133 }
    134 
    135 unsigned char *
    136 movstrstak(unsigned char *a, unsigned char *b)
    137 {
    138 	do
    139 	{
    140 		if (b >= brkend)
    141 			growstak(b);
    142 	}
    143 	while (*b++ = *a++);
    144 	return(--b);
    145 }
    146 
    147 /*
    148  * Copy s2 to s1, always copy n bytes.
    149  * Return s1
    150  */
    151 unsigned char *
    152 memcpystak(unsigned char *s1, unsigned char *s2, int n)
    153 {
    154 	unsigned char *os1 = s1;
    155 
    156 	while (--n >= 0) {
    157 		if (s1 >= brkend)
    158 			growstak(s1);
    159 		*s1++ = *s2++;
    160 	}
    161 	return (os1);
    162 }
    163