void
cmd_create(void)
{
int uid, gid, err;
int32_t perm;
char oelem[NAMELEN];
char name[NAMELEN];
if(err = con_clone(FID1, FID2)){
cprint("clone failed: %s\n", errstring[err]);
return;
}
if(skipbl(1)){
cprint("skipbl\n");
return;
}
oelem[0] = 0;
while(nextelem()) {
if(oelem[0])
if(err = con_walk(FID2, oelem)){
cprint("walk failed: %s\n", errstring[err]);
return;
}
memmove(oelem, elem, NAMELEN);
}
if(skipbl(1))
return;
uid = strtouid(cname(name));
if(uid == 0){
cprint("unknown user %s\n", name);
return;
}
gid = strtouid(cname(name));
if(gid == 0){
cprint("unknown group %s\n", name);
return;
}
perm = number(0777, 8);
skipbl(0);
for(; *cons.arg; cons.arg++){
if(*cons.arg == 'l')
perm |= PLOCK;
else
if(*cons.arg == 'a')
perm |= PAPND;
else
if(*cons.arg == 'd')
perm |= PDIR;
else
break;
}
err = con_create(FID2, elem, uid, gid, perm, 0);
if(err)
cprint("can't create %s: %s\n", elem, errstring[err]);
}
char*
skipstr(char *s, char *t)
{
while(*s && *s==*t)
s++, t++;
return skipbl(s);
}
String *
collecttext(void)
{
String *s = newstring();
int begline, i, c, delim;
if(skipbl()=='\n'){
getch();
i = 0;
do{
begline = i;
while((c = getch())>0 && c!='\n')
i++, Straddc(s, c);
i++, Straddc(s, '\n');
if(c < 0)
goto Return;
}while(s->s[begline]!='.' || s->s[begline+1]!='\n');
Strdelete(s, s->n-2, s->n);
}else{
okdelim(delim = getch());
getrhs(s, delim, 'a');
if(nextc()==delim)
getch();
atnl();
}
Return:
Straddc(s, 0); /* JUST FOR CMDPRINT() */
return s;
}
void
atnl(void)
{
skipbl();
if(getch() != '\n')
error(Enewline);
}
void
cmd_cfs(void)
{
Filsys *fs;
if(*cons.arg != ' ') {
fs = &filesys[0]; /* default */
} else {
if(skipbl(1)){
cprint("skipbl\n");
return;
}
if(!nextelem())
fs = &filesys[0]; /* default */
else
fs = fsstr(elem);
}
if(fs == 0) {
cprint("unknown file system %s\n", elem);
return;
}
if(con_attach(FID1, "adm", fs->name))
panic("FID1 attach to root");
cur_fs = fs;
}
yylex() {
static int ifdef=0;
static char *op2[]={"||", "&&" , ">>", "<<", ">=", "<=", "!=", "=="};
static int val2[]={OROR, ANDAND, RS, LS, GE, LE, NE, EQ};
static char *opc="b\bt\tn\nf\fr\r\\\\";
extern char fastab[];
extern char *outp,*inp,*newp; extern int flslvl;
register char savc, *s; char *skipbl(); int val;
register char **p2;
struct symtab {
char *name;
char *value;
} *sp, *lookup();
for (;;) {
extern int passcom; /* this crap makes #if's work */
int opt_passcom = passcom; /* even with -C option */
passcom = 0; /* (else comments make syntax errs) */
newp=skipbl(newp);
passcom = opt_passcom; /* nb: lint uses -C so its useful! */
if (*inp=='\n') return(stop); /* end of #if */
savc= *newp; *newp='\0';
for (p2=op2+8; --p2>=op2; ) /* check 2-char ops */
if (0==strcmp(*p2,inp)) {val=val2[p2-op2]; goto ret;}
s="+-*/%<>&^|?:!~(),"; /* check 1-char ops */
while (*s) if (*s++== *inp) {val= *--s; goto ret;}
if (*inp<='9' && *inp>='0') {/* a number */
if (*inp=='0') yylval= (inp[1]=='x' || inp[1]=='X') ?
tobinary(inp+2,16) : tobinary(inp+1,8);
else yylval=tobinary(inp,10);
val=number;
} else if (isid(*inp)) {
if (0==strcmp(inp,"defined")) {ifdef=1; ++flslvl; val=DEFINED;}
else {
sp=lookup(inp,-1); if (ifdef!=0) {ifdef=0; --flslvl;}
yylval= (sp->value==0) ? 0 : 1;
val=number;
}
} else if (*inp=='\'') {/* character constant */
val=number;
if (inp[1]=='\\') {/* escaped */
char c; if (newp[-1]=='\'') newp[-1]='\0';
s=opc;
while (*s) if (*s++!=inp[2]) ++s; else {yylval= *s; goto ret;}
if (inp[2]<='9' && inp[2]>='0') yylval=c=tobinary(inp+2,8);
else yylval=inp[2];
} else yylval=inp[1];
} else if (0==strcmp("\\\n",inp)) {*newp=savc; continue;}
else {
*newp=savc; pperror("Illegal character %c in preprocessor if", *inp);
continue;
}
ret:
*newp=savc; outp=inp=newp; return(val);
}
}
/*
* comma-separate possibly blank-separated strings in line; e points before newline
*/
void
commas(char *s, char *e)
{
char *t;
/* may have initial blanks */
s = skipbl(s, e);
while(s < e){
s = findbl(s, e);
if(s == e)
break;
t = skipbl(s, e);
if(t == e) /* no more words */
break;
/* patch comma */
*s++ = ',';
while(s < t)
*s++ = ' ';
}
}
void
cmd_remove(void)
{
if(con_clone(FID1, FID2))
return;
if(skipbl(1))
return;
while(nextelem())
if(con_walk(FID2, elem)){
cprint("can't walk %s\n", elem);
return;
}
con_remove(FID2);
}
void
cmd_listen(void)
{
char addr[NAMELEN];
if(skipbl(0))
strcpy(addr, "tcp!*!564"); /* 9fs */
else
cname(addr);
if(netserve(addr))
cprint("announce %s failed\n", addr);
else
cprint("announce %s\n", addr);
}
Addr *
compoundaddr(void)
{
Addr addr;
Addr *ap, *next;
addr.left = simpleaddr();
if((addr.type = skipbl())!=',' && addr.type!=';')
return addr.left;
getch();
next = addr.next = compoundaddr();
if(next && (next->type==',' || next->type==';') && next->left==0)
error(Eaddress);
ap = newaddr();
*ap = addr;
return ap;
}
void
adbcmds(void)
{
char cmd;
unsigned rtcu, rtcl, dec, pdec, x;
int i, j;
unsigned char d[64];
cmd = skipbl();
switch (cmd) {
case 't':
for (;;) {
rtcl = get_rtcl();
rtcu = get_rtcu();
dec = get_dec();
printf("rtc u=%u l=%u dec=%x (%d = %d.%.7d)\n",
rtcu, rtcl, dec, pdec - dec, (pdec - dec) / 1000000000,
((pdec - dec) % 1000000000) / 100);
pdec = dec;
if (cmd == 'x')
break;
while (xmon_read(stdin, &cmd, 1) != 1)
;
}
break;
case 'r':
init_adb_log();
while (adb_bitwait(8, 0, 0, 0) == 0)
adb_readin();
break;
case 'w':
i = 0;
while (scanhex(&x))
d[i++] = x;
init_adb_log();
j = adb_write(d, i);
printf("sent %d bytes\n", j);
while (adb_bitwait(8, 0, 0, 0) == 0)
adb_readin();
break;
case 'l':
dump_adb_log();
break;
}
}
Addr *
simpleaddr(void)
{
Addr addr;
Addr *ap, *nap;
addr.next = 0;
addr.left = 0;
switch(skipbl()){
case '#':
addr.type = getch();
addr.num = getnum(1);
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
addr.num = getnum(1);
addr.type='l';
break;
case '/': case '?': case '"':
addr.are = getregexp(addr.type = getch());
break;
case '.':
case '$':
case '+':
case '-':
case '\'':
addr.type = getch();
break;
default:
return 0;
}
if(addr.next = simpleaddr())
switch(addr.next->type){
case '.':
case '$':
case '\'':
if(addr.type!='"')
case '"':
error(Eaddress);
break;
case 'l':
case '#':
if(addr.type=='"')
break;
/* fall through */
case '/':
case '?':
if(addr.type!='+' && addr.type!='-'){
/* insert the missing '+' */
nap = newaddr();
nap->type='+';
nap->next = addr.next;
addr.next = nap;
}
break;
case '+':
case '-':
break;
default:
panic("simpleaddr");
}
ap = newaddr();
*ap = addr;
return ap;
}
Cmd *
parsecmd(int nest)
{
int i, c;
Cmdtab *ct;
Cmd *cp, *ncp;
Cmd cmd;
cmd.next = cmd.ccmd = 0;
cmd.re = 0;
cmd.flag = cmd.num = 0;
cmd.addr = compoundaddr();
if(skipbl() == -1)
return 0;
if((c=getch())==-1)
return 0;
cmd.cmdc = c;
if(cmd.cmdc=='c' && nextc()=='d'){ /* sleazy two-character case */
getch(); /* the 'd' */
cmd.cmdc='c'|0x100;
}
i = lookup(cmd.cmdc);
if(i >= 0){
if(cmd.cmdc == '\n')
goto Return; /* let nl_cmd work it all out */
ct = &cmdtab[i];
if(ct->defaddr==aNo && cmd.addr)
error(Enoaddr);
if(ct->count)
cmd.num = getnum(ct->count);
if(ct->regexp){
/* x without pattern -> .*\n, indicated by cmd.re==0 */
/* X without pattern is all files */
if((ct->cmdc!='x' && ct->cmdc!='X') ||
((c = nextc())!=' ' && c!='\t' && c!='\n')){
skipbl();
if((c = getch())=='\n' || c<0)
error(Enopattern);
okdelim(c);
cmd.re = getregexp(c);
if(ct->cmdc == 's'){
cmd.ctext = newstring();
getrhs(cmd.ctext, c, 's');
if(nextc() == c){
getch();
if(nextc() == 'g')
cmd.flag = getch();
}
}
}
}
if(ct->addr && (cmd.caddr=simpleaddr())==0)
error(Eaddress);
if(ct->defcmd){
if(skipbl() == '\n'){
getch();
cmd.ccmd = newcmd();
cmd.ccmd->cmdc = ct->defcmd;
}else if((cmd.ccmd = parsecmd(nest))==0)
panic("defcmd");
}else if(ct->text)
cmd.ctext = collecttext();
else if(ct->token)
cmd.ctext = collecttoken(ct->token);
else
atnl();
}else
switch(cmd.cmdc){
case '{':
cp = 0;
do{
if(skipbl()=='\n')
getch();
ncp = parsecmd(nest+1);
if(cp)
cp->next = ncp;
else
cmd.ccmd = ncp;
}while(cp = ncp);
break;
case '}':
atnl();
if(nest==0)
error(Enolbrace);
return 0;
default:
error_c(Eunk, cmd.cmdc);
}
Return:
cp = newcmd();
*cp = cmd;
return cp;
}
char*
cname(char *name)
{
skipbl(0);
return _cname(name);
}
void
cmd_rename(void)
{
uint32_t perm;
Dentry d;
char stat[DIRREC];
char oelem[NAMELEN], noelem[NAMELEN], nxelem[NAMELEN];
int err;
if(con_clone(FID1, FID2))
return;
if(skipbl(1))
return;
oelem[0] = 0;
while(nextelem()) {
if(oelem[0])
if(con_walk(FID2, oelem)){
cprint("file does not exits");
return;
}
memmove(oelem, elem, NAMELEN);
}
if(skipbl(1))
return;
if(cons.arg[0]=='/'){
if(con_clone(FID1, FID3))
return;
noelem[0] = 0;
while(nextelem()){
if(noelem[0])
if(con_walk(FID3, noelem)){
cprint("target path %s does not exist", noelem);
return;
}
memmove(noelem, elem, NAMELEN);
}
if(!con_walk(FID3, elem)){
cprint("target %s already exists\n", elem);
return;
}
if(con_walk(FID2, oelem)){
cprint("src %s does not exist\n", oelem);
return;
}
/*
* we know the target does not exist,
* the source does exist.
* to do the rename, create the target and then
* copy the directory entry directly. then remove the source.
*/
if(err = con_stat(FID2, stat)){
cprint("can't stat file: %s\n", errstring[err]);
return;
}
convM2D9p1(stat, &d);
perm = (d.mode&0777)|((d.mode&0x7000)<<17);
if(err = con_create(FID3, elem, d.uid, d.gid, perm, (d.mode&DDIR)?OREAD:ORDWR)){
cprint("can't create %s: %s\n", elem, errstring[err]);
return;
}
if(err = con_swap(FID2, FID3)){
cprint("can't swap data: %s\n", errstring[err]);
return;
}
if(err = con_remove(FID2)){
cprint("can't remove file: %s\n", errstring[err]);
return;
}
}else{
cname(nxelem);
if(strchr(nxelem, '/')){
cprint("bad rename target: not full path, but contains slashes\n");
return;
}
if(!con_walk(FID2, nxelem))
cprint("file %s already exists\n", nxelem);
else if(con_walk(FID2, oelem))
cprint("file does not already exist\n");
else if(err = con_stat(FID2, stat))
cprint("can't stat file: %s\n", errstring[err]);
else{
convM2D9p1(stat, &d);
strncpy(d.name, nxelem, NAMELEN);
convD2M9p1(&d, stat);
if(err = con_wstat(FID2, stat))
cprint("can't move file: %s\n", errstring[err]);
}
}
}
void
plot(char *flags)
{
int i, j, k;
char *t;
int32_t x, y;
int ra, dec;
int m;
Point p, pts[10];
Record *r;
Rectangle rect, r1;
int dx, dy, nogrid, textlevel, nogrey, zenithup;
Image *scr;
char *name, buf[32];
double v;
if(plotopen() < 0)
return;
nogrid = 0;
nogrey = 0;
textlevel = 1;
dx = 512;
dy = 512;
zenithup = 0;
for(;;){
if(t = alpha(flags, "nogrid")){
nogrid = 1;
flags = t;
continue;
}
if((t = alpha(flags, "zenith")) || (t = alpha(flags, "zenithup")) ){
zenithup = 1;
flags = t;
continue;
}
if((t = alpha(flags, "notext")) || (t = alpha(flags, "nolabel")) ){
textlevel = 0;
flags = t;
continue;
}
if((t = alpha(flags, "alltext")) || (t = alpha(flags, "alllabel")) ){
textlevel = 2;
flags = t;
continue;
}
if(t = alpha(flags, "dx")){
dx = strtol(t, &t, 0);
if(dx < 100){
fprint(2, "dx %d too small (min 100) in plot\n", dx);
return;
}
flags = skipbl(t);
continue;
}
if(t = alpha(flags, "dy")){
dy = strtol(t, &t, 0);
if(dy < 100){
fprint(2, "dy %d too small (min 100) in plot\n", dy);
return;
}
flags = skipbl(t);
continue;
}
if((t = alpha(flags, "nogrey")) || (t = alpha(flags, "nogray"))){
nogrey = 1;
flags = skipbl(t);
continue;
}
if(*flags){
fprint(2, "syntax error in plot\n");
return;
}
break;
}
flatten();
folded = 0;
if(bbox(0, 0, 1) < 0)
return;
if(ramax-ramin<100 || decmax-decmin<100){
fprint(2, "plot too small\n");
return;
}
scr = allocimage(display, Rect(0, 0, dx, dy), RGB24, 0, DBlack);
if(scr == nil){
fprint(2, "can't allocate image: %r\n");
return;
}
rect = scr->r;
rect.min.x += 16;
rect = insetrect(rect, 40);
if(setmap(ramin, ramax, decmin, decmax, rect, zenithup) < 0){
fprint(2, "can't set up map coordinates\n");
return;
}
if(!nogrid){
for(x=ramin; ; ){
for(j=0; j<nelem(pts); j++){
/* use double to avoid overflow */
v = (double)j / (double)(nelem(pts)-1);
v = decmin + v*(decmax-decmin);
pts[j] = map(x, v);
}
bezspline(scr, pts, nelem(pts), Endsquare, Endsquare, 0, GREY, ZP);
ra = x;
if(folded){
ra -= 180*c;
if(ra < 0)
ra += 360*c;
}
p = pts[0];
p.x -= stringwidth(font, hm5(angle(ra)))/2;
string(scr, p, GREY, ZP, font, hm5(angle(ra)));
p = pts[nelem(pts)-1];
p.x -= stringwidth(font, hm5(angle(ra)))/2;
p.y -= font->height;
string(scr, p, GREY, ZP, font, hm5(angle(ra)));
if(x == ramax)
break;
x += gridra(mapdec);
if(x > ramax)
x = ramax;
}
for(y=decmin; y<=decmax; y+=c){
for(j=0; j<nelem(pts); j++){
/* use double to avoid overflow */
v = (double)j / (double)(nelem(pts)-1);
v = ramin + v*(ramax-ramin);
pts[j] = map(v, y);
}
bezspline(scr, pts, nelem(pts), Endsquare, Endsquare, 0, GREY, ZP);
p = pts[0];
p.x += 3;
p.y -= font->height/2;
string(scr, p, GREY, ZP, font, deg(angle(y)));
p = pts[nelem(pts)-1];
p.x -= 3+stringwidth(font, deg(angle(y)));
p.y -= font->height/2;
string(scr, p, GREY, ZP, font, deg(angle(y)));
}
}
/* reorder to get planets in front of stars */
tolast(nil);
tolast("moon"); /* moon is in front of everything... */
tolast("shadow"); /* ... except the shadow */
for(i=0,r=rec; i<nrec; i++,r++){
dec = r->ngc.dec;
ra = r->ngc.ra;
if(folded){
ra -= 180*c;
if(ra < 0)
ra += 360*c;
}
if(textlevel){
name = nameof(r);
if(name==nil && textlevel>1 && r->type==SAO){
snprint(buf, sizeof buf, "SAO%ld", r->index);
name = buf;
}
if(name)
drawname(scr, nogrey? display->white : alphagrey, name, ra, dec);
}
if(r->type == Planet){
drawplanet(scr, &r->planet, map(ra, dec));
continue;
}
if(r->type == SAO){
m = r->sao.mag;
if(m == UNKNOWNMAG)
m = r->sao.mpg;
if(m == UNKNOWNMAG)
continue;
m = dsize(m);
if(m < 3)
fillellipse(scr, map(ra, dec), m, m, nogrey? display->white : lightgrey, ZP);
else{
ellipse(scr, map(ra, dec), m+1, m+1, 0, display->black, ZP);
fillellipse(scr, map(ra, dec), m, m, display->white, ZP);
}
continue;
}
if(r->type == Abell){
ellipse(scr, addpt(map(ra, dec), Pt(-3, 2)), 2, 1, 0, lightblue, ZP);
ellipse(scr, addpt(map(ra, dec), Pt(3, 2)), 2, 1, 0, lightblue, ZP);
ellipse(scr, addpt(map(ra, dec), Pt(0, -2)), 1, 2, 0, lightblue, ZP);
continue;
}
switch(r->ngc.type){
case Galaxy:
j = npixels(r->ngc.diam);
if(j < 4)
j = 4;
if(j > 10)
k = j/3;
else
k = j/2;
ellipse(scr, map(ra, dec), j, k, 0, lightblue, ZP);
break;
case PlanetaryN:
p = map(ra, dec);
j = npixels(r->ngc.diam);
if(j < 3)
j = 3;
ellipse(scr, p, j, j, 0, green, ZP);
line(scr, Pt(p.x, p.y+j+1), Pt(p.x, p.y+j+4),
Endsquare, Endsquare, 0, green, ZP);
line(scr, Pt(p.x, p.y-(j+1)), Pt(p.x, p.y-(j+4)),
Endsquare, Endsquare, 0, green, ZP);
line(scr, Pt(p.x+j+1, p.y), Pt(p.x+j+4, p.y),
Endsquare, Endsquare, 0, green, ZP);
line(scr, Pt(p.x-(j+1), p.y), Pt(p.x-(j+4), p.y),
Endsquare, Endsquare, 0, green, ZP);
break;
case DiffuseN:
case NebularCl:
p = map(ra, dec);
j = npixels(r->ngc.diam);
if(j < 4)
j = 4;
r1.min = Pt(p.x-j, p.y-j);
r1.max = Pt(p.x+j, p.y+j);
if(r->ngc.type != DiffuseN)
draw(scr, r1, ocstipple, ocstipple, ZP);
line(scr, Pt(p.x-j, p.y-j), Pt(p.x+j, p.y-j),
Endsquare, Endsquare, 0, green, ZP);
line(scr, Pt(p.x-j, p.y+j), Pt(p.x+j, p.y+j),
Endsquare, Endsquare, 0, green, ZP);
line(scr, Pt(p.x-j, p.y-j), Pt(p.x-j, p.y+j),
Endsquare, Endsquare, 0, green, ZP);
line(scr, Pt(p.x+j, p.y-j), Pt(p.x+j, p.y+j),
Endsquare, Endsquare, 0, green, ZP);
break;
case OpenCl:
p = map(ra, dec);
j = npixels(r->ngc.diam);
if(j < 4)
j = 4;
fillellipse(scr, p, j, j, ocstipple, ZP);
break;
case GlobularCl:
j = npixels(r->ngc.diam);
if(j < 4)
j = 4;
p = map(ra, dec);
ellipse(scr, p, j, j, 0, lightgrey, ZP);
line(scr, Pt(p.x-(j-1), p.y), Pt(p.x+j, p.y),
Endsquare, Endsquare, 0, lightgrey, ZP);
line(scr, Pt(p.x, p.y-(j-1)), Pt(p.x, p.y+j),
Endsquare, Endsquare, 0, lightgrey, ZP);
break;
}
}
flushimage(display, 1);
displayimage(scr);
}
