Return to unstr.c CVS log

Up to [CSRG BSD Unix] / 42BSD / games / fortune

Annotation of 42BSD/games/fortune/unstr.c, revision 1.1

1.1     ! root        1: # include      <stdio.h>
        !             2: # include      "strfile.h"
        !             3: 
        !             4: /*
        !             5:  *     This program un-does what "strfile" makes, thereby obtaining the
        !             6:  * original file again.  This can be invoked with the name of the output
        !             7:  * file, the input file, or both. If invoked with only a single argument
        !             8:  * ending in ".dat", it is pressumed to be the input file and the output
        !             9:  * file will be the same stripped of the ".dat".  If the single argument
        !            10:  * doesn't end in ".dat", then it is presumed to be the output file, and
        !            11:  * the input file is that name prepended by a ".dat".  If both are given
        !            12:  * they are treated literally as the input and output files.
        !            13:  *
        !            14:  *     Ken Arnold              Aug 13, 1978
        !            15:  */
        !            16: 
        !            17: char   sccsid[] = "@(#)unstr.c 1.2 (Berkeley) 5/14/81";
        !            18: 
        !            19: # define       reg     register
        !            20: 
        !            21: # define       DELIM_CH        '-'
        !            22: 
        !            23: char   infile[50],                     /* name of input file           */
        !            24:        outfile[50],                    /* name of output file          */
        !            25:        *rindex();
        !            26: 
        !            27: long   *calloc();
        !            28: 
        !            29: main(ac, av)
        !            30: int    ac;
        !            31: char   *av[]; {
        !            32: 
        !            33:        reg char        c;
        !            34:        reg FILE        *inf, *outf;
        !            35:        int             nstr, delim;
        !            36:        long            *seekpts;
        !            37:        STRFILE         tbl;            /* description table            */
        !            38: 
        !            39:        getargs(ac, av);
        !            40:        if ((inf = fopen(infile, "r")) == NULL) {
        !            41:                perror(infile);
        !            42:                exit(-1);
        !            43:        }
        !            44:        fread(&tbl,sizeof tbl,1,inf);
        !            45:        nstr = tbl.str_numstr;
        !            46:        if ((seekpts = calloc(sizeof *seekpts, nstr)) == NULL) {
        !            47:                perror("calloc");
        !            48:                exit(-1);
        !            49:        }
        !            50:        fread(seekpts, (sizeof seekpts[0]), nstr, inf);
        !            51:        if ((outf = fopen(outfile, "w")) == NULL) {
        !            52:                perror(outfile);
        !            53:                exit(-1);
        !            54:        }
        !            55:        delim = 0;
        !            56:        while ((c = getc(inf)) != EOF)
        !            57:                if (c != '\0')
        !            58:                        putc(c, outf);
        !            59:                else if (--nstr)
        !            60:                        if (ftell(inf) == tbl.str_delims[delim]) {
        !            61:                                fputs("%-\n", outf);
        !            62:                                delim++;
        !            63:                        }
        !            64:                        else
        !            65:                                fputs("%%\n", outf);
        !            66: }
        !            67: getargs(ac, av)
        !            68: reg int                ac;
        !            69: reg char       **av; {
        !            70: 
        !            71:        reg char        *sp;
        !            72: 
        !            73:        if (ac < 2) {
        !            74:                printf("usage: %s datafile[.dat] [ outfile ]\n",av[0]);
        !            75:                exit(-1);
        !            76:        }
        !            77:        strcpy(infile,av[1]);
        !            78:        if (ac < 3) {
        !            79:                strcpy(outfile,infile);
        !            80:                if ((sp = rindex(av[1])) && strcmp(sp, ".dat") == 0)
        !            81:                        outfile[strlen(outfile) - 4] = '\0';
        !            82:                else
        !            83:                        strcat(infile, ".dat");
        !            84:        }
        !            85:        else
        !            86:                strcpy(outfile, av[2]);
        !            87: }

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