Return to renum.c CVS log

Up to [Research Unix] / researchv10no / cmd / basic / bas

Annotation of researchv10no/cmd/basic/bas/renum.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include "ctype.h"
        !             3: #include "typedef.h"
        !             4: #include "basic.h"
        !             5: #include "tokens.h"
        !             6: 
        !             7: static int     rencnt;
        !             8: static Lnr     renbase, renincr, startln, endln;
        !             9: static int     i;
        !            10: 
        !            11: char   *outlnr();
        !            12: Lnr    cvtlnr(), newlnr();
        !            13: 
        !            14: 
        !            15: /*
        !            16:  * renumber --- renumber all stored lines
        !            17:  */
        !            18: 
        !            19: renumber(line1, incr, brange, erange)
        !            20: Lnr    line1;
        !            21: Lnr    incr;
        !            22: Lnr    brange;
        !            23: Lnr    erange;
        !            24: {
        !            25:        register Linep  s;
        !            26:        register Lnr    *p;
        !            27:        Lnr             lnr;
        !            28: 
        !            29:        renbase = line1;
        !            30:        renincr = incr;
        !            31:        startln = brange;
        !            32:        endln = erange;
        !            33:        i = 0;
        !            34:        p = (Lnr *)stkbase;
        !            35:        rencnt = 0;
        !            36:        lnr = line1;
        !            37: 
        !            38:        for ALL_LINES(s) {
        !            39:                *p++ = s->l_lnr;        /* remember the line number */
        !            40:                if ((char *)p >= stktop)
        !            41:                        err("too many lines");
        !            42:                ++rencnt;
        !            43:                lnr += incr;
        !            44:                if (lnr <= line1 || lnr > MAXLNR)
        !            45:                        err("invalid renumber parameters");
        !            46:                }
        !            47: 
        !            48:        lnr = line1;
        !            49:        for ALL_LINES(s) {
        !            50:                if (s->l_lnr >= startln && s->l_lnr <= endln) {
        !            51:                s->l_lnr = lnr;
        !            52:                lnr += incr;
        !            53:                }
        !            54:                }
        !            55:        for ALL_LINES(s) {
        !            56:                immed.l_lnr = s->l_lnr;
        !            57:                if (renumline(s))
        !            58:                        storeline(&immed);
        !            59:                }
        !            60: }
        !            61: 
        !            62: 
        !            63: /*
        !            64:  * renumline --- renumber the line pointed to by s
        !            65:  *              line numbers are always preceeded by:  
        !            66:  *                      THEN, GOTO, GOSUB
        !            67:  *              for an ON statement, there is a list of line numbers
        !            68:  *              following the GOTO or GOSUB
        !            69:  */
        !            70: 
        !            71: renumline(s)
        !            72: Linep  s;
        !            73: {
        !            74:        register char   *p, *q;
        !            75:        int             changed, onflag;
        !            76:        Lnr             l;
        !            77: 
        !            78:        changed = 0;
        !            79:        onflag = 0;
        !            80:        p = s->l_line;
        !            81:        for (q = immed.l_line, p = s->l_line; *p; ) {
        !            82:                switch ((*q++ = *p++)) {
        !            83:                case ON:
        !            84:                        ++onflag;
        !            85:                        break;
        !            86:                case COMMA:
        !            87:                        if (!onflag)
        !            88:                                break;
        !            89:                        /* fall thru if inside a ON ... GO ... */
        !            90:                case USING:
        !            91:                case THEN:
        !            92:                case ELSE:
        !            93:                case GOTO:
        !            94:                case GOSUB:
        !            95:                        if (isdigit(*p)) {
        !            96:                                inptr = p;
        !            97:                                l = cvtlnr();
        !            98:                                p = inptr;
        !            99:                                l = newlnr(l);
        !           100:                                q = outlnr(q, l);
        !           101:                                ++changed;
        !           102:                                }
        !           103:                        break;
        !           104:                case COLON:
        !           105:                case REM:
        !           106:                        onflag = 0;     /* reset onflag at end of statement */
        !           107:                        break;
        !           108:                        }
        !           109:                }
        !           110:        *q++ = 0;
        !           111:        *q = 0;
        !           112:        immed.l_len = q - immed.l_line + LINESIZE;
        !           113:        if (immed.l_len & 1)
        !           114:                ++immed.l_len;
        !           115:        return(changed);
        !           116: }
        !           117: 
        !           118: 
        !           119: /*
        !           120:  * outlnr --- convert specified line number to character string
        !           121:  */
        !           122: 
        !           123: char *outlnr(bp, lnr)
        !           124: char   *bp;
        !           125: Lnr    lnr;
        !           126: {
        !           127:        register char   *p;
        !           128: 
        !           129:        p = bp;
        !           130:        sprintf(p, "%u", lnr);
        !           131:        while (*p++)
        !           132:                ;
        !           133:        return (--p);
        !           134: }
        !           135: 
        !           136: 
        !           137: /*
        !           138:  * newlnr --- map old line number into a new one
        !           139:  */
        !           140: 
        !           141: Lnr newlnr(lnr)
        !           142: register Lnr   lnr;
        !           143: {
        !           144:        register Lnr    *p;
        !           145:        register Linep  s;
        !           146: 
        !           147:        p = (Lnr *)stkbase;
        !           148:        for ALL_LINES(s) {
        !           149:                if (*p++ == lnr)
        !           150:                        return(s->l_lnr);
        !           151:                        }
        !           152:        fprintf(stderr, "line %u not found\n", lnr);
        !           153:        return (lnr);
        !           154: }

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