static struct argnod *r_arg(Shell_t *shp) { register struct argnod *ap=0, *apold, *aptop=0; register long l; Stk_t *stkp=shp->stk; while((l=sfgetu(infile))>0) { ap = (struct argnod*)stkseek(stkp,(unsigned)l+ARGVAL); if(!aptop) aptop = ap; else apold->argnxt.ap = ap; if(--l > 0) { sfread(infile,ap->argval,(size_t)l); ccmaps(ap->argval, l, CC_ASCII, CC_NATIVE); } ap->argval[l] = 0; ap->argchn.cp = 0; ap->argflag = sfgetc(infile); #if 0 if((ap->argflag&ARG_MESSAGE) && *ap->argval) { /* replace international messages */ sh_endword(shp,1); ap->argflag &= ~ARG_MESSAGE; if(!(ap->argflag&(ARG_MAC|ARG_EXP))) ap = sh_endword(shp,0); else { ap = (struct argnod*)stkfreeze(stkp,0); if(ap->argflag==0) ap->argflag = ARG_RAW; } } else #endif ap = (struct argnod*)stkfreeze(stkp,0); if(*ap->argval==0 && (ap->argflag&ARG_EXP)) ap->argchn.ap = (struct argnod*)r_tree(shp); else if(*ap->argval==0 && (ap->argflag&~(ARG_APPEND|ARG_MESSAGE|ARG_QUOTED|ARG_ARRAY))==0) { struct fornod *fp = (struct fornod*)getnode(shp->stk,fornod); fp->fortyp = sfgetu(infile); fp->fortre = r_tree(shp); fp->fornam = ap->argval+1; ap->argchn.ap = (struct argnod*)fp; } apold = ap; } if(ap) ap->argnxt.ap = 0; return(aptop); }
static void r_comarg(Shell_t *shp,struct comnod *com) { char *cmdname=0; com->comio = r_redirect(shp); com->comset = r_arg(shp); com->comstate = 0; if(com->comtyp&COMSCAN) { com->comarg = r_arg(shp); if(com->comarg->argflag==ARG_RAW) cmdname = com->comarg->argval; } else if(com->comarg = (struct argnod*)r_comlist(shp)) cmdname = ((struct dolnod*)(com->comarg))->dolval[ARG_SPARE]; com->comline = sfgetu(infile); com->comnamq = 0; if(cmdname) { char *cp; com->comnamp = (void*)nv_search(cmdname,shp->fun_tree,0); if(com->comnamp && (cp =strrchr(cmdname+1,'.'))) { *cp = 0; com->comnamp = (void*)nv_open(cmdname,shp->var_tree,NV_VARNAME|NV_NOADD|NV_NOARRAY); *cp = '.'; } } else com->comnamp = 0; }
void getdeltaheader(register Archive_t* ap, register File_t* f) { register char* s; int n; unsigned long sum; Sfio_t* sp; char c; if (!(ap->format->flags & COMPRESSED)) { if (ap->delta && ap->delta->format && (ap->delta->format->variant == DELTA_94 || ap->delta->format->variant == DELTA_IGNORE && state.delta2delta)) { ap->delta->index++; if (ap->delta->tab && f->name && (f->delta.base = (Member_t*)hashget(ap->delta->tab, f->name))) f->delta.base->mark = 1; if (!(ap->format->flags & DELTAINFO)) { if (f->st->st_size <= 0 || bread(ap, &c, (off_t)1, (off_t)1, 1) <= 0) f->delta.op = DELTA_create; else { f->st->st_size--; f->delta.op = c; getdeltaops(ap, f); if (f->st->st_size >= 12 && (f->delta.op == DELTA_create || f->delta.op == DELTA_update)) { sum = ap->memsum; s = ap->delta->hdrbuf; n = 12; if (bread(ap, s, (off_t)n, (off_t)n, 1) > 0) { if (ap->delta->format->variant == DELTA_88) { unsigned char* u = (unsigned char*)s; int i; i = *u++; u += (i >> 3) & 07; f->uncompressed = 0; i &= 07; while (i-- > 0) f->uncompressed = f->uncompressed * 256 + *u++; } else if (sp = sfnew(NiL, s + 4, n, -1, SF_READ|SF_STRING)) { f->uncompressed = sfgetu(sp); sfclose(sp); } bunread(ap, s, n); } ap->memsum = sum; } }
static char *r_string(Stk_t *stkp) { register Sfio_t *in = infile; register unsigned long l = sfgetu(in); register char *ptr; if(l == 0) return(NIL(char*)); ptr = stkalloc(stkp,(unsigned)l); if(--l > 0) { if(sfread(in,ptr,(size_t)l)!=(size_t)l) return(NIL(char*)); ccmaps(ptr, l, CC_ASCII, CC_NATIVE); } ptr[l] = 0; return(ptr); }
int pzfile(Pz_t* pz) { unsigned char* s; int i; int j; size_t n; /* * 0 or more nul's mean clean EOF */ while (!(i = sfgetc(pz->io))); if (pz->disc->errorf) (*pz->disc->errorf)(pz, pz->disc, -1, "%s: pzfile: i=%02x", pz->path, i); if (i == -1) return 0; if (i == PZ_MARK_TAIL) { /* * file trailer */ while ((n = sfgetu(pz->io)) && !sferror(pz->io) && !sfeof(pz->io) && (s = (unsigned char*)sfreserve(pz->io, n, 0))) if (pz->disc->eventf && (*pz->disc->eventf)(pz, PZ_TAILREAD, s, n, pz->disc) < 0) return -1; if ((i = sfgetc(pz->io)) == -1) return 0; } j = sfgetc(pz->io); if (pz->disc->errorf) (*pz->disc->errorf)(pz, pz->disc, -1, "%s: pzfile: i=%02x j=%02x", pz->path, i, j); if (i == PZ_MAGIC_1 && j == PZ_MAGIC_2) { /* * next file header */ sfungetc(pz->io, j); sfungetc(pz->io, i); return pzopen(pz->disc, (char*)pz, PZ_AGAIN) ? 1 : -1; } if (pz->disc->errorf) (*pz->disc->errorf)(pz, pz->disc, 2, "%s: data corrupted", pz->path); return -1; }
MAIN() { unsigned int i, r; Sfio_t *fp; if(!(fp = sftmp(8))) terror("Can't open temp file\n"); for(i = 10000; i <= 100000; i += 9) if(sfputu(fp,i) < 0) terror("Writing %u\n",i); sfseek(fp,(Sfoff_t)0,0); for(i = 10000; i <= 100000; i += 9) if((r = (unsigned int)sfgetu(fp)) != i) terror("Input=%u, Expect=%u\n",r,i); TSTEXIT(0); }
tmain() { UNUSED(argc); UNUSED(argv); unsigned int i, r; Sfio_t *fp; if (!(fp = sftmp(8))) terror("Can't open temp file"); for (i = 10000; i <= 100000; i += 9) { if (sfputu(fp, i) < 0) terror("Writing %u", i); } sfseek(fp, (Sfoff_t)0, 0); for (i = 10000; i <= 100000; i += 9) { if ((r = (unsigned int)sfgetu(fp)) != i) terror("Input=%u, Expect=%u", r, i); } texit(0); }
/* * read in a shell tree */ static Shnode_t *r_tree(Shell_t *shp) { long l = sfgetl(infile); register int type; register Shnode_t *t=0; if(l<0) return(t); type = l; switch(type&COMMSK) { case TTIME: case TPAR: t = getnode(shp->stk,parnod); t->par.partre = r_tree(shp); break; case TCOM: t = getnode(shp->stk,comnod); t->tre.tretyp = type; r_comarg(shp,(struct comnod*)t); break; case TSETIO: case TFORK: t = getnode(shp->stk,forknod); t->fork.forkline = sfgetu(infile); t->fork.forktre = r_tree(shp); t->fork.forkio = r_redirect(shp); break; case TIF: t = getnode(shp->stk,ifnod); t->if_.iftre = r_tree(shp); t->if_.thtre = r_tree(shp); t->if_.eltre = r_tree(shp); break; case TWH: t = getnode(shp->stk,whnod); t->wh.whinc = (struct arithnod*)r_tree(shp); t->wh.whtre = r_tree(shp); t->wh.dotre = r_tree(shp); break; case TLST: case TAND: case TORF: case TFIL: t = getnode(shp->stk,lstnod); t->lst.lstlef = r_tree(shp); t->lst.lstrit = r_tree(shp); break; case TARITH: t = getnode(shp->stk,arithnod); t->ar.arline = sfgetu(infile); t->ar.arexpr = r_arg(shp); t->ar.arcomp = 0; if((t->ar.arexpr)->argflag&ARG_RAW) t->ar.arcomp = sh_arithcomp((t->ar.arexpr)->argval); break; case TFOR: t = getnode(shp->stk,fornod); t->for_.forline = 0; if(type&FLINENO) t->for_.forline = sfgetu(infile); t->for_.fortre = r_tree(shp); t->for_.fornam = r_string(shp->stk); t->for_.forlst = (struct comnod*)r_tree(shp); break; case TSW: t = getnode(shp->stk,swnod); t->sw.swline = 0; if(type&FLINENO) t->sw.swline = sfgetu(infile); t->sw.swarg = r_arg(shp); if(type&COMSCAN) t->sw.swio = r_redirect(shp); else t->sw.swio = 0; t->sw.swlst = r_switch(shp); break; case TFUN: { Stak_t *savstak; struct slnod *slp; struct functnod *fp; t = getnode(shp->stk,functnod); t->funct.functloc = -1; t->funct.functline = sfgetu(infile); t->funct.functnam = r_string(shp->stk); savstak = stakcreate(STAK_SMALL); savstak = stakinstall(savstak, 0); slp = (struct slnod*)stkalloc(shp->stk,sizeof(struct slnod)+sizeof(struct functnod)); slp->slchild = 0; slp->slnext = shp->st.staklist; shp->st.staklist = 0; fp = (struct functnod*)(slp+1); memset(fp, 0, sizeof(*fp)); fp->functtyp = TFUN|FAMP; if(shp->st.filename) fp->functnam = stkcopy(shp->stk,shp->st.filename); t->funct.functtre = r_tree(shp); t->funct.functstak = slp; slp->slptr = stakinstall(savstak,0); slp->slchild = shp->st.staklist; t->funct.functargs = (struct comnod*)r_tree(shp); break; } case TTST: t = getnode(shp->stk,tstnod); t->tst.tstline = sfgetu(infile); if((type&TPAREN)==TPAREN) t->lst.lstlef = r_tree(shp); else { t->lst.lstlef = (Shnode_t*)r_arg(shp); if((type&TBINARY)) t->lst.lstrit = (Shnode_t*)r_arg(shp); } } if(t) t->tre.tretyp = type; return(t); }
int pzheadread(register Pz_t* pz) { register int i; register int n; register unsigned char* s; size_t m; Pzpart_t* pp; if (pz->flags & PZ_HEAD) return 0; /* * check the header magic */ if (s = (unsigned char*)sfreserve(pz->io, 4, 1)) { i = s[0]; n = s[1]; } else i = n = 0; if (pz->disc->errorf) (*pz->disc->errorf)(pz, pz->disc, -1, "%s: pzheadread: f=%08x i=%02x n=%02x partition=%s%s", pz->path, pz->flags, i, n, pz->disc->partition, s ? "" : " (nil)"); if (i != PZ_MAGIC_1 || n != PZ_MAGIC_2 || s[2] == 0 || s[3] >= 10) { sfread(pz->io, s, 0); if (pz->flags & PZ_SPLIT) return 0; if (pz->flags & PZ_DISC) { pz->flags &= ~PZ_POP; return -1; } if (!(pz->flags & (PZ_READ|PZ_WRITE|PZ_STAT)) && (m = pz->prefix.count)) { if (pz->prefix.terminator >= 0) { while (m-- > 0) { if (!sfgetr(pz->io, pz->prefix.terminator, 0)) { if (pz->disc->errorf) (*pz->disc->errorf)(pz, pz->disc, 2, "%s: cannot read %I*u prefix record%s from data", pz->path, sizeof(pz->prefix.count), pz->prefix.count, pz->prefix.count == 1 ? "" : "s"); return -1; } } } else if (!sfreserve(pz->io, m, 0)) { if (pz->disc->errorf) (*pz->disc->errorf)(pz, pz->disc, 2, "%s: cannot read %I*u prefix byte%s from data", pz->path, sizeof(pz->prefix.count), pz->prefix.count, pz->prefix.count == 1 ? "" : "s"); return -1; } } if (!(n = pz->row)) { if ((pz->flags & PZ_ACCEPT) || !sfsize(pz->io)) n = 1; else if ((n = pzfixed(pz, pz->io, NiL, 0)) <= 0 && pz->disc->partition) { pz->flags |= PZ_ROWONLY; if (!pzpartition(pz, pz->disc->partition)) n = pz->row; pz->flags &= ~PZ_ROWONLY; } } if (n <= 0) { if (!(pz->flags & PZ_DELAY) && (pz->disc->partition || !(pz->flags & PZ_FORCE))) { if (pz->disc->errorf) (*pz->disc->errorf)(pz, pz->disc, 2, "%s: unknown input format", pz->path); return -1; } pz->flags |= PZ_UNKNOWN; n = 1; } if (!(pp = vmnewof(pz->vm, 0, Pzpart_t, 1, 0))) return -1; pz->major = PZ_MAJOR; pz->minor = PZ_MINOR; pp->name = ""; pp->row = n; return pzpartinit(pz, pp, NiL); } sfread(pz->io, s, 2); pz->flags &= ~PZ_FORCE; pz->major = sfgetc(pz->io); pz->minor = sfgetc(pz->io); switch (pz->major) { case 1: if (pz->minor <= 2) goto noway; break; case 2: pz->win = sfgetu(pz->io); break; default: goto noway; } pz->flags |= PZ_HEAD; return pzpartread(pz); noway: if (pz->disc->errorf) (*pz->disc->errorf)(pz, pz->disc, 2, "%s: data %d.%d not supported by implementation %d.%d", pz->path, pz->major, pz->minor, PZ_MAJOR, PZ_MINOR); return -1; }
int pzinflate(register Pz_t* pz, Sfio_t* op) { register Pzpart_t* pp; register int i; register int j; register int k; register size_t n; register size_t m; register unsigned char* pat; ssize_t r; Pzwrite_f writef; if (!(pz->flags & PZ_READ)) { if (pz->disc->errorf) (*pz->disc->errorf)(pz, pz->disc, ERROR_SYSTEM|2, "%s: cannot inflate -- not open for read", pz->path); return -1; } if (pz->flags & PZ_SPLIT) return pzssplit(pz); if (pz->flags & PZ_FORCE) { if (writef = pz->disc->writef) { n = pz->part->row; do { if (!(pat = (unsigned char*)sfreserve(pz->io, n, 0))) { if (sfvalue(pz->io)) { if (pz->disc->errorf) (*pz->disc->errorf)(pz, pz->disc, 2, "%s: data corrupted", pz->path); return -1; } break; } } while ((r = (*writef)(pz, op, pat, pz->disc)) >= 0); if (r < 0) return -1; } else if (sfmove(pz->io, op, SF_UNBOUND, -1) < 0 || sferror(pz->io)) { if (pz->disc->errorf) (*pz->disc->errorf)(pz, pz->disc, 2, "%s: data corrupted", pz->path); return -1; } if (sfsync(op)) { if (pz->disc->errorf) (*pz->disc->errorf)(pz, pz->disc, 2, "%s: output write error", pz->path); return -1; } return 0; } /* * copy the prefix */ if (pz->prefix.count) { if (!pz->prefix.skip && pz->prefix.data && sfwrite(op, pz->prefix.data, pz->prefix.count) != pz->prefix.count) { if (pz->disc->errorf) (*pz->disc->errorf)(pz, pz->disc, 2, "%s: output write error", pz->path); return -1; } pz->prefix.count = 0; } if ((pz->split.flags & (PZ_SPLIT_INFLATE|PZ_SPLIT_PART)) == PZ_SPLIT_INFLATE) i = pzsinflate(pz, op); else { /* * inflate each file */ do { /* * inflate each window */ pp = pz->part; pat = pz->pat; while (m = sfgetu(pz->io)) { /* * hi frequency data in pz->buf */ if (pp->nmap) { if (m > pz->win || (m % pp->nmap) || sfread(pz->io, pz->buf, m) != m) { if (pz->disc->errorf) (*pz->disc->errorf)(pz, pz->disc, ERROR_SYSTEM|2, "%s: data corrupted", pz->path); return -1; } n = m / pp->nmap; m = 0; j = 0; k = 0; for (i = 0; i < pp->nmap; i++) { if (i > 0 && pp->lab[i] == pp->lab[i - 1]) j++; else j = m; if (!pp->value || pp->value[i] < 0) pp->mix[k++] = pz->buf + j; m += n; } } else if (m != 1) { if (pz->disc->errorf) (*pz->disc->errorf)(pz, pz->disc, ERROR_SYSTEM|2, "%s: data corrupted", pz->path); return -1; } /* * lo frequency */ m = sfgetu(pz->io); if (m < pp->row || sfread(pz->io, pat, pp->row) != pp->row) { if (pz->disc->errorf) (*pz->disc->errorf)(pz, pz->disc, ERROR_SYSTEM|2, "%s: data corrupted", pz->path); return -1; } m -= pp->row; if (sfread(pz->io, pz->nxt = pz->val, m) != m) { if (pz->disc->errorf) (*pz->disc->errorf)(pz, pz->disc, ERROR_SYSTEM|2, "%s: data corrupted", pz->path); return -1; } /* * restore lo+hi on op */ if (restore(pz, pp, pz->io, op, pat, pz->wrk, pp->row, k, pp->map, pp->mix, pp->inc)) return -1; } if (!(pz->flags & PZ_SECTION)) { if ((k = sfgetc(pz->io)) == PZ_MARK_PART) { if ((m = sfgetu(pz->io)) && !sferror(pz->io) && !sfeof(pz->io) && (pat = (unsigned char*)sfreserve(pz->io, m, 0))) sfwrite(op, pat, m); } else if (k != EOF) sfungetc(pz->io, k); } if (sferror(op)) { if (pz->disc->errorf) (*pz->disc->errorf)(pz, pz->disc, ERROR_SYSTEM|2, "write error"); return -1; } } while ((i = !(pz->flags & PZ_SECTION)) && (i = pzfile(pz)) > 0); } if (i >= 0 && !(pz->split.flags & PZ_SPLIT_PART) && sfsync(op)) { if (pz->disc->errorf) (*pz->disc->errorf)(pz, pz->disc, ERROR_SYSTEM|2, "write error"); return -1; } return i; }