![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / dc|
Return to dc.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / dc |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)dc.c 4.7 (Berkeley) 9/15/89";
3: #endif not lint
4:
5: #include <paths.h>
6: #include <sys/signal.h>
7: #include <stdio.h>
8: #include "dc.h"
9:
10: main(argc,argv)
11: int argc;
12: char *argv[];
13: {
14: init(argc,argv);
15: commnds();
16: }
17: commnds(){
18: register int c;
19: register struct blk *p,*q;
20: long l;
21: int sign;
22: struct blk **ptr,*s,*t;
23: struct sym *sp;
24: int sk,sk1,sk2;
25: int n,d;
26:
27: while(1){
28: if(((c = readc())>='0' && c <= '9')|| (c>='A' && c <='F') || c == '.'){
29: unreadc(c);
30: p = readin();
31: pushp(p);
32: continue;
33: }
34: switch(c){
35: case ' ':
36: case '\n':
37: case 0377:
38: case EOF:
39: continue;
40: case 'Y':
41: sdump("stk",*stkptr);
42: printf("all %ld rel %ld headmor %ld\n",all,rel,headmor);
43: printf("nbytes %ld\n",nbytes);
44: continue;
45: case '_':
46: p = readin();
47: savk = sunputc(p);
48: chsign(p);
49: sputc(p,savk);
50: pushp(p);
51: continue;
52: case '-':
53: subt();
54: continue;
55: case '+':
56: if(eqk() != 0)continue;
57: binop('+');
58: continue;
59: case '*':
60: arg1 = pop();
61: EMPTY;
62: arg2 = pop();
63: EMPTYR(arg1);
64: sk1 = sunputc(arg1);
65: sk2 = sunputc(arg2);
66: binop('*');
67: p = pop();
68: sunputc(p);
69: savk = n = sk1+sk2;
70: if(n>k && n>sk1 && n>sk2){
71: sk = sk1;
72: if(sk<sk2)sk = sk2;
73: if(sk<k)sk = k;
74: p = removc(p,n-sk);
75: savk = sk;
76: }
77: sputc(p,savk);
78: pushp(p);
79: continue;
80: case '/':
81: casediv:
82: if(dscale() != 0)continue;
83: binop('/');
84: if(irem != 0)release(irem);
85: release(rem);
86: continue;
87: case '%':
88: if(dscale() != 0)continue;
89: binop('/');
90: p = pop();
91: release(p);
92: if(irem == 0){
93: sputc(rem,skr+k);
94: pushp(rem);
95: continue;
96: }
97: p = add0(rem,skd-(skr+k));
98: q = add(p,irem);
99: release(p);
100: release(irem);
101: sputc(q,skd);
102: pushp(q);
103: continue;
104: case 'v':
105: p = pop();
106: EMPTY;
107: savk = sunputc(p);
108: if(length(p) == 0){
109: sputc(p,savk);
110: pushp(p);
111: continue;
112: }
113: if((c = sbackc(p))<0){
114: error("sqrt of neg number\n");
115: }
116: if(k<savk)n = savk;
117: else{
118: n = k*2-savk;
119: savk = k;
120: }
121: arg1 = add0(p,n);
122: arg2 = sqrt(arg1);
123: sputc(arg2,savk);
124: pushp(arg2);
125: continue;
126: case '^':
127: neg = 0;
128: arg1 = pop();
129: EMPTY;
130: if(sunputc(arg1) != 0)error("exp not an integer\n");
131: arg2 = pop();
132: EMPTYR(arg1);
133: if(sfbeg(arg1) == 0 && sbackc(arg1)<0){
134: neg++;
135: chsign(arg1);
136: }
137: if(length(arg1)>=3){
138: error("exp too big\n");
139: }
140: savk = sunputc(arg2);
141: p = exp(arg2,arg1);
142: release(arg2);
143: rewind(arg1);
144: c = sgetc(arg1);
145: if(sfeof(arg1) == 0)
146: c = sgetc(arg1)*100 + c;
147: d = c*savk;
148: release(arg1);
149: if(neg == 0){
150: if(k>=savk)n = k;
151: else n = savk;
152: if(n<d){
153: q = removc(p,d-n);
154: sputc(q,n);
155: pushp(q);
156: }
157: else {
158: sputc(p,d);
159: pushp(p);
160: }
161: }
162: else {
163: sputc(p,d);
164: pushp(p);
165: }
166: if(neg == 0)continue;
167: p = pop();
168: q = salloc(2);
169: sputc(q,1);
170: sputc(q,0);
171: pushp(q);
172: pushp(p);
173: goto casediv;
174: case 'z':
175: p = salloc(2);
176: n = stkptr - stkbeg;
177: if(n >= 100){
178: sputc(p,n/100);
179: n %= 100;
180: }
181: sputc(p,n);
182: sputc(p,0);
183: pushp(p);
184: continue;
185: case 'Z':
186: p = pop();
187: EMPTY;
188: n = (length(p)-1)<<1;
189: fsfile(p);
190: sbackc(p);
191: if(sfbeg(p) == 0){
192: if((c = sbackc(p))<0){
193: n -= 2;
194: if(sfbeg(p) == 1)n += 1;
195: else {
196: if((c = sbackc(p)) == 0)n += 1;
197: else if(c > 90)n -= 1;
198: }
199: }
200: else if(c < 10) n -= 1;
201: }
202: release(p);
203: q = salloc(1);
204: if(n >= 100){
205: sputc(q,n%100);
206: n /= 100;
207: }
208: sputc(q,n);
209: sputc(q,0);
210: pushp(q);
211: continue;
212: case 'i':
213: p = pop();
214: EMPTY;
215: p = scalint(p);
216: release(inbas);
217: inbas = p;
218: continue;
219: case 'I':
220: p = copy(inbas,length(inbas)+1);
221: sputc(p,0);
222: pushp(p);
223: continue;
224: case 'o':
225: p = pop();
226: EMPTY;
227: p = scalint(p);
228: sign = 0;
229: n = length(p);
230: q = copy(p,n);
231: fsfile(q);
232: l = c = sbackc(q);
233: if(n != 1){
234: if(c<0){
235: sign = 1;
236: chsign(q);
237: n = length(q);
238: fsfile(q);
239: l = c = sbackc(q);
240: }
241: if(n != 1){
242: while(sfbeg(q) == 0)l = l*100+sbackc(q);
243: }
244: }
245: logo = log2(l);
246: obase = l;
247: release(basptr);
248: if(sign == 1)obase = -l;
249: basptr = p;
250: outdit = bigot;
251: if(n == 1 && sign == 0){
252: if(c <= 16){
253: outdit = hexot;
254: fw = 1;
255: fw1 = 0;
256: ll = 70;
257: release(q);
258: continue;
259: }
260: }
261: n = 0;
262: if(sign == 1)n++;
263: p = salloc(1);
264: sputc(p,-1);
265: t = add(p,q);
266: n += length(t)*2;
267: fsfile(t);
268: if((c = sbackc(t))>9)n++;
269: release(t);
270: release(q);
271: release(p);
272: fw = n;
273: fw1 = n-1;
274: ll = 70;
275: if(fw>=ll)continue;
276: ll = (70/fw)*fw;
277: continue;
278: case 'O':
279: p = copy(basptr,length(basptr)+1);
280: sputc(p,0);
281: pushp(p);
282: continue;
283: case '[':
284: n = 0;
285: p = salloc(0);
286: while(1){
287: if((c = readc()) == ']'){
288: if(n == 0)break;
289: n--;
290: }
291: sputc(p,c);
292: if(c == '[')n++;
293: }
294: pushp(p);
295: continue;
296: case 'k':
297: p = pop();
298: EMPTY;
299: p = scalint(p);
300: if(length(p)>1){
301: error("scale too big\n");
302: }
303: rewind(p);
304: k = sfeof(p)?0:sgetc(p);
305: release(scalptr);
306: scalptr = p;
307: continue;
308: case 'K':
309: p = copy(scalptr,length(scalptr)+1);
310: sputc(p,0);
311: pushp(p);
312: continue;
313: case 'X':
314: p = pop();
315: EMPTY;
316: fsfile(p);
317: n = sbackc(p);
318: release(p);
319: p = salloc(2);
320: sputc(p,n);
321: sputc(p,0);
322: pushp(p);
323: continue;
324: case 'Q':
325: p = pop();
326: EMPTY;
327: if(length(p)>2){
328: error("Q?\n");
329: }
330: rewind(p);
331: if((c = sgetc(p))<0){
332: error("neg Q\n");
333: }
334: release(p);
335: while(c-- > 0){
336: if(readptr == &readstk[0]){
337: error("readstk?\n");
338: }
339: if(*readptr != 0)release(*readptr);
340: readptr--;
341: }
342: continue;
343: case 'q':
344: if(readptr <= &readstk[1])exit(0);
345: if(*readptr != 0)release(*readptr);
346: readptr--;
347: if(*readptr != 0)release(*readptr);
348: readptr--;
349: continue;
350: case 'f':
351: if(stkptr == &stack[0])printf("empty stack\n");
352: else {
353: for(ptr = stkptr; ptr > &stack[0];){
354: print(*ptr--);
355: }
356: }
357: continue;
358: case 'p':
359: if(stkptr == &stack[0])printf("empty stack\n");
360: else{
361: print(*stkptr);
362: }
363: continue;
364: case 'P':
365: p = pop();
366: EMPTY;
367: sputc(p,0);
368: printf("%s",p->beg);
369: release(p);
370: continue;
371: case 'd':
372: if(stkptr == &stack[0]){
373: printf("empty stack\n");
374: continue;
375: }
376: q = *stkptr;
377: n = length(q);
378: p = copy(*stkptr,n);
379: pushp(p);
380: continue;
381: case 'c':
382: while(stkerr == 0){
383: p = pop();
384: if(stkerr == 0)release(p);
385: }
386: continue;
387: case 'S':
388: if(stkptr == &stack[0]){
389: error("save: args\n");
390: }
391: c = readc() & 0377;
392: sptr = stable[c];
393: sp = stable[c] = sfree;
394: sfree = sfree->next;
395: if(sfree == 0)goto sempty;
396: sp->next = sptr;
397: p = pop();
398: EMPTY;
399: if(c >= ARRAYST){
400: q = copy(p,PTRSZ);
401: for(n = 0;n < PTRSZ-1;n++)sputc(q,0);
402: release(p);
403: p = q;
404: }
405: sp->val = p;
406: continue;
407: sempty:
408: error("symbol table overflow\n");
409: case 's':
410: if(stkptr == &stack[0]){
411: error("save:args\n");
412: }
413: c = readc() & 0377;
414: sptr = stable[c];
415: if(sptr != 0){
416: p = sptr->val;
417: if(c >= ARRAYST){
418: rewind(p);
419: while(sfeof(p) == 0)release(getwd(p));
420: }
421: release(p);
422: }
423: else{
424: sptr = stable[c] = sfree;
425: sfree = sfree->next;
426: if(sfree == 0)goto sempty;
427: sptr->next = 0;
428: }
429: p = pop();
430: sptr->val = p;
431: continue;
432: case 'l':
433: load();
434: continue;
435: case 'L':
436: c = readc() & 0377;
437: sptr = stable[c];
438: if(sptr == 0){
439: error("L?\n");
440: }
441: stable[c] = sptr->next;
442: sptr->next = sfree;
443: sfree = sptr;
444: p = sptr->val;
445: if(c >= ARRAYST){
446: rewind(p);
447: while(sfeof(p) == 0){
448: q = getwd(p);
449: if(q != 0)release(q);
450: }
451: }
452: pushp(p);
453: continue;
454: case ':':
455: p = pop();
456: EMPTY;
457: q = scalint(p);
458: fsfile(q);
459: c = 0;
460: if((sfbeg(q) == 0) && ((c = sbackc(q))<0)){
461: error("neg index\n");
462: }
463: if(length(q)>2){
464: error("index too big\n");
465: }
466: if(sfbeg(q) == 0)c = c*100+sbackc(q);
467: if(c >= MAXIND){
468: error("index too big\n");
469: }
470: release(q);
471: n = readc() & 0377;
472: sptr = stable[n];
473: if(sptr == 0){
474: sptr = stable[n] = sfree;
475: sfree = sfree->next;
476: if(sfree == 0)goto sempty;
477: sptr->next = 0;
478: p = salloc((c+PTRSZ)*PTRSZ);
479: zero(p);
480: }
481: else{
482: p = sptr->val;
483: if(length(p)-PTRSZ < c*PTRSZ){
484: q = copy(p,(c+PTRSZ)*PTRSZ);
485: release(p);
486: p = q;
487: }
488: }
489: seekc(p,c*PTRSZ);
490: q = lookwd(p);
491: if (q!=NULL) release(q);
492: s = pop();
493: EMPTY;
494: salterwd(p,s);
495: sptr->val = p;
496: continue;
497: case ';':
498: p = pop();
499: EMPTY;
500: q = scalint(p);
501: fsfile(q);
502: c = 0;
503: if((sfbeg(q) == 0) && ((c = sbackc(q))<0)){
504: error("neg index\n");
505: }
506: if(length(q)>2){
507: error("index too big\n");
508: }
509: if(sfbeg(q) == 0)c = c*100+sbackc(q);
510: if(c >= MAXIND){
511: error("index too big\n");
512: }
513: release(q);
514: n = readc() & 0377;
515: sptr = stable[n];
516: if(sptr != 0){
517: p = sptr->val;
518: if(length(p)-PTRSZ >= c*PTRSZ){
519: seekc(p,c*PTRSZ);
520: s = getwd(p);
521: if(s != 0){
522: q = copy(s,length(s));
523: pushp(q);
524: continue;
525: }
526: }
527: }
528: q = salloc(PTRSZ);
529: putwd(q, (struct blk *)0);
530: pushp(q);
531: continue;
532: case 'x':
533: execute:
534: p = pop();
535: EMPTY;
536: if((readptr != &readstk[0]) && (*readptr != 0)){
537: if((*readptr)->rd == (*readptr)->wt)
538: release(*readptr);
539: else{
540: if(readptr++ == &readstk[RDSKSZ]){
541: error("nesting depth\n");
542: }
543: }
544: }
545: else readptr++;
546: *readptr = p;
547: if(p != 0)rewind(p);
548: else{
549: if((c = readc()) != '\n')unreadc(c);
550: }
551: continue;
552: case '?':
553: if(++readptr == &readstk[RDSKSZ]){
554: error("nesting depth\n");
555: }
556: *readptr = 0;
557: fsave = curfile;
558: curfile = stdin;
559: while((c = readc()) == '!')command();
560: p = salloc(0);
561: sputc(p,c);
562: while((c = readc()) != '\n'){
563: sputc(p,c);
564: if(c == '\\')sputc(p,readc());
565: }
566: curfile = fsave;
567: *readptr = p;
568: continue;
569: case '!':
570: if(command() == 1)goto execute;
571: continue;
572: case '<':
573: case '>':
574: case '=':
575: if(cond(c) == 1)goto execute;
576: continue;
577: default:
578: printf("%o is unimplemented\n",c);
579: }
580: }
581: }
582: struct blk *
583: div(ddivd,ddivr)
584: struct blk *ddivd,*ddivr;
585: {
586: int divsign,remsign,offset,divcarry;
587: int carry, dig,magic,d,dd;
588: long c,td,cc;
589: struct blk *ps;
590: register struct blk *p,*divd,*divr;
591:
592: rem = 0;
593: p = salloc(0);
594: if(length(ddivr) == 0){
595: pushp(ddivr);
596: printf("divide by 0\n");
597: return((struct blk *)1);
598: }
599: divsign = remsign = 0;
600: divr = ddivr;
601: fsfile(divr);
602: if(sbackc(divr) == -1){
603: divr = copy(ddivr,length(ddivr));
604: chsign(divr);
605: divsign = ~divsign;
606: }
607: divd = copy(ddivd,length(ddivd));
608: fsfile(divd);
609: if(sfbeg(divd) == 0 && sbackc(divd) == -1){
610: chsign(divd);
611: divsign = ~divsign;
612: remsign = ~remsign;
613: }
614: offset = length(divd) - length(divr);
615: if(offset < 0)goto ddone;
616: seekc(p,offset+1);
617: sputc(divd,0);
618: magic = 0;
619: fsfile(divr);
620: c = sbackc(divr);
621: if(c<10)magic++;
622: c = c*100 + (sfbeg(divr)?0:sbackc(divr));
623: if(magic>0){
624: c = (c*100 +(sfbeg(divr)?0:sbackc(divr)))*2;
625: c /= 25;
626: }
627: while(offset >= 0){
628: fsfile(divd);
629: td = sbackc(divd)*100;
630: dd = sfbeg(divd)?0:sbackc(divd);
631: td = (td+dd)*100;
632: dd = sfbeg(divd)?0:sbackc(divd);
633: td = td+dd;
634: cc = c;
635: if(offset == 0)td += 1;
636: else cc += 1;
637: if(magic != 0)td = td<<3;
638: dig = td/cc;
639: rewind(divr);
640: rewind(divxyz);
641: carry = 0;
642: while(sfeof(divr) == 0){
643: d = sgetc(divr)*dig+carry;
644: carry = d / 100;
645: salterc(divxyz,d%100);
646: }
647: salterc(divxyz,carry);
648: rewind(divxyz);
649: seekc(divd,offset);
650: carry = 0;
651: while(sfeof(divd) == 0){
652: d = slookc(divd);
653: d = d-(sfeof(divxyz)?0:sgetc(divxyz))-carry;
654: carry = 0;
655: if(d < 0){
656: d += 100;
657: carry = 1;
658: }
659: salterc(divd,d);
660: }
661: divcarry = carry;
662: sbackc(p);
663: salterc(p,dig);
664: sbackc(p);
665: if(--offset >= 0){
666: if(d > 0){
667: sbackc(divd);
668: dd=sbackc(divd);
669: salterc(divd,dd+100);
670: }
671: divd->wt--;
672: }
673: }
674: if(divcarry != 0){
675: salterc(p,dig-1);
676: salterc(divd,-1);
677: ps = add(divr,divd);
678: release(divd);
679: divd = ps;
680: }
681:
682: rewind(p);
683: divcarry = 0;
684: while(sfeof(p) == 0){
685: d = slookc(p)+divcarry;
686: divcarry = 0;
687: if(d >= 100){
688: d -= 100;
689: divcarry = 1;
690: }
691: salterc(p,d);
692: }
693: if(divcarry != 0)salterc(p,divcarry);
694: fsfile(p);
695: while(sfbeg(p) == 0){
696: if(sbackc(p) == 0)truncate(p);
697: else break;
698: }
699: if(divsign < 0)chsign(p);
700: fsfile(divd);
701: while(sfbeg(divd) == 0){
702: if(sbackc(divd) == 0)truncate(divd);
703: else break;
704: }
705: ddone:
706: if(remsign<0)chsign(divd);
707: if(divr != ddivr)release(divr);
708: rem = divd;
709: return(p);
710: }
711: dscale(){
712: register struct blk *dd,*dr;
713: register struct blk *r;
714: int c;
715:
716: dr = pop();
717: EMPTYS;
718: dd = pop();
719: EMPTYSR(dr);
720: fsfile(dd);
721: skd = sunputc(dd);
722: fsfile(dr);
723: skr = sunputc(dr);
724: if(sfbeg(dr) == 1 || (sfbeg(dr) == 0 && sbackc(dr) == 0)){
725: sputc(dr,skr);
726: pushp(dr);
727: errorrt("divide by 0\n");
728: }
729: c = k-skd+skr;
730: if(c < 0)r = removr(dd,-c);
731: else {
732: r = add0(dd,c);
733: irem = 0;
734: }
735: arg1 = r;
736: arg2 = dr;
737: savk = k;
738: return(0);
739: }
740: struct blk *
741: removr(p,n)
742: struct blk *p;
743: {
744: int nn;
745: register struct blk *q,*s,*r;
746:
747: rewind(p);
748: nn = (n+1)/2;
749: q = salloc(nn);
750: while(n>1){
751: sputc(q,sgetc(p));
752: n -= 2;
753: }
754: r = salloc(2);
755: while(sfeof(p) == 0)sputc(r,sgetc(p));
756: release(p);
757: if(n == 1){
758: s = div(r,tenptr);
759: release(r);
760: rewind(rem);
761: if(sfeof(rem) == 0)sputc(q,sgetc(rem));
762: release(rem);
763: irem = q;
764: return(s);
765: }
766: irem = q;
767: return(r);
768: }
769: struct blk *
770: sqrt(p)
771: struct blk *p;
772: {
773: struct blk *t;
774: struct blk *r,*q,*s;
775: int c,n,nn;
776:
777: n = length(p);
778: fsfile(p);
779: c = sbackc(p);
780: if((n&1) != 1)c = c*100+(sfbeg(p)?0:sbackc(p));
781: n = (n+1)>>1;
782: r = salloc(n);
783: zero(r);
784: seekc(r,n);
785: nn=1;
786: while((c -= nn)>=0)nn+=2;
787: c=(nn+1)>>1;
788: fsfile(r);
789: sbackc(r);
790: if(c>=100){
791: c -= 100;
792: salterc(r,c);
793: sputc(r,1);
794: }
795: else salterc(r,c);
796: while(1){
797: q = div(p,r);
798: s = add(q,r);
799: release(q);
800: release(rem);
801: q = div(s,sqtemp);
802: release(s);
803: release(rem);
804: s = copy(r,length(r));
805: chsign(s);
806: t = add(s,q);
807: release(s);
808: fsfile(t);
809: nn = sfbeg(t)?0:sbackc(t);
810: if(nn>=0)break;
811: release(r);
812: release(t);
813: r = q;
814: }
815: release(t);
816: release(q);
817: release(p);
818: return(r);
819: }
820: struct blk *
821: exp(base,ex)
822: struct blk *base,*ex;
823: {
824: register struct blk *r,*e,*p;
825: struct blk *e1,*t,*cp;
826: int temp,c,n;
827: r = salloc(1);
828: sputc(r,1);
829: p = copy(base,length(base));
830: e = copy(ex,length(ex));
831: fsfile(e);
832: if(sfbeg(e) != 0)goto edone;
833: temp=0;
834: c = sbackc(e);
835: if(c<0){
836: temp++;
837: chsign(e);
838: }
839: while(length(e) != 0){
840: e1=div(e,sqtemp);
841: release(e);
842: e = e1;
843: n = length(rem);
844: release(rem);
845: if(n != 0){
846: e1=mult(p,r);
847: release(r);
848: r = e1;
849: }
850: t = copy(p,length(p));
851: cp = mult(p,t);
852: release(p);
853: release(t);
854: p = cp;
855: }
856: if(temp != 0){
857: if((c = length(base)) == 0){
858: goto edone;
859: }
860: if(c>1)create(r);
861: else{
862: rewind(base);
863: if((c = sgetc(base))<=1){
864: create(r);
865: sputc(r,c);
866: }
867: else create(r);
868: }
869: }
870: edone:
871: release(p);
872: release(e);
873: return(r);
874: }
875: init(argc,argv)
876: int argc;
877: char *argv[];
878: {
879: register struct sym *sp;
880:
881: if (signal(SIGINT, SIG_IGN) != SIG_IGN)
882: signal(SIGINT,onintr);
883: setbuf(stdout,(char *)NULL);
884: svargc = --argc;
885: svargv = argv;
886: while(svargc>0 && svargv[1][0] == '-'){
887: switch(svargv[1][1]){
888: default:
889: dbg=1;
890: }
891: svargc--;
892: svargv++;
893: }
894: ifile=1;
895: if(svargc<=0)curfile = stdin;
896: else if((curfile = fopen(svargv[1],"r")) == NULL){
897: printf("can't open file %s\n",svargv[1]);
898: exit(1);
899: }
900: scalptr = salloc(1);
901: sputc(scalptr,0);
902: basptr = salloc(1);
903: sputc(basptr,10);
904: obase=10;
905: log10=log2(10L);
906: ll=70;
907: fw=1;
908: fw1=0;
909: tenptr = salloc(1);
910: sputc(tenptr,10);
911: obase=10;
912: inbas = salloc(1);
913: sputc(inbas,10);
914: sqtemp = salloc(1);
915: sputc(sqtemp,2);
916: chptr = salloc(0);
917: strptr = salloc(0);
918: divxyz = salloc(0);
919: stkbeg = stkptr = &stack[0];
920: stkend = &stack[STKSZ];
921: stkerr = 0;
922: readptr = &readstk[0];
923: k=0;
924: sp = sptr = &symlst[0];
925: while(sptr < &symlst[TBLSZ-1]){
926: sptr->next = ++sp;
927: sptr++;
928: }
929: sptr->next=0;
930: sfree = &symlst[0];
931: return;
932: }
933: void
934: onintr(){
935:
936: signal(SIGINT,onintr);
937: while(readptr != &readstk[0]){
938: if(*readptr != 0){release(*readptr);}
939: readptr--;
940: }
941: curfile = stdin;
942: commnds();
943: }
944: pushp(p)
945: struct blk *p;
946: {
947: if(stkptr == stkend){
948: printf("out of stack space\n");
949: return;
950: }
951: stkerr=0;
952: *++stkptr = p;
953: return;
954: }
955: struct blk *
956: pop(){
957: if(stkptr == stack){
958: stkerr=1;
959: return(0);
960: }
961: return(*stkptr--);
962: }
963: struct blk *
964: readin(){
965: register struct blk *p,*q;
966: int dp,dpct;
967: register int c;
968:
969: dp = dpct=0;
970: p = salloc(0);
971: while(1){
972: c = readc();
973: switch(c){
974: case '.':
975: if(dp != 0){
976: unreadc(c);
977: break;
978: }
979: dp++;
980: continue;
981: case '\\':
982: readc();
983: continue;
984: default:
985: if(c >= 'A' && c <= 'F')c = c - 'A' + 10;
986: else if(c >= '0' && c <= '9')c -= '0';
987: else goto gotnum;
988: if(dp != 0){
989: if(dpct >= 99)continue;
990: dpct++;
991: }
992: create(chptr);
993: if(c != 0)sputc(chptr,c);
994: q = mult(p,inbas);
995: release(p);
996: p = add(chptr,q);
997: release(q);
998: }
999: }
1000: gotnum:
1001: unreadc(c);
1002: if(dp == 0){
1003: sputc(p,0);
1004: return(p);
1005: }
1006: else{
1007: q = scale(p,dpct);
1008: return(q);
1009: }
1010: }
1011: struct blk *
1012: add0(p,ct)
1013: int ct;
1014: struct blk *p;
1015: {
1016: /* returns pointer to struct with ct 0's & p */
1017: register struct blk *q,*t;
1018:
1019: q = salloc(length(p)+(ct+1)/2);
1020: while(ct>1){
1021: sputc(q,0);
1022: ct -= 2;
1023: }
1024: rewind(p);
1025: while(sfeof(p) == 0){
1026: sputc(q,sgetc(p));
1027: }
1028: release(p);
1029: if(ct == 1){
1030: t = mult(tenptr,q);
1031: release(q);
1032: return(t);
1033: }
1034: return(q);
1035: }
1036: struct blk *
1037: mult(p,q)
1038: struct blk *p,*q;
1039: {
1040: register struct blk *mp,*mq,*mr;
1041: int sign,offset,carry;
1042: int cq,cp,mt,mcr;
1043:
1044: offset = sign = 0;
1045: fsfile(p);
1046: mp = p;
1047: if(sfbeg(p) == 0){
1048: if(sbackc(p)<0){
1049: mp = copy(p,length(p));
1050: chsign(mp);
1051: sign = ~sign;
1052: }
1053: }
1054: fsfile(q);
1055: mq = q;
1056: if(sfbeg(q) == 0){
1057: if(sbackc(q)<0){
1058: mq = copy(q,length(q));
1059: chsign(mq);
1060: sign = ~sign;
1061: }
1062: }
1063: mr = salloc(length(mp)+length(mq));
1064: zero(mr);
1065: rewind(mq);
1066: while(sfeof(mq) == 0){
1067: cq = sgetc(mq);
1068: rewind(mp);
1069: rewind(mr);
1070: mr->rd += offset;
1071: carry=0;
1072: while(sfeof(mp) == 0){
1073: cp = sgetc(mp);
1074: mcr = sfeof(mr)?0:slookc(mr);
1075: mt = cp*cq + carry + mcr;
1076: carry = mt/100;
1077: salterc(mr,mt%100);
1078: }
1079: offset++;
1080: if(carry != 0){
1081: mcr = sfeof(mr)?0:slookc(mr);
1082: salterc(mr,mcr+carry);
1083: }
1084: }
1085: if(sign < 0){
1086: chsign(mr);
1087: }
1088: if(mp != p)release(mp);
1089: if(mq != q)release(mq);
1090: return(mr);
1091: }
1092: chsign(p)
1093: struct blk *p;
1094: {
1095: register int carry;
1096: register char ct;
1097:
1098: carry=0;
1099: rewind(p);
1100: while(sfeof(p) == 0){
1101: ct=100-slookc(p)-carry;
1102: carry=1;
1103: if(ct>=100){
1104: ct -= 100;
1105: carry=0;
1106: }
1107: salterc(p,ct);
1108: }
1109: if(carry != 0){
1110: sputc(p,-1);
1111: fsfile(p);
1112: sbackc(p);
1113: ct = sbackc(p);
1114: if(ct == 99){
1115: truncate(p);
1116: sputc(p,-1);
1117: }
1118: }
1119: else{
1120: fsfile(p);
1121: ct = sbackc(p);
1122: if(ct == 0)truncate(p);
1123: }
1124: return;
1125: }
1126: readc(){
1127: loop:
1128: if((readptr != &readstk[0]) && (*readptr != 0)){
1129: if(sfeof(*readptr) == 0)return(lastchar = sgetc(*readptr));
1130: release(*readptr);
1131: readptr--;
1132: goto loop;
1133: }
1134: lastchar = getc(curfile);
1135: if(lastchar != EOF)return(lastchar);
1136: if(readptr != &readptr[0]){
1137: readptr--;
1138: if(*readptr == 0)curfile = stdin;
1139: goto loop;
1140: }
1141: if(curfile != stdin){
1142: fclose(curfile);
1143: curfile = stdin;
1144: goto loop;
1145: }
1146: exit(0);
1147: }
1148: unreadc(c)
1149: char c;
1150: {
1151:
1152: if((readptr != &readstk[0]) && (*readptr != 0)){
1153: sungetc(*readptr,c);
1154: }
1155: else ungetc(c,curfile);
1156: return;
1157: }
1158: binop(c)
1159: char c;
1160: {
1161: register struct blk *r;
1162:
1163: switch(c){
1164: case '+':
1165: r = add(arg1,arg2);
1166: break;
1167: case '*':
1168: r = mult(arg1,arg2);
1169: break;
1170: case '/':
1171: r = div(arg1,arg2);
1172: break;
1173: }
1174: release(arg1);
1175: release(arg2);
1176: sputc(r,savk);
1177: pushp(r);
1178: return;
1179: }
1180: print(hptr)
1181: struct blk *hptr;
1182: {
1183: int sc;
1184: register struct blk *p,*q,*dec;
1185: int dig,dout,ct;
1186:
1187: rewind(hptr);
1188: while(sfeof(hptr) == 0){
1189: if(sgetc(hptr)>99){
1190: rewind(hptr);
1191: while(sfeof(hptr) == 0){
1192: printf("%c",sgetc(hptr));
1193: }
1194: printf("\n");
1195: return;
1196: }
1197: }
1198: fsfile(hptr);
1199: sc = sbackc(hptr);
1200: if(sfbeg(hptr) != 0){
1201: printf("0\n");
1202: return;
1203: }
1204: count = ll;
1205: p = copy(hptr,length(hptr));
1206: sunputc(p);
1207: fsfile(p);
1208: if(sbackc(p)<0){
1209: chsign(p);
1210: OUTC('-');
1211: }
1212: if((obase == 0) || (obase == -1)){
1213: oneot(p,sc,'d');
1214: return;
1215: }
1216: if(obase == 1){
1217: oneot(p,sc,'1');
1218: return;
1219: }
1220: if(obase == 10){
1221: tenot(p,sc);
1222: return;
1223: }
1224: create(strptr);
1225: dig = log10*sc;
1226: dout = ((dig/10) + dig) /logo;
1227: dec = getdec(p,sc);
1228: p = removc(p,sc);
1229: while(length(p) != 0){
1230: q = div(p,basptr);
1231: release(p);
1232: p = q;
1233: (*outdit)(rem,0);
1234: }
1235: release(p);
1236: fsfile(strptr);
1237: while(sfbeg(strptr) == 0)OUTC(sbackc(strptr));
1238: if(sc == 0){
1239: release(dec);
1240: printf("\n");
1241: return;
1242: }
1243: create(strptr);
1244: OUTC('.');
1245: ct=0;
1246: do{
1247: q = mult(basptr,dec);
1248: release(dec);
1249: dec = getdec(q,sc);
1250: p = removc(q,sc);
1251: (*outdit)(p,1);
1252: }while(++ct < dout);
1253: release(dec);
1254: rewind(strptr);
1255: while(sfeof(strptr) == 0)OUTC(sgetc(strptr));
1256: printf("\n");
1257: return;
1258: }
1259:
1260: struct blk *
1261: getdec(p,sc)
1262: struct blk *p;
1263: {
1264: int cc;
1265: register struct blk *q,*t,*s;
1266:
1267: rewind(p);
1268: if(length(p)*2 < sc){
1269: q = copy(p,length(p));
1270: return(q);
1271: }
1272: q = salloc(length(p));
1273: while(sc >= 1){
1274: sputc(q,sgetc(p));
1275: sc -= 2;
1276: }
1277: if(sc != 0){
1278: t = mult(q,tenptr);
1279: s = salloc(cc = length(q));
1280: release(q);
1281: rewind(t);
1282: while(cc-- > 0)sputc(s,sgetc(t));
1283: sputc(s,0);
1284: release(t);
1285: t = div(s,tenptr);
1286: release(s);
1287: release(rem);
1288: return(t);
1289: }
1290: return(q);
1291: }
1292: tenot(p,sc)
1293: struct blk *p;
1294: {
1295: register int c,f;
1296:
1297: fsfile(p);
1298: f=0;
1299: while((sfbeg(p) == 0) && ((p->rd-p->beg-1)*2 >= sc)){
1300: c = sbackc(p);
1301: if((c<10) && (f == 1))printf("0%d",c);
1302: else printf("%d",c);
1303: f=1;
1304: TEST2;
1305: }
1306: if(sc == 0){
1307: printf("\n");
1308: release(p);
1309: return;
1310: }
1311: if((p->rd-p->beg)*2 > sc){
1312: c = sbackc(p);
1313: printf("%d.",c/10);
1314: TEST2;
1315: OUTC(c%10 +'0');
1316: sc--;
1317: }
1318: else {
1319: OUTC('.');
1320: }
1321: if(sc > (p->rd-p->beg)*2){
1322: while(sc>(p->rd-p->beg)*2){
1323: OUTC('0');
1324: sc--;
1325: }
1326: }
1327: while(sc > 1){
1328: c = sbackc(p);
1329: if(c<10)printf("0%d",c);
1330: else printf("%d",c);
1331: sc -= 2;
1332: TEST2;
1333: }
1334: if(sc == 1){
1335: OUTC(sbackc(p)/10 +'0');
1336: }
1337: printf("\n");
1338: release(p);
1339: return;
1340: }
1341: oneot(p,sc,ch)
1342: struct blk *p;
1343: char ch;
1344: {
1345: register struct blk *q;
1346:
1347: q = removc(p,sc);
1348: create(strptr);
1349: sputc(strptr,-1);
1350: while(length(q)>0){
1351: p = add(strptr,q);
1352: release(q);
1353: q = p;
1354: OUTC(ch);
1355: }
1356: release(q);
1357: printf("\n");
1358: return;
1359: }
1360: hexot(p,flg)
1361: struct blk *p;
1362: {
1363: register int c;
1364: rewind(p);
1365: if(sfeof(p) != 0){
1366: sputc(strptr,'0');
1367: release(p);
1368: return;
1369: }
1370: c = sgetc(p);
1371: release(p);
1372: if(c >= 16){
1373: printf("hex digit > 16");
1374: return;
1375: }
1376: sputc(strptr,c<10?c+'0':c-10+'A');
1377: return;
1378: }
1379: bigot(p,flg)
1380: struct blk *p;
1381: {
1382: register struct blk *t,*q;
1383: register int l;
1384: int neg;
1385:
1386: if(flg == 1)t = salloc(0);
1387: else{
1388: t = strptr;
1389: l = length(strptr)+fw-1;
1390: }
1391: neg=0;
1392: if(length(p) != 0){
1393: fsfile(p);
1394: if(sbackc(p)<0){
1395: neg=1;
1396: chsign(p);
1397: }
1398: while(length(p) != 0){
1399: q = div(p,tenptr);
1400: release(p);
1401: p = q;
1402: rewind(rem);
1403: sputc(t,sfeof(rem)?'0':sgetc(rem)+'0');
1404: release(rem);
1405: }
1406: }
1407: release(p);
1408: if(flg == 1){
1409: l = fw1-length(t);
1410: if(neg != 0){
1411: l--;
1412: sputc(strptr,'-');
1413: }
1414: fsfile(t);
1415: while(l-- > 0)sputc(strptr,'0');
1416: while(sfbeg(t) == 0)sputc(strptr,sbackc(t));
1417: release(t);
1418: }
1419: else{
1420: l -= length(strptr);
1421: while(l-- > 0)sputc(strptr,'0');
1422: if(neg != 0){
1423: sunputc(strptr);
1424: sputc(strptr,'-');
1425: }
1426: }
1427: sputc(strptr,' ');
1428: return;
1429: }
1430: struct blk *
1431: add(a1,a2)
1432: struct blk *a1,*a2;
1433: {
1434: register struct blk *p;
1435: register int carry,n;
1436: int size;
1437: int c,n1,n2;
1438:
1439: size = length(a1)>length(a2)?length(a1):length(a2);
1440: p = salloc(size);
1441: rewind(a1);
1442: rewind(a2);
1443: carry=0;
1444: while(--size >= 0){
1445: n1 = sfeof(a1)?0:sgetc(a1);
1446: n2 = sfeof(a2)?0:sgetc(a2);
1447: n = n1 + n2 + carry;
1448: if(n>=100){
1449: carry=1;
1450: n -= 100;
1451: }
1452: else if(n<0){
1453: carry = -1;
1454: n += 100;
1455: }
1456: else carry = 0;
1457: sputc(p,n);
1458: }
1459: if(carry != 0)sputc(p,carry);
1460: fsfile(p);
1461: if(sfbeg(p) == 0){
1462: while(sfbeg(p) == 0 && (c = sbackc(p)) == 0);
1463: if(c != 0)salterc(p,c);
1464: truncate(p);
1465: }
1466: fsfile(p);
1467: if(sfbeg(p) == 0 && sbackc(p) == -1){
1468: while((c = sbackc(p)) == 99){
1469: if(c == EOF)break;
1470: }
1471: sgetc(p);
1472: salterc(p,-1);
1473: truncate(p);
1474: }
1475: return(p);
1476: }
1477: eqk(){
1478: register struct blk *p,*q;
1479: register int skp;
1480: int skq;
1481:
1482: p = pop();
1483: EMPTYS;
1484: q = pop();
1485: EMPTYSR(p);
1486: skp = sunputc(p);
1487: skq = sunputc(q);
1488: if(skp == skq){
1489: arg1=p;
1490: arg2=q;
1491: savk = skp;
1492: return(0);
1493: }
1494: else if(skp < skq){
1495: savk = skq;
1496: p = add0(p,skq-skp);
1497: }
1498: else {
1499: savk = skp;
1500: q = add0(q,skp-skq);
1501: }
1502: arg1=p;
1503: arg2=q;
1504: return(0);
1505: }
1506: struct blk *
1507: removc(p,n)
1508: struct blk *p;
1509: {
1510: register struct blk *q,*r;
1511:
1512: rewind(p);
1513: while(n>1){
1514: sgetc(p);
1515: n -= 2;
1516: }
1517: q = salloc(2);
1518: while(sfeof(p) == 0)sputc(q,sgetc(p));
1519: if(n == 1){
1520: r = div(q,tenptr);
1521: release(q);
1522: release(rem);
1523: q = r;
1524: }
1525: release(p);
1526: return(q);
1527: }
1528: struct blk *
1529: scalint(p)
1530: struct blk *p;
1531: {
1532: register int n;
1533: n = sunputc(p);
1534: p = removc(p,n);
1535: return(p);
1536: }
1537: struct blk *
1538: scale(p,n)
1539: struct blk *p;
1540: {
1541: register struct blk *q,*s,*t;
1542:
1543: t = add0(p,n);
1544: q = salloc(1);
1545: sputc(q,n);
1546: s = exp(inbas,q);
1547: release(q);
1548: q = div(t,s);
1549: release(t);
1550: release(s);
1551: release(rem);
1552: sputc(q,n);
1553: return(q);
1554: }
1555: subt(){
1556: arg1=pop();
1557: EMPTYS;
1558: savk = sunputc(arg1);
1559: chsign(arg1);
1560: sputc(arg1,savk);
1561: pushp(arg1);
1562: if(eqk() != 0)return(1);
1563: binop('+');
1564: return(0);
1565: }
1566: command(){
1567: int c;
1568: char line[100],*sl;
1569: register int pid, rpid;
1570: sig_t savint;
1571: int retcode;
1572:
1573: switch(c = readc()){
1574: case '<':
1575: return(cond(NL));
1576: case '>':
1577: return(cond(NG));
1578: case '=':
1579: return(cond(NE));
1580: default:
1581: sl = line;
1582: *sl++ = c;
1583: while((c = readc()) != '\n')*sl++ = c;
1584: *sl = 0;
1585: if((pid = fork()) == 0){
1586: execl(_PATH_BSHELL,"sh","-c",line,0);
1587: exit(0100);
1588: }
1589: savint = signal(SIGINT, SIG_IGN);
1590: while((rpid = wait(&retcode)) != pid && rpid != -1);
1591: signal(SIGINT,savint);
1592: printf("!\n");
1593: return(0);
1594: }
1595: }
1596: cond(c)
1597: char c;
1598: {
1599: register struct blk *p;
1600: register char cc;
1601:
1602: if(subt() != 0)return(1);
1603: p = pop();
1604: sunputc(p);
1605: if(length(p) == 0){
1606: release(p);
1607: if(c == '<' || c == '>' || c == NE){
1608: readc();
1609: return(0);
1610: }
1611: load();
1612: return(1);
1613: }
1614: else {
1615: if(c == '='){
1616: release(p);
1617: readc();
1618: return(0);
1619: }
1620: }
1621: if(c == NE){
1622: release(p);
1623: load();
1624: return(1);
1625: }
1626: fsfile(p);
1627: cc = sbackc(p);
1628: release(p);
1629: if((cc<0 && (c == '<' || c == NG)) ||
1630: (cc >0) && (c == '>' || c == NL)){
1631: readc();
1632: return(0);
1633: }
1634: load();
1635: return(1);
1636: }
1637: load(){
1638: register int c;
1639: register struct blk *p,*q;
1640: struct blk *t,*s;
1641: c = readc() & 0377;
1642: sptr = stable[c];
1643: if(sptr != 0){
1644: p = sptr->val;
1645: if(c >= ARRAYST){
1646: q = salloc(length(p));
1647: rewind(p);
1648: while(sfeof(p) == 0){
1649: s = getwd(p);
1650: if(s == 0){putwd(q, (struct blk *)NULL);}
1651: else{
1652: t = copy(s,length(s));
1653: putwd(q,t);
1654: }
1655: }
1656: pushp(q);
1657: }
1658: else{
1659: q = copy(p,length(p));
1660: pushp(q);
1661: }
1662: }
1663: else{
1664: q = salloc(1);
1665: sputc(q,0);
1666: pushp(q);
1667: }
1668: return;
1669: }
1670: log2(n)
1671: long n;
1672: {
1673: register int i;
1674:
1675: if(n == 0)return(0);
1676: i=31;
1677: if(n<0)return(i);
1678: while((n= n<<1) >0)i--;
1679: return(--i);
1680: }
1681:
1682: struct blk *
1683: salloc(size)
1684: int size;
1685: {
1686: register struct blk *hdr;
1687: register char *ptr;
1688: all++;
1689: nbytes += size;
1690: ptr = malloc((unsigned)size);
1691: if(ptr == 0){
1692: garbage("salloc");
1693: if((ptr = malloc((unsigned)size)) == 0)
1694: ospace("salloc");
1695: }
1696: if((hdr = hfree) == 0)hdr = morehd();
1697: hfree = (struct blk *)hdr->rd;
1698: hdr->rd = hdr->wt = hdr->beg = ptr;
1699: hdr->last = ptr+size;
1700: return(hdr);
1701: }
1702: struct blk *
1703: morehd(){
1704: register struct blk *h,*kk;
1705: headmor++;
1706: nbytes += HEADSZ;
1707: hfree = h = (struct blk *)malloc(HEADSZ);
1708: if(hfree == 0){
1709: garbage("morehd");
1710: if((hfree = h = (struct blk *)malloc(HEADSZ)) == 0)
1711: ospace("headers");
1712: }
1713: kk = h;
1714: while(h<hfree+(HEADSZ/BLK))(h++)->rd = (char *)++kk;
1715: (--h)->rd=0;
1716: return(hfree);
1717: }
1718: /*
1719: sunputc(hptr)
1720: struct blk *hptr;
1721: {
1722: hptr->wt--;
1723: hptr->rd = hptr->wt;
1724: return(*hptr->wt);
1725: }
1726: */
1727: struct blk *
1728: copy(hptr,size)
1729: struct blk *hptr;
1730: int size;
1731: {
1732: register struct blk *hdr;
1733: register unsigned sz;
1734: register char *ptr;
1735:
1736: all++;
1737: nbytes += size;
1738: sz = length(hptr);
1739: ptr = nalloc(hptr->beg, (unsigned)size);
1740: if(ptr == 0){
1741: garbage("copy");
1742: if((ptr = nalloc(hptr->beg, (unsigned)size)) == NULL){
1743: printf("copy size %d\n",size);
1744: ospace("copy");
1745: }
1746: }
1747: if((hdr = hfree) == 0)hdr = morehd();
1748: hfree = (struct blk *)hdr->rd;
1749: hdr->rd = hdr->beg = ptr;
1750: hdr->last = ptr+size;
1751: hdr->wt = ptr+sz;
1752: ptr = hdr->wt;
1753: while(ptr<hdr->last)*ptr++ = '\0';
1754: return(hdr);
1755: }
1756: sdump(s1,hptr)
1757: char *s1;
1758: struct blk *hptr;
1759: {
1760: char *p;
1761: printf("%s %o rd %o wt %o beg %o last %o\n",s1,hptr,hptr->rd,hptr->wt,hptr->beg,hptr->last);
1762: p = hptr->beg;
1763: while(p < hptr->wt)printf("%d ",*p++);
1764: printf("\n");
1765: }
1766: seekc(hptr,n)
1767: struct blk *hptr;
1768: {
1769: register char *nn,*p;
1770:
1771: nn = hptr->beg+n;
1772: if(nn > hptr->last){
1773: nbytes += nn - hptr->last;
1774: p = realloc(hptr->beg, (unsigned)n);
1775: if(p == 0){
1776: hptr->beg = realloc(hptr->beg, (unsigned)(hptr->last-hptr->beg));
1777: garbage("seekc");
1778: if((p = realloc(hptr->beg, (unsigned)n)) == 0)
1779: ospace("seekc");
1780: }
1781: hptr->beg = p;
1782: hptr->wt = hptr->last = hptr->rd = p+n;
1783: return;
1784: }
1785: hptr->rd = nn;
1786: if(nn>hptr->wt)hptr->wt = nn;
1787: return;
1788: }
1789: salterwd(hptr,n)
1790: struct wblk *hptr;
1791: struct blk *n;
1792: {
1793: if(hptr->rdw == hptr->lastw)more(hptr);
1794: *hptr->rdw++ = n;
1795: if(hptr->rdw > hptr->wtw)hptr->wtw = hptr->rdw;
1796: return;
1797: }
1798: more(hptr)
1799: struct blk *hptr;
1800: {
1801: register unsigned size;
1802: register char *p;
1803:
1804: if((size=(hptr->last-hptr->beg)*2) == 0)size=1;
1805: nbytes += size/2;
1806: p = realloc(hptr->beg, (unsigned)size);
1807: if(p == 0){
1808: hptr->beg = realloc(hptr->beg, (unsigned)(hptr->last-hptr->beg));
1809: garbage("more");
1810: if((p = realloc(hptr->beg,(unsigned)size)) == 0)
1811: ospace("more");
1812: }
1813: hptr->rd = hptr->rd-hptr->beg+p;
1814: hptr->wt = hptr->wt-hptr->beg+p;
1815: hptr->beg = p;
1816: hptr->last = p+size;
1817: return;
1818: }
1819: ospace(s)
1820: char *s;
1821: {
1822: printf("out of space: %s\n",s);
1823: printf("all %ld rel %ld headmor %ld\n",all,rel,headmor);
1824: printf("nbytes %ld\n",nbytes);
1825: sdump("stk",*stkptr);
1826: abort();
1827: }
1828: garbage(s)
1829: char *s;
1830: {
1831: int i;
1832: struct blk *p, *q;
1833: struct sym *tmps;
1834: int ct;
1835:
1836: /* printf("got to garbage %s\n",s); */
1837: for(i=0;i<TBLSZ;i++){
1838: tmps = stable[i];
1839: if(tmps != 0){
1840: if(i < ARRAYST){
1841: do {
1842: p = tmps->val;
1843: if(((int)p->beg & 01) != 0){
1844: printf("string %o\n",i);
1845: sdump("odd beg",p);
1846: }
1847: redef(p);
1848: tmps = tmps->next;
1849: } while(tmps != 0);
1850: continue;
1851: }
1852: else {
1853: do {
1854: p = tmps->val;
1855: rewind(p);
1856: ct = 0;
1857: while((q = getwd(p)) != NULL){
1858: ct++;
1859: if(q != 0){
1860: if(((int)q->beg & 01) != 0){
1861: printf("array %o elt %d odd\n",i-ARRAYST,ct);
1862: printf("tmps %o p %o\n",tmps,p);
1863: sdump("elt",q);
1864: }
1865: redef(q);
1866: }
1867: }
1868: tmps = tmps->next;
1869: } while(tmps != 0);
1870: }
1871: }
1872: }
1873: }
1874: redef(p)
1875: struct blk *p;
1876: {
1877: register offset;
1878: register char *newp;
1879:
1880: if ((int)p->beg&01) {
1881: printf("odd ptr %o hdr %o\n",p->beg,p);
1882: ospace("redef-bad");
1883: }
1884: newp = realloc(p->beg, (unsigned)(p->last-p->beg));
1885: if(newp == NULL)ospace("redef");
1886: offset = newp - p->beg;
1887: p->beg = newp;
1888: p->rd += offset;
1889: p->wt += offset;
1890: p->last += offset;
1891: }
1892:
1893: release(p)
1894: register struct blk *p;
1895: {
1896: rel++;
1897: nbytes -= p->last - p->beg;
1898: p->rd = (char *)hfree;
1899: hfree = p;
1900: free(p->beg);
1901: }
1902:
1903: struct blk *
1904: getwd(p)
1905: struct blk *p;
1906: {
1907: register struct wblk *wp;
1908:
1909: wp = (struct wblk *)p;
1910: if (wp->rdw == wp->wtw)
1911: return(NULL);
1912: return(*wp->rdw++);
1913: }
1914:
1915: putwd(p, c)
1916: struct blk *p, *c;
1917: {
1918: register struct wblk *wp;
1919:
1920: wp = (struct wblk *)p;
1921: if (wp->wtw == wp->lastw)
1922: more(p);
1923: *wp->wtw++ = c;
1924: }
1925:
1926: struct blk *
1927: lookwd(p)
1928: struct blk *p;
1929: {
1930: register struct wblk *wp;
1931:
1932: wp = (struct wblk *)p;
1933: if (wp->rdw == wp->wtw)
1934: return(NULL);
1935: return(*wp->rdw);
1936: }
1937: char *
1938: nalloc(p,nbytes)
1939: register char *p;
1940: unsigned nbytes;
1941: {
1942: char *malloc();
1943: register char *q, *r;
1944: q = r = malloc(nbytes);
1945: if(q==0)
1946: return(0);
1947: while(nbytes--)
1948: *q++ = *p++;
1949: return(r);
1950: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.