12b89f8f2Sbostic /*-
2*a71d9ce2Sbostic * Copyright (c) 1991, 1993
3*a71d9ce2Sbostic * The Regents of the University of California. All rights reserved.
42b89f8f2Sbostic *
52b89f8f2Sbostic * %sccs.include.proprietary.c%
62b89f8f2Sbostic */
73a9a0a5bSrrh
82b89f8f2Sbostic #ifndef lint
9*a71d9ce2Sbostic static char copyright[] =
10*a71d9ce2Sbostic "@(#) Copyright (c) 1991, 1993\n\
11*a71d9ce2Sbostic The Regents of the University of California. All rights reserved.\n";
122b89f8f2Sbostic #endif /* not lint */
132b89f8f2Sbostic
142b89f8f2Sbostic #ifndef lint
15*a71d9ce2Sbostic static char sccsid[] = "@(#)dc.c 8.1 (Berkeley) 06/06/93";
162b89f8f2Sbostic #endif /* not lint */
172b89f8f2Sbostic
1879f069a4Sbostic #include <sys/signal.h>
193a9a0a5bSrrh #include <stdio.h>
203a9a0a5bSrrh #include "dc.h"
212b89f8f2Sbostic #include <paths.h>
2279f069a4Sbostic
main(argc,argv)233a9a0a5bSrrh main(argc,argv)
243a9a0a5bSrrh int argc;
253a9a0a5bSrrh char *argv[];
263a9a0a5bSrrh {
273a9a0a5bSrrh init(argc,argv);
283a9a0a5bSrrh commnds();
293a9a0a5bSrrh }
commnds()303a9a0a5bSrrh commnds(){
313a9a0a5bSrrh register int c;
323a9a0a5bSrrh register struct blk *p,*q;
333a9a0a5bSrrh long l;
343a9a0a5bSrrh int sign;
353a9a0a5bSrrh struct blk **ptr,*s,*t;
363a9a0a5bSrrh struct sym *sp;
373a9a0a5bSrrh int sk,sk1,sk2;
383a9a0a5bSrrh int n,d;
393a9a0a5bSrrh
403a9a0a5bSrrh while(1){
413a9a0a5bSrrh if(((c = readc())>='0' && c <= '9')|| (c>='A' && c <='F') || c == '.'){
423a9a0a5bSrrh unreadc(c);
433a9a0a5bSrrh p = readin();
443a9a0a5bSrrh pushp(p);
453a9a0a5bSrrh continue;
463a9a0a5bSrrh }
473a9a0a5bSrrh switch(c){
483a9a0a5bSrrh case ' ':
493a9a0a5bSrrh case '\n':
503a9a0a5bSrrh case 0377:
513a9a0a5bSrrh case EOF:
523a9a0a5bSrrh continue;
533a9a0a5bSrrh case 'Y':
543a9a0a5bSrrh sdump("stk",*stkptr);
553a9a0a5bSrrh printf("all %ld rel %ld headmor %ld\n",all,rel,headmor);
563a9a0a5bSrrh printf("nbytes %ld\n",nbytes);
573a9a0a5bSrrh continue;
583a9a0a5bSrrh case '_':
593a9a0a5bSrrh p = readin();
603a9a0a5bSrrh savk = sunputc(p);
613a9a0a5bSrrh chsign(p);
623a9a0a5bSrrh sputc(p,savk);
633a9a0a5bSrrh pushp(p);
643a9a0a5bSrrh continue;
653a9a0a5bSrrh case '-':
663a9a0a5bSrrh subt();
673a9a0a5bSrrh continue;
683a9a0a5bSrrh case '+':
693a9a0a5bSrrh if(eqk() != 0)continue;
703a9a0a5bSrrh binop('+');
713a9a0a5bSrrh continue;
723a9a0a5bSrrh case '*':
733a9a0a5bSrrh arg1 = pop();
743a9a0a5bSrrh EMPTY;
753a9a0a5bSrrh arg2 = pop();
763a9a0a5bSrrh EMPTYR(arg1);
773a9a0a5bSrrh sk1 = sunputc(arg1);
783a9a0a5bSrrh sk2 = sunputc(arg2);
793a9a0a5bSrrh binop('*');
803a9a0a5bSrrh p = pop();
813a9a0a5bSrrh sunputc(p);
821f443b07Sbostic savk = n = sk1+sk2;
831f443b07Sbostic if(n>k && n>sk1 && n>sk2){
843a9a0a5bSrrh sk = sk1;
853a9a0a5bSrrh if(sk<sk2)sk = sk2;
863a9a0a5bSrrh if(sk<k)sk = k;
871f443b07Sbostic p = removc(p,n-sk);
883a9a0a5bSrrh savk = sk;
893a9a0a5bSrrh }
903a9a0a5bSrrh sputc(p,savk);
913a9a0a5bSrrh pushp(p);
923a9a0a5bSrrh continue;
933a9a0a5bSrrh case '/':
943a9a0a5bSrrh casediv:
953a9a0a5bSrrh if(dscale() != 0)continue;
963a9a0a5bSrrh binop('/');
973a9a0a5bSrrh if(irem != 0)release(irem);
983a9a0a5bSrrh release(rem);
993a9a0a5bSrrh continue;
1003a9a0a5bSrrh case '%':
1013a9a0a5bSrrh if(dscale() != 0)continue;
1023a9a0a5bSrrh binop('/');
1033a9a0a5bSrrh p = pop();
1043a9a0a5bSrrh release(p);
1053a9a0a5bSrrh if(irem == 0){
1063a9a0a5bSrrh sputc(rem,skr+k);
1073a9a0a5bSrrh pushp(rem);
1083a9a0a5bSrrh continue;
1093a9a0a5bSrrh }
1103a9a0a5bSrrh p = add0(rem,skd-(skr+k));
1113a9a0a5bSrrh q = add(p,irem);
1123a9a0a5bSrrh release(p);
1133a9a0a5bSrrh release(irem);
1143a9a0a5bSrrh sputc(q,skd);
1153a9a0a5bSrrh pushp(q);
1163a9a0a5bSrrh continue;
1173a9a0a5bSrrh case 'v':
1183a9a0a5bSrrh p = pop();
1193a9a0a5bSrrh EMPTY;
1203a9a0a5bSrrh savk = sunputc(p);
1213a9a0a5bSrrh if(length(p) == 0){
1223a9a0a5bSrrh sputc(p,savk);
1233a9a0a5bSrrh pushp(p);
1243a9a0a5bSrrh continue;
1253a9a0a5bSrrh }
1263a9a0a5bSrrh if((c = sbackc(p))<0){
1273a9a0a5bSrrh error("sqrt of neg number\n");
1283a9a0a5bSrrh }
1293a9a0a5bSrrh if(k<savk)n = savk;
1303a9a0a5bSrrh else{
1313a9a0a5bSrrh n = k*2-savk;
1323a9a0a5bSrrh savk = k;
1333a9a0a5bSrrh }
1343a9a0a5bSrrh arg1 = add0(p,n);
1352177257bStorek arg2 = dcsqrt(arg1);
1363a9a0a5bSrrh sputc(arg2,savk);
1373a9a0a5bSrrh pushp(arg2);
1383a9a0a5bSrrh continue;
1393a9a0a5bSrrh case '^':
1403a9a0a5bSrrh neg = 0;
1413a9a0a5bSrrh arg1 = pop();
1423a9a0a5bSrrh EMPTY;
1433a9a0a5bSrrh if(sunputc(arg1) != 0)error("exp not an integer\n");
1443a9a0a5bSrrh arg2 = pop();
1453a9a0a5bSrrh EMPTYR(arg1);
1463a9a0a5bSrrh if(sfbeg(arg1) == 0 && sbackc(arg1)<0){
1473a9a0a5bSrrh neg++;
1483a9a0a5bSrrh chsign(arg1);
1493a9a0a5bSrrh }
1503a9a0a5bSrrh if(length(arg1)>=3){
1513a9a0a5bSrrh error("exp too big\n");
1523a9a0a5bSrrh }
1533a9a0a5bSrrh savk = sunputc(arg2);
1543a9a0a5bSrrh p = exp(arg2,arg1);
1553a9a0a5bSrrh release(arg2);
1563a9a0a5bSrrh rewind(arg1);
1573a9a0a5bSrrh c = sgetc(arg1);
1583a9a0a5bSrrh if(sfeof(arg1) == 0)
1593a9a0a5bSrrh c = sgetc(arg1)*100 + c;
1603a9a0a5bSrrh d = c*savk;
1613a9a0a5bSrrh release(arg1);
1623a9a0a5bSrrh if(neg == 0){
1633a9a0a5bSrrh if(k>=savk)n = k;
1643a9a0a5bSrrh else n = savk;
1653a9a0a5bSrrh if(n<d){
1663a9a0a5bSrrh q = removc(p,d-n);
1673a9a0a5bSrrh sputc(q,n);
1683a9a0a5bSrrh pushp(q);
1693a9a0a5bSrrh }
1703a9a0a5bSrrh else {
1713a9a0a5bSrrh sputc(p,d);
1723a9a0a5bSrrh pushp(p);
1733a9a0a5bSrrh }
1743a9a0a5bSrrh }
1753a9a0a5bSrrh else {
1763a9a0a5bSrrh sputc(p,d);
1773a9a0a5bSrrh pushp(p);
1783a9a0a5bSrrh }
1793a9a0a5bSrrh if(neg == 0)continue;
1803a9a0a5bSrrh p = pop();
1813a9a0a5bSrrh q = salloc(2);
1823a9a0a5bSrrh sputc(q,1);
1833a9a0a5bSrrh sputc(q,0);
1843a9a0a5bSrrh pushp(q);
1853a9a0a5bSrrh pushp(p);
1863a9a0a5bSrrh goto casediv;
1873a9a0a5bSrrh case 'z':
1883a9a0a5bSrrh p = salloc(2);
1893a9a0a5bSrrh n = stkptr - stkbeg;
1903a9a0a5bSrrh if(n >= 100){
1913a9a0a5bSrrh sputc(p,n/100);
1923a9a0a5bSrrh n %= 100;
1933a9a0a5bSrrh }
1943a9a0a5bSrrh sputc(p,n);
1953a9a0a5bSrrh sputc(p,0);
1963a9a0a5bSrrh pushp(p);
1973a9a0a5bSrrh continue;
1983a9a0a5bSrrh case 'Z':
1993a9a0a5bSrrh p = pop();
2003a9a0a5bSrrh EMPTY;
2013a9a0a5bSrrh n = (length(p)-1)<<1;
2023a9a0a5bSrrh fsfile(p);
2033a9a0a5bSrrh sbackc(p);
2043a9a0a5bSrrh if(sfbeg(p) == 0){
2053a9a0a5bSrrh if((c = sbackc(p))<0){
2063a9a0a5bSrrh n -= 2;
2073a9a0a5bSrrh if(sfbeg(p) == 1)n += 1;
2083a9a0a5bSrrh else {
2093a9a0a5bSrrh if((c = sbackc(p)) == 0)n += 1;
2103a9a0a5bSrrh else if(c > 90)n -= 1;
2113a9a0a5bSrrh }
2123a9a0a5bSrrh }
2133a9a0a5bSrrh else if(c < 10) n -= 1;
2143a9a0a5bSrrh }
2153a9a0a5bSrrh release(p);
2163a9a0a5bSrrh q = salloc(1);
2173a9a0a5bSrrh if(n >= 100){
2183a9a0a5bSrrh sputc(q,n%100);
2193a9a0a5bSrrh n /= 100;
2203a9a0a5bSrrh }
2213a9a0a5bSrrh sputc(q,n);
2223a9a0a5bSrrh sputc(q,0);
2233a9a0a5bSrrh pushp(q);
2243a9a0a5bSrrh continue;
2253a9a0a5bSrrh case 'i':
2263a9a0a5bSrrh p = pop();
2273a9a0a5bSrrh EMPTY;
2283a9a0a5bSrrh p = scalint(p);
2293a9a0a5bSrrh release(inbas);
2303a9a0a5bSrrh inbas = p;
2313a9a0a5bSrrh continue;
2323a9a0a5bSrrh case 'I':
2333a9a0a5bSrrh p = copy(inbas,length(inbas)+1);
2343a9a0a5bSrrh sputc(p,0);
2353a9a0a5bSrrh pushp(p);
2363a9a0a5bSrrh continue;
2373a9a0a5bSrrh case 'o':
2383a9a0a5bSrrh p = pop();
2393a9a0a5bSrrh EMPTY;
2403a9a0a5bSrrh p = scalint(p);
2413a9a0a5bSrrh sign = 0;
2423a9a0a5bSrrh n = length(p);
2433a9a0a5bSrrh q = copy(p,n);
2443a9a0a5bSrrh fsfile(q);
2453a9a0a5bSrrh l = c = sbackc(q);
2463a9a0a5bSrrh if(n != 1){
2473a9a0a5bSrrh if(c<0){
2483a9a0a5bSrrh sign = 1;
2493a9a0a5bSrrh chsign(q);
2503a9a0a5bSrrh n = length(q);
2513a9a0a5bSrrh fsfile(q);
2523a9a0a5bSrrh l = c = sbackc(q);
2533a9a0a5bSrrh }
2543a9a0a5bSrrh if(n != 1){
2553a9a0a5bSrrh while(sfbeg(q) == 0)l = l*100+sbackc(q);
2563a9a0a5bSrrh }
2573a9a0a5bSrrh }
2583a9a0a5bSrrh logo = log2(l);
2593a9a0a5bSrrh obase = l;
2603a9a0a5bSrrh release(basptr);
2613a9a0a5bSrrh if(sign == 1)obase = -l;
2623a9a0a5bSrrh basptr = p;
2633a9a0a5bSrrh outdit = bigot;
2643a9a0a5bSrrh if(n == 1 && sign == 0){
2653a9a0a5bSrrh if(c <= 16){
2663a9a0a5bSrrh outdit = hexot;
2673a9a0a5bSrrh fw = 1;
2683a9a0a5bSrrh fw1 = 0;
2693a9a0a5bSrrh ll = 70;
2703a9a0a5bSrrh release(q);
2713a9a0a5bSrrh continue;
2723a9a0a5bSrrh }
2733a9a0a5bSrrh }
2743a9a0a5bSrrh n = 0;
2753a9a0a5bSrrh if(sign == 1)n++;
2763a9a0a5bSrrh p = salloc(1);
2773a9a0a5bSrrh sputc(p,-1);
2783a9a0a5bSrrh t = add(p,q);
2793a9a0a5bSrrh n += length(t)*2;
2803a9a0a5bSrrh fsfile(t);
2813a9a0a5bSrrh if((c = sbackc(t))>9)n++;
2823a9a0a5bSrrh release(t);
2833a9a0a5bSrrh release(q);
2843a9a0a5bSrrh release(p);
2853a9a0a5bSrrh fw = n;
2863a9a0a5bSrrh fw1 = n-1;
2873a9a0a5bSrrh ll = 70;
2883a9a0a5bSrrh if(fw>=ll)continue;
2893a9a0a5bSrrh ll = (70/fw)*fw;
2903a9a0a5bSrrh continue;
2913a9a0a5bSrrh case 'O':
2923a9a0a5bSrrh p = copy(basptr,length(basptr)+1);
2933a9a0a5bSrrh sputc(p,0);
2943a9a0a5bSrrh pushp(p);
2953a9a0a5bSrrh continue;
2963a9a0a5bSrrh case '[':
2973a9a0a5bSrrh n = 0;
2983a9a0a5bSrrh p = salloc(0);
2993a9a0a5bSrrh while(1){
3003a9a0a5bSrrh if((c = readc()) == ']'){
3013a9a0a5bSrrh if(n == 0)break;
3023a9a0a5bSrrh n--;
3033a9a0a5bSrrh }
3043a9a0a5bSrrh sputc(p,c);
3053a9a0a5bSrrh if(c == '[')n++;
3063a9a0a5bSrrh }
3073a9a0a5bSrrh pushp(p);
3083a9a0a5bSrrh continue;
3093a9a0a5bSrrh case 'k':
3103a9a0a5bSrrh p = pop();
3113a9a0a5bSrrh EMPTY;
3123a9a0a5bSrrh p = scalint(p);
3133a9a0a5bSrrh if(length(p)>1){
3143a9a0a5bSrrh error("scale too big\n");
3153a9a0a5bSrrh }
3163a9a0a5bSrrh rewind(p);
3173a9a0a5bSrrh k = sfeof(p)?0:sgetc(p);
3183a9a0a5bSrrh release(scalptr);
3193a9a0a5bSrrh scalptr = p;
3203a9a0a5bSrrh continue;
3213a9a0a5bSrrh case 'K':
3223a9a0a5bSrrh p = copy(scalptr,length(scalptr)+1);
3233a9a0a5bSrrh sputc(p,0);
3243a9a0a5bSrrh pushp(p);
3253a9a0a5bSrrh continue;
3263a9a0a5bSrrh case 'X':
3273a9a0a5bSrrh p = pop();
3283a9a0a5bSrrh EMPTY;
3293a9a0a5bSrrh fsfile(p);
3303a9a0a5bSrrh n = sbackc(p);
3313a9a0a5bSrrh release(p);
3323a9a0a5bSrrh p = salloc(2);
3333a9a0a5bSrrh sputc(p,n);
3343a9a0a5bSrrh sputc(p,0);
3353a9a0a5bSrrh pushp(p);
3363a9a0a5bSrrh continue;
3373a9a0a5bSrrh case 'Q':
3383a9a0a5bSrrh p = pop();
3393a9a0a5bSrrh EMPTY;
3403a9a0a5bSrrh if(length(p)>2){
3413a9a0a5bSrrh error("Q?\n");
3423a9a0a5bSrrh }
3433a9a0a5bSrrh rewind(p);
3443a9a0a5bSrrh if((c = sgetc(p))<0){
3453a9a0a5bSrrh error("neg Q\n");
3463a9a0a5bSrrh }
3473a9a0a5bSrrh release(p);
3483a9a0a5bSrrh while(c-- > 0){
3493a9a0a5bSrrh if(readptr == &readstk[0]){
3503a9a0a5bSrrh error("readstk?\n");
3513a9a0a5bSrrh }
3523a9a0a5bSrrh if(*readptr != 0)release(*readptr);
3533a9a0a5bSrrh readptr--;
3543a9a0a5bSrrh }
3553a9a0a5bSrrh continue;
3563a9a0a5bSrrh case 'q':
3573a9a0a5bSrrh if(readptr <= &readstk[1])exit(0);
3583a9a0a5bSrrh if(*readptr != 0)release(*readptr);
3593a9a0a5bSrrh readptr--;
3603a9a0a5bSrrh if(*readptr != 0)release(*readptr);
3613a9a0a5bSrrh readptr--;
3623a9a0a5bSrrh continue;
3633a9a0a5bSrrh case 'f':
3643a9a0a5bSrrh if(stkptr == &stack[0])printf("empty stack\n");
3653a9a0a5bSrrh else {
3663a9a0a5bSrrh for(ptr = stkptr; ptr > &stack[0];){
3673a9a0a5bSrrh print(*ptr--);
3683a9a0a5bSrrh }
3693a9a0a5bSrrh }
3703a9a0a5bSrrh continue;
3713a9a0a5bSrrh case 'p':
3723a9a0a5bSrrh if(stkptr == &stack[0])printf("empty stack\n");
3733a9a0a5bSrrh else{
3743a9a0a5bSrrh print(*stkptr);
3753a9a0a5bSrrh }
3763a9a0a5bSrrh continue;
3773a9a0a5bSrrh case 'P':
3783a9a0a5bSrrh p = pop();
3793a9a0a5bSrrh EMPTY;
3803a9a0a5bSrrh sputc(p,0);
3813a9a0a5bSrrh printf("%s",p->beg);
3823a9a0a5bSrrh release(p);
3833a9a0a5bSrrh continue;
3843a9a0a5bSrrh case 'd':
3853a9a0a5bSrrh if(stkptr == &stack[0]){
3863a9a0a5bSrrh printf("empty stack\n");
3873a9a0a5bSrrh continue;
3883a9a0a5bSrrh }
3893a9a0a5bSrrh q = *stkptr;
3903a9a0a5bSrrh n = length(q);
3913a9a0a5bSrrh p = copy(*stkptr,n);
3923a9a0a5bSrrh pushp(p);
3933a9a0a5bSrrh continue;
3943a9a0a5bSrrh case 'c':
3953a9a0a5bSrrh while(stkerr == 0){
3963a9a0a5bSrrh p = pop();
3973a9a0a5bSrrh if(stkerr == 0)release(p);
3983a9a0a5bSrrh }
3993a9a0a5bSrrh continue;
4003a9a0a5bSrrh case 'S':
4013a9a0a5bSrrh if(stkptr == &stack[0]){
4023a9a0a5bSrrh error("save: args\n");
4033a9a0a5bSrrh }
4043a9a0a5bSrrh c = readc() & 0377;
4053a9a0a5bSrrh sptr = stable[c];
4063a9a0a5bSrrh sp = stable[c] = sfree;
4073a9a0a5bSrrh sfree = sfree->next;
4083a9a0a5bSrrh if(sfree == 0)goto sempty;
4093a9a0a5bSrrh sp->next = sptr;
4103a9a0a5bSrrh p = pop();
4113a9a0a5bSrrh EMPTY;
4123a9a0a5bSrrh if(c >= ARRAYST){
4133a9a0a5bSrrh q = copy(p,PTRSZ);
4143a9a0a5bSrrh for(n = 0;n < PTRSZ-1;n++)sputc(q,0);
4153a9a0a5bSrrh release(p);
4163a9a0a5bSrrh p = q;
4173a9a0a5bSrrh }
4183a9a0a5bSrrh sp->val = p;
4193a9a0a5bSrrh continue;
4203a9a0a5bSrrh sempty:
4213a9a0a5bSrrh error("symbol table overflow\n");
4223a9a0a5bSrrh case 's':
4233a9a0a5bSrrh if(stkptr == &stack[0]){
4243a9a0a5bSrrh error("save:args\n");
4253a9a0a5bSrrh }
4263a9a0a5bSrrh c = readc() & 0377;
4273a9a0a5bSrrh sptr = stable[c];
4283a9a0a5bSrrh if(sptr != 0){
4293a9a0a5bSrrh p = sptr->val;
4303a9a0a5bSrrh if(c >= ARRAYST){
4313a9a0a5bSrrh rewind(p);
4323a9a0a5bSrrh while(sfeof(p) == 0)release(getwd(p));
4333a9a0a5bSrrh }
4343a9a0a5bSrrh release(p);
4353a9a0a5bSrrh }
4363a9a0a5bSrrh else{
4373a9a0a5bSrrh sptr = stable[c] = sfree;
4383a9a0a5bSrrh sfree = sfree->next;
4393a9a0a5bSrrh if(sfree == 0)goto sempty;
4403a9a0a5bSrrh sptr->next = 0;
4413a9a0a5bSrrh }
4423a9a0a5bSrrh p = pop();
4433a9a0a5bSrrh sptr->val = p;
4443a9a0a5bSrrh continue;
4453a9a0a5bSrrh case 'l':
4463a9a0a5bSrrh load();
4473a9a0a5bSrrh continue;
4483a9a0a5bSrrh case 'L':
4493a9a0a5bSrrh c = readc() & 0377;
4503a9a0a5bSrrh sptr = stable[c];
4513a9a0a5bSrrh if(sptr == 0){
4523a9a0a5bSrrh error("L?\n");
4533a9a0a5bSrrh }
4543a9a0a5bSrrh stable[c] = sptr->next;
4553a9a0a5bSrrh sptr->next = sfree;
4563a9a0a5bSrrh sfree = sptr;
4573a9a0a5bSrrh p = sptr->val;
4583a9a0a5bSrrh if(c >= ARRAYST){
4593a9a0a5bSrrh rewind(p);
4603a9a0a5bSrrh while(sfeof(p) == 0){
4613a9a0a5bSrrh q = getwd(p);
4623a9a0a5bSrrh if(q != 0)release(q);
4633a9a0a5bSrrh }
4643a9a0a5bSrrh }
4653a9a0a5bSrrh pushp(p);
4663a9a0a5bSrrh continue;
4673a9a0a5bSrrh case ':':
4683a9a0a5bSrrh p = pop();
4693a9a0a5bSrrh EMPTY;
4703a9a0a5bSrrh q = scalint(p);
4713a9a0a5bSrrh fsfile(q);
4723a9a0a5bSrrh c = 0;
4733a9a0a5bSrrh if((sfbeg(q) == 0) && ((c = sbackc(q))<0)){
4743a9a0a5bSrrh error("neg index\n");
4753a9a0a5bSrrh }
4763a9a0a5bSrrh if(length(q)>2){
4773a9a0a5bSrrh error("index too big\n");
4783a9a0a5bSrrh }
4793a9a0a5bSrrh if(sfbeg(q) == 0)c = c*100+sbackc(q);
4803a9a0a5bSrrh if(c >= MAXIND){
4813a9a0a5bSrrh error("index too big\n");
4823a9a0a5bSrrh }
4833a9a0a5bSrrh release(q);
4843a9a0a5bSrrh n = readc() & 0377;
4853a9a0a5bSrrh sptr = stable[n];
4863a9a0a5bSrrh if(sptr == 0){
4873a9a0a5bSrrh sptr = stable[n] = sfree;
4883a9a0a5bSrrh sfree = sfree->next;
4893a9a0a5bSrrh if(sfree == 0)goto sempty;
4903a9a0a5bSrrh sptr->next = 0;
4913a9a0a5bSrrh p = salloc((c+PTRSZ)*PTRSZ);
4923a9a0a5bSrrh zero(p);
4933a9a0a5bSrrh }
4943a9a0a5bSrrh else{
4953a9a0a5bSrrh p = sptr->val;
4963a9a0a5bSrrh if(length(p)-PTRSZ < c*PTRSZ){
4973a9a0a5bSrrh q = copy(p,(c+PTRSZ)*PTRSZ);
4983a9a0a5bSrrh release(p);
4993a9a0a5bSrrh p = q;
5003a9a0a5bSrrh }
5013a9a0a5bSrrh }
5023a9a0a5bSrrh seekc(p,c*PTRSZ);
5033a9a0a5bSrrh q = lookwd(p);
5043a9a0a5bSrrh if (q!=NULL) release(q);
5053a9a0a5bSrrh s = pop();
5063a9a0a5bSrrh EMPTY;
5073a9a0a5bSrrh salterwd(p,s);
5083a9a0a5bSrrh sptr->val = p;
5093a9a0a5bSrrh continue;
5103a9a0a5bSrrh case ';':
5113a9a0a5bSrrh p = pop();
5123a9a0a5bSrrh EMPTY;
5133a9a0a5bSrrh q = scalint(p);
5143a9a0a5bSrrh fsfile(q);
5153a9a0a5bSrrh c = 0;
5163a9a0a5bSrrh if((sfbeg(q) == 0) && ((c = sbackc(q))<0)){
5173a9a0a5bSrrh error("neg index\n");
5183a9a0a5bSrrh }
5193a9a0a5bSrrh if(length(q)>2){
5203a9a0a5bSrrh error("index too big\n");
5213a9a0a5bSrrh }
5223a9a0a5bSrrh if(sfbeg(q) == 0)c = c*100+sbackc(q);
5233a9a0a5bSrrh if(c >= MAXIND){
5243a9a0a5bSrrh error("index too big\n");
5253a9a0a5bSrrh }
5263a9a0a5bSrrh release(q);
5273a9a0a5bSrrh n = readc() & 0377;
5283a9a0a5bSrrh sptr = stable[n];
5293a9a0a5bSrrh if(sptr != 0){
5303a9a0a5bSrrh p = sptr->val;
5313a9a0a5bSrrh if(length(p)-PTRSZ >= c*PTRSZ){
5323a9a0a5bSrrh seekc(p,c*PTRSZ);
5333a9a0a5bSrrh s = getwd(p);
5343a9a0a5bSrrh if(s != 0){
5353a9a0a5bSrrh q = copy(s,length(s));
5363a9a0a5bSrrh pushp(q);
5373a9a0a5bSrrh continue;
5383a9a0a5bSrrh }
5393a9a0a5bSrrh }
5403a9a0a5bSrrh }
5413a9a0a5bSrrh q = salloc(PTRSZ);
5423a9a0a5bSrrh putwd(q, (struct blk *)0);
5433a9a0a5bSrrh pushp(q);
5443a9a0a5bSrrh continue;
5453a9a0a5bSrrh case 'x':
5463a9a0a5bSrrh execute:
5473a9a0a5bSrrh p = pop();
5483a9a0a5bSrrh EMPTY;
5493a9a0a5bSrrh if((readptr != &readstk[0]) && (*readptr != 0)){
5503a9a0a5bSrrh if((*readptr)->rd == (*readptr)->wt)
5513a9a0a5bSrrh release(*readptr);
5523a9a0a5bSrrh else{
5533a9a0a5bSrrh if(readptr++ == &readstk[RDSKSZ]){
5543a9a0a5bSrrh error("nesting depth\n");
5553a9a0a5bSrrh }
5563a9a0a5bSrrh }
5573a9a0a5bSrrh }
5583a9a0a5bSrrh else readptr++;
5593a9a0a5bSrrh *readptr = p;
5603a9a0a5bSrrh if(p != 0)rewind(p);
5613a9a0a5bSrrh else{
5623a9a0a5bSrrh if((c = readc()) != '\n')unreadc(c);
5633a9a0a5bSrrh }
5643a9a0a5bSrrh continue;
5653a9a0a5bSrrh case '?':
5663a9a0a5bSrrh if(++readptr == &readstk[RDSKSZ]){
5673a9a0a5bSrrh error("nesting depth\n");
5683a9a0a5bSrrh }
5693a9a0a5bSrrh *readptr = 0;
5703a9a0a5bSrrh fsave = curfile;
5713a9a0a5bSrrh curfile = stdin;
5723a9a0a5bSrrh while((c = readc()) == '!')command();
5733a9a0a5bSrrh p = salloc(0);
5743a9a0a5bSrrh sputc(p,c);
5753a9a0a5bSrrh while((c = readc()) != '\n'){
5763a9a0a5bSrrh sputc(p,c);
5773a9a0a5bSrrh if(c == '\\')sputc(p,readc());
5783a9a0a5bSrrh }
5793a9a0a5bSrrh curfile = fsave;
5803a9a0a5bSrrh *readptr = p;
5813a9a0a5bSrrh continue;
5823a9a0a5bSrrh case '!':
5833a9a0a5bSrrh if(command() == 1)goto execute;
5843a9a0a5bSrrh continue;
5853a9a0a5bSrrh case '<':
5863a9a0a5bSrrh case '>':
5873a9a0a5bSrrh case '=':
5883a9a0a5bSrrh if(cond(c) == 1)goto execute;
5893a9a0a5bSrrh continue;
5903a9a0a5bSrrh default:
5913a9a0a5bSrrh printf("%o is unimplemented\n",c);
5923a9a0a5bSrrh }
5933a9a0a5bSrrh }
5943a9a0a5bSrrh }
5953a9a0a5bSrrh struct blk *
div(ddivd,ddivr)5963a9a0a5bSrrh div(ddivd,ddivr)
5973a9a0a5bSrrh struct blk *ddivd,*ddivr;
5983a9a0a5bSrrh {
5993a9a0a5bSrrh int divsign,remsign,offset,divcarry;
6003a9a0a5bSrrh int carry, dig,magic,d,dd;
6013a9a0a5bSrrh long c,td,cc;
6023a9a0a5bSrrh struct blk *ps;
6033a9a0a5bSrrh register struct blk *p,*divd,*divr;
6043a9a0a5bSrrh
6053a9a0a5bSrrh rem = 0;
6063a9a0a5bSrrh p = salloc(0);
6073a9a0a5bSrrh if(length(ddivr) == 0){
6083a9a0a5bSrrh pushp(ddivr);
609886a55d5Sbostic printf("divide by 0\n");
610886a55d5Sbostic return((struct blk *)1);
6113a9a0a5bSrrh }
6123a9a0a5bSrrh divsign = remsign = 0;
6133a9a0a5bSrrh divr = ddivr;
6143a9a0a5bSrrh fsfile(divr);
6153a9a0a5bSrrh if(sbackc(divr) == -1){
6163a9a0a5bSrrh divr = copy(ddivr,length(ddivr));
6173a9a0a5bSrrh chsign(divr);
6183a9a0a5bSrrh divsign = ~divsign;
6193a9a0a5bSrrh }
6203a9a0a5bSrrh divd = copy(ddivd,length(ddivd));
6213a9a0a5bSrrh fsfile(divd);
6223a9a0a5bSrrh if(sfbeg(divd) == 0 && sbackc(divd) == -1){
6233a9a0a5bSrrh chsign(divd);
6243a9a0a5bSrrh divsign = ~divsign;
6253a9a0a5bSrrh remsign = ~remsign;
6263a9a0a5bSrrh }
6273a9a0a5bSrrh offset = length(divd) - length(divr);
6283a9a0a5bSrrh if(offset < 0)goto ddone;
6293a9a0a5bSrrh seekc(p,offset+1);
6303a9a0a5bSrrh sputc(divd,0);
6313a9a0a5bSrrh magic = 0;
6323a9a0a5bSrrh fsfile(divr);
6333a9a0a5bSrrh c = sbackc(divr);
6343a9a0a5bSrrh if(c<10)magic++;
6353a9a0a5bSrrh c = c*100 + (sfbeg(divr)?0:sbackc(divr));
6363a9a0a5bSrrh if(magic>0){
6373a9a0a5bSrrh c = (c*100 +(sfbeg(divr)?0:sbackc(divr)))*2;
6383a9a0a5bSrrh c /= 25;
6393a9a0a5bSrrh }
6403a9a0a5bSrrh while(offset >= 0){
6413a9a0a5bSrrh fsfile(divd);
6423a9a0a5bSrrh td = sbackc(divd)*100;
6433a9a0a5bSrrh dd = sfbeg(divd)?0:sbackc(divd);
6443a9a0a5bSrrh td = (td+dd)*100;
6453a9a0a5bSrrh dd = sfbeg(divd)?0:sbackc(divd);
6463a9a0a5bSrrh td = td+dd;
6473a9a0a5bSrrh cc = c;
6483a9a0a5bSrrh if(offset == 0)td += 1;
6493a9a0a5bSrrh else cc += 1;
6503a9a0a5bSrrh if(magic != 0)td = td<<3;
6513a9a0a5bSrrh dig = td/cc;
6523a9a0a5bSrrh rewind(divr);
6533a9a0a5bSrrh rewind(divxyz);
6543a9a0a5bSrrh carry = 0;
6553a9a0a5bSrrh while(sfeof(divr) == 0){
6563a9a0a5bSrrh d = sgetc(divr)*dig+carry;
6573a9a0a5bSrrh carry = d / 100;
6583a9a0a5bSrrh salterc(divxyz,d%100);
6593a9a0a5bSrrh }
6603a9a0a5bSrrh salterc(divxyz,carry);
6613a9a0a5bSrrh rewind(divxyz);
6623a9a0a5bSrrh seekc(divd,offset);
6633a9a0a5bSrrh carry = 0;
6643a9a0a5bSrrh while(sfeof(divd) == 0){
6653a9a0a5bSrrh d = slookc(divd);
6663a9a0a5bSrrh d = d-(sfeof(divxyz)?0:sgetc(divxyz))-carry;
6673a9a0a5bSrrh carry = 0;
6683a9a0a5bSrrh if(d < 0){
6693a9a0a5bSrrh d += 100;
6703a9a0a5bSrrh carry = 1;
6713a9a0a5bSrrh }
6723a9a0a5bSrrh salterc(divd,d);
6733a9a0a5bSrrh }
6743a9a0a5bSrrh divcarry = carry;
6753a9a0a5bSrrh sbackc(p);
6763a9a0a5bSrrh salterc(p,dig);
6773a9a0a5bSrrh sbackc(p);
6781f443b07Sbostic if(--offset >= 0){
6791f443b07Sbostic if(d > 0){
6801f443b07Sbostic sbackc(divd);
6811f443b07Sbostic dd=sbackc(divd);
6821f443b07Sbostic salterc(divd,dd+100);
6831f443b07Sbostic }
6841f443b07Sbostic divd->wt--;
6851f443b07Sbostic }
6863a9a0a5bSrrh }
6873a9a0a5bSrrh if(divcarry != 0){
6883a9a0a5bSrrh salterc(p,dig-1);
6893a9a0a5bSrrh salterc(divd,-1);
6903a9a0a5bSrrh ps = add(divr,divd);
6913a9a0a5bSrrh release(divd);
6923a9a0a5bSrrh divd = ps;
6933a9a0a5bSrrh }
6943a9a0a5bSrrh
6953a9a0a5bSrrh rewind(p);
6963a9a0a5bSrrh divcarry = 0;
6973a9a0a5bSrrh while(sfeof(p) == 0){
6983a9a0a5bSrrh d = slookc(p)+divcarry;
6993a9a0a5bSrrh divcarry = 0;
7003a9a0a5bSrrh if(d >= 100){
7013a9a0a5bSrrh d -= 100;
7023a9a0a5bSrrh divcarry = 1;
7033a9a0a5bSrrh }
7043a9a0a5bSrrh salterc(p,d);
7053a9a0a5bSrrh }
7063a9a0a5bSrrh if(divcarry != 0)salterc(p,divcarry);
7073a9a0a5bSrrh fsfile(p);
7083a9a0a5bSrrh while(sfbeg(p) == 0){
7093a9a0a5bSrrh if(sbackc(p) == 0)truncate(p);
7103a9a0a5bSrrh else break;
7113a9a0a5bSrrh }
7123a9a0a5bSrrh if(divsign < 0)chsign(p);
7133a9a0a5bSrrh fsfile(divd);
7143a9a0a5bSrrh while(sfbeg(divd) == 0){
7153a9a0a5bSrrh if(sbackc(divd) == 0)truncate(divd);
7163a9a0a5bSrrh else break;
7173a9a0a5bSrrh }
7183a9a0a5bSrrh ddone:
7193a9a0a5bSrrh if(remsign<0)chsign(divd);
7203a9a0a5bSrrh if(divr != ddivr)release(divr);
7213a9a0a5bSrrh rem = divd;
7223a9a0a5bSrrh return(p);
7233a9a0a5bSrrh }
dscale()7243a9a0a5bSrrh dscale(){
7253a9a0a5bSrrh register struct blk *dd,*dr;
7263a9a0a5bSrrh register struct blk *r;
7273a9a0a5bSrrh int c;
7283a9a0a5bSrrh
7293a9a0a5bSrrh dr = pop();
7303a9a0a5bSrrh EMPTYS;
7313a9a0a5bSrrh dd = pop();
7323a9a0a5bSrrh EMPTYSR(dr);
7333a9a0a5bSrrh fsfile(dd);
7343a9a0a5bSrrh skd = sunputc(dd);
7353a9a0a5bSrrh fsfile(dr);
7363a9a0a5bSrrh skr = sunputc(dr);
7373a9a0a5bSrrh if(sfbeg(dr) == 1 || (sfbeg(dr) == 0 && sbackc(dr) == 0)){
7383a9a0a5bSrrh sputc(dr,skr);
7393a9a0a5bSrrh pushp(dr);
7403a9a0a5bSrrh errorrt("divide by 0\n");
7413a9a0a5bSrrh }
7423a9a0a5bSrrh c = k-skd+skr;
7433a9a0a5bSrrh if(c < 0)r = removr(dd,-c);
7443a9a0a5bSrrh else {
7453a9a0a5bSrrh r = add0(dd,c);
7463a9a0a5bSrrh irem = 0;
7473a9a0a5bSrrh }
7483a9a0a5bSrrh arg1 = r;
7493a9a0a5bSrrh arg2 = dr;
7503a9a0a5bSrrh savk = k;
7513a9a0a5bSrrh return(0);
7523a9a0a5bSrrh }
7533a9a0a5bSrrh struct blk *
removr(p,n)7543a9a0a5bSrrh removr(p,n)
7553a9a0a5bSrrh struct blk *p;
7563a9a0a5bSrrh {
7573a9a0a5bSrrh int nn;
7583a9a0a5bSrrh register struct blk *q,*s,*r;
7593a9a0a5bSrrh
7603a9a0a5bSrrh rewind(p);
7613a9a0a5bSrrh nn = (n+1)/2;
7623a9a0a5bSrrh q = salloc(nn);
7633a9a0a5bSrrh while(n>1){
7643a9a0a5bSrrh sputc(q,sgetc(p));
7653a9a0a5bSrrh n -= 2;
7663a9a0a5bSrrh }
7673a9a0a5bSrrh r = salloc(2);
7683a9a0a5bSrrh while(sfeof(p) == 0)sputc(r,sgetc(p));
7693a9a0a5bSrrh release(p);
7703a9a0a5bSrrh if(n == 1){
7713a9a0a5bSrrh s = div(r,tenptr);
7723a9a0a5bSrrh release(r);
7733a9a0a5bSrrh rewind(rem);
7743a9a0a5bSrrh if(sfeof(rem) == 0)sputc(q,sgetc(rem));
7753a9a0a5bSrrh release(rem);
7763a9a0a5bSrrh irem = q;
7773a9a0a5bSrrh return(s);
7783a9a0a5bSrrh }
7793a9a0a5bSrrh irem = q;
7803a9a0a5bSrrh return(r);
7813a9a0a5bSrrh }
7823a9a0a5bSrrh struct blk *
dcsqrt(p)7832177257bStorek dcsqrt(p)
7843a9a0a5bSrrh struct blk *p;
7853a9a0a5bSrrh {
7863a9a0a5bSrrh struct blk *t;
7873a9a0a5bSrrh struct blk *r,*q,*s;
7883a9a0a5bSrrh int c,n,nn;
7893a9a0a5bSrrh
7903a9a0a5bSrrh n = length(p);
7913a9a0a5bSrrh fsfile(p);
7923a9a0a5bSrrh c = sbackc(p);
7933a9a0a5bSrrh if((n&1) != 1)c = c*100+(sfbeg(p)?0:sbackc(p));
7943a9a0a5bSrrh n = (n+1)>>1;
7953a9a0a5bSrrh r = salloc(n);
7963a9a0a5bSrrh zero(r);
7973a9a0a5bSrrh seekc(r,n);
7983a9a0a5bSrrh nn=1;
7993a9a0a5bSrrh while((c -= nn)>=0)nn+=2;
8003a9a0a5bSrrh c=(nn+1)>>1;
8013a9a0a5bSrrh fsfile(r);
8023a9a0a5bSrrh sbackc(r);
8033a9a0a5bSrrh if(c>=100){
8043a9a0a5bSrrh c -= 100;
8053a9a0a5bSrrh salterc(r,c);
8063a9a0a5bSrrh sputc(r,1);
8073a9a0a5bSrrh }
8083a9a0a5bSrrh else salterc(r,c);
8093a9a0a5bSrrh while(1){
8103a9a0a5bSrrh q = div(p,r);
8113a9a0a5bSrrh s = add(q,r);
8123a9a0a5bSrrh release(q);
8133a9a0a5bSrrh release(rem);
8143a9a0a5bSrrh q = div(s,sqtemp);
8153a9a0a5bSrrh release(s);
8163a9a0a5bSrrh release(rem);
8173a9a0a5bSrrh s = copy(r,length(r));
8183a9a0a5bSrrh chsign(s);
8193a9a0a5bSrrh t = add(s,q);
8203a9a0a5bSrrh release(s);
8213a9a0a5bSrrh fsfile(t);
8223a9a0a5bSrrh nn = sfbeg(t)?0:sbackc(t);
8233a9a0a5bSrrh if(nn>=0)break;
8243a9a0a5bSrrh release(r);
8253a9a0a5bSrrh release(t);
8263a9a0a5bSrrh r = q;
8273a9a0a5bSrrh }
8283a9a0a5bSrrh release(t);
8293a9a0a5bSrrh release(q);
8303a9a0a5bSrrh release(p);
8313a9a0a5bSrrh return(r);
8323a9a0a5bSrrh }
8333a9a0a5bSrrh struct blk *
exp(base,ex)8343a9a0a5bSrrh exp(base,ex)
8353a9a0a5bSrrh struct blk *base,*ex;
8363a9a0a5bSrrh {
8373a9a0a5bSrrh register struct blk *r,*e,*p;
8383a9a0a5bSrrh struct blk *e1,*t,*cp;
8393a9a0a5bSrrh int temp,c,n;
8403a9a0a5bSrrh r = salloc(1);
8413a9a0a5bSrrh sputc(r,1);
8423a9a0a5bSrrh p = copy(base,length(base));
8433a9a0a5bSrrh e = copy(ex,length(ex));
8443a9a0a5bSrrh fsfile(e);
8453a9a0a5bSrrh if(sfbeg(e) != 0)goto edone;
8463a9a0a5bSrrh temp=0;
8473a9a0a5bSrrh c = sbackc(e);
8483a9a0a5bSrrh if(c<0){
8493a9a0a5bSrrh temp++;
8503a9a0a5bSrrh chsign(e);
8513a9a0a5bSrrh }
8523a9a0a5bSrrh while(length(e) != 0){
8533a9a0a5bSrrh e1=div(e,sqtemp);
8543a9a0a5bSrrh release(e);
8553a9a0a5bSrrh e = e1;
8563a9a0a5bSrrh n = length(rem);
8573a9a0a5bSrrh release(rem);
8583a9a0a5bSrrh if(n != 0){
8593a9a0a5bSrrh e1=mult(p,r);
8603a9a0a5bSrrh release(r);
8613a9a0a5bSrrh r = e1;
8623a9a0a5bSrrh }
8633a9a0a5bSrrh t = copy(p,length(p));
8643a9a0a5bSrrh cp = mult(p,t);
8653a9a0a5bSrrh release(p);
8663a9a0a5bSrrh release(t);
8673a9a0a5bSrrh p = cp;
8683a9a0a5bSrrh }
8693a9a0a5bSrrh if(temp != 0){
8703a9a0a5bSrrh if((c = length(base)) == 0){
8713a9a0a5bSrrh goto edone;
8723a9a0a5bSrrh }
8733a9a0a5bSrrh if(c>1)create(r);
8743a9a0a5bSrrh else{
8753a9a0a5bSrrh rewind(base);
8763a9a0a5bSrrh if((c = sgetc(base))<=1){
8773a9a0a5bSrrh create(r);
8783a9a0a5bSrrh sputc(r,c);
8793a9a0a5bSrrh }
8803a9a0a5bSrrh else create(r);
8813a9a0a5bSrrh }
8823a9a0a5bSrrh }
8833a9a0a5bSrrh edone:
8843a9a0a5bSrrh release(p);
8853a9a0a5bSrrh release(e);
8863a9a0a5bSrrh return(r);
8873a9a0a5bSrrh }
init(argc,argv)8883a9a0a5bSrrh init(argc,argv)
8893a9a0a5bSrrh int argc;
8903a9a0a5bSrrh char *argv[];
8913a9a0a5bSrrh {
8923a9a0a5bSrrh register struct sym *sp;
8933a9a0a5bSrrh
8943a9a0a5bSrrh if (signal(SIGINT, SIG_IGN) != SIG_IGN)
8953a9a0a5bSrrh signal(SIGINT,onintr);
8963a9a0a5bSrrh setbuf(stdout,(char *)NULL);
8973a9a0a5bSrrh svargc = --argc;
8983a9a0a5bSrrh svargv = argv;
8993a9a0a5bSrrh while(svargc>0 && svargv[1][0] == '-'){
9003a9a0a5bSrrh switch(svargv[1][1]){
9013a9a0a5bSrrh default:
9023a9a0a5bSrrh dbg=1;
9033a9a0a5bSrrh }
9043a9a0a5bSrrh svargc--;
9053a9a0a5bSrrh svargv++;
9063a9a0a5bSrrh }
9073a9a0a5bSrrh ifile=1;
9083a9a0a5bSrrh if(svargc<=0)curfile = stdin;
9093a9a0a5bSrrh else if((curfile = fopen(svargv[1],"r")) == NULL){
9103a9a0a5bSrrh printf("can't open file %s\n",svargv[1]);
9113a9a0a5bSrrh exit(1);
9123a9a0a5bSrrh }
9133a9a0a5bSrrh scalptr = salloc(1);
9143a9a0a5bSrrh sputc(scalptr,0);
9153a9a0a5bSrrh basptr = salloc(1);
9163a9a0a5bSrrh sputc(basptr,10);
9173a9a0a5bSrrh obase=10;
9183a9a0a5bSrrh log10=log2(10L);
9193a9a0a5bSrrh ll=70;
9203a9a0a5bSrrh fw=1;
9213a9a0a5bSrrh fw1=0;
9223a9a0a5bSrrh tenptr = salloc(1);
9233a9a0a5bSrrh sputc(tenptr,10);
9243a9a0a5bSrrh obase=10;
9253a9a0a5bSrrh inbas = salloc(1);
9263a9a0a5bSrrh sputc(inbas,10);
9273a9a0a5bSrrh sqtemp = salloc(1);
9283a9a0a5bSrrh sputc(sqtemp,2);
9293a9a0a5bSrrh chptr = salloc(0);
9303a9a0a5bSrrh strptr = salloc(0);
9313a9a0a5bSrrh divxyz = salloc(0);
9323a9a0a5bSrrh stkbeg = stkptr = &stack[0];
9333a9a0a5bSrrh stkend = &stack[STKSZ];
9343a9a0a5bSrrh stkerr = 0;
9353a9a0a5bSrrh readptr = &readstk[0];
9363a9a0a5bSrrh k=0;
9373a9a0a5bSrrh sp = sptr = &symlst[0];
93873464c87Ssam while(sptr < &symlst[TBLSZ-1]){
9393a9a0a5bSrrh sptr->next = ++sp;
9403a9a0a5bSrrh sptr++;
9413a9a0a5bSrrh }
9423a9a0a5bSrrh sptr->next=0;
9433a9a0a5bSrrh sfree = &symlst[0];
9443a9a0a5bSrrh return;
9453a9a0a5bSrrh }
9462bdf30e8Sbostic void
onintr()9473a9a0a5bSrrh onintr(){
9483a9a0a5bSrrh
9493a9a0a5bSrrh signal(SIGINT,onintr);
9503a9a0a5bSrrh while(readptr != &readstk[0]){
9513a9a0a5bSrrh if(*readptr != 0){release(*readptr);}
9523a9a0a5bSrrh readptr--;
9533a9a0a5bSrrh }
9543a9a0a5bSrrh curfile = stdin;
9553a9a0a5bSrrh commnds();
9563a9a0a5bSrrh }
9573a9a0a5bSrrh pushp(p)
9583a9a0a5bSrrh struct blk *p;
9593a9a0a5bSrrh {
9603a9a0a5bSrrh if(stkptr == stkend){
9613a9a0a5bSrrh printf("out of stack space\n");
9623a9a0a5bSrrh return;
9633a9a0a5bSrrh }
9643a9a0a5bSrrh stkerr=0;
9653a9a0a5bSrrh *++stkptr = p;
9663a9a0a5bSrrh return;
9673a9a0a5bSrrh }
9683a9a0a5bSrrh struct blk *
pop()9693a9a0a5bSrrh pop(){
9703a9a0a5bSrrh if(stkptr == stack){
9713a9a0a5bSrrh stkerr=1;
9723a9a0a5bSrrh return(0);
9733a9a0a5bSrrh }
9743a9a0a5bSrrh return(*stkptr--);
9753a9a0a5bSrrh }
9763a9a0a5bSrrh struct blk *
readin()9773a9a0a5bSrrh readin(){
9783a9a0a5bSrrh register struct blk *p,*q;
9793a9a0a5bSrrh int dp,dpct;
9803a9a0a5bSrrh register int c;
9813a9a0a5bSrrh
9823a9a0a5bSrrh dp = dpct=0;
9833a9a0a5bSrrh p = salloc(0);
9843a9a0a5bSrrh while(1){
9853a9a0a5bSrrh c = readc();
9863a9a0a5bSrrh switch(c){
9873a9a0a5bSrrh case '.':
9883a9a0a5bSrrh if(dp != 0){
9893a9a0a5bSrrh unreadc(c);
9903a9a0a5bSrrh break;
9913a9a0a5bSrrh }
9923a9a0a5bSrrh dp++;
9933a9a0a5bSrrh continue;
9943a9a0a5bSrrh case '\\':
9953a9a0a5bSrrh readc();
9963a9a0a5bSrrh continue;
9973a9a0a5bSrrh default:
9983a9a0a5bSrrh if(c >= 'A' && c <= 'F')c = c - 'A' + 10;
9993a9a0a5bSrrh else if(c >= '0' && c <= '9')c -= '0';
10003a9a0a5bSrrh else goto gotnum;
10013a9a0a5bSrrh if(dp != 0){
10023a9a0a5bSrrh if(dpct >= 99)continue;
10033a9a0a5bSrrh dpct++;
10043a9a0a5bSrrh }
10053a9a0a5bSrrh create(chptr);
10063a9a0a5bSrrh if(c != 0)sputc(chptr,c);
10073a9a0a5bSrrh q = mult(p,inbas);
10083a9a0a5bSrrh release(p);
10093a9a0a5bSrrh p = add(chptr,q);
10103a9a0a5bSrrh release(q);
10113a9a0a5bSrrh }
10123a9a0a5bSrrh }
10133a9a0a5bSrrh gotnum:
10143a9a0a5bSrrh unreadc(c);
10153a9a0a5bSrrh if(dp == 0){
10163a9a0a5bSrrh sputc(p,0);
10173a9a0a5bSrrh return(p);
10183a9a0a5bSrrh }
10193a9a0a5bSrrh else{
10203a9a0a5bSrrh q = scale(p,dpct);
10213a9a0a5bSrrh return(q);
10223a9a0a5bSrrh }
10233a9a0a5bSrrh }
10243a9a0a5bSrrh struct blk *
add0(p,ct)10253a9a0a5bSrrh add0(p,ct)
10263a9a0a5bSrrh int ct;
10273a9a0a5bSrrh struct blk *p;
10283a9a0a5bSrrh {
10293a9a0a5bSrrh /* returns pointer to struct with ct 0's & p */
10303a9a0a5bSrrh register struct blk *q,*t;
10313a9a0a5bSrrh
10323a9a0a5bSrrh q = salloc(length(p)+(ct+1)/2);
10333a9a0a5bSrrh while(ct>1){
10343a9a0a5bSrrh sputc(q,0);
10353a9a0a5bSrrh ct -= 2;
10363a9a0a5bSrrh }
10373a9a0a5bSrrh rewind(p);
10383a9a0a5bSrrh while(sfeof(p) == 0){
10393a9a0a5bSrrh sputc(q,sgetc(p));
10403a9a0a5bSrrh }
10413a9a0a5bSrrh release(p);
10423a9a0a5bSrrh if(ct == 1){
10433a9a0a5bSrrh t = mult(tenptr,q);
10443a9a0a5bSrrh release(q);
10453a9a0a5bSrrh return(t);
10463a9a0a5bSrrh }
10473a9a0a5bSrrh return(q);
10483a9a0a5bSrrh }
10493a9a0a5bSrrh struct blk *
mult(p,q)10503a9a0a5bSrrh mult(p,q)
10513a9a0a5bSrrh struct blk *p,*q;
10523a9a0a5bSrrh {
10533a9a0a5bSrrh register struct blk *mp,*mq,*mr;
10543a9a0a5bSrrh int sign,offset,carry;
10553a9a0a5bSrrh int cq,cp,mt,mcr;
10563a9a0a5bSrrh
10573a9a0a5bSrrh offset = sign = 0;
10583a9a0a5bSrrh fsfile(p);
10593a9a0a5bSrrh mp = p;
10603a9a0a5bSrrh if(sfbeg(p) == 0){
10613a9a0a5bSrrh if(sbackc(p)<0){
10623a9a0a5bSrrh mp = copy(p,length(p));
10633a9a0a5bSrrh chsign(mp);
10643a9a0a5bSrrh sign = ~sign;
10653a9a0a5bSrrh }
10663a9a0a5bSrrh }
10673a9a0a5bSrrh fsfile(q);
10683a9a0a5bSrrh mq = q;
10693a9a0a5bSrrh if(sfbeg(q) == 0){
10703a9a0a5bSrrh if(sbackc(q)<0){
10713a9a0a5bSrrh mq = copy(q,length(q));
10723a9a0a5bSrrh chsign(mq);
10733a9a0a5bSrrh sign = ~sign;
10743a9a0a5bSrrh }
10753a9a0a5bSrrh }
10763a9a0a5bSrrh mr = salloc(length(mp)+length(mq));
10773a9a0a5bSrrh zero(mr);
10783a9a0a5bSrrh rewind(mq);
10793a9a0a5bSrrh while(sfeof(mq) == 0){
10803a9a0a5bSrrh cq = sgetc(mq);
10813a9a0a5bSrrh rewind(mp);
10823a9a0a5bSrrh rewind(mr);
10833a9a0a5bSrrh mr->rd += offset;
10843a9a0a5bSrrh carry=0;
10853a9a0a5bSrrh while(sfeof(mp) == 0){
10863a9a0a5bSrrh cp = sgetc(mp);
10873a9a0a5bSrrh mcr = sfeof(mr)?0:slookc(mr);
10883a9a0a5bSrrh mt = cp*cq + carry + mcr;
10893a9a0a5bSrrh carry = mt/100;
10903a9a0a5bSrrh salterc(mr,mt%100);
10913a9a0a5bSrrh }
10923a9a0a5bSrrh offset++;
10933a9a0a5bSrrh if(carry != 0){
10943a9a0a5bSrrh mcr = sfeof(mr)?0:slookc(mr);
10953a9a0a5bSrrh salterc(mr,mcr+carry);
10963a9a0a5bSrrh }
10973a9a0a5bSrrh }
10983a9a0a5bSrrh if(sign < 0){
10993a9a0a5bSrrh chsign(mr);
11003a9a0a5bSrrh }
11013a9a0a5bSrrh if(mp != p)release(mp);
11023a9a0a5bSrrh if(mq != q)release(mq);
11033a9a0a5bSrrh return(mr);
11043a9a0a5bSrrh }
11053a9a0a5bSrrh chsign(p)
11063a9a0a5bSrrh struct blk *p;
11073a9a0a5bSrrh {
11083a9a0a5bSrrh register int carry;
11093a9a0a5bSrrh register char ct;
11103a9a0a5bSrrh
11113a9a0a5bSrrh carry=0;
11123a9a0a5bSrrh rewind(p);
11133a9a0a5bSrrh while(sfeof(p) == 0){
11143a9a0a5bSrrh ct=100-slookc(p)-carry;
11153a9a0a5bSrrh carry=1;
11163a9a0a5bSrrh if(ct>=100){
11173a9a0a5bSrrh ct -= 100;
11183a9a0a5bSrrh carry=0;
11193a9a0a5bSrrh }
11203a9a0a5bSrrh salterc(p,ct);
11213a9a0a5bSrrh }
11223a9a0a5bSrrh if(carry != 0){
11233a9a0a5bSrrh sputc(p,-1);
11243a9a0a5bSrrh fsfile(p);
11253a9a0a5bSrrh sbackc(p);
11263a9a0a5bSrrh ct = sbackc(p);
11273a9a0a5bSrrh if(ct == 99){
11283a9a0a5bSrrh truncate(p);
11293a9a0a5bSrrh sputc(p,-1);
11303a9a0a5bSrrh }
11313a9a0a5bSrrh }
11323a9a0a5bSrrh else{
11333a9a0a5bSrrh fsfile(p);
11343a9a0a5bSrrh ct = sbackc(p);
11353a9a0a5bSrrh if(ct == 0)truncate(p);
11363a9a0a5bSrrh }
11373a9a0a5bSrrh return;
11383a9a0a5bSrrh }
readc()11393a9a0a5bSrrh readc(){
11403a9a0a5bSrrh loop:
11413a9a0a5bSrrh if((readptr != &readstk[0]) && (*readptr != 0)){
11423a9a0a5bSrrh if(sfeof(*readptr) == 0)return(lastchar = sgetc(*readptr));
11433a9a0a5bSrrh release(*readptr);
11443a9a0a5bSrrh readptr--;
11453a9a0a5bSrrh goto loop;
11463a9a0a5bSrrh }
11473a9a0a5bSrrh lastchar = getc(curfile);
11483a9a0a5bSrrh if(lastchar != EOF)return(lastchar);
11493a9a0a5bSrrh if(readptr != &readptr[0]){
11503a9a0a5bSrrh readptr--;
11513a9a0a5bSrrh if(*readptr == 0)curfile = stdin;
11523a9a0a5bSrrh goto loop;
11533a9a0a5bSrrh }
11543a9a0a5bSrrh if(curfile != stdin){
11553a9a0a5bSrrh fclose(curfile);
11563a9a0a5bSrrh curfile = stdin;
11573a9a0a5bSrrh goto loop;
11583a9a0a5bSrrh }
11593a9a0a5bSrrh exit(0);
11603a9a0a5bSrrh }
unreadc(c)11613a9a0a5bSrrh unreadc(c)
11623a9a0a5bSrrh char c;
11633a9a0a5bSrrh {
11643a9a0a5bSrrh
11653a9a0a5bSrrh if((readptr != &readstk[0]) && (*readptr != 0)){
11663a9a0a5bSrrh sungetc(*readptr,c);
11673a9a0a5bSrrh }
11683a9a0a5bSrrh else ungetc(c,curfile);
11693a9a0a5bSrrh return;
11703a9a0a5bSrrh }
binop(c)11713a9a0a5bSrrh binop(c)
11723a9a0a5bSrrh char c;
11733a9a0a5bSrrh {
11743a9a0a5bSrrh register struct blk *r;
11753a9a0a5bSrrh
11763a9a0a5bSrrh switch(c){
11773a9a0a5bSrrh case '+':
11783a9a0a5bSrrh r = add(arg1,arg2);
11793a9a0a5bSrrh break;
11803a9a0a5bSrrh case '*':
11813a9a0a5bSrrh r = mult(arg1,arg2);
11823a9a0a5bSrrh break;
11833a9a0a5bSrrh case '/':
11843a9a0a5bSrrh r = div(arg1,arg2);
11853a9a0a5bSrrh break;
11863a9a0a5bSrrh }
11873a9a0a5bSrrh release(arg1);
11883a9a0a5bSrrh release(arg2);
11893a9a0a5bSrrh sputc(r,savk);
11903a9a0a5bSrrh pushp(r);
11913a9a0a5bSrrh return;
11923a9a0a5bSrrh }
11933a9a0a5bSrrh print(hptr)
11943a9a0a5bSrrh struct blk *hptr;
11953a9a0a5bSrrh {
11963a9a0a5bSrrh int sc;
11973a9a0a5bSrrh register struct blk *p,*q,*dec;
11983a9a0a5bSrrh int dig,dout,ct;
11993a9a0a5bSrrh
12003a9a0a5bSrrh rewind(hptr);
12013a9a0a5bSrrh while(sfeof(hptr) == 0){
12023a9a0a5bSrrh if(sgetc(hptr)>99){
12033a9a0a5bSrrh rewind(hptr);
12043a9a0a5bSrrh while(sfeof(hptr) == 0){
12053a9a0a5bSrrh printf("%c",sgetc(hptr));
12063a9a0a5bSrrh }
12073a9a0a5bSrrh printf("\n");
12083a9a0a5bSrrh return;
12093a9a0a5bSrrh }
12103a9a0a5bSrrh }
12113a9a0a5bSrrh fsfile(hptr);
12123a9a0a5bSrrh sc = sbackc(hptr);
12133a9a0a5bSrrh if(sfbeg(hptr) != 0){
12143a9a0a5bSrrh printf("0\n");
12153a9a0a5bSrrh return;
12163a9a0a5bSrrh }
12173a9a0a5bSrrh count = ll;
12183a9a0a5bSrrh p = copy(hptr,length(hptr));
12193a9a0a5bSrrh sunputc(p);
12203a9a0a5bSrrh fsfile(p);
12213a9a0a5bSrrh if(sbackc(p)<0){
12223a9a0a5bSrrh chsign(p);
12233a9a0a5bSrrh OUTC('-');
12243a9a0a5bSrrh }
12253a9a0a5bSrrh if((obase == 0) || (obase == -1)){
12263a9a0a5bSrrh oneot(p,sc,'d');
12273a9a0a5bSrrh return;
12283a9a0a5bSrrh }
12293a9a0a5bSrrh if(obase == 1){
12303a9a0a5bSrrh oneot(p,sc,'1');
12313a9a0a5bSrrh return;
12323a9a0a5bSrrh }
12333a9a0a5bSrrh if(obase == 10){
12343a9a0a5bSrrh tenot(p,sc);
12353a9a0a5bSrrh return;
12363a9a0a5bSrrh }
12373a9a0a5bSrrh create(strptr);
12383a9a0a5bSrrh dig = log10*sc;
12393a9a0a5bSrrh dout = ((dig/10) + dig) /logo;
12403a9a0a5bSrrh dec = getdec(p,sc);
12413a9a0a5bSrrh p = removc(p,sc);
12423a9a0a5bSrrh while(length(p) != 0){
12433a9a0a5bSrrh q = div(p,basptr);
12443a9a0a5bSrrh release(p);
12453a9a0a5bSrrh p = q;
12463a9a0a5bSrrh (*outdit)(rem,0);
12473a9a0a5bSrrh }
12483a9a0a5bSrrh release(p);
12493a9a0a5bSrrh fsfile(strptr);
12503a9a0a5bSrrh while(sfbeg(strptr) == 0)OUTC(sbackc(strptr));
12513a9a0a5bSrrh if(sc == 0){
12523a9a0a5bSrrh release(dec);
12533a9a0a5bSrrh printf("\n");
12543a9a0a5bSrrh return;
12553a9a0a5bSrrh }
12563a9a0a5bSrrh create(strptr);
12573a9a0a5bSrrh OUTC('.');
12583a9a0a5bSrrh ct=0;
12593a9a0a5bSrrh do{
12603a9a0a5bSrrh q = mult(basptr,dec);
12613a9a0a5bSrrh release(dec);
12623a9a0a5bSrrh dec = getdec(q,sc);
12633a9a0a5bSrrh p = removc(q,sc);
12643a9a0a5bSrrh (*outdit)(p,1);
12653a9a0a5bSrrh }while(++ct < dout);
12663a9a0a5bSrrh release(dec);
12673a9a0a5bSrrh rewind(strptr);
12683a9a0a5bSrrh while(sfeof(strptr) == 0)OUTC(sgetc(strptr));
12693a9a0a5bSrrh printf("\n");
12703a9a0a5bSrrh return;
12713a9a0a5bSrrh }
12723a9a0a5bSrrh
12733a9a0a5bSrrh struct blk *
getdec(p,sc)12743a9a0a5bSrrh getdec(p,sc)
12753a9a0a5bSrrh struct blk *p;
12763a9a0a5bSrrh {
12773a9a0a5bSrrh int cc;
12783a9a0a5bSrrh register struct blk *q,*t,*s;
12793a9a0a5bSrrh
12803a9a0a5bSrrh rewind(p);
12813a9a0a5bSrrh if(length(p)*2 < sc){
12823a9a0a5bSrrh q = copy(p,length(p));
12833a9a0a5bSrrh return(q);
12843a9a0a5bSrrh }
12853a9a0a5bSrrh q = salloc(length(p));
12863a9a0a5bSrrh while(sc >= 1){
12873a9a0a5bSrrh sputc(q,sgetc(p));
12883a9a0a5bSrrh sc -= 2;
12893a9a0a5bSrrh }
12903a9a0a5bSrrh if(sc != 0){
12913a9a0a5bSrrh t = mult(q,tenptr);
12923a9a0a5bSrrh s = salloc(cc = length(q));
12933a9a0a5bSrrh release(q);
12943a9a0a5bSrrh rewind(t);
12953a9a0a5bSrrh while(cc-- > 0)sputc(s,sgetc(t));
12963a9a0a5bSrrh sputc(s,0);
12973a9a0a5bSrrh release(t);
12983a9a0a5bSrrh t = div(s,tenptr);
12993a9a0a5bSrrh release(s);
13003a9a0a5bSrrh release(rem);
13013a9a0a5bSrrh return(t);
13023a9a0a5bSrrh }
13033a9a0a5bSrrh return(q);
13043a9a0a5bSrrh }
13053a9a0a5bSrrh tenot(p,sc)
13063a9a0a5bSrrh struct blk *p;
13073a9a0a5bSrrh {
13083a9a0a5bSrrh register int c,f;
13093a9a0a5bSrrh
13103a9a0a5bSrrh fsfile(p);
13113a9a0a5bSrrh f=0;
13123a9a0a5bSrrh while((sfbeg(p) == 0) && ((p->rd-p->beg-1)*2 >= sc)){
13133a9a0a5bSrrh c = sbackc(p);
13143a9a0a5bSrrh if((c<10) && (f == 1))printf("0%d",c);
13153a9a0a5bSrrh else printf("%d",c);
13163a9a0a5bSrrh f=1;
13173a9a0a5bSrrh TEST2;
13183a9a0a5bSrrh }
13193a9a0a5bSrrh if(sc == 0){
13203a9a0a5bSrrh printf("\n");
13213a9a0a5bSrrh release(p);
13223a9a0a5bSrrh return;
13233a9a0a5bSrrh }
13243a9a0a5bSrrh if((p->rd-p->beg)*2 > sc){
13253a9a0a5bSrrh c = sbackc(p);
13263a9a0a5bSrrh printf("%d.",c/10);
13273a9a0a5bSrrh TEST2;
13283a9a0a5bSrrh OUTC(c%10 +'0');
13293a9a0a5bSrrh sc--;
13303a9a0a5bSrrh }
13313a9a0a5bSrrh else {
13323a9a0a5bSrrh OUTC('.');
13333a9a0a5bSrrh }
13343a9a0a5bSrrh if(sc > (p->rd-p->beg)*2){
13353a9a0a5bSrrh while(sc>(p->rd-p->beg)*2){
13363a9a0a5bSrrh OUTC('0');
13373a9a0a5bSrrh sc--;
13383a9a0a5bSrrh }
13393a9a0a5bSrrh }
13403a9a0a5bSrrh while(sc > 1){
13413a9a0a5bSrrh c = sbackc(p);
13423a9a0a5bSrrh if(c<10)printf("0%d",c);
13433a9a0a5bSrrh else printf("%d",c);
13443a9a0a5bSrrh sc -= 2;
13453a9a0a5bSrrh TEST2;
13463a9a0a5bSrrh }
13473a9a0a5bSrrh if(sc == 1){
13483a9a0a5bSrrh OUTC(sbackc(p)/10 +'0');
13493a9a0a5bSrrh }
13503a9a0a5bSrrh printf("\n");
13513a9a0a5bSrrh release(p);
13523a9a0a5bSrrh return;
13533a9a0a5bSrrh }
13543a9a0a5bSrrh oneot(p,sc,ch)
13553a9a0a5bSrrh struct blk *p;
13563a9a0a5bSrrh char ch;
13573a9a0a5bSrrh {
13583a9a0a5bSrrh register struct blk *q;
13593a9a0a5bSrrh
13603a9a0a5bSrrh q = removc(p,sc);
13613a9a0a5bSrrh create(strptr);
13623a9a0a5bSrrh sputc(strptr,-1);
13633a9a0a5bSrrh while(length(q)>0){
13643a9a0a5bSrrh p = add(strptr,q);
13653a9a0a5bSrrh release(q);
13663a9a0a5bSrrh q = p;
13673a9a0a5bSrrh OUTC(ch);
13683a9a0a5bSrrh }
13693a9a0a5bSrrh release(q);
13703a9a0a5bSrrh printf("\n");
13713a9a0a5bSrrh return;
13723a9a0a5bSrrh }
13733a9a0a5bSrrh hexot(p,flg)
13743a9a0a5bSrrh struct blk *p;
13753a9a0a5bSrrh {
13763a9a0a5bSrrh register int c;
13773a9a0a5bSrrh rewind(p);
13783a9a0a5bSrrh if(sfeof(p) != 0){
13793a9a0a5bSrrh sputc(strptr,'0');
13803a9a0a5bSrrh release(p);
13813a9a0a5bSrrh return;
13823a9a0a5bSrrh }
13833a9a0a5bSrrh c = sgetc(p);
13843a9a0a5bSrrh release(p);
13853a9a0a5bSrrh if(c >= 16){
13863a9a0a5bSrrh printf("hex digit > 16");
13873a9a0a5bSrrh return;
13883a9a0a5bSrrh }
13893a9a0a5bSrrh sputc(strptr,c<10?c+'0':c-10+'A');
13903a9a0a5bSrrh return;
13913a9a0a5bSrrh }
13923a9a0a5bSrrh bigot(p,flg)
13933a9a0a5bSrrh struct blk *p;
13943a9a0a5bSrrh {
13953a9a0a5bSrrh register struct blk *t,*q;
13963a9a0a5bSrrh register int l;
13973a9a0a5bSrrh int neg;
13983a9a0a5bSrrh
13993a9a0a5bSrrh if(flg == 1)t = salloc(0);
14003a9a0a5bSrrh else{
14013a9a0a5bSrrh t = strptr;
14023a9a0a5bSrrh l = length(strptr)+fw-1;
14033a9a0a5bSrrh }
14043a9a0a5bSrrh neg=0;
14053a9a0a5bSrrh if(length(p) != 0){
14063a9a0a5bSrrh fsfile(p);
14073a9a0a5bSrrh if(sbackc(p)<0){
14083a9a0a5bSrrh neg=1;
14093a9a0a5bSrrh chsign(p);
14103a9a0a5bSrrh }
14113a9a0a5bSrrh while(length(p) != 0){
14123a9a0a5bSrrh q = div(p,tenptr);
14133a9a0a5bSrrh release(p);
14143a9a0a5bSrrh p = q;
14153a9a0a5bSrrh rewind(rem);
14163a9a0a5bSrrh sputc(t,sfeof(rem)?'0':sgetc(rem)+'0');
14173a9a0a5bSrrh release(rem);
14183a9a0a5bSrrh }
14193a9a0a5bSrrh }
14203a9a0a5bSrrh release(p);
14213a9a0a5bSrrh if(flg == 1){
14223a9a0a5bSrrh l = fw1-length(t);
14233a9a0a5bSrrh if(neg != 0){
14243a9a0a5bSrrh l--;
14253a9a0a5bSrrh sputc(strptr,'-');
14263a9a0a5bSrrh }
14273a9a0a5bSrrh fsfile(t);
14283a9a0a5bSrrh while(l-- > 0)sputc(strptr,'0');
14293a9a0a5bSrrh while(sfbeg(t) == 0)sputc(strptr,sbackc(t));
14303a9a0a5bSrrh release(t);
14313a9a0a5bSrrh }
14323a9a0a5bSrrh else{
14333a9a0a5bSrrh l -= length(strptr);
14343a9a0a5bSrrh while(l-- > 0)sputc(strptr,'0');
14353a9a0a5bSrrh if(neg != 0){
14363a9a0a5bSrrh sunputc(strptr);
14373a9a0a5bSrrh sputc(strptr,'-');
14383a9a0a5bSrrh }
14393a9a0a5bSrrh }
14403a9a0a5bSrrh sputc(strptr,' ');
14413a9a0a5bSrrh return;
14423a9a0a5bSrrh }
14433a9a0a5bSrrh struct blk *
add(a1,a2)14443a9a0a5bSrrh add(a1,a2)
14453a9a0a5bSrrh struct blk *a1,*a2;
14463a9a0a5bSrrh {
14473a9a0a5bSrrh register struct blk *p;
14483a9a0a5bSrrh register int carry,n;
14493a9a0a5bSrrh int size;
14503a9a0a5bSrrh int c,n1,n2;
14513a9a0a5bSrrh
14523a9a0a5bSrrh size = length(a1)>length(a2)?length(a1):length(a2);
14533a9a0a5bSrrh p = salloc(size);
14543a9a0a5bSrrh rewind(a1);
14553a9a0a5bSrrh rewind(a2);
14563a9a0a5bSrrh carry=0;
14573a9a0a5bSrrh while(--size >= 0){
14583a9a0a5bSrrh n1 = sfeof(a1)?0:sgetc(a1);
14593a9a0a5bSrrh n2 = sfeof(a2)?0:sgetc(a2);
14603a9a0a5bSrrh n = n1 + n2 + carry;
14613a9a0a5bSrrh if(n>=100){
14623a9a0a5bSrrh carry=1;
14633a9a0a5bSrrh n -= 100;
14643a9a0a5bSrrh }
14653a9a0a5bSrrh else if(n<0){
14663a9a0a5bSrrh carry = -1;
14673a9a0a5bSrrh n += 100;
14683a9a0a5bSrrh }
14693a9a0a5bSrrh else carry = 0;
14703a9a0a5bSrrh sputc(p,n);
14713a9a0a5bSrrh }
14723a9a0a5bSrrh if(carry != 0)sputc(p,carry);
14733a9a0a5bSrrh fsfile(p);
14743a9a0a5bSrrh if(sfbeg(p) == 0){
14753a9a0a5bSrrh while(sfbeg(p) == 0 && (c = sbackc(p)) == 0);
14763a9a0a5bSrrh if(c != 0)salterc(p,c);
14773a9a0a5bSrrh truncate(p);
14783a9a0a5bSrrh }
14793a9a0a5bSrrh fsfile(p);
14803a9a0a5bSrrh if(sfbeg(p) == 0 && sbackc(p) == -1){
14813a9a0a5bSrrh while((c = sbackc(p)) == 99){
14823a9a0a5bSrrh if(c == EOF)break;
14833a9a0a5bSrrh }
14843a9a0a5bSrrh sgetc(p);
14853a9a0a5bSrrh salterc(p,-1);
14863a9a0a5bSrrh truncate(p);
14873a9a0a5bSrrh }
14883a9a0a5bSrrh return(p);
14893a9a0a5bSrrh }
eqk()14903a9a0a5bSrrh eqk(){
14913a9a0a5bSrrh register struct blk *p,*q;
14923a9a0a5bSrrh register int skp;
14933a9a0a5bSrrh int skq;
14943a9a0a5bSrrh
14953a9a0a5bSrrh p = pop();
14963a9a0a5bSrrh EMPTYS;
14973a9a0a5bSrrh q = pop();
14983a9a0a5bSrrh EMPTYSR(p);
14993a9a0a5bSrrh skp = sunputc(p);
15003a9a0a5bSrrh skq = sunputc(q);
15013a9a0a5bSrrh if(skp == skq){
15023a9a0a5bSrrh arg1=p;
15033a9a0a5bSrrh arg2=q;
15043a9a0a5bSrrh savk = skp;
15053a9a0a5bSrrh return(0);
15063a9a0a5bSrrh }
15073a9a0a5bSrrh else if(skp < skq){
15083a9a0a5bSrrh savk = skq;
15093a9a0a5bSrrh p = add0(p,skq-skp);
15103a9a0a5bSrrh }
15113a9a0a5bSrrh else {
15123a9a0a5bSrrh savk = skp;
15133a9a0a5bSrrh q = add0(q,skp-skq);
15143a9a0a5bSrrh }
15153a9a0a5bSrrh arg1=p;
15163a9a0a5bSrrh arg2=q;
15173a9a0a5bSrrh return(0);
15183a9a0a5bSrrh }
15193a9a0a5bSrrh struct blk *
removc(p,n)15203a9a0a5bSrrh removc(p,n)
15213a9a0a5bSrrh struct blk *p;
15223a9a0a5bSrrh {
15233a9a0a5bSrrh register struct blk *q,*r;
15243a9a0a5bSrrh
15253a9a0a5bSrrh rewind(p);
15263a9a0a5bSrrh while(n>1){
15273a9a0a5bSrrh sgetc(p);
15283a9a0a5bSrrh n -= 2;
15293a9a0a5bSrrh }
15303a9a0a5bSrrh q = salloc(2);
15313a9a0a5bSrrh while(sfeof(p) == 0)sputc(q,sgetc(p));
15323a9a0a5bSrrh if(n == 1){
15333a9a0a5bSrrh r = div(q,tenptr);
15343a9a0a5bSrrh release(q);
15353a9a0a5bSrrh release(rem);
15363a9a0a5bSrrh q = r;
15373a9a0a5bSrrh }
15383a9a0a5bSrrh release(p);
15393a9a0a5bSrrh return(q);
15403a9a0a5bSrrh }
15413a9a0a5bSrrh struct blk *
scalint(p)15423a9a0a5bSrrh scalint(p)
15433a9a0a5bSrrh struct blk *p;
15443a9a0a5bSrrh {
15453a9a0a5bSrrh register int n;
15463a9a0a5bSrrh n = sunputc(p);
15473a9a0a5bSrrh p = removc(p,n);
15483a9a0a5bSrrh return(p);
15493a9a0a5bSrrh }
15503a9a0a5bSrrh struct blk *
scale(p,n)15513a9a0a5bSrrh scale(p,n)
15523a9a0a5bSrrh struct blk *p;
15533a9a0a5bSrrh {
15543a9a0a5bSrrh register struct blk *q,*s,*t;
15553a9a0a5bSrrh
15563a9a0a5bSrrh t = add0(p,n);
15573a9a0a5bSrrh q = salloc(1);
15583a9a0a5bSrrh sputc(q,n);
15593a9a0a5bSrrh s = exp(inbas,q);
15603a9a0a5bSrrh release(q);
15613a9a0a5bSrrh q = div(t,s);
15623a9a0a5bSrrh release(t);
15633a9a0a5bSrrh release(s);
15643a9a0a5bSrrh release(rem);
15653a9a0a5bSrrh sputc(q,n);
15663a9a0a5bSrrh return(q);
15673a9a0a5bSrrh }
subt()15683a9a0a5bSrrh subt(){
15693a9a0a5bSrrh arg1=pop();
15703a9a0a5bSrrh EMPTYS;
15713a9a0a5bSrrh savk = sunputc(arg1);
15723a9a0a5bSrrh chsign(arg1);
15733a9a0a5bSrrh sputc(arg1,savk);
15743a9a0a5bSrrh pushp(arg1);
15753a9a0a5bSrrh if(eqk() != 0)return(1);
15763a9a0a5bSrrh binop('+');
15773a9a0a5bSrrh return(0);
15783a9a0a5bSrrh }
command()15793a9a0a5bSrrh command(){
15803a9a0a5bSrrh int c;
15813a9a0a5bSrrh char line[100],*sl;
15822bdf30e8Sbostic register int pid, rpid;
15832bdf30e8Sbostic sig_t savint;
15843a9a0a5bSrrh int retcode;
15853a9a0a5bSrrh
15863a9a0a5bSrrh switch(c = readc()){
15873a9a0a5bSrrh case '<':
15883a9a0a5bSrrh return(cond(NL));
15893a9a0a5bSrrh case '>':
15903a9a0a5bSrrh return(cond(NG));
15913a9a0a5bSrrh case '=':
15923a9a0a5bSrrh return(cond(NE));
15933a9a0a5bSrrh default:
15943a9a0a5bSrrh sl = line;
15953a9a0a5bSrrh *sl++ = c;
15963a9a0a5bSrrh while((c = readc()) != '\n')*sl++ = c;
15973a9a0a5bSrrh *sl = 0;
15983a9a0a5bSrrh if((pid = fork()) == 0){
159979f069a4Sbostic execl(_PATH_BSHELL,"sh","-c",line,0);
16003a9a0a5bSrrh exit(0100);
16013a9a0a5bSrrh }
16023a9a0a5bSrrh savint = signal(SIGINT, SIG_IGN);
16033a9a0a5bSrrh while((rpid = wait(&retcode)) != pid && rpid != -1);
16043a9a0a5bSrrh signal(SIGINT,savint);
16053a9a0a5bSrrh printf("!\n");
16063a9a0a5bSrrh return(0);
16073a9a0a5bSrrh }
16083a9a0a5bSrrh }
cond(c)16093a9a0a5bSrrh cond(c)
16103a9a0a5bSrrh char c;
16113a9a0a5bSrrh {
16123a9a0a5bSrrh register struct blk *p;
16133a9a0a5bSrrh register char cc;
16143a9a0a5bSrrh
16153a9a0a5bSrrh if(subt() != 0)return(1);
16163a9a0a5bSrrh p = pop();
16173a9a0a5bSrrh sunputc(p);
16183a9a0a5bSrrh if(length(p) == 0){
16193a9a0a5bSrrh release(p);
16203a9a0a5bSrrh if(c == '<' || c == '>' || c == NE){
16213a9a0a5bSrrh readc();
16223a9a0a5bSrrh return(0);
16233a9a0a5bSrrh }
16243a9a0a5bSrrh load();
16253a9a0a5bSrrh return(1);
16263a9a0a5bSrrh }
16273a9a0a5bSrrh else {
16283a9a0a5bSrrh if(c == '='){
16293a9a0a5bSrrh release(p);
16303a9a0a5bSrrh readc();
16313a9a0a5bSrrh return(0);
16323a9a0a5bSrrh }
16333a9a0a5bSrrh }
16343a9a0a5bSrrh if(c == NE){
16353a9a0a5bSrrh release(p);
16363a9a0a5bSrrh load();
16373a9a0a5bSrrh return(1);
16383a9a0a5bSrrh }
16393a9a0a5bSrrh fsfile(p);
16403a9a0a5bSrrh cc = sbackc(p);
16413a9a0a5bSrrh release(p);
16423a9a0a5bSrrh if((cc<0 && (c == '<' || c == NG)) ||
16433a9a0a5bSrrh (cc >0) && (c == '>' || c == NL)){
16443a9a0a5bSrrh readc();
16453a9a0a5bSrrh return(0);
16463a9a0a5bSrrh }
16473a9a0a5bSrrh load();
16483a9a0a5bSrrh return(1);
16493a9a0a5bSrrh }
load()16503a9a0a5bSrrh load(){
16513a9a0a5bSrrh register int c;
16523a9a0a5bSrrh register struct blk *p,*q;
16533a9a0a5bSrrh struct blk *t,*s;
16543a9a0a5bSrrh c = readc() & 0377;
16553a9a0a5bSrrh sptr = stable[c];
16563a9a0a5bSrrh if(sptr != 0){
16573a9a0a5bSrrh p = sptr->val;
16583a9a0a5bSrrh if(c >= ARRAYST){
16593a9a0a5bSrrh q = salloc(length(p));
16603a9a0a5bSrrh rewind(p);
16613a9a0a5bSrrh while(sfeof(p) == 0){
16623a9a0a5bSrrh s = getwd(p);
16633a9a0a5bSrrh if(s == 0){putwd(q, (struct blk *)NULL);}
16643a9a0a5bSrrh else{
16653a9a0a5bSrrh t = copy(s,length(s));
16663a9a0a5bSrrh putwd(q,t);
16673a9a0a5bSrrh }
16683a9a0a5bSrrh }
16693a9a0a5bSrrh pushp(q);
16703a9a0a5bSrrh }
16713a9a0a5bSrrh else{
16723a9a0a5bSrrh q = copy(p,length(p));
16733a9a0a5bSrrh pushp(q);
16743a9a0a5bSrrh }
16753a9a0a5bSrrh }
16763a9a0a5bSrrh else{
16773a9a0a5bSrrh q = salloc(1);
16783a9a0a5bSrrh sputc(q,0);
16793a9a0a5bSrrh pushp(q);
16803a9a0a5bSrrh }
16813a9a0a5bSrrh return;
16823a9a0a5bSrrh }
log2(n)16833a9a0a5bSrrh log2(n)
16843a9a0a5bSrrh long n;
16853a9a0a5bSrrh {
16863a9a0a5bSrrh register int i;
16873a9a0a5bSrrh
16883a9a0a5bSrrh if(n == 0)return(0);
16893a9a0a5bSrrh i=31;
16903a9a0a5bSrrh if(n<0)return(i);
16913a9a0a5bSrrh while((n= n<<1) >0)i--;
16923a9a0a5bSrrh return(--i);
16933a9a0a5bSrrh }
16943a9a0a5bSrrh
16953a9a0a5bSrrh struct blk *
salloc(size)16963a9a0a5bSrrh salloc(size)
16973a9a0a5bSrrh int size;
16983a9a0a5bSrrh {
16993a9a0a5bSrrh register struct blk *hdr;
17003a9a0a5bSrrh register char *ptr;
17013a9a0a5bSrrh all++;
17023a9a0a5bSrrh nbytes += size;
17033a9a0a5bSrrh ptr = malloc((unsigned)size);
17043a9a0a5bSrrh if(ptr == 0){
17053a9a0a5bSrrh garbage("salloc");
17063a9a0a5bSrrh if((ptr = malloc((unsigned)size)) == 0)
17073a9a0a5bSrrh ospace("salloc");
17083a9a0a5bSrrh }
17093a9a0a5bSrrh if((hdr = hfree) == 0)hdr = morehd();
17103a9a0a5bSrrh hfree = (struct blk *)hdr->rd;
17113a9a0a5bSrrh hdr->rd = hdr->wt = hdr->beg = ptr;
17123a9a0a5bSrrh hdr->last = ptr+size;
17133a9a0a5bSrrh return(hdr);
17143a9a0a5bSrrh }
17153a9a0a5bSrrh struct blk *
morehd()17163a9a0a5bSrrh morehd(){
17173a9a0a5bSrrh register struct blk *h,*kk;
17183a9a0a5bSrrh headmor++;
17193a9a0a5bSrrh nbytes += HEADSZ;
17203a9a0a5bSrrh hfree = h = (struct blk *)malloc(HEADSZ);
17213a9a0a5bSrrh if(hfree == 0){
17223a9a0a5bSrrh garbage("morehd");
17233a9a0a5bSrrh if((hfree = h = (struct blk *)malloc(HEADSZ)) == 0)
17243a9a0a5bSrrh ospace("headers");
17253a9a0a5bSrrh }
17263a9a0a5bSrrh kk = h;
17273a9a0a5bSrrh while(h<hfree+(HEADSZ/BLK))(h++)->rd = (char *)++kk;
17283a9a0a5bSrrh (--h)->rd=0;
17293a9a0a5bSrrh return(hfree);
17303a9a0a5bSrrh }
17313a9a0a5bSrrh /*
17323a9a0a5bSrrh sunputc(hptr)
17333a9a0a5bSrrh struct blk *hptr;
17343a9a0a5bSrrh {
17353a9a0a5bSrrh hptr->wt--;
17363a9a0a5bSrrh hptr->rd = hptr->wt;
17373a9a0a5bSrrh return(*hptr->wt);
17383a9a0a5bSrrh }
17393a9a0a5bSrrh */
17403a9a0a5bSrrh struct blk *
copy(hptr,size)17413a9a0a5bSrrh copy(hptr,size)
17423a9a0a5bSrrh struct blk *hptr;
17433a9a0a5bSrrh int size;
17443a9a0a5bSrrh {
17453a9a0a5bSrrh register struct blk *hdr;
17463a9a0a5bSrrh register unsigned sz;
17473a9a0a5bSrrh register char *ptr;
17483a9a0a5bSrrh
17493a9a0a5bSrrh all++;
17503a9a0a5bSrrh nbytes += size;
17513a9a0a5bSrrh sz = length(hptr);
17523a9a0a5bSrrh ptr = nalloc(hptr->beg, (unsigned)size);
17533a9a0a5bSrrh if(ptr == 0){
17543a9a0a5bSrrh garbage("copy");
17553a9a0a5bSrrh if((ptr = nalloc(hptr->beg, (unsigned)size)) == NULL){
17563a9a0a5bSrrh printf("copy size %d\n",size);
17573a9a0a5bSrrh ospace("copy");
17583a9a0a5bSrrh }
17593a9a0a5bSrrh }
17603a9a0a5bSrrh if((hdr = hfree) == 0)hdr = morehd();
17613a9a0a5bSrrh hfree = (struct blk *)hdr->rd;
17623a9a0a5bSrrh hdr->rd = hdr->beg = ptr;
17633a9a0a5bSrrh hdr->last = ptr+size;
17643a9a0a5bSrrh hdr->wt = ptr+sz;
17653a9a0a5bSrrh ptr = hdr->wt;
17663a9a0a5bSrrh while(ptr<hdr->last)*ptr++ = '\0';
17673a9a0a5bSrrh return(hdr);
17683a9a0a5bSrrh }
sdump(s1,hptr)17693a9a0a5bSrrh sdump(s1,hptr)
17703a9a0a5bSrrh char *s1;
17713a9a0a5bSrrh struct blk *hptr;
17723a9a0a5bSrrh {
17733a9a0a5bSrrh char *p;
17743a9a0a5bSrrh printf("%s %o rd %o wt %o beg %o last %o\n",s1,hptr,hptr->rd,hptr->wt,hptr->beg,hptr->last);
17753a9a0a5bSrrh p = hptr->beg;
17763a9a0a5bSrrh while(p < hptr->wt)printf("%d ",*p++);
17773a9a0a5bSrrh printf("\n");
17783a9a0a5bSrrh }
17793a9a0a5bSrrh seekc(hptr,n)
17803a9a0a5bSrrh struct blk *hptr;
17813a9a0a5bSrrh {
17823a9a0a5bSrrh register char *nn,*p;
17833a9a0a5bSrrh
17843a9a0a5bSrrh nn = hptr->beg+n;
17853a9a0a5bSrrh if(nn > hptr->last){
17863a9a0a5bSrrh nbytes += nn - hptr->last;
17873a9a0a5bSrrh p = realloc(hptr->beg, (unsigned)n);
17883a9a0a5bSrrh if(p == 0){
17893a9a0a5bSrrh hptr->beg = realloc(hptr->beg, (unsigned)(hptr->last-hptr->beg));
17903a9a0a5bSrrh garbage("seekc");
17913a9a0a5bSrrh if((p = realloc(hptr->beg, (unsigned)n)) == 0)
17923a9a0a5bSrrh ospace("seekc");
17933a9a0a5bSrrh }
17943a9a0a5bSrrh hptr->beg = p;
17953a9a0a5bSrrh hptr->wt = hptr->last = hptr->rd = p+n;
17963a9a0a5bSrrh return;
17973a9a0a5bSrrh }
17983a9a0a5bSrrh hptr->rd = nn;
17993a9a0a5bSrrh if(nn>hptr->wt)hptr->wt = nn;
18003a9a0a5bSrrh return;
18013a9a0a5bSrrh }
18023a9a0a5bSrrh salterwd(hptr,n)
18033a9a0a5bSrrh struct wblk *hptr;
18043a9a0a5bSrrh struct blk *n;
18053a9a0a5bSrrh {
18063a9a0a5bSrrh if(hptr->rdw == hptr->lastw)more(hptr);
18073a9a0a5bSrrh *hptr->rdw++ = n;
18083a9a0a5bSrrh if(hptr->rdw > hptr->wtw)hptr->wtw = hptr->rdw;
18093a9a0a5bSrrh return;
18103a9a0a5bSrrh }
18113a9a0a5bSrrh more(hptr)
18123a9a0a5bSrrh struct blk *hptr;
18133a9a0a5bSrrh {
18143a9a0a5bSrrh register unsigned size;
18153a9a0a5bSrrh register char *p;
18163a9a0a5bSrrh
18173a9a0a5bSrrh if((size=(hptr->last-hptr->beg)*2) == 0)size=1;
18183a9a0a5bSrrh nbytes += size/2;
18193a9a0a5bSrrh p = realloc(hptr->beg, (unsigned)size);
18203a9a0a5bSrrh if(p == 0){
18213a9a0a5bSrrh hptr->beg = realloc(hptr->beg, (unsigned)(hptr->last-hptr->beg));
18223a9a0a5bSrrh garbage("more");
1823c56eff5bSlepreau if((p = realloc(hptr->beg,(unsigned)size)) == 0)
18243a9a0a5bSrrh ospace("more");
18253a9a0a5bSrrh }
18263a9a0a5bSrrh hptr->rd = hptr->rd-hptr->beg+p;
18273a9a0a5bSrrh hptr->wt = hptr->wt-hptr->beg+p;
18283a9a0a5bSrrh hptr->beg = p;
18293a9a0a5bSrrh hptr->last = p+size;
18303a9a0a5bSrrh return;
18313a9a0a5bSrrh }
ospace(s)18323a9a0a5bSrrh ospace(s)
18333a9a0a5bSrrh char *s;
18343a9a0a5bSrrh {
18353a9a0a5bSrrh printf("out of space: %s\n",s);
18363a9a0a5bSrrh printf("all %ld rel %ld headmor %ld\n",all,rel,headmor);
18373a9a0a5bSrrh printf("nbytes %ld\n",nbytes);
18383a9a0a5bSrrh sdump("stk",*stkptr);
18393a9a0a5bSrrh abort();
18403a9a0a5bSrrh }
garbage(s)18413a9a0a5bSrrh garbage(s)
18423a9a0a5bSrrh char *s;
18433a9a0a5bSrrh {
18443a9a0a5bSrrh int i;
18453a9a0a5bSrrh struct blk *p, *q;
18463a9a0a5bSrrh struct sym *tmps;
18473a9a0a5bSrrh int ct;
18483a9a0a5bSrrh
18493a9a0a5bSrrh /* printf("got to garbage %s\n",s); */
18503a9a0a5bSrrh for(i=0;i<TBLSZ;i++){
18513a9a0a5bSrrh tmps = stable[i];
18523a9a0a5bSrrh if(tmps != 0){
18533a9a0a5bSrrh if(i < ARRAYST){
18543a9a0a5bSrrh do {
18553a9a0a5bSrrh p = tmps->val;
18563a9a0a5bSrrh if(((int)p->beg & 01) != 0){
18573a9a0a5bSrrh printf("string %o\n",i);
18583a9a0a5bSrrh sdump("odd beg",p);
18593a9a0a5bSrrh }
18603a9a0a5bSrrh redef(p);
18613a9a0a5bSrrh tmps = tmps->next;
18623a9a0a5bSrrh } while(tmps != 0);
18633a9a0a5bSrrh continue;
18643a9a0a5bSrrh }
18653a9a0a5bSrrh else {
18663a9a0a5bSrrh do {
18673a9a0a5bSrrh p = tmps->val;
18683a9a0a5bSrrh rewind(p);
18693a9a0a5bSrrh ct = 0;
18703a9a0a5bSrrh while((q = getwd(p)) != NULL){
18713a9a0a5bSrrh ct++;
18723a9a0a5bSrrh if(q != 0){
18733a9a0a5bSrrh if(((int)q->beg & 01) != 0){
18743a9a0a5bSrrh printf("array %o elt %d odd\n",i-ARRAYST,ct);
18753a9a0a5bSrrh printf("tmps %o p %o\n",tmps,p);
18763a9a0a5bSrrh sdump("elt",q);
18773a9a0a5bSrrh }
18783a9a0a5bSrrh redef(q);
18793a9a0a5bSrrh }
18803a9a0a5bSrrh }
18813a9a0a5bSrrh tmps = tmps->next;
18823a9a0a5bSrrh } while(tmps != 0);
18833a9a0a5bSrrh }
18843a9a0a5bSrrh }
18853a9a0a5bSrrh }
18863a9a0a5bSrrh }
18873a9a0a5bSrrh redef(p)
18883a9a0a5bSrrh struct blk *p;
18893a9a0a5bSrrh {
18903a9a0a5bSrrh register offset;
18913a9a0a5bSrrh register char *newp;
18923a9a0a5bSrrh
18933a9a0a5bSrrh if ((int)p->beg&01) {
18943a9a0a5bSrrh printf("odd ptr %o hdr %o\n",p->beg,p);
18953a9a0a5bSrrh ospace("redef-bad");
18963a9a0a5bSrrh }
18973a9a0a5bSrrh newp = realloc(p->beg, (unsigned)(p->last-p->beg));
18983a9a0a5bSrrh if(newp == NULL)ospace("redef");
18993a9a0a5bSrrh offset = newp - p->beg;
19003a9a0a5bSrrh p->beg = newp;
19013a9a0a5bSrrh p->rd += offset;
19023a9a0a5bSrrh p->wt += offset;
19033a9a0a5bSrrh p->last += offset;
19043a9a0a5bSrrh }
19053a9a0a5bSrrh
release(p)19063a9a0a5bSrrh release(p)
19073a9a0a5bSrrh register struct blk *p;
19083a9a0a5bSrrh {
19093a9a0a5bSrrh rel++;
19103a9a0a5bSrrh nbytes -= p->last - p->beg;
19113a9a0a5bSrrh p->rd = (char *)hfree;
19123a9a0a5bSrrh hfree = p;
19133a9a0a5bSrrh free(p->beg);
19143a9a0a5bSrrh }
19153a9a0a5bSrrh
19163a9a0a5bSrrh struct blk *
getwd(p)19173a9a0a5bSrrh getwd(p)
19183a9a0a5bSrrh struct blk *p;
19193a9a0a5bSrrh {
19203a9a0a5bSrrh register struct wblk *wp;
19213a9a0a5bSrrh
19223a9a0a5bSrrh wp = (struct wblk *)p;
19233a9a0a5bSrrh if (wp->rdw == wp->wtw)
19243a9a0a5bSrrh return(NULL);
19253a9a0a5bSrrh return(*wp->rdw++);
19263a9a0a5bSrrh }
19273a9a0a5bSrrh
19283a9a0a5bSrrh putwd(p, c)
19293a9a0a5bSrrh struct blk *p, *c;
19303a9a0a5bSrrh {
19313a9a0a5bSrrh register struct wblk *wp;
19323a9a0a5bSrrh
19333a9a0a5bSrrh wp = (struct wblk *)p;
19343a9a0a5bSrrh if (wp->wtw == wp->lastw)
19353a9a0a5bSrrh more(p);
19363a9a0a5bSrrh *wp->wtw++ = c;
19373a9a0a5bSrrh }
19383a9a0a5bSrrh
19393a9a0a5bSrrh struct blk *
lookwd(p)19403a9a0a5bSrrh lookwd(p)
19413a9a0a5bSrrh struct blk *p;
19423a9a0a5bSrrh {
19433a9a0a5bSrrh register struct wblk *wp;
19443a9a0a5bSrrh
19453a9a0a5bSrrh wp = (struct wblk *)p;
19463a9a0a5bSrrh if (wp->rdw == wp->wtw)
19473a9a0a5bSrrh return(NULL);
19483a9a0a5bSrrh return(*wp->rdw);
19493a9a0a5bSrrh }
19503a9a0a5bSrrh char *
nalloc(p,nbytes)19513a9a0a5bSrrh nalloc(p,nbytes)
19523a9a0a5bSrrh register char *p;
19533a9a0a5bSrrh unsigned nbytes;
19543a9a0a5bSrrh {
19553a9a0a5bSrrh char *malloc();
19563a9a0a5bSrrh register char *q, *r;
19573a9a0a5bSrrh q = r = malloc(nbytes);
19583a9a0a5bSrrh if(q==0)
19593a9a0a5bSrrh return(0);
19603a9a0a5bSrrh while(nbytes--)
19613a9a0a5bSrrh *q++ = *p++;
19623a9a0a5bSrrh return(r);
19633a9a0a5bSrrh }
1964