Return to quote.c CVS log

Up to [Research Unix] / researchv10no / cmd / mk / src

Annotation of researchv10no/cmd/mk/src/quote.c, revision 1.1

1.1     ! root        1: #include       "mk.h"
        !             2: 
        !             3: /*
        !             4:        quoted stuff gets EBIT
        !             5: */
        !             6: 
        !             7: static
        !             8: squote(fd, srcp, destp)
        !             9:        char **srcp, **destp;
        !            10: {
        !            11:        register char *src = *srcp, *dest = *destp;
        !            12: 
        !            13:        while(*src != '\''){
        !            14:                if(*src == 0){
        !            15:                        char *s;
        !            16: 
        !            17:                        if(s = Frdline(fd)){
        !            18:                                inline++;
        !            19:                                *dest++ = '\n'|EBIT;
        !            20:                                strcpy(src, s);
        !            21:                                continue;
        !            22:                        } else {
        !            23:                                SYNERR(-1); Fprint(2, "missing closing '\n");
        !            24:                                break;
        !            25:                        }
        !            26:                }
        !            27:                *dest++ = *src++|EBIT;
        !            28:        }
        !            29:        *dest = 0;
        !            30:        if(*src)
        !            31:                src++;
        !            32:        *srcp = src;
        !            33:        *destp = dest;
        !            34: }
        !            35: 
        !            36: static
        !            37: dquote(fd, src, dest)
        !            38:        char **src, **dest;
        !            39: {
        !            40:        char *p = *src, *s = *dest;
        !            41:        char *t, carry;
        !            42:        Symtab *sym;
        !            43: 
        !            44:        while(*p != '"'){
        !            45:                switch(*p)
        !            46:                {
        !            47:                case 0:
        !            48:                        if(t = Frdline(fd)){
        !            49:                                inline++;
        !            50:                                *s++ = '\n'|EBIT;
        !            51:                                strcpy(p, t);
        !            52:                                continue;
        !            53:                        } else {
        !            54:                                SYNERR(-1); Fprint(2, "missing closing \"\n");
        !            55:                                break;
        !            56:                        }
        !            57:                        break;
        !            58:                case '\\':
        !            59:                        switch(*++p)
        !            60:                        {
        !            61:                        default:
        !            62:                                *s++ = '\\'|EBIT;
        !            63:                        case '\\': case '"':
        !            64:                        case '\'': case '$':
        !            65:                                *s++ = *p|EBIT;
        !            66:                        }
        !            67:                        p++;
        !            68:                        break;
        !            69:                case '$':
        !            70:                        varsub(&p, &s, EBIT);
        !            71:                        break;
        !            72:                default:
        !            73:                        *s++ = *p++|EBIT;
        !            74:                }
        !            75:        }
        !            76:        *s = 0;
        !            77:        if(*p)
        !            78:                p++;
        !            79:        *src = p;
        !            80:        *dest = s;
        !            81: }
        !            82: 
        !            83: quote1(fd, src, dest)
        !            84:        char *src, *dest;
        !            85: {
        !            86:        char *t;
        !            87: 
        !            88:        while(*src){
        !            89:                switch(*src)
        !            90:                {
        !            91:                case '\'':
        !            92:                        src++;
        !            93:                        squote(fd, &src, &dest);
        !            94:                        break;
        !            95:                case '\\':
        !            96:                        if(src[1]){
        !            97:                                *dest++ = *++src | EBIT;
        !            98:                                src++;
        !            99:                        } else if(t = Frdline(fd)){
        !           100:                                inline++;
        !           101:                                strcpy(src, t);
        !           102:                        }
        !           103:                        break;
        !           104:                default:
        !           105:                        *dest++ = *src++;
        !           106:                }
        !           107:        }
        !           108:        *dest = 0;
        !           109: }
        !           110: 
        !           111: quote2(fd, src, dest)
        !           112:        char *src, *dest;
        !           113: {
        !           114:        char *t;
        !           115: 
        !           116:        while(*src){
        !           117:                switch(*src)
        !           118:                {
        !           119:                case '"':
        !           120:                        src++;
        !           121:                        dquote(fd, &src, &dest);
        !           122:                        break;
        !           123:                case '\\':
        !           124:                        if(src[1]){
        !           125:                                *dest++ = *++src;
        !           126:                                src++;
        !           127:                        } else if(t = Frdline(fd)){
        !           128:                                inline++;
        !           129:                                strcpy(src, t);
        !           130:                        }
        !           131:                        break;
        !           132:                case '$':
        !           133:                        varsub(&src, &dest, 0);
        !           134:                        break;
        !           135:                default:
        !           136:                        *dest++ = *src++;
        !           137:                }
        !           138:        }
        !           139:        *dest = 0;
        !           140: }
        !           141: 
        !           142: static char *
        !           143: subsub(val, ext, dest, bit)
        !           144:        char *val, *ext, *dest;
        !           145: {
        !           146:        register char *s;
        !           147:        char *a, *b, *c, *d;
        !           148:        int na, nb, nc, nd, n;
        !           149:        int destsub = 0;
        !           150: 
        !           151:        /* prepare literals */
        !           152:        a = s = ext;
        !           153:        for(; *s && (*s != '=') && !PERCENT(*s); s++)
        !           154:                ;
        !           155:        na = s-a;
        !           156:        if(PERCENT(*s)) s++;
        !           157:        b = s;
        !           158:        for(; *s && (*s != '='); s++)
        !           159:                ;
        !           160:        nb = s-b;
        !           161:        if(*s == '=') s++;
        !           162:        c = s;
        !           163:        for(; *s && !PERCENT(*s); s++)
        !           164:                ;
        !           165:        nc = s-c;
        !           166:        if(PERCENT(*s)) s++, destsub = 1;
        !           167:        d = s;
        !           168:        for(; *s; s++)
        !           169:                ;
        !           170:        nd = s-d;
        !           171:        /* break into words, do sub */
        !           172:        while(*val){
        !           173:                for(s = val; *s && !SEP(*s); s++)
        !           174:                        ;
        !           175:                /* substitute in val..s */
        !           176:                if((memcmp(val, a, na) == 0) && (memcmp(s-nb, b, nb) == 0)){
        !           177: #define        DEST(s,n)       if(n) memcpy(dest,s,n), dest += n
        !           178:                        DEST(c, nc);
        !           179:                        n = (s-nb) - (val+na);
        !           180:                        if(destsub)
        !           181:                                DEST(val+na, n);
        !           182:                        DEST(d, nd);
        !           183:                } else
        !           184:                        while(val < s)
        !           185:                                *dest++ = (*val++&~EBIT)|bit;
        !           186:                /* clean up */
        !           187:                while(*s && SEP(*s))
        !           188:                        *dest++ = (*s++&~EBIT)|bit;
        !           189:                val = s;
        !           190:        }
        !           191:        return(dest);
        !           192: }
        !           193: 
        !           194: varsub(psrc, pdest, bit)
        !           195:        char **psrc, **pdest;
        !           196: {
        !           197:        char *t, carry;
        !           198:        Symtab *sym;
        !           199:        char *src = *psrc, *dest = *pdest;
        !           200:        char *v = 0, vc;
        !           201: 
        !           202:        if(*++src == '{'){
        !           203:                for(t = ++src; *src != '}'; src++)
        !           204:                        if(*src == 0){
        !           205:                                SYNERR(-1);
        !           206:                                Fprint(2, "missing '}'\n");
        !           207:                                Exit();
        !           208:                        }
        !           209:                v = shname(t);
        !           210:                if(src == v)
        !           211:                        v = 0;
        !           212:                else {
        !           213:                        if(*v != ':'){
        !           214:                                SYNERR(-1);
        !           215:                                Fprint(2, "bad variable name\n");
        !           216:                                Exit();
        !           217:                        }
        !           218:                        vc = *v;
        !           219:                        *v = 0;
        !           220:                }
        !           221:                *src++ = carry = 0;
        !           222:        } else {
        !           223:                src = shname(t = src);
        !           224:                carry = *src;
        !           225:                *src = 0;
        !           226:        }
        !           227:        if(sym = symlook(t, S_VAR, (char *)0)){
        !           228:                if(v){
        !           229: char buf[BIGBLOCK]; strcpy(buf, v+1); lex(-1, buf);
        !           230:                        dest = subsub(sym->value, buf, dest, bit);
        !           231:                        *v = vc;
        !           232:                } else
        !           233:                        for(t = sym->value; *t; )
        !           234:                                *dest++ = *t++|bit;
        !           235:        }
        !           236:        if(carry)
        !           237:                *src = carry;
        !           238:        *psrc = src;
        !           239:        *pdest = dest;
        !           240: }

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