ATF_TC_BODY(proccreds, tc)
{
struct lwp *l1, *l2;
rump_init();
RZ(rump_pub_lwproc_rfork(RUMP_RFCFDG));
l1 = rump_pub_lwproc_curlwp();
RZ(rump_pub_lwproc_newlwp(rump_sys_getpid()));
RZ(rump_pub_lwproc_rfork(RUMP_RFCFDG));
l2 = rump_pub_lwproc_curlwp();
RL(rump_sys_setuid(22));
ATF_REQUIRE_EQ(rump_sys_getuid(), 22);
rump_pub_lwproc_switch(l1);
ATF_REQUIRE_EQ(rump_sys_getuid(), 0); /* from parent, proc0 */
RL(rump_sys_setuid(11));
ATF_REQUIRE_EQ(rump_sys_getuid(), 11);
rump_pub_lwproc_switch(l2);
ATF_REQUIRE_EQ(rump_sys_getuid(), 22);
rump_pub_lwproc_newlwp(rump_sys_getpid());
ATF_REQUIRE_EQ(rump_sys_getuid(), 22);
}
ATF_TC_BODY(makecn, tc)
{
struct componentname *cn;
char pathstr[MAXPATHLEN] = TESTFILE;
struct vnode *vp;
extern struct vnode *rumpns_rootvnode;
rump_init();
/*
* Strategy is to create a componentname, edit the passed
* string, and then do a lookup with the componentname.
*/
RL(rump_sys_mkdir("/" TESTFILE, 0777));
/* need stable lwp for componentname */
RZ(rump_pub_lwproc_rfork(RUMP_RFCFDG));
/* try it once with the right path */
cn = rump_pub_makecn(RUMP_NAMEI_LOOKUP, 0, pathstr, strlen(pathstr),
rump_pub_cred_create(0, 0, 0, NULL), rump_pub_lwproc_curlwp());
RZ(RUMP_VOP_LOOKUP(rumpns_rootvnode, &vp, cn));
rump_pub_freecn(cn, RUMPCN_FREECRED);
/* and then with modification-in-the-middle */
cn = rump_pub_makecn(RUMP_NAMEI_LOOKUP, 0, pathstr, strlen(pathstr),
rump_pub_cred_create(0, 0, 0, NULL), rump_pub_lwproc_curlwp());
strcpy(pathstr, "/muuta");
RZ(RUMP_VOP_LOOKUP(rumpns_rootvnode, &vp, cn));
rump_pub_freecn(cn, RUMPCN_FREECRED);
}
ATF_TC_BODY(lwps, tc)
{
struct lwp *l[LOOPS];
pid_t mypid;
struct lwp *l_orig;
int i;
rump_init();
RZ(rump_pub_lwproc_rfork(RUMP_RFCFDG));
mypid = rump_sys_getpid();
RL(rump_sys_setuid(375));
l_orig = rump_pub_lwproc_curlwp();
for (i = 0; i < LOOPS; i++) {
mypid = rump_sys_getpid();
ATF_REQUIRE(mypid != -1 && mypid != 0);
RZ(rump_pub_lwproc_newlwp(mypid));
l[i] = rump_pub_lwproc_curlwp();
ATF_REQUIRE_EQ(rump_sys_getuid(), 375);
}
rump_pub_lwproc_switch(l_orig);
rump_pub_lwproc_releaselwp();
for (i = 0; i < LOOPS; i++) {
rump_pub_lwproc_switch(l[i]);
ATF_REQUIRE_EQ(rump_sys_getpid(), mypid);
ATF_REQUIRE_EQ(rump_sys_getuid(), 375);
rump_pub_lwproc_releaselwp();
ATF_REQUIRE_EQ(rump_sys_getpid(), 1);
ATF_REQUIRE_EQ(rump_sys_getuid(), 0);
}
ATF_REQUIRE_EQ(rump_pub_lwproc_newlwp(mypid), ESRCH);
}
static REPF(jtrepzsx) {
A q,x,y;
I c,d,j,k=-1,m,p=0,*qv,*xv,*yv;
P*ap;
RZ(a&&w);
ap=PAV(a);
x=SPA(ap,x);
m=AN(x);
if(!AN(SPA(ap,a)))R repzdx(ravel(x),w,wf,wcr);
y=SPA(ap,i);
yv=AV(y);
RZ(x=cvt(INT,vec(FL,2*m,AV(x))));
xv=AV(x);
if(equ(zero,SPA(ap,e))) {
k=c=*(wf+AS(w));
if(!wf&&SPARSE&AT(w)) {
A a,y;
I m,n,q,*v;
P*wp;
wp=PAV(w);
a=SPA(wp,a);
if(AN(a)&&!*AV(a)) {
y=SPA(wp,i);
v=AS(y);
m=v[0];
n=v[1];
v=AV(y);
k=m?v[(m-1)*n]+1:0;
q=0;
DO(m, if(q==*v)++q; else if(q<*v) {
k=q;
break;
}
v+=n;);
}
A jtrank1ex(J jt,A w,A fs,I mr,AF f1) {
PROLOG;
A y,y0,yw,z;
B wb;
C*v,*vv;
I k,mn,n=1,p,*s,wcn,wcr,wf,wk,wr,*ws,wt,yn,yr,*ys,yt;
RZ(w);
wt=AT(w);
if(wt&SPARSE)R sprank1(w,fs,mr,f1);
wr=AR(w);
ws=AS(w);
wcr=efr(wr,mr);
wf=wr-wcr;
wb=ARELATIVE(w);
if(!wf)R CALL1(f1,w,fs);
RE(wcn=prod(wcr,wf+ws));
wk=wcn*bp(wt);
v=CAV(w)-wk;
NEWYW;
p=wf;
s=ws;
RE(mn=prod(wf,ws));
if(AN(w))MOVEYW else RZ(yw=reshape(vec(INT,wcr,ws+wf),filler(w)));
#define VALENCE 1
#define TEMPLATE 0
#include "cr_t.h"
}
static F2(jtfitct){D d;V*sv;
RZ(a&&w);
ASSERT(!AR(w),EVRANK);
sv=VAV(a);
RZ(w=cvt(FL,w)); d=*DAV(w); ASSERT(0<=d&&d<5.82076609134675e-11,EVDOMAIN);
R CDERIV(CFIT,jtfitct1,jtfitct2,sv->mr,sv->lr,sv->rr);
}
// General setup for verbs with IRS that do not go through jtirs[12]
// A verb u["n] using this function checks to see whether it has multiple cells; if so,
// it calls here, giving a callback; we split the arguents into cells and call the callback,
// which is often the same original function that called here.
A jtrank2ex(J jt,A a,A w,A fs,I lr,I rr,AF f2){PROLOG(0042);A y,y0,ya,yw,z;B ab,b,wb;
C*u,*uu,*v,*vv;I acn,acr,af,ak,ar,*as,at,k,mn,n=1,p,q,*s,wcn,wcr,wf,wk,wr,*ws,wt,yn,yr,*ys,yt;
RZ(a&&w);
at=AT(a); wt=AT(w);
if(at&SPARSE||wt&SPARSE)R sprank2(a,w,fs,lr,rr,f2);
// ?r=rank, ?s->shape, ?cr=effective rank, ?f=#frame, ?b=relative flag, for each argument
ar=AR(a); as=AS(a); acr=efr(ar,lr); af=ar-acr; ab=ARELATIVE(a);
wr=AR(w); ws=AS(w); wcr=efr(wr,rr); wf=wr-wcr; wb=ARELATIVE(w);
if(!af&&!wf)R CALL2(f2,a,w,fs); // if there's only one cell, run on it, that's the result
// multiple cells. Loop through them.
// ?cn=number of atoms in a cell, ?k=#bytes in a cell, uv point to one cell before aw data
// Allocate y? to hold one cell of ?, with uu,vv pointing to the data of y?
RE(acn=prod(acr,as+af)); ak=acn*bp(at); u=CAV(a)-ak; NEWYA;
RE(wcn=prod(wcr,ws+wf)); wk=wcn*bp(wt); v=CAV(w)-wk; NEWYW;
// b means 'w frame is larger'; p=#larger frame; q=#shorter frame; s->larger frame
// mn=#cells in larger frame (& therefore #cells in result); n=# times to repeat each cell
// from shorter-frame argument
b=af<=wf; p=b?wf:af; q=b?af:wf; s=b?ws:as; RE(mn=prod(p,s)); RE(n=prod(p-q,s+q));
ASSERT(!ICMP(as,ws,q),EVLENGTH); // error if frames are not same as prefix
// Initialize y? to hold data for the first cell; but if ? is empty, set y? to a cell of fills
if(AN(a))MOVEYA else RZ(ya=reshape(vec(INT,acr,as+af),filler(a)));
if(AN(w))MOVEYW else RZ(yw=reshape(vec(INT,wcr,ws+wf),filler(w)));
#define VALENCE 2
#define TEMPLATE 0
#include "cr_t.h"
}
ATF_TC_BODY(key, tc)
{
RZ(rump_init());
RL(open("hostfile", O_RDWR | O_CREAT, 0777));
RZ(rump_pub_etfs_register("/key", "hostfile", RUMP_ETFS_REG));
ATF_REQUIRE_EQ(rump_pub_etfs_register("key", "hostfile", RUMP_ETFS_REG),
EINVAL);
RL(rump_sys_open("/key", O_RDONLY));
RL(rump_sys_open("////////key", O_RDONLY));
RZ(rump_pub_etfs_register("////key//with/slashes", "hostfile",
RUMP_ETFS_REG));
RL(rump_sys_open("/key//with/slashes", O_RDONLY));
RL(rump_sys_open("key//with/slashes", O_RDONLY));
ATF_REQUIRE_ERRNO(ENOENT,
rump_sys_open("/key/with/slashes", O_RDONLY) == -1);
RL(rump_sys_mkdir("/a", 0777));
ATF_REQUIRE_ERRNO(ENOENT,
rump_sys_open("/a/key//with/slashes", O_RDONLY) == -1);
}
static REPF(jtrepzdx){A p,q,x;P*wp;
RZ(a&&w);
if(SPARSE&AT(w)){wp=PAV(w); x=SPA(wp,e);}
else x=jt->fill&&AN(jt->fill)?jt->fill:filler(w);
RZ(p=repeat(ravel(rect(a)),ravel(stitch(IX(wcr?*(wf+AS(w)):1),num[-1]))));
RZ(q=irs2(w,x,0L,wcr,0L,jtover));
R irs2(p,q,0L,1L,wcr+!wcr,jtfrom);
} /* (dense complex) # (dense or sparse) */
static A jtcants(J jt,A a,A w,A z){A a1,q,y;B*b,*c;I*u,wr,zr;P*wp,*zp;
RZ(a&&w&&z);
RZ(a=grade1(a));
wr=AR(w); wp=PAV(w); a1=SPA(wp,a);
zr=AR(z); zp=PAV(z);
ASSERT(wr==zr,EVNONCE);
RZ(b=bfi(wr,a1,1));
GA(q,B01,wr,1,0); c=BAV(q); u=AV(a); DO(wr, c[i]=b[u[i]];);
static A jtvaspc(J jt,A a,A w,C id,VF ado,I cv,I t,I zt,I af,I acr,I wf,I wcr,I f,I r){A q;I*as,*v,*ws;
as=AS(a);
ws=AS(w);
GA(q,INT,f+r,1,0); v=AV(q);
if(r>acr){ICPY(v,wf+ws,r); RZ(a=irs2(vec(INT,r-acr,acr+v),a,0L,1L,0L,jtreshape));}
if(r>wcr){ICPY(v,af+as,r); RZ(w=irs2(vec(INT,r-wcr,wcr+v),w,0L,1L,0L,jtreshape));}
R vasp(a,w,id,ado,cv,t,zt,af,r,wf,r,f,r);
} /* prefix agreement on cells */
A jtfxeachv(J jt,I r,A w){A*wv,x,z,*zv;I n,wd;
RZ(w);
n=AN(w); wv=AAV(w); wd=(I)w*ARELATIVE(w);
ASSERT(r>=AR(w),EVRANK);
ASSERT(n,EVLENGTH);
ASSERT(BOX&AT(w),EVDOMAIN);
GA(z,BOX,n,AR(w),AS(w)); zv=AAV(z);
DO(n, RZ(zv[i]=x=fx(WVR(i))); ASSERT(VERB&AT(x),EVDOMAIN););
static DF1(jtgsuffix){A h,*hv,z,*zv;I m,n,r;
RZ(w);
if(jt->rank&&jt->rank[1]<AR(w)){r=jt->rank[1]; jt->rank=0; R rank1ex(w,self,jt->rank[1],jtgsuffix);}
jt->rank=0;
n=IC(w);
h=VAV(self)->h; hv=AAV(h); m=AN(h);
GATV(z,BOX,n,1,0); zv=AAV(z);
DO(n, RZ(zv[i]=df1(drop(sc(i),w),hv[i%m])););
static F1(jtnvrpush){
if(jt->nvrtop==AN(jt->nvra)){
RZ(jt->nvra=ext(1,jt->nvra)); jt->nvrav=AAV(jt->nvra);
while(AN(jt->nvrb)<AN(jt->nvra))RZ(jt->nvrb=ext(1,jt->nvrb)); jt->nvrbv=BAV(jt->nvrb);
}
jt->nvrav[jt->nvrtop]=w;
jt->nvrbv[jt->nvrtop]=1;
++jt->nvrtop;
R w;
}
static DF1(insert){PROLOG;A hs,*hv,z;I hn,j,k,m,n;
RZ(w);
m=IC(w); hs=VAV(self)->h; hn=AN(hs); hv=AAV(hs);
if(!m)R df1(w,iden(*hv));
j=n=MAX(hn,m-1);
RZ(z=AR(w)?from(sc(n%m),w):ca(w));
if(1==n)R z;
DO(n, --j; k=j%hn; RZ(z=(VAV(hv[k])->f2)(from(sc(j%m),w),z,hv[k])));
EPILOG(z);
}
F1(bool){A b,h;I j,*v;
RZ(w);
if(VERB&AT(w))R ADERIV(CBOOL, basis1,0L, 0L,0L,0L);
RZ(w=vi(w));
v=AV(w);
DO(AN(w), j=*v++; ASSERT(-16<=j&&j<16,EVINDEX));
GA(b,BOOL,64,2,0); *AS(b)=16; *(1+AS(b))=4; MC(AV(b),booltab,64L);
RZ(h=cant2(apv(AR(w),0L,1L),from(w,b)));
R fdef(CBOOL,VERB, bool1,bool2, w,0L,h, 0L, RMAXL,0L,0L);
}
static DF1(reduce){PROLOG;DECLF;A y,z;C*u,*v;I c,k,m,old,t;
RZ(w);
m=IC(w);
if(!m)R df1(w,iden(fs));
RZ(z=tail(w));
if(1==m)R z;
t=AT(w); c=AN(z);
GA(y,t,c,AR(z),AS(z)); u=CAV(y); k=SZT(t,c); v=CAV(w)+k*(m-1);
old=tbase+ttop;
DO(m-1, MC(u,v-=k,k); RZ(z=f2(y,z,fs)); gc(z,old));
EPILOG(z);
}
static DF1(jtpowseqlim){PROLOG(0039);A x,y,z,*zv;I i,n;
RZ(w);
RZ(z=exta(BOX,1L,1L,20L)); zv=AAV(z); *zv++=x=w;
i=1; n=AN(z);
while(1){
if(n==i){RZ(z=ext(0,z)); zv=i+AAV(z); n=AN(z);}
RZ(*zv++=x=df1(y=x,self));
if(equ(x,y)){AN(z)=*AS(z)=i; break;}
++i;
}
z=ope(z);
EPILOG(z);
} /* f^:(<_) w */
static F2(jtpdtby){A z;B b,*u,*v,*wv;C er=0;I at,m,n,p,t,wt,zk;
at=AT(a); wt=AT(w); t=at&B01?wt:at;
RZ(z=ipprep(a,w,t,&m,&n,&p)); zk=n*bp(t); u=BAV(a); v=wv=BAV(w);
NAN0;
switch(t){
default: ASSERT(0,EVDOMAIN);
case CMPX: if(at&B01)PDTBY(Z,Z,ZINC) else PDTXB(Z,Z,ZINC,c=*u++ ); break;
case FL: if(at&B01)PDTBY(D,D,DINC) else PDTXB(D,D,DINC,c=*u++ ); break;
case INT: if(at&B01)PDTBY(I,I,IINC) else PDTXB(I,I,IINC,c=*u++ );
if(er==EWOV){
RZ(z=ipprep(a,w,FL,&m,&n,&p)); zk=n*sizeof(D); u=BAV(a); v=wv=BAV(w);
if(at&B01)PDTBY(D,I,IINC) else PDTXB(D,I,IINC,c=(D)*u++);
}}
static NUMH(jtnumj){C*t,*ta;D x,y;Z*v;
v=(Z*)vv;
if(t=memchr(s,'j',n))ta=0; else t=ta=memchr(s,'a',n);
RZ(numd(t?t-s:n,s,&x));
if(t){t+=ta?2:1; RZ(numd(n+s-t,t,&y));} else y=0;
if(ta){C c;
c=*(1+ta);
RZ(0<=x&&(c=='d'||c=='r'));
if(c=='d')y*=PI/180; if(y<=-P2||P2<=y)y-=P2*jfloor(y/P2); if(0>y)y+=P2;
v->re=y==0.5*PI||y==1.5*PI?0:x*cos(y); v->im=y==PI?0:x*sin(y);
}else{v->re=x; v->im=y;}
R 1;
}
ATF_TC_BODY(rfork, tc)
{
struct stat sb;
struct lwp *l, *l2;
int fd;
RZ(rump_init());
ATF_REQUIRE_EQ(rump_pub_lwproc_rfork(RUMP_RFFDG|RUMP_RFCFDG), EINVAL);
RZ(rump_pub_lwproc_rfork(0));
l = rump_pub_lwproc_curlwp();
RL(fd = rump_sys_open("/file", O_RDWR | O_CREAT, 0777));
/* ok, first check rfork(RUMP_RFCFDG) does *not* preserve fd's */
RZ(rump_pub_lwproc_rfork(RUMP_RFCFDG));
ATF_REQUIRE_ERRNO(EBADF, rump_sys_write(fd, &fd, sizeof(fd)) == -1);
/* then check that rfork(0) does */
rump_pub_lwproc_switch(l);
RZ(rump_pub_lwproc_rfork(0));
ATF_REQUIRE_EQ(rump_sys_write(fd, &fd, sizeof(fd)), sizeof(fd));
RL(rump_sys_fstat(fd, &sb));
l2 = rump_pub_lwproc_curlwp();
/*
* check that the shared fd table is really shared by
* closing fd in parent
*/
rump_pub_lwproc_switch(l);
RL(rump_sys_close(fd));
rump_pub_lwproc_switch(l2);
ATF_REQUIRE_ERRNO(EBADF, rump_sys_fstat(fd, &sb) == -1);
/* redo, this time copying the fd table instead of sharing it */
rump_pub_lwproc_releaselwp();
rump_pub_lwproc_switch(l);
RL(fd = rump_sys_open("/file", O_RDWR, 0777));
RZ(rump_pub_lwproc_rfork(RUMP_RFFDG));
ATF_REQUIRE_EQ(rump_sys_write(fd, &fd, sizeof(fd)), sizeof(fd));
RL(rump_sys_fstat(fd, &sb));
l2 = rump_pub_lwproc_curlwp();
/* check that the fd table is copied */
rump_pub_lwproc_switch(l);
RL(rump_sys_close(fd));
rump_pub_lwproc_switch(l2);
RL(rump_sys_fstat(fd, &sb));
ATF_REQUIRE_EQ(sb.st_size, sizeof(fd));
}
AF jtatcompf(J jt,A a,A w,A self){AF f;I ar,at,m,wr,wt;
RZ(a&&w);
at=AT(a); ar=AR(a);
wt=AT(w); wr=AR(w);
m=VAV(self)->flag%256;
if(1<ar||1<wr){if(32<=m&&m<=37||40<=m&&m<=45||48<=m&&m<=53)R(AF)jtfslashatg; RZ(7==m%8);}
ASSERT(AN(a)==AN(w)||!ar||!wr||5<m%8,EVLENGTH);
f=atcompX[m];
if(!f){
if(at&B01+INT+FL&&wt&B01+INT+FL)f=atcompxy[9*m+3*(at&B01?0:at&INT?1:2)+(wt&B01?0:wt&INT?1:2)];
else if(at&LIT&&wt&LIT) f=atcompC[m];
else if(at&SBT&&wt&SBT) f=atcompSB[m];
}
R f;
} /* function table look-up for comp i. 1: and i.&1@:comp etc. */
ATF_TC_BODY(bigenough, tc)
{
struct stat sb;
RZ(system("rump_server " RUMPSERV));
RL(setenv("RUMP_SERVER", RUMPSERV, 1));
RL(dup2(0, 10));
RL(dup2(1, 11));
RL(dup2(2, 12));
RL(close(0));
RL(close(1));
RL(close(2));
RL(rumpclient_init());
RL(rump_sys_getpid());
ATF_REQUIRE_ERRNO(EBADF, fstat(0, &sb) == -1);
ATF_REQUIRE_ERRNO(EBADF, fstat(1, &sb) == -1);
ATF_REQUIRE_ERRNO(EBADF, fstat(2, &sb) == -1);
RL(rump_sys_getpid());
/* restore these. does it help? */
dup2(10, 0);
dup2(11, 1);
dup2(12, 2);
}
static F2(jtpdtspmv){A ax,b,g,x,wx,y,yi,yj,z;B*bv;I m,n,s[2],*u,*v,*yv;P*ap,*wp,*zp;
RZ(a&&w);
ap=PAV(a); y=SPA(ap,i); yv=AV(y); s[0]=n=*AS(y); s[1]=1;
GATV(yj,INT,n,2,s);
if(DENSE&AT(w)){
GATV(yi,INT,n,2,s); u=AV(yi); AR(yj)=1; v=AV(yj);
DO(n, *u++=*yv++; *v++=*yv++;);
static DF1(case1){A u;V*sv;
PREF1(case1);
sv=VAV(self);
RZ(u=from(df1(w,sv->g),sv->h));
ASSERT(!AR(u),EVRANK);
R df1(w,*AV(u));
}
static DF2(case2){A u;V*sv;
PREF2(case2);
sv=VAV(self);
RZ(u=from(df2(a,w,sv->g),sv->h));
ASSERT(!AR(u),EVRANK);
R df2(a,w,*AV(u));
}
static A jtmerge1(J jt,A w,A ind){A z;B*b;C*wc,*zc;D*wd,*zd;I c,it,j,k,m,r,*s,t,*u,*wi,*zi;
RZ(w&&ind);
r=MAX(0,AR(w)-1); s=1+AS(w); t=AT(w); k=bp(t); m=IC(w); c=aii(w);
ASSERT(!(t&SPARSE),EVNONCE);
ASSERT(r==AR(ind),EVRANK);
ASSERT(!ICMP(s,AS(ind),r),EVLENGTH);
GA(z,t,c,r,s);
if(!(AT(ind)&B01+INT))RZ(ind=cvt(INT,ind));
it=AT(ind); u=AV(ind); b=(B*)u;
ASSERT(!c||1<m||!(it&B01),EVINDEX);
ASSERT(!c||1!=m||!memchr(b,C1,c),EVINDEX);
zi=AV(z); zc=(C*)zi; zd=(D*)zc;
wi=AV(w); wc=(C*)wi; wd=(D*)wc;
switch(MCASE(it,k)){
case MCASE(B01,sizeof(C)): DO(c, *zc++=wc[*b++?i+c:i];); break;
case MCASE(B01,sizeof(I)): DO(c, *zi++=wi[*b++?i+c:i];); break;
static DF2(jtfolkcomp0){F2PREFIP;DECLFGH;PROLOG(0035);A z;AF f;D oldct=jt->ct;
RZ(a&&w);
jt->ct=0;
if(f=atcompf(a,w,self))z=f(jt,a,w,self); else if(cap(fs))CAP2 else FOLK2;
jt->ct=oldct;
EPILOG(z);
}
static I jtcongoto(J jt,I n,CW*con,A*lv){A x,z;C*s;CW*d=con,*e;I i,j,k,m;
RZ(z=congotoblk(n,con));
for(i=0;i<n;++i,++d)
if(CGOTO==d->type){
x=lv[d->i]; s=5+CAV(x); m=0; while('.'!=s[m])++m; ++m;
e=con-1; j=-1;
DO(n, ++e; if(LABELEQU(m,s,e)){j=1+i; d->go=(US)j; break;});
static F1(jtvtokens){A t,*y,z;I n,*s;TA*x;
RZ(t=tokens(vs(w))); n=AN(t); y=AAV(t);
jt->tmonad=1;
GA(z,BOX,WTA*(5+n),2,0); s=AS(z); *s++=5+n; *s=WTA;
x=(TA*)AV(z);
x->a=mark; x->t=0; ++x;
DO(n, x->a=t=*y++; x->t=0; ++x; if(t==xnam||jt->dotnames&&t==xdot)jt->tmonad=0;);
