Return to supr.c CVS log

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

Annotation of 43BSDTahoe/new/B/src/bed/supr.c, revision 1.1

1.1     ! root        1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1984. */
        !             2: static char rcsid[] = "$Header: supr.c,v 2.3 84/07/23 13:03:15 guido Exp $";
        !             3: 
        !             4: /*
        !             5:  * B editor -- Superroutines.
        !             6:  */
        !             7: 
        !             8: #include "b.h"
        !             9: #include "feat.h"
        !            10: #include "bobj.h"
        !            11: #include "node.h"
        !            12: #include "supr.h"
        !            13: #include "gram.h"
        !            14: 
        !            15: /*
        !            16:  * Compute the length of the ep->s1'th item of node tree(ep->focus).
        !            17:  */
        !            18: 
        !            19: Visible int
        !            20: lenitem(ep)
        !            21:        register environ *ep;
        !            22: {
        !            23:        register node n = tree(ep->focus);
        !            24:        register node nn;
        !            25: 
        !            26:        if (ep->s1&1) /* Fixed text */
        !            27:                return fwidth(noderepr(n)[ep->s1/2]);
        !            28:        /* Else, variable text or a whole node */
        !            29:        nn = child(n, ep->s1/2);
        !            30:        return width(nn);
        !            31: }
        !            32: 
        !            33: 
        !            34: /*
        !            35:  * Find the largest possible representation of the focus.
        !            36:  * E.g., a WHOLE can also be represented as a SUBSET of its parent,
        !            37:  * provided it has a parent.
        !            38:  * Also, a SUBSET may be extended with some empty left and right
        !            39:  * items and then look like a WHOLE, etc.
        !            40:  * This process is repeated until no more improvements can be made.
        !            41:  */
        !            42: 
        !            43: Visible Procedure
        !            44: grow(ep)
        !            45:        environ *ep;
        !            46: {
        !            47:        subgrow(ep, Yes);
        !            48: }
        !            49: 
        !            50: Visible Procedure
        !            51: subgrow(ep, ignorespaces)
        !            52:        register environ *ep;
        !            53:        bool ignorespaces;
        !            54: {
        !            55:        register node n;
        !            56:        register int sym;
        !            57:        register int i;
        !            58:        register int len;
        !            59:        register string repr;
        !            60: 
        !            61:        switch (ep->mode) {
        !            62:        case ATBEGIN:
        !            63:        case ATEND:
        !            64:        case VHOLE:
        !            65:        case FHOLE:
        !            66:                ritevhole(ep);
        !            67:                if (ep->mode != FHOLE && ep->mode != VHOLE || lenitem(ep) == 0)
        !            68:                        leftvhole(ep);
        !            69: 
        !            70:        }
        !            71: 
        !            72:        for (;;) {
        !            73:                n = tree(ep->focus);
        !            74:                sym = symbol(n);
        !            75: 
        !            76:                switch (ep->mode) {
        !            77: 
        !            78:                case VHOLE:
        !            79:                case FHOLE:
        !            80:                        if ((sym == Optional || sym == Hole) && ep->s2 == 0) {
        !            81:                                ep->mode = WHOLE;
        !            82:                                continue;
        !            83:                        }
        !            84:                        if (lenitem(ep) <= 0) {
        !            85:                                ep->mode = SUBSET;
        !            86:                                ep->s2 = ep->s1;
        !            87:                                continue;
        !            88:                        }
        !            89:                        return;
        !            90: 
        !            91:                case ATBEGIN:
        !            92:                case ATEND:
        !            93:                        if (sym == Optional || sym == Hole) {
        !            94:                                ep->mode = WHOLE;
        !            95:                                continue;
        !            96:                        }
        !            97:                        return;
        !            98: 
        !            99:                case SUBRANGE:
        !           100:                        if (ep->s1&1) {
        !           101:                                repr = noderepr(n)[ep->s1/2];
        !           102:                                len = fwidth(repr);
        !           103:                                if (!ignorespaces) {
        !           104:                                  while (ep->s2 > 0 && repr[ep->s2-1] == ' ')
        !           105:                                        --ep->s2;
        !           106:                                  while (ep->s3 < len && repr[ep->s3+1] == ' ')
        !           107:                                        ++ep->s3;
        !           108:                                }
        !           109:                        }
        !           110:                        else
        !           111:                                len = Length((value) firstchild(n));
        !           112:                        if (ep->s2 == 0 && ep->s3 >= len - 1) {
        !           113:                                ep->mode = SUBSET;
        !           114:                                ep->s2 = ep->s1;
        !           115:                                continue;
        !           116:                        }
        !           117:                        return;
        !           118: 
        !           119:                case SUBSET:
        !           120:                        subgrsubset(ep, ignorespaces);
        !           121:                        if (ep->s1 == 1) {
        !           122:                                if (ep->s2 == 2*nchildren(n) + 1) {
        !           123:                                        ep->mode = WHOLE;
        !           124:                                        continue;
        !           125:                                }
        !           126:                                if (ep->s2 == 2*nchildren(n) - 1 && issublist(sym)) {
        !           127:                                        ep->mode = SUBLIST;
        !           128:                                        ep->s3 = 1;
        !           129:                                        return;
        !           130:                                }
        !           131:                        }
        !           132:                        return;
        !           133: 
        !           134:                case SUBLIST:
        !           135:                        for (i = ep->s3; i > 0; --i)
        !           136:                                n = lastchild(n);
        !           137:                        sym = symbol(n);
        !           138:                        if (sym == Optional) {
        !           139:                                ep->mode = WHOLE;
        !           140:                                continue;
        !           141:                        }
        !           142:                        return;
        !           143: 
        !           144:                case WHOLE:
        !           145:                        ep->s1 = 2*ichild(ep->focus);
        !           146:                        if (up(&ep->focus)) {
        !           147:                                ep->mode = SUBSET;
        !           148:                                ep->s2 = ep->s1;
        !           149:                                higher(ep);
        !           150:                                continue;
        !           151:                        }
        !           152:                        return; /* Leave as WHOLE if there is no parent */
        !           153: 
        !           154:                default:
        !           155:                        Abort();
        !           156:                        /* NOTREACHED */
        !           157: 
        !           158:                }
        !           159:                
        !           160:        }
        !           161:        /* Not reached */
        !           162: }
        !           163: 
        !           164: 
        !           165: /*
        !           166:  * Ditto to find smallest possible representation.
        !           167:  */
        !           168: 
        !           169: Visible Procedure
        !           170: shrink(ep)
        !           171:        register environ *ep;
        !           172: {
        !           173:        register node n;
        !           174:        register int sym;
        !           175: 
        !           176:        for (;;) {
        !           177:                n = tree(ep->focus);
        !           178:                sym = symbol(n);
        !           179: 
        !           180:                switch (ep->mode) {
        !           181: 
        !           182:                case WHOLE:
        !           183:                        if (sym == Hole || sym == Optional)
        !           184:                                return;
        !           185:                        ep->mode = SUBSET;
        !           186:                        ep->s1 = 1;
        !           187:                        ep->s2 = 2*nchildren(n) + 1;
        !           188:                        continue;
        !           189: 
        !           190:                case SUBLIST:
        !           191:                        if (sym == Hole || sym == Optional) {
        !           192:                                ep->mode = WHOLE;
        !           193:                                return;
        !           194:                        }
        !           195:                        if (ep->s3 == 1) {
        !           196:                                ep->mode = SUBSET;
        !           197:                                ep->s1 = 1;
        !           198:                                ep->s2 = 2*nchildren(n) - 1;
        !           199:                                continue;
        !           200:                        }
        !           201:                        return;
        !           202: 
        !           203:                case SUBSET:
        !           204:                        if (sym == Hole || sym == Optional) {
        !           205:                                ep->mode = WHOLE;
        !           206:                                return;
        !           207:                        }
        !           208:                        shrsubset(ep);
        !           209:                        if (ep->s1 == ep->s2) {
        !           210:                                if (isunititem(ep)) {
        !           211:                                        ep->mode = SUBRANGE;
        !           212:                                        ep->s2 = 0;
        !           213:                                        ep->s3 = lenitem(ep) - 1;
        !           214:                                        return;
        !           215:                                }
        !           216:                                else {
        !           217:                                        s_downi(ep, ep->s1/2);
        !           218:                                        ep->mode = WHOLE;
        !           219:                                        continue;
        !           220:                                }
        !           221:                        }
        !           222:                        return;
        !           223: 
        !           224:                case SUBRANGE:
        !           225:                        if (sym == Optional || sym == Hole)
        !           226:                                ep->mode = WHOLE;
        !           227:                        return;
        !           228: 
        !           229:                case ATBEGIN:
        !           230:                        ritevhole(ep);
        !           231:                        if (ep->mode == ATBEGIN) {
        !           232:                                if (sym == Optional || sym == Hole)
        !           233:                                        ep->mode = WHOLE;
        !           234:                                return;
        !           235:                        }
        !           236:                        continue;
        !           237: 
        !           238:                case FHOLE:
        !           239:                case VHOLE:
        !           240:                        ritevhole(ep);
        !           241:                        if (ep->mode != VHOLE && ep->mode != FHOLE)
        !           242:                                continue;
        !           243:                        sym = symbol(tree(ep->focus));
        !           244:                        if (sym == Optional || sym == Hole && ep->s2 == 0)
        !           245:                                ep->mode = WHOLE;
        !           246:                        return;
        !           247: 
        !           248:                case ATEND:
        !           249:                        return;
        !           250: 
        !           251:                default:
        !           252:                        Abort();
        !           253:                        /* NOTREACHED */
        !           254: 
        !           255:                }
        !           256:        }
        !           257:        /* Not reached */
        !           258: 
        !           259: }
        !           260: 
        !           261: 
        !           262: /*
        !           263:  * Subroutine to find the largest way to describe a SUBSET focus
        !           264:  * (modulo surrounding blanks and newlines).
        !           265:  */
        !           266: 
        !           267: Visible Procedure
        !           268: growsubset(ep)
        !           269:        environ *ep;
        !           270: {
        !           271:        subgrsubset(ep, Yes);
        !           272: }
        !           273: 
        !           274: Visible Procedure
        !           275: subgrsubset(ep, ignorespaces)
        !           276:        register environ *ep;
        !           277:        bool ignorespaces;
        !           278: {
        !           279:        register node n = tree(ep->focus);
        !           280:        register string *rp = noderepr(n);
        !           281:        register nch21 = nchildren(n)*2 + 1;
        !           282:        register int i;
        !           283: 
        !           284:        Assert(ep->mode == SUBSET);
        !           285:        for (i = ep->s1; i > 1 && subisnull(n, rp, i-1, ignorespaces); --i)
        !           286:                ;
        !           287:        ep->s1 = i;
        !           288:        for (i = ep->s2; i < nch21 && subisnull(n, rp, i+1, ignorespaces); ++i)
        !           289:                ;
        !           290:        ep->s2 = i;
        !           291: }
        !           292: 
        !           293: 
        !           294: /*
        !           295:  * Ditto for the smallest way.
        !           296:  */
        !           297: 
        !           298: Visible Procedure /* Ought to be Hidden */
        !           299: shrsubset(ep)
        !           300:        register environ *ep;
        !           301: {
        !           302:        register node n = tree(ep->focus);
        !           303:        register string *rp = noderepr(n);
        !           304:        register int s1 = ep->s1;
        !           305:        register int s2 = ep->s2;
        !           306: 
        !           307:        for (; s1 < s2 && isnull(n, rp, s1); ++s1)
        !           308:                ;
        !           309:        ep->s1 = s1;
        !           310:        for (; s2 > s1 && isnull(n, rp, s2); --s2)
        !           311:                ;
        !           312:        ep->s2 = s2;
        !           313: }
        !           314: 
        !           315: 
        !           316: /*
        !           317:  * Subroutine for grow/shrink to see whether item i is (almost) invisible.
        !           318:  */
        !           319: 
        !           320: Visible bool
        !           321: isnull(n, rp, i)
        !           322:        node n;
        !           323:        string *rp;
        !           324:        int i;
        !           325: {
        !           326:        return subisnull(n, rp, i, Yes);
        !           327: }
        !           328: 
        !           329: Hidden Procedure
        !           330: subisnull(n, rp, i, ignorespaces)
        !           331:        register node n;
        !           332:        register string *rp;
        !           333:        register int i;
        !           334:        bool ignorespaces;
        !           335: {
        !           336:        register string repr;
        !           337:        register node nn;
        !           338: 
        !           339:        if (i&1) { /* Fixed text */
        !           340:                repr = rp[i/2];
        !           341:                return !Fw_positive(repr) || ignorespaces && allspaces(repr);
        !           342:        }
        !           343:        nn = child(n, i/2);
        !           344:        return width(nn) == 0;
        !           345: }
        !           346: 
        !           347: 
        !           348: /*
        !           349:  * Find the rightmost VHOLE which would look the same as the current one.
        !           350:  */
        !           351: 
        !           352: Visible Procedure
        !           353: ritevhole(ep)
        !           354:        register environ *ep;
        !           355: {
        !           356:        register node n;
        !           357:        register int ich;
        !           358:        register int len;
        !           359:        register int s1save;
        !           360: 
        !           361:        for (;;) {
        !           362:                n = tree(ep->focus);
        !           363: 
        !           364:                switch (ep->mode) {
        !           365: 
        !           366:                case WHOLE:
        !           367:                        ep->mode = ATEND;
        !           368:                        break;
        !           369: 
        !           370:                case VHOLE:
        !           371:                case FHOLE:
        !           372:                        len = lenitem(ep);
        !           373:                        Assert(len >= 0);
        !           374:                        if (ep->s2 < len)
        !           375:                                return; /* Hole in middle of string */
        !           376:                        s1save = ep->s1;
        !           377:                        if (nextitem(ep)) {
        !           378:                                if (isunititem(ep)) {
        !           379:                                        ep->mode = (ep->s1&1) ? FHOLE : VHOLE;
        !           380:                                        ep->s2 = 0;
        !           381:                                }
        !           382:                                else if (fwidth(noderepr(child(n, ep->s1/2))[0]) < 0) {
        !           383:                                        /* Next item begins with newline -- avoid */
        !           384:                                        ep->s1 = s1save;
        !           385:                                        return;
        !           386:                                }
        !           387:                                else {
        !           388:                                        s_downi(ep, ep->s1/2);
        !           389:                                        ep->mode = ATBEGIN;
        !           390:                                }
        !           391:                                break;
        !           392:                        }
        !           393:                        ep->mode = ATEND;
        !           394:                        /* Fall through */
        !           395:                case ATEND:
        !           396:                        if (!parent(ep->focus) || width(n) < 0)
        !           397:                                return;
        !           398:                        ich = ichild(ep->focus);
        !           399:                        ep->s1 = 2*ich;
        !           400:                        s_up(ep);
        !           401:                        if (nextitem(ep)) {
        !           402:                                /* Note -- negative width cannot occur (see test above) */
        !           403:                                if (isunititem(ep)) {
        !           404:                                        ep->mode = (ep->s1&1) ? FHOLE : VHOLE;
        !           405:                                        ep->s2 = 0;
        !           406:                                }
        !           407:                                else {
        !           408:                                        ep->mode = ATBEGIN;
        !           409:                                        s_downi(ep, ep->s1/2);
        !           410:                                }
        !           411:                                break;
        !           412:                        }
        !           413:                        continue;
        !           414: 
        !           415:                case ATBEGIN:
        !           416:                        if (fwidth(noderepr(n)[0]) < 0)
        !           417:                                return; /* Already at dangerous position */
        !           418:                        ep->mode = FHOLE;
        !           419:                        ep->s1 = 1;
        !           420:                        ep->s2 = 0;
        !           421:                        continue;
        !           422: 
        !           423:                default:
        !           424:                        Abort();
        !           425:                        /* NOTREACHED */
        !           426: 
        !           427:                }
        !           428:        }
        !           429: }
        !           430: 
        !           431: 
        !           432: /*
        !           433:  * Ditto to the left.
        !           434:  */
        !           435: 
        !           436: Visible Procedure
        !           437: leftvhole(ep)
        !           438:        register environ *ep;
        !           439: {
        !           440:        register int ich;
        !           441: 
        !           442:        for (;;) {
        !           443:                switch (ep->mode) {
        !           444: 
        !           445:                case WHOLE:
        !           446:                        ep->mode = ATBEGIN;
        !           447:                        break;
        !           448: 
        !           449:                case VHOLE:
        !           450:                case FHOLE:
        !           451:                        if (ep->s2 > 0)
        !           452:                                return;
        !           453:                        if (previtem(ep)) {
        !           454:                                if (isunititem(ep)) {
        !           455:                                        ep->mode = (ep->s1&1) ? FHOLE : VHOLE;
        !           456:                                        ep->s2 = lenitem(ep);
        !           457:                                }
        !           458:                                else {
        !           459:                                        s_downi(ep, ep->s1/2);
        !           460:                                        ep->mode = ATEND;
        !           461:                                }
        !           462:                        }
        !           463:                        else if (fwidth(noderepr(tree(ep->focus))[0]) < 0)
        !           464:                                return;
        !           465:                        else
        !           466:                                ep->mode = ATBEGIN;
        !           467:                        continue;
        !           468: 
        !           469:                case ATBEGIN:
        !           470:                        ich = ichild(ep->focus);
        !           471:                        if (!up(&ep->focus))
        !           472:                                return;
        !           473:                        higher(ep);
        !           474:                        ep->s1 = 2*ich;
        !           475:                        if (prevnnitem(ep)) {
        !           476:                                if (isunititem(ep)) {
        !           477:                                        ep->mode = (ep->s1&1) ? FHOLE : VHOLE;
        !           478:                                        ep->s2 = lenitem(ep);
        !           479:                                }
        !           480:                                else {
        !           481:                                        s_downi(ep, ep->s1/2);
        !           482:                                        ep->mode = ATEND;
        !           483:                                }
        !           484:                        }
        !           485:                        else if (fwidth(noderepr(tree(ep->focus))[0]) < 0) {
        !           486:                                s_downi(ep, ich); /* Undo up */
        !           487:                                return;
        !           488:                        }
        !           489:                        else
        !           490:                                ep->mode = ATBEGIN;
        !           491:                        continue;
        !           492: 
        !           493:                case ATEND:
        !           494:                        lastnnitem(ep);
        !           495:                        if (isunititem(ep)) {
        !           496:                                ep->s2 = lenitem(ep);
        !           497:                                ep->mode = (ep->s1&1) ? FHOLE : VHOLE;
        !           498:                        }
        !           499:                        else
        !           500:                                s_downi(ep, ep->s1/2);
        !           501:                        continue;
        !           502: 
        !           503:                default:
        !           504:                        Abort();
        !           505: 
        !           506:                }
        !           507:        }
        !           508: }
        !           509: 
        !           510: 
        !           511: /*
        !           512:  * Safe up, downi, left and rite routines:
        !           513:  * 1) Rather die than fail;
        !           514:  * 2) Update ep->highest properly.
        !           515:  */
        !           516: 
        !           517: Visible Procedure
        !           518: s_up(ep)
        !           519:        register environ *ep;
        !           520: {
        !           521:        if (!up(&ep->focus))
        !           522:                syserr("s_up failed");
        !           523:        higher(ep);
        !           524: }
        !           525: 
        !           526: Visible Procedure
        !           527: s_downi(ep, i)
        !           528:        register environ *ep;
        !           529:        register int i;
        !           530: {
        !           531:        if (!downi(&ep->focus, i))
        !           532:                syserr("s_downi failed");
        !           533: }
        !           534: 
        !           535: Visible Procedure
        !           536: s_down(ep)
        !           537:        register environ *ep;
        !           538: {
        !           539:        if (!down(&ep->focus))
        !           540:                syserr("s_down failed");
        !           541: }
        !           542: 
        !           543: Visible Procedure
        !           544: s_downrite(ep)
        !           545:        register environ *ep;
        !           546: {
        !           547:        if (!downrite(&ep->focus))
        !           548:                syserr("s_downrite failed");
        !           549: }
        !           550: 
        !           551: Visible Procedure
        !           552: s_left(ep)
        !           553:        register environ *ep;
        !           554: {
        !           555:        register int ich = ichild(ep->focus);
        !           556: 
        !           557:        s_up(ep);
        !           558:        s_downi(ep, ich-1);
        !           559: }
        !           560: 
        !           561: Visible Procedure
        !           562: s_rite(ep)
        !           563:        register environ *ep;
        !           564: {
        !           565:        register int ich = ichild(ep->focus);
        !           566: 
        !           567:        s_up(ep);
        !           568:        s_downi(ep, ich+1);
        !           569: }
        !           570: 
        !           571: 
        !           572: /*
        !           573:  * Find next item in a subset, using ep->s1 as index.
        !           574:  * (This used to be less trivial, so it's still a subroutine rather than
        !           575:  * coded in-line or as a macro.)
        !           576:  */
        !           577: 
        !           578: Visible bool
        !           579: nextitem(ep)
        !           580:        register environ *ep;
        !           581: {
        !           582:        if (ep->s1 >= 2*nchildren(tree(ep->focus)) + 1)
        !           583:                return No; /* Already at last item */
        !           584:        ++ep->s1;
        !           585:        return Yes;
        !           586: }
        !           587: 
        !           588: 
        !           589: /*
        !           590:  * Ditto for previous.
        !           591:  */
        !           592: 
        !           593: Visible bool
        !           594: previtem(ep)
        !           595:        register environ *ep;
        !           596: {
        !           597:        if (ep->s1 <= 1
        !           598:                || ep->s1 == 2 && fwidth(noderepr(tree(ep->focus))[0]) < 0)
        !           599:                return No; /* Already at first item */
        !           600:        --ep->s1;
        !           601:        return Yes;
        !           602: }
        !           603: 
        !           604: 
        !           605: /*
        !           606:  * Test whether item ep->s1 is "small", i.e., fixed or varying text
        !           607:  * but not a whole subtree.
        !           608:  */
        !           609: 
        !           610: Visible bool
        !           611: isunititem(ep)
        !           612:        register environ *ep;
        !           613: {
        !           614:        return (ep->s1&1) || Type(child(tree(ep->focus), ep->s1/2)) == Tex;
        !           615: }
        !           616: 
        !           617: 
        !           618: /*
        !           619:  * Check for consistent mode information.
        !           620:  */
        !           621: 
        !           622: Visible bool
        !           623: checkep(ep)
        !           624:        register environ *ep;
        !           625: {
        !           626:        switch (ep->mode) {
        !           627: 
        !           628:        case FHOLE:
        !           629:                if (!(ep->s1&1))
        !           630:                        break;
        !           631:                if (ep->s2 < 0 || ep->s2 > lenitem(ep))
        !           632:                        break;
        !           633:                return Yes;
        !           634: 
        !           635:        case VHOLE:
        !           636:                if (!(ep->s1&1)) {
        !           637:                        if (Type(child(tree(ep->focus), ep->s1/2)) != Tex)
        !           638:                                break;
        !           639:                }
        !           640:                if (ep->s2 < 0 || ep->s2 > lenitem(ep))
        !           641:                        break;
        !           642:                return Yes;
        !           643: 
        !           644:        case SUBSET:
        !           645:                if (ep->s2 == ep->s1 && isunititem(ep) && lenitem(ep) <= 0)
        !           646:                        break;
        !           647:                return Yes;
        !           648: 
        !           649:        default:
        !           650:                return Yes;
        !           651: 
        !           652:        }
        !           653:        dbmess(ep);
        !           654:        return No;
        !           655: }
        !           656: 
        !           657: 
        !           658: /*
        !           659:  * Like {next,prev,first,last}item, but with empty items skipped
        !           660:  * (i.e., those with length <= 0).
        !           661:  */
        !           662: 
        !           663: Visible bool
        !           664: nextnnitem(ep)
        !           665:        register environ *ep;
        !           666: {
        !           667:        register int s1save = ep->s1;
        !           668: 
        !           669:        while (nextitem(ep)) {
        !           670:                if (lenitem(ep) != 0)
        !           671:                        return Yes;
        !           672:        }
        !           673:        ep->s1 = s1save;
        !           674:        return No;
        !           675: }
        !           676: 
        !           677: Visible bool
        !           678: prevnnitem(ep)
        !           679:        register environ *ep;
        !           680: {
        !           681:        register int s1save = ep->s1;
        !           682:        register int len;
        !           683: 
        !           684:        while (previtem(ep)) {
        !           685:                len = lenitem(ep);
        !           686:                if (len > 0 || len < 0 && ep->s1 > 1)
        !           687:                        return Yes;
        !           688:        }
        !           689:        ep->s1 = s1save;
        !           690:        return No;
        !           691: }
        !           692: 
        !           693: 
        !           694: Visible Procedure
        !           695: firstnnitem(ep)
        !           696:        register environ *ep;
        !           697: {
        !           698:        ep->s1 = fwidth(noderepr(tree(ep->focus))[0]) < 0 ? 2 : 1;
        !           699:        while (lenitem(ep) == 0) {
        !           700:                if (!nextitem(ep))
        !           701:                        break;
        !           702:        }
        !           703:        return;
        !           704: }
        !           705: 
        !           706: Visible Procedure
        !           707: lastnnitem(ep)
        !           708:        register environ *ep;
        !           709: {
        !           710:        ep->s1 = 2*nchildren(tree(ep->focus)) + 1;
        !           711:        while (lenitem(ep) == 0) {
        !           712:                if (!previtem(ep))
        !           713:                        break;
        !           714:        }
        !           715:        return;
        !           716: }
        !           717: 
        !           718: 
        !           719: /*
        !           720:  * Prepare the focus for insertion.
        !           721:  * If the focus isn't a hole, make a hole just before it which becomes the
        !           722:  * new focus.
        !           723:  * Also repair strange statuses left by moves, so we may have more chance
        !           724:  * to insert a character.
        !           725:  */
        !           726: 
        !           727: Visible Procedure
        !           728: fixit(ep)
        !           729:        register environ *ep;
        !           730: {
        !           731:        /* First, make a hole if it's not already a hole. */
        !           732: 
        !           733:        switch (ep->mode) {
        !           734: 
        !           735:        case FHOLE:
        !           736:                break;
        !           737: 
        !           738:        case VHOLE:
        !           739:                if (ep->s1&1)
        !           740:                        ep->mode = FHOLE;
        !           741:                break;
        !           742: 
        !           743:        case SUBRANGE:
        !           744:                if (ep->s1&1)
        !           745:                        ep->mode = FHOLE;
        !           746:                else
        !           747:                        ep->mode = VHOLE;
        !           748:                break;
        !           749: 
        !           750:        case SUBSET:
        !           751:                if (ep->s1&1) {
        !           752:                        if (ep->s1 == 1)
        !           753:                                ep->mode = ATBEGIN;
        !           754:                        else {
        !           755:                                ep->mode = FHOLE;
        !           756:                                ep->s2 = 0;
        !           757:                        }
        !           758:                }
        !           759:                else if (Type(child(tree(ep->focus), ep->s1/2)) == Tex) {
        !           760:                        ep->mode = VHOLE;
        !           761:                        ep->s2 = 0;
        !           762:                }
        !           763:                else {
        !           764:                        s_downi(ep, ep->s1/2);
        !           765:                        ep->mode = ATBEGIN;
        !           766:                }
        !           767:                break;
        !           768: 
        !           769:        case ATBEGIN:
        !           770:        case SUBLIST:
        !           771:        case WHOLE:
        !           772:                ep->mode = ATBEGIN;
        !           773:                break;
        !           774: 
        !           775:        case ATEND:
        !           776:                break;
        !           777: 
        !           778:        default:
        !           779:                Abort();
        !           780:        }
        !           781: 
        !           782:        leftvhole(ep);
        !           783:        if (ep->mode == ATEND && symbol(tree(ep->focus)) == Hole)
        !           784:                ep->mode = WHOLE; /***** Experiment! *****/
        !           785: }
        !           786: 
        !           787: 
        !           788: /*
        !           789:  * Small utility to see if a string contains only spaces
        !           790:  * (this is true for the empty string "").
        !           791:  * The string pointer must not be null!
        !           792:  */
        !           793: 
        !           794: Visible bool
        !           795: allspaces(str)
        !           796:        register string str;
        !           797: {
        !           798:        Assert(str);
        !           799:        for (; *str; ++str) {
        !           800:                if (*str != ' ')
        !           801:                        return No;
        !           802:        }
        !           803:        return Yes;
        !           804: }
        !           805: 
        !           806: 
        !           807: /*
        !           808:  * Function to compute the actual width of the focus.
        !           809:  */
        !           810: 
        !           811: Visible int
        !           812: focwidth(ep)
        !           813:        register environ *ep;
        !           814: {
        !           815:        node nn;
        !           816:        register node n = tree(ep->focus);
        !           817:        register string *rp = noderepr(n);
        !           818:        register int i;
        !           819:        register int w;
        !           820:        int len = 0;
        !           821: 
        !           822:        switch (ep->mode) {
        !           823: 
        !           824:        case VHOLE:
        !           825:        case FHOLE:
        !           826:        case ATEND:
        !           827:        case ATBEGIN:
        !           828:                return 0;
        !           829: 
        !           830:        case WHOLE:
        !           831:                return width(n);
        !           832: 
        !           833:        case SUBRANGE:
        !           834:                return ep->s3 - ep->s2 + 1;
        !           835: 
        !           836:        case SUBSET:
        !           837:                for (i = ep->s1; i <= ep->s2; ++i) {
        !           838:                        if (i&1)
        !           839:                                w = fwidth(rp[i/2]);
        !           840:                        else {
        !           841:                                nn = child(n, i/2);
        !           842:                                w = width(nn);
        !           843:                        }
        !           844:                        if (w < 0 && len >= 0)
        !           845:                                len = w;
        !           846:                        else if (w >= 0 && len < 0)
        !           847:                                ;
        !           848:                        else
        !           849:                                len += w;
        !           850:                }
        !           851:                return len;
        !           852: 
        !           853:        case SUBLIST:
        !           854:                len = width(n);
        !           855:                for (i = ep->s3; i > 0; --i)
        !           856:                        n = lastchild(n);
        !           857:                w = width(n);
        !           858:                if (w < 0 && len >= 0)
        !           859:                        return w;
        !           860:                if (w >= 0 && len < 0)
        !           861:                        return len;
        !           862:                return len - w;
        !           863: 
        !           864:        default:
        !           865:                Abort();
        !           866:                /* NOTREACHED */
        !           867:        }
        !           868: }
        !           869: 
        !           870: 
        !           871: /*
        !           872:  * Compute the offset of the focus from the beginning of the current node.
        !           873:  * This may be input again to fixfocus to allow restoration of this position.
        !           874:  */
        !           875: 
        !           876: Visible int
        !           877: focoffset(ep)
        !           878:        register environ *ep;
        !           879: {
        !           880:        node nn;
        !           881:        register node n;
        !           882:        register string *rp;
        !           883:        register int w;
        !           884:        register int len;
        !           885:        register int i;
        !           886: 
        !           887:        switch (ep->mode) {
        !           888: 
        !           889:        case WHOLE:
        !           890:        case SUBLIST:
        !           891:                return 0;
        !           892: 
        !           893:        case ATBEGIN:
        !           894:                return ep->spflag;
        !           895: 
        !           896:        case ATEND:
        !           897:                w = width(tree(ep->focus));
        !           898:                if (w < 0)
        !           899:                        return w;
        !           900:                return w + ep->spflag;
        !           901: 
        !           902:        case SUBSET:
        !           903:        case FHOLE:
        !           904:        case VHOLE:
        !           905:        case SUBRANGE:
        !           906:                n = tree(ep->focus);
        !           907:                rp = noderepr(n);
        !           908:                len = 0;
        !           909:                for (i = 1; i < ep->s1; ++i) {
        !           910:                        if (i&1)
        !           911:                                w = Fwidth(rp[i/2]);
        !           912:                        else {
        !           913:                                nn = child(n, i/2);
        !           914:                                w = width(nn);
        !           915:                        }
        !           916:                        if (w < 0) {
        !           917:                                if (len >= 0)
        !           918:                                        len = w;
        !           919:                                else
        !           920:                                        len += w;
        !           921:                        }
        !           922:                        else if (len >= 0)
        !           923:                                len += w;
        !           924:                }
        !           925:                if (ep->mode == SUBSET || len < 0)
        !           926:                        return len;
        !           927:                return len + ep->s2 + ep->spflag;
        !           928: 
        !           929:        default:
        !           930:                Abort();
        !           931:                /* NOTREACHED */
        !           932:        }
        !           933: }
        !           934: 
        !           935: 
        !           936: /*
        !           937:  * Return the first character of the focus (maybe '\n'; 0 if zero-width).
        !           938:  */
        !           939: 
        !           940: Visible int
        !           941: focchar(ep)
        !           942:        environ *ep;
        !           943: {
        !           944:        node n = tree(ep->focus);
        !           945:        string str;
        !           946:        string *rp;
        !           947:        int i;
        !           948:        int c;
        !           949: 
        !           950:        switch (ep->mode) {
        !           951: 
        !           952:        case VHOLE:
        !           953:        case FHOLE:
        !           954:        case ATBEGIN:
        !           955:        case ATEND:
        !           956:                return 0;
        !           957: 
        !           958:        case WHOLE:
        !           959:        case SUBLIST:
        !           960:                return nodechar(n);
        !           961: 
        !           962:        case SUBSET:
        !           963:                rp = noderepr(n);
        !           964:                for (i = ep->s1; i <= ep->s2; ++i) {
        !           965:                        if (i&1) {
        !           966:                                if (!Fw_zero(rp[i/2]))
        !           967:                                return rp[i/2][0];
        !           968:                        }
        !           969:                        else {
        !           970:                                c = nodechar(child(n, i/2));
        !           971:                                if (c)
        !           972:                                        return c;
        !           973:                        }
        !           974:                }
        !           975:                return 0;
        !           976: 
        !           977:        case SUBRANGE:
        !           978:                if (ep->s1&1)
        !           979:                        str = noderepr(n)[ep->s1/2];
        !           980:                else {
        !           981:                        Assert(Type(child(n, ep->s1/2)) == Tex);
        !           982:                        str = Str((value)child(n, ep->s1/2));
        !           983:                }
        !           984:                return str[ep->s2];
        !           985: 
        !           986:        default:
        !           987:                Abort();
        !           988:                /* NOTREACHED */
        !           989: 
        !           990:        }
        !           991: }
        !           992: 
        !           993: 
        !           994: /*
        !           995:  * Subroutine to return first character of node.
        !           996:  */
        !           997: 
        !           998: Visible int
        !           999: nodechar(n)
        !          1000:        node n;
        !          1001: {
        !          1002:        string *rp;
        !          1003:        int nch;
        !          1004:        int i;
        !          1005:        int c;
        !          1006: 
        !          1007:        if (Type(n) == Tex)
        !          1008:                return Str((value)n)[0];
        !          1009:        rp = noderepr(n);
        !          1010:        if (!Fw_zero(rp[0]))
        !          1011:                return rp[0][0];
        !          1012:        nch = nchildren(n);
        !          1013:        for (i = 1; i <= nch; ++i) {
        !          1014:                c = nodechar(child(n, i));
        !          1015:                if (c)
        !          1016:                        return c;
        !          1017:                if (!Fw_zero(rp[i]))
        !          1018:                        return rp[i][0];
        !          1019:        }
        !          1020:        return 0;
        !          1021: }
        !          1022: 
        !          1023: 
        !          1024: /*
        !          1025:  * Function to compute the actual indentation level at the focus.
        !          1026:  */
        !          1027: 
        !          1028: Visible int
        !          1029: focindent(ep)
        !          1030:        environ *ep;
        !          1031: {
        !          1032:        int y = Ycoord(ep->focus);
        !          1033:        int x = Xcoord(ep->focus);
        !          1034:        int level = Level(ep->focus);
        !          1035:        node n = tree(ep->focus);
        !          1036: 
        !          1037:        switch (ep->mode) {
        !          1038: 
        !          1039:        case WHOLE:
        !          1040:        case ATBEGIN:
        !          1041:        case SUBLIST:
        !          1042:                break;
        !          1043: 
        !          1044:        case ATEND:
        !          1045:                evalcoord(n, 1 + nchildren(n), &y, &x, &level);
        !          1046:                break;
        !          1047: 
        !          1048:        case SUBSET:
        !          1049:        case FHOLE:
        !          1050:        case VHOLE:
        !          1051:                evalcoord(n, ep->s1/2, &y, &x, &level);
        !          1052:                break;
        !          1053: 
        !          1054:        default:
        !          1055:                Abort();
        !          1056:        }
        !          1057:        return level;
        !          1058: }
        !          1059: 
        !          1060: 
        !          1061: /*
        !          1062:  * Routines to move 'environ' structures.
        !          1063:  */
        !          1064: 
        !          1065: emove(s, d)
        !          1066:        environ *s;
        !          1067:        environ *d;
        !          1068: {
        !          1069: #ifdef STRUCTASS
        !          1070:        *d = *s;
        !          1071: #else !STRUCTASS
        !          1072:        d->focus = s->focus;
        !          1073: 
        !          1074:        d->mode = s->mode;
        !          1075:        d->copyflag = s->copyflag;
        !          1076:        d->spflag = s->spflag;
        !          1077:        d->changed = s->changed;
        !          1078: 
        !          1079:        d->s1 = s->s1;
        !          1080:        d->s2 = s->s2;
        !          1081:        d->s3 = s->s3;
        !          1082: 
        !          1083:        d->highest = s->highest;
        !          1084: 
        !          1085:        d->copybuffer = s->copybuffer;
        !          1086: #ifdef RECORDING
        !          1087:        d->oldmacro = s->oldmacro;
        !          1088:        d->newmacro = s->newmacro;
        !          1089: #endif RECORDING
        !          1090: 
        !          1091:        d->generation = s->generation;
        !          1092: #endif !STRUCTASS
        !          1093: }
        !          1094: 
        !          1095: ecopy(s, d)
        !          1096:        environ *s;
        !          1097:        environ *d;
        !          1098: {
        !          1099:        emove(s, d);
        !          1100:        pathcopy(d->focus);
        !          1101:        copy(d->copybuffer);
        !          1102: #ifdef RECORDING
        !          1103:        copy(d->oldmacro);
        !          1104:        copy(d->newmacro);
        !          1105: #endif RECORDING
        !          1106: }
        !          1107: 
        !          1108: erelease(e)
        !          1109:        environ *e;
        !          1110: {
        !          1111:        pathrelease(e->focus);
        !          1112:        release(e->copybuffer);
        !          1113: #ifdef RECORDING
        !          1114:        release(e->oldmacro);
        !          1115:        release(e->newmacro);
        !          1116: #endif RECORDING
        !          1117: }

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