hbase

dc.c (35168B)

---

 /*	from 4.4BSD /usr/src/usr.bin/dc/dc.c	*/
 /*-
  * Copyright (c) 1991, 1993
  *	The Regents of the University of California.  All rights reserved.
  *
  * This module is believed to contain source code proprietary to AT&T.
  * Use and redistribution is subject to the Berkeley Software License
  * Agreement and your Software Agreement with AT&T (Western Electric).
  *
  *	from dc.c	8.1 (Berkeley) 6/6/93"
  */
 /*
  * Copyright(C) Caldera International Inc. 2001-2002. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *   Redistributions of source code and documentation must retain the
  *    above copyright notice, this list of conditions and the following
  *    disclaimer.
  *   Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *   All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *      This product includes software developed or owned by Caldera
  *      International, Inc.
  *   Neither the name of Caldera International, Inc. nor the names of
  *    other contributors may be used to endorse or promote products
  *    derived from this software without specific prior written permission.
  *
  * USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
  * INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE
  * LIABLE FOR ANY DIRECT, INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /*	Sccsid @(#)dc.c	1.21 (gritter) 12/25/06>	*/
 
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <signal.h>
 #include "sigset.h"
 #include <stdlib.h>
 #include <inttypes.h>
 #include <limits.h>
 
 #include "dc.h"
 
 int
 main(int argc,char **argv)
 {
 	init(argc,argv);
 	commnds();
 	/*NOTREACHED*/
 	return(0);
 }
 
 void
 commnds(void){
 	register int c;
 	register struct blk *p,*q;
 	long l;
 	int sign;
 	struct blk **ptr,*s,*t;
 	struct sym *sp;
 	int sk,sk1,sk2;
 	int n,d;
 
 	while(1){
 		if(((c = readc())>='0' && c <= '9')|| (c>='A' && c <='F') || c == '.'){
 			unreadc(c);
 			p = readin();
 			pushp(p);
 			continue;
 		}
 		switch(c){
 		case ' ':
 		case '\n':
 		case 0377:
 		case EOF:
 			continue;
 		case 'Y':
 			sdump("stk",*stkptr);
 			printf("all %ld rel %ld headmor %ld\n",all,rel,headmor);
 			printf("nbytes %ld\n",nbytes);
 			continue;
 		case '_':
 			p = readin();
 			savk = sunputc(p);
 			chsign(p);
 			sputc(p,savk);
 			pushp(p);
 			continue;
 		case '-':
 			subt();
 			continue;
 		case '+':
 			if(eqk() != 0)continue;
 			binop('+');
 			continue;
 		case '*':
 			arg1 = pop();
 			EMPTY;
 			arg2 = pop();
 			EMPTYR(arg1);
 			sk1 = sunputc(arg1);
 			sk2 = sunputc(arg2);
 			binop('*');
 			p = pop();
 			sunputc(p);
 			savk = n = sk1+sk2;
 			if(n>k && n>sk1 && n>sk2){
 				sk = sk1;
 				if(sk<sk2)sk = sk2;
 				if(sk<k)sk = k;
 				p = removc(p,n-sk);
 				savk = sk;
 			}
 			sputc(p,savk);
 			pushp(p);
 			continue;
 		case '/':
 casediv:
 			if(dscale() != 0)continue;
 			binop('/');
 			if(irem != 0)release(irem);
 			release(rem);
 			continue;
 		case '%':
 			if(dscale() != 0)continue;
 			binop('/');
 			p = pop();
 			release(p);
 			if(irem == 0){
 				sputc(rem,skr+k);
 				pushp(rem);
 				continue;
 			}
 			p = add0(rem,skd-(skr+k));
 			q = add(p,irem);
 			release(p);
 			release(irem);
 			sputc(q,skd);
 			pushp(q);
 			continue;
 		case 'v':
 			p = pop();
 			EMPTY;
 			savk = sunputc(p);
 			if(length(p) == 0){
 				sputc(p,savk);
 				pushp(p);
 				continue;
 			}
 			if((c = sbackc(p))<0){
 				error("sqrt of neg number\n");
 			}
 			if(k<savk)n = savk;
 			else{
 				n = k*2-savk;
 				savk = k;
 			}
 			arg1 = add0(p,n);
 			arg2 = dcsqrt(arg1);
 			sputc(arg2,savk);
 			pushp(arg2);
 			continue;
 		case '^':
 			neg = 0;
 			arg1 = pop();
 			EMPTY;
 			if(sunputc(arg1) != 0)error("exp not an integer\n");
 			arg2 = pop();
 			EMPTYR(arg1);
 			if(sfbeg(arg1) == 0 && sbackc(arg1)<0){
 				neg++;
 				chsign(arg1);
 			}
 			if(length(arg1)>=3){
 				error("exp too big\n");
 			}
 			savk = sunputc(arg2);
 			p = dcexp(arg2,arg1);
 			release(arg2);
 			rewind(arg1);
 			c = sgetc(arg1);
 			if(sfeof(arg1) == 0)
 				c = sgetc(arg1)*100 + c;
 			d = c*savk;
 			release(arg1);
 			if(neg == 0){
 				if(k>=savk)n = k;
 				else n = savk;
 				if(n<d){
 					q = removc(p,d-n);
 					sputc(q,n);
 					pushp(q);
 				}
 				else {
 					sputc(p,d);
 					pushp(p);
 				}
 			}
 			else {
 				sputc(p,d);
 				pushp(p);
 			}
 			if(neg == 0)continue;
 			p = pop();
 			q = salloc(2);
 			sputc(q,1);
 			sputc(q,0);
 			pushp(q);
 			pushp(p);
 			goto casediv;
 		case 'z':
 			p = salloc(2);
 			n = stkptr - stkbeg;
 			if(n >= 100){
 				sputc(p,n/100);
 				n %= 100;
 			}
 			sputc(p,n);
 			sputc(p,0);
 			pushp(p);
 			continue;
 		case 'Z':
 			p = pop();
 			EMPTY;
 			n = (length(p)-1)<<1;
 			fsfile(p);
 			sbackc(p);
 			if(sfbeg(p) == 0){
 				if((c = sbackc(p))<0){
 					n -= 2;
 					if(sfbeg(p) == 1)n += 1;
 					else {
 						if((c = sbackc(p)) == 0)n += 1;
 						else if(c > 90)n -= 1;
 					}
 				}
 				else if(c < 10) n -= 1;
 			}
 			release(p);
 			q = salloc(1);
 			if(n >= 100){
 				sputc(q,n%100);
 				n /= 100;
 			}
 			sputc(q,n);
 			sputc(q,0);
 			pushp(q);
 			continue;
 		case 'i':
 			p = pop();
 			EMPTY;
 			p = scalint(p);
 			release(inbas);
 			inbas = p;
 			continue;
 		case 'I':
 			p = copy(inbas,length(inbas)+1);
 			sputc(p,0);
 			pushp(p);
 			continue;
 		case 'o':
 			p = pop();
 			EMPTY;
 			p = scalint(p);
 			sign = 0;
 			n = length(p);
 			q = copy(p,n);
 			fsfile(q);
 			l = c = sbackc(q);
 			if(n != 1){
 				if(c<0){
 					sign = 1;
 					chsign(q);
 					n = length(q);
 					fsfile(q);
 					l = c = sbackc(q);
 				}
 				if(n != 1){
 					while(sfbeg(q) == 0)l = l*100+sbackc(q);
 				}
 			}
 			if (l > BC_BASE_MAX)
 				error("output base is too large\n");
 			logo = log_2(l);
 			obase = l;
 			release(basptr);
 			if(sign == 1)obase = (long)-l;
 			basptr = p;
 			outdit = (int (*)(struct blk *, int, int))bigot;
 			if(n == 1 && sign == 0){
 				if(c <= 16){
 					outdit = (int (*)(struct blk *, int, int))hexot;
 					fw = 1;
 					fw1 = 0;
 					ll = 68;
 					release(q);
 					continue;
 				}
 			}
 			n = 0;
 			if(sign == 1)n++;
 			p = salloc(1);
 			sputc(p,-1);
 			t = add(p,q);
 			n += length(t)*2;
 			fsfile(t);
 			if((c = sbackc(t))>9)n++;
 			release(t);
 			release(q);
 			release(p);
 			fw = n;
 			fw1 = n-1;
 			ll = 68;
 			if(fw>=ll)continue;
 			ll = (68/fw)*fw;
 			continue;
 		case 'O':
 			p = copy(basptr,length(basptr)+1);
 			sputc(p,0);
 			pushp(p);
 			continue;
 		case '[':
 			n = 0;
 			p = salloc(0);
 			while(1){
 				if((c = readc()) == ']'){
 					if(n == 0)break;
 					n--;
 				}
 				sputc(p,c);
 				if(c == '[')n++;
 			}
 			pushp(p);
 			continue;
 		case 'k':
 			p = pop();
 			EMPTY;
 			p = scalint(p);
 			if(length(p)>1){
 				error("scale too big\n");
 			}
 			rewind(p);
 			k = sfeof(p)?0:sgetc(p);
 			release(scalptr);
 			scalptr = p;
 			continue;
 		case 'K':
 			p = copy(scalptr,length(scalptr)+1);
 			sputc(p,0);
 			pushp(p);
 			continue;
 		case 'X':
 			p = pop();
 			EMPTY;
 			fsfile(p);
 			n = sbackc(p);
 			release(p);
 			p = salloc(2);
 			sputc(p,n);
 			sputc(p,0);
 			pushp(p);
 			continue;
 		case 'Q':
 			p = pop();
 			EMPTY;
 			if(length(p)>2){
 				error("Q?\n");
 			}
 			rewind(p);
 			if((c =  sgetc(p))<0){
 				error("neg Q\n");
 			}
 			release(p);
 			while(c-- > 0){
 				if(readptr == &readstk[0]){
 					error("readstk?\n");
 				}
 				if(*readptr != 0)release(*readptr);
 				readptr--;
 			}
 			continue;
 		case 'q':
 			if(readptr <= &readstk[1])exit(0);
 			if(*readptr != 0)release(*readptr);
 			readptr--;
 			if(*readptr != 0)release(*readptr);
 			readptr--;
 			continue;
 		case 'f':
 			if(stkptr == &stack[0])printf("empty stack\n");
 			else {
 				for(ptr = stkptr; ptr > &stack[0];){
 					print(*ptr--);
 				}
 			}
 			continue;
 		case 'p':
 			if(stkptr == &stack[0])printf("empty stack\n");
 			else{
 				print(*stkptr);
 			}
 			continue;
 		case 'P':
 			p = pop();
 			EMPTY;
 			sputc(p,0);
 			printf("%s",p->beg);
 			release(p);
 			continue;
 		case 'd':
 			if(stkptr == &stack[0]){
 				printf("empty stack\n");
 				continue;
 			}
 			q = *stkptr;
 			n = length(q);
 			p = copy(*stkptr,n);
 			pushp(p);
 			continue;
 		case 'c':
 			while(stkerr == 0){
 				p = pop();
 				if(stkerr == 0)release(p);
 			}
 			continue;
 		case 'S':
 			if(stkptr == &stack[0]){
 				error("save: args\n");
 			}
 			c = readc() & 0377;
 			sptr = stable[c];
 			sp = stable[c] = sfree;
 			sfree = sfree->next;
 			if(sfree == 0)goto sempty;
 			sp->next = sptr;
 			p = pop();
 			EMPTY;
 			if(c >= ARRAYST){
 				q = copy(p,length(p));
 				for(n = 0;n < PTRSZ;n++)sputc(q,0);
 				release(p);
 				p = q;
 			}
 			sp->val = p;
 			continue;
 sempty:
 			error("symbol table overflow\n");
 		case 's':
 			if(stkptr == &stack[0]){
 				error("save:args\n");
 			}
 			c = readc() & 0377;
 			sptr = stable[c];
 			if(sptr != 0){
 				p = sptr->val;
 				if(c >= ARRAYST){
 					rewind(p);
 					while(sfeof(p) == 0)release(dcgetwd(p));
 				}
 				release(p);
 			}
 			else{
 				sptr = stable[c] = sfree;
 				sfree = sfree->next;
 				if(sfree == 0)goto sempty;
 				sptr->next = 0;
 			}
 			p = pop();
 			sptr->val = p;
 			continue;
 		case 'l':
 			load();
 			continue;
 		case 'L':
 			c = readc() & 0377;
 			sptr = stable[c];
 			if(sptr == 0){
 				error("L?\n");
 			}
 			stable[c] = sptr->next;
 			sptr->next = sfree;
 			sfree = sptr;
 			p = sptr->val;
 			if(c >= ARRAYST){
 				rewind(p);
 				while(sfeof(p) == 0){
 					q = dcgetwd(p);
 					if(q != 0)release(q);
 				}
 			}
 			pushp(p);
 			continue;
 		case ':':
 			p = pop();
 			EMPTY;
 			q = scalint(p);
 			fsfile(q);
 			c = 0;
 			if((sfbeg(q) == 0) && ((c = sbackc(q))<0)){
 				error("neg index\n");
 			}
 			if(length(q)>2){
 				error("index too big\n");
 			}
 			if(sfbeg(q) == 0)c = c*100+sbackc(q);
 			if(c >= BC_DIM_MAX){
 				error("index too big\n");
 			}
 			release(q);
 			n = readc() & 0377;
 			sptr = stable[n];
 			if(sptr == 0){
 				sptr = stable[n] = sfree;
 				sfree = sfree->next;
 				if(sfree == 0)goto sempty;
 				sptr->next = 0;
 				p = salloc((c+PTRSZ)*PTRSZ);
 				zero(p);
 			}
 			else{
 				p = sptr->val;
 				if(length(p)-PTRSZ < c*PTRSZ){
 					q = copy(p,(c+PTRSZ)*PTRSZ);
 					release(p);
 					p = q;
 				}
 			}
 			seekc(p,c*PTRSZ);
 			q = lookwd(p);
 			if (q!=NULL) release(q);
 			s = pop();
 			EMPTY;
 			salterwd((struct wblk *)p,s);
 			sptr->val = p;
 			continue;
 		case ';':
 			p = pop();
 			EMPTY;
 			q = scalint(p);
 			fsfile(q);
 			c = 0;
 			if((sfbeg(q) == 0) && ((c = sbackc(q))<0)){
 				error("neg index\n");
 			}
 			if(length(q)>2){
 				error("index too big\n");
 			}
 			if(sfbeg(q) == 0)c = c*100+sbackc(q);
 			if(c >= BC_DIM_MAX){
 				error("index too big\n");
 			}
 			release(q);
 			n = readc() & 0377;
 			sptr = stable[n];
 			if(sptr != 0){
 				p = sptr->val;
 				if(length(p)-PTRSZ >= c*PTRSZ){
 					seekc(p,c*PTRSZ);
 					s = dcgetwd(p);
 					if(s != 0){
 						q = copy(s,length(s));
 						pushp(q);
 						continue;
 					}
 				}
 			}
 			q = salloc(1);
 			sputc(q, 0);
 			pushp(q);
 			continue;
 		case 'x':
 execute:
 			p = pop();
 			EMPTY;
 			if((readptr != &readstk[0]) && (*readptr != 0)){
 				if((*readptr)->rd == (*readptr)->wt)
 					release(*readptr);
 				else{
 					if(readptr++ == &readstk[RDSKSZ]){
 						error("nesting depth\n");
 					}
 				}
 			}
 			else readptr++;
 			*readptr = p;
 			if(p != 0)rewind(p);
 			else{
 				if((c = readc()) != '\n')unreadc(c);
 			}
 			continue;
 		case '?':
 			if(++readptr == &readstk[RDSKSZ]){
 				error("nesting depth\n");
 			}
 			*readptr = 0;
 			fsave = curfile;
 			curfile = stdin;
 			while((c = readc()) == '!')command();
 			p = salloc(0);
 			sputc(p,c);
 			while((c = readc()) != '\n'){
 				sputc(p,c);
 				if(c == '\\')sputc(p,readc());
 			}
 			curfile = fsave;
 			*readptr = p;
 			continue;
 		case '!':
 			if(command() == 1)goto execute;
 			continue;
 		case '<':
 		case '>':
 		case '=':
 			if(cond(c) == 1)goto execute;
 			continue;
 		default:
 			printf("%o is unimplemented\n",c);
 		}
 	}
 }
 
 struct blk *
 div(struct blk *ddivd,struct blk *ddivr)
 {
 	int divsign,remsign,offset,divcarry = 0;
 	int carry, dig = 0,magic,d = 0,dd;
 	long c,td,cc;
 	struct blk *ps;
 	register struct blk *p,*divd,*divr;
 
 	rem = 0;
 	p = salloc(0);
 	if(length(ddivr) == 0){
 		pushp(ddivr);
 		printf("divide by 0\n");
 		return NULL;
 	}
 	divsign = remsign = 0;
 	divr = ddivr;
 	fsfile(divr);
 	if(sbackc(divr) == -1){
 		divr = copy(ddivr,length(ddivr));
 		chsign(divr);
 		divsign = ~divsign;
 	}
 	divd = copy(ddivd,length(ddivd));
 	fsfile(divd);
 	if(sfbeg(divd) == 0 && sbackc(divd) == -1){
 		chsign(divd);
 		divsign = ~divsign;
 		remsign = ~remsign;
 	}
 	offset = length(divd) - length(divr);
 	if(offset < 0)goto ddone;
 	seekc(p,offset+1);
 	sputc(divd,0);
 	magic = 0;
 	fsfile(divr);
 	c = sbackc(divr);
 	if(c<10)magic++;
 	c = c*100 + (sfbeg(divr)?0:sbackc(divr));
 	if(magic>0){
 		c = (c*100 +(sfbeg(divr)?0:sbackc(divr)))*2;
 		c /= 25;
 	}
 	while(offset >= 0){
 		fsfile(divd);
 		td = sbackc(divd)*100;
 		dd = sfbeg(divd)?0:sbackc(divd);
 		td = (td+dd)*100;
 		dd = sfbeg(divd)?0:sbackc(divd);
 		td = td+dd;
 		cc = c;
 		if(offset == 0)td += 1;
 		else cc += 1;
 		if(magic != 0)td = td<<3;
 		dig = td/cc;
 		rewind(divr);
 		rewind(divxyz);
 		carry = 0;
 		while(sfeof(divr) == 0){
 			d = sgetc(divr)*dig+carry;
 			carry = d / 100;
 			salterc(divxyz,d%100);
 		}
 		salterc(divxyz,carry);
 		rewind(divxyz);
 		seekc(divd,offset);
 		carry = 0;
 		while(sfeof(divd) == 0){
 			d = slookc(divd);
 			d = d-(sfeof(divxyz)?0:sgetc(divxyz))-carry;
 			carry = 0;
 			if(d < 0){
 				d += 100;
 				carry = 1;
 			}
 			salterc(divd,d);
 		}
 		divcarry = carry;
 		sbackc(p);
 		salterc(p,dig);
 		sbackc(p);
 		if(--offset >= 0){
 			if(d > 0){
 				sbackc(divd);
 				dd=sbackc(divd);
 				salterc(divd,dd+100);
 			}
 			divd->wt--;
 		}
 	}
 	if(divcarry != 0){
 		salterc(p,dig-1);
 		salterc(divd,-1);
 		ps = add(divr,divd);
 		release(divd);
 		divd = ps;
 	}
 
 	rewind(p);
 	divcarry = 0;
 	while(sfeof(p) == 0){
 		d = slookc(p)+divcarry;
 		divcarry = 0;
 		if(d >= 100){
 			d -= 100;
 			divcarry = 1;
 		}
 		salterc(p,d);
 	}
 	if(divcarry != 0)salterc(p,divcarry);
 	fsfile(p);
 	while(sfbeg(p) == 0){
 		if(sbackc(p) == 0)truncate(p);
 		else break;
 	}
 	if(divsign < 0)chsign(p);
 	fsfile(divd);
 	while(sfbeg(divd) == 0){
 		if(sbackc(divd) == 0)truncate(divd);
 		else break;
 	}
 ddone:
 	if(remsign<0)chsign(divd);
 	if(divr != ddivr)release(divr);
 	rem = divd;
 	return(p);
 }
 
 int
 dscale(void){
 	register struct blk *dd,*dr;
 	register struct blk *r;
 	int c;
 
 	dr = pop();
 	EMPTYS;
 	dd = pop();
 	EMPTYSR(dr);
 	fsfile(dd);
 	skd = sunputc(dd);
 	fsfile(dr);
 	skr = sunputc(dr);
 	if(sfbeg(dr) == 1 || (sfbeg(dr) == 0 && sbackc(dr) == 0)){
 		sputc(dr,skr);
 		pushp(dr);
 		errorrt("divide by 0\n");
 	}
 	c = k-skd+skr;
 	if(c < 0)r = removr(dd,-c);
 	else {
 		r = add0(dd,c);
 		irem = 0;
 	}
 	arg1 = r;
 	arg2 = dr;
 	savk = k;
 	return(0);
 }
 
 struct blk *
 removr(struct blk *p,int n)
 {
 	int nn;
 	register struct blk *q,*s,*r;
 
 	rewind(p);
 	nn = (n+1)/2;
 	q = salloc(nn);
 	while(n>1){
 		sputc(q,sgetc(p));
 		n -= 2;
 	}
 	r = salloc(2);
 	while(sfeof(p) == 0)sputc(r,sgetc(p));
 	release(p);
 	if(n == 1){
 		s = dcdiv(r,tenptr);
 		release(r);
 		rewind(rem);
 		if(sfeof(rem) == 0)sputc(q,sgetc(rem));
 		release(rem);
 		irem = q;
 		return(s);
 	}
 	irem = q;
 	return(r);
 }
 
 struct blk *
 sqrt(struct blk *p)
 {
 	struct blk *t;
 	struct blk *r,*q,*s;
 	int c,n,nn;
 
 	n = length(p);
 	fsfile(p);
 	c = sbackc(p);
 	if((n&1) != 1)c = c*100+(sfbeg(p)?0:sbackc(p));
 	n = (n+1)>>1;
 	r = salloc(n);
 	zero(r);
 	seekc(r,n);
 	nn=1;
 	while((c -= nn)>=0)nn+=2;
 	c=(nn+1)>>1;
 	fsfile(r);
 	sbackc(r);
 	if(c>=100){
 		c -= 100;
 		salterc(r,c);
 		sputc(r,1);
 	}
 	else salterc(r,c);
 	while(1){
 		q = dcdiv(p,r);
 		s = add(q,r);
 		release(q);
 		release(rem);
 		q = dcdiv(s,sqtemp);
 		release(s);
 		release(rem);
 		s = copy(r,length(r));
 		chsign(s);
 		t = add(s,q);
 		release(s);
 		fsfile(t);
 		nn = sfbeg(t)?0:sbackc(t);
 		if(nn>=0)break;
 		release(r);
 		release(t);
 		r = q;
 	}
 	release(t);
 	release(q);
 	release(p);
 	return(r);
 }
 
 struct blk *
 exp(struct blk *base,struct blk *ex)
 {
 	register struct blk *r,*e,*p;
 	struct blk *e1,*t,*cp;
 	int temp,c,n;
 	r = salloc(1);
 	sputc(r,1);
 	p = copy(base,length(base));
 	e = copy(ex,length(ex));
 	fsfile(e);
 	if(sfbeg(e) != 0)goto edone;
 	temp=0;
 	c = sbackc(e);
 	if(c<0){
 		temp++;
 		chsign(e);
 	}
 	while(length(e) != 0){
 		e1=dcdiv(e,sqtemp);
 		release(e);
 		e = e1;
 		n = length(rem);
 		release(rem);
 		if(n != 0){
 			e1=mult(p,r);
 			release(r);
 			r = e1;
 		}
 		t = copy(p,length(p));
 		cp = mult(p,t);
 		release(p);
 		release(t);
 		p = cp;
 	}
 	if(temp != 0){
 		if((c = length(base)) == 0){
 			goto edone;
 		}
 		if(c>1)create(r);
 		else{
 			rewind(base);
 			if((c = sgetc(base))<=1){
 				create(r);
 				sputc(r,c);
 			}
 			else create(r);
 		}
 	}
 edone:
 	release(p);
 	release(e);
 	return(r);
 }
 
 void
 init(int argc,char **argv)
 {
 	register struct sym *sp;
 
 	if (sigset(SIGINT, SIG_IGN) != SIG_IGN)
 		sigset(SIGINT,onintr);
 	setbuf(stdout,(char *)NULL);
 	svargc = --argc;
 	svargv = argv;
 	while(svargc>0 && svargv[1][0] == '-'){
 		switch(svargv[1][1]){
 		default:
 			dbg=1;
 		}
 		svargc--;
 		svargv++;
 	}
 	ifile=1;
 	if(svargc<=0)curfile = stdin;
 	else if((curfile = fopen(svargv[1],"r")) == NULL){
 		printf("can't open file %s\n",svargv[1]);
 		exit(1);
 		}
 	scalptr = salloc(1);
 	sputc(scalptr,0);
 	basptr = salloc(1);
 	sputc(basptr,10);
 	obase=10;
 	log_10=log_2(10L);
 	ll=68;
 	fw=1;
 	fw1=0;
 	tenptr = salloc(1);
 	sputc(tenptr,10);
 	obase=10;
 	inbas = salloc(1);
 	sputc(inbas,10);
 	sqtemp = salloc(1);
 	sputc(sqtemp,2);
 	chptr = salloc(0);
 	strptr = salloc(0);
 	divxyz = salloc(0);
 	stkbeg = stkptr = &stack[0];
 	stkend = &stack[STKSZ];
 	stkerr = 0;
 	readptr = &readstk[0];
 	k=0;
 	sp = sptr = &symlst[0];
 	while(sptr < &symlst[TBLSZ]){
 		sptr->next = ++sp;
 		sptr++;
 	}
 	sptr->next=0;
 	sfree = &symlst[0];
 	return;
 }
 
 void
 onintr(int signum){
 
 	sigset(SIGINT,onintr);
 	while(readptr != &readstk[0]){
 		if(*readptr != 0){release(*readptr);}
 		readptr--;
 	}
 	curfile = stdin;
 	commnds();
 }
 
 void
 pushp(struct blk *p)
 {
 	if(stkptr == stkend){
 		printf("out of stack space\n");
 		return;
 	}
 	stkerr=0;
 	*++stkptr = p;
 	return;
 }
 
 struct blk *
 pop(void){
 	if(stkptr == stack){
 		stkerr=1;
 		return(0);
 	}
 	return(*stkptr--);
 }
 
 struct blk *
 readin(void){
 	register struct blk *p,*q;
 	int dp,dpct;
 	register int c;
 
 	dp = dpct=0;
 	p = salloc(0);
 	while(1){
 		c = readc();
 		switch(c){
 		case '.':
 			if(dp != 0){
 				unreadc(c);
 				break;
 			}
 			dp++;
 			continue;
 		case '\\':
 			readc();
 			continue;
 		default:
 			if(c >= 'A' && c <= 'F')c = c - 'A' + 10;
 			else if(c >= '0' && c <= '9')c -= '0';
 			else goto gotnum;
 			if(dp != 0){
 				if(dpct >= 99)continue;
 				dpct++;
 			}
 			create(chptr);
 			if(c != 0)sputc(chptr,c);
 			q = mult(p,inbas);
 			release(p);
 			p = add(chptr,q);
 			release(q);
 		}
 	}
 gotnum:
 	unreadc(c);
 	if(dp == 0){
 		sputc(p,0);
 		return(p);
 	}
 	else{
 		q = scale(p,dpct);
 		return(q);
 	}
 }
 
 struct blk *
 add0(struct blk *p,int ct)
 {
 		/* returns pointer to struct with ct 0's & p */
 	register struct blk *q,*t;
 
 	q = salloc(length(p)+(ct+1)/2);
 	while(ct>1){
 		sputc(q,0);
 		ct -= 2;
 	}
 	rewind(p);
 	while(sfeof(p) == 0){
 		sputc(q,sgetc(p));
 	}
 	release(p);
 	if(ct == 1){
 		t = mult(tenptr,q);
 		release(q);
 		return(t);
 	}
 	return(q);
 }
 
 struct blk *
 mult(struct blk *p,struct blk *q)
 {
 	register struct blk *mp,*mq,*mr;
 	int sign,offset,carry;
 	int cq,cp,mt,mcr;
 
 	offset = sign = 0;
 	fsfile(p);
 	mp = p;
 	if(sfbeg(p) == 0){
 		if(sbackc(p)<0){
 			mp = copy(p,length(p));
 			chsign(mp);
 			sign = ~sign;
 		}
 	}
 	fsfile(q);
 	mq = q;
 	if(sfbeg(q) == 0){
 		if(sbackc(q)<0){
 			mq = copy(q,length(q));
 			chsign(mq);
 			sign = ~sign;
 		}
 	}
 	mr = salloc(length(mp)+length(mq));
 	zero(mr);
 	rewind(mq);
 	while(sfeof(mq) == 0){
 		cq = sgetc(mq);
 		rewind(mp);
 		rewind(mr);
 		mr->rd += offset;
 		carry=0;
 		while(sfeof(mp) == 0){
 			cp = sgetc(mp);
 			mcr = sfeof(mr)?0:slookc(mr);
 			mt = cp*cq + carry + mcr;
 			carry = mt/100;
 			salterc(mr,mt%100);
 		}
 		offset++;
 		if(carry != 0){
 			mcr = sfeof(mr)?0:slookc(mr);
 			salterc(mr,mcr+carry);
 		}
 	}
 	if(sign < 0){
 		chsign(mr);
 	}
 	if(mp != p)release(mp);
 	if(mq != q)release(mq);
 	return(mr);
 }
 
 void
 chsign(struct blk *p)
 {
 	register int carry;
 	register char ct;
 
 	carry=0;
 	rewind(p);
 	while(sfeof(p) == 0){
 		ct=100-slookc(p)-carry;
 		carry=1;
 		if(ct>=100){
 			ct -= 100;
 			carry=0;
 		}
 		salterc(p,ct);
 	}
 	if(carry != 0){
 		sputc(p,-1);
 		fsfile(p);
 		sbackc(p);
 		ct = sbackc(p);
 		if(ct == 99){
 			truncate(p);
 			sputc(p,-1);
 		}
 	}
 	else{
 		fsfile(p);
 		ct = sbackc(p);
 		if(ct == 0)truncate(p);
 	}
 	return;
 }
 
 int
 readc(void){
 loop:
 	if((readptr != &readstk[0]) && (*readptr != 0)){
 		if(sfeof(*readptr) == 0)return(lastchar = sgetc(*readptr));
 		release(*readptr);
 		readptr--;
 		goto loop;
 	}
 	lastchar = getc(curfile);
 	if(lastchar != EOF)return(lastchar);
 	if(readptr != &readptr[0]){
 		readptr--;
 		if(*readptr == 0)curfile = stdin;
 		goto loop;
 	}
 	if(curfile != stdin){
 		fclose(curfile);
 		curfile = stdin;
 		goto loop;
 	}
 	exit(0);
 }
 
 void
 unreadc(char c)
 {
 
 	if((readptr != &readstk[0]) && (*readptr != 0)){
 		sungetc(*readptr,c);
 	}
 	else ungetc(c,curfile);
 	return;
 }
 
 void
 binop(char c)
 {
 	register struct blk *r = NULL;
 
 	switch(c){
 	case '+':
 		r = add(arg1,arg2);
 		break;
 	case '*':
 		r = mult(arg1,arg2);
 		break;
 	case '/':
 		r = dcdiv(arg1,arg2);
 		break;
 	}
 	release(arg1);
 	release(arg2);
 	sputc(r,savk);
 	pushp(r);
 	return;
 }
 
 void
 print(struct blk *hptr)
 {
 	int sc;
 	register struct blk *p,*q,*dec;
 	int dig,dout,ct;
 
 	rewind(hptr);
 	while(sfeof(hptr) == 0){
 		if(sgetc(hptr)>99){
 			rewind(hptr);
 			while(sfeof(hptr) == 0){
 				printf("%c",sgetc(hptr));
 			}
 			printf("\n");
 			return;
 		}
 	}
 	fsfile(hptr);
 	sc = sbackc(hptr);
 	if(sfbeg(hptr) != 0){
 		printf("0\n");
 		return;
 	}
 	count = ll;
 	p = copy(hptr,length(hptr));
 	sunputc(p);
 	fsfile(p);
 	if(sbackc(p)<0){
 		chsign(p);
 		OUTC('-');
 	}
 	if((obase == 0) || (obase == -1)){
 		oneot(p,sc,'d');
 		return;
 	}
 	if(obase == 1){
 		oneot(p,sc,'1');
 		return;
 	}
 	if(obase == 10){
 		tenot(p,sc);
 		return;
 	}
 	create(strptr);
 	dig = log_10*sc;
 	dout = ((dig/10) + dig) /logo;
 	dec = getdec(p,sc);
 	p = removc(p,sc);
 	while(length(p) != 0){
 		q = dcdiv(p,basptr);
 		release(p);
 		p = q;
 		(*outdit)(rem,0,1);
 	}
 	release(p);
 	fsfile(strptr);
 	while(sfbeg(strptr) == 0)OUTC(sbackc(strptr));
 	if(sc == 0){
 		release(dec);
 		printf("\n");
 		return;
 	}
 	create(strptr);
 	OUTC('.');
 	ct=0;
 	do{
 		q = mult(basptr,dec);
 		release(dec);
 		dec = getdec(q,sc);
 		p = removc(q,sc);
 		(*outdit)(p,1,ct+1<dout);
 	}while(++ct < dout);
 	release(dec);
 	rewind(strptr);
 	while(sfeof(strptr) == 0)OUTC(sgetc(strptr));
 	printf("\n");
 	return;
 }
 
 struct blk *
 getdec(struct blk *p,int sc)
 {
 	int cc;
 	register struct blk *q,*t,*s;
 
 	rewind(p);
 	if(length(p)*2 < sc){
 		q = copy(p,length(p));
 		return(q);
 	}
 	q = salloc(length(p));
 	while(sc >= 1){
 		sputc(q,sgetc(p));
 		sc -= 2;
 	}
 	if(sc != 0){
 		t = mult(q,tenptr);
 		s = salloc(cc = length(q));
 		release(q);
 		rewind(t);
 		while(cc-- > 0)sputc(s,sgetc(t));
 		sputc(s,0);
 		release(t);
 		t = dcdiv(s,tenptr);
 		release(s);
 		release(rem);
 		return(t);
 	}
 	return(q);
 }
 
 void
 tenot(struct blk *p,int sc)
 {
 	register int c,f;
 	char	b[3];
 
 	fsfile(p);
 	f=0;
 	while((sfbeg(p) == 0) && ((p->rd-p->beg-1)*2 >= sc)){
 		c = sbackc(p);
 		if((c<10) && (f == 1))snprintf(b, sizeof b, "0%d",c);
 		else snprintf(b, sizeof b, "%d",c);
 		f=1;
 		TEST2(b);
 	}
 	if(sc == 0){
 		printf("\n");
 		release(p);
 		return;
 	}
 	if((p->rd-p->beg)*2 > sc){
 		c = sbackc(p);
 		snprintf(b, sizeof b, "%d.",c/10);
 		TEST2(b);
 		OUTC(c%10 +'0');
 		sc--;
 	}
 	else {
 		OUTC('.');
 	}
 	if(sc > (p->rd-p->beg)*2){
 		while(sc>(p->rd-p->beg)*2){
 			OUTC('0');
 			sc--;
 		}
 	}
 	while(sc > 1){
 		c = sbackc(p);
 		if(c<10)snprintf(b, sizeof b, "0%d",c);
 		else snprintf(b, sizeof b, "%d",c);
 		sc -= 2;
 		TEST2(b);
 	}
 	if(sc == 1){
 		OUTC(sbackc(p)/10 +'0');
 	}
 	printf("\n");
 	release(p);
 	return;
 }
 
 void
 oneot(struct blk *p,int sc,char ch)
 {
 	register struct blk *q;
 
 	q = removc(p,sc);
 	create(strptr);
 	sputc(strptr,-1);
 	while(length(q)>0){
 		p = add(strptr,q);
 		release(q);
 		q = p;
 		OUTC(ch);
 	}
 	release(q);
 	printf("\n");
 	return;
 }
 
 void
 hexot(struct blk *p,int flg,int unused)
 {
 	register int c;
 	rewind(p);
 	if(sfeof(p) != 0){
 		sputc(strptr,'0');
 		release(p);
 		return;
 	}
 	c = sgetc(p);
 	release(p);
 	if(c >= 16){
 		printf("hex digit > 16");
 		return;
 	}
 	sputc(strptr,c<10?c+'0':c-10+'A');
 	return;
 }
 
 void
 bigot(struct blk *p,int flg,int putspc)
 {
 	register struct blk *t,*q;
 	register int l = 0;
 	int neg;
 
 	if(flg == 1)t = salloc(0);
 	else{
 		t = strptr;
 		l = length(strptr)+fw-1;
 	}
 	neg=0;
 	if(length(p) != 0){
 		fsfile(p);
 		if(sbackc(p)<0){
 			neg=1;
 			chsign(p);
 		}
 		while(length(p) != 0){
 			q = dcdiv(p,tenptr);
 			release(p);
 			p = q;
 			rewind(rem);
 			sputc(t,sfeof(rem)?'0':sgetc(rem)+'0');
 			release(rem);
 		}
 	}
 	release(p);
 	if(flg == 1){
 		l = fw1-length(t);
 		if(neg != 0){
 			l--;
 			sputc(strptr,'-');
 		}
 		fsfile(t);
 		while(l-- > 0)sputc(strptr,'0');
 		while(sfbeg(t) == 0)sputc(strptr,sbackc(t));
 		release(t);
 	}
 	else{
 		l -= length(strptr);
 		while(l-- > 0)sputc(strptr,'0');
 		if(neg != 0){
 			sunputc(strptr);
 			sputc(strptr,'-');
 		}
 	}
 	if (putspc)
 		sputc(strptr,' ');
 	return;
 }
 
 struct blk *
 add(struct blk *a1,struct blk *a2)
 {
 	register struct blk *p;
 	register int carry,n;
 	int size;
 	int c = 0,n1,n2;
 
 	size = length(a1)>length(a2)?length(a1):length(a2);
 	p = salloc(size);
 	rewind(a1);
 	rewind(a2);
 	carry=0;
 	while(--size >= 0){
 		n1 = sfeof(a1)?0:sgetc(a1);
 		n2 = sfeof(a2)?0:sgetc(a2);
 		n = n1 + n2 + carry;
 		if(n>=100){
 			carry=1;
 			n -= 100;
 		}
 		else if(n<0){
 			carry = -1;
 			n += 100;
 		}
 		else carry = 0;
 		sputc(p,n);
 	}
 	if(carry != 0)sputc(p,carry);
 	fsfile(p);
 	if(sfbeg(p) == 0){
 		while(sfbeg(p) == 0 && (c = sbackc(p)) == 0);
 		if(c != 0)salterc(p,c);
 		truncate(p);
 	}
 	fsfile(p);
 	if(sfbeg(p) == 0 && sbackc(p) == -1){
 		while((c = sbackc(p)) == 99){
 			if(c == EOF)break;
 		}
 		sgetc(p);
 		salterc(p,-1);
 		truncate(p);
 	}
 	return(p);
 }
 
 int
 eqk(void){
 	register struct blk *p,*q;
 	register int skp;
 	int skq;
 
 	p = pop();
 	EMPTYS;
 	q = pop();
 	EMPTYSR(p);
 	skp = sunputc(p);
 	skq = sunputc(q);
 	if(skp == skq){
 		arg1=p;
 		arg2=q;
 		savk = skp;
 		return(0);
 	}
 	else if(skp < skq){
 		savk = skq;
 		p = add0(p,skq-skp);
 	}
 	else {
 		savk = skp;
 		q = add0(q,skp-skq);
 	}
 	arg1=p;
 	arg2=q;
 	return(0);
 }
 
 struct blk *
 removc(struct blk *p,int n)
 {
 	register struct blk *q,*r;
 
 	rewind(p);
 	while(n>1){
 		sgetc(p);
 		n -= 2;
 	}
 	q = salloc(2);
 	while(sfeof(p) == 0)sputc(q,sgetc(p));
 	if(n == 1){
 		r = dcdiv(q,tenptr);
 		release(q);
 		release(rem);
 		q = r;
 	}
 	release(p);
 	return(q);
 }
 
 struct blk *
 scalint(struct blk *p)
 {
 	register int n;
 	n = sunputc(p);
 	p = removc(p,n);
 	return(p);
 }
 
 struct blk *
 scale(struct blk *p,int n)
 {
 	register struct blk *q,*s,*t;
 
 	t = add0(p,n);
 	q = salloc(1);
 	sputc(q,n);
 	s = dcexp(inbas,q);
 	release(q);
 	q = dcdiv(t,s);
 	release(t);
 	release(s);
 	release(rem);
 	sputc(q,n);
 	return(q);
 }
 
 int
 subt(void){
 	arg1=pop();
 	EMPTYS;
 	savk = sunputc(arg1);
 	chsign(arg1);
 	sputc(arg1,savk);
 	pushp(arg1);
 	if(eqk() != 0)return(1);
 	binop('+');
 	return(0);
 }
 
 int
 command(void){
 	int c;
 	static char *line;
 	static int linesize;
 	char *sl;
 	register void (*savint)(int);
 	register int pid,rpid;
 	int retcode;
 
 	switch(c = readc()){
 	case '<':
 		return(cond(NL));
 	case '>':
 		return(cond(NG));
 	case '=':
 		return(cond(NE));
 	default:
 		if (line == 0)
 			line = srealloc(0, linesize = 10);
 		sl = line;
 		*sl++ = c;
 		while((c = readc()) != '\n') {
 			if (sl >= &line[linesize-2]) {
 				int	diff = sl - line;
 				line = srealloc(line, linesize += 10);
 				sl = &line[diff];
 			}
 			*sl++ = c;
 		}
 		*sl = 0;
 		if((pid = fork()) == 0){
 			execl(SHELL,"sh","-c",line,NULL);
 			exit(0100);
 		}
 		savint = sigset(SIGINT, SIG_IGN);
 		while((rpid = wait(&retcode)) != pid && rpid != -1);
 		sigset(SIGINT,savint);
 		printf("!\n");
 		return(0);
 	}
 }
 
 int
 cond(char c)
 {
 	register struct blk *p;
 	register int cc;
 
 	if(subt() != 0)return(1);
 	p = pop();
 	sunputc(p);
 	if(length(p) == 0){
 		release(p);
 		if(c == '<' || c == '>' || c == NE){
 			readc();
 			return(0);
 		}
 		load();
 		return(1);
 	}
 	else {
 		if(c == '='){
 			release(p);
 			readc();
 			return(0);
 		}
 	}
 	if(c == NE){
 		release(p);
 		load();
 		return(1);
 	}
 	fsfile(p);
 	cc = sbackc(p);
 	release(p);
 	if((cc<0 && (c == '<' || c == NG)) ||
 		(cc >0) && (c == '>' || c == NL)){
 		readc();
 		return(0);
 	}
 	load();
 	return(1);
 }
 
 void
 load(void){
 	register int c;
 	register struct blk *p,*q;
 	struct blk *t,*s;
 	c = readc() & 0377;
 	sptr = stable[c];
 	if(sptr != 0){
 		p = sptr->val;
 		if(c >= ARRAYST){
 			q = salloc(length(p));
 			rewind(p);
 			while(sfeof(p) == 0){
 				s = dcgetwd(p);
 				if(s == 0){putwd(q, (struct blk *)NULL);}
 				else{
 					t = copy(s,length(s));
 					putwd(q,t);
 				}
 			}
 			pushp(q);
 		}
 		else{
 			q = copy(p,length(p));
 			pushp(q);
 		}
 	}
 	else{
 		q = salloc(1);
 		sputc(q,0);
 		pushp(q);
 	}
 	return;
 }
 
 int
 log_2(long n)
 {
 	register int i;
 
 	if(n == 0)return(0);
 	i=31;
 	if(n<0)return(i);
 	while((n= n<<1) >0)i--;
 	return(--i);
 }
 
 struct blk *
 salloc(int size)
 {
 	register struct blk *hdr;
 	register char *ptr;
 	all++;
 	nbytes += size;
 	ptr = malloc((unsigned)(size?size:1));
 	if(ptr == 0){
 		garbage("salloc");
 		if((ptr = malloc((unsigned)(size?size:1))) == 0)
 			ospace("salloc");
 	}
 	if((hdr = hfree) == 0)hdr = morehd();
 	hfree = (struct blk *)hdr->rd;
 	hdr->rd = hdr->wt = hdr->beg = ptr;
 	hdr->last = ptr+size;
 	return(hdr);
 }
 
 struct blk *
 morehd(void){
 	register struct blk *h,*kk;
 	headmor++;
 	nbytes += HEADSZ;
 	hfree = h = (struct blk *)malloc(HEADSZ);
 	if(hfree == 0){
 		garbage("morehd");
 		if((hfree = h = (struct blk *)malloc(HEADSZ)) == 0)
 			ospace("headers");
 	}
 	kk = h;
 	while(h<hfree+(HEADSZ/BLK))(h++)->rd = (char *)++kk;
 	(--h)->rd=0;
 	return(hfree);
 }
 
 /*
 sunputc(struct blk *hptr)
 {
 	hptr->wt--;
 	hptr->rd = hptr->wt;
 	return(*hptr->wt);
 }
 */
 
 struct blk *
 copy(struct blk *hptr,int size)
 {
 	register struct blk *hdr;
 	register unsigned sz;
 	register char *ptr;
 
 	all++;
 	nbytes += size;
 	sz = length(hptr);
 	ptr = nalloc(hptr->beg, (unsigned)size);
 	if(ptr == 0){
 		garbage("copy");
 		if((ptr = nalloc(hptr->beg, (unsigned)size)) == NULL){
 			printf("copy size %d\n",size);
 			ospace("copy");
 		}
 	}
 	if((hdr = hfree) == 0)hdr = morehd();
 	hfree = (struct blk *)hdr->rd;
 	hdr->rd = hdr->beg = ptr;
 	hdr->last = ptr+size;
 	hdr->wt = ptr+sz;
 	ptr = hdr->wt;
 	while(ptr<hdr->last)*ptr++ = '\0';
 	return(hdr);
 }
 
 void
 sdump(char *s1,struct blk *hptr)
 {
 	char *p;
 	printf("%s %lo rd %lo wt %lo beg %lo last %lo\n", s1,
 			(long)(intptr_t)hptr,
 			(long)(intptr_t)hptr->rd,
 			(long)(intptr_t)hptr->wt,
 			(long)(intptr_t)hptr->beg,
 			(long)(intptr_t)hptr->last);
 	p = hptr->beg;
 	while(p < hptr->wt)printf("%d ",*p++);
 	printf("\n");
 }
 
 void
 seekc(struct blk *hptr,int n)
 {
 	register char *nn,*p;
 
 	nn = hptr->beg+n;
 	if(nn > hptr->last){
 		nbytes += nn - hptr->last;
 		/*free(hptr->beg);*/
 		p = realloc(hptr->beg, (unsigned)n);
 		if(p == 0){
 			hptr->beg = realloc(hptr->beg, (unsigned)(hptr->last-hptr->beg));
 			garbage("seekc");
 			if((p = realloc(hptr->beg, (unsigned)n)) == 0)
 				ospace("seekc");
 		}
 		hptr->beg = p;
 		hptr->wt = hptr->last = hptr->rd = p+n;
 		return;
 	}
 	hptr->rd = nn;
 	if(nn>hptr->wt)hptr->wt = nn;
 	return;
 }
 
 void
 salterwd(struct wblk *hptr,struct blk *n)
 {
 	if(hptr->rdw == hptr->lastw)more((struct blk *)hptr);
 	*hptr->rdw++ = n;
 	if(hptr->rdw > hptr->wtw)hptr->wtw = hptr->rdw;
 	return;
 }
 
 void
 more(struct blk *hptr)
 {
 	register unsigned size;
 	register char *p;
 
 	if((size=(hptr->last-hptr->beg)*2) == 0)size=1;
 	nbytes += size/2;
 	/*free(hptr->beg);*/
 	p = realloc(hptr->beg, (unsigned)size);
 	if(p == 0){
 		hptr->beg = realloc(hptr->beg, (unsigned)(hptr->last-hptr->beg));
 		garbage("more");
 		if((p = realloc(hptr->beg,size)) == 0)
 			ospace("more");
 	}
 	hptr->rd = hptr->rd-hptr->beg+p;
 	hptr->wt = hptr->wt-hptr->beg+p;
 	hptr->beg = p;
 	hptr->last = p+size;
 	return;
 }
 
 void
 ospace(char *s)
 {
 	printf("out of space: %s\n",s);
 	printf("all %ld rel %ld headmor %ld\n",all,rel,headmor);
 	printf("nbytes %ld\n",nbytes);
 	sdump("stk",*stkptr);
 	abort();
 }
 
 void
 garbage(char *s)
 {
 	int i;
 	struct blk *p, *q;
 	struct sym *tmps;
 	int ct;
 
 /*	printf("got to garbage %s\n",s);	*/
 	for(i=0;i<TBLSZ;i++){
 		tmps = stable[i];
 		if(tmps != 0){
 			if(i < ARRAYST){
 				do {
 					p = tmps->val;
 					if(((intptr_t)p->beg & 01)  != 0){
 						printf("string %o\n",i);
 						sdump("odd beg",p);
 					}
 					redef(p);
 					tmps = tmps->next;
 				} while(tmps != 0);
 				continue;
 			}
 			else {
 				do {
 					p = tmps->val;
 					rewind(p);
 					ct = 0;
 					while((q = dcgetwd(p)) != NULL){
 						ct++;
 						if(q != 0){
 							if(((intptr_t)q->beg & 01) != 0){
 								printf("array %o elt %d odd\n",i-ARRAYST,ct);
 printf("tmps %lo p %lo\n",(long)(intptr_t)tmps,(long)(intptr_t)p);
 								sdump("elt",q);
 							}
 							redef(q);
 						}
 					}
 					tmps = tmps->next;
 				} while(tmps != 0);
 			}
 		}
 	}
 }
 
 void
 redef(struct blk *p)
 {
 	register int offset;
 	register char *newp;
 
 	if ((intptr_t)p->beg&01) {
 		printf("odd ptr %lo hdr %lo\n",(long)(intptr_t)p->beg,
 				(long)(intptr_t)p);
 		ospace("redef-bad");
 	}
 	/*free(p->beg);*/
 	newp = realloc(p->beg, (unsigned)(p->last-p->beg));
 	if(newp == NULL)ospace("redef");
 	offset = newp - p->beg;
 	p->beg = newp;
 	p->rd += offset;
 	p->wt += offset;
 	p->last += offset;
 }
 
 void
 release(register struct blk *p)
 {
 	rel++;
 	nbytes -= p->last - p->beg;
 	p->rd = (char *)hfree;
 	hfree = p;
 	free(p->beg);
 }
 
 struct blk *
 dcgetwd(struct blk *p)
 {
 	register struct wblk *wp;
 
 	wp = (struct wblk *)p;
 	if (wp->rdw == wp->wtw)
 		return(NULL);
 	return(*wp->rdw++);
 }
 
 void
 putwd(struct blk *p, struct blk *c)
 {
 	register struct wblk *wp;
 
 	wp = (struct wblk *)p;
 	if (wp->wtw == wp->lastw)
 		more(p);
 	*wp->wtw++ = c;
 }
 
 struct blk *
 lookwd(struct blk *p)
 {
 	register struct wblk *wp;
 
 	wp = (struct wblk *)p;
 	if (wp->rdw == wp->wtw)
 		return(NULL);
 	return(*wp->rdw);
 }
 
 char *
 nalloc(register char *p,unsigned nbytes)
 {
 	register char *q, *r;
 	q = r = malloc(nbytes ? nbytes : 1);
 	if(q==0)
 		return(0);
 	while(nbytes--)
 		*q++ = *p++;
 	return(r);
 }
 
 void *
 srealloc(void *op, size_t size)
 {
 	void	*np;
 
 	if ((np = realloc(op, size)) == 0) {
 		write(2, "no memory\n", 10);
 		_exit(077);
 	}
 	return np;
 }