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

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.