![[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] / 43BSDTahoe / usr.bin / dc|
Return to dc.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / usr.bin / dc |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)dc.c 4.5 (Berkeley) 9/28/87";
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 = n = sk1+sk2;
68: if(n>k && n>sk1 && n>sk2){
69: sk = sk1;
70: if(sk<sk2)sk = sk2;
71: if(sk<k)sk = k;
72: p = removc(p,n-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;
589:
590: rem = 0;
591: p = salloc(0);
592: if(length(ddivr) == 0){
593: pushp(ddivr);
594: printf("divide by 0\n");
595: return((struct blk *)1);
596: }
597: divsign = remsign = 0;
598: divr = ddivr;
599: fsfile(divr);
600: if(sbackc(divr) == -1){
601: divr = copy(ddivr,length(ddivr));
602: chsign(divr);
603: divsign = ~divsign;
604: }
605: divd = copy(ddivd,length(ddivd));
606: fsfile(divd);
607: if(sfbeg(divd) == 0 && sbackc(divd) == -1){
608: chsign(divd);
609: divsign = ~divsign;
610: remsign = ~remsign;
611: }
612: offset = length(divd) - length(divr);
613: if(offset < 0)goto ddone;
614: seekc(p,offset+1);
615: sputc(divd,0);
616: magic = 0;
617: fsfile(divr);
618: c = sbackc(divr);
619: if(c<10)magic++;
620: c = c*100 + (sfbeg(divr)?0:sbackc(divr));
621: if(magic>0){
622: c = (c*100 +(sfbeg(divr)?0:sbackc(divr)))*2;
623: c /= 25;
624: }
625: while(offset >= 0){
626: fsfile(divd);
627: td = sbackc(divd)*100;
628: dd = sfbeg(divd)?0:sbackc(divd);
629: td = (td+dd)*100;
630: dd = sfbeg(divd)?0:sbackc(divd);
631: td = td+dd;
632: cc = c;
633: if(offset == 0)td += 1;
634: else cc += 1;
635: if(magic != 0)td = td<<3;
636: dig = td/cc;
637: rewind(divr);
638: rewind(divxyz);
639: carry = 0;
640: while(sfeof(divr) == 0){
641: d = sgetc(divr)*dig+carry;
642: carry = d / 100;
643: salterc(divxyz,d%100);
644: }
645: salterc(divxyz,carry);
646: rewind(divxyz);
647: seekc(divd,offset);
648: carry = 0;
649: while(sfeof(divd) == 0){
650: d = slookc(divd);
651: d = d-(sfeof(divxyz)?0:sgetc(divxyz))-carry;
652: carry = 0;
653: if(d < 0){
654: d += 100;
655: carry = 1;
656: }
657: salterc(divd,d);
658: }
659: divcarry = carry;
660: sbackc(p);
661: salterc(p,dig);
662: sbackc(p);
663: if(--offset >= 0){
664: if(d > 0){
665: sbackc(divd);
666: dd=sbackc(divd);
667: salterc(divd,dd+100);
668: }
669: divd->wt--;
670: }
671: }
672: if(divcarry != 0){
673: salterc(p,dig-1);
674: salterc(divd,-1);
675: ps = add(divr,divd);
676: release(divd);
677: divd = ps;
678: }
679:
680: rewind(p);
681: divcarry = 0;
682: while(sfeof(p) == 0){
683: d = slookc(p)+divcarry;
684: divcarry = 0;
685: if(d >= 100){
686: d -= 100;
687: divcarry = 1;
688: }
689: salterc(p,d);
690: }
691: if(divcarry != 0)salterc(p,divcarry);
692: fsfile(p);
693: while(sfbeg(p) == 0){
694: if(sbackc(p) == 0)truncate(p);
695: else break;
696: }
697: if(divsign < 0)chsign(p);
698: fsfile(divd);
699: while(sfbeg(divd) == 0){
700: if(sbackc(divd) == 0)truncate(divd);
701: else break;
702: }
703: ddone:
704: if(remsign<0)chsign(divd);
705: if(divr != ddivr)release(divr);
706: rem = divd;
707: return(p);
708: }
709: dscale(){
710: register struct blk *dd,*dr;
711: register struct blk *r;
712: int c;
713:
714: dr = pop();
715: EMPTYS;
716: dd = pop();
717: EMPTYSR(dr);
718: fsfile(dd);
719: skd = sunputc(dd);
720: fsfile(dr);
721: skr = sunputc(dr);
722: if(sfbeg(dr) == 1 || (sfbeg(dr) == 0 && sbackc(dr) == 0)){
723: sputc(dr,skr);
724: pushp(dr);
725: errorrt("divide by 0\n");
726: }
727: c = k-skd+skr;
728: if(c < 0)r = removr(dd,-c);
729: else {
730: r = add0(dd,c);
731: irem = 0;
732: }
733: arg1 = r;
734: arg2 = dr;
735: savk = k;
736: return(0);
737: }
738: struct blk *
739: removr(p,n)
740: struct blk *p;
741: {
742: int nn;
743: register struct blk *q,*s,*r;
744:
745: rewind(p);
746: nn = (n+1)/2;
747: q = salloc(nn);
748: while(n>1){
749: sputc(q,sgetc(p));
750: n -= 2;
751: }
752: r = salloc(2);
753: while(sfeof(p) == 0)sputc(r,sgetc(p));
754: release(p);
755: if(n == 1){
756: s = div(r,tenptr);
757: release(r);
758: rewind(rem);
759: if(sfeof(rem) == 0)sputc(q,sgetc(rem));
760: release(rem);
761: irem = q;
762: return(s);
763: }
764: irem = q;
765: return(r);
766: }
767: struct blk *
768: sqrt(p)
769: struct blk *p;
770: {
771: struct blk *t;
772: struct blk *r,*q,*s;
773: int c,n,nn;
774:
775: n = length(p);
776: fsfile(p);
777: c = sbackc(p);
778: if((n&1) != 1)c = c*100+(sfbeg(p)?0:sbackc(p));
779: n = (n+1)>>1;
780: r = salloc(n);
781: zero(r);
782: seekc(r,n);
783: nn=1;
784: while((c -= nn)>=0)nn+=2;
785: c=(nn+1)>>1;
786: fsfile(r);
787: sbackc(r);
788: if(c>=100){
789: c -= 100;
790: salterc(r,c);
791: sputc(r,1);
792: }
793: else salterc(r,c);
794: while(1){
795: q = div(p,r);
796: s = add(q,r);
797: release(q);
798: release(rem);
799: q = div(s,sqtemp);
800: release(s);
801: release(rem);
802: s = copy(r,length(r));
803: chsign(s);
804: t = add(s,q);
805: release(s);
806: fsfile(t);
807: nn = sfbeg(t)?0:sbackc(t);
808: if(nn>=0)break;
809: release(r);
810: release(t);
811: r = q;
812: }
813: release(t);
814: release(q);
815: release(p);
816: return(r);
817: }
818: struct blk *
819: exp(base,ex)
820: struct blk *base,*ex;
821: {
822: register struct blk *r,*e,*p;
823: struct blk *e1,*t,*cp;
824: int temp,c,n;
825: r = salloc(1);
826: sputc(r,1);
827: p = copy(base,length(base));
828: e = copy(ex,length(ex));
829: fsfile(e);
830: if(sfbeg(e) != 0)goto edone;
831: temp=0;
832: c = sbackc(e);
833: if(c<0){
834: temp++;
835: chsign(e);
836: }
837: while(length(e) != 0){
838: e1=div(e,sqtemp);
839: release(e);
840: e = e1;
841: n = length(rem);
842: release(rem);
843: if(n != 0){
844: e1=mult(p,r);
845: release(r);
846: r = e1;
847: }
848: t = copy(p,length(p));
849: cp = mult(p,t);
850: release(p);
851: release(t);
852: p = cp;
853: }
854: if(temp != 0){
855: if((c = length(base)) == 0){
856: goto edone;
857: }
858: if(c>1)create(r);
859: else{
860: rewind(base);
861: if((c = sgetc(base))<=1){
862: create(r);
863: sputc(r,c);
864: }
865: else create(r);
866: }
867: }
868: edone:
869: release(p);
870: release(e);
871: return(r);
872: }
873: init(argc,argv)
874: int argc;
875: char *argv[];
876: {
877: register struct sym *sp;
878:
879: if (signal(SIGINT, SIG_IGN) != SIG_IGN)
880: signal(SIGINT,onintr);
881: setbuf(stdout,(char *)NULL);
882: svargc = --argc;
883: svargv = argv;
884: while(svargc>0 && svargv[1][0] == '-'){
885: switch(svargv[1][1]){
886: default:
887: dbg=1;
888: }
889: svargc--;
890: svargv++;
891: }
892: ifile=1;
893: if(svargc<=0)curfile = stdin;
894: else if((curfile = fopen(svargv[1],"r")) == NULL){
895: printf("can't open file %s\n",svargv[1]);
896: exit(1);
897: }
898: scalptr = salloc(1);
899: sputc(scalptr,0);
900: basptr = salloc(1);
901: sputc(basptr,10);
902: obase=10;
903: log10=log2(10L);
904: ll=70;
905: fw=1;
906: fw1=0;
907: tenptr = salloc(1);
908: sputc(tenptr,10);
909: obase=10;
910: inbas = salloc(1);
911: sputc(inbas,10);
912: sqtemp = salloc(1);
913: sputc(sqtemp,2);
914: chptr = salloc(0);
915: strptr = salloc(0);
916: divxyz = salloc(0);
917: stkbeg = stkptr = &stack[0];
918: stkend = &stack[STKSZ];
919: stkerr = 0;
920: readptr = &readstk[0];
921: k=0;
922: sp = sptr = &symlst[0];
923: while(sptr < &symlst[TBLSZ-1]){
924: sptr->next = ++sp;
925: sptr++;
926: }
927: sptr->next=0;
928: sfree = &symlst[0];
929: return;
930: }
931: onintr(){
932:
933: signal(SIGINT,onintr);
934: while(readptr != &readstk[0]){
935: if(*readptr != 0){release(*readptr);}
936: readptr--;
937: }
938: curfile = stdin;
939: commnds();
940: }
941: pushp(p)
942: struct blk *p;
943: {
944: if(stkptr == stkend){
945: printf("out of stack space\n");
946: return;
947: }
948: stkerr=0;
949: *++stkptr = p;
950: return;
951: }
952: struct blk *
953: pop(){
954: if(stkptr == stack){
955: stkerr=1;
956: return(0);
957: }
958: return(*stkptr--);
959: }
960: struct blk *
961: readin(){
962: register struct blk *p,*q;
963: int dp,dpct;
964: register int c;
965:
966: dp = dpct=0;
967: p = salloc(0);
968: while(1){
969: c = readc();
970: switch(c){
971: case '.':
972: if(dp != 0){
973: unreadc(c);
974: break;
975: }
976: dp++;
977: continue;
978: case '\\':
979: readc();
980: continue;
981: default:
982: if(c >= 'A' && c <= 'F')c = c - 'A' + 10;
983: else if(c >= '0' && c <= '9')c -= '0';
984: else goto gotnum;
985: if(dp != 0){
986: if(dpct >= 99)continue;
987: dpct++;
988: }
989: create(chptr);
990: if(c != 0)sputc(chptr,c);
991: q = mult(p,inbas);
992: release(p);
993: p = add(chptr,q);
994: release(q);
995: }
996: }
997: gotnum:
998: unreadc(c);
999: if(dp == 0){
1000: sputc(p,0);
1001: return(p);
1002: }
1003: else{
1004: q = scale(p,dpct);
1005: return(q);
1006: }
1007: }
1008: struct blk *
1009: add0(p,ct)
1010: int ct;
1011: struct blk *p;
1012: {
1013: /* returns pointer to struct with ct 0's & p */
1014: register struct blk *q,*t;
1015:
1016: q = salloc(length(p)+(ct+1)/2);
1017: while(ct>1){
1018: sputc(q,0);
1019: ct -= 2;
1020: }
1021: rewind(p);
1022: while(sfeof(p) == 0){
1023: sputc(q,sgetc(p));
1024: }
1025: release(p);
1026: if(ct == 1){
1027: t = mult(tenptr,q);
1028: release(q);
1029: return(t);
1030: }
1031: return(q);
1032: }
1033: struct blk *
1034: mult(p,q)
1035: struct blk *p,*q;
1036: {
1037: register struct blk *mp,*mq,*mr;
1038: int sign,offset,carry;
1039: int cq,cp,mt,mcr;
1040:
1041: offset = sign = 0;
1042: fsfile(p);
1043: mp = p;
1044: if(sfbeg(p) == 0){
1045: if(sbackc(p)<0){
1046: mp = copy(p,length(p));
1047: chsign(mp);
1048: sign = ~sign;
1049: }
1050: }
1051: fsfile(q);
1052: mq = q;
1053: if(sfbeg(q) == 0){
1054: if(sbackc(q)<0){
1055: mq = copy(q,length(q));
1056: chsign(mq);
1057: sign = ~sign;
1058: }
1059: }
1060: mr = salloc(length(mp)+length(mq));
1061: zero(mr);
1062: rewind(mq);
1063: while(sfeof(mq) == 0){
1064: cq = sgetc(mq);
1065: rewind(mp);
1066: rewind(mr);
1067: mr->rd += offset;
1068: carry=0;
1069: while(sfeof(mp) == 0){
1070: cp = sgetc(mp);
1071: mcr = sfeof(mr)?0:slookc(mr);
1072: mt = cp*cq + carry + mcr;
1073: carry = mt/100;
1074: salterc(mr,mt%100);
1075: }
1076: offset++;
1077: if(carry != 0){
1078: mcr = sfeof(mr)?0:slookc(mr);
1079: salterc(mr,mcr+carry);
1080: }
1081: }
1082: if(sign < 0){
1083: chsign(mr);
1084: }
1085: if(mp != p)release(mp);
1086: if(mq != q)release(mq);
1087: return(mr);
1088: }
1089: chsign(p)
1090: struct blk *p;
1091: {
1092: register int carry;
1093: register char ct;
1094:
1095: carry=0;
1096: rewind(p);
1097: while(sfeof(p) == 0){
1098: ct=100-slookc(p)-carry;
1099: carry=1;
1100: if(ct>=100){
1101: ct -= 100;
1102: carry=0;
1103: }
1104: salterc(p,ct);
1105: }
1106: if(carry != 0){
1107: sputc(p,-1);
1108: fsfile(p);
1109: sbackc(p);
1110: ct = sbackc(p);
1111: if(ct == 99){
1112: truncate(p);
1113: sputc(p,-1);
1114: }
1115: }
1116: else{
1117: fsfile(p);
1118: ct = sbackc(p);
1119: if(ct == 0)truncate(p);
1120: }
1121: return;
1122: }
1123: readc(){
1124: loop:
1125: if((readptr != &readstk[0]) && (*readptr != 0)){
1126: if(sfeof(*readptr) == 0)return(lastchar = sgetc(*readptr));
1127: release(*readptr);
1128: readptr--;
1129: goto loop;
1130: }
1131: lastchar = getc(curfile);
1132: if(lastchar != EOF)return(lastchar);
1133: if(readptr != &readptr[0]){
1134: readptr--;
1135: if(*readptr == 0)curfile = stdin;
1136: goto loop;
1137: }
1138: if(curfile != stdin){
1139: fclose(curfile);
1140: curfile = stdin;
1141: goto loop;
1142: }
1143: exit(0);
1144: }
1145: unreadc(c)
1146: char c;
1147: {
1148:
1149: if((readptr != &readstk[0]) && (*readptr != 0)){
1150: sungetc(*readptr,c);
1151: }
1152: else ungetc(c,curfile);
1153: return;
1154: }
1155: binop(c)
1156: char c;
1157: {
1158: register struct blk *r;
1159:
1160: switch(c){
1161: case '+':
1162: r = add(arg1,arg2);
1163: break;
1164: case '*':
1165: r = mult(arg1,arg2);
1166: break;
1167: case '/':
1168: r = div(arg1,arg2);
1169: break;
1170: }
1171: release(arg1);
1172: release(arg2);
1173: sputc(r,savk);
1174: pushp(r);
1175: return;
1176: }
1177: print(hptr)
1178: struct blk *hptr;
1179: {
1180: int sc;
1181: register struct blk *p,*q,*dec;
1182: int dig,dout,ct;
1183:
1184: rewind(hptr);
1185: while(sfeof(hptr) == 0){
1186: if(sgetc(hptr)>99){
1187: rewind(hptr);
1188: while(sfeof(hptr) == 0){
1189: printf("%c",sgetc(hptr));
1190: }
1191: printf("\n");
1192: return;
1193: }
1194: }
1195: fsfile(hptr);
1196: sc = sbackc(hptr);
1197: if(sfbeg(hptr) != 0){
1198: printf("0\n");
1199: return;
1200: }
1201: count = ll;
1202: p = copy(hptr,length(hptr));
1203: sunputc(p);
1204: fsfile(p);
1205: if(sbackc(p)<0){
1206: chsign(p);
1207: OUTC('-');
1208: }
1209: if((obase == 0) || (obase == -1)){
1210: oneot(p,sc,'d');
1211: return;
1212: }
1213: if(obase == 1){
1214: oneot(p,sc,'1');
1215: return;
1216: }
1217: if(obase == 10){
1218: tenot(p,sc);
1219: return;
1220: }
1221: create(strptr);
1222: dig = log10*sc;
1223: dout = ((dig/10) + dig) /logo;
1224: dec = getdec(p,sc);
1225: p = removc(p,sc);
1226: while(length(p) != 0){
1227: q = div(p,basptr);
1228: release(p);
1229: p = q;
1230: (*outdit)(rem,0);
1231: }
1232: release(p);
1233: fsfile(strptr);
1234: while(sfbeg(strptr) == 0)OUTC(sbackc(strptr));
1235: if(sc == 0){
1236: release(dec);
1237: printf("\n");
1238: return;
1239: }
1240: create(strptr);
1241: OUTC('.');
1242: ct=0;
1243: do{
1244: q = mult(basptr,dec);
1245: release(dec);
1246: dec = getdec(q,sc);
1247: p = removc(q,sc);
1248: (*outdit)(p,1);
1249: }while(++ct < dout);
1250: release(dec);
1251: rewind(strptr);
1252: while(sfeof(strptr) == 0)OUTC(sgetc(strptr));
1253: printf("\n");
1254: return;
1255: }
1256:
1257: struct blk *
1258: getdec(p,sc)
1259: struct blk *p;
1260: {
1261: int cc;
1262: register struct blk *q,*t,*s;
1263:
1264: rewind(p);
1265: if(length(p)*2 < sc){
1266: q = copy(p,length(p));
1267: return(q);
1268: }
1269: q = salloc(length(p));
1270: while(sc >= 1){
1271: sputc(q,sgetc(p));
1272: sc -= 2;
1273: }
1274: if(sc != 0){
1275: t = mult(q,tenptr);
1276: s = salloc(cc = length(q));
1277: release(q);
1278: rewind(t);
1279: while(cc-- > 0)sputc(s,sgetc(t));
1280: sputc(s,0);
1281: release(t);
1282: t = div(s,tenptr);
1283: release(s);
1284: release(rem);
1285: return(t);
1286: }
1287: return(q);
1288: }
1289: tenot(p,sc)
1290: struct blk *p;
1291: {
1292: register int c,f;
1293:
1294: fsfile(p);
1295: f=0;
1296: while((sfbeg(p) == 0) && ((p->rd-p->beg-1)*2 >= sc)){
1297: c = sbackc(p);
1298: if((c<10) && (f == 1))printf("0%d",c);
1299: else printf("%d",c);
1300: f=1;
1301: TEST2;
1302: }
1303: if(sc == 0){
1304: printf("\n");
1305: release(p);
1306: return;
1307: }
1308: if((p->rd-p->beg)*2 > sc){
1309: c = sbackc(p);
1310: printf("%d.",c/10);
1311: TEST2;
1312: OUTC(c%10 +'0');
1313: sc--;
1314: }
1315: else {
1316: OUTC('.');
1317: }
1318: if(sc > (p->rd-p->beg)*2){
1319: while(sc>(p->rd-p->beg)*2){
1320: OUTC('0');
1321: sc--;
1322: }
1323: }
1324: while(sc > 1){
1325: c = sbackc(p);
1326: if(c<10)printf("0%d",c);
1327: else printf("%d",c);
1328: sc -= 2;
1329: TEST2;
1330: }
1331: if(sc == 1){
1332: OUTC(sbackc(p)/10 +'0');
1333: }
1334: printf("\n");
1335: release(p);
1336: return;
1337: }
1338: oneot(p,sc,ch)
1339: struct blk *p;
1340: char ch;
1341: {
1342: register struct blk *q;
1343:
1344: q = removc(p,sc);
1345: create(strptr);
1346: sputc(strptr,-1);
1347: while(length(q)>0){
1348: p = add(strptr,q);
1349: release(q);
1350: q = p;
1351: OUTC(ch);
1352: }
1353: release(q);
1354: printf("\n");
1355: return;
1356: }
1357: hexot(p,flg)
1358: struct blk *p;
1359: {
1360: register int c;
1361: rewind(p);
1362: if(sfeof(p) != 0){
1363: sputc(strptr,'0');
1364: release(p);
1365: return;
1366: }
1367: c = sgetc(p);
1368: release(p);
1369: if(c >= 16){
1370: printf("hex digit > 16");
1371: return;
1372: }
1373: sputc(strptr,c<10?c+'0':c-10+'A');
1374: return;
1375: }
1376: bigot(p,flg)
1377: struct blk *p;
1378: {
1379: register struct blk *t,*q;
1380: register int l;
1381: int neg;
1382:
1383: if(flg == 1)t = salloc(0);
1384: else{
1385: t = strptr;
1386: l = length(strptr)+fw-1;
1387: }
1388: neg=0;
1389: if(length(p) != 0){
1390: fsfile(p);
1391: if(sbackc(p)<0){
1392: neg=1;
1393: chsign(p);
1394: }
1395: while(length(p) != 0){
1396: q = div(p,tenptr);
1397: release(p);
1398: p = q;
1399: rewind(rem);
1400: sputc(t,sfeof(rem)?'0':sgetc(rem)+'0');
1401: release(rem);
1402: }
1403: }
1404: release(p);
1405: if(flg == 1){
1406: l = fw1-length(t);
1407: if(neg != 0){
1408: l--;
1409: sputc(strptr,'-');
1410: }
1411: fsfile(t);
1412: while(l-- > 0)sputc(strptr,'0');
1413: while(sfbeg(t) == 0)sputc(strptr,sbackc(t));
1414: release(t);
1415: }
1416: else{
1417: l -= length(strptr);
1418: while(l-- > 0)sputc(strptr,'0');
1419: if(neg != 0){
1420: sunputc(strptr);
1421: sputc(strptr,'-');
1422: }
1423: }
1424: sputc(strptr,' ');
1425: return;
1426: }
1427: struct blk *
1428: add(a1,a2)
1429: struct blk *a1,*a2;
1430: {
1431: register struct blk *p;
1432: register int carry,n;
1433: int size;
1434: int c,n1,n2;
1435:
1436: size = length(a1)>length(a2)?length(a1):length(a2);
1437: p = salloc(size);
1438: rewind(a1);
1439: rewind(a2);
1440: carry=0;
1441: while(--size >= 0){
1442: n1 = sfeof(a1)?0:sgetc(a1);
1443: n2 = sfeof(a2)?0:sgetc(a2);
1444: n = n1 + n2 + carry;
1445: if(n>=100){
1446: carry=1;
1447: n -= 100;
1448: }
1449: else if(n<0){
1450: carry = -1;
1451: n += 100;
1452: }
1453: else carry = 0;
1454: sputc(p,n);
1455: }
1456: if(carry != 0)sputc(p,carry);
1457: fsfile(p);
1458: if(sfbeg(p) == 0){
1459: while(sfbeg(p) == 0 && (c = sbackc(p)) == 0);
1460: if(c != 0)salterc(p,c);
1461: truncate(p);
1462: }
1463: fsfile(p);
1464: if(sfbeg(p) == 0 && sbackc(p) == -1){
1465: while((c = sbackc(p)) == 99){
1466: if(c == EOF)break;
1467: }
1468: sgetc(p);
1469: salterc(p,-1);
1470: truncate(p);
1471: }
1472: return(p);
1473: }
1474: eqk(){
1475: register struct blk *p,*q;
1476: register int skp;
1477: int skq;
1478:
1479: p = pop();
1480: EMPTYS;
1481: q = pop();
1482: EMPTYSR(p);
1483: skp = sunputc(p);
1484: skq = sunputc(q);
1485: if(skp == skq){
1486: arg1=p;
1487: arg2=q;
1488: savk = skp;
1489: return(0);
1490: }
1491: else if(skp < skq){
1492: savk = skq;
1493: p = add0(p,skq-skp);
1494: }
1495: else {
1496: savk = skp;
1497: q = add0(q,skp-skq);
1498: }
1499: arg1=p;
1500: arg2=q;
1501: return(0);
1502: }
1503: struct blk *
1504: removc(p,n)
1505: struct blk *p;
1506: {
1507: register struct blk *q,*r;
1508:
1509: rewind(p);
1510: while(n>1){
1511: sgetc(p);
1512: n -= 2;
1513: }
1514: q = salloc(2);
1515: while(sfeof(p) == 0)sputc(q,sgetc(p));
1516: if(n == 1){
1517: r = div(q,tenptr);
1518: release(q);
1519: release(rem);
1520: q = r;
1521: }
1522: release(p);
1523: return(q);
1524: }
1525: struct blk *
1526: scalint(p)
1527: struct blk *p;
1528: {
1529: register int n;
1530: n = sunputc(p);
1531: p = removc(p,n);
1532: return(p);
1533: }
1534: struct blk *
1535: scale(p,n)
1536: struct blk *p;
1537: {
1538: register struct blk *q,*s,*t;
1539:
1540: t = add0(p,n);
1541: q = salloc(1);
1542: sputc(q,n);
1543: s = exp(inbas,q);
1544: release(q);
1545: q = div(t,s);
1546: release(t);
1547: release(s);
1548: release(rem);
1549: sputc(q,n);
1550: return(q);
1551: }
1552: subt(){
1553: arg1=pop();
1554: EMPTYS;
1555: savk = sunputc(arg1);
1556: chsign(arg1);
1557: sputc(arg1,savk);
1558: pushp(arg1);
1559: if(eqk() != 0)return(1);
1560: binop('+');
1561: return(0);
1562: }
1563: command(){
1564: int c;
1565: char line[100],*sl;
1566: register (*savint)(),pid,rpid;
1567: int retcode;
1568:
1569: switch(c = readc()){
1570: case '<':
1571: return(cond(NL));
1572: case '>':
1573: return(cond(NG));
1574: case '=':
1575: return(cond(NE));
1576: default:
1577: sl = line;
1578: *sl++ = c;
1579: while((c = readc()) != '\n')*sl++ = c;
1580: *sl = 0;
1581: if((pid = fork()) == 0){
1582: execl("/bin/sh","sh","-c",line,0);
1583: exit(0100);
1584: }
1585: savint = signal(SIGINT, SIG_IGN);
1586: while((rpid = wait(&retcode)) != pid && rpid != -1);
1587: signal(SIGINT,savint);
1588: printf("!\n");
1589: return(0);
1590: }
1591: }
1592: cond(c)
1593: char c;
1594: {
1595: register struct blk *p;
1596: register char cc;
1597:
1598: if(subt() != 0)return(1);
1599: p = pop();
1600: sunputc(p);
1601: if(length(p) == 0){
1602: release(p);
1603: if(c == '<' || c == '>' || c == NE){
1604: readc();
1605: return(0);
1606: }
1607: load();
1608: return(1);
1609: }
1610: else {
1611: if(c == '='){
1612: release(p);
1613: readc();
1614: return(0);
1615: }
1616: }
1617: if(c == NE){
1618: release(p);
1619: load();
1620: return(1);
1621: }
1622: fsfile(p);
1623: cc = sbackc(p);
1624: release(p);
1625: if((cc<0 && (c == '<' || c == NG)) ||
1626: (cc >0) && (c == '>' || c == NL)){
1627: readc();
1628: return(0);
1629: }
1630: load();
1631: return(1);
1632: }
1633: load(){
1634: register int c;
1635: register struct blk *p,*q;
1636: struct blk *t,*s;
1637: c = readc() & 0377;
1638: sptr = stable[c];
1639: if(sptr != 0){
1640: p = sptr->val;
1641: if(c >= ARRAYST){
1642: q = salloc(length(p));
1643: rewind(p);
1644: while(sfeof(p) == 0){
1645: s = getwd(p);
1646: if(s == 0){putwd(q, (struct blk *)NULL);}
1647: else{
1648: t = copy(s,length(s));
1649: putwd(q,t);
1650: }
1651: }
1652: pushp(q);
1653: }
1654: else{
1655: q = copy(p,length(p));
1656: pushp(q);
1657: }
1658: }
1659: else{
1660: q = salloc(1);
1661: sputc(q,0);
1662: pushp(q);
1663: }
1664: return;
1665: }
1666: log2(n)
1667: long n;
1668: {
1669: register int i;
1670:
1671: if(n == 0)return(0);
1672: i=31;
1673: if(n<0)return(i);
1674: while((n= n<<1) >0)i--;
1675: return(--i);
1676: }
1677:
1678: struct blk *
1679: salloc(size)
1680: int size;
1681: {
1682: register struct blk *hdr;
1683: register char *ptr;
1684: all++;
1685: nbytes += size;
1686: ptr = malloc((unsigned)size);
1687: if(ptr == 0){
1688: garbage("salloc");
1689: if((ptr = malloc((unsigned)size)) == 0)
1690: ospace("salloc");
1691: }
1692: if((hdr = hfree) == 0)hdr = morehd();
1693: hfree = (struct blk *)hdr->rd;
1694: hdr->rd = hdr->wt = hdr->beg = ptr;
1695: hdr->last = ptr+size;
1696: return(hdr);
1697: }
1698: struct blk *
1699: morehd(){
1700: register struct blk *h,*kk;
1701: headmor++;
1702: nbytes += HEADSZ;
1703: hfree = h = (struct blk *)malloc(HEADSZ);
1704: if(hfree == 0){
1705: garbage("morehd");
1706: if((hfree = h = (struct blk *)malloc(HEADSZ)) == 0)
1707: ospace("headers");
1708: }
1709: kk = h;
1710: while(h<hfree+(HEADSZ/BLK))(h++)->rd = (char *)++kk;
1711: (--h)->rd=0;
1712: return(hfree);
1713: }
1714: /*
1715: sunputc(hptr)
1716: struct blk *hptr;
1717: {
1718: hptr->wt--;
1719: hptr->rd = hptr->wt;
1720: return(*hptr->wt);
1721: }
1722: */
1723: struct blk *
1724: copy(hptr,size)
1725: struct blk *hptr;
1726: int size;
1727: {
1728: register struct blk *hdr;
1729: register unsigned sz;
1730: register char *ptr;
1731:
1732: all++;
1733: nbytes += size;
1734: sz = length(hptr);
1735: ptr = nalloc(hptr->beg, (unsigned)size);
1736: if(ptr == 0){
1737: garbage("copy");
1738: if((ptr = nalloc(hptr->beg, (unsigned)size)) == NULL){
1739: printf("copy size %d\n",size);
1740: ospace("copy");
1741: }
1742: }
1743: if((hdr = hfree) == 0)hdr = morehd();
1744: hfree = (struct blk *)hdr->rd;
1745: hdr->rd = hdr->beg = ptr;
1746: hdr->last = ptr+size;
1747: hdr->wt = ptr+sz;
1748: ptr = hdr->wt;
1749: while(ptr<hdr->last)*ptr++ = '\0';
1750: return(hdr);
1751: }
1752: sdump(s1,hptr)
1753: char *s1;
1754: struct blk *hptr;
1755: {
1756: char *p;
1757: printf("%s %o rd %o wt %o beg %o last %o\n",s1,hptr,hptr->rd,hptr->wt,hptr->beg,hptr->last);
1758: p = hptr->beg;
1759: while(p < hptr->wt)printf("%d ",*p++);
1760: printf("\n");
1761: }
1762: seekc(hptr,n)
1763: struct blk *hptr;
1764: {
1765: register char *nn,*p;
1766:
1767: nn = hptr->beg+n;
1768: if(nn > hptr->last){
1769: nbytes += nn - hptr->last;
1770: p = realloc(hptr->beg, (unsigned)n);
1771: if(p == 0){
1772: hptr->beg = realloc(hptr->beg, (unsigned)(hptr->last-hptr->beg));
1773: garbage("seekc");
1774: if((p = realloc(hptr->beg, (unsigned)n)) == 0)
1775: ospace("seekc");
1776: }
1777: hptr->beg = p;
1778: hptr->wt = hptr->last = hptr->rd = p+n;
1779: return;
1780: }
1781: hptr->rd = nn;
1782: if(nn>hptr->wt)hptr->wt = nn;
1783: return;
1784: }
1785: salterwd(hptr,n)
1786: struct wblk *hptr;
1787: struct blk *n;
1788: {
1789: if(hptr->rdw == hptr->lastw)more(hptr);
1790: *hptr->rdw++ = n;
1791: if(hptr->rdw > hptr->wtw)hptr->wtw = hptr->rdw;
1792: return;
1793: }
1794: more(hptr)
1795: struct blk *hptr;
1796: {
1797: register unsigned size;
1798: register char *p;
1799:
1800: if((size=(hptr->last-hptr->beg)*2) == 0)size=1;
1801: nbytes += size/2;
1802: p = realloc(hptr->beg, (unsigned)size);
1803: if(p == 0){
1804: hptr->beg = realloc(hptr->beg, (unsigned)(hptr->last-hptr->beg));
1805: garbage("more");
1806: if((p = realloc(hptr->beg,(unsigned)size)) == 0)
1807: ospace("more");
1808: }
1809: hptr->rd = hptr->rd-hptr->beg+p;
1810: hptr->wt = hptr->wt-hptr->beg+p;
1811: hptr->beg = p;
1812: hptr->last = p+size;
1813: return;
1814: }
1815: ospace(s)
1816: char *s;
1817: {
1818: printf("out of space: %s\n",s);
1819: printf("all %ld rel %ld headmor %ld\n",all,rel,headmor);
1820: printf("nbytes %ld\n",nbytes);
1821: sdump("stk",*stkptr);
1822: abort();
1823: }
1824: garbage(s)
1825: char *s;
1826: {
1827: int i;
1828: struct blk *p, *q;
1829: struct sym *tmps;
1830: int ct;
1831:
1832: /* printf("got to garbage %s\n",s); */
1833: for(i=0;i<TBLSZ;i++){
1834: tmps = stable[i];
1835: if(tmps != 0){
1836: if(i < ARRAYST){
1837: do {
1838: p = tmps->val;
1839: if(((int)p->beg & 01) != 0){
1840: printf("string %o\n",i);
1841: sdump("odd beg",p);
1842: }
1843: redef(p);
1844: tmps = tmps->next;
1845: } while(tmps != 0);
1846: continue;
1847: }
1848: else {
1849: do {
1850: p = tmps->val;
1851: rewind(p);
1852: ct = 0;
1853: while((q = getwd(p)) != NULL){
1854: ct++;
1855: if(q != 0){
1856: if(((int)q->beg & 01) != 0){
1857: printf("array %o elt %d odd\n",i-ARRAYST,ct);
1858: printf("tmps %o p %o\n",tmps,p);
1859: sdump("elt",q);
1860: }
1861: redef(q);
1862: }
1863: }
1864: tmps = tmps->next;
1865: } while(tmps != 0);
1866: }
1867: }
1868: }
1869: }
1870: redef(p)
1871: struct blk *p;
1872: {
1873: register offset;
1874: register char *newp;
1875:
1876: if ((int)p->beg&01) {
1877: printf("odd ptr %o hdr %o\n",p->beg,p);
1878: ospace("redef-bad");
1879: }
1880: newp = realloc(p->beg, (unsigned)(p->last-p->beg));
1881: if(newp == NULL)ospace("redef");
1882: offset = newp - p->beg;
1883: p->beg = newp;
1884: p->rd += offset;
1885: p->wt += offset;
1886: p->last += offset;
1887: }
1888:
1889: release(p)
1890: register struct blk *p;
1891: {
1892: rel++;
1893: nbytes -= p->last - p->beg;
1894: p->rd = (char *)hfree;
1895: hfree = p;
1896: free(p->beg);
1897: }
1898:
1899: struct blk *
1900: getwd(p)
1901: struct blk *p;
1902: {
1903: register struct wblk *wp;
1904:
1905: wp = (struct wblk *)p;
1906: if (wp->rdw == wp->wtw)
1907: return(NULL);
1908: return(*wp->rdw++);
1909: }
1910:
1911: putwd(p, c)
1912: struct blk *p, *c;
1913: {
1914: register struct wblk *wp;
1915:
1916: wp = (struct wblk *)p;
1917: if (wp->wtw == wp->lastw)
1918: more(p);
1919: *wp->wtw++ = c;
1920: }
1921:
1922: struct blk *
1923: lookwd(p)
1924: struct blk *p;
1925: {
1926: register struct wblk *wp;
1927:
1928: wp = (struct wblk *)p;
1929: if (wp->rdw == wp->wtw)
1930: return(NULL);
1931: return(*wp->rdw);
1932: }
1933: char *
1934: nalloc(p,nbytes)
1935: register char *p;
1936: unsigned nbytes;
1937: {
1938: char *malloc();
1939: register char *q, *r;
1940: q = r = malloc(nbytes);
1941: if(q==0)
1942: return(0);
1943: while(nbytes--)
1944: *q++ = *p++;
1945: return(r);
1946: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.