Return to par.c CVS log

Up to [Research Unix] / researchv10no / cmd / ap / apkeys

Annotation of researchv10no/cmd/ap/apkeys/par.c, revision 1.1

1.1     ! root        1: # include "stdio.h"
        !             2: # include "assert.h"
        !             3: # include "key..c"
        !             4: int nseq =0;
        !             5: int nsent=0;
        !             6: int nstory=0;
        !             7: int ndest= -1;
        !             8: extern int destyet;
        !             9: # define NW 2000
        !            10: struct wordstr wds[NW];
        !            11: int nwds = 0;
        !            12: int wseen=0;
        !            13: int final=0;
        !            14: extern char *udir, *uname;
        !            15: mkwrd(w, negfl)
        !            16:        char *w;
        !            17: {
        !            18: struct wordstr *wp;
        !            19: wp = &wds[nwds++];
        !            20: wp->wch  = w;
        !            21: wp ->seq= nseq;
        !            22: wp->ifneg = negfl;
        !            23: wp->single=0;
        !            24: wp->mask = (1<<wseen);
        !            25: if (!negfl)
        !            26:        final |= (1<<wseen);
        !            27: wp->which = SEQ;
        !            28: wseen++;
        !            29: assert(nwds<NW);
        !            30: }
        !            31: int sqseen=0;
        !            32: #define NSEQ 2000
        !            33: struct matchstr seqs[NSEQ];
        !            34: int len[NSEQ];
        !            35: mkseq()
        !            36: {
        !            37: struct matchstr *sp;
        !            38: len[nseq]=wseen;
        !            39: sp = &seqs[nseq++];
        !            40: sp->next = nsent;
        !            41: sp->lim = final;
        !            42: sp->smask = (1<<sqseen);
        !            43: sp->ntype = SENT;
        !            44: assert (nseq<NSEQ);
        !            45: if (wseen == 1)
        !            46:        wds[nwds-1].single=1;
        !            47: wseen=final=0;
        !            48: sqseen++;
        !            49: }
        !            50: int snseen=0;
        !            51: #define NSENT 2000
        !            52: struct matchstr sents[NSENT];
        !            53: mksent()
        !            54: {
        !            55: struct matchstr *sp;
        !            56: sp = &sents[nsent++];
        !            57: sp->next = nstory;
        !            58: sp->lim = (1<<sqseen)-1;
        !            59: sp->smask = (1<<snseen);
        !            60: sp->ntype = STORY;
        !            61: assert (nsent<NSENT);
        !            62: sqseen=0;
        !            63: snseen++;
        !            64: }
        !            65: #define NSTORY 900
        !            66: struct matchstr stories[NSTORY];
        !            67: mkstory()
        !            68: {
        !            69: struct matchstr *sp;
        !            70: if (destyet==0) defdest();
        !            71: sp = &stories[nstory++];
        !            72: sp->next = (ndest>0 ? ndest : 0);
        !            73: sp->lim = (1<<snseen)-1;
        !            74: sp->ntype = DEST;
        !            75: assert (nstory<NSTORY);
        !            76: snseen=0;
        !            77: }
        !            78: # define ND 200
        !            79: struct deststr dests[ND];
        !            80: int stuff = 3;
        !            81: svwh(x)
        !            82:        char *x;
        !            83: {
        !            84: ndest++;
        !            85: destyet=1;
        !            86: dests[ndest].dstr = x;
        !            87: dests[ndest].sndflg = stuff;
        !            88: dests[ndest].homedir = udir;
        !            89: }
        !            90: optimize()
        !            91: {
        !            92: int i;
        !            93: struct wordstr *wp;
        !            94: struct matchstr *sp, *xp;
        !            95: for(i=0; i<nsent; i++)
        !            96:        {
        !            97:        xp = &sents[i];
        !            98:        sp = &stories[xp->next];
        !            99:        if (xp->smask == sp->lim)
        !           100:                {
        !           101:                xp->next = sp->next;
        !           102:                xp->ntype = sp->ntype;
        !           103:                xp->smask = sp->smask;
        !           104:                sp->ntype=0;
        !           105:                }
        !           106:        }
        !           107: for(i=0; i<nseq; i++)
        !           108:        {
        !           109:        xp = &seqs[i];
        !           110:        sp = &sents[xp->next];
        !           111:        if (xp->smask == sp->lim)
        !           112:                {
        !           113:                xp->next = sp->next;
        !           114:                xp->ntype = sp->ntype;
        !           115:                xp->smask = sp->smask;
        !           116:                sp->ntype=0;
        !           117:                }
        !           118:        }
        !           119: for(i=0; i<nwds; i++)
        !           120:        {
        !           121:        wp = &wds[i];
        !           122:        sp = &seqs[wp->seq];
        !           123:        if (wp->single)
        !           124:                {
        !           125:                wp->seq = sp->next;
        !           126:                wp->which = sp->ntype;
        !           127:                wp->mask = sp->smask;
        !           128:                if (wp->ifneg)
        !           129:                        {
        !           130:                        switch(wp->which)
        !           131:                                {
        !           132:                                case SENT:
        !           133:                                        sents[wp->seq].lim &= (~wp->mask);
        !           134:                                        break;
        !           135:                                case STORY:
        !           136:                                        stories[wp->seq].lim &= (~wp->mask);
        !           137:                                        break;
        !           138:                                }
        !           139:                        }
        !           140:                sp->ntype=0;
        !           141:                }
        !           142:        }
        !           143: }
        !           144: compress()
        !           145: {
        !           146: int i, j, k;
        !           147: struct matchstr *sp, *tp;
        !           148: for(i=0, j=nsent-1; i<j; i++)
        !           149:        {
        !           150:        if (sents[i].ntype!=0)
        !           151:                continue;
        !           152:        while (sents[j].ntype==0)
        !           153:                j--;
        !           154:        if (i>=j) break;
        !           155:        sents[i]=sents[j];
        !           156:        sents[j].ntype=0;
        !           157:        for(k=0; k<nwds; k++)
        !           158:                {
        !           159:                assert(!(wds[k].which==SENT && wds[k].seq==i));
        !           160:                if (wds[k].seq == j && wds[k].which == SENT)
        !           161:                        wds[k].seq=i;
        !           162:                }
        !           163:        for(k=0; k<nseq; k++)
        !           164:                {
        !           165:                assert(!(seqs[k].ntype==SENT && seqs[k].next==i))
        !           166:                if (seqs[k].next==j && seqs[k].ntype==SENT)
        !           167:                        seqs[k].next=i;
        !           168:                }
        !           169:        }
        !           170: if (sents[i].ntype) i++;
        !           171: nsent = i;
        !           172: for(i=0, j=nseq-1; i<j; i++)
        !           173:        {
        !           174:        if (seqs[i].ntype!=0)
        !           175:                continue;
        !           176:        while (seqs[j].ntype==0)
        !           177:                j--;
        !           178:        if (i>=j) break;
        !           179:        seqs[i]=seqs[j];
        !           180:        seqs[j].ntype=0;
        !           181:        len[i]=len[j];
        !           182:        for(k=0; k<nwds; k++)
        !           183:                {
        !           184:                assert(!(wds[k].which==SEQ && wds[k].seq==i));
        !           185:                if (wds[k].seq == j && wds[k].which == SEQ)
        !           186:                        wds[k].seq=i;
        !           187:                }
        !           188:        }
        !           189: if (seqs[i].ntype) i++;
        !           190: nseq = i;
        !           191: for(i=0, j=nstory-1; i<j; i++)
        !           192:        {
        !           193:        if (stories[i].ntype!=0)
        !           194:                continue;
        !           195:        while (stories[j].ntype==0)
        !           196:                j--;
        !           197:        if (i>=j) break;
        !           198:        stories[i]=stories[j];
        !           199:        stories[j].ntype=0;
        !           200:        for(k=0; k<nwds; k++)
        !           201:                {
        !           202:                assert(!(wds[k].which==STORY && wds[k].seq==i));
        !           203:                if (wds[k].seq == j && wds[k].which == STORY)
        !           204:                        wds[k].seq=i;
        !           205:                }
        !           206:        for(k=0; k<nseq; k++)
        !           207:                {
        !           208:                assert(!(seqs[k].ntype==STORY && seqs[k].next==i))
        !           209:                if (seqs[k].next==j && seqs[k].ntype==STORY)
        !           210:                        seqs[k].next=i;
        !           211:                }
        !           212:        for(k=0; k<nsent; k++)
        !           213:                {
        !           214:                assert(!(sents[k].ntype==STORY && sents[k].next==i))
        !           215:                if (sents[k].next==j && sents[k].ntype==STORY)
        !           216:                        sents[k].next=i;
        !           217:                }
        !           218:        }
        !           219: if (stories[i].ntype) i++;
        !           220: nstory = i;
        !           221: }
        !           222: dump()
        !           223: {
        !           224: optimize();
        !           225: compress();
        !           226: prvecs();
        !           227: }
        !           228: prvecs()
        !           229: {
        !           230: int i;
        !           231: int comp(), exch();
        !           232: shell (nwds, comp, exch);
        !           233: printf("%d entries in word list; word, seq, negfl, which, mask\n", nwds);
        !           234: for(i=0; i<nwds; i++)
        !           235:        printf("%s %d %d %d %d\n", wds[i].wch, wds[i].seq, wds[i].ifneg, wds[i].which, wds[i].mask);
        !           236: printf("%d entries in sequence list; sent, ntype, lim, mask, length\n", nseq);
        !           237: for(i=0; i<nseq; i++)
        !           238:        printf("%d %d %d %d %d\n", seqs[i].next, seqs[i].ntype, seqs[i].lim, seqs[i].smask, len[i]);
        !           239: printf("%d entries in sentence list; story, ntype, lim, mask\n", nsent);
        !           240: for(i=0; i<nsent; i++)
        !           241:        printf("%d %d %d %d\n", sents[i].next, sents[i].ntype, sents[i].lim, sents[i].smask);
        !           242: printf("%d entries in story list; dest, ntype, lim\n", nstory);
        !           243: for(i=0; i<nstory; i++)
        !           244:        printf("%d %d %d\n", stories[i].next, stories[i].ntype, stories[i].lim);
        !           245: printf("%d entries in destination list; level, dest\n", ndest+1);
        !           246: for(i=0; i<=ndest; i++)
        !           247:        {
        !           248:        char *p, *s;
        !           249:        p = dests[i].dstr;
        !           250:        while (*p=='>' || *p==' ' || *p=='\t')
        !           251:                p++;
        !           252:        if (*p=='|' || *p=='/')
        !           253:                printf("%d %s\n", dests[i].sndflg, dests[i].dstr);
        !           254:        else
        !           255:                {
        !           256:                printf("%d ", dests[i].sndflg);
        !           257:                for(s=dests[i].dstr; s<p; s++)
        !           258:                        putchar(*s);
        !           259:                printf("%s/%s\n", dests[i].homedir, p);
        !           260:                }
        !           261:        }
        !           262: }
        !           263: svsz(n)
        !           264: {
        !           265: stuff=n;
        !           266: }
        !           267: defdest()
        !           268: {
        !           269: static char dbuff[20];
        !           270:        ndest++;
        !           271:        sprintf(dbuff, "| mail %s", uname);
        !           272:        dests[ndest].dstr = svc(dbuff);
        !           273:        dests[ndest].sndflg=3;
        !           274:        destyet=1;
        !           275:        }
        !           276: comp(i,j) /* compares word list for i and j; true if ok */
        !           277: {
        !           278: return (strcmp (wds[i].wch, wds[j].wch) <= 0);
        !           279: }
        !           280: exch(i,j)
        !           281: {
        !           282: struct wordstr t;
        !           283: t = wds[i];
        !           284: wds[i]=wds[j];
        !           285: wds[j]=t;
        !           286: }

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