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

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.