cmd/troff/n3.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*  Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*    All Rights Reserved   */

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * troff3.c
 *
 * macro and string routines, storage allocation
 */


#include "tdef.h"
#ifdef NROFF
#include "tw.h"
#endif
#include "ext.h"

#define MHASH(x)    ((x>>6)^x)&0177
struct  contab *mhash[128]; /* 128 == the 0177 on line above */
#define blisti(i)   (((i)-ENV_BLK*BLK) / BLK)
filep   blist[NBLIST];
tchar   *argtop;
int pagech = '%';
int strflg;

#ifdef  INCORE
    tchar *wbuf;
    tchar corebuf[(ENV_BLK + NBLIST + 1) * BLK];
#else
    tchar wbuf[BLK];
    tchar rbuf[BLK];
#endif

int
caseig()
{
    int i;
    filep oldoff;

    oldoff = offset;
    offset = 0;
    i = copyb();
    offset = oldoff;
    if (i != '.')
        control(i, 1);

    return (0);
}

int
casern()
{
    int i, j;

    lgf++;
    skip();
    if ((i = getrq()) == 0 || (oldmn = findmn(i)) < 0)
        return (0);
    skip();
    clrmn(findmn(j = getrq()));
    if (j) {
        munhash(&contab[oldmn]);
        contab[oldmn].rq = j;
        maddhash(&contab[oldmn]);
    }

    return (0);
}

int
maddhash(rp)
struct contab *rp;
{
    struct contab **hp;

    if (rp->rq == 0)
        return (0);
    hp = &mhash[MHASH(rp->rq)];
    rp->link = *hp;
    *hp = rp;

    return (0);
}

int
munhash(mp)
struct contab *mp;
{
    struct contab *p;
    struct contab **lp;

    if (mp->rq == 0)
        return (0);
    lp = &mhash[MHASH(mp->rq)];
    p = *lp;
    while (p) {
        if (p == mp) {
            *lp = p->link;
            p->link = 0;
            return (0);
        }
        lp = &p->link;
        p = p->link;
    }

    return (0);
}

int
mrehash()
{
    struct contab *p;
    int i;

    for (i=0; i<128; i++)
        mhash[i] = 0;
    for (p=contab; p < &contab[NM]; p++)
        p->link = 0;
    for (p=contab; p < &contab[NM]; p++) {
        if (p->rq == 0)
            continue;
        i = MHASH(p->rq);
        p->link = mhash[i];
        mhash[i] = p;
    }

    return (0);
}

int
caserm()
{
    int j;

    lgf++;
    while (!skip() && (j = getrq()) != 0)
        clrmn(findmn(j));
    lgf--;

    return (0);
}


int
caseas()
{
    app++;
    caseds();

    return (0);
}


int
caseds()
{
    ds++;
    casede();

    return (0);
}


int
caseam()
{
    app++;
    casede();

    return (0);
}


int
casede()
{
    int i, req;
    filep savoff;
    extern filep finds();

    if (dip != d)
        wbfl();
    req = '.';
    lgf++;
    skip();
    if ((i = getrq()) == 0)
        goto de1;
    if ((offset = finds(i)) == 0)
        goto de1;
    if (ds)
        copys();
    else
        req = copyb();
    wbfl();
    clrmn(oldmn);
    if (newmn) {
        if (contab[newmn].rq)
            munhash(&contab[newmn]);
        contab[newmn].rq = i;
        maddhash(&contab[newmn]);
    }
    if (apptr) {
        savoff = offset;
        offset = apptr;
        wbt((tchar) IMP);
        offset = savoff;
    }
    offset = dip->op;
    if (req != '.')
        control(req, 1);
de1:
    ds = app = 0;
    return (0);
}


int
findmn(i)
int i;
{
    struct contab *p;

    for (p = mhash[MHASH(i)]; p; p = p->link)
        if (i == p->rq)
            return(p - contab);
    return(-1);
}


int
clrmn(i)
int i;
{
    if (i >= 0) {
        if (contab[i].mx)
            ffree((filep)contab[i].mx);
        munhash(&contab[i]);
        contab[i].rq = 0;
        contab[i].mx = 0;
        contab[i].f = 0;
    }

    return (0);
}


filep finds(mn)
int mn;
{
    int i;
    filep savip;
    extern filep alloc();
    extern filep incoff();

    oldmn = findmn(mn);
    newmn = 0;
    apptr = (filep)0;
    if (app && oldmn >= 0 && contab[oldmn].mx) {
        savip = ip;
        ip = (filep)contab[oldmn].mx;
        oldmn = -1;
        while ((i = rbf()) != 0)
            ;
        apptr = ip;
        if (!diflg)
            ip = incoff(ip);
        nextb = ip;
        ip = savip;
    } else {
        for (i = 0; i < NM; i++) {
            if (contab[i].rq == 0)
                break;
        }
        if (i == NM || (nextb = alloc()) == 0) {
            app = 0;
            if (macerr++ > 1)
                done2(02);
            errprint(gettext("Too many (%d) string/macro names"),
                     NM);
            edone(04);
            return(offset = 0);
        }
        contab[i].mx = (unsigned) nextb;
        if (!diflg) {
            newmn = i;
            if (oldmn == -1)
                contab[i].rq = -1;
        } else {
            contab[i].rq = mn;
            maddhash(&contab[i]);
        }
    }
    app = 0;
    return(offset = nextb);
}


int
skip()          /*skip over blanks; return nlflg*/
{
    tchar i;

    while (cbits(i = getch()) == ' ')
        ;
    ch = i;
    return(nlflg);
}


int
copyb()
{
    int i, j, state;
    tchar ii;
    int req, k;
    filep savoff;

    if (skip() || !(j = getrq()))
        j = '.';
    req = j;
    k = j >> BYTE;
    j &= BYTEMASK;
    copyf++;
    flushi();
    nlflg = 0;
    state = 1;

/* state 0  eat up
 * state 1  look for .
 * state 2  look for first char of end macro
 * state 3  look for second char of end macro
 */

    while (1) {
        i = cbits(ii = getch());
        if (state == 3) {
            if (i == k)
                break;
            if (!k) {
                ch = ii;
                i = getach();
                ch = ii;
                if (!i)
                    break;
            }
            state = 0;
            goto c0;
        }
        if (i == '\n') {
            state = 1;
            nlflg = 0;
            goto c0;
        }
        if (state == 1 && i == '.') {
            state++;
            savoff = offset;
            goto c0;
        }
        if ((state == 2) && (i == j)) {
            state++;
            goto c0;
        }
        state = 0;
c0:
        if (offset)
            wbf(ii);
    }
    if (offset) {
        wbfl();
        offset = savoff;
        wbt((tchar)0);
    }
    copyf--;
    return(req);
}


int
copys()
{
    tchar i;

    copyf++;
    if (skip())
        goto c0;
    if (cbits(i = getch()) != '"')
        wbf(i);
    while (cbits(i = getch()) != '\n')
        wbf(i);
c0:
    wbt((tchar)0);
    copyf--;

    return (0);
}


filep alloc()       /*return free blist[] block in nextb*/
{
    int i;
    filep j;

    for (i = 0; i < NBLIST; i++) {
        if (blist[i] == 0)
            break;
    }
    if (i == NBLIST) {
        j = 0;
    } else {
        blist[i] = -1;
        j = (filep)i * BLK + ENV_BLK * BLK;
    }
#ifdef  DEBUG
    if (debug & DB_ALLC) {
        char cc1, cc2;
        fdprintf(stderr, "alloc: ");
        if (oldmn >= 0 && oldmn < NM) {
            cc1 = contab[oldmn].rq & 0177;
            if ((cc2 = (contab[oldmn].rq >> BYTE) & 0177) == 0)
                cc2 = ' ';
            fdprintf(stderr, "oldmn %d %c%c, ", oldmn, cc1, cc2);
        }
        fdprintf(stderr, "newmn %d; nextb was %x, will be %x\n",
            newmn, nextb, j);
    }
#endif  /* DEBUG */
    return(nextb = j);
}


int
ffree(i)        /*free blist[i] and blocks pointed to*/
filep i;
{
    int j;

    while (blist[j = blisti(i)] != (unsigned) ~0) {
        i = (filep) blist[j];
        blist[j] = 0;
    }
    blist[j] = 0;

    return (0);
}

int
wbt(i)
tchar i;
{
    wbf(i);
    wbfl();

    return (0);
}


int
wbf(i)          /*store i into blist[offset] (?) */
tchar i;
{
    int j;

    if (!offset)
        return (0);
    if (!woff) {
        woff = offset;
#ifdef INCORE
        wbuf = &corebuf[woff];  /* INCORE only */
#endif
        wbfi = 0;
    }
    wbuf[wbfi++] = i;
    if (!((++offset) & (BLK - 1))) {
        wbfl();
        j = blisti(--offset);
        if (j < 0 || j >= NBLIST) {
            errprint(gettext("Out of temp file space"));
            done2(01);
        }
        if (blist[j] == (unsigned) ~0) {
            if (alloc() == 0) {
                errprint(gettext("Out of temp file space"));
                done2(01);
            }
            blist[j] = (unsigned)(nextb);
        }
        offset = ((filep)blist[j]);
    }
    if (wbfi >= BLK)
        wbfl();

    return (0);
}


int
wbfl()          /*flush current blist[] block*/
{
    if (woff == 0)
        return (0);
#ifndef INCORE
    lseek(ibf, ((long)woff) * sizeof(tchar), 0);
    write(ibf, (char *)wbuf, wbfi * sizeof(tchar));
#endif
    if ((woff & (~(BLK - 1))) == (roff & (~(BLK - 1))))
        roff = -1;
    woff = 0;

    return (0);
}


tchar rbf()     /*return next char from blist[] block*/
{
    tchar i;
    filep j, p;
    extern filep incoff();

    if (ip == NBLIST*BLK) {     /* for rdtty */
        if (j = rdtty())
            return(j);
        else
            return(popi());
    }
    /* this is an inline expansion of rbf0: dirty! */
#ifndef INCORE
    j = ip & ~(BLK - 1);
    if (j != roff) {
        roff = j;
        lseek(ibf, (long)j * sizeof(tchar), 0);
        if (read(ibf, (char *)rbuf, BLK * sizeof(tchar)) <= 0)
            i = 0;
        else
            i = rbuf[ip & (BLK-1)];
    } else
        i = rbuf[ip & (BLK-1)];
#else
    i = corebuf[ip];
#endif
    /* end of rbf0 */
    if (i == 0) {
        if (!app)
            i = popi();
        return(i);
    }
    /* this is an inline expansion of incoff: also dirty */
    p = ++ip;
    if ((p & (BLK - 1)) == 0) {
        if ((ip = blist[blisti(p-1)]) == (unsigned) ~0) {
            errprint(gettext("Bad storage allocation"));
            ip = 0;
            done2(-5);
        }
        /* this was meant to protect against people removing
         * the macro they were standing on, but it's too
         * sensitive to block boundaries.
         * if (ip == 0) {
         *  errprint(gettext("Block removed while in use"));
         *  done2(-6);
         * }
         */
    }
    return(i);
}


tchar rbf0(p)
filep p;
{
#ifndef INCORE
    filep i;

    if ((i = p & ~(BLK - 1)) != roff) {
        roff = i;
        lseek(ibf, (long)roff * sizeof(tchar), 0);
        if (read(ibf, (char *)rbuf, BLK * sizeof(tchar)) == 0)
            return(0);
    }
    return(rbuf[p & (BLK-1)]);
#else
    return(corebuf[p]);
#endif
}


filep incoff(p)     /*get next blist[] block*/
filep p;
{
    p++;
    if ((p & (BLK - 1)) == 0) {
        if ((p = blist[blisti(p-1)]) == (unsigned) ~0) {
            errprint(gettext("Bad storage allocation"));
            done2(-5);
        }
    }
    return(p);
}


tchar popi()
{
    struct s *p;

    if (frame == stk)
        return(0);
    if (strflg)
        strflg--;
    p = nxf = frame;
    p->nargs = 0;
    frame = p->pframe;
    ip = p->pip;
    pendt = p->ppendt;
    lastpbp = p->lastpbp;
    return(p->pch);
}

/*
 *  test that the end of the allocation is above a certain location
 *  in memory
 */
#define SPACETEST(base, size) while ((enda - (size)) <= (char *)(base)){setbrk(DELTA);}

int
pushi(newip, mname)
filep newip;
int mname;
{
    struct s *p;
    extern char *setbrk();

    SPACETEST(nxf, sizeof(struct s));
    p = nxf;
    p->pframe = frame;
    p->pip = ip;
    p->ppendt = pendt;
    p->pch = ch;
    p->lastpbp = lastpbp;
    p->mname = mname;
    lastpbp = pbp;
    pendt = ch = 0;
    frame = nxf;
    if (nxf->nargs == 0)
        nxf += 1;
    else
        nxf = (struct s *)argtop;
    return(ip = newip);
}


char    *setbrk(x)
int x;
{
    char    *i, *k;
    int j;
    char    *sbrk();

    if ((i = sbrk(x)) == (char *) -1) {
        errprint(gettext("Core limit reached"));
        edone(0100);
    }
    if (j = (unsigned)i % sizeof(int)) {    /*check alignment for 3B*/
        j = sizeof(int) - j;        /*only init calls should need this*/
        if ((k = sbrk(j)) == (char *) -1) {
            errprint("Core limit reached");
            edone(0100);
        }
        if (k != i + x) {   /*there must have been an intervening sbrk*/
            errprint ("internal error in setbrk: i=%x, j=%d, k=%x",
                i, j, k);
            edone(0100);
        }
        i += j;
    }
    enda = i + x;
    return(i);
}


int
getsn()
{
    int i;

    if ((i = getach()) == 0)
        return(0);
    if (i == '(')
        return(getrq());
    else
        return(i);
}


int
setstr()
{
    int i, j;

    lgf++;
    if ((i = getsn()) == 0 || (j = findmn(i)) == -1 || !contab[j].mx) {
        lgf--;
        return(0);
    } else {
        SPACETEST(nxf, sizeof(struct s));
        nxf->nargs = 0;
        strflg++;
        lgf--;
        return pushi((filep)contab[j].mx, i);
    }
}


int
collect()
{
    int j;
    tchar i;
    tchar *strp;
    tchar * lim;
    tchar * *argpp, **argppend;
    int quote;
    struct s *savnxf;

    copyf++;
    nxf->nargs = 0;
    savnxf = nxf;
    if (skip())
        goto rtn;

    {
        char *memp;
        memp = (char *)savnxf;
        /*
         *  1 s structure for the macro descriptor
         *  APERMAC tchar *'s for pointers into the strings
         *  space for the tchar's themselves
         */
        memp += sizeof(struct s);
        /*
         *  CPERMAC (the total # of characters for ALL arguments)
         *  to a macros, has been carefully chosen
         *  so that the distance between stack frames is < DELTA
         */
#define CPERMAC 200
#define APERMAC 9
        memp += APERMAC * sizeof(tchar *);
        memp += CPERMAC * sizeof(tchar);
        nxf = (struct s*)memp;
    }
    lim = (tchar *)nxf;
    argpp = (tchar **)(savnxf + 1);
    argppend = &argpp[APERMAC];
    SPACETEST(argppend, sizeof(tchar *));
    strp = (tchar *)argppend;
    /*
     *  Zero out all the string pointers before filling them in.
     */
    for (j = 0; j < APERMAC; j++){
        argpp[j] = (tchar *)0;
    }
#if 0
    errprint("savnxf=0x%x,nxf=0x%x,argpp=0x%x,strp=argppend=0x%x,lim=0x%x,enda=0x%x",
        savnxf, nxf, argpp, strp, lim, enda);
#endif
    strflg = 0;
    while ((argpp != argppend) && (!skip())) {
        *argpp++ = strp;
        quote = 0;
        if (cbits(i = getch()) == '"')
            quote++;
        else
            ch = i;
        while (1) {
            i = getch();
            if (nlflg || (!quote && cbits(i) == ' '))
                break;
            if (   quote
                && (cbits(i) == '"')
                && (cbits(i = getch()) != '"')) {
                ch = i;
                break;
            }
            *strp++ = i;
            if (strflg && strp >= lim) {
#if 0
                errprint("strp=0x%x, lim = 0x%x",
                    strp, lim);
#endif
                errprint(gettext("Macro argument too long"));
                copyf--;
                edone(004);
            }
            SPACETEST(strp, 3 * sizeof(tchar));
        }
        *strp++ = 0;
    }
    nxf = savnxf;
    nxf->nargs = argpp - (tchar **)(savnxf + 1);
    argtop = strp;
rtn:
    copyf--;

    return (0);
}


int
seta()
{
    int i;

    i = cbits(getch()) - '0';
    if (i > 0 && i <= APERMAC && i <= frame->nargs)
        pushback(*(((tchar **)(frame + 1)) + i - 1));

    return (0);
}


int
caseda()
{
    app++;
    casedi();

    return (0);
}


int
casedi()
{
    int i, j;
    int *k;

    lgf++;
    if (skip() || (i = getrq()) == 0) {
        if (dip != d)
            wbt((tchar)0);
        if (dilev > 0) {
            numtab[DN].val = dip->dnl;
            numtab[DL].val = dip->maxl;
            dip = &d[--dilev];
            offset = dip->op;
        }
        goto rtn;
    }
    if (++dilev == NDI) {
        --dilev;
        errprint(gettext("Diversions nested too deep"));
        edone(02);
    }
    if (dip != d)
        wbt((tchar)0);
    diflg++;
    dip = &d[dilev];
    dip->op = finds(i);
    dip->curd = i;
    clrmn(oldmn);
    k = (int *) & dip->dnl;
    for (j = 0; j < 10; j++)
        k[j] = 0;   /*not op and curd*/
rtn:
    app = 0;
    diflg = 0;

    return (0);
}


int
casedt()
{
    lgf++;
    dip->dimac = dip->ditrap = dip->ditf = 0;
    skip();
    dip->ditrap = vnumb((int *)0);
    if (nonumb)
        return (0);
    skip();
    dip->dimac = getrq();

    return (0);
}


int
casetl()
{
    int j;
    int w[3];
    tchar buf[LNSIZE];
    tchar *tp;
    tchar i, delim;

    dip->nls = 0;
    skip();
    if (ismot(delim = getch())) {
        ch = delim;
        delim = '\'';
    } else
        delim = cbits(delim);
    tp = buf;
    numtab[HP].val = 0;
    w[0] = w[1] = w[2] = 0;
    j = 0;
    while (cbits(i = getch()) != '\n') {
        if (cbits(i) == cbits(delim)) {
            if (j < 3)
                w[j] = numtab[HP].val;
            numtab[HP].val = 0;
            j++;
            *tp++ = 0;
        } else {
            if (cbits(i) == pagech) {
                setn1(numtab[PN].val, numtab[findr('%')].fmt,
                      i&SFMASK);
                continue;
            }
            numtab[HP].val += width(i);
            if (tp < &buf[LNSIZE-10])
                *tp++ = i;
        }
    }
    if (j<3)
        w[j] = numtab[HP].val;
    *tp++ = 0;
    *tp++ = 0;
    *tp++ = 0;
    tp = buf;
#ifdef NROFF
    horiz(po);
#endif
    while (i = *tp++)
        pchar(i);
    if (w[1] || w[2])
        horiz(j = quant((lt - w[1]) / 2 - w[0], HOR));
    while (i = *tp++)
        pchar(i);
    if (w[2]) {
        horiz(lt - w[0] - w[1] - w[2] - j);
        while (i = *tp++)
            pchar(i);
    }
    newline(0);
    if (dip != d) {
        if (dip->dnl > dip->hnl)
            dip->hnl = dip->dnl;
    } else {
        if (numtab[NL].val > dip->hnl)
            dip->hnl = numtab[NL].val;
    }

    return (0);
}


int
casepc()
{
    pagech = chget(IMP);

    return (0);
}


int
casepm()
{
    int i, k;
    char    *p;
    int xx, cnt, tcnt, kk, tot;
    filep j;
    char    pmline[10];

    kk = cnt = tcnt = 0;
    tot = !skip();
    for (i = 0; i < NM; i++) {
        if ((xx = contab[i].rq) == 0 || contab[i].mx == 0)
            continue;
        tcnt++;
        p = pmline;
        j = (filep) contab[i].mx;
        k = 1;
        while ((j = blist[blisti(j)]) != (unsigned) ~0) {
            k++;
        }
        cnt++;
        kk += k;
        if (!tot) {
            *p++ = xx & 0177;
            if (!(*p++ = (xx >> BYTE) & 0177))
                *(p - 1) = ' ';
            *p++ = 0;
            fdprintf(stderr, "%s %d\n", pmline, k);
        }
    }
    fdprintf(stderr, "pm: total %d, macros %d, space %d\n", tcnt, cnt, kk);

    return (0);
}

int
stackdump() /* dumps stack of macros in process */
{
    struct s *p;

    if (frame != stk) {
        for (p = frame; p != stk; p = p->pframe)
            fdprintf(stderr, "%c%c ", p->mname&0177, (p->mname>>BYTE)&0177);
        fdprintf(stderr, "\n");
    }

    return (0);
}