Annotation of researchv10no/cmd/refer/refer2.c, revision 1.1.1.1

1.1       root        1: # include "refer..c"
                      2: extern FILE *in;
                      3: # define NFLD 30
                      4: # define TLEN 800
                      5: char one[ANSLEN];
                      6: int onelen = ANSLEN;
                      7: static char dr [100] = "";
                      8: doref(firline)
                      9:        char *firline;
                     10: {
                     11: char buff[QLEN], dbuff[3*QLEN], answer[ANSLEN], temp[TLEN];
                     12: char line[LLINE];
                     13: char *p, **sr, *flds[NFLD], *r;
                     14: int nf, nr, alph, query = 0, chp, digs;
                     15: 
                     16: /* get query */
                     17: buff[0] = dbuff[0] = 0;
                     18: if (nobracket)
                     19:        {
                     20:        strcpy( control(firline[0]) ? dbuff : buff , firline);
                     21:        if (control(firline[0])) query=1;
                     22:        firline= "  ";
                     23:        }
                     24: while (input(line))
                     25:        {
                     26:        if (prefix(".]", line))
                     27:                break;
                     28:        if (nobracket && line[0]=='\n')
                     29:                break;
                     30:        if (control(line[0])) query=1;
                     31:        strcat (query  ? dbuff: buff, line);
                     32:        if (strlen(buff)>QLEN)
                     33:                err("buff too big (%d)", strlen(buff));
                     34:        assert (strlen(dbuff) <3*QLEN);
                     35:        }
                     36: if (strcmp (buff, "$LIST$\n")==0)
                     37:        {
                     38: # if D1
                     39: fprintf(stderr, "dump sorted list\n");
                     40: # endif
                     41:        assert ( dbuff[0]==0);
                     42:        dumpold();
                     43:        if (recycle)
                     44:                refnum=0;
                     45:        return;
                     46:        }
                     47: answer[0] = 0;
                     48: # ifdef D1
                     49:        fprintf(stderr, "query is %s\n",buff);
                     50: # endif
                     51: for( p=buff; *p; p++)
                     52:        {
                     53:        if (isupper(*p)) *p |= 040;
                     54:        }
                     55: alph = digs =0;
                     56: for(p=buff; *p; p++)
                     57:        {
                     58:        if (isalpha(chp = *p)) alph++;
                     59:        else
                     60:        if (isdigit(*p)) digs++;
                     61:        else
                     62:                {
                     63:                *p=0;
                     64:                if ( (alph+digs<3) || common(p-alph))
                     65:                        {
                     66:                        r = p-alph;
                     67:                        while (r < p)
                     68:                                *r++ = ' ';
                     69:                        }
                     70:                if ( alph==0 && digs >0)
                     71:                        {
                     72:                        r = p-digs;
                     73: # if D1
                     74: fprintf(stderr, "number, %d long, text is %s\n",digs,r);
                     75: # endif
                     76:                        if (digs != 4 || (atoi(r)/100 != 19))
                     77:                                {
                     78:                                while (r<p)
                     79:                                        *r++ = ' ';
                     80:                                }
                     81:                        }
                     82:                if (chp== '\\')
                     83:                        *p++ = ' ';
                     84:                *p=' ';
                     85:                alph = digs = 0;
                     86:                }
                     87:        }
                     88: # ifdef D1
                     89:        fprintf(stderr, "query translated to %s\n", buff);
                     90: # endif
                     91: one[0]=0;
                     92: if (buff[0]) /* do not search if no query */
                     93: for( sr= rdata; sr < search; sr++)
                     94:        {
                     95: # ifdef D1
                     96:        fprintf(stderr, "now searching %s\n", *sr);
                     97: # endif
                     98:        temp[0]=0;
                     99:        corout (buff, temp, "hunt", *sr, TLEN);
                    100:        strcpy(dr, *sr);
                    101:        dirfix(dr);
                    102:        assert (strlen(temp)<TLEN);
                    103:        if (strlen(temp)+strlen(answer)>LLINE)
                    104:                err("Accumulated answers too large",0);
                    105:        strcat (answer, temp);
                    106:        if (strlen(answer)>LLINE)
                    107:                err("answer too long (%d)", strlen(answer));
                    108:        if (newline(answer) > 0) break;
                    109:        }
                    110: # if D1
                    111: fprintf(stderr, "answer:\n%s****\n", answer);
                    112: # endif
                    113: assert (strlen(one)<ANSLEN);
                    114: assert (strlen(answer)<ANSLEN);
                    115: if (buff[0])
                    116: switch (newline(answer))
                    117:        {
                    118:        case 0:
                    119:                fprintf (stderr, "No such paper %s\n", buff);
                    120:                return;
                    121:        default:
                    122:                fprintf(stderr, "too many hits for '%s'\n", trimnl(buff));
                    123:                choices(answer);
                    124:                p = buff;
                    125:                while (*p != '\n') p++;
                    126:                *++p=0;
                    127:        case 1:
                    128: # ifdef D1
                    129:        fprintf(stderr, "found one\n");
                    130: # endif
                    131:                if (endpush)
                    132:                        if (nr = chkdup(answer))
                    133:                                {
                    134:                                if (bare<2)
                    135:                                        putsig (0, flds, nr, firline, line);
                    136:                                if (pagecit)
                    137:                                        pgnum(refnum);
                    138:                                return;
                    139:                                }
                    140: # if D1
                    141:                fprintf(stderr, "one[0] was %o\n",one[0]);
                    142: # endif
                    143:                if (one[0]==0)
                    144:                        corout (answer, one, "deliv", dr, 2*QLEN);
                    145: # if D1
                    146:                fprintf(stderr, "one now %o\n",one[0]);
                    147: # endif
                    148:                break;
                    149:        }
                    150: assert (strlen(buff)<QLEN);
                    151: assert (strlen(one)<ANSLEN);
                    152: nf = tabs(flds, one);
                    153: nf += tabs(flds+nf, dbuff);
                    154: clean(flds, nf, 'L');
                    155: # if D1
                    156: fprintf(stderr, "one %.20s dbuff %.20s nf %d\n",one,dbuff, nf);
                    157: # endif
                    158: assert (nf < NFLD);
                    159: refnum++;
                    160: if (sort) putkey (nf, flds, refnum, keystr);
                    161: # if D1
                    162: fprintf(stderr, "past putkey, bare %d\n", bare);
                    163: # endif
                    164: if (bare<2)
                    165:        putsig (nf, flds, refnum, firline, line);
                    166: else
                    167:        flout();
                    168: if (pagecit)
                    169:        pgnum(refnum);
                    170: # if D1
                    171: fprintf(stderr, "put signal\n");
                    172: # endif
                    173: putref (nf, flds);
                    174: # if D1
                    175: fprintf(stderr, "put ref\n");
                    176: # endif
                    177: }
                    178: newline(s)
                    179:        char *s;
                    180: {
                    181: int k =0, c;
                    182: while (c = *s++)
                    183:        if (c == '\n')
                    184:                k++;
                    185: return(k);
                    186: }
                    187: choices( buff )
                    188:        char *buff;
                    189: {
                    190: char ob[LLINE], *p, *r, *q, *t;
                    191: int nl;
                    192: for(r=p= buff; *p; p++)
                    193:        {
                    194:        if (*p == '\n')
                    195:                {
                    196:                *p++ = 0;
                    197:                        {
                    198:                        corout (r, ob, "deliv", dr, LLINE);
                    199:                        nl = 1;
                    200:                        for( q=ob; *q; q++)
                    201:                                {
                    202:                                if (nl && (q[0] == '.' || q[0] == '%') && q[1] == 'T')
                    203:                                        {
                    204:                                        q += 3;
                    205:                                        for (t=q; *t && *t != '\n'; t++);
                    206:                                        *t = 0;
                    207:                                        fprintf(stderr, "%.70s\n", q);
                    208:                                        q=0; break;
                    209:                                        }
                    210:                                nl = *q == '\n';
                    211:                                }
                    212:                        if (q)
                    213:                                fprintf(stderr, "??? at %s\n",r);
                    214:                        }
                    215:                r=p;
                    216:                }
                    217:        if (*p==0) break; /* the p++ might go past the end */
                    218:        }
                    219: }
                    220: 
                    221: control(c)
                    222:        {
                    223:        if (c=='.') return(1);
                    224:        if (c=='%') return(1);
                    225:        return(0);
                    226:        }
                    227: dirfix(s)
                    228:        char *s;
                    229: {
                    230: char *t;
                    231: for(t= s; *t; t++)
                    232:        ;
                    233: while (t>s && *t!='/') t--;
                    234: if (t>s)
                    235:        *t=0;
                    236: }
                    237: clean(xf, nf, c)
                    238:        char *xf[];
                    239: {
                    240: int i, j;
                    241: for(i=nf-1; i>=0; i--)
                    242:        {
                    243:        if (control(xf[i][0]) && xf[i][1]==c)
                    244:                break;
                    245:        }
                    246: if (i<0) return;
                    247: for(j=i-1; j>=0; j--)
                    248:        {
                    249:        if (control(xf[j][0]) && xf[j][1]==c)
                    250:                xf[j][1]= '~'; /* cancel */
                    251:        }
                    252: }
                    253: pgnum(rn)
                    254:        {
                    255:        char pgtemp[100], rname[10];
                    256:        sprintf(rname, "%c%c", prnA[rn/62], prnB[rn%62]);
                    257:        sprintf(pgtemp, ".ie '\\*(%s'' .ds %s \\n%%\n.el .as %s , \\n%%\n",
                    258:                rname, rname, rname);
                    259:        output(pgtemp);
                    260:        }

unix.superglobalmegacorp.com

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