Return to drop.c CVS log

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

Annotation of researchv10no/cmd/refer/update/drop.c, revision 1.1

1.1     ! root        1: # include "stdio.h"
        !             2: # include "assert.h"
        !             3: # include "ctype.h"
        !             4: 
        !             5: main(argc,argv)
        !             6:        char *argv[];
        !             7: {
        !             8: /* arguments are keys of a paper */
        !             9: /* output is file & lines to drop */
        !            10:        char answer[200], filname[60], outname[60];
        !            11:        int nuse = 0, i, c, length, line1, line2;
        !            12:        long l, start;
        !            13:        FILE *lkin, *lkout, *fin, *fout;
        !            14:        char *select = 0;
        !            15:        extern char *indexes;
        !            16: lkin = fopen("/dev/null", "w");
        !            17: lkout = fopen("/dev/null", "r");
        !            18: _assert (lkin !=NULL); _assert (lkout!=NULL);
        !            19: while (argc>1 &&argv[1][0]=='-')
        !            20:        {
        !            21:        switch(argv[1][1])
        !            22:                {
        !            23:                case 'p': /* use private index files */
        !            24:                        indexes = argv[2];
        !            25:                        argv += 2; argc -= 2;
        !            26:                        continue;
        !            27:                case 'u': /* use the Nth item */
        !            28:                        nuse = atoi(argv[1]+2);
        !            29:                        argv++; argc--;
        !            30:                        continue;
        !            31:                case 's': /* insist on a particular string */
        !            32:                        select = argv[2];
        !            33:                        argv += 2; argc -= 2;
        !            34:                        continue;
        !            35:                default:
        !            36:                        fprintf(stderr, "unknown option %s\n",argv[1]);
        !            37:                        argv++; argc--;
        !            38:                        continue;
        !            39:                }
        !            40:        }
        !            41: lookup(lkin, lkout);
        !            42: if (argc<=1) fprintf(stderr, "No search keys\n");
        !            43: _assert (argc>1);
        !            44: for(i=1; i<argc; i++)
        !            45:        fprintf(lkin, "%s ", argv[i]);
        !            46: fprintf(lkin, "\n");
        !            47: fclose(lkin);
        !            48: /* skip items up to nuse */
        !            49: for(i=1; i<nuse; i++)
        !            50:        geta(answer, lkout, select);
        !            51: /* get the right answer */
        !            52: i = geta(answer, lkout, select);
        !            53: if (i==0)
        !            54:        {
        !            55:        fprintf(stderr, "No match\n");
        !            56:        exit(1);
        !            57:        }
        !            58: sscanf(answer, "%[^:]:%ld,%d", filname, &start, &length);
        !            59: if (nuse<=0 && geta(answer, lkout, select)>0)
        !            60:        {
        !            61:        fprintf(stderr, "Not unique - use lookbib and either -s or -u\n");
        !            62:        exit(1);
        !            63:        }
        !            64: fclose(lkout);
        !            65: assert(strlen(filname)>0));
        !            66: fin = fopen(filname, "r");
        !            67: _assert (fin!=NULL);
        !            68: c=0;
        !            69: for(i=getpid()%990; 1; i++)
        !            70:        {
        !            71:        _assert (c++<100);
        !            72:        sprintf(outname, "bib%03d", i);
        !            73:        if (access(outname, 06) != 0)
        !            74:                break;
        !            75:        }
        !            76: printf("Will delete:   (file %s)\n\n", outname);
        !            77: line1 = 1;
        !            78: for(l=0; l<start; l++)
        !            79:        {
        !            80:        c = getc(fin);
        !            81:        _assert (c!=EOF);
        !            82:        if (c=='\n')
        !            83:                line1++;
        !            84:        }
        !            85: line2=line1;
        !            86: for(i=0; i<length; i++)
        !            87:        {
        !            88:        c = getc(fin);
        !            89:        _assert (c != EOF);
        !            90:        putchar(c);
        !            91:        if (c== '\n')
        !            92:                line2++;
        !            93:        }
        !            94: fclose(fin);
        !            95: fout = fopen(outname, "w");
        !            96: fprintf(fout, "%%# %s %d %d delete %ld %d\n",
        !            97:        filname, line1, line2-1,start, length);
        !            98: fclose(fout);
        !            99: }
        !           100: geta(answer, f, str)
        !           101:        char *answer, *str;
        !           102:        FILE *f;
        !           103: {
        !           104: answer[0]=0;
        !           105: while (answer[0]==0 && feof(f)==0)
        !           106:        {
        !           107:        answer[0]=0;
        !           108:        fgets(answer, 200, f);
        !           109:        trim(answer);
        !           110:        if (contain(answer, str)==0)
        !           111:                answer[0]=0;
        !           112:        }
        !           113: return( answer[0]!=0);
        !           114: }
        !           115: contain(answer, str)
        !           116:        char *answer, *str;
        !           117: {
        !           118: char filname[100]; long start; int length;
        !           119: int ft;
        !           120: char buff[1000], *s, *st;
        !           121: if (str==0) return(1);
        !           122: if (answer[0]==0) return(1);
        !           123: sscanf(answer, "%[^:]:%ld,%d", filname, &start, &length);
        !           124: assert(strlen(filname)>0));
        !           125: ft = open(filname, 0);
        !           126: assert(ft>=0);
        !           127: lseek(ft, start, 0);
        !           128: if (length>1000) length=1000;
        !           129: length = read(ft, buff, length);
        !           130: close(ft);
        !           131: buff[length]=0;
        !           132: st = buff+length;
        !           133: for(s=buff; s<st; s++)
        !           134:        if (prefix(str, s))
        !           135:                return(1);
        !           136: return(0);
        !           137: }
        !           138: prefix(sh,lg)
        !           139:        char *sh, *lg;
        !           140: {
        !           141: int c;
        !           142: while ( (c= *sh++) == *lg++)
        !           143:        {
        !           144:        if (c==0)
        !           145:                return(1);
        !           146:        }
        !           147: return(c==0);
        !           148: }
        !           149: trim(s)
        !           150:        char *s;
        !           151: {
        !           152: while (*s)s++;
        !           153: if (*--s=='\n') *s=0;
        !           154: }

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