sed: Can't open /usr/web/plan9/sources.html #include <u.h> #include <libc.h> #include <bio.h> typedef void* pointer; #pragma varargck type "lx" pointer #define FATAL 0 #define NFATAL 1 #define BLK sizeof(Blk) #define PTRSZ sizeof(int*) #define TBLSZ 256 /* 1<<BI2BY */ #define HEADSZ 1024 #define STKSZ 100 #define RDSKSZ 100 #define ARRAYST 221 #define MAXIND 2048 #define NL 1 #define NG 2 #define NE 3 #define length(p) ((p)->wt-(p)->beg) #define rewind(p) (p)->rd=(p)->beg #define create(p) (p)->rd = (p)->wt = (p)->beg #define fsfile(p) (p)->rd = (p)->wt #define truncate(p) (p)->wt = (p)->rd #define sfeof(p) (((p)->rd==(p)->wt)?1:0) #define sfbeg(p) (((p)->rd==(p)->beg)?1:0) #define sungetc(p,c) *(--(p)->rd)=c #define sgetc(p) (((p)->rd==(p)->wt)?-1:*(p)->rd++) #define skipc(p) {if((p)->rd<(p)->wt)(p)->rd++;} #define slookc(p) (((p)->rd==(p)->wt)?-1:*(p)->rd) #define sbackc(p) (((p)->rd==(p)->beg)?-1:*(--(p)->rd)) #define backc(p) {if((p)->rd>(p)->beg) --(p)->rd;} #define sputc(p,c) {if((p)->wt==(p)->last)more(p);\ *(p)->wt++ = c; } #define salterc(p,c) {if((p)->rd==(p)->last)more(p);\ *(p)->rd++ = c;\ if((p)->rd>(p)->wt)(p)->wt=(p)->rd;} #define sunputc(p) (*((p)->rd = --(p)->wt)) #define sclobber(p) ((p)->rd = --(p)->wt) #define zero(p) for(pp=(p)->beg;pp<(p)->last;)\ *pp++='\0' #define OUTC(x) {Bputc(&bout,x); if(--count == 0){Bprint(&bout,"\\\n"); count=ll;} } #define TEST2 {if((count -= 2) <=0){Bprint(&bout,"\\\n");count=ll;}} #define EMPTY if(stkerr != 0){Bprint(&bout,"stack empty\n"); continue; } #define EMPTYR(x) if(stkerr!=0){pushp(x);Bprint(&bout,"stack empty\n");continue;} #define EMPTYS if(stkerr != 0){Bprint(&bout,"stack empty\n"); return(1);} #define EMPTYSR(x) if(stkerr !=0){Bprint(&bout,"stack empty\n");pushp(x);return(1);} #define error(p) {Bprint(&bout,p); continue; } #define errorrt(p) {Bprint(&bout,p); return(1); } #define LASTFUN 026 typedef struct Blk Blk; struct Blk { char *rd; char *wt; char *beg; char *last; }; typedef struct Sym Sym; struct Sym { Sym *next; Blk *val; }; typedef struct Wblk Wblk; struct Wblk { Blk **rdw; Blk **wtw; Blk **begw; Blk **lastw; }; Biobuf *curfile, *fsave; Blk *arg1, *arg2; uchar savk; int dbg; int ifile; Blk *scalptr, *basptr, *tenptr, *inbas; Blk *sqtemp, *chptr, *strptr, *divxyz; Blk *stack[STKSZ]; Blk **stkptr,**stkbeg; Blk **stkend; Blk *hfree; int stkerr; int lastchar; Blk *readstk[RDSKSZ]; Blk **readptr; Blk *rem; int k; Blk *irem; int skd,skr; int neg; Sym symlst[TBLSZ]; Sym *stable[TBLSZ]; Sym *sptr, *sfree; long rel; long nbytes; long all; long headmor; long obase; int fw,fw1,ll; void (*outdit)(Blk *p, int flg); int logo; int logten; int count; char *pp; char *dummy; long longest, maxsize, active; int lall, lrel, lcopy, lmore, lbytes; int inside; Biobuf bin; Biobuf bout; void main(int argc, char *argv[]); void commnds(void); Blk* readin(void); Blk* div(Blk *ddivd, Blk *ddivr); int dscale(void); Blk* removr(Blk *p, int n); Blk* dcsqrt(Blk *p); void init(int argc, char *argv[]); void onintr(void); void pushp(Blk *p); Blk* pop(void); Blk* readin(void); Blk* add0(Blk *p, int ct); Blk* mult(Blk *p, Blk *q); void chsign(Blk *p); int readc(void); void unreadc(char c); void binop(char c); void dcprint(Blk *hptr); Blk* dcexp(Blk *base, Blk *ex); Blk* getdec(Blk *p, int sc); void tenot(Blk *p, int sc); void oneot(Blk *p, int sc, char ch); void hexot(Blk *p, int flg); void bigot(Blk *p, int flg); Blk* add(Blk *a1, Blk *a2); int eqk(void); Blk* removc(Blk *p, int n); Blk* scalint(Blk *p); Blk* scale(Blk *p, int n); int subt(void); int command(void); int cond(char c); void load(void); int log2(long n); Blk* salloc(int size); Blk* morehd(void); Blk* copy(Blk *hptr, int size); void sdump(char *s1, Blk *hptr); void seekc(Blk *hptr, int n); void salterwd(Blk *hptr, Blk *n); void more(Blk *hptr); void ospace(char *s); void garbage(char *s); void release(Blk *p); Blk* dcgetwd(Blk *p); void putwd(Blk *p, Blk *c); Blk* lookwd(Blk *p); int getstk(void); /********debug only**/ void tpr(char *cp, Blk *bp) { print("%s-> ", cp); print("beg: %lx rd: %lx wt: %lx last: %lx\n", bp->beg, bp->rd, bp->wt, bp->last); for (cp = bp->beg; cp != bp->wt; cp++) { print("%d", *cp); if (cp != bp->wt-1) print("/"); } print("\n"); } /************/ void main(int argc, char *argv[]) { Binit(&bin, 0, OREAD); Binit(&bout, 1, OWRITE); init(argc,argv); commnds(); exits(0); } void commnds(void) { Blk *p, *q, **ptr, *s, *t; long l; Sym *sp; int sk, sk1, sk2, c, sign, n, d; while(1) { Bflush(&bout); if(((c = readc())>='0' && c <= '9') || (c>='A' && c <='F') || c == '.') { unreadc(c); p = readin(); pushp(p); continue; } switch(c) { case ' ': case '\t': case '\n': case -1: continue; case 'Y': sdump("stk",*stkptr); Bprint(&bout, "all %ld rel %ld headmor %ld\n",all,rel,headmor); Bprint(&bout, "nbytes %ld\n",nbytes); Bprint(&bout, "longest %ld active %ld maxsize %ld\n", longest, active, maxsize); Bprint(&bout, "new all %d rel %d copy %d more %d lbytes %d\n", lall, lrel, lcopy, lmore, lbytes); lall = lrel = lcopy = lmore = lbytes = 0; continue; case '_': p = readin(); savk = sunputc(p); chsign(p); sputc(p,savk); pushp(p); continue; case '-': subt(); continue; case '+': if(eqk() != 0) continue; binop('+'); continue; case '*': arg1 = pop(); EMPTY; arg2 = pop(); EMPTYR(arg1); sk1 = sunputc(arg1); sk2 = sunputc(arg2); savk = sk1+sk2; binop('*'); p = pop(); if(savk>k && savk>sk1 && savk>sk2) { sclobber(p); sk = sk1; if(sk<sk2) sk = sk2; if(sk<k) sk = k; p = removc(p,savk-sk); savk = sk; sputc(p,savk); } pushp(p); continue; case '/': casediv: if(dscale() != 0) continue; binop('/'); if(irem != 0) release(irem); release(rem); continue; case '%': if(dscale() != 0) continue; binop('/'); p = pop(); release(p); if(irem == 0) { sputc(rem,skr+k); pushp(rem); continue; } p = add0(rem,skd-(skr+k)); q = add(p,irem); release(p); release(irem); sputc(q,skd); pushp(q); continue; case 'v': p = pop(); EMPTY; savk = sunputc(p); if(length(p) == 0) { sputc(p,savk); pushp(p); continue; } if(sbackc(p)<0) { error("sqrt of neg number\n"); } if(k<savk) n = savk; else { n = k*2-savk; savk = k; } arg1 = add0(p,n); arg2 = dcsqrt(arg1); sputc(arg2,savk); pushp(arg2); continue; case '^': neg = 0; arg1 = pop(); EMPTY; if(sunputc(arg1) != 0) error("exp not an integer\n"); arg2 = pop(); EMPTYR(arg1); if(sfbeg(arg1) == 0 && sbackc(arg1)<0) { neg++; chsign(arg1); } if(length(arg1)>=3) { error("exp too big\n"); } savk = sunputc(arg2); p = dcexp(arg2,arg1); release(arg2); rewind(arg1); c = sgetc(arg1); if(c == -1) c = 0; else if(sfeof(arg1) == 0) c = sgetc(arg1)*100 + c; d = c*savk; release(arg1); /* if(neg == 0) { removed to fix -exp bug*/ if(k>=savk) n = k; else n = savk; if(n<d) { q = removc(p,d-n); sputc(q,n); pushp(q); } else { sputc(p,d); pushp(p); } /* } else { this is disaster for exp <-127 */ /* sputc(p,d); */ /* pushp(p); */ /* } */ if(neg == 0) continue; p = pop(); q = salloc(2); sputc(q,1); sputc(q,0); pushp(q); pushp(p); goto casediv; case 'z': p = salloc(2); n = stkptr - stkbeg; if(n >= 100) { sputc(p,n/100); n %= 100; } sputc(p,n); sputc(p,0); pushp(p); continue; case 'Z': p = pop(); EMPTY; n = (length(p)-1)<<1; fsfile(p); backc(p); if(sfbeg(p) == 0) { if((c = sbackc(p))<0) { n -= 2; if(sfbeg(p) == 1) n++; else { if((c = sbackc(p)) == 0) n++; else if(c > 90) n--; } } else if(c < 10) n--; } release(p); q = salloc(1); if(n >= 100) { sputc(q,n%100); n /= 100; } sputc(q,n); sputc(q,0); pushp(q); continue; case 'i': p = pop(); EMPTY; p = scalint(p); release(inbas); inbas = p; continue; case 'I': p = copy(inbas,length(inbas)+1); sputc(p,0); pushp(p); continue; case 'o': p = pop(); EMPTY; p = scalint(p); sign = 0; n = length(p); q = copy(p,n); fsfile(q); l = c = sbackc(q); if(n != 1) { if(c<0) { sign = 1; chsign(q); n = length(q); fsfile(q); l = c = sbackc(q); } if(n != 1) { while(sfbeg(q) == 0) l = l*100+sbackc(q); } } logo = log2(l); obase = l; release(basptr); if(sign == 1) obase = -l; basptr = p; outdit = bigot; if(n == 1 && sign == 0) { if(c <= 16) { outdit = hexot; fw = 1; fw1 = 0; ll = 70; release(q); continue; } } n = 0; if(sign == 1) n++; p = salloc(1); sputc(p,-1); t = add(p,q); n += length(t)*2; fsfile(t); if(sbackc(t)>9) n++; release(t); release(q); release(p); fw = n; fw1 = n-1; ll = 70; if(fw>=ll) continue; ll = (70/fw)*fw; continue; case 'O': p = copy(basptr,length(basptr)+1); sputc(p,0); pushp(p); continue; case '[': n = 0; p = salloc(0); for(;;) { if((c = readc()) == ']') { if(n == 0) break; n--; } sputc(p,c); if(c == '[') n++; } pushp(p); continue; case 'k': p = pop(); EMPTY; p = scalint(p); if(length(p)>1) { error("scale too big\n"); } rewind(p); k = 0; if(!sfeof(p)) k = sgetc(p); release(scalptr); scalptr = p; continue; case 'K': p = copy(scalptr,length(scalptr)+1); sputc(p,0); pushp(p); continue; case 'X': p = pop(); EMPTY; fsfile(p); n = sbackc(p); release(p); p = salloc(2); sputc(p,n); sputc(p,0); pushp(p); continue; case 'Q': p = pop(); EMPTY; if(length(p)>2) { error("Q?\n"); } rewind(p); if((c = sgetc(p))<0) { error("neg Q\n"); } release(p); while(c-- > 0) { if(readptr == &readstk[0]) { error("readstk?\n"); } if(*readptr != 0) release(*readptr); readptr--; } continue; case 'q': if(readptr <= &readstk[1]) exits(0); if(*readptr != 0) release(*readptr); readptr--; if(*readptr != 0) release(*readptr); readptr--; continue; case 'f': if(stkptr == &stack[0]) Bprint(&bout,"empty stack\n"); else { for(ptr = stkptr; ptr > &stack[0];) { dcprint(*ptr--); } } continue; case 'p': if(stkptr == &stack[0]) Bprint(&bout,"empty stack\n"); else { dcprint(*stkptr); } continue; case 'P': p = pop(); EMPTY; sputc(p,0); Bprint(&bout,"%s",p->beg); release(p); continue; case 'd': if(stkptr == &stack[0]) { Bprint(&bout,"empty stack\n"); continue; } q = *stkptr; n = length(q); p = copy(*stkptr,n); pushp(p); continue; case 'c': while(stkerr == 0) { p = pop(); if(stkerr == 0) release(p); } continue; case 'S': if(stkptr == &stack[0]) { error("save: args\n"); } c = getstk() & 0377; sptr = stable[c]; sp = stable[c] = sfree; sfree = sfree->next; if(sfree == 0) goto sempty; sp->next = sptr; p = pop(); EMPTY; if(c >= ARRAYST) { q = copy(p,length(p)+PTRSZ); for(n = 0;n < PTRSZ;n++) { sputc(q,0); } release(p); p = q; } sp->val = p; continue; sempty: error("symbol table overflow\n"); case 's': if(stkptr == &stack[0]) { error("save:args\n"); } c = getstk() & 0377; sptr = stable[c]; if(sptr != 0) { p = sptr->val; if(c >= ARRAYST) { rewind(p); while(sfeof(p) == 0) release(dcgetwd(p)); } release(p); } else { sptr = stable[c] = sfree; sfree = sfree->next; if(sfree == 0) goto sempty; sptr->next = 0; } p = pop(); sptr->val = p; continue; case 'l': load(); continue; case 'L': c = getstk() & 0377; sptr = stable[c]; if(sptr == 0) { error("L?\n"); } stable[c] = sptr->next; sptr->next = sfree; sfree = sptr; p = sptr->val; if(c >= ARRAYST) { rewind(p); while(sfeof(p) == 0) { q = dcgetwd(p); if(q != 0) release(q); } } pushp(p); continue; case ':': p = pop(); EMPTY; q = scalint(p); fsfile(q); c = 0; if((sfbeg(q) == 0) && ((c = sbackc(q))<0)) { error("neg index\n"); } if(length(q)>2) { error("index too big\n"); } if(sfbeg(q) == 0) c = c*100+sbackc(q); if(c >= MAXIND) { error("index too big\n"); } release(q); n = getstk() & 0377; sptr = stable[n]; if(sptr == 0) { sptr = stable[n] = sfree; sfree = sfree->next; if(sfree == 0) goto sempty; sptr->next = 0; p = salloc((c+PTRSZ)*PTRSZ); zero(p); } else { p = sptr->val; if(length(p)-PTRSZ < c*PTRSZ) { q = copy(p,(c+PTRSZ)*PTRSZ); release(p); p = q; } } seekc(p,c*PTRSZ); q = lookwd(p); if(q!=0) release(q); s = pop(); EMPTY; salterwd(p, s); sptr->val = p; continue; case ';': p = pop(); EMPTY; q = scalint(p); fsfile(q); c = 0; if((sfbeg(q) == 0) && ((c = sbackc(q))<0)) { error("neg index\n"); } if(length(q)>2) { error("index too big\n"); } if(sfbeg(q) == 0) c = c*100+sbackc(q); if(c >= MAXIND) { error("index too big\n"); } release(q); n = getstk() & 0377; sptr = stable[n]; if(sptr != 0){ p = sptr->val; if(length(p)-PTRSZ >= c*PTRSZ) { seekc(p,c*PTRSZ); s = dcgetwd(p); if(s != 0) { q = copy(s,length(s)); pushp(q); continue; } } } q = salloc(1); /*so uninitialized array elt prints as 0*/ sputc(q, 0); pushp(q); continue; case 'x': execute: p = pop(); EMPTY; if((readptr != &readstk[0]) && (*readptr != 0)) { if((*readptr)->rd == (*readptr)->wt) release(*readptr); else { if(readptr++ == &readstk[RDSKSZ]) { error("nesting depth\n"); } } } else readptr++; *readptr = p; if(p != 0) rewind(p); else { if((c = readc()) != '\n') unreadc(c); } continue; case '?': if(++readptr == &readstk[RDSKSZ]) { error("nesting depth\n"); } *readptr = 0; fsave = curfile; curfile = &bin; while((c = readc()) == '!') command(); p = salloc(0); sputc(p,c); while((c = readc()) != '\n') { sputc(p,c); if(c == '\\') sputc(p,readc()); } curfile = fsave; *readptr = p; continue; case '!': if(command() == 1) goto execute; continue; case '<': case '>': case '=': if(cond(c) == 1) goto execute; continue; default: Bprint(&bout,"%o is unimplemented\n",c); } } } Blk* div(Blk *ddivd, Blk *ddivr) { int divsign, remsign, offset, divcarry, carry, dig, magic, d, dd, under, first; long c, td, cc; Blk *ps, *px, *p, *divd, *divr; dig = 0; under = 0; divcarry = 0; rem = 0; p = salloc(0); if(length(ddivr) == 0) { pushp(ddivr); Bprint(&bout,"divide by 0\n"); return(p); } divsign = remsign = first = 0; divr = ddivr; fsfile(divr); if(sbackc(divr) == -1) { divr = copy(ddivr,length(ddivr)); chsign(divr); divsign = ~divsign; } divd = copy(ddivd,length(ddivd)); fsfile(divd); if(sfbeg(divd) == 0 && sbackc(divd) == -1) { chsign(divd); divsign = ~divsign; remsign = ~remsign; } offset = length(divd) - length(divr); if(offset < 0) goto ddone; seekc(p,offset+1); sputc(divd,0); magic = 0; fsfile(divr); c = sbackc(divr); if(c < 10) magic++; c = c * 100 + (sfbeg(divr)?0:sbackc(divr)); if(magic>0){ c = (c * 100 +(sfbeg(divr)?0:sbackc(divr)))*2; c /= 25; } while(offset >= 0) { first++; fsfile(divd); td = sbackc(divd) * 100; dd = sfbeg(divd)?0:sbackc(divd); td = (td + dd) * 100; dd = sfbeg(divd)?0:sbackc(divd); td = td + dd; cc = c; if(offset == 0) td++; else cc++; if(magic != 0) td = td<<3; dig = td/cc; under=0; if(td%cc < 8 && dig > 0 && magic) { dig--; under=1; } rewind(divr); rewind(divxyz); carry = 0; while(sfeof(divr) == 0) { d = sgetc(divr)*dig+carry; carry = d / 100; salterc(divxyz,d%100); } salterc(divxyz,carry); rewind(divxyz); seekc(divd,offset); carry = 0; while(sfeof(divd) == 0) { d = slookc(divd); d = d-(sfeof(divxyz)?0:sgetc(divxyz))-carry; carry = 0; if(d < 0) { d += 100; carry = 1; } salterc(divd,d); } divcarry = carry; backc(p); salterc(p,dig); backc(p); fsfile(divd); d=sbackc(divd); if((d != 0) && /*!divcarry*/ (offset != 0)) { d = sbackc(divd) + 100; salterc(divd,d); } if(--offset >= 0) divd->wt--; } if(under) { /* undershot last - adjust*/ px = copy(divr,length(divr)); /*11/88 don't corrupt ddivr*/ chsign(px); ps = add(px,divd); fsfile(ps); if(length(ps) > 0 && sbackc(ps) < 0) { release(ps); /*only adjust in really undershot*/ } else { release(divd); salterc(p, dig+1); divd=ps; } } if(divcarry != 0) { salterc(p,dig-1); salterc(divd,-1); ps = add(divr,divd); release(divd); divd = ps; } rewind(p); divcarry = 0; while(sfeof(p) == 0){ d = slookc(p)+divcarry; divcarry = 0; if(d >= 100){ d -= 100; divcarry = 1; } salterc(p,d); } if(divcarry != 0)salterc(p,divcarry); fsfile(p); while(sfbeg(p) == 0) { if(sbackc(p) != 0) break; truncate(p); } if(divsign < 0) chsign(p); fsfile(divd); while(sfbeg(divd) == 0) { if(sbackc(divd) != 0) break; truncate(divd); } ddone: if(remsign<0) chsign(divd); if(divr != ddivr) release(divr); rem = divd; return(p); } int dscale(void) { Blk *dd, *dr, *r; int c; dr = pop(); EMPTYS; dd = pop(); EMPTYSR(dr); fsfile(dd); skd = sunputc(dd); fsfile(dr); skr = sunputc(dr); if(sfbeg(dr) == 1 || (sfbeg(dr) == 0 && sbackc(dr) == 0)) { sputc(dr,skr); pushp(dr); Bprint(&bout,"divide by 0\n"); return(1); } if(sfbeg(dd) == 1 || (sfbeg(dd) == 0 && sbackc(dd) == 0)) { sputc(dd,skd); pushp(dd); return(1); } c = k-skd+skr; if(c < 0) r = removr(dd,-c); else { r = add0(dd,c); irem = 0; } arg1 = r; arg2 = dr; savk = k; return(0); } Blk* removr(Blk *p, int n) { int nn, neg; Blk *q, *s, *r; fsfile(p); neg = sbackc(p); if(neg < 0) chsign(p); rewind(p); nn = (n+1)/2; q = salloc(nn); while(n>1) { sputc(q,sgetc(p)); n -= 2; } r = salloc(2); while(sfeof(p) == 0) sputc(r,sgetc(p)); release(p); if(n == 1){ s = div(r,tenptr); release(r); rewind(rem); if(sfeof(rem) == 0) sputc(q,sgetc(rem)); release(rem); if(neg < 0){ chsign(s); chsign(q); irem = q; return(s); } irem = q; return(s); } if(neg < 0) { chsign(r); chsign(q); irem = q; return(r); } irem = q; return(r); } Blk* dcsqrt(Blk *p) { Blk *t, *r, *q, *s; int c, n, nn; n = length(p); fsfile(p); c = sbackc(p); if((n&1) != 1) c = c*100+(sfbeg(p)?0:sbackc(p)); n = (n+1)>>1; r = salloc(n); zero(r); seekc(r,n); nn=1; while((c -= nn)>=0) nn+=2; c=(nn+1)>>1; fsfile(r); backc(r); if(c>=100) { c -= 100; salterc(r,c); sputc(r,1); } else salterc(r,c); for(;;){ q = div(p,r); s = add(q,r); release(q); release(rem); q = div(s,sqtemp); release(s); release(rem); s = copy(r,length(r)); chsign(s); t = add(s,q); release(s); fsfile(t); nn = sfbeg(t)?0:sbackc(t); if(nn>=0) break; release(r); release(t); r = q; } release(t); release(q); release(p); return(r); } Blk* dcexp(Blk *base, Blk *ex) { Blk *r, *e, *p, *e1, *t, *cp; int temp, c, n; r = salloc(1); sputc(r,1); p = copy(base,length(base)); e = copy(ex,length(ex)); fsfile(e); if(sfbeg(e) != 0) goto edone; temp=0; c = sbackc(e); if(c<0) { temp++; chsign(e); } while(length(e) != 0) { e1=div(e,sqtemp); release(e); e = e1; n = length(rem); release(rem); if(n != 0) { e1=mult(p,r); release(r); r = e1; } t = copy(p,length(p)); cp = mult(p,t); release(p); release(t); p = cp; } if(temp != 0) { if((c = length(base)) == 0) { goto edone; } if(c>1) create(r); else { rewind(base); if((c = sgetc(base))<=1) { create(r); sputc(r,c); } else create(r); } } edone: release(p); release(e); return(r); } void init(int argc, char *argv[]) { Sym *sp; Dir *d; ARGBEGIN { default: dbg = 1; break; } ARGEND ifile = 1; curfile = &bin; if(*argv){ d = dirstat(*argv); if(d == nil) { fprint(2, "dc: can't open file %s\n", *argv); exits("open"); } if(d->mode & DMDIR) { fprint(2, "dc: file %s is a directory\n", *argv); exits("open"); } free(d); if((curfile = Bopen(*argv, OREAD)) == 0) { fprint(2,"dc: can't open file %s\n", *argv); exits("open"); } } /* dummy = malloc(0); /* prepare for garbage-collection */ scalptr = salloc(1); sputc(scalptr,0); basptr = salloc(1); sputc(basptr,10); obase=10; logten=log2(10L); ll=70; fw=1; fw1=0; tenptr = salloc(1); sputc(tenptr,10); obase=10; inbas = salloc(1); sputc(inbas,10); sqtemp = salloc(1); sputc(sqtemp,2); chptr = salloc(0); strptr = salloc(0); divxyz = salloc(0); stkbeg = stkptr = &stack[0]; stkend = &stack[STKSZ]; stkerr = 0; readptr = &readstk[0]; k=0; sp = sptr = &symlst[0]; while(sptr < &symlst[TBLSZ-1]) { sptr->next = ++sp; sptr++; } sptr->next=0; sfree = &symlst[0]; } void pushp(Blk *p) { if(stkptr == stkend) { Bprint(&bout,"out of stack space\n"); return; } stkerr=0; *++stkptr = p; return; } Blk* pop(void) { if(stkptr == stack) { stkerr=1; return(0); } return(*stkptr--); } Blk* readin(void) { Blk *p, *q; int dp, dpct, c; dp = dpct=0; p = salloc(0); for(;;){ c = readc(); switch(c) { case '.': if(dp != 0) goto gotnum; dp++; continue; case '\\': readc(); continue; default: if(c >= 'A' && c <= 'F') c = c - 'A' + 10; else if(c >= '0' && c <= '9') c -= '0'; else goto gotnum; if(dp != 0) { if(dpct >= 99) continue; dpct++; } create(chptr); if(c != 0) sputc(chptr,c); q = mult(p,inbas); release(p); p = add(chptr,q); release(q); } } gotnum: unreadc(c); if(dp == 0) { sputc(p,0); return(p); } else { q = scale(p,dpct); return(q); } } /* * returns pointer to struct with ct 0's & p */ Blk* add0(Blk *p, int ct) { Blk *q, *t; q = salloc(length(p)+(ct+1)/2); while(ct>1) { sputc(q,0); ct -= 2; } rewind(p); while(sfeof(p) == 0) { sputc(q,sgetc(p)); } release(p); if(ct == 1) { t = mult(tenptr,q); release(q); return(t); } return(q); } Blk* mult(Blk *p, Blk *q) { Blk *mp, *mq, *mr; int sign, offset, carry; int cq, cp, mt, mcr; offset = sign = 0; fsfile(p); mp = p; if(sfbeg(p) == 0) { if(sbackc(p)<0) { mp = copy(p,length(p)); chsign(mp); sign = ~sign; } } fsfile(q); mq = q; if(sfbeg(q) == 0){ if(sbackc(q)<0) { mq = copy(q,length(q)); chsign(mq); sign = ~sign; } } mr = salloc(length(mp)+length(mq)); zero(mr); rewind(mq); while(sfeof(mq) == 0) { cq = sgetc(mq); rewind(mp); rewind(mr); mr->rd += offset; carry=0; while(sfeof(mp) == 0) { cp = sgetc(mp); mcr = sfeof(mr)?0:slookc(mr); mt = cp*cq + carry + mcr; carry = mt/100; salterc(mr,mt%100); } offset++; if(carry != 0) { mcr = sfeof(mr)?0:slookc(mr); salterc(mr,mcr+carry); } } if(sign < 0) { chsign(mr); } if(mp != p) release(mp); if(mq != q) release(mq); return(mr); } void chsign(Blk *p) { int carry; char ct; carry=0; rewind(p); while(sfeof(p) == 0) { ct=100-slookc(p)-carry; carry=1; if(ct>=100) { ct -= 100; carry=0; } salterc(p,ct); } if(carry != 0) { sputc(p,-1); fsfile(p); backc(p); ct = sbackc(p); if(ct == 99 /*&& !sfbeg(p)*/) { truncate(p); sputc(p,-1); } } else{ fsfile(p); ct = sbackc(p); if(ct == 0) truncate(p); } return; } int readc(void) { loop: if((readptr != &readstk[0]) && (*readptr != 0)) { if(sfeof(*readptr) == 0) return(lastchar = sgetc(*readptr)); release(*readptr); readptr--; goto loop; } lastchar = Bgetc(curfile); if(lastchar != -1) return(lastchar); if(readptr != &readptr[0]) { readptr--; if(*readptr == 0) curfile = &bin; goto loop; } if(curfile != &bin) { Bterm(curfile); curfile = &bin; goto loop; } exits(0); return 0; /* shut up ken */ } void unreadc(char c) { if((readptr != &readstk[0]) && (*readptr != 0)) { sungetc(*readptr,c); } else Bungetc(curfile); return; } void binop(char c) { Blk *r; r = 0; switch(c) { case '+': r = add(arg1,arg2); break; case '*': r = mult(arg1,arg2); break; case '/': r = div(arg1,arg2); break; } release(arg1); release(arg2); sputc(r,savk); pushp(r); } void dcprint(Blk *hptr) { Blk *p, *q, *dec; int dig, dout, ct, sc; rewind(hptr); while(sfeof(hptr) == 0) { if(sgetc(hptr)>99) { rewind(hptr); while(sfeof(hptr) == 0) { Bprint(&bout,"%c",sgetc(hptr)); } Bprint(&bout,"\n"); return; } } fsfile(hptr); sc = sbackc(hptr); if(sfbeg(hptr) != 0) { Bprint(&bout,"0\n"); return; } count = ll; p = copy(hptr,length(hptr)); sclobber(p); fsfile(p); if(sbackc(p)<0) { chsign(p); OUTC('-'); } if((obase == 0) || (obase == -1)) { oneot(p,sc,'d'); return; } if(obase == 1) { oneot(p,sc,'1'); return; } if(obase == 10) { tenot(p,sc); return; } /* sleazy hack to scale top of stack - divide by 1 */ pushp(p); sputc(p, sc); p=salloc(0); create(p); sputc(p, 1); sputc(p, 0); pushp(p); if(dscale() != 0) return; p = div(arg1, arg2); release(arg1); release(arg2); sc = savk; create(strptr); dig = logten*sc; dout = ((dig/10) + dig) / logo; dec = getdec(p,sc); p = removc(p,sc); while(length(p) != 0) { q = div(p,basptr); release(p); p = q; (*outdit)(rem,0); } release(p); fsfile(strptr); while(sfbeg(strptr) == 0) OUTC(sbackc(strptr)); if(sc == 0) { release(dec); Bprint(&bout,"\n"); return; } create(strptr); OUTC('.'); ct=0; do { q = mult(basptr,dec); release(dec); dec = getdec(q,sc); p = removc(q,sc); (*outdit)(p,1); } while(++ct < dout); release(dec); rewind(strptr); while(sfeof(strptr) == 0) OUTC(sgetc(strptr)); Bprint(&bout,"\n"); } Blk* getdec(Blk *p, int sc) { int cc; Blk *q, *t, *s; rewind(p); if(length(p)*2 < sc) { q = copy(p,length(p)); return(q); } q = salloc(length(p)); while(sc >= 1) { sputc(q,sgetc(p)); sc -= 2; } if(sc != 0) { t = mult(q,tenptr); s = salloc(cc = length(q)); release(q); rewind(t); while(cc-- > 0) sputc(s,sgetc(t)); sputc(s,0); release(t); t = div(s,tenptr); release(s); release(rem); return(t); } return(q); } void tenot(Blk *p, int sc) { int c, f; fsfile(p); f=0; while((sfbeg(p) == 0) && ((p->rd-p->beg-1)*2 >= sc)) { c = sbackc(p); if((c<10) && (f == 1)) Bprint(&bout,"0%d",c); else Bprint(&bout,"%d",c); f=1; TEST2; } if(sc == 0) { Bprint(&bout,"\n"); release(p); return; } if((p->rd-p->beg)*2 > sc) { c = sbackc(p); Bprint(&bout,"%d.",c/10); TEST2; OUTC(c%10 +'0'); sc--; } else { OUTC('.'); } while(sc>(p->rd-p->beg)*2) { OUTC('0'); sc--; } while(sc > 1) { c = sbackc(p); if(c<10) Bprint(&bout,"0%d",c); else Bprint(&bout,"%d",c); sc -= 2; TEST2; } if(sc == 1) { OUTC(sbackc(p)/10 +'0'); } Bprint(&bout,"\n"); release(p); } void oneot(Blk *p, int sc, char ch) { Blk *q; q = removc(p,sc); create(strptr); sputc(strptr,-1); while(length(q)>0) { p = add(strptr,q); release(q); q = p; OUTC(ch); } release(q); Bprint(&bout,"\n"); } void hexot(Blk *p, int flg) { int c; USED(flg); rewind(p); if(sfeof(p) != 0) { sputc(strptr,'0'); release(p); return; } c = sgetc(p); release(p); if(c >= 16) { Bprint(&bout,"hex digit > 16"); return; } sputc(strptr,c<10?c+'0':c-10+'a'); } void bigot(Blk *p, int flg) { Blk *t, *q; int neg, l; if(flg == 1) { t = salloc(0); l = 0; } else { t = strptr; l = length(strptr)+fw-1; } neg=0; if(length(p) != 0) { fsfile(p); if(sbackc(p)<0) { neg=1; chsign(p); } while(length(p) != 0) { q = div(p,tenptr); release(p); p = q; rewind(rem); sputc(t,sfeof(rem)?'0':sgetc(rem)+'0'); release(rem); } } release(p); if(flg == 1) { l = fw1-length(t); if(neg != 0) { l--; sputc(strptr,'-'); } fsfile(t); while(l-- > 0) sputc(strptr,'0'); while(sfbeg(t) == 0) sputc(strptr,sbackc(t)); release(t); } else { l -= length(strptr); while(l-- > 0) sputc(strptr,'0'); if(neg != 0) { sclobber(strptr); sputc(strptr,'-'); } } sputc(strptr,' '); } Blk* add(Blk *a1, Blk *a2) { Blk *p; int carry, n, size, c, n1, n2; size = length(a1)>length(a2)?length(a1):length(a2); p = salloc(size); rewind(a1); rewind(a2); carry=0; while(--size >= 0) { n1 = sfeof(a1)?0:sgetc(a1); n2 = sfeof(a2)?0:sgetc(a2); n = n1 + n2 + carry; if(n>=100) { carry=1; n -= 100; } else if(n<0) { carry = -1; n += 100; } else carry = 0; sputc(p,n); } if(carry != 0) sputc(p,carry); fsfile(p); if(sfbeg(p) == 0) { c = 0; while(sfbeg(p) == 0 && (c = sbackc(p)) == 0) ; if(c != 0) salterc(p,c); truncate(p); } fsfile(p); if(sfbeg(p) == 0 && sbackc(p) == -1) { while((c = sbackc(p)) == 99) { if(c == -1) break; } skipc(p); salterc(p,-1); truncate(p); } return(p); } int eqk(void) { Blk *p, *q; int skp, skq; p = pop(); EMPTYS; q = pop(); EMPTYSR(p); skp = sunputc(p); skq = sunputc(q); if(skp == skq) { arg1=p; arg2=q; savk = skp; return(0); } if(skp < skq) { savk = skq; p = add0(p,skq-skp); } else { savk = skp; q = add0(q,skp-skq); } arg1=p; arg2=q; return(0); } Blk* removc(Blk *p, int n) { Blk *q, *r; rewind(p); while(n>1) { skipc(p); n -= 2; } q = salloc(2); while(sfeof(p) == 0) sputc(q,sgetc(p)); if(n == 1) { r = div(q,tenptr); release(q); release(rem); q = r; } release(p); return(q); } Blk* scalint(Blk *p) { int n; n = sunputc(p); p = removc(p,n); return(p); } Blk* scale(Blk *p, int n) { Blk *q, *s, *t; t = add0(p,n); q = salloc(1); sputc(q,n); s = dcexp(inbas,q); release(q); q = div(t,s); release(t); release(s); release(rem); sputc(q,n); return(q); } int subt(void) { arg1=pop(); EMPTYS; savk = sunputc(arg1); chsign(arg1); sputc(arg1,savk); pushp(arg1); if(eqk() != 0) return(1); binop('+'); return(0); } int command(void) { char line[100], *sl; int pid, p, c; switch(c = readc()) { case '<': return(cond(NL)); case '>': return(cond(NG)); case '=': return(cond(NE)); default: sl = line; *sl++ = c; while((c = readc()) != '\n') *sl++ = c; *sl = 0; if((pid = fork()) == 0) { execl("/bin/rc","rc","-c",line,nil); exits("shell"); } for(;;) { if((p = waitpid()) < 0) break; if(p== pid) break; } Bprint(&bout,"!\n"); return(0); } } int cond(char c) { Blk *p; int cc; if(subt() != 0) return(1); p = pop(); sclobber(p); if(length(p) == 0) { release(p); if(c == '<' || c == '>' || c == NE) { getstk(); return(0); } load(); return(1); } if(c == '='){ release(p); getstk(); return(0); } if(c == NE) { release(p); load(); return(1); } fsfile(p); cc = sbackc(p); release(p); if((cc<0 && (c == '<' || c == NG)) || (cc >0) && (c == '>' || c == NL)) { getstk(); return(0); } load(); return(1); } void load(void) { int c; Blk *p, *q, *t, *s; c = getstk() & 0377; sptr = stable[c]; if(sptr != 0) { p = sptr->val; if(c >= ARRAYST) { q = salloc(length(p)); rewind(p); while(sfeof(p) == 0) { s = dcgetwd(p); if(s == 0) { putwd(q, (Blk*)0); } else { t = copy(s,length(s)); putwd(q,t); } } pushp(q); } else { q = copy(p,length(p)); pushp(q); } } else { q = salloc(1); if(c <= LASTFUN) { Bprint(&bout,"function %c undefined\n",c+'a'-1); sputc(q,'c'); sputc(q,'0'); sputc(q,' '); sputc(q,'1'); sputc(q,'Q'); } else sputc(q,0); pushp(q); } } int log2(long n) { int i; if(n == 0) return(0); i=31; if(n<0) return(i); while((n <<= 1) > 0) i--; return i-1; } Blk* salloc(int size) { Blk *hdr; char *ptr; all++; lall++; if(all - rel > active) active = all - rel; nbytes += size; lbytes += size; if(nbytes >maxsize) maxsize = nbytes; if(size > longest) longest = size; ptr = malloc((unsigned)size); if(ptr == 0){ garbage("salloc"); if((ptr = malloc((unsigned)size)) == 0) ospace("salloc"); } if((hdr = hfree) == 0) hdr = morehd(); hfree = (Blk *)hdr->rd; hdr->rd = hdr->wt = hdr->beg = ptr; hdr->last = ptr+size; return(hdr); } Blk* morehd(void) { Blk *h, *kk; headmor++; nbytes += HEADSZ; hfree = h = (Blk *)malloc(HEADSZ); if(hfree == 0) { garbage("morehd"); if((hfree = h = (Blk*)malloc(HEADSZ)) == 0) ospace("headers"); } kk = h; while(h<hfree+(HEADSZ/BLK)) (h++)->rd = (char*)++kk; (h-1)->rd=0; return(hfree); } Blk* copy(Blk *hptr, int size) { Blk *hdr; unsigned sz; char *ptr; all++; lall++; lcopy++; nbytes += size; lbytes += size; if(size > longest) longest = size; if(size > maxsize) maxsize = size; sz = length(hptr); ptr = malloc(size); if(ptr == 0) { Bprint(&bout,"copy size %d\n",size); ospace("copy"); } memmove(ptr, hptr->beg, sz); if (size-sz > 0) memset(ptr+sz, 0, size-sz); if((hdr = hfree) == 0) hdr = morehd(); hfree = (Blk *)hdr->rd; hdr->rd = hdr->beg = ptr; hdr->last = ptr+size; hdr->wt = ptr+sz; ptr = hdr->wt; while(ptr<hdr->last) *ptr++ = '\0'; return(hdr); } void sdump(char *s1, Blk *hptr) { char *p; if(hptr == nil) { Bprint(&bout, "%s no block\n", s1); return; } Bprint(&bout,"%s %lx rd %lx wt %lx beg %lx last %lx\n", s1,hptr,hptr->rd,hptr->wt,hptr->beg,hptr->last); p = hptr->beg; while(p < hptr->wt) Bprint(&bout,"%d ",*p++); Bprint(&bout,"\n"); } void seekc(Blk *hptr, int n) { char *nn,*p; nn = hptr->beg+n; if(nn > hptr->last) { nbytes += nn - hptr->last; if(nbytes > maxsize) maxsize = nbytes; lbytes += nn - hptr->last; if(n > longest) longest = n; /* free(hptr->beg); /**/ p = realloc(hptr->beg, n); if(p == 0) { /* hptr->beg = realloc(hptr->beg, hptr->last-hptr->beg); ** garbage("seekc"); ** if((p = realloc(hptr->beg, n)) == 0) */ ospace("seekc"); } hptr->beg = p; hptr->wt = hptr->last = hptr->rd = p+n; return; } hptr->rd = nn; if(nn>hptr->wt) hptr->wt = nn; } void salterwd(Blk *ahptr, Blk *n) { Wblk *hptr; hptr = (Wblk*)ahptr; if(hptr->rdw == hptr->lastw) more(ahptr); *hptr->rdw++ = n; if(hptr->rdw > hptr->wtw) hptr->wtw = hptr->rdw; } void more(Blk *hptr) { unsigned size; char *p; if((size=(hptr->last-hptr->beg)*2) == 0) size=2; nbytes += size/2; if(nbytes > maxsize) maxsize = nbytes; if(size > longest) longest = size; lbytes += size/2; lmore++; /* free(hptr->beg);/**/ p = realloc(hptr->beg, size); if(p == 0) { /* hptr->beg = realloc(hptr->beg, (hptr->last-hptr->beg)); ** garbage("more"); ** if((p = realloc(hptr->beg,size)) == 0) */ ospace("more"); } hptr->rd = p + (hptr->rd - hptr->beg); hptr->wt = p + (hptr->wt - hptr->beg); hptr->beg = p; hptr->last = p+size; } void ospace(char *s) { Bprint(&bout,"out of space: %s\n",s); Bprint(&bout,"all %ld rel %ld headmor %ld\n",all,rel,headmor); Bprint(&bout,"nbytes %ld\n",nbytes); sdump("stk",*stkptr); abort(); } void garbage(char *s) { USED(s); } void release(Blk *p) { rel++; lrel++; nbytes -= p->last - p->beg; p->rd = (char*)hfree; hfree = p; free(p->beg); } Blk* dcgetwd(Blk *p) { Wblk *wp; wp = (Wblk*)p; if(wp->rdw == wp->wtw) return(0); return(*wp->rdw++); } void putwd(Blk *p, Blk *c) { Wblk *wp; wp = (Wblk*)p; if(wp->wtw == wp->lastw) more(p); *wp->wtw++ = c; } Blk* lookwd(Blk *p) { Wblk *wp; wp = (Wblk*)p; if(wp->rdw == wp->wtw) return(0); return(*wp->rdw); } int getstk(void) { int n; uchar c; c = readc(); if(c != '<') return c; n = 0; while(1) { c = readc(); if(c == '>') break; n = n*10+c-'0'; } return n; } sed: Can't open /usr/web/plan9/sources.html