Return to reg.c CVS log

Up to [MW Coherent from dump] / coherent / b / bin / troff

Annotation of coherent/b/bin/troff/reg.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * reg.c
        !             3:  * Nroff/Troff.
        !             4:  * Register manipulation.
        !             5:  */
        !             6: 
        !             7: #include "roff.h"
        !             8: 
        !             9: /*
        !            10:  * Return a pointer to a number register of the given name.
        !            11:  */
        !            12: REG *
        !            13: getnreg(name) char name[2];
        !            14: {
        !            15:        register REG *rp;
        !            16: 
        !            17:        if ((rp = findreg(name, RNUMR)) == NULL) {
        !            18:                rp = makereg(name, RNUMR);
        !            19:                rp->n_reg.r_nval = 0;
        !            20:                rp->n_reg.r_form = '1';
        !            21:                rp->n_reg.r_incr = 1;
        !            22:        }
        !            23:        return rp;
        !            24: }
        !            25: 
        !            26: /*
        !            27:  * Create a register of the given name and type.  If one
        !            28:  * already exists, remove it.
        !            29:  */
        !            30: REG    *
        !            31: makereg(name, type) char name[2]; int type;
        !            32: {
        !            33:        REG **rpp;
        !            34:        register REG *rp;
        !            35:        register MAC *mp, *lmp;
        !            36: 
        !            37:        if (rp = findreg(name, type)) {
        !            38: #if    (DDEBUG & DBGREGS)
        !            39:                printd(DBGREGS,"makereg: deleting old register %c%c\n",
        !            40:                        name[0], name[1]);
        !            41: #endif
        !            42:                if (rp->t_reg.r_type == RTEXT) {
        !            43:                        rp->t_reg.r_maxh = 0;
        !            44:                        rp->t_reg.r_maxw = 0;
        !            45:                        mp = rp->t_reg.r_macd.t_div.m_next;
        !            46:                        while (mp) {
        !            47:                                if (mp->t_div.m_type==MTEXT &&
        !            48:                                    mp->t_div.m_core!=NULL)
        !            49:                                        nfree(mp->t_div.m_core);
        !            50:                                lmp = mp;
        !            51:                                mp = mp->t_div.m_next;
        !            52:                                nfree(lmp);
        !            53:                        }
        !            54:                }
        !            55:        } else {
        !            56: #if    (DDEBUG & DBGREGS)
        !            57:                printd(DBGREGS,"makereg: creating register %c%c, type %d\n",
        !            58:                                name[0],name[1],type);
        !            59: #endif
        !            60:                rpp = &regt[hash(name)];
        !            61:                rp = (REG *) nalloc(sizeof *rp);
        !            62:                rp->t_reg.r_type = type;
        !            63:                rp->t_reg.r_name[0] = name[0];
        !            64:                rp->t_reg.r_name[1] = name[1];
        !            65:                rp->t_reg.r_maxh = 0;
        !            66:                rp->t_reg.r_maxw = 0;
        !            67:                rp->t_reg.r_next = *rpp;
        !            68:                *rpp = rp;
        !            69:        }
        !            70:        return rp;
        !            71: }
        !            72: 
        !            73: /*
        !            74:  * Remove the given text register or request.
        !            75:  * Return 1 if the register is found, else 0.
        !            76:  */
        !            77: reltreg(name) char name[2];
        !            78: {
        !            79:        MAC *lmp;
        !            80:        register MAC *mp;
        !            81:        register REG *rp, **lrp;
        !            82: 
        !            83: #if    (DDEBUG & DBGREGS)
        !            84:        printd(DBGREGS, "reltreg: removing text register %c%c\n", name[0],name[1]);
        !            85: #endif
        !            86:        for (lrp = &regt[hash(name)]; rp = *lrp; lrp = &rp->t_reg.r_next) {
        !            87:                if (rp->n_reg.r_name[0]==name[0] &&
        !            88:                    rp->n_reg.r_name[1]==name[1]) {
        !            89:                        if (rp->n_reg.r_type != RTEXT)
        !            90:                                continue;
        !            91:                        mp = rp->t_reg.r_macd.t_div.m_next;
        !            92:                        while (mp) {
        !            93:                                if (mp->t_div.m_type==MTEXT &&
        !            94:                                    mp->t_div.m_core!=NULL)
        !            95:                                        nfree(mp->t_div.m_core);
        !            96:                                lmp = mp;
        !            97:                                mp = mp->t_div.m_next;
        !            98:                                nfree(lmp);
        !            99:                        }
        !           100:                        *lrp = rp->t_reg.r_next;
        !           101:                        nfree(rp);
        !           102:                        return 1;
        !           103:                }
        !           104:        }
        !           105:        return 0;
        !           106: }
        !           107: 
        !           108: /*
        !           109:  * Remove the given number register.
        !           110:  * Return 1 if we found it, else 0.
        !           111:  */
        !           112: relnreg(name) char name[2];
        !           113: {
        !           114:        register REG *rp, **lrp;
        !           115: 
        !           116: #if    (DDEBUG & DBGREGS)
        !           117:        printd(DBGREGS, "relnreg: removing number register %c%c\n",
        !           118:                name[0],name[1]);
        !           119: #endif
        !           120:        for (lrp = &regt[hash(name)]; rp = *lrp; lrp = &rp->t_reg.r_next) {
        !           121:                if (rp->n_reg.r_name[0]==name[0] &&
        !           122:                    rp->n_reg.r_name[1]==name[1]) {
        !           123:                        if (rp->n_reg.r_type == RNUMR) {
        !           124:                                *lrp = rp->t_reg.r_next;
        !           125:                                nfree(rp);
        !           126:                                return 1;
        !           127:                        }
        !           128:                }
        !           129:        }
        !           130:        return 0;
        !           131: }
        !           132: 
        !           133: /*
        !           134:  * Given a register name and a register type,
        !           135:  * return a pointer to the register if it exists or NULL if not.
        !           136:  */
        !           137: REG *
        !           138: findreg(name, type) char name[2]; int type;
        !           139: {
        !           140:        register REG *rp;
        !           141: 
        !           142: #if    (DDEBUG & DBGREGX)
        !           143:        printd(DBGREGX, "findreg: looking for register %c%c, type %d --",
        !           144:                        name[0],name[1],type);
        !           145: #endif
        !           146:        for (rp=regt[hash(name)]; rp; rp=rp->t_reg.r_next)
        !           147:                if (rp->n_reg.r_name[0]==name[0] &&
        !           148:                    rp->n_reg.r_name[1]==name[1])
        !           149:                        if (rp->n_reg.r_type == type) {
        !           150: #if    (DDEBUG & DBGREGX)
        !           151:                                printd(DBGREGX, "found\n");
        !           152: #endif
        !           153:                                return rp;
        !           154:                        }
        !           155: #if    (DDEBUG & DBGREGX)
        !           156:        printd(DBGREGX, "not found\n");
        !           157: #endif
        !           158:        return NULL;
        !           159: }
        !           160: 
        !           161: /*
        !           162:  * Convert a string to a two character register name.
        !           163:  */
        !           164: argname(str, name) register char *str; char name[2];
        !           165: {
        !           166:        if ((name[0] = str[0]) == '\0')
        !           167:                name[1] = '\0';
        !           168:        else
        !           169:                name[1] = str[1];
        !           170: }
        !           171: 
        !           172: /* end of reg.c */

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