Return to getprm.c CVS log

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

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

1.1     ! root        1: /*     /sccs/src/cmd/uucp/s.getprm.c
        !             2:        getprm.c        1.4     8/30/84 17:37:22
        !             3: */
        !             4: #include "uucp.h"
        !             5: VERSION(@(#)getprm.c   1.4)
        !             6: 
        !             7: #define LQUOTE '('
        !             8: #define RQUOTE ')'
        !             9: 
        !            10: #define ZERO   0
        !            11: #define WHITE  1
        !            12: #define DELIMIT        2
        !            13: #define QUOTE  3
        !            14: #define OTHER  9
        !            15: 
        !            16: 
        !            17: extern char *bal();
        !            18: 
        !            19: /*
        !            20:  * get next parameter from s
        !            21:  *     s       -> string to scan
        !            22:  *     prm     -> pointer to use to return token
        !            23:  * return:
        !            24:  *      s      -> pointer to next character 
        !            25:  *             NULL at end
        !            26:  */
        !            27: char *
        !            28: getprm(s, prm)
        !            29: register char *s, *prm;
        !            30: {
        !            31:        register char *c;
        !            32:        char rightq;            /* the right quote character */
        !            33: 
        !            34:        /* skip white space */
        !            35:        while (charType(*s) == WHITE)
        !            36:                s++;
        !            37: 
        !            38:        *prm = '\0';
        !            39:        if (*s == '\0')
        !            40:                return(NULL);
        !            41: 
        !            42:        if (charType(*s) == DELIMIT) {
        !            43:                *prm++ = *s++;
        !            44:                *prm = '\0';
        !            45:                return(s);
        !            46:        }
        !            47: 
        !            48:        /* look for quoted argument */
        !            49:        if (charType(*s) == QUOTE) {
        !            50:            /* setup the right quote character */
        !            51:            if (*s == LQUOTE)
        !            52:                rightq = RQUOTE;
        !            53:            else
        !            54:                rightq = *s;
        !            55: 
        !            56:            c = bal(s, rightq);
        !            57:            (void) strcpy(prm, s, c-s+1);
        !            58:            prm[c-s+1] = '\0';
        !            59:            if ( *(s=c) == rightq) /* if end of string don't increment */
        !            60:                s++;
        !            61:            return(s);
        !            62:        }
        !            63: 
        !            64:        while (charType(*s) == OTHER)
        !            65:                *prm++ = *s++;
        !            66:        *prm = '\0';
        !            67: 
        !            68:        return(s);
        !            69: }
        !            70: 
        !            71: /*
        !            72:  * split name into system and file part
        !            73:  *     name    -> string to scan
        !            74:  *     sys     -> return area for system name
        !            75:  *     rest    -> return area for remainder
        !            76:  * return:
        !            77:  *     0       -> no system prefix
        !            78:  *     TRUE    -> system prefix return in sys
        !            79:  */
        !            80: 
        !            81: split(name, sys, rest)
        !            82: register char *name;
        !            83: char *sys, *rest;
        !            84: {
        !            85:        register char *c, *n;
        !            86: 
        !            87:        *sys = '\0';
        !            88:        if (*name == LQUOTE) {
        !            89:                c = bal(name, RQUOTE);
        !            90:                name++;
        !            91:                (void) strncpy(rest, name, c-name);
        !            92:                rest[c-name] = '\0';
        !            93:                return(0);
        !            94:        }
        !            95: 
        !            96:        for (n = name ;; n = c+1) { /* loop to get rid if initial Mynames */
        !            97:            if ((c = strchr(n, '!')) == NULL) {
        !            98:                (void) strcpy(rest, n);
        !            99:                return(0);
        !           100:            }
        !           101: 
        !           102:            /*  ignore escaped '!' */
        !           103:            if ((c != n) && (*(c-1) == '\\')) {
        !           104:                *(c-1) = '\0';
        !           105:                (void) strcpy(rest, n);
        !           106:                (void) strcat(rest, c);
        !           107:                return(0);
        !           108:            }
        !           109: 
        !           110:            *c = '\0';
        !           111:            if (EQUALS(n, Myname)) /* initial system is Myname */
        !           112:                continue;
        !           113: 
        !           114:            (void) strcpy(sys, n);
        !           115:            (void) strcpy(rest, ++c);
        !           116:            return(TRUE);
        !           117:        }
        !           118:        /*NOTREACHED*/
        !           119: }
        !           120: 
        !           121: 
        !           122: /*
        !           123:  * bal - get balanced quoted string
        !           124:  *
        !           125:  * s - input string
        !           126:  * r - right quote
        !           127:  * Note: *s is the left quote
        !           128:  * return:
        !           129:  *  pointer to the end of the quoted string
        !           130:  * Note:
        !           131:  *     If the string is not balanced, it returns a pointer to the
        !           132:  *     end of the string.
        !           133:  */
        !           134: 
        !           135: char *
        !           136: bal(s, r)
        !           137: register char *s;
        !           138: char r;
        !           139: {
        !           140:        short count = 1;
        !           141:        char l;         /* left quote character */
        !           142: 
        !           143:        for (l = *s++; *s; s++) {
        !           144:            if (*s == r) {
        !           145:                if (--count == 0)
        !           146:                    break;      /* this is the balanced end */
        !           147:            }
        !           148:            else if (*s == l)
        !           149:                count++;
        !           150:        }
        !           151:        return(s);
        !           152: }
        !           153: 
        !           154: 
        !           155: /*
        !           156:  * charType - classify type of character , white space, delimiter, other
        !           157:  *
        !           158:  * s - character
        !           159:  * return:
        !           160:  *     WHITE - whitespace
        !           161:  *     DELIMIT - delimiter
        !           162:  *     QUOTE - some type of quote "'(`
        !           163:  *     OTHER - other
        !           164:  */
        !           165: 
        !           166: charType(s)
        !           167: char s;
        !           168: {
        !           169:        switch(s) {
        !           170:        case '>':
        !           171:        case '<':
        !           172:        case '|':
        !           173:        case ';':
        !           174:        case '&':
        !           175:        case '^':
        !           176:        case '\\':
        !           177:                return(DELIMIT);
        !           178: 
        !           179:        case ' ':
        !           180:        case '\t':
        !           181:        case '\n':
        !           182:                return(WHITE);
        !           183: 
        !           184:        case '\0':
        !           185:                return(ZERO);
        !           186: 
        !           187: 
        !           188:        case '"':
        !           189:        case '\'':
        !           190:        case '`':
        !           191:        case LQUOTE:
        !           192:                return(QUOTE);
        !           193: 
        !           194:        default:
        !           195:                return(OTHER);
        !           196:        }
        !           197: }

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