Return to ex_voper.c CVS log

Up to [Research Unix] / researchv10no / cmd / ex

Annotation of researchv10no/cmd/ex/ex_voper.c, revision 1.1

1.1     ! root        1: /* Copyright (c) 1981 Regents of the University of California */
        !             2: static char *sccsid = "@(#)ex_voper.c  7.2     10/31/81";
        !             3: #include "ex.h"
        !             4: #include "ex_tty.h"
        !             5: #include "ex_vis.h"
        !             6: 
        !             7: #define        blank()         isspace(wcursor[0])
        !             8: #define        forbid(a)       if (a) goto errlab;
        !             9: 
        !            10: char   vscandir[2] =   { '/', 0 };
        !            11: 
        !            12: /*
        !            13:  * Decode an operator/operand type command.
        !            14:  * Eventually we switch to an operator subroutine in ex_vops.c.
        !            15:  * The work here is setting up a function variable to point
        !            16:  * to the routine we want, and manipulation of the variables
        !            17:  * wcursor and wdot, which mark the other end of the affected
        !            18:  * area.  If wdot is zero, then the current line is the other end,
        !            19:  * and if wcursor is zero, then the first non-blank location of the
        !            20:  * other line is implied.
        !            21:  */
        !            22: operate(c, cnt)
        !            23:        register int c, cnt;
        !            24: {
        !            25:        register int i;
        !            26:        int (*moveop)(), (*deleteop)();
        !            27:        register int (*opf)();
        !            28:        bool subop = 0;
        !            29:        char *oglobp, *ocurs;
        !            30:        register line *addr;
        !            31:        line *odot;
        !            32:        static char lastFKND, lastFCHR;
        !            33:        short d;
        !            34: 
        !            35:        moveop = vmove, deleteop = vdelete;
        !            36:        wcursor = cursor;
        !            37:        wdot = NOLINE;
        !            38:        notecnt = 0;
        !            39:        dir = 1;
        !            40:        switch (c) {
        !            41: 
        !            42:        /*
        !            43:         * d            delete operator.
        !            44:         */
        !            45:        case 'd':
        !            46:                moveop = vdelete;
        !            47:                deleteop = beep;
        !            48:                break;
        !            49: 
        !            50:        /*
        !            51:         * s            substitute characters, like c\040, i.e. change space.
        !            52:         */
        !            53:        case 's':
        !            54:                ungetkey(' ');
        !            55:                subop++;
        !            56:                /* fall into ... */
        !            57: 
        !            58:        /*
        !            59:         * c            Change operator.
        !            60:         */
        !            61:        case 'c':
        !            62:                if (c == 'c' && workcmd[0] == 'C' || workcmd[0] == 'S')
        !            63:                        subop++;
        !            64:                moveop = vchange;
        !            65:                deleteop = beep;
        !            66:                break;
        !            67: 
        !            68:        /*
        !            69:         * !            Filter through a UNIX command.
        !            70:         */
        !            71:        case '!':
        !            72:                moveop = vfilter;
        !            73:                deleteop = beep;
        !            74:                break;
        !            75: 
        !            76:        /*
        !            77:         * y            Yank operator.  Place specified text so that it
        !            78:         *              can be put back with p/P.  Also yanks to named buffers.
        !            79:         */
        !            80:        case 'y':
        !            81:                moveop = vyankit;
        !            82:                deleteop = beep;
        !            83:                break;
        !            84: 
        !            85:        /*
        !            86:         * =            Reformat operator (for LISP).
        !            87:         */
        !            88: #ifdef LISPCODE
        !            89:        case '=':
        !            90:                forbid(!value(LISP));
        !            91:                /* fall into ... */
        !            92: #endif
        !            93: 
        !            94:        /*
        !            95:         * >            Right shift operator.
        !            96:         * <            Left shift operator.
        !            97:         */
        !            98:        case '<':
        !            99:        case '>':
        !           100:                moveop = vshftop;
        !           101:                deleteop = beep;
        !           102:                break;
        !           103: 
        !           104:        /*
        !           105:         * r            Replace character under cursor with single following
        !           106:         *              character.
        !           107:         */
        !           108:        case 'r':
        !           109:                vmacchng(1);
        !           110:                vrep(cnt);
        !           111:                return;
        !           112: 
        !           113:        default:
        !           114:                goto nocount;
        !           115:        }
        !           116:        vmacchng(1);
        !           117:        /*
        !           118:         * Had an operator, so accept another count.
        !           119:         * Multiply counts together.
        !           120:         */
        !           121:        if (isdigit(peekkey()) && peekkey() != '0') {
        !           122:                cnt *= vgetcnt();
        !           123:                Xcnt = cnt;
        !           124:                forbid (cnt <= 0);
        !           125:        }
        !           126: 
        !           127:        /*
        !           128:         * Get next character, mapping it and saving as
        !           129:         * part of command for repeat.
        !           130:         */
        !           131:        c = map(getesc(),arrows);
        !           132:        if (c == 0)
        !           133:                return;
        !           134:        if (!subop)
        !           135:                *lastcp++ = c;
        !           136: nocount:
        !           137:        opf = moveop;
        !           138:        switch (c) {
        !           139: 
        !           140:        /*
        !           141:         * b            Back up a word.
        !           142:         * B            Back up a word, liberal definition.
        !           143:         */
        !           144:        case 'b':
        !           145:        case 'B':
        !           146:                dir = -1;
        !           147:                /* fall into ... */
        !           148: 
        !           149:        /*
        !           150:         * w            Forward a word.
        !           151:         * W            Forward a word, liberal definition.
        !           152:         */
        !           153:        case 'W':
        !           154:        case 'w':
        !           155:                wdkind = c & ' ';
        !           156:                forbid(lfind(2, cnt, opf, 0) < 0);
        !           157:                vmoving = 0;
        !           158:                break;
        !           159: 
        !           160:        /*
        !           161:         * E            to end of following blank/nonblank word
        !           162:         */
        !           163:        case 'E':
        !           164:                wdkind = 0;
        !           165:                goto ein;
        !           166: 
        !           167:        /*
        !           168:         * e            To end of following word.
        !           169:         */
        !           170:        case 'e':
        !           171:                wdkind = 1;
        !           172: ein:
        !           173:                forbid(lfind(3, cnt - 1, opf, 0) < 0);
        !           174:                vmoving = 0;
        !           175:                break;
        !           176: 
        !           177:        /*
        !           178:         * (            Back an s-expression.
        !           179:         */
        !           180:        case '(':
        !           181:                dir = -1;
        !           182:                /* fall into... */
        !           183: 
        !           184:        /*
        !           185:         * )            Forward an s-expression.
        !           186:         */
        !           187:        case ')':
        !           188:                forbid(lfind(0, cnt, opf, (line *) 0) < 0);
        !           189:                markDOT();
        !           190:                break;
        !           191: 
        !           192:        /*
        !           193:         * {            Back an s-expression, but don't stop on atoms.
        !           194:         *              In text mode, a paragraph.  For C, a balanced set
        !           195:         *              of {}'s.
        !           196:         */
        !           197:        case '{':
        !           198:                dir = -1;
        !           199:                /* fall into... */
        !           200: 
        !           201:        /*
        !           202:         * }            Forward an s-expression, but don't stop on atoms.
        !           203:         *              In text mode, back paragraph.  For C, back a balanced
        !           204:         *              set of {}'s.
        !           205:         */
        !           206:        case '}':
        !           207:                forbid(lfind(1, cnt, opf, (line *) 0) < 0);
        !           208:                markDOT();
        !           209:                break;
        !           210: 
        !           211:        /*
        !           212:         * %            To matching () or {}.  If not at ( or { scan for
        !           213:         *              first such after cursor on this line.
        !           214:         */
        !           215:        case '%':
        !           216:                vsave();
        !           217:                i = lmatchp((line *) 0);
        !           218: #ifdef TRACE
        !           219:                if (trace)
        !           220:                        fprintf(trace, "after lmatchp in %, dot=%d, wdot=%d, dol=%d\n", lineno(dot), lineno(wdot), lineno(dol));
        !           221: #endif
        !           222:                getDOT();
        !           223:                forbid(!i);
        !           224:                if (opf != vmove)
        !           225:                        if (dir > 0)
        !           226:                                wcursor++;
        !           227:                        else
        !           228:                                cursor++;
        !           229:                else
        !           230:                        markDOT();
        !           231:                vmoving = 0;
        !           232:                break;
        !           233: 
        !           234:        /*
        !           235:         * [            Back to beginning of defun, i.e. an ( in column 1.
        !           236:         *              For text, back to a section macro.
        !           237:         *              For C, back to a { in column 1 (~~ beg of function.)
        !           238:         */
        !           239:        case '[':
        !           240:                dir = -1;
        !           241:                /* fall into ... */
        !           242: 
        !           243:        /*
        !           244:         * ]            Forward to next defun, i.e. a ( in column 1.
        !           245:         *              For text, forward section.
        !           246:         *              For C, forward to a } in column 1 (if delete or such)
        !           247:         *              or if a move to a { in column 1.
        !           248:         */
        !           249:        case ']':
        !           250:                if (!vglobp)
        !           251:                        forbid(getkey() != c);
        !           252:                forbid (Xhadcnt);
        !           253:                vsave();
        !           254:                i = lbrack(c, opf);
        !           255:                getDOT();
        !           256:                forbid(!i);
        !           257:                markDOT();
        !           258:                if (ospeed > B300)
        !           259:                        hold |= HOLDWIG;
        !           260:                break;
        !           261: 
        !           262:        /*
        !           263:         * ,            Invert last find with f F t or T, like inverse
        !           264:         *              of ;.
        !           265:         */
        !           266:        case ',':
        !           267:                forbid (lastFKND == 0);
        !           268:                c = isupper(lastFKND) ? tolower(lastFKND) : toupper(lastFKND);
        !           269:                i = lastFCHR;
        !           270:                if (vglobp == 0)
        !           271:                        vglobp = "";
        !           272:                subop++;
        !           273:                goto nocount;
        !           274: 
        !           275:        /*
        !           276:         * 0            To beginning of real line.
        !           277:         */
        !           278:        case '0':
        !           279:                wcursor = linebuf;
        !           280:                vmoving = 0;
        !           281:                break;
        !           282: 
        !           283:        /*
        !           284:         * ;            Repeat last find with f F t or T.
        !           285:         */
        !           286:        case ';':
        !           287:                forbid (lastFKND == 0);
        !           288:                c = lastFKND;
        !           289:                i = lastFCHR;
        !           290:                subop++;
        !           291:                goto nocount;
        !           292: 
        !           293:        /*
        !           294:         * F            Find single character before cursor in current line.
        !           295:         * T            Like F, but stops before character.
        !           296:         */
        !           297:        case 'F':       /* inverted find */
        !           298:        case 'T':
        !           299:                dir = -1;
        !           300:                /* fall into ... */
        !           301: 
        !           302:        /*
        !           303:         * f            Find single character following cursor in current line.
        !           304:         * t            Like f, but stope before character.
        !           305:         */
        !           306:        case 'f':       /* find */
        !           307:        case 't':
        !           308:                if (!subop) {
        !           309:                        i = getesc();
        !           310:                        if (i == 0)
        !           311:                                return;
        !           312:                        *lastcp++ = i;
        !           313:                }
        !           314:                if (vglobp == 0)
        !           315:                        lastFKND = c, lastFCHR = i;
        !           316:                for (; cnt > 0; cnt--)
        !           317:                        forbid (find(i) == 0);
        !           318:                vmoving = 0;
        !           319:                switch (c) {
        !           320: 
        !           321:                case 'T':
        !           322:                        wcursor++;
        !           323:                        break;
        !           324: 
        !           325:                case 't':
        !           326:                        wcursor--;
        !           327:                case 'f':
        !           328: fixup:
        !           329:                        if (moveop != vmove)
        !           330:                                wcursor++;
        !           331:                        break;
        !           332:                }
        !           333:                break;
        !           334: 
        !           335:        /*
        !           336:         * |            Find specified print column in current line.
        !           337:         */
        !           338:        case '|':
        !           339:                if (Pline == numbline)
        !           340:                        cnt += 8;
        !           341:                vmovcol = cnt;
        !           342:                vmoving = 1;
        !           343:                wcursor = vfindcol(cnt);
        !           344:                break;
        !           345: 
        !           346:        /*
        !           347:         * ^            To beginning of non-white space on line.
        !           348:         */
        !           349:        case '^':
        !           350:                wcursor = vskipwh(linebuf);
        !           351:                vmoving = 0;
        !           352:                break;
        !           353: 
        !           354:        /*
        !           355:         * $            To end of line.
        !           356:         */
        !           357:        case '$':
        !           358:                if (opf == vmove) {
        !           359:                        vmoving = 1;
        !           360:                        vmovcol = 20000;
        !           361:                } else
        !           362:                        vmoving = 0;
        !           363:                if (cnt > 1) {
        !           364:                        if (opf == vmove) {
        !           365:                                wcursor = 0;
        !           366:                                cnt--;
        !           367:                        } else
        !           368:                                wcursor = linebuf;
        !           369:                        /* This is wrong at EOF */
        !           370:                        wdot = dot + cnt;
        !           371:                        break;
        !           372:                }
        !           373:                if (linebuf[0]) {
        !           374:                        wcursor = strend(linebuf) - 1;
        !           375:                        goto fixup;
        !           376:                }
        !           377:                wcursor = linebuf;
        !           378:                break;
        !           379: 
        !           380:        /*
        !           381:         * h            Back a character.
        !           382:         * ^H           Back a character.
        !           383:         */
        !           384:        case 'h':
        !           385:        case CTRL(h):
        !           386:                dir = -1;
        !           387:                /* fall into ... */
        !           388: 
        !           389:        /*
        !           390:         * space        Forward a character.
        !           391:         */
        !           392:        case 'l':
        !           393:        case ' ':
        !           394:                forbid (margin() || opf == vmove && edge());
        !           395:                while (cnt > 0 && !margin())
        !           396:                        wcursor += dir, cnt--;
        !           397:                if (margin() && opf == vmove || wcursor < linebuf)
        !           398:                        wcursor -= dir;
        !           399:                vmoving = 0;
        !           400:                break;
        !           401: 
        !           402:        /*
        !           403:         * D            Delete to end of line, short for d$.
        !           404:         */
        !           405:        case 'D':
        !           406:                cnt = INF;
        !           407:                goto deleteit;
        !           408: 
        !           409:        /*
        !           410:         * X            Delete character before cursor.
        !           411:         */
        !           412:        case 'X':
        !           413:                dir = -1;
        !           414:                /* fall into ... */
        !           415: deleteit:
        !           416:        /*
        !           417:         * x            Delete character at cursor, leaving cursor where it is.
        !           418:         */
        !           419:        case 'x':
        !           420:                if (margin())
        !           421:                        goto errlab;
        !           422:                vmacchng(1);
        !           423:                while (cnt > 0 && !margin())
        !           424:                        wcursor += dir, cnt--;
        !           425:                opf = deleteop;
        !           426:                vmoving = 0;
        !           427:                break;
        !           428: 
        !           429:        default:
        !           430:                /*
        !           431:                 * Stuttered operators are equivalent to the operator on
        !           432:                 * a line, thus turn dd into d_.
        !           433:                 */
        !           434:                if (opf == vmove || c != workcmd[0]) {
        !           435: errlab:
        !           436:                        beep();
        !           437:                        vmacp = 0;
        !           438:                        return;
        !           439:                }
        !           440:                /* fall into ... */
        !           441: 
        !           442:        /*
        !           443:         * _            Target for a line or group of lines.
        !           444:         *              Stuttering is more convenient; this is mostly
        !           445:         *              for aesthetics.
        !           446:         */
        !           447:        case '_':
        !           448:                wdot = dot + cnt - 1;
        !           449:                vmoving = 0;
        !           450:                wcursor = 0;
        !           451:                break;
        !           452: 
        !           453:        /*
        !           454:         * H            To first, home line on screen.
        !           455:         *              Count is for count'th line rather than first.
        !           456:         */
        !           457:        case 'H':
        !           458:                wdot = (dot - vcline) + cnt - 1;
        !           459:                if (opf == vmove)
        !           460:                        markit(wdot);
        !           461:                vmoving = 0;
        !           462:                wcursor = 0;
        !           463:                break;
        !           464: 
        !           465:        /*
        !           466:         * -            Backwards lines, to first non-white character.
        !           467:         */
        !           468:        case '-':
        !           469:                wdot = dot - cnt;
        !           470:                vmoving = 0;
        !           471:                wcursor = 0;
        !           472:                break;
        !           473: 
        !           474:        /*
        !           475:         * ^P           To previous line same column.  Ridiculous on the
        !           476:         *              console of the VAX since it puts console in LSI mode.
        !           477:         */
        !           478:        case 'k':
        !           479:        case CTRL(p):
        !           480:                wdot = dot - cnt;
        !           481:                if (vmoving == 0)
        !           482:                        vmoving = 1, vmovcol = column(cursor);
        !           483:                wcursor = 0;
        !           484:                break;
        !           485: 
        !           486:        /*
        !           487:         * L            To last line on screen, or count'th line from the
        !           488:         *              bottom.
        !           489:         */
        !           490:        case 'L':
        !           491:                wdot = dot + vcnt - vcline - cnt;
        !           492:                if (opf == vmove)
        !           493:                        markit(wdot);
        !           494:                vmoving = 0;
        !           495:                wcursor = 0;
        !           496:                break;
        !           497: 
        !           498:        /*
        !           499:         * M            To the middle of the screen.
        !           500:         */
        !           501:        case 'M':
        !           502:                wdot = dot + ((vcnt + 1) / 2) - vcline - 1;
        !           503:                if (opf == vmove)
        !           504:                        markit(wdot);
        !           505:                vmoving = 0;
        !           506:                wcursor = 0;
        !           507:                break;
        !           508: 
        !           509:        /*
        !           510:         * +            Forward line, to first non-white.
        !           511:         *
        !           512:         * CR           Convenient synonym for +.
        !           513:         */
        !           514:        case '+':
        !           515:        case CR:
        !           516:                wdot = dot + cnt;
        !           517:                vmoving = 0;
        !           518:                wcursor = 0;
        !           519:                break;
        !           520: 
        !           521:        /*
        !           522:         * ^N           To next line, same column if possible.
        !           523:         *
        !           524:         * LF           Linefeed is a convenient synonym for ^N.
        !           525:         */
        !           526:        case CTRL(n):
        !           527:        case 'j':
        !           528:        case NL:
        !           529:                wdot = dot + cnt;
        !           530:                if (vmoving == 0)
        !           531:                        vmoving = 1, vmovcol = column(cursor);
        !           532:                wcursor = 0;
        !           533:                break;
        !           534: 
        !           535:        /*
        !           536:         * n            Search to next match of current pattern.
        !           537:         */
        !           538:        case 'n':
        !           539:                vglobp = vscandir;
        !           540:                c = *vglobp++;
        !           541:                goto nocount;
        !           542: 
        !           543:        /*
        !           544:         * N            Like n but in reverse direction.
        !           545:         */
        !           546:        case 'N':
        !           547:                vglobp = vscandir[0] == '/' ? "?" : "/";
        !           548:                c = *vglobp++;
        !           549:                goto nocount;
        !           550: 
        !           551:        /*
        !           552:         * '            Return to line specified by following mark,
        !           553:         *              first white position on line.
        !           554:         *
        !           555:         * `            Return to marked line at remembered column.
        !           556:         */
        !           557:        case '\'':
        !           558:        case '`':
        !           559:                d = c;
        !           560:                c = getesc();
        !           561:                if (c == 0)
        !           562:                        return;
        !           563:                c = markreg(c);
        !           564:                forbid (c == 0);
        !           565:                wdot = getmark(c);
        !           566:                forbid (wdot == NOLINE);
        !           567:                forbid (Xhadcnt);
        !           568:                vmoving = 0;
        !           569:                wcursor = d == '`' ? ncols[c - 'a'] : 0;
        !           570:                if (opf == vmove && (wdot != dot || (d == '`' && wcursor != cursor)))
        !           571:                        markDOT();
        !           572:                if (wcursor) {
        !           573:                        vsave();
        !           574:                        getline(*wdot);
        !           575:                        if (wcursor > strend(linebuf))
        !           576:                                wcursor = 0;
        !           577:                        getDOT();
        !           578:                }
        !           579:                if (ospeed > B300)
        !           580:                        hold |= HOLDWIG;
        !           581:                break;
        !           582: 
        !           583:        /*
        !           584:         * G            Goto count'th line, or last line if no count
        !           585:         *              given.
        !           586:         */
        !           587:        case 'G':
        !           588:                if (!Xhadcnt)
        !           589:                        cnt = lineDOL();
        !           590:                wdot = zero + cnt;
        !           591:                forbid (wdot < one || wdot > dol);
        !           592:                if (opf == vmove)
        !           593:                        markit(wdot);
        !           594:                vmoving = 0;
        !           595:                wcursor = 0;
        !           596:                break;
        !           597: 
        !           598:        /*
        !           599:         * /            Scan forward for following re.
        !           600:         * ?            Scan backward for following re.
        !           601:         */
        !           602:        case '/':
        !           603:        case '?':
        !           604:                forbid (Xhadcnt);
        !           605:                vsave();
        !           606:                ocurs = cursor;
        !           607:                odot = dot;
        !           608:                wcursor = 0;
        !           609:                if (readecho(c))
        !           610:                        return;
        !           611:                if (!vglobp)
        !           612:                        vscandir[0] = genbuf[0];
        !           613:                oglobp = globp; CP(vutmp, genbuf); globp = vutmp;
        !           614:                d = peekc;
        !           615: fromsemi:
        !           616:                ungetchar(0);
        !           617:                fixech();
        !           618:                CATCH
        !           619: #ifndef CBREAK
        !           620:                        /*
        !           621:                         * Lose typeahead (ick).
        !           622:                         */
        !           623:                        vcook();
        !           624: #endif
        !           625:                        addr = address(cursor);
        !           626: #ifndef CBREAK
        !           627:                        vraw();
        !           628: #endif
        !           629:                ONERR
        !           630: #ifndef CBREAK
        !           631:                        vraw();
        !           632: #endif
        !           633: slerr:
        !           634:                        globp = oglobp;
        !           635:                        dot = odot;
        !           636:                        cursor = ocurs;
        !           637:                        ungetchar(d);
        !           638:                        splitw = 0;
        !           639:                        vclean();
        !           640:                        vjumpto(dot, ocurs, 0);
        !           641:                        return;
        !           642:                ENDCATCH
        !           643:                if (globp == 0)
        !           644:                        globp = "";
        !           645:                else if (peekc)
        !           646:                        --globp;
        !           647:                if (*globp == ';') {
        !           648:                        /* /foo/;/bar/ */
        !           649:                        globp++;
        !           650:                        dot = addr;
        !           651:                        cursor = loc1;
        !           652:                        goto fromsemi;
        !           653:                }
        !           654:                dot = odot;
        !           655:                ungetchar(d);
        !           656:                c = 0;
        !           657:                if (*globp == 'z')
        !           658:                        globp++, c = '\n';
        !           659:                if (any(*globp, "^+-."))
        !           660:                        c = *globp++;
        !           661:                i = 0;
        !           662:                while (isdigit(*globp))
        !           663:                        i = i * 10 + *globp++ - '0';
        !           664:                if (any(*globp, "^+-."))
        !           665:                        c = *globp++;
        !           666:                if (*globp) {
        !           667:                        /* random junk after the pattern */
        !           668:                        beep();
        !           669:                        goto slerr;
        !           670:                }
        !           671:                globp = oglobp;
        !           672:                splitw = 0;
        !           673:                vmoving = 0;
        !           674:                wcursor = loc1;
        !           675:                if (i != 0)
        !           676:                        vsetsiz(i);
        !           677:                if (opf == vmove) {
        !           678:                        if (state == ONEOPEN || state == HARDOPEN)
        !           679:                                outline = destline = WBOT;
        !           680:                        if (addr != dot || loc1 != cursor)
        !           681:                                markDOT();
        !           682:                        if (loc1 > linebuf && *loc1 == 0)
        !           683:                                loc1--;
        !           684:                        if (c)
        !           685:                                vjumpto(addr, loc1, c);
        !           686:                        else {
        !           687:                                vmoving = 0;
        !           688:                                if (loc1) {
        !           689:                                        vmoving++;
        !           690:                                        vmovcol = column(loc1);
        !           691:                                }
        !           692:                                getDOT();
        !           693:                                if (state == CRTOPEN && addr != dot)
        !           694:                                        vup1();
        !           695:                                vupdown(addr - dot, NOSTR);
        !           696:                        }
        !           697:                        return;
        !           698:                }
        !           699:                lastcp[-1] = 'n';
        !           700:                getDOT();
        !           701:                wdot = addr;
        !           702:                break;
        !           703:        }
        !           704:        /*
        !           705:         * Apply.
        !           706:         */
        !           707:        if (vreg && wdot == 0)
        !           708:                wdot = dot;
        !           709:        (*opf)(c);
        !           710:        wdot = NOLINE;
        !           711: }
        !           712: 
        !           713: /*
        !           714:  * Find single character c, in direction dir from cursor.
        !           715:  */
        !           716: find(c)
        !           717:        char c;
        !           718: {
        !           719: 
        !           720:        for(;;) {
        !           721:                if (edge())
        !           722:                        return (0);
        !           723:                wcursor += dir;
        !           724:                if (*wcursor == c)
        !           725:                        return (1);
        !           726:        }
        !           727: }
        !           728: 
        !           729: /*
        !           730:  * Do a word motion with operator op, and cnt more words
        !           731:  * to go after this.
        !           732:  */
        !           733: word(op, cnt)
        !           734:        register int (*op)();
        !           735:        int cnt;
        !           736: {
        !           737:        register int which;
        !           738:        register char *iwc;
        !           739:        register line *iwdot = wdot;
        !           740: 
        !           741:        if (dir == 1) {
        !           742:                iwc = wcursor;
        !           743:                which = wordch(wcursor);
        !           744:                while (wordof(which, wcursor)) {
        !           745:                        if (cnt == 1 && op != vmove && wcursor[1] == 0) {
        !           746:                                wcursor++;
        !           747:                                break;
        !           748:                        }
        !           749:                        if (!lnext())
        !           750:                                return (0);
        !           751:                        if (wcursor == linebuf)
        !           752:                                break;
        !           753:                }
        !           754:                /* Unless last segment of a change skip blanks */
        !           755:                if (op != vchange || cnt > 1)
        !           756:                        while (!margin() && blank())
        !           757:                                wcursor++;
        !           758:                else
        !           759:                        if (wcursor == iwc && iwdot == wdot && *iwc)
        !           760:                                wcursor++;
        !           761:                if (op == vmove && margin())
        !           762:                        wcursor--;
        !           763:        } else {
        !           764:                if (!lnext())
        !           765:                        return (0);
        !           766:                while (blank())
        !           767:                        if (!lnext())
        !           768:                                return (0);
        !           769:                if (!margin()) {
        !           770:                        which = wordch(wcursor);
        !           771:                        while (!margin() && wordof(which, wcursor))
        !           772:                                wcursor--;
        !           773:                }
        !           774:                if (wcursor < linebuf || !wordof(which, wcursor))
        !           775:                        wcursor++;
        !           776:        }
        !           777:        return (1);
        !           778: }
        !           779: 
        !           780: /*
        !           781:  * To end of word, with operator op and cnt more motions
        !           782:  * remaining after this.
        !           783:  */
        !           784: eend(op)
        !           785:        register int (*op)();
        !           786: {
        !           787:        register int which;
        !           788: 
        !           789:        if (!lnext())
        !           790:                return;
        !           791:        while (blank())
        !           792:                if (!lnext())
        !           793:                        return;
        !           794:        which = wordch(wcursor);
        !           795:        while (wordof(which, wcursor)) {
        !           796:                if (wcursor[1] == 0) {
        !           797:                        wcursor++;
        !           798:                        break;
        !           799:                }
        !           800:                if (!lnext())
        !           801:                        return;
        !           802:        }
        !           803:        if (op != vchange && op != vdelete && wcursor > linebuf)
        !           804:                wcursor--;
        !           805: }
        !           806: 
        !           807: /*
        !           808:  * Wordof tells whether the character at *wc is in a word of
        !           809:  * kind which (blank/nonblank words are 0, conservative words 1).
        !           810:  */
        !           811: wordof(which, wc)
        !           812:        char which;
        !           813:        register char *wc;
        !           814: {
        !           815: 
        !           816:        if (isspace(*wc))
        !           817:                return (0);
        !           818:        return (!wdkind || wordch(wc) == which);
        !           819: }
        !           820: 
        !           821: /*
        !           822:  * Wordch tells whether character at *wc is a word character
        !           823:  * i.e. an alfa, digit, or underscore.
        !           824:  */
        !           825: wordch(wc)
        !           826:        char *wc;
        !           827: {
        !           828:        register int c;
        !           829: 
        !           830:        c = wc[0];
        !           831:        return (isalpha(c) || isdigit(c) || c == '_');
        !           832: }
        !           833: 
        !           834: /*
        !           835:  * Edge tells when we hit the last character in the current line.
        !           836:  */
        !           837: edge()
        !           838: {
        !           839: 
        !           840:        if (linebuf[0] == 0)
        !           841:                return (1);
        !           842:        if (dir == 1)
        !           843:                return (wcursor[1] == 0);
        !           844:        else
        !           845:                return (wcursor == linebuf);
        !           846: }
        !           847: 
        !           848: /*
        !           849:  * Margin tells us when we have fallen off the end of the line.
        !           850:  */
        !           851: margin()
        !           852: {
        !           853: 
        !           854:        return (wcursor < linebuf || wcursor[0] == 0);
        !           855: }

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