Annotation of researchv10no/cmd/weather/wsort.c, revision 1.1.1.1

1.1       root        1: # include "stdio.h"
                      2: # include "ctype.h"
                      3: # include "assert.h"
                      4: # include "cbt.h"
                      5: # include "weath.h"
                      6: # define SURFACE 1
                      7: # define FORECAST 2
                      8: mbuf key, rec, rkey;
                      9: char kb[100], rb[100], rkb[100];
                     10: bfile *bf;
                     11: char *index(), *vis(), *airport();
                     12: double atof();
                     13: 
                     14: main()
                     15: {
                     16: char line[200], line2[200];
                     17: int kind=0, k;
                     18: bf = bopen("/usr/spool/weather/air", 0);
                     19: assert(bf!=NULL);
                     20: while (gets(line))
                     21:        {
                     22:        k = strlen(line);
                     23:        if (k==0) continue;
                     24:        if (k==8 && strncmp(line+3, "00", 2)==0)
                     25:                {
                     26:                switch(atoi(line+5))
                     27:                        {
                     28:                        case 200: /* new england */
                     29:                        case 201: /* eastern states */
                     30:                        case 202: /* midatlantic */
                     31:                        case 203: /* southeastern */
                     32:                        case 204: /* great lakes */
                     33:                        case 205: /* ohio valley */
                     34:                        case 206: /* northern plains */
                     35:                        case 207: /* great plains */
                     36:                        case 208: /* gulf coast */
                     37:                        case 209: /* northern rockies */
                     38:                        case 210: /* southwestern */
                     39:                        case 211: /* pacific northwest */
                     40:                        case 212: /* pacific */
                     41:                        case 290: /* alaska */
                     42:                        case 291: /* hawaii */
                     43:                                kind = SURFACE;
                     44:                                continue;
                     45:                        case 431: kind = FORECAST; continue;
                     46:                        }
                     47:                kind=0;
                     48:                continue;
                     49:                }
                     50:        switch(kind)
                     51:                {
                     52:                case SURFACE:
                     53:                        surf(line); break;
                     54:                case FORECAST:
                     55:                        if (strlen(line)>5 && line[3]==' ' &&
                     56:                                isupper(line[0]) && isupper(line[1]))
                     57:                        {
                     58:                                gets(line2);
                     59:                                fore(line, line2);
                     60:                        }
                     61:                        break;
                     62:                }
                     63:        }
                     64: }
                     65: surf(line)
                     66:        char *line;
                     67: {
                     68: int nv, nw, i; char *v[50], *w[50], *s, *p, *aname;
                     69: double north, west;
                     70: if (strlen(line)<10) return;
                     71: if (!isalpha(line[0])) return;
                     72: s = index(line, '/');
                     73: if (s==NULL) return;
                     74: while (s>line && *s!= ' ')s--;
                     75: *s++ = 0;
                     76: nv = getargs(line, v);
                     77: nw = getargs(s, w);
                     78: aname = airport(v[0]);
                     79: if (aname==NULL) return;
                     80: for(i=0; i<nw; i++)
                     81:        if (strlen(w[i])==4 && isdigit(w[i][0]))
                     82:                break;
                     83: if (i==nw || i<2) return;
                     84: p = vis(v[nv-1]);
                     85: if (p==NULL ) return;
                     86: printf("at %s (%s)\n temp %s, weather%s\n", v[0], aname, w[i-2], p);
                     87: north = atof(aname);
                     88: west = atof(index(aname, ' '));
                     89: update( v[0], north, west, w[i-2], v[nv-1]);
                     90: }
                     91: char *
                     92: vis(s)
                     93:        char *s;
                     94: {
                     95: int d;
                     96: static char temp[50];
                     97: d= atoi(s);
                     98: while (isdigit(*s)) s++;
                     99: if (*s==0)
                    100:        {
                    101:        sprintf(temp, " clear, visibility %d miles", d);
                    102:        return(temp);
                    103:        }
                    104: temp[0]=0;
                    105: for( ; *s; s++)
                    106: switch(*s)
                    107:        {
                    108:        case 'A': strcat(temp, " hail"); break;
                    109:        case 'D': strcat(temp, " dust"); break;
                    110:        case 'F': strcat(temp, " fog"); break;
                    111:        case 'I': if (s[1]=='P') strcat(temp, " sleet"); break;
                    112:        case 'K': strcat(temp, " smoke"); break;
                    113:        case 'L': strcat(temp, " drizzle"); break;
                    114:        case 'R': strcat(temp, " rain"); break;
                    115:        case 'W': strcat(temp, " showers"); break;
                    116:        case 'S': strcat(temp, " snow"); break;
                    117:        case 'T': strcat(temp, " thunderstorms"); break;
                    118:        case 'Z': strcat(temp, " freezing"); break;
                    119:        case '-': break;
                    120:        default: return(NULL);
                    121:        }
                    122: return(temp);
                    123: }
                    124: fore( l1, l2)
                    125:        char *l1, *l2;
                    126: {
                    127: char *s;
                    128: int p1, p2, p3, p4, max1, min1, max2, min2;
                    129: l1[3]=0;
                    130: s=airport(l1);
                    131: if(s==NULL) return;
                    132: printf("For airport %s, %s\n", l1, s);
                    133: sscanf(l1+4, "%*s %d %d %d %d", &p1, &p2, &p3, &p4);
                    134: sscanf(l2, "%*s %d %d %d %d", &max1, &min1, &max2, &min2);
                    135: printf("next 24 hours temps max %d min %d, prob precip %d %d\n",max1, min1, p1, p2);
                    136: }
                    137: char *
                    138: airport(s)
                    139:        char *s;
                    140: {
                    141: int i;
                    142: key.mdata = s;
                    143: key.mlen = strlen(s);
                    144: i=bseek(bf, key);
                    145: if (i!=1) return(NULL);
                    146: rkey.mdata =rkb; rec.mdata = rb;
                    147: bread(bf, &rkey, &rec);
                    148: assert(strcmp(rkey.mdata, key.mdata)==0);
                    149: rkey.mdata[rkey.mlen]=0;
                    150: rec.mdata[rec.mlen]=0;
                    151: return(rec.mdata);
                    152: }
                    153: update (acode, north, west, temp, weath)
                    154:        double north, west;
                    155:        char *acode, *temp, *weath;
                    156: {
                    157: char fname[30], odata[2000], *p, *s;
                    158: struct wline *wp;
                    159: int n, w, f;
                    160: n = north;
                    161: n = n-n%4;
                    162: w = west;
                    163: w = w-w%4;
                    164: sprintf(fname, "/usr/spool/weather/o%.2d.%.2d", n, w);
                    165: f = open(fname, 2);
                    166: if (f>=0)
                    167:        {
                    168:        n=read(f, odata, 2000);
                    169:        assert(n<2000);
                    170:        for(wp=odata; wp<odata+n; wp++)
                    171:                {
                    172:                if (strncmp(wp->anam, acode, 3)==0)
                    173:                        {
                    174:                        strncpy(wp->wtemp, temp, 3);
                    175:                        strncpy(wp->wweath, weath, 7);
                    176:                        lseek (f, 0L, 0);
                    177:                        write(f, odata, n);
                    178:                        return;
                    179:                        }
                    180:                }
                    181:        }
                    182: else
                    183:        {
                    184:        f = creat(fname, 0666);
                    185:        wp = odata;
                    186:        n=0;
                    187:        }
                    188: sprintf(wp->anam, "%.3s%5.2f%6.2f%3.3s%7.7s\n", acode, north,
                    189:        west, temp, weath);
                    190: lseek (f, 0L, 0);
                    191: write(f, odata, n+sizeof(*wp));
                    192: close(f);
                    193: }

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.