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