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

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.