Return to cmp.c CVS log

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

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

1.1     ! root        1: /*
        !             2:  * Compare two files.
        !             3:  */
        !             4: 
        !             5: #include <stdio.h>
        !             6: #include <sys/types.h>
        !             7: 
        !             8: #define        isdigit(c)      ((c)>='0'&&(c)<='9')
        !             9: 
        !            10: int    lflag;          /* Print all differences */
        !            11: int    sflag;          /* Return status only */
        !            12: int    differ;         /* Non-zero if files differ */
        !            13: long   byteno;
        !            14: long   lineno = 1;
        !            15: fsize_t        skip1, skip2;
        !            16: long   atol();
        !            17: 
        !            18: char   eopen[] = "Cannot open %s\n";
        !            19: char   usage[] = "Usage: cmp [-l] [-s] file1 file2 [skip1 skip2]\n";
        !            20: #if    HEX
        !            21: char   diffl[] = "%ld: 0x%02x 0x%02x\n";
        !            22: #else
        !            23: char   diffl[] = "%ld: %3o %3o\n";
        !            24: #endif
        !            25: char   diffn[] = "%s, %s differ at char %ld, line %ld\n";
        !            26: 
        !            27: main(argc, argv)
        !            28: char *argv[];
        !            29: {
        !            30: #ifdef MSDOS
        !            31:        msdoscvt("cmp", &argc, &argv);
        !            32: #endif
        !            33:        if (argc > 1) {
        !            34:                if (*argv[1] == '-') {
        !            35:                        if (argv[1][1]=='s' && argv[1][2]=='\0')
        !            36:                                sflag = 1;
        !            37:                        else if (argv[1][1]=='l' && argv[1][2]=='\0')
        !            38:                                lflag = 1;
        !            39:                        else if (argv[1][1] == '\0') {
        !            40:                                argc++;
        !            41:                                argv--;
        !            42:                        } else
        !            43:                                err(usage);
        !            44:                        argc--;
        !            45:                        argv++;
        !            46:                }
        !            47:        }
        !            48:        if (argc==5 && isdigit(*argv[3]) && isdigit(*argv[4])) {
        !            49:                skip1 = atol(argv[3]);
        !            50:                skip2 = atol(argv[4]);
        !            51:                argc -= 2;
        !            52:        }
        !            53:        if (argc != 3)
        !            54:                err(usage);
        !            55:        cmp(argv[1], argv[2]);
        !            56:        exit(differ ? 1 : 0);
        !            57: }
        !            58: 
        !            59: /*
        !            60:  * Do the work of comparing the two files
        !            61:  */
        !            62: cmp(a, b)
        !            63: char *a, *b;
        !            64: {
        !            65:        FILE *fp1, *fp2;
        !            66:        register c1, c2;
        !            67: 
        !            68:        if (a[0]=='-' && a[1]=='\0') {
        !            69:                fp1 = stdin;
        !            70: #ifdef MSDOS
        !            71:                _setbinary(stdin);
        !            72: #endif
        !            73:        }
        !            74:        else if ((fp1 = fopen(a, "rb")) == NULL)
        !            75:                err(eopen, a);
        !            76:        if ((fp2 = fopen(b, "rb")) == NULL)
        !            77:                err(eopen, b);
        !            78:        while (skip1--)
        !            79:                if ((c1 = getc(fp1)) == EOF) {
        !            80:                        remark("EOF in skipping on %s\n", a);
        !            81:                        exit(1);
        !            82:                }
        !            83:        while (skip2--)
        !            84:                if ((c2 = getc(fp2)) == EOF) {
        !            85:                        remark("EOF in skipping on %s\n", b);
        !            86:                        exit(1);
        !            87:                }
        !            88:        for (;;) {
        !            89:                c1 = getc(fp1);
        !            90:                c2 = getc(fp2);
        !            91:                if (c1==EOF || c2==EOF)
        !            92:                        break;
        !            93:                byteno++;
        !            94:                if (c1 != c2) {
        !            95:                        differ = 1;
        !            96:                        if (lflag)
        !            97:                                remark(diffl, byteno, c1, c2);
        !            98:                        else {
        !            99:                                remark(diffn, a, b, byteno, lineno);
        !           100:                                return;
        !           101:                        }
        !           102:                }
        !           103:                if (c1 == '\n')
        !           104:                        lineno++;
        !           105:        }
        !           106:        if (c1 != c2) {
        !           107:                remark("EOF on %s\n", c1==EOF ? a : b);
        !           108:                differ = 1;
        !           109:        }
        !           110: }
        !           111: 
        !           112: err(x)
        !           113: {
        !           114:        if (!sflag)
        !           115:                fprintf(stderr, "%r", &x);
        !           116:        exit(2);
        !           117: }
        !           118: 
        !           119: remark(x)
        !           120: {
        !           121:        if (!sflag)
        !           122:                printf("%r", &x);
        !           123: }

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