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

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.