Return to getargs.c CVS log

Up to [Research Unix] / researchv10no / cmd / uucp

Annotation of researchv10no/cmd/uucp/getargs.c, revision 1.1

1.1     ! root        1: /*     /sccs/src/cmd/uucp/s.getargs.c
        !             2:        getargs.c       1.1     8/30/84 17:37:20
        !             3: */
        !             4: #include "uucp.h"
        !             5: VERSION(@(#)getargs.c  1.1);
        !             6: 
        !             7: /*
        !             8:  * generate a vector of pointers (arps) to the
        !             9:  * substrings in string "s".
        !            10:  * Each substring is separated by blanks and/or tabs.
        !            11:  *     s       -> string to analyze -- s GETS MODIFIED
        !            12:  *     arps    -> array of pointers -- count + 1 pointers
        !            13:  *     count   -> max number of fields
        !            14:  * returns:
        !            15:  *     i       -> # of subfields
        !            16:  *     arps[i] = NULL
        !            17:  */
        !            18: 
        !            19: getargs(s, arps, count)
        !            20: register char *s, *arps[];
        !            21: {
        !            22:        register int i;
        !            23: 
        !            24:        for (i = 0; i < count; i++) {
        !            25:                while (*s == ' ' || *s == '\t')
        !            26:                        *s++ = '\0';
        !            27:                if (*s == '\n')
        !            28:                        *s = '\0';
        !            29:                if (*s == '\0')
        !            30:                        break;
        !            31:                arps[i] = s++;
        !            32:                while (*s != '\0' && *s != ' '
        !            33:                        && *s != '\t' && *s != '\n')
        !            34:                                s++;
        !            35:        }
        !            36:        arps[i] = NULL;
        !            37:        return(i);
        !            38: }
        !            39: 
        !            40: /***
        !            41:  *      bsfix(args) - remove backslashes from args
        !            42:  *
        !            43:  *      \123 style strings are collapsed into a single character
        !            44:  *     \000 gets mapped into \N for further processing downline.
        !            45:  *      \ at end of string is removed
        !            46:  *     \t gets replaced by a tab
        !            47:  *     \n gets replaced by a newline
        !            48:  *     \r gets replaced by a carriage return
        !            49:  *     \b gets replaced by a backspace
        !            50:  *     \s gets replaced by a blank 
        !            51:  *     any other unknown \ sequence is left intact for further processing
        !            52:  *     downline.
        !            53:  */
        !            54: 
        !            55: void
        !            56: bsfix (args)
        !            57: char **args;
        !            58: {
        !            59:        register char *str, *to, *cp;
        !            60:        register int num;
        !            61: 
        !            62:        for (; *args; args++) {
        !            63:                str = *args;
        !            64:                for (to = str; *str; str++) {
        !            65:                        if (*str == '\\') {
        !            66:                                if (str[1] == '\0')
        !            67:                                        break;
        !            68:                                switch (*++str) {
        !            69:                                case '0':
        !            70:                                case '1':
        !            71:                                case '2':
        !            72:                                case '3':
        !            73:                                case '4':
        !            74:                                case '5':
        !            75:                                case '6':
        !            76:                                case '7':
        !            77:                                        for ( num = 0, cp = str
        !            78:                                            ; cp - str < 3
        !            79:                                            ; cp++
        !            80:                                            ) {
        !            81:                                                if ('0' <= *cp && *cp <= '7') {
        !            82:                                                        num <<= 3;
        !            83:                                                        num += *cp - '0';
        !            84:                                                }
        !            85:                                                else
        !            86:                                                    break;
        !            87:                                        }
        !            88:                                        if (num == 0) {
        !            89:                                                *to++ = '\\';
        !            90:                                                *to++ = 'N';
        !            91:                                        } else
        !            92:                                                *to++ = num;
        !            93:                                        str = cp-1;
        !            94:                                        break;
        !            95: 
        !            96:                                case 't':
        !            97:                                        *to++ = '\t';
        !            98:                                        break;
        !            99: 
        !           100:                                case 's':       
        !           101:                                        *to++ = ' ';
        !           102:                                        break;
        !           103: 
        !           104:                                case 'n':
        !           105:                                        *to++ = '\n';
        !           106:                                        break;
        !           107: 
        !           108:                                case 'r':
        !           109:                                        *to++ = '\r';
        !           110:                                        break;
        !           111: 
        !           112:                                case 'b':
        !           113:                                        *to++ = '\b';
        !           114:                                        break;
        !           115: 
        !           116:                                default:
        !           117:                                        *to++ = '\\';
        !           118:                                        *to++ = *str;
        !           119:                                        break;
        !           120:                                }
        !           121:                        }
        !           122:                        else
        !           123:                                *to++ = *str;
        !           124:                }
        !           125:                *to = '\0';
        !           126:        }
        !           127: }

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