#include <u.h>
#include <libc.h>
#include <bio.h>
#include <draw.h>
#include <event.h>
#include "sky.h"
#include "strings.c"

enum
{
       NNGC=7840,      /* number of NGC numbers [1..NNGC] */
       NIC = 5386,     /* number of IC numbers */
       NNGCrec=NNGC+NIC,       /* number of records in the NGC catalog (including IC's, starting at NNGC */
       NMrec=122,      /* number of M records */
       NM=110,         /* number of M numbers */
       NAbell=2712,    /* number of records in the Abell catalog */
       NName=1000,     /* number of prose names; estimated maximum (read from editable text file) */
       NBayer=1517,    /* number of bayer entries */
       NSAO=258998,    /* number of SAO stars */
       MAXcon=1932,    /* maximum number of patches in a constellation */
       Ncon=88,        /* number of constellations */
       Npatch=92053,   /* highest patch number */
};

char            ngctype[NNGCrec];
Mindexrec       mindex[NMrec];
Namerec         name[NName];
Bayerec         bayer[NBayer];
long            con[MAXcon];
ushort          conindex[Ncon+1];
long            patchaddr[Npatch+1];

Record  *rec;
Record  *orec;
Record  *cur;

char    *dir=DIR;
int     saodb;
int     ngcdb;
int     abelldb;
int     ngctypedb;
int     mindexdb;
int     namedb;
int     bayerdb;
int     condb;
int     conindexdb;
int     patchdb;
char    parsed[3];
long    nrec;
long    nreca;
long    norec;
long    noreca;

Biobuf  bin;
Biobuf  bout;

main(int argc, char *argv[])
{
       char *line;

       Binit(&bin, 0, OREAD);
       Binit(&bout, 1, OWRITE);
       if(argc != 1)
               dir = argv[1];
       astro("", 1);
       while(line = Brdline(&bin, '\n')){
               line[Blinelen(&bin)-1] = 0;
               lookup(line, 1);
               Bflush(&bout);
       }
       if(display != nil){
               closedisplay(display);
               /* automatic refresh of rio window is triggered by mouse */
               close(open("/dev/mouse", OREAD));
       }
       return 0;
}

void
reset(void)
{
       nrec = 0;
       cur = rec;
}

void
grow(void)
{
       nrec++;
       if(nreca < nrec){
               nreca = nrec+50;
               rec = realloc(rec, nreca*sizeof(Record));
               if(rec == 0){
                       fprint(2, "scat: realloc fails\n");
                       exits("realloc");
               }
       }
       cur = rec+nrec-1;
}

void
copy(void)
{
       if(noreca < nreca){
               noreca = nreca;
               orec = realloc(orec, nreca*sizeof(Record));
               if(orec == 0){
                       fprint(2, "scat: realloc fails\n");
                       exits("realloc");
               }
       }
       memmove(orec, rec, nrec*sizeof(Record));
       norec = nrec;
}

int
eopen(char *s)
{
       char buf[128];
       int f;

       sprint(buf, "%s/%s.scat", dir, s);
       f = open(buf, 0);
       if(f<0){
               fprint(2, "scat: can't open %s\n", buf);
               exits("open");
       }
       return f;
}


void
Eread(int f, char *name, void *addr, long n)
{
       if(read(f, addr, n) != n){      /* BUG! */
               fprint(2, "scat: read error on %s\n", name);
               exits("read");
       }
}

char*
skipbl(char *s)
{
       while(*s!=0 && (*s==' ' || *s=='\t'))
               s++;
       return s;
}

char*
skipstr(char *s, char *t)
{
       while(*s && *s==*t)
               s++, t++;
       return skipbl(s);
}

/* produce little-endian long at address l */
long
Long(long *l)
{
       uchar *p;

       p = (uchar*)l;
       return (long)p[0]|((long)p[1]<<8)|((long)p[2]<<16)|((long)p[3]<<24);
}

/* produce little-endian long at address l */
int
Short(short *s)
{
       uchar *p;

       p = (uchar*)s;
       return p[0]|(p[1]<<8);
}

void
nameopen(void)
{
       Biobuf b;
       int i;
       char *l, *p;

       if(namedb == 0){
               namedb = eopen("name");
               Binit(&b, namedb, OREAD);
               for(i=0; i<NName; i++){
                       l = Brdline(&b, '\n');
                       if(l == 0)
                               break;
                       p = strchr(l, '\t');
                       if(p == 0){
               Badformat:
                               Bprint(&bout, "warning: name.scat bad format; line %d\n", i+1);
                               break;
                       }
                       *p++ = 0;
                       strcpy(name[i].name, l);
                       if(strncmp(p, "ngc", 3) == 0)
                               name[i].ngc = atoi(p+3);
                       else if(strncmp(p, "ic", 2) == 0)
                               name[i].ngc = atoi(p+2)+NNGC;
                       else if(strncmp(p, "sao", 3) == 0)
                               name[i].sao = atoi(p+3);
                       else if(strncmp(p, "abell", 5) == 0)
                               name[i].abell = atoi(p+5);
                       else
                               goto Badformat;
               }
               if(i == NName)
                       Bprint(&bout, "warning: too many names in name.scat (max %d); extra ignored\n", NName);
               close(namedb);

               bayerdb = eopen("bayer");
               Eread(bayerdb, "bayer", bayer, sizeof bayer);
               close(bayerdb);
               for(i=0; i<NBayer; i++)
                       bayer[i].sao = Long(&bayer[i].sao);
       }
}

void
saoopen(void)
{
       if(saodb == 0){
               nameopen();
               saodb = eopen("sao");
       }
}

void
ngcopen(void)
{
       if(ngcdb == 0){
               nameopen();
               ngcdb = eopen("ngc2000");
               ngctypedb = eopen("ngc2000type");
               Eread(ngctypedb, "ngctype", ngctype, sizeof ngctype);
               close(ngctypedb);
       }
}

void
abellopen(void)
{
       /* nothing extra to do with abell: it's directly indexed by number */
       if(abelldb == 0)
               abelldb = eopen("abell");
}

void
patchopen(void)
{
       Biobuf *b;
       long l, m;
       char buf[100];

       if(patchdb == 0){
               patchdb = eopen("patch");
               sprint(buf, "%s/patchindex.scat", dir);
               b = Bopen(buf, OREAD);
               if(b == 0){
                       fprint(2, "can't open %s\n", buf);
                       exits("open");
               }
               for(m=0,l=0; l<=Npatch; l++)
                       patchaddr[l] = m += Bgetc(b)*4;
               Bterm(b);
       }
}

void
mopen(void)
{
       int i;

       if(mindexdb == 0){
               mindexdb = eopen("mindex");
               Eread(mindexdb, "mindex", mindex, sizeof mindex);
               close(mindexdb);
               for(i=0; i<NMrec; i++)
                       mindex[i].ngc = Short(&mindex[i].ngc);
       }
}

void
constelopen(void)
{
       int i;

       if(condb == 0){
               condb = eopen("con");
               conindexdb = eopen("conindex");
               Eread(conindexdb, "conindex", conindex, sizeof conindex);
               close(conindexdb);
               for(i=0; i<Ncon+1; i++)
                       conindex[i] = Short((short*)&conindex[i]);
       }
}

void
lowercase(char *s)
{
       for(; *s; s++)
               if('A'<=*s && *s<='Z')
                       *s += 'a'-'A';
}

int
loadngc(long index)
{
       static int failed;
       long j;

       ngcopen();
       j = (index-1)*sizeof(NGCrec);
       grow();
       cur->type = NGC;
       cur->index = index;
       seek(ngcdb, j, 0);
       /* special case: NGC data may not be available */
       if(read(ngcdb, &cur->ngc, sizeof(NGCrec)) != sizeof(NGCrec)){
               if(!failed){
                       fprint(2, "scat: NGC database not available\n");
                       failed++;
               }
               cur->type = NONGC;
               cur->ngc.ngc = 0;
               cur->ngc.ra = 0;
               cur->ngc.dec = 0;
               cur->ngc.diam = 0;
               cur->ngc.mag = 0;
               return 0;
       }
       cur->ngc.ngc = Short(&cur->ngc.ngc);
       cur->ngc.ra = Long(&cur->ngc.ra);
       cur->ngc.dec = Long(&cur->ngc.dec);
       cur->ngc.diam = Long(&cur->ngc.diam);
       cur->ngc.mag = Short(&cur->ngc.mag);
       return 1;
}

int
loadabell(long index)
{
       long j;

       abellopen();
       j = index-1;
       grow();
       cur->type = Abell;
       cur->index = index;
       seek(abelldb, j*sizeof(Abellrec), 0);
       Eread(abelldb, "abell", &cur->abell, sizeof(Abellrec));
       cur->abell.abell = Short(&cur->abell.abell);
       if(cur->abell.abell != index){
               fprint(2, "bad format in abell catalog\n");
               exits("abell");
       }
       cur->abell.ra = Long(&cur->abell.ra);
       cur->abell.dec = Long(&cur->abell.dec);
       cur->abell.glat = Long(&cur->abell.glat);
       cur->abell.glong = Long(&cur->abell.glong);
       cur->abell.rad = Long(&cur->abell.rad);
       cur->abell.mag10 = Short(&cur->abell.mag10);
       cur->abell.pop = Short(&cur->abell.pop);
       cur->abell.dist = Short(&cur->abell.dist);
       return 1;
}

int
loadsao(int index)
{
       if(index<=0 || index>NSAO)
               return 0;
       saoopen();
       grow();
       cur->type = SAO;
       cur->index = index;
       seek(saodb, (index-1)*sizeof(SAOrec), 0);
       Eread(saodb, "sao", &cur->sao, sizeof(SAOrec));
       cur->sao.ra = Long(&cur->sao.ra);
       cur->sao.dec = Long(&cur->sao.dec);
       cur->sao.dra = Long(&cur->sao.dra);
       cur->sao.ddec = Long(&cur->sao.ddec);
       cur->sao.mag = Short(&cur->sao.mag);
       cur->sao.mpg = Short(&cur->sao.mpg);
       cur->sao.hd = Long(&cur->sao.hd);
       return 1;
}

int
loadplanet(int index, Record *r)
{
       if(index<0 || index>NPlanet || planet[index].name[0]=='\0')
               return 0;
       grow();
       cur->type = Planet;
       cur->index = index;
       /* check whether to take new or existing record */
       if(r == nil)
               memmove(&cur->planet, &planet[index], sizeof(Planetrec));
       else
               memmove(&cur->planet, &r->planet, sizeof(Planetrec));
       return 1;
}

int
loadpatch(long index)
{
       int i;

       patchopen();
       if(index<=0 || index>Npatch)
               return 0;
       grow();
       cur->type = Patch;
       cur->index = index;
       seek(patchdb, patchaddr[index-1], 0);
       cur->patch.nkey = (patchaddr[index]-patchaddr[index-1])/4;
       Eread(patchdb, "patch", cur->patch.key, cur->patch.nkey*4);
       for(i=0; i<cur->patch.nkey; i++)
               cur->patch.key[i] = Long(&cur->patch.key[i]);
       return 1;
}

int
loadtype(int t)
{
       int i;

       ngcopen();
       for(i=0; i<NNGCrec; i++)
               if(t == (ngctype[i])){
                       grow();
                       cur->type = NGCN;
                       cur->index = i+1;
               }
       return 1;
}

void
flatten(void)
{
       int i, j, notflat;
       Record *or;
       long key;

   loop:
       copy();
       reset();
       notflat = 0;
       for(i=0,or=orec; i<norec; i++,or++){
               switch(or->type){
               default:
                       fprint(2, "bad type %d in flatten\n", or->type);
                       break;

               case NONGC:
                       break;

               case Planet:
               case Abell:
               case NGC:
               case SAO:
                       grow();
                       memmove(cur, or, sizeof(Record));
                       break;

               case NGCN:
                       if(loadngc(or->index))
                               notflat = 1;
                       break;

               case NamedSAO:
                       loadsao(or->index);
                       notflat = 1;
                       break;

               case NamedNGC:
                       if(loadngc(or->index))
                               notflat = 1;
                       break;

               case NamedAbell:
                       loadabell(or->index);
                       notflat = 1;
                       break;

               case PatchC:
                       loadpatch(or->index);
                       notflat = 1;
                       break;

               case Patch:
                       for(j=1; j<or->patch.nkey; j++){
                               key = or->patch.key[j];
                               if((key&0x3F) == SAO)
                                       loadsao((key>>8)&0xFFFFFF);
                               else if((key&0x3F) == Abell)
                                       loadabell((key>>8)&0xFFFFFF);
                               else
                                       loadngc((key>>16)&0xFFFF);
                       }
                       break;
               }
       }
       if(notflat)
               goto loop;
}

int
ism(int index)
{
       int i;

       for(i=0; i<NMrec; i++)
               if(mindex[i].ngc == index)
                       return 1;
       return 0;
}

char*
alpha(char *s, char *t)
{
       int n;

       n = strlen(t);
       if(strncmp(s, t, n)==0 && (s[n]<'a' || 'z'<s[n]))
               return skipbl(s+n);
       return 0;

}

char*
text(char *s, char *t)
{
       int n;

       n = strlen(t);
       if(strncmp(s, t, n)==0 && (s[n]==0 || s[n]==' ' || s[n]=='\t'))
               return skipbl(s+n);
       return 0;

}

int
cull(char *s, int keep, int dobbox)
{
       int i, j, nobj, keepthis;
       Record *or;
       char *t;
       int dogrtr, doless, dom, dosao, dongc, doabell;
       int mgrtr, mless;
       char obj[100];

       memset(obj, 0, sizeof(obj));
       nobj = 0;
       dogrtr = 0;
       doless = 0;
       dom = 0;
       dongc = 0;
       dosao = 0;
       doabell = 0;
       mgrtr = mless= 0;
       if(dobbox)
               goto Cull;
       for(;;){
               if(s[0] == '>'){
                       dogrtr = 1;
                       mgrtr = 10 * strtod(s+1, &t);
                       if(mgrtr==0  && t==s+1){
                               fprint(2, "bad magnitude\n");
                               return 0;
                       }
                       s = skipbl(t);
                       continue;
               }
               if(s[0] == '<'){
                       doless = 1;
                       mless = 10 * strtod(s+1, &t);
                       if(mless==0  && t==s+1){
                               fprint(2, "bad magnitude\n");
                               return 0;
                       }
                       s = skipbl(t);
                       continue;
               }
               if(t = text(s, "m")){
                       dom = 1;
                       s = t;
                       continue;
               }
               if(t = text(s, "sao")){
                       dosao = 1;
                       s = t;
                       continue;
               }
               if(t = text(s, "ngc")){
                       dongc = 1;
                       s = t;
                       continue;
               }
               if(t = text(s, "abell")){
                       doabell = 1;
                       s = t;
                       continue;
               }
               for(i=0; names[i].name; i++)
                       if(t = alpha(s, names[i].name)){
                               if(nobj > 100){
                                       fprint(2, "too many object types\n");
                                       return 0;
                               }
                               obj[nobj++] = names[i].type;
                               s = t;
                               goto Continue;
                       }
               break;
           Continue:;
       }
       if(*s){
               fprint(2, "syntax error in object list\n");
               return 0;
       }

   Cull:
       flatten();
       copy();
       reset();
       if(dom)
               mopen();
       if(dosao)
               saoopen();
       if(dongc || nobj)
               ngcopen();
       if(doabell)
               abellopen();
       for(i=0,or=orec; i<norec; i++,or++){
               keepthis = !keep;
               if(dobbox && inbbox(or->ngc.ra, or->ngc.dec))
                       keepthis = keep;
               if(doless && or->ngc.mag <= mless)
                       keepthis = keep;
               if(dogrtr && or->ngc.mag >= mgrtr)
                       keepthis = keep;
               if(dom && (or->type==NGC && ism(or->ngc.ngc)))
                       keepthis = keep;
               if(dongc && or->type==NGC)
                       keepthis = keep;
               if(doabell && or->type==Abell)
                       keepthis = keep;
               if(dosao && or->type==SAO)
                       keepthis = keep;
               for(j=0; j<nobj; j++)
                       if(or->type==NGC && or->ngc.type==obj[j])
                               keepthis = keep;
               if(keepthis){
                       grow();
                       memmove(cur, or, sizeof(Record));
               }
       }
       return 1;
}

int
compar(void *va, void *vb)
{
       Record *a=va, *b=vb;

       if(a->type == b->type)
               return a->index - b->index;
       return a->type - b->type;
}

void
sort(void)
{
       int i;
       Record *r, *s;

       if(nrec == 0)
               return;
       qsort(rec, nrec, sizeof(Record), compar);
       r = rec+1;
       s = rec;
       for(i=1; i<nrec; i++,r++){
               /* may have multiple instances of a planet in the scene */
               if(r->type==s->type && r->index==s->index && r->type!=Planet)
                       continue;
               memmove(++s, r, sizeof(Record));
       }
       nrec = (s+1)-rec;
}

char    greekbuf[128];

char*
togreek(char *s)
{
       char *t;
       int i, n;
       Rune r;

       t = greekbuf;
       while(*s){
               for(i=1; i<=24; i++){
                       n = strlen(greek[i]);
                       if(strncmp(s, greek[i], n)==0 && (s[n]==' ' || s[n]=='\t')){
                               s += n;
                               t += runetochar(t, &greeklet[i]);
                               goto Cont;
                       }
               }
               n = chartorune(&r, s);
               for(i=0; i<n; i++)
                       *t++ = *s++;
   Cont:;
       }
       *t = 0;
       return greekbuf;
}

char*
fromgreek(char *s)
{
       char *t;
       int i, n;
       Rune r;

       t = greekbuf;
       while(*s){
               n = chartorune(&r, s);
               for(i=1; i<=24; i++){
                       if(r == greeklet[i]){
                               strcpy(t, greek[i]);
                               t += strlen(greek[i]);
                               s += n;
                               goto Cont;
                       }
               }
               for(i=0; i<n; i++)
                       *t++ = *s++;
   Cont:;
       }
       *t = 0;
       return greekbuf;
}

#ifdef OLD
/*
* Old version
*/
int
coords(int deg)
{
       int i;
       int x, y;
       Record *or;
       long dec, ra, ndec, nra;
       int rdeg;

       flatten();
       copy();
       reset();
       deg *= 2;
       for(i=0,or=orec; i<norec; i++,or++){
               if(or->type == Planet)  /* must keep it here */
                       loadplanet(or->index, or);
               dec = or->ngc.dec/MILLIARCSEC;
               ra = or->ngc.ra/MILLIARCSEC;
               rdeg = deg/cos((dec*PI)/180);
               for(y=-deg; y<=+deg; y++){
                       ndec = dec*2+y;
                       if(ndec/2>=90 || ndec/2<=-90)
                               continue;
                       /* fp errors hurt here, so we round 1' to the pole */
                       if(ndec >= 0)
                               ndec = ndec*500*60*60 + 60000;
                       else
                               ndec = ndec*500*60*60 - 60000;
                       for(x=-rdeg; x<=+rdeg; x++){
                               nra = ra*2+x;
                               if(nra/2 < 0)
                                       nra += 360*2;
                               if(nra/2 >= 360)
                                       nra -= 360*2;
                               /* fp errors hurt here, so we round up 1' */
                               nra = nra/2*MILLIARCSEC + 60000;
                               loadpatch(patcha(angle(nra), angle(ndec)));
                       }
               }
       }
       sort();
       return 1;
}
#endif

/*
* New version attempts to match the boundaries of the plot better.
*/
int
coords(int deg)
{
       int i;
       int x, y, xx;
       Record *or;
       long min, circle;
       double factor;

       flatten();
       circle = 360*MILLIARCSEC;
       deg *= MILLIARCSEC;

       /* find center */
       folded = 0;
       bbox(0, 0, 0);
       /* now expand */
       factor = cos(angle((decmax+decmin)/2));
       if(factor < .2)
               factor = .2;
       factor = floor(1/factor);
       folded = 0;
       bbox(factor*deg, deg, 1);
       Bprint(&bout, "%s to ", hms(angle(ramin)));
       Bprint(&bout, "%s\n", hms(angle(ramax)));
       Bprint(&bout, "%s to ", dms(angle(decmin)));
       Bprint(&bout, "%s\n", dms(angle(decmax)));
       copy();
       reset();
       for(i=0,or=orec; i<norec; i++,or++)
               if(or->type == Planet)  /* must keep it here */
                       loadplanet(or->index, or);
       min = ramin;
       if(ramin > ramax)
               min -= circle;
       for(x=min; x<=ramax; x+=250*60*60){
               xx = x;
               if(xx < 0)
                       xx += circle;
               for(y=decmin; y<=decmax; y+=250*60*60)
                       if(-circle/4 < y && y < circle/4)
                               loadpatch(patcha(angle(xx), angle(y)));
       }
       sort();
       cull(nil, 1, 1);
       return 1;
}

void
pplate(char *flags)
{
       int i;
       long c;
       int na, rah, ram, d1, d2;
       double r0;
       int ra, dec;
       long ramin, ramax, decmin, decmax;      /* all in degrees */
       Record *r;
       int folded;
       Angle racenter, deccenter, rasize, decsize, a[4];
       Picture *pic;

       rasize = -1.0;
       decsize = -1.0;
       na = 0;
       for(;;){
               while(*flags==' ')
                       flags++;
               if(('0'<=*flags && *flags<='9') || *flags=='+' || *flags=='-'){
                       if(na >= 3)
                               goto err;
                       a[na++] = getra(flags);
                       while(*flags && *flags!=' ')
                               flags++;
                       continue;
               }
               if(*flags){
       err:
                       Bprint(&bout, "syntax error in plate\n");
                       return;
               }
               break;
       }
       switch(na){
       case 0:
               break;
       case 1:
               rasize = a[0];
               decsize = rasize;
               break;
       case 2:
               rasize = a[0];
               decsize = a[1];
               break;
       case 3:
       case 4:
               racenter = a[0];
               deccenter = a[1];
               rasize = a[2];
               if(na == 4)
                       decsize = a[3];
               else
                       decsize = rasize;
               if(rasize<0.0 || decsize<0.0){
                       Bprint(&bout, "negative sizes\n");
                       return;
               }
               goto done;
       }
       folded = 0;
       /* convert to milliarcsec */
       c = 1000*60*60;
   Again:
       if(nrec == 0){
               Bprint(&bout, "empty\n");
               return;
       }
       ramin = 0x7FFFFFFF;
       ramax = -0x7FFFFFFF;
       decmin = 0x7FFFFFFF;
       decmax = -0x7FFFFFFF;
       for(r=rec,i=0; i<nrec; i++,r++){
               if(r->type == Patch){
                       radec(r->index, &rah, &ram, &dec);
                       ra = 15*rah+ram/4;
                       r0 = c/cos(RAD(dec));
                       ra *= c;
                       dec *= c;
                       if(dec == 0)
                               d1 = c, d2 = c;
                       else if(dec < 0)
                               d1 = c, d2 = 0;
                       else
                               d1 = 0, d2 = c;
               }else if(r->type==SAO || r->type==NGC || r->type==Abell){
                       ra = r->ngc.ra;
                       dec = r->ngc.dec;
                       d1 = 0, d2 = 0, r0 = 0;
               }else if(r->type==NGCN){
                       loadngc(r->index);
                       continue;
               }else if(r->type==NamedSAO){
                       loadsao(r->index);
                       continue;
               }else if(r->type==NamedNGC){
                       loadngc(r->index);
                       continue;
               }else if(r->type==NamedAbell){
                       loadabell(r->index);
                       continue;
               }else
                       continue;
               if(dec+d2 > decmax)
                       decmax = dec+d2;
               if(dec-d1 < decmin)
                       decmin = dec-d1;
               if(folded){
                       ra -= 180*c;
                       if(ra < 0)
                               ra += 360*c;
               }
               if(ra+r0 > ramax)
                       ramax = ra+r0;
               if(ra < ramin)
                       ramin = ra;
       }
       if(!folded && ramax-ramin>270*c){
               folded = 1;
               goto Again;
       }
       racenter = angle(ramin+(ramax-ramin)/2);
       deccenter = angle(decmin+(decmax-decmin)/2);
       if(rasize<0 || decsize<0){
               rasize = angle(ramax-ramin)*cos(deccenter);
               decsize = angle(decmax-decmin);
       }
   done:
       if(DEG(rasize)>1.1 || DEG(decsize)>1.1){
               Bprint(&bout, "plate too big: %s", ms(rasize));
               Bprint(&bout, " x %s\n", ms(decsize));
               Bprint(&bout, "trimming to 30'x30'\n");
               rasize = RAD(0.5);
               decsize = RAD(0.5);
       }
       Bprint(&bout, "%s %s ", hms(racenter), dms(deccenter));
       Bprint(&bout, "%s", ms(rasize));
       Bprint(&bout, " x %s\n", ms(decsize));
       Bflush(&bout);
       flatten();
       pic = image(racenter, deccenter, rasize, decsize);
       if(pic == 0)
               return;
       Bprint(&bout, "plate %s locn %d %d %d %d\n", pic->name, pic->minx, pic->miny, pic->maxx, pic->maxy);
       Bflush(&bout);
       displaypic(pic);
}

void
lookup(char *s, int doreset)
{
       int i, j, k;
       int rah, ram, deg;
       char *starts, *inputline=s, *t, *u;
       Record *r;
       long n;
       double x;
       Angle ra;

       lowercase(s);
       s = skipbl(s);

       if(*s == 0)
               goto Print;

       if(t = alpha(s, "flat")){
               if(*t){
                       fprint(2, "flat takes no arguments\n");
                       return;
               }
               if(nrec == 0){
                       fprint(2, "no records\n");
                       return;
               }
               flatten();
               goto Print;
       }

       if(t = alpha(s, "print")){
               if(*t){
                       fprint(2, "print takes no arguments\n");
                       return;
               }
               for(i=0,r=rec; i<nrec; i++,r++)
                       prrec(r);
               return;
       }

       if(t = alpha(s, "add")){
               lookup(t, 0);
               return;
       }

       if(t = alpha(s, "sao")){
               n = strtoul(t, &u, 10);
               if(n<=0 || n>NSAO)
                       goto NotFound;
               t = skipbl(u);
               if(*t){
                       fprint(2, "syntax error in sao\n");
                       return;
               }
               if(doreset)
                       reset();
               if(!loadsao(n))
                       goto NotFound;
               goto Print;
       }

       if(t = alpha(s, "ngc")){
               n = strtoul(t, &u, 10);
               if(n<=0 || n>NNGC)
                       goto NotFound;
               t = skipbl(u);
               if(*t){
                       fprint(2, "syntax error in ngc\n");
                       return;
               }
               if(doreset)
                       reset();
               if(!loadngc(n))
                       goto NotFound;
               goto Print;
       }

       if(t = alpha(s, "ic")){
               n = strtoul(t, &u, 10);
               if(n<=0 || n>NIC)
                       goto NotFound;
               t = skipbl(u);
               if(*t){
                       fprint(2, "syntax error in ic\n");
                       return;
               }
               if(doreset)
                       reset();
               if(!loadngc(n+NNGC))
                       goto NotFound;
               goto Print;
       }

       if(t = alpha(s, "abell")){
               n = strtoul(t, &u, 10);
               if(n<=0 || n>NAbell)
                       goto NotFound;
               if(doreset)
                       reset();
               if(!loadabell(n))
                       goto NotFound;
               goto Print;
       }

       if(t = alpha(s, "m")){
               n = strtoul(t, &u, 10);
               if(n<=0 || n>NM)
                       goto NotFound;
               mopen();
               for(j=n-1; mindex[j].m<n; j++)
                       ;
               if(doreset)
                       reset();
               while(mindex[j].m == n){
                       if(mindex[j].ngc){
                               grow();
                               cur->type = NGCN;
                               cur->index = mindex[j].ngc;
                       }
                       j++;
               }
               goto Print;
       }

       for(i=1; i<=Ncon; i++)
               if(t = alpha(s, constel[i])){
                       if(*t){
                               fprint(2, "syntax error in constellation\n");
                               return;
                       }
                       constelopen();
                       seek(condb, 4L*conindex[i-1], 0);
                       j = conindex[i]-conindex[i-1];
                       Eread(condb, "con", con, 4*j);
                       if(doreset)
                               reset();
                       for(k=0; k<j; k++){
                               grow();
                               cur->type = PatchC;
                               cur->index = Long(&con[k]);
                       }
                       goto Print;
               }

       if(t = alpha(s, "expand")){
               n = 0;
               if(*t){
                       if(*t<'0' && '9'<*t){
               Expanderr:
                               fprint(2, "syntax error in expand\n");
                               return;
                       }
                       n = strtoul(t, &u, 10);
                       t = skipbl(u);
                       if(*t)
                               goto Expanderr;
               }
               coords(n);
               goto Print;
       }

       if(t = alpha(s, "plot")){
               if(nrec == 0){
                       Bprint(&bout, "empty\n");
                       return;
               }
               plot(t);
               return;
       }

       if(t = alpha(s, "astro")){
               astro(t, 0);
               return;
       }

       if(t = alpha(s, "plate")){
               pplate(t);
               return;
       }

       if(t = alpha(s, "gamma")){
               while(*t==' ')
                       t++;
               u = t;
               x = strtod(t, &u);
               if(u > t)
                       gam.gamma = x;
               Bprint(&bout, "%.2f\n", gam.gamma);
               return;
       }

       if(t = alpha(s, "keep")){
               if(!cull(t, 1, 0))
                       return;
               goto Print;
       }

       if(t = alpha(s, "drop")){
               if(!cull(t, 0, 0))
                       return;
               goto Print;
       }

       for(i=0; planet[i].name[0]; i++){
               if(t = alpha(s, planet[i].name)){
                       if(doreset)
                               reset();
                       loadplanet(i, nil);
                       goto Print;
               }
       }

       for(i=0; names[i].name; i++){
               if(t = alpha(s, names[i].name)){
                       if(*t){
                               fprint(2, "syntax error in type\n");
                               return;
                       }
                       if(doreset)
                               reset();
                       loadtype(names[i].type);
                       goto Print;
               }
       }

       switch(s[0]){
       case '"':
               starts = ++s;
               while(*s != '"')
                       if(*s++ == 0){
                               fprint(2, "bad star name\n");
                               return;
                       }
               *s = 0;
               if(doreset)
                       reset();
               j = nrec;
               saoopen();
               starts = fromgreek(starts);
               for(i=0; i<NName; i++)
                       if(equal(starts, name[i].name)){
                               grow();
                               if(name[i].sao){
                                       rec[j].type = NamedSAO;
                                       rec[j].index = name[i].sao;
                               }
                               if(name[i].ngc){
                                       rec[j].type = NamedNGC;
                                       rec[j].index = name[i].ngc;
                               }
                               if(name[i].abell){
                                       rec[j].type = NamedAbell;
                                       rec[j].index = name[i].abell;
                               }
                               strcpy(rec[j].named.name, name[i].name);
                               j++;
                       }
               if(parsename(starts))
                       for(i=0; i<NBayer; i++)
                               if(bayer[i].name[0]==parsed[0] &&
                                 (bayer[i].name[1]==parsed[1] || parsed[1]==0) &&
                                  bayer[i].name[2]==parsed[2]){
                                       grow();
                                       rec[j].type = NamedSAO;
                                       rec[j].index = bayer[i].sao;
                                       strncpy(rec[j].named.name, starts, sizeof(rec[j].named.name));
                                       j++;
                               }
               if(j == 0){
                       *s = '"';
                       goto NotFound;
               }
               break;

       case '0': case '1': case '2': case '3': case '4':
       case '5': case '6': case '7': case '8': case '9':
               strtoul(s, &t, 10);
               if(*t != 'h'){
       BadCoords:
                       fprint(2, "bad coordinates %s\n", inputline);
                       break;
               }
               ra = DEG(getra(s));
               while(*s && *s!=' ' && *s!='\t')
                       s++;
               rah = ra/15;
               ra = ra-rah*15;
               ram = ra*4;
               deg = strtol(s, &t, 10);
               if(t == s)
                       goto BadCoords;
               /* degree sign etc. is optional */
               if((uchar)*t == L'°')
                       deg = DEG(getra(s));
               if(doreset)
                       reset();
               if(abs(deg)>=90 || rah>=24)
                       goto BadCoords;
               if(!loadpatch(patch(rah, ram, deg)))
                       goto NotFound;
               break;

       default:
               fprint(2, "unknown command %s\n", inputline);
               return;
       }

   Print:
       if(nrec == 0)
               Bprint(&bout, "empty\n");
       else if(nrec <= 2)
               for(i=0; i<nrec; i++)
                       prrec(rec+i);
       else
               Bprint(&bout, "%ld items\n", nrec);
       return;

   NotFound:
       fprint(2, "%s not found\n", inputline);
       return;
}

char *ngctypes[] =
{
[Galaxy]                "Gx",
[PlanetaryN]    "Pl",
[OpenCl]                "OC",
[GlobularCl]    "Gb",
[DiffuseN]              "Nb",
[NebularCl]     "C+N",
[Asterism]              "Ast",
[Knot]          "Kt",
[Triple]                "***",
[Double]                "D*",
[Single]                "*",
[Uncertain]     "?",
[Nonexistent]   "-",
[Unknown]       " ",
[PlateDefect]   "PD",
};

char*
ngcstring(int d)
{
       if(d<Galaxy || d>PlateDefect)
               return "can't happen";
       return ngctypes[d];
}

short   descindex[NINDEX];

void
printnames(Record *r)
{
       int i, ok, done;

       done = 0;
       for(i=0; i<NName; i++){ /* stupid linear search! */
               ok = 0;
               if(r->type==SAO && r->index==name[i].sao)
                       ok = 1;
               if(r->type==NGC && r->ngc.ngc==name[i].ngc)
                       ok = 1;
               if(r->type==Abell && r->abell.abell==name[i].abell)
                       ok = 1;
               if(ok){
                       if(done++ == 0)
                               Bprint(&bout, "\t");
                       Bprint(&bout, " \"%s\"", togreek(name[i].name));
               }
       }
       if(done)
               Bprint(&bout, "\n");
}

int
equal(char *s1, char *s2)
{
       int c;

       while(*s1){
               if(*s1==' '){
                       while(*s1==' ')
                               s1++;
                       continue;
               }
               while(*s2==' ')
                       s2++;
               c=*s2;
               if('A'<=*s2 && *s2<='Z')
                       c^=' ';
               if(*s1!=c)
                       return 0;
               s1++, s2++;
       }
       return 1;
}

int
parsename(char *s)
{
       char *blank;
       int i;

       blank = strchr(s, ' ');
       if(blank==0 || strchr(blank+1, ' ') || strlen(blank+1)!=3)
               return 0;
       blank++;
       parsed[0] = parsed[1] = parsed[2] = 0;
       if('0'<=s[0] && s[0]<='9'){
               i = atoi(s);
               parsed[0] = i;
               if(i > 100)
                       return 0;
       }else{
               for(i=1; i<=24; i++)
                       if(strncmp(greek[i], s, strlen(greek[i]))==0){
                               parsed[0]=100+i;
                               goto out;
                       }
               return 0;
           out:
               if('0'<=s[strlen(greek[i])] && s[strlen(greek[i])]<='9')
                       parsed[1]=s[strlen(greek[i])]-'0';
       }
       for(i=1; i<=88; i++)
               if(strcmp(constel[i], blank)==0){
                       parsed[2] = i;
                       return 1;
               }
       return 0;
}

char*
dist_grp(int dg)
{
       switch(dg){
       default:
               return "unknown";
       case 1:
               return "13.3-14.0";
       case 2:
               return "14.1-14.8";
       case 3:
               return "14.9-15.6";
       case 4:
               return "15.7-16.4";
       case 5:
               return "16.5-17.2";
       case 6:
               return "17.3-18.0";
       case 7:
               return ">18.0";
       }
}

char*
rich_grp(int dg)
{
       switch(dg){
       default:
               return "unknown";
       case 0:
               return "30-40";
       case 1:
               return "50-79";
       case 2:
               return "80-129";
       case 3:
               return "130-199";
       case 4:
               return "200-299";
       case 5:
               return ">=300";
       }
}

char*
nameof(Record *r)
{
       NGCrec *n;
       SAOrec *s;
       Abellrec *a;
       static char buf[128];
       int i;

       switch(r->type){
       default:
               return nil;
       case SAO:
               s = &r->sao;
               if(s->name[0] == 0)
                       return nil;
               if(s->name[0] >= 100){
                       i = snprint(buf, sizeof buf, "%C", greeklet[s->name[0]-100]);
                       if(s->name[1])
                               i += snprint(buf+i, sizeof buf-i, "%d", s->name[1]);
               }else
                       i = snprint(buf, sizeof buf, " %d", s->name[0]);
               snprint(buf+i, sizeof buf-i, " %s", constel[s->name[2]]);
               break;
       case NGC:
               n = &r->ngc;
               if(n->type >= Uncertain)
                       return nil;
               if(n->ngc <= NNGC)
                       snprint(buf, sizeof buf, "NGC%4d ", n->ngc);
               else
                       snprint(buf, sizeof buf, "IC%4d ", n->ngc-NNGC);
               break;
       case Abell:
               a = &r->abell;
               snprint(buf, sizeof buf, "Abell%4d", a->abell);
               break;
       }
       return buf;
}

void
prrec(Record *r)
{
       NGCrec *n;
       SAOrec *s;
       Abellrec *a;
       Planetrec *p;
       int i, rah, ram, dec, nn;
       long key;

       if(r) switch(r->type){
       default:
               fprint(2, "can't prrec type %d\n", r->type);
               exits("type");

       case Planet:
               p = &r->planet;
               Bprint(&bout, "%s", p->name);
               Bprint(&bout, "\t%s %s",
                       hms(angle(p->ra)),
                       dms(angle(p->dec)));
               Bprint(&bout, " %3.2f° %3.2f°",
                       p->az/(double)MILLIARCSEC, p->alt/(double)MILLIARCSEC);
               Bprint(&bout, " %s",
                       ms(angle(p->semidiam)));
               if(r->index <= 1)
                       Bprint(&bout, " %g", p->phase);
               Bprint(&bout, "\n");
               break;

       case NGC:
               n = &r->ngc;
               if(n->ngc <= NNGC)
                       Bprint(&bout, "NGC%4d ", n->ngc);
               else
                       Bprint(&bout, "IC%4d ", n->ngc-NNGC);
               Bprint(&bout, "%s ", ngcstring(n->type));
               if(n->mag == UNKNOWNMAG)
                       Bprint(&bout, "----");
               else
                       Bprint(&bout, "%.1f%c", n->mag/10.0, n->magtype);
               Bprint(&bout, "\t%s %s\t%c%.1f'\n",
                       hm(angle(n->ra)),
                       dm(angle(n->dec)),
                       n->diamlim,
                       DEG(angle(n->diam))*60.);
               prdesc(n->desc, desctab, descindex);
               printnames(r);
               break;

       case Abell:
               a = &r->abell;
               Bprint(&bout, "Abell%4d  %.1f %.2f° %dMpc", a->abell, a->mag10/10.0,
                       DEG(angle(a->rad)), a->dist);
               Bprint(&bout, "\t%s %s\t%.2f %.2f\n",
                       hm(angle(a->ra)),
                       dm(angle(a->dec)),
                       DEG(angle(a->glat)),
                       DEG(angle(a->glong)));
               Bprint(&bout, "\tdist grp: %s  rich grp: %s  %d galaxies/°²\n",
                       dist_grp(a->distgrp),
                       rich_grp(a->richgrp),
                       a->pop);
               printnames(r);
               break;

       case SAO:
               s = &r->sao;
               Bprint(&bout, "SAO%6ld  ", r->index);
               if(s->mag==UNKNOWNMAG)
                       Bprint(&bout, "---");
               else
                       Bprint(&bout, "%.1f", s->mag/10.0);
               if(s->mpg==UNKNOWNMAG)
                       Bprint(&bout, ",---");
               else
                       Bprint(&bout, ",%.1f", s->mpg/10.0);
               Bprint(&bout, "  %s %s  %.4fs %.3f\"",
                       hms(angle(s->ra)),
                       dms(angle(s->dec)),
                       DEG(angle(s->dra))*(4*60),
                       DEG(angle(s->ddec))*(60*60));
               Bprint(&bout, "  %.3s %c %.2s %ld %d",
                       s->spec, s->code, s->compid, s->hd, s->hdcode);
               if(s->name[0])
                       Bprint(&bout, " \"%s\"", nameof(r));
               Bprint(&bout, "\n");
               printnames(r);
               break;

       case Patch:
               radec(r->index, &rah, &ram, &dec);
               Bprint(&bout, "%dh%dm %d°", rah, ram, dec);
               key = r->patch.key[0];
               Bprint(&bout, " %s", constel[key&0xFF]);
               if((key>>=8) & 0xFF)
                       Bprint(&bout, " %s", constel[key&0xFF]);
               if((key>>=8) & 0xFF)
                       Bprint(&bout, " %s", constel[key&0xFF]);
               if((key>>=8) & 0xFF)
                       Bprint(&bout, " %s", constel[key&0xFF]);
               for(i=1; i<r->patch.nkey; i++){
                       key = r->patch.key[i];
                       switch(key&0x3F){
                       case SAO:
                               Bprint(&bout, " SAO%ld", (key>>8)&0xFFFFFF);
                               break;
                       case Abell:
                               Bprint(&bout, " Abell%ld", (key>>8)&0xFFFFFF);
                               break;
                       default:        /* NGC */
                               nn = (key>>16)&0xFFFF;
                               if(nn > NNGC)
                                       Bprint(&bout, " IC%d", nn-NNGC);
                               else
                                       Bprint(&bout, " NGC%d", nn);
                               Bprint(&bout, "(%s)", ngcstring(key&0x3F));
                               break;
                       }
               }
               Bprint(&bout, "\n");
               break;

       case NGCN:
               if(r->index <= NNGC)
                       Bprint(&bout, "NGC%ld\n", r->index);
               else
                       Bprint(&bout, "IC%ld\n", r->index-NNGC);
               break;

       case NamedSAO:
               Bprint(&bout, "SAO%ld \"%s\"\n", r->index, togreek(r->named.name));
               break;

       case NamedNGC:
               if(r->index <= NNGC)
                       Bprint(&bout, "NGC%ld \"%s\"\n", r->index, togreek(r->named.name));
               else
                       Bprint(&bout, "IC%ld \"%s\"\n", r->index-NNGC, togreek(r->named.name));
               break;

       case NamedAbell:
               Bprint(&bout, "Abell%ld \"%s\"\n", r->index, togreek(r->named.name));
               break;

       case PatchC:
               radec(r->index, &rah, &ram, &dec);
               Bprint(&bout, "%dh%dm %d\n", rah, ram, dec);
               break;
       }
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.