Return to refer2.c CVS log

Up to [Research Unix] / researchv10no / cmd / refer

Annotation of researchv10no/cmd/refer/refer2.c, revision 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:        }

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