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