CP/M/CPM_CDROM.iso/cpm/bdsc/bdsc-2/uniq.c

C/C++ Source or Header | 1994-07-13 | 4.1 KB | 201 lines

#define VERSION "uniq.c -- BDS Version 1.0 -- 6/20/82"
/*
 *    uniq - report repeated lines in a file
 *
 *    Adapted for BDS C by Jeff Martin, from a program by the same
 *    name written to run under the Unix (tm) operating system.
 *
 *    From the manual page for the Unix command:
 *
 *      "Uniq reads the input file comparing adjacent lines.  In the
 *      normal case, the second and succeeding copies    of repeated
 *      lines    are removed; the remainder is written on the output
 *      file.     Input and output should always    be different.  Note
 *      that repeated    lines must be adjacent in order    to be found.
 *      If the -u flag is used, just the lines that
 *      are not repeated in the original file    are output.  The -d
 *      option specifies that    one copy of just the repeated lines is
 *      to be    written.  The normal mode output is the    union of the
 *      -u and -d mode outputs.
 *
 *      "The -c option supersedes -u and -d and generates an output
 *      report in default style but with each    line preceded by a
 *      count    of the number of times it occurred.
 *
 *      "The n arguments specify skipping an initial portion of each
 *      line in the comparison:
 *
 *      -n      The first n fields together with any blanks before
 *          each are ignored.  A field is    defined    as a string of
 *          non-space, non-tab characters    separated by tabs and
 *          spaces from its neighbors.
 *
 *      ^n      The first n characters are ignored.  Fields are
 *          skipped before characters."
 *
 *    To compile: CC1 uniq.c
 *
 *    To link: L2 uniq dio
 *      or --  CLINK uniq -f dio
 */

#define STDERR 4
#include <a:bdscio.h>
#include <a:dio.h>

    int    fields;
    int    letters;
    int    linec;
    char    mode;
    int    uniq;
    char    *skip();
    char    b1[1000], b2[1000];
    struct _buf    infile;

main(argc, argv)
int argc;
char *argv[];
{
    dioinit(&argc, argv);

    fields = letters = linec = uniq = 0;
    mode = '\0';
    while(argc > 1) {
        if(*argv[1] == '-') {
            if (isdigit(argv[1][1]))
                fields = atoi(&argv[1][1]);
            else mode = tolower(argv[1][1]);
            argc--;
            argv++;
            continue;
        }
        if(*argv[1] == '^') {
            letters = atoi(&argv[1][1]);
            argc--;
            argv++;
            continue;
        }
        if ((argc == 2) && (fopen(argv[1], infile) == ERROR)) {
            fprintf(STDERR,"Cannot open %s\n", argv[1]);
            exit(1);
        }
        break;
    }

    if (argc != 2) {
        usage();
        exit(1);
    }

    if(gline(b1)) {
        dioflush();
        exit(0);
    }
    for(;;) {
        linec++;
        if(gline(b2)) {
            pline(b1);
            dioflush();
            exit(0);
        }
        if(!equal(b1, b2)) {
            pline(b1);
            linec = 0;
            do {
                linec++;
                if(gline(b1)) {
                    pline(b2);
                    dioflush();
                    exit(0);
                }
            } while(equal(b1, b2));
            pline(b2);
            linec = 0;
        }
    }
}

usage()
{
    fprintf(STDERR,"\n%s\n",VERSION);
    fputs("\nUsage: UNIQ [-u][-d][-c] [-n] [^n] input [>output]\n",STDERR);
    fputs("\t-u ==> just output unrepeated lines\n",STDERR);
    fputs("\t-d ==> output one copy of just repeated lines\n",STDERR);
    fputs("\t(default) ==> union of -u and -d options\n\n",STDERR);
    fputs("\t-c ==> prefix each output line with count of occurrences\n\n",STDERR);
    fputs("\t-n ==> skip first n fields in comparison\n",STDERR);
    fputs("\t^n ==> ignore first n characters (fields are skipped first)\n",STDERR);
    exit(1);
}

gline(buf)
char buf[];
{

    if (fgets(buf,infile) == NULL) {
        *buf = 0;
        return(1);
    }
    buf[strlen(buf)-1] = '\0';
    return(0);
}

pline(buf)
char buf[];
{
    switch(mode) {

    case 'u':
        if(uniq) {
            uniq = 0;
            return;
        }
        break;

    case 'd':
        if(uniq)
            break;
        return;

    case 'c':
        printf("%4d ", linec);
    }
    uniq = 0;
    puts(buf);
    putchar('\n');
}

equal(s1, s2)
char s1[], s2[];
{
    char c;

    s1 = skip(s1);
    s2 = skip(s2);
    while((c = *s1++) != 0)
        if(c != *s2++) return(0);
    if(*s2 != 0)
        return(0);
    uniq++;
    return(1);
}

char *
skip(s)
char *s;
{
    int nf, nl;

    nf = nl = 0;
    while(nf++ < fields) {
        while(*s == ' ' || *s == '\t')
            s++;
        while( !(*s == ' ' || *s == '\t' || *s == 0) )
            s++;
    }
    while(nl++ < letters && *s != 0)
            s++;
    return(s);
}