Return to cat.c CVS log

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

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

1.1     ! root        1: 
        !             2: 
        !             3: /*
        !             4:  * cat -- concatinate and print
        !             5:  */
        !             6: #include       <errno.h>
        !             7: #include       <stdio.h>
        !             8: #include       <access.h>
        !             9: 
        !            10: int    uflag;                          /* don't buffer */
        !            11: char   *filename;                      /* current input file name */
        !            12: 
        !            13: main( argc, argv)
        !            14: char   *argv[];
        !            15: {
        !            16:        static char     obuf[BUFSIZ];
        !            17:        register int    i = 0;  
        !            18: 
        !            19:        ++argv;
        !            20:        if (--argc>0 && strcmp( *argv, "-u")==0) {
        !            21:                ++argv;
        !            22:                --argc;
        !            23:                ++uflag;
        !            24:                setbuf( stdout, (char *)NULL);
        !            25:        }
        !            26:        else
        !            27:                setbuf( stdout, obuf);
        !            28: 
        !            29:        if (argc <= 0)
        !            30:                cat("-");
        !            31:        else
        !            32:        {       while (*argv)
        !            33:                {   if (strcmp(*argv, "-") && access(*argv, AREAD))
        !            34:                    {  fprintf(stderr, "cat: %s: %s\n", *argv,
        !            35:                          sys_errlist[errno]);
        !            36:                       *argv[0] = 0;  /* flag arg as invalid */
        !            37:                    }
        !            38:                    i++;     /* count the arg */
        !            39:                    argv++;  /* advance to next arg */
        !            40:                }
        !            41:                
        !            42:                argv -= i;  /* back to start of filename args to process */
        !            43: 
        !            44:                do {
        !            45:                        if (*argv[0] == 0)  /* arg to skip? */ 
        !            46:                        {  argv++;
        !            47:                           continue;        /* yes */
        !            48:                        }
        !            49:                        cat(*argv++);
        !            50:                } while (--argc);
        !            51:        }
        !            52:        exit(0);
        !            53: }
        !            54: 
        !            55: 
        !            56: cat(file)
        !            57: char *file;
        !            58: {
        !            59:        register        c;
        !            60:        register FILE   *f;
        !            61:        extern char     *sys_errlist[];
        !            62:        extern          errno;
        !            63: 
        !            64:        if (strcmp( file, "-") == 0) {
        !            65:                filename = "<stdin>";
        !            66:                f = stdin;
        !            67:        }
        !            68:        else {
        !            69:                filename = file;
        !            70:                f = fopen( file, "r");
        !            71:                if (f == (FILE *)NULL) 
        !            72:                {  fprintf(stderr, "cat: %s: %s\n", file, sys_errlist[errno]);
        !            73:                   return;
        !            74:                }
        !            75:        }
        !            76:        if (uflag)
        !            77:                setbuf( f, (char *)NULL);
        !            78: 
        !            79:        while ((c=getc( f)) != EOF) {
        !            80:                putchar( c);
        !            81:                if (ferror( stdout))
        !            82:                        fatal( errno==EIO? "write error": sys_errlist[errno]);
        !            83:        }
        !            84: 
        !            85:        if (ferror( f))
        !            86:                fatal( errno==EIO? "read error": sys_errlist[errno]);
        !            87:        if (f != stdin)
        !            88:                fclose( f);
        !            89: }
        !            90: 
        !            91: 
        !            92: fatal( mesg)
        !            93: char   *mesg;
        !            94: {
        !            95: 
        !            96:        fflush( stdout);
        !            97:        printerr( "cat: ", filename, ": ", mesg, "\n", (char *)0);
        !            98:        exit(1);
        !            99: }
        !           100: 
        !           101: 
        !           102: printerr( arg0)
        !           103: char   *arg0;
        !           104: {
        !           105:        register char   **pp;
        !           106: 
        !           107:        for (pp= &arg0; *pp; )
        !           108:                fputs( *pp++, stderr);
        !           109: }

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