Return to echo.c CVS log

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

Annotation of coherent/d/bin/echo.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * echo -- print arguments
                      3:  *
                      4:  * Usage:      echo [ -n ] [ argument ... ]
                      5:  *
                      6:  * Option:     -n      Do not print terminal newline
                      7:  *
                      8:  * Note:       The following C-like escape conventions are usable with
                      9:  *             ECHO; beware of conflicts with the shell's use of \:
                     10:  *                     \b      backspace
                     11:  *                     \c      print line without new-line
                     12:  *                             (same as -n option)
                     13:  *                     \f      form-feed
                     14:  *                     \n      new-line
                     15:  *                     \r      carriage returnm
                     16:  *                     \t      tab
                     17:  *                     \v      vertical tab
                     18:  *                     \\      backslash
                     19:  *                     \0x     where x represents the octal value of an
                     20:  *                             ASCII character
                     21:  *
                     22:  */
                     23: 
                     24: static char    buf[512];                       /* working buffer */
                     25: static char   * bufend = &buf[sizeof buf];     /* pointer to end ogf buf */
                     26: static char   * bufp   = &buf[0];      /* pointer to current offset in buf */
                     27: static char    lastch  = '\n';         /* last output char (if non-zero) */
                     28: static int     asc;                    /* octal value */
                     29: 
                     30: main( argc, argv )
                     31: int    argc;
                     32: register char  ** argv;
                     33: {
                     34:        extern  echos();
                     35: 
                     36:        if ( strcmp( *++argv, "-n" ) == 0 ) {
                     37:                lastch = 0;
                     38:                ++argv;
                     39:        }
                     40: 
                     41:        /*
                     42:         * Read all argument strings into buffer. Separate each argument
                     43:         * with a blank.
                     44:         */
                     45:        while ( *argv ) {
                     46:                echos( *argv );
                     47:                if ( *++argv )
                     48:                        echos( " " );
                     49:        }
                     50: 
                     51:        if ( *bufp = lastch )
                     52:                ++bufp;
                     53: 
                     54:        if ( bufp > buf )
                     55:                write( 1, buf, bufp - buf );
                     56: 
                     57:        exit( 0 );
                     58: }
                     59: 
                     60: /*
                     61:  * static
                     62:  * echos( sp )
                     63:  * char * sp;
                     64:  *
                     65:  *     Input:  sp      - pointer to string to append to output buffer.
                     66:  *
                     67:  *     Action: Transfer string to output buffer at offset specified by 'bufp'.
                     68:  *             If buffer becomes full during transfer, write buffer to stdout,
                     69:  *             and wrap 'bufp' back to beginning of buffer.
                     70:  */
                     71: 
                     72: static
                     73: echos( sp )
                     74: register char  * sp;
                     75: {
                     76:        register char   * dp = bufp;
                     77:        extern char *   getoct();
                     78: 
                     79:        /*
                     80:         * Copy argument to buffer.
                     81:         */
                     82:        for ( ; *sp ; ++sp ) {
                     83:                if ( *sp == '\\' ) {
                     84:                        if ( *++sp == '\0' )
                     85:                                break;
                     86: 
                     87:                        switch (*sp) {
                     88:                        case 'b': *dp = '\b';   break;
                     89:                        case 'f': *dp = '\f';   break;
                     90:                        case 'n': *dp = '\n';   break;
                     91:                        case 'r': *dp = '\r';   break;
                     92:                        case 't': *dp = '\t';   break;
                     93:                        case 'v': *dp = 013;    break;
                     94:                        case 'c': lastch = 0; --dp; break;
                     95:                        case '0': sp  = getoct( ++sp );
                     96:                                  *dp = (char)asc;
                     97:                                  break;
                     98:                        default : *dp = *sp;    break;
                     99:                        }
                    100:                } else
                    101:                        *dp = *sp;
                    102: 
                    103:                /*
                    104:                 * Empty buffer to standard output if full.
                    105:                 */
                    106:                if ( ++dp == bufend ) {
                    107:                        write( 1, buf, sizeof buf );
                    108:                        dp = buf;
                    109:                }
                    110:        }
                    111: 
                    112:        bufp = dp;
                    113: }
                    114: 
                    115: /*
                    116:  * char *
                    117:  * getoct( s )
                    118:  * char * s;
                    119:  *
                    120:  *     Input:  s       - pointer to current offset in string.
                    121:  *
                    122:  *     Action: Read octal value from string ( up to 3 characters ).
                    123:  *
                    124:  *     Return: Pointer to current offset in string.
                    125:  */
                    126: char *
                    127: getoct( s )
                    128: char   * s;
                    129: {
                    130:        int     i;      /* working counter */
                    131: 
                    132:        i   = 0;
                    133:        asc = 0;        /* clear octal value buffer */
                    134: 
                    135:        while ( (*s) && (*s >= '0') && (*s <= '7') && ( i < 3 ) ) {
                    136:                asc = asc * 8 + *s - '0';       /* octal value accumulation */
                    137:                ++s;
                    138:                ++i;
                    139:        }
                    140: 
                    141:        return( --s );
                    142: }

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