Return to tktxidx.c CVS log

Up to [Micropolis - Activity] / micropolis / src / tk

Annotation of micropolis/src/tk/tktxidx.c, revision 1.1

1.1     ! root        1: /* 
        !             2:  * tkTextIndex.c --
        !             3:  *
        !             4:  *     This module provides procedures that manipulate indices for
        !             5:  *     text widgets.
        !             6:  *
        !             7:  * Copyright 1992 Regents of the University of California.
        !             8:  * Permission to use, copy, modify, and distribute this
        !             9:  * software and its documentation for any purpose and without
        !            10:  * fee is hereby granted, provided that the above copyright
        !            11:  * notice appear in all copies.  The University of California
        !            12:  * makes no representations about the suitability of this
        !            13:  * software for any purpose.  It is provided "as is" without
        !            14:  * express or implied warranty.
        !            15:  */
        !            16: 
        !            17: #ifndef lint
        !            18: static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkTextIndex.c,v 1.2 92/07/16 16:32:26 ouster Exp $ SPRITE (Berkeley)";
        !            19: #endif
        !            20: 
        !            21: #include "default.h"
        !            22: #include "tkconfig.h"
        !            23: #include "tk.h"
        !            24: #include "tktext.h"
        !            25: 
        !            26: /*
        !            27:  * Forward declarations for procedures defined later in this file:
        !            28:  */
        !            29: 
        !            30: static void            BackwardChars _ANSI_ARGS_((TkText *textPtr,
        !            31:                            TkTextLine *linePtr, int *lineIndexPtr,
        !            32:                            int *chPtr, int count));
        !            33: static char *          ForwBack _ANSI_ARGS_((TkText *textPtr,
        !            34:                            char *string, int *lineIndexPtr, int *chPtr));
        !            35: static void            ForwardChars _ANSI_ARGS_((TkText *textPtr,
        !            36:                            TkTextLine *linePtr, int *lineIndexPtr,
        !            37:                            int *chPtr, int count));
        !            38: static char *          StartEnd _ANSI_ARGS_((TkText *textPtr,
        !            39:                            char *string, int *lineIndexPtr, int *chPtr));
        !            40: 
        !            41: /*
        !            42:  *----------------------------------------------------------------------
        !            43:  *
        !            44:  * TkTextGetIndex --
        !            45:  *
        !            46:  *     Given a string, return the line and character indices that
        !            47:  *     it describes.
        !            48:  *
        !            49:  * Results:
        !            50:  *     The return value is a standard Tcl return result.  If
        !            51:  *     TCL_OK is returned, then everything went well and information
        !            52:  *     is stored at *lineIndexPtr and *chPtr;  otherwise TCL_ERROR
        !            53:  *     is returned and an error message is left in interp->result.
        !            54:  *
        !            55:  * Side effects:
        !            56:  *     None.
        !            57:  *
        !            58:  *----------------------------------------------------------------------
        !            59:  */
        !            60: 
        !            61: int
        !            62: TkTextGetIndex(interp, textPtr, string, lineIndexPtr, chPtr)
        !            63:     Tcl_Interp *interp;                /* Use this for error reporting. */
        !            64:     TkText *textPtr;           /* Information about text widget. */
        !            65:     char *string;              /* Textual description of position. */
        !            66:     int *lineIndexPtr;         /* Store line number here. */
        !            67:     int *chPtr;                        /* Store character position here. */
        !            68: {
        !            69:     register char *p;
        !            70:     char *end, *endOfBase;
        !            71:     TkTextLine *linePtr;
        !            72:     Tcl_HashEntry *hPtr;
        !            73:     TkAnnotation *markPtr;
        !            74:     TkTextTag *tagPtr;
        !            75:     TkTextSearch search;
        !            76:     int first;
        !            77:     char c;
        !            78: 
        !            79:     /*
        !            80:      *------------------------------------------------
        !            81:      * Stage 1: parse the base index.
        !            82:      *------------------------------------------------
        !            83:      */
        !            84: 
        !            85:     if (string[0] == '@') {
        !            86:        /*
        !            87:         * Find character at a given x,y location in the window.
        !            88:         */
        !            89: 
        !            90:        int x, y;
        !            91: 
        !            92:        p = string+1;
        !            93:        x = strtol(p, &end, 0);
        !            94:        if ((end == p) || (*end != ',')) {
        !            95:            goto error;
        !            96:        }
        !            97:        p = end+1;
        !            98:        y = strtol(p, &end, 0);
        !            99:        if (end == p) {
        !           100:            goto error;
        !           101:        }
        !           102:        *lineIndexPtr = TkBTreeLineIndex(TkTextCharAtLoc(textPtr, x,
        !           103:                y, chPtr));
        !           104:        endOfBase = end;
        !           105:        goto gotBase; 
        !           106:     } else if (isdigit(string[0]) || (string[0] == '-')) {
        !           107:        /*
        !           108:         * Base is identified with line and character indices.
        !           109:         */
        !           110: 
        !           111:        *lineIndexPtr = strtol(string, &end, 0) - 1;
        !           112:        if ((end == string) || (*end != '.')) {
        !           113:            goto error;
        !           114:        }
        !           115:        p = end+1;
        !           116:        if ((*p == 'e') && (strncmp(p, "end", 3) == 0)) {
        !           117:            linePtr = TkBTreeFindLine(textPtr->tree, *lineIndexPtr);
        !           118:            if (linePtr == NULL) {
        !           119:                Tcl_AppendResult(interp, "bad text index \"", string,
        !           120:                        "\": no such line in text", (char *) NULL);
        !           121:                return TCL_ERROR;
        !           122:            }
        !           123:            *chPtr = linePtr->numBytes - 1;
        !           124:            endOfBase = p+3;
        !           125:            goto gotBase;
        !           126:        } else {
        !           127:            *chPtr = strtol(p, &end, 0);
        !           128:            if (end == p) {
        !           129:                goto error;
        !           130:            }
        !           131:            endOfBase = end;
        !           132:            goto gotBase;
        !           133:        }
        !           134:     }
        !           135: 
        !           136:     for (p = string; *p != 0; p++) {
        !           137:        if (isspace(*p) || (*p == '+') || (*p == '-')) {
        !           138:            break;
        !           139:        }
        !           140:     }
        !           141:     endOfBase = p;
        !           142:     if ((string[0] == 'e')
        !           143:            && (strncmp(string, "end", endOfBase-string) == 0)) {
        !           144:        /*
        !           145:         * Base position is end of text.
        !           146:         */
        !           147: 
        !           148:        *lineIndexPtr = TkBTreeNumLines(textPtr->tree) - 1;
        !           149:        linePtr = TkBTreeFindLine(textPtr->tree, *lineIndexPtr);
        !           150:        *chPtr = linePtr->numBytes - 1;
        !           151:        goto gotBase;
        !           152:     } else {
        !           153:        /*
        !           154:         * See if the base position is the name of a mark.
        !           155:         */
        !           156: 
        !           157:        c = *endOfBase;
        !           158:        *endOfBase = 0;
        !           159:        hPtr = Tcl_FindHashEntry(&textPtr->markTable, string);
        !           160:        *endOfBase = c;
        !           161:        if (hPtr != NULL) {
        !           162:            markPtr = (TkAnnotation *) Tcl_GetHashValue(hPtr);
        !           163:            *lineIndexPtr = TkBTreeLineIndex(markPtr->linePtr);
        !           164:            *chPtr = markPtr->ch;
        !           165:            goto gotBase;
        !           166:        }
        !           167:     }
        !           168: 
        !           169:     /*
        !           170:      * Nothing has worked so far.  See if the base has the form
        !           171:      * "tag.first" or "tag.last" where "tag" is the name of a valid
        !           172:      * tag.
        !           173:      */
        !           174: 
        !           175:     p = strchr(string, '.');
        !           176:     if (p == NULL) {
        !           177:        goto error;
        !           178:     }
        !           179:     if ((p[1] == 'f') && (endOfBase == (p+6))
        !           180:            && (strncmp(p+1, "first", endOfBase - (p+1)) == 0)) {
        !           181:        first = 1;
        !           182:     } else if ((p[1] == 'l') && (endOfBase == (p+5))
        !           183:            && (strncmp(p+1, "last", endOfBase - (p+1)) == 0)) {
        !           184:        first = 0;
        !           185:     } else {
        !           186:        goto error;
        !           187:     }
        !           188:     *p = 0;
        !           189:     hPtr = Tcl_FindHashEntry(&textPtr->tagTable, string);
        !           190:     *p = '.';
        !           191:     if (hPtr == NULL) {
        !           192:        goto error;
        !           193:     }
        !           194:     tagPtr = (TkTextTag *) Tcl_GetHashValue(hPtr);
        !           195:     TkBTreeStartSearch(textPtr->tree, 0, 0, TkBTreeNumLines(textPtr->tree),
        !           196:            0, tagPtr, &search);
        !           197:     if (!TkBTreeNextTag(&search)) {
        !           198:        Tcl_AppendResult(interp,
        !           199:                "text doesn't contain any characters tagged with \"",
        !           200:                Tcl_GetHashKey(&textPtr->tagTable, hPtr), "\"", (char *) NULL);
        !           201:        return TCL_ERROR;
        !           202:     }
        !           203:     if (first) {
        !           204:        *lineIndexPtr = search.line1;
        !           205:        *chPtr = search.ch1;
        !           206:     } else {
        !           207:        while (TkBTreeNextTag(&search)) {
        !           208:            *lineIndexPtr = search.line1;
        !           209:            *chPtr = search.ch1;
        !           210:        }
        !           211:     }
        !           212: 
        !           213:     /*
        !           214:      *-------------------------------------------------------------------
        !           215:      * Stage 2: process zero or more modifiers.  Each modifier is either
        !           216:      * a keyword like "wordend" or "linestart", or it has the form
        !           217:      * "op count units" where op is + or -, count is a number, and units
        !           218:      * is "chars" or "lines".
        !           219:      *-------------------------------------------------------------------
        !           220:      */
        !           221: 
        !           222:     gotBase:
        !           223:     p = endOfBase;
        !           224:     while (1) {
        !           225:        while (isspace(*p)) {
        !           226:            p++;
        !           227:        }
        !           228:        if (*p == 0) {
        !           229:            return TCL_OK;
        !           230:        }
        !           231:     
        !           232:        if ((*p == '+') || (*p == '-')) {
        !           233:            p = ForwBack(textPtr, p, lineIndexPtr, chPtr);
        !           234:        } else {
        !           235:            p = StartEnd(textPtr, p, lineIndexPtr, chPtr);
        !           236:        }
        !           237:        if (p == NULL) {
        !           238:            goto error;
        !           239:        }
        !           240:     }
        !           241: 
        !           242:     error:
        !           243:     Tcl_AppendResult(interp, "bad text index \"", string, "\"",
        !           244:            (char *) NULL);
        !           245:     return TCL_ERROR;
        !           246: }
        !           247: 
        !           248: /*
        !           249:  *----------------------------------------------------------------------
        !           250:  *
        !           251:  * TkTextPrintIndex --
        !           252:  *
        !           253:  *     Given a line number and a character index, this procedure
        !           254:  *     generates a string description of the position, which is
        !           255:  *     suitable for reading in again later.
        !           256:  *
        !           257:  * Results:
        !           258:  *     The characters pointed to by string are modified.
        !           259:  *
        !           260:  * Side effects:
        !           261:  *     None.
        !           262:  *
        !           263:  *----------------------------------------------------------------------
        !           264:  */
        !           265: 
        !           266: void
        !           267: TkTextPrintIndex(line, ch, string)
        !           268:     int line;                  /* Line number. */
        !           269:     int ch;                    /* Character position within line. */
        !           270:     char *string;              /* Place to store the position.  Must have
        !           271:                                 * at least POS_CHARS characters. */
        !           272: {
        !           273:     sprintf(string, "%d.%d", line+1, ch);
        !           274: }
        !           275: 
        !           276: /*
        !           277:  *----------------------------------------------------------------------
        !           278:  *
        !           279:  * TkTextRoundIndex --
        !           280:  *
        !           281:  *     Given a line index and a character index, this procedure
        !           282:  *     adjusts those positions if necessary to correspond to the
        !           283:  *     nearest actual character within the text.
        !           284:  *
        !           285:  * Results:
        !           286:  *     The return value is a pointer to the line structure for
        !           287:  *     the line of the text's B-tree that contains the indicated
        !           288:  *     character.  In addition, *lineIndexPtr and *chPtr are
        !           289:  *     modified if necessary to refer to an existing character
        !           290:  *     in the file.
        !           291:  *
        !           292:  * Side effects:
        !           293:  *     None.
        !           294:  *
        !           295:  *----------------------------------------------------------------------
        !           296:  */
        !           297: 
        !           298: 
        !           299: TkTextLine *
        !           300: TkTextRoundIndex(textPtr, lineIndexPtr, chPtr)
        !           301:     TkText *textPtr;                   /* Information about text widget. */
        !           302:     int *lineIndexPtr;                 /* Points to initial line index,
        !           303:                                         * which is overwritten with actual
        !           304:                                         * line index. */
        !           305:     int *chPtr;                                /* Points to initial character index,
        !           306:                                         * which is overwritten with actual
        !           307:                                         * character index. */
        !           308: {
        !           309:     int line, ch, lastLine;
        !           310:     TkTextLine *linePtr;
        !           311: 
        !           312:     line = *lineIndexPtr;
        !           313:     ch = *chPtr;
        !           314:     if (line < 0) {
        !           315:        line = 0;
        !           316:        ch = 0;
        !           317:     }
        !           318:     lastLine = TkBTreeNumLines(textPtr->tree) - 1;
        !           319:     if (line > lastLine) {
        !           320:        line = lastLine;
        !           321:        linePtr = TkBTreeFindLine(textPtr->tree, line);
        !           322:        ch = linePtr->numBytes - 1;
        !           323:     } else {
        !           324:        linePtr = TkBTreeFindLine(textPtr->tree, line);
        !           325:        if (ch < 0) {
        !           326:            ch = 0;
        !           327:        }
        !           328:        if (ch >= linePtr->numBytes) {
        !           329:            if (line == lastLine) {
        !           330:                ch = linePtr->numBytes - 1;
        !           331:            } else {
        !           332:                line++;
        !           333:                linePtr = TkBTreeNextLine(linePtr);
        !           334:                ch = 0;
        !           335:            }
        !           336:        }
        !           337:     }
        !           338:     *lineIndexPtr = line;
        !           339:     *chPtr = ch;
        !           340:     return linePtr;
        !           341: }
        !           342: 
        !           343: /*
        !           344:  *----------------------------------------------------------------------
        !           345:  *
        !           346:  * ForwBack --
        !           347:  *
        !           348:  *     This procedure handles +/- modifiers for indices to adjust
        !           349:  *     the index forwards or backwards.
        !           350:  *
        !           351:  * Results:
        !           352:  *     If the modifier is successfully parsed then the return value
        !           353:  *     is the address of the first character after the modifier, and
        !           354:  *     *lineIndexPtr and *chPtr are updated to reflect the modifier.
        !           355:  *     If there is a syntax error in the modifier then NULL is returned.
        !           356:  *
        !           357:  * Side effects:
        !           358:  *     None.
        !           359:  *
        !           360:  *----------------------------------------------------------------------
        !           361:  */
        !           362: 
        !           363: static char *
        !           364: ForwBack(textPtr, string, lineIndexPtr, chPtr)
        !           365:     TkText *textPtr;           /* Information about widget that index
        !           366:                                 * refers to. */
        !           367:     char *string;              /* String to parse for additional info
        !           368:                                 * about modifier (count and units). 
        !           369:                                 * Points to "+" or "-" that starts
        !           370:                                 * modifier. */
        !           371:     int *lineIndexPtr;         /* Points to current line index, which will
        !           372:                                 * be updated to reflect modifier. */
        !           373:     int *chPtr;                        /* Points to current character index, which
        !           374:                                 * will be updated to reflect modifier. */
        !           375: {
        !           376:     register char *p;
        !           377:     char *end, *units;
        !           378:     int count, length, lastLine;
        !           379:     TkTextLine *linePtr;
        !           380: 
        !           381:     /*
        !           382:      * Get the count (how many units forward or backward).
        !           383:      */
        !           384: 
        !           385:     p = string+1;
        !           386:     while (isspace(*p)) {
        !           387:        p++;
        !           388:     }
        !           389:     count = strtoul(p, &end, 0);
        !           390:     if (end == p) {
        !           391:        return NULL;
        !           392:     }
        !           393:     p = end;
        !           394:     while (isspace(*p)) {
        !           395:        p++;
        !           396:     }
        !           397: 
        !           398:     /*
        !           399:      * Find the end of this modifier (next space or + or - character),
        !           400:      * then parse the unit specifier and update the position
        !           401:      * accordingly.
        !           402:      */
        !           403: 
        !           404:     units = p; 
        !           405:     while ((*p != 0) && !isspace(*p) && (*p != '+') && (*p != '-')) {
        !           406:        p++;
        !           407:     }
        !           408:     length = p - units;
        !           409:     if ((*units == 'c') && (strncmp(units, "chars", length) == 0)) {
        !           410:        linePtr = TkTextRoundIndex(textPtr, lineIndexPtr, chPtr);
        !           411:        if (*string == '+') {
        !           412:            ForwardChars(textPtr, linePtr, lineIndexPtr, chPtr, count);
        !           413:        } else {
        !           414:            BackwardChars(textPtr, linePtr, lineIndexPtr, chPtr, count);
        !           415:        }
        !           416:     } else if ((*units == 'l') && (strncmp(units, "lines", length) == 0)) {
        !           417:        if (*string == '+') {
        !           418:            *lineIndexPtr += count;
        !           419:            lastLine = TkBTreeNumLines(textPtr->tree) - 1;
        !           420:            if (*lineIndexPtr > lastLine) {
        !           421:                *lineIndexPtr = lastLine;
        !           422:            }
        !           423:        } else {
        !           424:            *lineIndexPtr -= count;
        !           425:            if (*lineIndexPtr < 0) {
        !           426:                *lineIndexPtr = 0;
        !           427:            }
        !           428:        }
        !           429:        linePtr = TkBTreeFindLine(textPtr->tree, *lineIndexPtr);
        !           430:        if (*chPtr >= linePtr->numBytes) {
        !           431:            *chPtr = linePtr->numBytes - 1;
        !           432:        }
        !           433:        if (*chPtr < 0) {
        !           434:            *chPtr = 0;
        !           435:        }
        !           436:     } else {
        !           437:        return NULL;
        !           438:     }
        !           439:     return p;
        !           440: }
        !           441: 
        !           442: /*
        !           443:  *----------------------------------------------------------------------
        !           444:  *
        !           445:  * ForwardChars --
        !           446:  *
        !           447:  *     Given a position in a text widget, this procedure computes
        !           448:  *     a new position that is "count" characters ahead of the given
        !           449:  *     position.
        !           450:  *
        !           451:  * Results:
        !           452:  *     *LineIndexPtr and *chPtr are overwritten with new values
        !           453:  *     corresponding to the new position.
        !           454:  *
        !           455:  * Side effects:
        !           456:  *     None.
        !           457:  *
        !           458:  *----------------------------------------------------------------------
        !           459:  */
        !           460: 
        !           461:        /* ARGSUSED */
        !           462: static void
        !           463: ForwardChars(textPtr, linePtr, lineIndexPtr, chPtr, count)
        !           464:     TkText *textPtr;                   /* Information about text widget. */
        !           465:     register TkTextLine *linePtr;      /* Text line corresponding to
        !           466:                                         * *lineIndexPtr. */
        !           467:     int *lineIndexPtr;                 /* Points to initial line index,
        !           468:                                         * which is overwritten with final
        !           469:                                         * line index. */
        !           470:     int *chPtr;                                /* Points to initial character index,
        !           471:                                         * which is overwritten with final
        !           472:                                         * character index. */
        !           473:     int count;                         /* How many characters forward to
        !           474:                                         * move.  Must not be negative. */
        !           475: {
        !           476:     TkTextLine *nextPtr;
        !           477:     int bytesInLine;
        !           478: 
        !           479:     while (count > 0) {
        !           480:        bytesInLine = linePtr->numBytes - *chPtr;
        !           481:        if (bytesInLine > count) {
        !           482:            *chPtr += count;
        !           483:            return;
        !           484:        }
        !           485:        nextPtr = TkBTreeNextLine(linePtr);
        !           486:        if (nextPtr == NULL) {
        !           487:            *chPtr = linePtr->numBytes - 1;
        !           488:            return;
        !           489:        }
        !           490:        *chPtr = 0;
        !           491:        *lineIndexPtr += 1;
        !           492:        linePtr = nextPtr;
        !           493:        count -= bytesInLine;
        !           494:     }
        !           495: }
        !           496: 
        !           497: /*
        !           498:  *----------------------------------------------------------------------
        !           499:  *
        !           500:  * BackwardChars --
        !           501:  *
        !           502:  *     Given a position in a text widget, this procedure computes
        !           503:  *     a new position that is "count" characters earlier than the given
        !           504:  *     position.
        !           505:  *
        !           506:  * Results:
        !           507:  *     *LineIndexPtr and *chPtr are overwritten with new values
        !           508:  *     corresponding to the new position.
        !           509:  *
        !           510:  * Side effects:
        !           511:  *     None.
        !           512:  *
        !           513:  *----------------------------------------------------------------------
        !           514:  */
        !           515: 
        !           516: static void
        !           517: BackwardChars(textPtr, linePtr, lineIndexPtr, chPtr, count)
        !           518:     TkText *textPtr;                   /* Information about text widget. */
        !           519:     register TkTextLine *linePtr;      /* Text line corresponding to
        !           520:                                         * *lineIndexPtr. */
        !           521:     int *lineIndexPtr;                 /* Points to initial line index,
        !           522:                                         * which is overwritten with final
        !           523:                                         * line index. */
        !           524:     int *chPtr;                                /* Points to initial character index,
        !           525:                                         * which is overwritten with final
        !           526:                                         * character index. */
        !           527:     int count;                         /* How many characters backward to
        !           528:                                         * move.  Must not be negative. */
        !           529: {
        !           530:     int bytesInLine;
        !           531: 
        !           532:     while (count > 0) {
        !           533:        bytesInLine = *chPtr;
        !           534:        if (bytesInLine >= count) {
        !           535:            *chPtr -= count;
        !           536:            return;
        !           537:        }
        !           538:        if (*lineIndexPtr <= 0) {
        !           539:            *chPtr = 0;
        !           540:            return;
        !           541:        }
        !           542:        *lineIndexPtr -= 1;
        !           543:        linePtr = TkBTreeFindLine(textPtr->tree, *lineIndexPtr);
        !           544:        count -= bytesInLine;
        !           545:        *chPtr = linePtr->numBytes;
        !           546:     }
        !           547: }
        !           548: 
        !           549: /*
        !           550:  *----------------------------------------------------------------------
        !           551:  *
        !           552:  * StartEnd --
        !           553:  *
        !           554:  *     This procedure handles modifiers like "wordstart" and "lineend"
        !           555:  *     to adjust indices forwards or backwards.
        !           556:  *
        !           557:  * Results:
        !           558:  *     If the modifier is successfully parsed then the return value
        !           559:  *     is the address of the first character after the modifier, and
        !           560:  *     *lineIndexPtr and *chPtr are updated to reflect the modifier.
        !           561:  *     If there is a syntax error in the modifier then NULL is returned.
        !           562:  *
        !           563:  * Side effects:
        !           564:  *     None.
        !           565:  *
        !           566:  *----------------------------------------------------------------------
        !           567:  */
        !           568: 
        !           569: static char *
        !           570: StartEnd(textPtr, string, lineIndexPtr, chPtr)
        !           571:     TkText *textPtr;           /* Information about widget that index
        !           572:                                 * refers to. */
        !           573:     char *string;              /* String to parse for additional info
        !           574:                                 * about modifier (count and units). 
        !           575:                                 * Points to first character of modifer
        !           576:                                 * word. */
        !           577:     int *lineIndexPtr;         /* Points to current line index, which will
        !           578:                                 * be updated to reflect modifier. */
        !           579:     int *chPtr;                        /* Points to current character index, which
        !           580:                                 * will be updated to reflect modifier. */
        !           581: {
        !           582:     char *p, c;
        !           583:     int length;
        !           584:     register TkTextLine *linePtr;
        !           585: 
        !           586:     /*
        !           587:      * Find the end of the modifier word.
        !           588:      */
        !           589: 
        !           590:     for (p = string; isalnum(*p); p++) {
        !           591:        /* Empty loop body. */
        !           592:     }
        !           593:     length = p-string;
        !           594:     linePtr = TkTextRoundIndex(textPtr, lineIndexPtr, chPtr);
        !           595:     if ((*string == 'l') && (strncmp(string, "lineend", length) == 0)
        !           596:            && (length >= 5)) {
        !           597:        *chPtr = linePtr->numBytes - 1;
        !           598:     } else if ((*string == 'l') && (strncmp(string, "linestart", length) == 0)
        !           599:            && (length >= 5)) {
        !           600:        *chPtr = 0;
        !           601:     } else if ((*string == 'w') && (strncmp(string, "wordend", length) == 0)
        !           602:            && (length >= 5)) {
        !           603:        c = linePtr->bytes[*chPtr];
        !           604:        if (!isalnum(c) && (c != '_')) {
        !           605:            if (*chPtr >= (linePtr->numBytes - 1)) {
        !           606:                /*
        !           607:                 * End of line:  go to start of next line unless this is the
        !           608:                 * last line in the text.
        !           609:                 */
        !           610: 
        !           611:                if (TkBTreeNextLine(linePtr) != NULL) {
        !           612:                    *lineIndexPtr += 1;
        !           613:                    *chPtr = 0;
        !           614:                }
        !           615:            } else {
        !           616:                *chPtr += 1;
        !           617:            }
        !           618:        } else {
        !           619:            do {
        !           620:                *chPtr += 1;
        !           621:                c = linePtr->bytes[*chPtr];
        !           622:            } while (isalnum(c) || (c == '_'));
        !           623:        }
        !           624:     } else if ((*string == 'w') && (strncmp(string, "wordstart", length) == 0)
        !           625:            && (length >= 5)) {
        !           626:        c = linePtr->bytes[*chPtr];
        !           627:        if (isalnum(c) || (c == '_')) {
        !           628:            while (*chPtr > 0) {
        !           629:                c = linePtr->bytes[(*chPtr) - 1];
        !           630:                if (!isalnum(c) && (c != '_')) {
        !           631:                    break;
        !           632:                }
        !           633:                *chPtr -= 1;
        !           634:            }
        !           635:        }
        !           636:     } else {
        !           637:        return NULL;
        !           638:     }
        !           639:     return p;
        !           640: }

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