Return to decode.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd / sdb

Annotation of 3BSD/cmd/sdb/decode.c, revision 1.1

1.1     ! root        1: #include "head.h"
        !             2: 
        !             3: /* decode() - read a line from standard input and decode it */
        !             4: 
        !             5: decode(p)
        !             6: char *p; {
        !             7:        register char c, *q;
        !             8:        integ = scallf = reflag = colonflag = 0;
        !             9:        proc[0] = cmd = args[0] = var[0] = '\0';
        !            10:        argsp = args;
        !            11:        
        !            12:        if (eqany(*p, "/?")) {  /* regular expression */
        !            13:                c = *p;
        !            14:                redir = (c == '/');
        !            15:                reflag = 1;
        !            16:                p++;
        !            17:                if (*p == '\n' || *p == c) return(0);
        !            18:                q = re;
        !            19:                while(*p != c && *p != '\n') *q++ = *p++;
        !            20:                *q = '\0';
        !            21:                return(0);
        !            22:        }
        !            23:        
        !            24:        if (*p == '!') { /* shell escape */
        !            25:                for (q = p; *q != '\n'; q++) ;
        !            26:                *q = '\0';
        !            27:                system(p+1);
        !            28:                return(0);
        !            29:        }
        !            30:        
        !            31:        if (*p == '\n') {
        !            32:                cmd = '\n';
        !            33:                return(0);
        !            34:        }
        !            35:        
        !            36:        if (*p == ':') {
        !            37:                colonflag++;
        !            38:        }
        !            39:        
        !            40:        while (*p != '\n') {    /* decode item by item */
        !            41:        
        !            42:                if (number(*p)) {       /* decimal number */
        !            43:                        if(integ) {
        !            44:                                error("Too many numbers");
        !            45:                                return(1);
        !            46:                        }
        !            47:                        integ = readint(&p);
        !            48:                        continue;
        !            49:                }
        !            50:                
        !            51:                if (varchar(*p) || eqany(*p, COMMANDS)) { 
        !            52:                                        /* proc, variable or command */
        !            53:                        if (cmd != '\0') {
        !            54:                                p = cpall(args, p);
        !            55:                                continue;
        !            56:                        }
        !            57:                        q = p;
        !            58:                        while (varchar(*q) || number(*q) || eqany(*q,COMMANDS))
        !            59:                                q++;
        !            60:                        if (*q == '(') {        /* procedure call */
        !            61:                                if (proc[0] != '\0') {
        !            62:                                        error("Too many procedure calls");
        !            63:                                        return(1);
        !            64:                                }
        !            65:                                scallf = 1;
        !            66:                                p = cpname(proc, p);
        !            67:                                p = cpall(args, p);
        !            68:                                continue;
        !            69:                        }
        !            70:                        if (*q == ':') {        /* procedure name */
        !            71:                                colonflag++;
        !            72:                                p = cpname(proc, p);
        !            73:                                continue;
        !            74:                        }
        !            75:                        if (*q == '$') {        /* variable name */
        !            76:                                p = cpname(var, p);
        !            77:                                continue;
        !            78:                        }
        !            79:                        if (((q-p == 1 && eqany(*p,COMMANDS) && 
        !            80:                                (proc[0]=='\0' || eqany(*p, "abcd"))) ||
        !            81:                                (integ && eqany(*p,COMMANDS))|| eqany(*p, "+-")) 
        !            82:                                && !(*p=='-' && *(p+1) == '>'))
        !            83:                                                        {  /* command */
        !            84:                                cmd = *p++;
        !            85:                                if (eqany(cmd, "acers")) {
        !            86:                                        while(*p == ' ')
        !            87:                                                p++;
        !            88:                                        p = cpall(args, p);
        !            89:                                }
        !            90:                                continue;
        !            91:                        }
        !            92:                        /* otherwise, its a variable */
        !            93:                        if (var[0] != '\0') {
        !            94:                                error("Too many variable names");
        !            95:                                return(1);
        !            96:                        }
        !            97:                        p = cpname(var, p);
        !            98:                        if (*p == '\n') {
        !            99:                                cmd = '/';
        !           100:                                continue;
        !           101:                        }
        !           102:                        if (cmd == '\0') cmd = *p ? *p : '/';
        !           103:                        p++;
        !           104:                        p = cpall(args,p);
        !           105:                        continue;
        !           106:                }
        !           107:                p++;    /* otherwise ignore p */
        !           108:        }
        !           109:        return(0);
        !           110: }

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