Return to split.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin

Annotation of coherent/d/bin/split.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * split.c
        !             3:  * Usage: split [ -n ] [ infile [ outfile ]]
        !             4:  *
        !             5:  * split copies its input file into n-line pieces
        !             6:  * with output filenames ending in "aa", "ab", ... "zz".
        !             7:  * "n" (default 1000) is the number of lines per output file,
        !             8:  * "infile" (default or "-" is standard input) is the file to read,
        !             9:  * "outfile" (default "x") is the initial part of the output file name.
        !            10:  * A "-n" option beginning with 'c' (e.g. "-c100000") splits
        !            11:  * a binary file into characters instead of an ASCII file into lines.
        !            12:  */
        !            13: 
        !            14: #include <stdio.h>
        !            15: 
        !            16: /*
        !            17:  * Globals.
        !            18:  */
        !            19: int    binary = 0;             /* 0 for ASCII lines, 1 for binary characters */
        !            20: long   chunk = 1000L;          /* number of lines or chars per output file */
        !            21: FILE   *ifp = stdin;           /* input file pointer */
        !            22: char   *outname = "xaa";       /* first output filename */
        !            23: 
        !            24: /*
        !            25:  * Functions.
        !            26:  */
        !            27: long   atol();
        !            28: void   copy();
        !            29: void   fatal();
        !            30: char   *malloc();
        !            31: void   nextname();
        !            32: void   options();
        !            33: char   *strcat();
        !            34: char   *strcpy();
        !            35: 
        !            36: main(argc, argv) int argc; char *argv[];
        !            37: {
        !            38:        register int c;
        !            39:        register FILE *ofp;
        !            40:        register char *mode;
        !            41:        register char *tail;
        !            42: 
        !            43:        options(argc, argv);
        !            44:        tail = outname + strlen(outname) - 1;
        !            45:        mode = (binary) ? "wb" : "w";
        !            46:        while (!feof(ifp) && (c = getc(ifp)) != EOF) {
        !            47:                ungetc(c, ifp);
        !            48:                if ((ofp = fopen(outname, mode)) == NULL)
        !            49:                        fatal("split: cannot open output file \"%s\"\n",
        !            50:                                outname);
        !            51:                copy(ofp);
        !            52:                if (fclose(ofp) == EOF)
        !            53:                        fatal("split: cannot close output file \"%s\"\n",
        !            54:                                outname);
        !            55:                nextname(tail);
        !            56:        }
        !            57:        exit(0);
        !            58: }
        !            59: 
        !            60: /*
        !            61:  * Copy "chunk" lines or characters from "ifp" to "ofp".
        !            62:  */
        !            63: void copy(ofp) register FILE *ofp;
        !            64: {
        !            65:        register int c;
        !            66:        register long num;
        !            67: 
        !            68:        for (num = chunk; (c = getc(ifp)) != EOF; ) {
        !            69:                putc(c, ofp);
        !            70:                if ((binary || c == '\n') && --num <= 0)
        !            71:                        return;
        !            72:        }
        !            73: }
        !            74: 
        !            75: /*
        !            76:  * Cry and die.
        !            77:  * Avoids the nonportable "%r" format by assuming char * "cp" follows "fmt".
        !            78:  * The second argument is omitted if the "fmt" does not require it.
        !            79:  */
        !            80: void fatal(fmt, cp) register char *fmt, *cp;
        !            81: {
        !            82:        fprintf(stderr, fmt, cp);
        !            83:        exit(1);
        !            84: }
        !            85: 
        !            86: /*
        !            87:  * Set "outname" to the next output file name.
        !            88:  * If there are no more output files, issue an error message and exit.
        !            89:  */
        !            90: void nextname(cp) register char *cp;
        !            91: {
        !            92:        if (++*cp <= 'z')
        !            93:                return;
        !            94:        *cp = 'a';
        !            95:        if (++*--cp <= 'z')
        !            96:                return;
        !            97:        fatal("split: too many output files\n");
        !            98: }
        !            99: 
        !           100: /*
        !           101:  * Process command line options and initialize globals.
        !           102:  */
        !           103: void options(argc, argv) register int argc; register char *argv[];
        !           104: {
        !           105:        register char *cp;
        !           106: 
        !           107:        if (--argc > 0 && **++argv == '-') {
        !           108:                cp = ++*argv;
        !           109:                if (*cp == 'c') {
        !           110:                        binary = 1;
        !           111:                        ++cp;
        !           112:                }
        !           113:                chunk = atol(cp);
        !           114:                ++argv;
        !           115:                --argc;
        !           116:        }
        !           117:        if (chunk <= 0L || argc > 2)
        !           118:                fatal("Usage: split [ -n ] [ infile [ outfile ]]\n");
        !           119:        if (argc > 0) {
        !           120:                cp = *argv++;
        !           121:                if (strcmp(cp, "-") != 0
        !           122:                 && (ifp = fopen(cp, (binary) ? "rb" : "r")) == NULL)
        !           123:                        fatal("split: cannot open input file \"%s\"\n", cp);
        !           124:        }
        !           125:        if (argc > 1) {
        !           126:                cp = *argv++;
        !           127:                if ((outname = malloc(strlen(cp) + 3)) == NULL)
        !           128:                        fatal("split: \"%s\" too long\n", cp);
        !           129:                strcpy(outname, cp);
        !           130:                strcat(outname, "aa");
        !           131:        }
        !           132: }

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