Return to deco.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / B / src / bed

Annotation of 43BSD/contrib/B/src/bed/deco.c, revision 1.1

1.1     ! root        1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1984. */
        !             2: static char rcsid[] = "$Header: deco.c,v 2.3 84/07/19 11:45:12 guido Exp $";
        !             3: 
        !             4: /*
        !             5:  * B editor -- Delete and copy commands.
        !             6:  */
        !             7: 
        !             8: #include <ctype.h>
        !             9: 
        !            10: #include "b.h"
        !            11: #include "erro.h"
        !            12: #include "bobj.h"
        !            13: #include "node.h"
        !            14: #include "gram.h"
        !            15: #include "supr.h"
        !            16: #include "queu.h"
        !            17: 
        !            18: 
        !            19: value copyout(); /* Forward */
        !            20: 
        !            21: /*
        !            22:  * DELETE and COPY currently share a buffer, called the copy buffer.
        !            23:  * (Physically, there is one such a buffer in each environment.)
        !            24:  * In ordinary use, the copy buffer receives the text deleted by the
        !            25:  * last DELETE command (unless it just removed a hole); the COPY command
        !            26:  * can then be used (with the focus on a hole) to copy it back.
        !            27:  * When some portion of text must be held while other text is deleted,
        !            28:  * the COPY command again, but now with the focus on the text to be held,
        !            29:  * copies it to the buffer and deleted text won't overwrite the buffer
        !            30:  * until it is copied back at least once.
        !            31:  * If the buffer holds text that was explicitly copied out but not yet
        !            32:  * copied back in, it is saved on a file when the editor exits, so it can
        !            33:  * be used in the next session; but this is not true for text implicitly
        !            34:  * placed in the buffer through DELETE.
        !            35:  */
        !            36: 
        !            37: /*
        !            38:  * Delete command -- delete the text in the focus, or delete the hole
        !            39:  * if it is only a hole.
        !            40:  */
        !            41: 
        !            42: Visible bool
        !            43: delete(ep)
        !            44:        register environ *ep;
        !            45: {
        !            46:        higher(ep);
        !            47:        shrink(ep);
        !            48:        if (ishole(ep))
        !            49:                return delhole(ep);
        !            50:        if (!ep->copyflag) {
        !            51:                release(ep->copybuffer);
        !            52:                ep->copybuffer = copyout(ep);
        !            53:        }
        !            54:        return delbody(ep);
        !            55: }
        !            56: 
        !            57: 
        !            58: /*
        !            59:  * Delete the focus under the assumption that it contains some text.
        !            60:  */
        !            61: 
        !            62: Visible bool
        !            63: delbody(ep)
        !            64:        register environ *ep;
        !            65: {
        !            66:        ep->changed = Yes;
        !            67: 
        !            68:        subgrow(ep, No); /* Don't ignore spaces */
        !            69:        switch (ep->mode) {
        !            70: 
        !            71:        case SUBRANGE:
        !            72:                if (ep->s1&1)
        !            73:                        return delfixed(ep);
        !            74:                return delvarying(ep);
        !            75: 
        !            76:        case SUBSET:
        !            77:                return delsubset(ep, Yes);
        !            78: 
        !            79:        case SUBLIST:
        !            80:                return delsublist(ep);
        !            81: 
        !            82:        case WHOLE:
        !            83:                return delwhole(ep);
        !            84: 
        !            85:        default:
        !            86:                Abort();
        !            87:                /* NOTREACHED */
        !            88:        }
        !            89: }
        !            90: 
        !            91: 
        !            92: /*
        !            93:  * Delete portion (ep->mode == SUBRANGE) of varying text ((ep->s1&1) == 0).
        !            94:  */
        !            95: 
        !            96: Hidden bool
        !            97: delvarying(ep)
        !            98:        register environ *ep;
        !            99: {
        !           100:        auto queue q = Qnil;
        !           101:        register node n = tree(ep->focus);
        !           102:        auto value v = (value) child(n, ep->s1/2);
        !           103:        register len = Length(v);
        !           104: 
        !           105:        Assert(ep->mode == SUBRANGE && !(ep->s1&1)); /* Wrong call */
        !           106:        Assert(Type(v) == Tex); /* Inconsistent parse tree */
        !           107:        if (ep->s2 == 0
        !           108:                && !mayinsert(tree(ep->focus), ep->s1/2, 0, Str(v)[ep->s3 + 1])) {
        !           109:                /* Cannot do simple substring deletion. */
        !           110:                stringtoqueue(Str(v) + ep->s3 + 1, &q);
        !           111:                delfocus(&ep->focus);
        !           112:                ep->mode = WHOLE;
        !           113:                return app_queue(ep, &q);
        !           114:        }
        !           115:        v = copy(v);
        !           116:        putintrim(&v, ep->s2, len - ep->s3 - 1, "");
        !           117:        s_downi(ep, ep->s1/2);
        !           118:        replace(&ep->focus, (node) v);
        !           119:        s_up(ep);
        !           120:        ep->mode = VHOLE;
        !           121:        return Yes;
        !           122: }
        !           123: 
        !           124: 
        !           125: /*
        !           126:  * Delete portion (ep->mode == SUBRANGE) of fixed text ((ep->s1&1) == 1).
        !           127:  */
        !           128: 
        !           129: Hidden bool
        !           130: delfixed(ep)
        !           131:        register environ *ep;
        !           132: {
        !           133:        register node n = tree(ep->focus);
        !           134:        char buf[15]; /* Long enough for all fixed texts */
        !           135:        register string repr = noderepr(n)[ep->s1/2];
        !           136:        register int len;
        !           137:        queue q = Qnil;
        !           138:        bool ok;
        !           139: 
        !           140:        Assert(ep->mode == SUBRANGE && (ep->s1&1));
        !           141:        if (ep->s1 > 1) {
        !           142:                ep->mode = FHOLE;
        !           143:                return Yes;
        !           144:        }
        !           145:        Assert(fwidth(repr) < sizeof buf - 1);
        !           146:        len = ep->s2;
        !           147:        ep->s2 = ep->s3 + 1;
        !           148:        ep->mode = FHOLE;
        !           149:        nosuggtoqueue(ep, &q);
        !           150:        strcpy(buf, repr);
        !           151:        if (nchildren(tree(ep->focus)) > 0)
        !           152:                buf[len] = 0;
        !           153:        else
        !           154:                strcpy(buf+len, buf+ep->s2);
        !           155:        delfocus(&ep->focus);
        !           156:        ep->mode = WHOLE;
        !           157:        markpath(&ep->focus, 1);
        !           158:        ok = ins_string(ep, buf, &q, 0);
        !           159:        if (!ok) {
        !           160:                qrelease(q);
        !           161:                return No;
        !           162:        }
        !           163:        firstmarked(&ep->focus, 1) || Abort();
        !           164:        unmkpath(&ep->focus, 1);
        !           165:        fixfocus(ep, len);
        !           166:        return app_queue(ep, &q);
        !           167: }
        !           168: 
        !           169: 
        !           170: /*
        !           171:  * Delete focus if ep->mode == SUBSET.
        !           172:  */
        !           173: 
        !           174: Hidden bool
        !           175: delsubset(ep, hack)
        !           176:        register environ *ep;
        !           177:        bool hack;
        !           178: {
        !           179:        auto queue q = Qnil;
        !           180:        auto queue q2 = Qnil;
        !           181:        register node n = tree(ep->focus);
        !           182:        register node nn;
        !           183:        register string *rp = noderepr(n);
        !           184:        register int nch = nchildren(n);
        !           185:        register int i;
        !           186: 
        !           187:        if (hack) {
        !           188:                shrsubset(ep);
        !           189:                if (ep->s1 == ep->s2 && !(ep->s1&1)) {
        !           190:                        nn = child(tree(ep->focus), ep->s1/2);
        !           191:                        if (fwidth(noderepr(nn)[0]) < 0) {
        !           192:                                /* It starts with a newline, leave the newline */
        !           193:                                s_downi(ep, ep->s1/2);
        !           194:                                ep->mode = SUBSET;
        !           195:                                ep->s1 = 2;
        !           196:                                ep->s2 = 2*nchildren(nn) + 1;
        !           197:                                return delsubset(ep, hack);
        !           198:                        }
        !           199:                }
        !           200:                subgrsubset(ep, No); /* Undo shrsubset */
        !           201:                if (ep->s2 == 3 && rp[1] && Strequ(rp[1], "\t"))
        !           202:                        --ep->s2; /* Hack for deletion of unit-head or if/for/wh. head */
        !           203:        }
        !           204:        if (ep->s1 == 1 && Fw_negative(rp[0]))
        !           205:                ++ep->s1; /* Hack for deletion of test-suite or refinement head */
        !           206: 
        !           207:        if (Fw_zero(rp[0]) ? (ep->s2 < 3 || ep->s1 > 3) : ep->s1 > 1) {
        !           208:                /* No deep structural change */
        !           209:                for (i = (ep->s1+1)/2; i <= ep->s2/2; ++i) {
        !           210:                        s_downi(ep, i);
        !           211:                        delfocus(&ep->focus);
        !           212:                        s_up(ep);
        !           213:                }
        !           214:                if (ep->s1&1) {
        !           215:                        ep->mode = FHOLE;
        !           216:                        ep->s2 = 0;
        !           217:                }
        !           218:                else if (Type(child(tree(ep->focus), ep->s1/2)) == Tex) {
        !           219:                        ep->mode = VHOLE;
        !           220:                        ep->s2 = 0;
        !           221:                }
        !           222:                else {
        !           223:                        s_downi(ep, ep->s1/2);
        !           224:                        ep->mode = ATBEGIN;
        !           225:                }
        !           226:                return Yes;
        !           227:        }
        !           228: 
        !           229:        balance(ep); /* Make balanced \t - \b pairs */
        !           230:        subsettoqueue(n, 1, ep->s1-1, &q);
        !           231:        subsettoqueue(n, ep->s2+1, 2*nch+1, &q2);
        !           232:        nonewline(&q2); /* Wonder what will happen...? */
        !           233:        delfocus(&ep->focus);
        !           234:        ep->mode = ATBEGIN;
        !           235:        leftvhole(ep);
        !           236:        if (!ins_queue(ep, &q, &q2)) {
        !           237:                qrelease(q2);
        !           238:                return No;
        !           239:        }
        !           240:        return app_queue(ep, &q2);
        !           241: }
        !           242: 
        !           243: 
        !           244: /*
        !           245:  * Delete the focus if ep->mode == SUBLIST.
        !           246:  */
        !           247: 
        !           248: delsublist(ep)
        !           249:        register environ *ep;
        !           250: {
        !           251:        register node n;
        !           252:        register int i;
        !           253:        register int sym;
        !           254:        queue q = Qnil;
        !           255:        bool flag;
        !           256: 
        !           257:        Assert(ep->mode == SUBLIST);
        !           258:        n = tree(ep->focus);
        !           259:        flag = fwidth(noderepr(n)[0]) < 0;
        !           260:        for (i = ep->s3; i > 0; --i) {
        !           261:                n = lastchild(n);
        !           262:                Assert(n);
        !           263:        }
        !           264:        if (flag) {
        !           265:                n = nodecopy(n);
        !           266:                s_down(ep);
        !           267:                do {
        !           268:                        delfocus(&ep->focus);
        !           269:                } while (rite(&ep->focus));
        !           270:                if (!allowed(ep->focus, symbol(n))) {
        !           271:                        error(DEL_REM); /* The remains wouldn't fit */
        !           272:                        noderelease(n);
        !           273:                        return No;
        !           274:                }
        !           275:                replace(&ep->focus, n);
        !           276:                s_up(ep);
        !           277:                s_down(ep); /* I.e., to leftmost sibling */
        !           278:                ep->mode = WHOLE;
        !           279:                return Yes;
        !           280:        }
        !           281:        sym = symbol(n);
        !           282:        if (sym == Optional || sym == Hole) {
        !           283:                delfocus(&ep->focus);
        !           284:                ep->mode = WHOLE;
        !           285:        }
        !           286:        else if (!allowed(ep->focus, sym)) {
        !           287:                preptoqueue(n, &q);
        !           288:                delfocus(&ep->focus);
        !           289:                ep->mode = WHOLE;
        !           290:                return app_queue(ep, &q);
        !           291:        }
        !           292:        else {
        !           293:                replace(&ep->focus, nodecopy(n));
        !           294:                ep->mode = ATBEGIN;
        !           295:        }
        !           296:        return Yes;
        !           297: }
        !           298: 
        !           299: 
        !           300: /*
        !           301:  * Delete the focus if ep->mode == WHOLE.
        !           302:  */
        !           303: 
        !           304: Hidden bool
        !           305: delwhole(ep)
        !           306:        register environ *ep;
        !           307: {
        !           308:        register int sym = symbol(tree(ep->focus));
        !           309: 
        !           310:        Assert(ep->mode == WHOLE);
        !           311:        if (sym == Optional || sym == Hole)
        !           312:                return No;
        !           313:        delfocus(&ep->focus);
        !           314:        return Yes;
        !           315: }
        !           316: 
        !           317: 
        !           318: /*
        !           319:  * Delete the focus if it is only a hole.
        !           320:  * Assume shrink() has been called before!
        !           321:  */
        !           322: 
        !           323: Hidden bool
        !           324: delhole(ep)
        !           325:        register environ *ep;
        !           326: {
        !           327:        node n;
        !           328:        int sym;
        !           329:        bool flag = No;
        !           330: 
        !           331:        switch (ep->mode) {
        !           332:        
        !           333:        case ATBEGIN:
        !           334:        case VHOLE:
        !           335:        case FHOLE:
        !           336:        case ATEND:
        !           337:                return widen(ep);
        !           338: 
        !           339:        case WHOLE:
        !           340:                Assert((sym = symbol(tree(ep->focus))) == Optional || sym == Hole);
        !           341:                if (ichild(ep->focus) != 1)
        !           342:                        break;
        !           343:                if (!up(&ep->focus))
        !           344:                        return No;
        !           345:                higher(ep);
        !           346:                ep->mode = SUBSET;
        !           347:                ep->s1 = 2;
        !           348:                ep->s2 = 2;
        !           349:                if (fwidth(noderepr(tree(ep->focus))[0]) < 0) {
        !           350:                        flag = Yes;
        !           351:                        ep->s2 = 3; /* Extend to rest of line */
        !           352:                }
        !           353:        }
        !           354: 
        !           355:        ep->changed = Yes;
        !           356:        grow(ep);
        !           357: 
        !           358:        switch (ep->mode) {
        !           359: 
        !           360:        case SUBSET:
        !           361:                if (!delsubset(ep, No))
        !           362:                        return No;
        !           363:                if (!flag)
        !           364:                        return widen(ep);
        !           365:                leftvhole(ep);
        !           366:                oneline(ep);
        !           367:                return Yes;
        !           368: 
        !           369:        case SUBLIST:
        !           370:                n = tree(ep->focus);
        !           371:                n = lastchild(n);
        !           372:                sym = symbol(n);
        !           373:                if (!allowed(ep->focus, sym)) {
        !           374:                        error(DEL_REM); /* The remains wouldn't fit */
        !           375:                        return No;
        !           376:                }
        !           377:                flag = samelevel(sym, symbol(tree(ep->focus)));
        !           378:                replace(&ep->focus, nodecopy(n));
        !           379:                if (flag) {
        !           380:                        ep->mode = SUBLIST;
        !           381:                        ep->s3 = 1;
        !           382:                }
        !           383:                else
        !           384:                        ep->mode = WHOLE;
        !           385:                return Yes;
        !           386: 
        !           387:        case WHOLE:
        !           388:                Assert(!parent(ep->focus)); /* Must be at root! */
        !           389:                return No;
        !           390: 
        !           391:        default:
        !           392:                Abort();
        !           393:                /* NOTREACHED */
        !           394: 
        !           395:        }
        !           396: }
        !           397: 
        !           398: 
        !           399: /*
        !           400:  * Subroutine to delete the focus.
        !           401:  */
        !           402: 
        !           403: Visible Procedure
        !           404: delfocus(pp)
        !           405:        register path *pp;
        !           406: {
        !           407:        register path pa = parent(*pp);
        !           408:        register int sympa = pa ? symbol(tree(pa)) : Rootsymbol;
        !           409: 
        !           410:        replace(pp, child(gram(sympa), ichild(*pp)));
        !           411: }
        !           412: 
        !           413: 
        !           414: /*
        !           415:  * Copy command -- copy the focus to the copy buffer if it contains
        !           416:  * some text, copy the copy buffer into the focus if the focus is
        !           417:  * empty (just a hole).
        !           418:  */
        !           419: 
        !           420: Visible bool
        !           421: copyinout(ep)
        !           422:        register environ *ep;
        !           423: {
        !           424:        shrink(ep);
        !           425:        if (!ishole(ep)) {
        !           426:                release(ep->copybuffer);
        !           427:                ep->copybuffer = copyout(ep);
        !           428:                ep->copyflag = !!ep->copybuffer;
        !           429:                return ep->copyflag;
        !           430:        }
        !           431:        else {
        !           432:                fixit(ep); /* Make sure it looks like a hole now */
        !           433:                if (!copyin(ep, (queue) ep->copybuffer))
        !           434:                        return No;
        !           435:                ep->copyflag = No;
        !           436:                return Yes;
        !           437:        }
        !           438: }
        !           439: 
        !           440: 
        !           441: /*
        !           442:  * Copy the focus to the copy buffer.
        !           443:  */
        !           444: 
        !           445: Visible value
        !           446: copyout(ep)
        !           447:        register environ *ep;
        !           448: {
        !           449:        auto queue q = Qnil;
        !           450:        auto path p;
        !           451:        register node n;
        !           452:        register value v;
        !           453:        char buf[15];
        !           454:        register string *rp;
        !           455:        register int i;
        !           456: 
        !           457:        switch (ep->mode) {
        !           458:        case WHOLE:
        !           459:                preptoqueue(tree(ep->focus), &q);
        !           460:                break;
        !           461:        case SUBLIST:
        !           462:                p = pathcopy(ep->focus);
        !           463:                for (i = ep->s3; i > 0; --i)
        !           464:                        downrite(&p) || Abort();
        !           465:                for (i = ep->s3; i > 0; --i) {
        !           466:                        up(&p) || Abort();
        !           467:                        n = tree(p);
        !           468:                        subsettoqueue(n, 1, 2*nchildren(n) - 1, &q);
        !           469:                }
        !           470:                pathrelease(p);
        !           471:                break;
        !           472:        case SUBSET:
        !           473:                balance(ep);
        !           474:                subsettoqueue(tree(ep->focus), ep->s1, ep->s2, &q);
        !           475:                break;
        !           476:        case SUBRANGE:
        !           477:                Assert(ep->s3 >= ep->s2);
        !           478:                if (ep->s1&1) { /* Fixed text */
        !           479:                        Assert(ep->s3 - ep->s2 + 1 < sizeof buf);
        !           480:                        rp = noderepr(tree(ep->focus));
        !           481:                        Assert(ep->s2 < Fwidth(rp[ep->s1/2]));
        !           482:                        strncpy(buf, rp[ep->s1/2] + ep->s2, ep->s3 - ep->s2 + 1);
        !           483:                        buf[ep->s3 - ep->s2 + 1] = 0;
        !           484:                        stringtoqueue(buf, &q);
        !           485:                }
        !           486:                else { /* Varying text */
        !           487:                        v = (value) child(tree(ep->focus), ep->s1/2);
        !           488:                        Assert(Type(v) == Tex);
        !           489:                        v = trim(v, ep->s2, Length(v) - ep->s3 - 1);
        !           490:                        preptoqueue((node)v, &q);
        !           491:                        release(v);
        !           492:                }
        !           493:                break;
        !           494:        default:
        !           495:                Abort();
        !           496:        }
        !           497:        nonewline(&q);
        !           498:        return (value)q;
        !           499: }
        !           500: 
        !           501: 
        !           502: /*
        !           503:  * Subroutine to ensure the copy buffer doesn't start with a newline.
        !           504:  */
        !           505: 
        !           506: Hidden Procedure
        !           507: nonewline(pq)
        !           508:        register queue *pq;
        !           509: {
        !           510:        register node n;
        !           511:        register int c;
        !           512: 
        !           513:        if (!emptyqueue(*pq)) {
        !           514:                for (;;) {
        !           515:                        n = queuebehead(pq);
        !           516:                        if (Type(n) == Tex) {
        !           517:                                if (Str((value) n)[0] != '\n')
        !           518:                                        preptoqueue(n, pq);
        !           519:                                noderelease(n);
        !           520:                                break;
        !           521:                        }
        !           522:                        else {
        !           523:                                c = nodechar(n);
        !           524:                                if (c != '\n')
        !           525:                                        preptoqueue(n, pq);
        !           526:                                else
        !           527:                                        splitnode(n, pq);
        !           528:                                noderelease(n);
        !           529:                                if (c != '\n')
        !           530:                                        break;
        !           531:                        }
        !           532:                }
        !           533:        }
        !           534: }
        !           535: 
        !           536: 
        !           537: /*
        !           538:  * Refinement for copyout, case SUBSET: make sure that \t is balanced with \b.
        !           539:  * Actually it can only handle the case where a \t is in the subset and the
        !           540:  * matching \b is immediately following.
        !           541:  */
        !           542: 
        !           543: Hidden Procedure
        !           544: balance(ep)
        !           545:        environ *ep;
        !           546: {
        !           547:        string *rp = noderepr(tree(ep->focus));
        !           548:        int i;
        !           549:        int level = 0;
        !           550: 
        !           551:        Assert(ep->mode == SUBSET);
        !           552:        for (i = ep->s1/2; i*2 < ep->s2; ++i) {
        !           553:                if (rp[i]) {
        !           554:                        if (index(rp[i], '\t'))
        !           555:                                ++level;
        !           556:                        else if (index(rp[i], '\b'))
        !           557:                                --level;
        !           558:                }
        !           559:        }
        !           560:        if (level > 0 && i*2 == ep->s2 && rp[i] && index(rp[i], '\b'))
        !           561:                ep->s2 = 2*i + 1;
        !           562: }
        !           563: 
        !           564: 
        !           565: /*
        !           566:  * Copy the copy buffer to the focus.
        !           567:  */
        !           568: 
        !           569: Hidden bool
        !           570: copyin(ep, q)
        !           571:        register environ *ep;
        !           572:        /*auto*/ queue q;
        !           573: {
        !           574:        auto queue q2 = Qnil;
        !           575: 
        !           576:        if (!q) {
        !           577:                error(COPY_EMPTY); /* Empty copy buffer */
        !           578:                return No;
        !           579:        }
        !           580:        ep->changed = Yes;
        !           581:        q = qcopy(q);
        !           582:        if (!ins_queue(ep, &q, &q2)) {
        !           583:                qrelease(q2);
        !           584:                return No;
        !           585:        }
        !           586:        return app_queue(ep, &q2);
        !           587: }
        !           588: 
        !           589: 
        !           590: /*
        !           591:  * Find out whether the focus looks like a hole or if it has some real
        !           592:  * text in it.
        !           593:  * Assumes shrink(ep) has already been performed.
        !           594:  */
        !           595: 
        !           596: Visible bool
        !           597: ishole(ep)
        !           598:        register environ *ep;
        !           599: {
        !           600:        register int sym;
        !           601: 
        !           602:        switch (ep->mode) {
        !           603:        
        !           604:        case ATBEGIN:
        !           605:        case ATEND:
        !           606:        case VHOLE:
        !           607:        case FHOLE:
        !           608:                return Yes;
        !           609: 
        !           610:        case SUBLIST:
        !           611:        case SUBRANGE:
        !           612:                return No;
        !           613: 
        !           614:        case SUBSET:
        !           615:                return colonhack(ep); /* (Side-effect!) */
        !           616: 
        !           617:        case WHOLE:
        !           618:                sym = symbol(tree(ep->focus));
        !           619:                return sym == Optional || sym == Hole;
        !           620: 
        !           621:        default:
        !           622:                Abort();
        !           623:                /* NOTREACHED */
        !           624:        }
        !           625: }
        !           626: 
        !           627: 
        !           628: /*
        !           629:  * Amendment to ishole so that it categorizes '?: ?' as a hole.
        !           630:  * This makes deletion of empty refinements / alternative-suites
        !           631:  * easier (Steven).
        !           632:  */
        !           633: 
        !           634: Hidden bool
        !           635: colonhack(ep)
        !           636:        environ *ep;
        !           637: {
        !           638:        node n = tree(ep->focus);
        !           639:        node n1;
        !           640:        string *rp = noderepr(n);
        !           641:        int i;
        !           642:        int sym;
        !           643: 
        !           644:        for (i = ep->s1; i <= ep->s2; ++i) {
        !           645:                if (i&1) {
        !           646:                        if (!allright(rp[i/2]))
        !           647:                                return No;
        !           648:                }
        !           649:                else {
        !           650:                        n1 = child(n, i/2);
        !           651:                        if (Type(n1) == Tex)
        !           652:                                return No;
        !           653:                        sym = symbol(n1);
        !           654:                        if (sym != Hole && sym != Optional)
        !           655:                                return No;
        !           656:                }
        !           657:        }
        !           658:        return Yes;
        !           659: }
        !           660: 
        !           661: 
        !           662: /*
        !           663:  * Refinement for colonhack.  Recognize strings that are almost blank
        !           664:  * (i.e. containing only spaces, colons and the allowed control characters).
        !           665:  */
        !           666: 
        !           667: Hidden bool
        !           668: allright(repr)
        !           669:        string repr;
        !           670: {
        !           671:        if (repr) {
        !           672:                for (; *repr; ++repr) {
        !           673:                        if (!index(": \t\b\n\r", *repr))
        !           674:                                return No;
        !           675:                }
        !           676:        }
        !           677:        return Yes;
        !           678: }

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