diff options
Diffstat (limited to 'generic')
| -rw-r--r-- | generic/tkTextBTree.c | 2149 |
1 files changed, 1075 insertions, 1074 deletions
diff --git a/generic/tkTextBTree.c b/generic/tkTextBTree.c index 1919849..d77197f 100644 --- a/generic/tkTextBTree.c +++ b/generic/tkTextBTree.c @@ -1,17 +1,17 @@ -/* +/* * tkTextBTree.c -- * - * This file contains code that manages the B-tree representation - * of text for Tk's text widget and implements character and - * toggle segment types. - * + * This file contains code that manages the B-tree representation of text + * for Tk's text widget and implements character and toggle segment + * types. + * * Copyright (c) 1992-1994 The Regents of the University of California. * Copyright (c) 1994-1995 Sun Microsystems, Inc. * - * See the file "license.terms" for information on usage and redistribution - * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * See the file "license.terms" for information on usage and redistribution of + * this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tkTextBTree.c,v 1.16 2005/02/14 23:00:44 vincentdarley Exp $ + * RCS: @(#) $Id: tkTextBTree.c,v 1.17 2005/07/29 13:35:07 dkf Exp $ */ #include "tkInt.h" @@ -20,37 +20,36 @@ /* * Implementation notes: - * - * Most of this file is independent of the text widget implementation - * and representation now. Without much effort this could be developed - * further into a new Tcl object type of which the Tk text widget is one - * example of a client. - * + * + * Most of this file is independent of the text widget implementation and + * representation now. Without much effort this could be developed further + * into a new Tcl object type of which the Tk text widget is one example of a + * client. + * * The B-tree is set up with a dummy last line of text which must not be - * displayed, and must _never_ have a non-zero pixel count. This dummy - * line is a historical convenience to avoid other code having to deal - * with NULL TkTextLines. Since Tk 8.5, with pixel line height - * calculations and peer widgets, this dummy line is becoming somewhat - * of a liability, and special case code has been required to deal with - * it. It is probably a good idea to investigate removing the dummy - * line completely. This could result in an overall simplification - * (although it would require new special case code to deal with the - * fact that '.text index end' would then not really point to a valid - * line, rather it would point to the beginning of a non-existent line + * displayed, and must _never_ have a non-zero pixel count. This dummy line is + * a historical convenience to avoid other code having to deal with NULL + * TkTextLines. Since Tk 8.5, with pixel line height calculations and peer + * widgets, this dummy line is becoming somewhat of a liability, and special + * case code has been required to deal with it. It is probably a good idea to + * investigate removing the dummy line completely. This could result in an + * overall simplification (although it would require new special case code to + * deal with the fact that '.text index end' would then not really point to a + * valid line, rather it would point to the beginning of a non-existent line * one beyond all current lines - we could perhaps define that as a * TkTextIndex with a NULL TkTextLine ptr). */ /* - * The data structure below keeps summary information about one tag as part - * of the tag information in a node. + * The data structure below keeps summary information about one tag as part of + * the tag information in a node. */ typedef struct Summary { TkTextTag *tagPtr; /* Handle for tag. */ - int toggleCount; /* Number of transitions into or - * out of this tag that occur in - * the subtree rooted at this node. */ + int toggleCount; /* Number of transitions into or out + * of this tag that occur in the + * subtree rooted at this node. */ struct Summary *nextPtr; /* Next in list of all tags for same * node, or NULL if at end of list. */ } Summary; @@ -78,44 +77,43 @@ typedef struct Node { int numChildren; /* Number of children of this node. */ int numLines; /* Total number of lines (leaves) in * the subtree rooted here. */ - int* numPixels; /* Array containing total number - * of vertical display pixels in - * the subtree rooted here, one - * entry for each peer widget. */ + int* numPixels; /* Array containing total number of + * vertical display pixels in the + * subtree rooted here, one entry for + * each peer widget. */ } Node; -/* - * Used to avoid having to allocate and deallocate arrays on the - * fly for commonly used procedures. Must be > 0. +/* + * Used to avoid having to allocate and deallocate arrays on the fly for + * commonly used functions. Must be > 0. */ #define PIXEL_CLIENTS 5 /* - * Upper and lower bounds on how many children a node may have: - * rebalance when either of these limits is exceeded. MAX_CHILDREN - * should be twice MIN_CHILDREN and MIN_CHILDREN must be >= 2. + * Upper and lower bounds on how many children a node may have: rebalance when + * either of these limits is exceeded. MAX_CHILDREN should be twice + * MIN_CHILDREN and MIN_CHILDREN must be >= 2. */ #define MAX_CHILDREN 12 #define MIN_CHILDREN 6 /* - * The data structure below defines an entire B-tree. Since text - * widgets are the only current B-tree clients, 'clients' and - * 'pixelReferences' are identical. + * The data structure below defines an entire B-tree. Since text widgets are + * the only current B-tree clients, 'clients' and 'pixelReferences' are + * identical. */ typedef struct BTree { Node *rootPtr; /* Pointer to root of B-tree. */ - int clients; /* Number of clients of this - * B-tree */ - int pixelReferences; /* Number of clients of this - * B-tree which care about - * pixel heights */ - TkSharedText *sharedTextPtr; /* Used to find tagTable in consistency - * checking code, and to access - * list of all B-tree clients */ + int clients; /* Number of clients of this B-tree */ + int pixelReferences; /* Number of clients of this B-tree + * which care about pixel heights. */ + TkSharedText *sharedTextPtr; /* Used to find tagTable in + * consistency checking code, and to + * access list of all B-tree + * clients. */ int startEndCount; TkTextLine **startEnd; TkText **startEndRef; @@ -127,15 +125,15 @@ typedef struct BTree { */ typedef struct TagInfo { - int numTags; /* Number of tags for which there - * is currently information in - * tags and counts. */ + int numTags; /* Number of tags for which there is + * currently information in tags and + * counts. */ int arraySize; /* Number of entries allocated for * tags and counts. */ TkTextTag **tagPtrs; /* Array of tags seen so far. * Malloc-ed. */ int *counts; /* Toggle count (so far) for each - * entry in tags. Malloc-ed. */ + * entry in tags. Malloc-ed. */ } TagInfo; /* @@ -155,12 +153,12 @@ int tkBTreeDebug = 0; + sizeof(TkTextToggle))) /* - * Forward declarations for procedures defined in this file: + * Forward declarations for functions defined in this file: */ -static int AdjustPixelClient _ANSI_ARGS_((BTree *treePtr, +static int AdjustPixelClient _ANSI_ARGS_((BTree *treePtr, int defaultHeight, Node *nodePtr, TkTextLine *start, - TkTextLine *end, int useReference, + TkTextLine *end, int useReference, int newPixelReferences, int *counting)); static void ChangeNodeToggleCount _ANSI_ARGS_((Node *nodePtr, TkTextTag *tagPtr, int delta)); @@ -173,18 +171,18 @@ static TkTextSegment * CharCleanupProc _ANSI_ARGS_((TkTextSegment *segPtr, static TkTextSegment * CharSplitProc _ANSI_ARGS_((TkTextSegment *segPtr, int index)); static void CheckNodeConsistency _ANSI_ARGS_((Node *nodePtr, - int references)); + int references)); static void CleanupLine _ANSI_ARGS_((TkTextLine *linePtr)); static void DeleteSummaries _ANSI_ARGS_((Summary *tagPtr)); static void DestroyNode _ANSI_ARGS_((Node *nodePtr)); -static TkTextSegment * FindTagEnd _ANSI_ARGS_((TkTextBTree tree, +static TkTextSegment * FindTagEnd _ANSI_ARGS_((TkTextBTree tree, TkTextTag *tagPtr, TkTextIndex *indexPtr)); static void IncCount _ANSI_ARGS_((TkTextTag *tagPtr, int inc, TagInfo *tagInfoPtr)); static void Rebalance _ANSI_ARGS_((BTree *treePtr, Node *nodePtr)); -static void RecomputeNodeCounts _ANSI_ARGS_((BTree *treePtr, - Node *nodePtr)); -static void RemovePixelClient _ANSI_ARGS_((BTree *treePtr, +static void RecomputeNodeCounts _ANSI_ARGS_((BTree *treePtr, + Node *nodePtr)); +static void RemovePixelClient _ANSI_ARGS_((BTree *treePtr, Node *nodePtr, int overwriteWithLast)); static TkTextSegment * SplitSeg _ANSI_ARGS_((TkTextIndex *indexPtr)); static void ToggleCheckProc _ANSI_ARGS_((TkTextSegment *segPtr, @@ -197,60 +195,59 @@ static void ToggleLineChangeProc _ANSI_ARGS_((TkTextSegment *segPtr, TkTextLine *linePtr)); static TkTextSegment * FindTagStart _ANSI_ARGS_((TkTextBTree tree, TkTextTag *tagPtr, TkTextIndex *indexPtr)); -static void AdjustStartEndRefs _ANSI_ARGS_((BTree *treePtr, +static void AdjustStartEndRefs _ANSI_ARGS_((BTree *treePtr, TkText *textPtr, int action)); -/* +/* * Actions for use by AdjustStartEndRefs */ -#define TEXT_ADD_REFS 1 -#define TEXT_REMOVE_REFS 2 + +#define TEXT_ADD_REFS 1 +#define TEXT_REMOVE_REFS 2 /* * Type record for character segments: */ Tk_SegType tkTextCharType = { - "character", /* name */ - 0, /* leftGravity */ - CharSplitProc, /* splitProc */ - CharDeleteProc, /* deleteProc */ - CharCleanupProc, /* cleanupProc */ - (Tk_SegLineChangeProc *) NULL, /* lineChangeProc */ - TkTextCharLayoutProc, /* layoutProc */ - CharCheckProc /* checkProc */ + "character", /* name */ + 0, /* leftGravity */ + CharSplitProc, /* splitProc */ + CharDeleteProc, /* deleteProc */ + CharCleanupProc, /* cleanupProc */ + NULL, /* lineChangeProc */ + TkTextCharLayoutProc, /* layoutProc */ + CharCheckProc /* checkProc */ }; /* - * Type record for segments marking the beginning of a tagged - * range: + * Type record for segments marking the beginning of a tagged range: */ Tk_SegType tkTextToggleOnType = { - "toggleOn", /* name */ - 0, /* leftGravity */ - (Tk_SegSplitProc *) NULL, /* splitProc */ - ToggleDeleteProc, /* deleteProc */ - ToggleCleanupProc, /* cleanupProc */ - ToggleLineChangeProc, /* lineChangeProc */ - (Tk_SegLayoutProc *) NULL, /* layoutProc */ - ToggleCheckProc /* checkProc */ + "toggleOn", /* name */ + 0, /* leftGravity */ + NULL, /* splitProc */ + ToggleDeleteProc, /* deleteProc */ + ToggleCleanupProc, /* cleanupProc */ + ToggleLineChangeProc, /* lineChangeProc */ + NULL, /* layoutProc */ + ToggleCheckProc /* checkProc */ }; /* - * Type record for segments marking the end of a tagged - * range: + * Type record for segments marking the end of a tagged range: */ Tk_SegType tkTextToggleOffType = { - "toggleOff", /* name */ - 1, /* leftGravity */ - (Tk_SegSplitProc *) NULL, /* splitProc */ - ToggleDeleteProc, /* deleteProc */ - ToggleCleanupProc, /* cleanupProc */ - ToggleLineChangeProc, /* lineChangeProc */ - (Tk_SegLayoutProc *) NULL, /* layoutProc */ - ToggleCheckProc /* checkProc */ + "toggleOff", /* name */ + 1, /* leftGravity */ + NULL, /* splitProc */ + ToggleDeleteProc, /* deleteProc */ + ToggleCleanupProc, /* cleanupProc */ + ToggleLineChangeProc, /* lineChangeProc */ + NULL, /* layoutProc */ + ToggleCheckProc /* checkProc */ }; /* @@ -258,11 +255,11 @@ Tk_SegType tkTextToggleOffType = { * * TkBTreeCreate -- * - * This procedure is called to create a new text B-tree. + * This function is called to create a new text B-tree. * * Results: - * The return value is a pointer to a new B-tree containing - * one line with nothing but a newline character. + * The return value is a pointer to a new B-tree containing one line with + * nothing but a newline character. * * Side effects: * Memory is allocated and initialized. @@ -278,18 +275,18 @@ TkBTreeCreate(sharedTextPtr) register Node *rootPtr; register TkTextLine *linePtr, *linePtr2; register TkTextSegment *segPtr; - + /* - * The tree will initially have two empty lines. The second line - * isn't actually part of the tree's contents, but its presence - * makes several operations easier. The tree will have one node, - * which is also the root of the tree. + * The tree will initially have two empty lines. The second line isn't + * actually part of the tree's contents, but its presence makes several + * operations easier. The tree will have one node, which is also the root + * of the tree. */ rootPtr = (Node *) ckalloc(sizeof(Node)); linePtr = (TkTextLine *) ckalloc(sizeof(TkTextLine)); linePtr2 = (TkTextLine *) ckalloc(sizeof(TkTextLine)); - + rootPtr->parentPtr = NULL; rootPtr->nextPtr = NULL; rootPtr->summaryPtr = NULL; @@ -297,14 +294,16 @@ TkBTreeCreate(sharedTextPtr) rootPtr->children.linePtr = linePtr; rootPtr->numChildren = 2; rootPtr->numLines = 2; - /* - * The tree currently has no registered clients, so all pixel - * count pointers are simply NULL + + /* + * The tree currently has no registered clients, so all pixel count + * pointers are simply NULL */ + rootPtr->numPixels = NULL; linePtr->pixels = NULL; linePtr2->pixels = NULL; - + linePtr->parentPtr = rootPtr; linePtr->nextPtr = linePtr2; segPtr = (TkTextSegment *) ckalloc(CSEG_SIZE(1)); @@ -314,7 +313,7 @@ TkBTreeCreate(sharedTextPtr) segPtr->size = 1; segPtr->body.chars[0] = '\n'; segPtr->body.chars[1] = 0; - + linePtr2->parentPtr = rootPtr; linePtr2->nextPtr = NULL; segPtr = (TkTextSegment *) ckalloc(CSEG_SIZE(1)); @@ -333,7 +332,7 @@ TkBTreeCreate(sharedTextPtr) treePtr->startEndCount = 0; treePtr->startEnd = NULL; treePtr->startEndRef = NULL; - + return (TkTextBTree) treePtr; } @@ -342,28 +341,26 @@ TkBTreeCreate(sharedTextPtr) * * TkBTreeAddClient -- * - * This procedure is called to provide a client with access to - * a given B-tree. If the client wishes to make use of the - * B-tree's pixel height storage, caching and calculation - * mechanisms, then a non-negative 'defaultHeight' must be - * provided. In this case the return value is a pixel tree - * reference which must be provided in all of the B-tree API which - * refers to or modifies pixel heights: - * - * TkBTreeAdjustPixelHeight, + * This function is called to provide a client with access to a given + * B-tree. If the client wishes to make use of the B-tree's pixel height + * storage, caching and calculation mechanisms, then a non-negative + * 'defaultHeight' must be provided. In this case the return value is a + * pixel tree reference which must be provided in all of the B-tree API + * which refers to or modifies pixel heights: + * + * TkBTreeAdjustPixelHeight, * TkBTreeFindPixelLine, - * TkBTreeNumPixels, + * TkBTreeNumPixels, * TkBTreePixelsTo, * (and two private functions AdjustPixelClient, RemovePixelClient). - * - * If this is not provided, then the above functions must - * never be called for this client. + * + * If this is not provided, then the above functions must never be called + * for this client. * * Results: - * The return value is the pixelReference used by the B-tree to - * refer to pixel counts for the new client. It should be stored - * by the caller. If defaultHeight was negative, then the return - * value will be -1. + * The return value is the pixelReference used by the B-tree to refer to + * pixel counts for the new client. It should be stored by the caller. + * If defaultHeight was negative, then the return value will be -1. * * Side effects: * Memory may be allocated and initialized. @@ -373,14 +370,13 @@ TkBTreeCreate(sharedTextPtr) void TkBTreeAddClient(tree, textPtr, defaultHeight) - TkTextBTree tree; /* B-tree to add a client to */ - TkText *textPtr; /* Client to add */ - int defaultHeight; /* Default line height for the new - * client, or -1 if no pixel - * heights are to be kept. */ + TkTextBTree tree; /* B-tree to add a client to */ + TkText *textPtr; /* Client to add */ + int defaultHeight; /* Default line height for the new client, or + * -1 if no pixel heights are to be kept. */ { register BTree *treePtr = (BTree*) tree; - + if (treePtr == NULL) { Tcl_Panic("NULL treePtr in TkBTreeAddClient"); } @@ -393,19 +389,19 @@ TkBTreeAddClient(tree, textPtr, defaultHeight) TkTextLine *end; int counting = (textPtr->start == NULL ? 1 : 0); int useReference = treePtr->pixelReferences; - /* - * We must set the 'end' value in AdjustPixelClient so that - * the last dummy line in the B-tree doesn't contain - * a pixel height. + + /* + * We must set the 'end' value in AdjustPixelClient so that the last + * dummy line in the B-tree doesn't contain a pixel height. */ + end = textPtr->end; if (end == NULL) { end = TkBTreeFindLine(tree, NULL, TkBTreeNumLines(tree, NULL)); } - AdjustPixelClient(treePtr, defaultHeight, treePtr->rootPtr, - textPtr->start, end, useReference, - 1 + useReference, &counting); - + AdjustPixelClient(treePtr, defaultHeight, treePtr->rootPtr, + textPtr->start, end, useReference, useReference+1, &counting); + textPtr->pixelReference = useReference; treePtr->pixelReferences++; } else { @@ -419,48 +415,46 @@ TkBTreeAddClient(tree, textPtr, defaultHeight) * * TkBTreeClientRangeChanged -- * - * Called when the -startline or -endline options of a text - * widget client of the B-tree have changed. + * Called when the -startline or -endline options of a text widget client + * of the B-tree have changed. * * Results: * None. * * Side effects: - * Lots of processing of the B-tree is done, with potential - * for memory to be allocated and initialized for the pixel - * heights of the widget. + * Lots of processing of the B-tree is done, with potential for memory to + * be allocated and initialized for the pixel heights of the widget. * *---------------------------------------------------------------------- */ void TkBTreeClientRangeChanged(textPtr, defaultHeight) - TkText *textPtr; /* Client whose start, end have - * changed. */ - int defaultHeight; /* Default line height for the new - * client, or -1 if no pixel - * heights are to be kept. */ + TkText *textPtr; /* Client whose start, end have changed. */ + int defaultHeight; /* Default line height for the new client, or + * -1 if no pixel heights are to be kept. */ { TkTextLine *end; BTree *treePtr = (BTree*) textPtr->sharedTextPtr->tree; - + int counting = (textPtr->start == NULL ? 1 : 0); int useReference = textPtr->pixelReference; AdjustStartEndRefs(treePtr, textPtr, TEXT_ADD_REFS | TEXT_REMOVE_REFS); - /* - * We must set the 'end' value in AdjustPixelClient so that - * the last dummy line in the B-tree doesn't contain - * a pixel height. + + /* + * We must set the 'end' value in AdjustPixelClient so that the last dummy + * line in the B-tree doesn't contain a pixel height. */ + end = textPtr->end; if (end == NULL) { - end = TkBTreeFindLine(textPtr->sharedTextPtr->tree, + end = TkBTreeFindLine(textPtr->sharedTextPtr->tree, NULL, TkBTreeNumLines(textPtr->sharedTextPtr->tree, NULL)); } AdjustPixelClient(treePtr, defaultHeight, treePtr->rootPtr, - textPtr->start, end, useReference, - treePtr->pixelReferences, &counting); + textPtr->start, end, useReference, treePtr->pixelReferences, + &counting); } /* @@ -471,8 +465,7 @@ TkBTreeClientRangeChanged(textPtr, defaultHeight) * Delete a B-tree, recycling all of the storage it contains. * * Results: - * The tree is deleted, so 'tree' should never - * again be used. + * The tree is deleted, so 'tree' should never again be used. * * Side effects: * Memory is freed. @@ -482,19 +475,19 @@ TkBTreeClientRangeChanged(textPtr, defaultHeight) void TkBTreeDestroy(tree) - TkTextBTree tree; /* Tree to clean up */ + TkTextBTree tree; /* Tree to clean up */ { BTree *treePtr = (BTree *) tree; - /* + /* * There's no need to loop over each client of the tree, calling - * 'TkBTreeRemoveClient', since the 'DestroyNode' will clean - * everything up itself. + * 'TkBTreeRemoveClient', since the 'DestroyNode' will clean everything up + * itself. */ - + DestroyNode(treePtr->rootPtr); if (treePtr->startEnd != NULL) { - ckfree((char *) treePtr->startEnd); + ckfree((char *) treePtr->startEnd); ckfree((char *) treePtr->startEndRef); } ckfree((char *) treePtr); @@ -505,14 +498,14 @@ TkBTreeDestroy(tree) * * TkBTreeRemoveClient -- * - * Remove a client widget from its B-tree, cleaning up the pixel - * arrays which it uses if necessary. If this is the last such - * widget, we also destroy the whole tree. + * Remove a client widget from its B-tree, cleaning up the pixel arrays + * which it uses if necessary. If this is the last such widget, we also + * destroy the whole tree. * * Results: - * All tree-specific aspects of the given client are deleted. - * If no more references exist, then the given tree is also - * deleted (in which case 'tree' must not be used again). + * All tree-specific aspects of the given client are deleted. If no more + * references exist, then the given tree is also deleted (in which case + * 'tree' must not be used again). * * Side effects: * Memory may be freed. @@ -522,45 +515,55 @@ TkBTreeDestroy(tree) void TkBTreeRemoveClient(tree, textPtr) - TkTextBTree tree; /* Tree to remove client from */ - TkText *textPtr; /* Client to remove. */ + TkTextBTree tree; /* Tree to remove client from. */ + TkText *textPtr; /* Client to remove. */ { BTree *treePtr = (BTree *) tree; int pixelReference = textPtr->pixelReference; - + if (treePtr->clients == 1) { - /* The last reference to the tree */ + /* + * The last reference to the tree. + */ + DestroyNode(treePtr->rootPtr); ckfree((char *) treePtr); return; } else if (pixelReference == -1) { - /* A client which doesn't care about pixels */ + /* + * A client which doesn't care about pixels. + */ + treePtr->clients--; } else { - /* Clean up pixel data for the given reference */ - + /* + * Clean up pixel data for the given reference. + */ + if (pixelReference == (treePtr->pixelReferences-1)) { - /* - * The widget we're removing has the last index, - * so deletion is easier. + /* + * The widget we're removing has the last index, so deletion is + * easier. */ + RemovePixelClient(treePtr, treePtr->rootPtr, -1); } else { TkText *adjustPtr; - + RemovePixelClient(treePtr, treePtr->rootPtr, pixelReference); - /* - * Now we need to adjust the 'pixelReference' of the - * peer widget whose storage we've just moved. + /* + * Now we need to adjust the 'pixelReference' of the peer widget + * whose storage we've just moved. */ + adjustPtr = treePtr->sharedTextPtr->peers; while (adjustPtr != NULL) { - if (adjustPtr->pixelReference == (treePtr->pixelReferences-1)) { + if (adjustPtr->pixelReference == (treePtr->pixelReferences-1)) { adjustPtr->pixelReference = pixelReference; - break; - } - adjustPtr = adjustPtr->next; + break; + } + adjustPtr = adjustPtr->next; } if (adjustPtr == NULL) { Tcl_Panic("Couldn't find text widget with correct reference"); @@ -569,7 +572,7 @@ TkBTreeRemoveClient(tree, textPtr) treePtr->pixelReferences--; treePtr->clients--; } - + if (textPtr->start != NULL || textPtr->end != NULL) { AdjustStartEndRefs(treePtr, textPtr, TEXT_REMOVE_REFS); } @@ -580,25 +583,23 @@ TkBTreeRemoveClient(tree, textPtr) * * AdjustStartEndRefs -- * - * Modify B-tree's cache of start, end lines for the given text - * widget. + * Modify B-tree's cache of start, end lines for the given text widget. * * Results: * None. * * Side effects: - * The number of cached items may change - * (treePtr->startEndCount). + * The number of cached items may change (treePtr->startEndCount). * *---------------------------------------------------------------------- */ static void -AdjustStartEndRefs(treePtr, textPtr, action) - BTree *treePtr; /* The entire B-tree */ - TkText *textPtr; /* The text widget for which we want to - * adjust it's start and end cache. */ - int action; /* Action to perform */ +AdjustStartEndRefs(treePtr, textPtr, action) + BTree *treePtr; /* The entire B-tree */ + TkText *textPtr; /* The text widget for which we want to adjust + * it's start and end cache. */ + int action; /* Action to perform */ { if (action & TEXT_REMOVE_REFS) { int i = 0; @@ -610,30 +611,38 @@ AdjustStartEndRefs(treePtr, textPtr, action) treePtr->startEndRef[count] = treePtr->startEndRef[i]; } if (treePtr->startEndRef[i] != textPtr) { - count++; + count++; } i++; } treePtr->startEndCount = count; - treePtr->startEnd = (TkTextLine**)ckrealloc((char*)treePtr->startEnd, - sizeof(TkTextLine*)*count); - treePtr->startEndRef = (TkText**)ckrealloc((char*)treePtr->startEndRef, - sizeof(TkText*)*count); - } - if ((action & TEXT_ADD_REFS) - && (textPtr->start != NULL || textPtr->end != NULL)) { + treePtr->startEnd = (TkTextLine **) + ckrealloc((char *) treePtr->startEnd, + sizeof(TkTextLine *) * count); + treePtr->startEndRef = (TkText **) + ckrealloc((char *) treePtr->startEndRef, + sizeof(TkText *) * count); + } + if ((action & TEXT_ADD_REFS) + && (textPtr->start != NULL || textPtr->end != NULL)) { int count; - if (textPtr->start != NULL) treePtr->startEndCount++; - if (textPtr->end != NULL) treePtr->startEndCount++; + if (textPtr->start != NULL) { + treePtr->startEndCount++; + } + if (textPtr->end != NULL) { + treePtr->startEndCount++; + } count = treePtr->startEndCount; - - treePtr->startEnd = (TkTextLine**)ckrealloc((char*)treePtr->startEnd, - sizeof(TkTextLine*)*count); - treePtr->startEndRef = (TkText**)ckrealloc((char*)treePtr->startEndRef, - sizeof(TkText*)*count); - + + treePtr->startEnd = (TkTextLine **) + ckrealloc((char *) treePtr->startEnd, + sizeof(TkTextLine *) * count); + treePtr->startEndRef = (TkText **) + ckrealloc((char *) treePtr->startEndRef, + sizeof(TkText *) * count); + if (textPtr->start != NULL) { count--; treePtr->startEnd[count] = textPtr->start; @@ -652,69 +661,60 @@ AdjustStartEndRefs(treePtr, textPtr, action) * * AdjustPixelClient -- * - * Utility procedure used to update all data structures for the - * existence of a new peer widget based on this B-tree, or for - * the modification of the start, end lines of an existing peer - * widget. - * + * Utility function used to update all data structures for the existence + * of a new peer widget based on this B-tree, or for the modification of + * the start, end lines of an existing peer widget. + * * Immediately _after_ calling this, treePtr->clients and - * treePtr->pixelReferences should be adjusted if needed (i.e. - * if this is a new peer). + * treePtr->pixelReferences should be adjusted if needed (i.e. if this is + * a new peer). * * Results: * None. * * Side effects: - * All the storage for Nodes and TkTextLines in the tree may - * be adjusted. + * All the storage for Nodes and TkTextLines in the tree may be adjusted. * *---------------------------------------------------------------------- */ static int -AdjustPixelClient(treePtr, defaultHeight, nodePtr, start, end, - useReference, newPixelReferences, counting) - BTree *treePtr; /* Pointer to tree */ - int defaultHeight; /* Default pixel line - * height, which can be zero. */ - Node *nodePtr; /* Adjust from this node - * downwards */ - TkTextLine *start; /* First line for this pixel - * client */ - TkTextLine *end; /* Last line for this pixel - * client */ - int useReference; /* pixel reference for the - * client we are adding or - * changing */ - int newPixelReferences; /* New number of pixel - * references to this B-tree */ - int *counting; /* References an integer which - * is zero if we're outside the - * relevant range for this - * client, and 1 if we're - * inside. */ +AdjustPixelClient(treePtr, defaultHeight, nodePtr, start, end, + useReference, newPixelReferences, counting) + BTree *treePtr; /* Pointer to tree */ + int defaultHeight; /* Default pixel line height, which can be + * zero. */ + Node *nodePtr; /* Adjust from this node downwards */ + TkTextLine *start; /* First line for this pixel client */ + TkTextLine *end; /* Last line for this pixel client */ + int useReference; /* pixel reference for the client we are + * adding or changing */ + int newPixelReferences; /* New number of pixel references to this + * B-tree */ + int *counting; /* References an integer which is zero if + * we're outside the relevant range for this + * client, and 1 if we're inside. */ { int pixelCount = 0; /* - * Traverse entire tree down from nodePtr, reallocating pixel - * structures for each Node and TkTextLine, adding room for the new - * peer's pixel information (1 extra int per Node, 2 extra ints per - * TkTextLine). Also copy the information from the last peer into - * the new space (so it contains something sensible). + * Traverse entire tree down from nodePtr, reallocating pixel structures + * for each Node and TkTextLine, adding room for the new peer's pixel + * information (1 extra int per Node, 2 extra ints per TkTextLine). Also + * copy the information from the last peer into the new space (so it + * contains something sensible). */ - + if (nodePtr->level != 0) { Node *loopPtr = nodePtr->children.nodePtr; while (loopPtr != NULL) { pixelCount += AdjustPixelClient(treePtr, defaultHeight, loopPtr, - start, end, useReference, - newPixelReferences, counting); + start, end, useReference, newPixelReferences, counting); loopPtr = loopPtr->nextPtr; } } else { register TkTextLine *linePtr = nodePtr->children.linePtr; - + while (linePtr != NULL) { if (!*counting && (linePtr == start)) { *counting = 1; @@ -723,24 +723,25 @@ AdjustPixelClient(treePtr, defaultHeight, nodePtr, start, end, *counting = 0; } if (newPixelReferences != treePtr->pixelReferences) { - linePtr->pixels = (int*)ckrealloc((char*)linePtr->pixels, - sizeof(int)*2*newPixelReferences); + linePtr->pixels = (int *) ckrealloc((char *) linePtr->pixels, + sizeof(int) * 2 * newPixelReferences); } - /* - * Notice that for the very last line, we are never counting - * and therefore this always has a height of 0 and an epoch - * of 1. + + /* + * Notice that for the very last line, we are never counting and + * therefore this always has a height of 0 and an epoch of 1. */ + linePtr->pixels[2*useReference] = (*counting ? defaultHeight : 0); linePtr->pixels[1+2*useReference] = (*counting ? 0 : 1); pixelCount += linePtr->pixels[2*useReference]; - + linePtr = linePtr->nextPtr; } } if (newPixelReferences != treePtr->pixelReferences) { - nodePtr->numPixels = (int*)ckrealloc((char*)nodePtr->numPixels, - sizeof(int)*newPixelReferences); + nodePtr->numPixels = (int *) ckrealloc((char *) nodePtr->numPixels, + sizeof(int) * newPixelReferences); } nodePtr->numPixels[useReference] = pixelCount; return pixelCount; @@ -751,48 +752,45 @@ AdjustPixelClient(treePtr, defaultHeight, nodePtr, start, end, * * RemovePixelClient -- * - * Utility procedure used to update all data structures for the - * removal of a peer widget which used to be based on this B-tree. - * - * Immediately _after_ calling this, treePtr->clients should - * be decremented. + * Utility function used to update all data structures for the removal of + * a peer widget which used to be based on this B-tree. + * + * Immediately _after_ calling this, treePtr->clients should be + * decremented. * * Results: * None. * * Side effects: - * All the storage for Nodes and TkTextLines in the tree may - * be adjusted. + * All the storage for Nodes and TkTextLines in the tree may be adjusted. * *---------------------------------------------------------------------- */ static void RemovePixelClient(treePtr, nodePtr, overwriteWithLast) - BTree *treePtr; /* Pointer to tree */ - Node *nodePtr; /* Adjust from this node - * downwards */ - int overwriteWithLast; /* Over-write this peer widget's - * information with the last one - */ + BTree *treePtr; /* Pointer to tree */ + Node *nodePtr; /* Adjust from this node downwards */ + int overwriteWithLast; /* Over-write this peer widget's information + * with the last one. */ { /* - * Traverse entire tree down from nodePtr, reallocating pixel - * structures for each Node and TkTextLine, removing space allocated - * for one peer. If 'overwriteWithLast' is not -1, then copy the - * information which was in the last slot on top of one of the - * others (i.e. it's not the last one we're deleting). + * Traverse entire tree down from nodePtr, reallocating pixel structures + * for each Node and TkTextLine, removing space allocated for one peer. + * If 'overwriteWithLast' is not -1, then copy the information which was + * in the last slot on top of one of the others (i.e. it's not the last + * one we're deleting). */ if (overwriteWithLast != -1) { - nodePtr->numPixels[overwriteWithLast] - = nodePtr->numPixels[treePtr->pixelReferences-1]; + nodePtr->numPixels[overwriteWithLast] = + nodePtr->numPixels[treePtr->pixelReferences-1]; } if (treePtr->pixelReferences == 1) { nodePtr->numPixels = NULL; } else { - nodePtr->numPixels = (int*)ckrealloc((char*)nodePtr->numPixels, - sizeof(int)*(treePtr->pixelReferences-1)); + nodePtr->numPixels = (int *) ckrealloc((char *) nodePtr->numPixels, + sizeof(int) * (treePtr->pixelReferences - 1)); } if (nodePtr->level != 0) { nodePtr = nodePtr->children.nodePtr; @@ -804,16 +802,16 @@ RemovePixelClient(treePtr, nodePtr, overwriteWithLast) register TkTextLine *linePtr = nodePtr->children.linePtr; while (linePtr != NULL) { if (overwriteWithLast != -1) { - linePtr->pixels[2*overwriteWithLast] - = linePtr->pixels[2*(treePtr->pixelReferences-1)]; - linePtr->pixels[1+2*overwriteWithLast] - = linePtr->pixels[1+2*(treePtr->pixelReferences-1)]; + linePtr->pixels[2*overwriteWithLast] = + linePtr->pixels[2*(treePtr->pixelReferences-1)]; + linePtr->pixels[1+2*overwriteWithLast] = + linePtr->pixels[1+2*(treePtr->pixelReferences-1)]; } if (treePtr->pixelReferences == 1) { linePtr->pixels = NULL; } else { - linePtr->pixels = (int*)ckrealloc((char*)linePtr->pixels, - sizeof(int)*2*(treePtr->pixelReferences-1)); + linePtr->pixels = (int *) ckrealloc((char *) linePtr->pixels, + sizeof(int) * 2 * (treePtr->pixelReferences-1)); } linePtr = linePtr->nextPtr; } @@ -825,8 +823,8 @@ RemovePixelClient(treePtr, nodePtr, overwriteWithLast) * * DestroyNode -- * - * This is a recursive utility procedure used during the deletion - * of a B-tree. + * This is a recursive utility function used during the deletion of a + * B-tree. * * Results: * None. @@ -839,7 +837,7 @@ RemovePixelClient(treePtr, nodePtr, overwriteWithLast) static void DestroyNode(nodePtr) - register Node *nodePtr; /* Destroy from this node downwards */ + register Node *nodePtr; /* Destroy from this node downwards */ { if (nodePtr->level == 0) { TkTextLine *linePtr; @@ -875,8 +873,8 @@ DestroyNode(nodePtr) * * DeleteSummaries -- * - * Free up all of the memory in a list of tag summaries associated - * with a node. + * Free up all of the memory in a list of tag summaries associated with a + * node. * * Results: * None. @@ -889,8 +887,8 @@ DestroyNode(nodePtr) static void DeleteSummaries(summaryPtr) - register Summary *summaryPtr; /* First in list of node's tag - * summaries. */ + register Summary *summaryPtr; + /* First in list of node's tag summaries. */ { register Summary *nextPtr; while (summaryPtr != NULL) { @@ -905,67 +903,65 @@ DeleteSummaries(summaryPtr) * * TkBTreeAdjustPixelHeight -- * - * Adjust the pixel height of a given logical line to the - * specified value. + * Adjust the pixel height of a given logical line to the specified + * value. * * Results: * Total number of valid pixels currently known in the tree. * * Side effects: - * Updates overall data structures so pixel height count is - * consistent. + * Updates overall data structures so pixel height count is consistent. * *---------------------------------------------------------------------- */ int TkBTreeAdjustPixelHeight(textPtr, linePtr, newPixelHeight, mergedLogicalLines) - CONST TkText *textPtr; /* Client of the B-tree */ - register TkTextLine *linePtr; /* The logical line to update */ - int newPixelHeight; /* The line's known height - * in pixels */ - int mergedLogicalLines; /* The number of extra logical - * lines which have been merged - * with this one (due to elided - * eols). They will have their - * pixel height set to zero, and - * the total pixel height - * associated with the given - * linePtr. */ + CONST TkText *textPtr; /* Client of the B-tree */ + register TkTextLine *linePtr; + /* The logical line to update. */ + int newPixelHeight; /* The line's known height in pixels. */ + int mergedLogicalLines; /* The number of extra logical lines which + * have been merged with this one (due to + * elided eols). They will have their pixel + * height set to zero, and the total pixel + * height associated with the given linePtr */ { register Node *nodePtr; - int changeToPixelCount; /* Counts change to total number of - * pixels in file. */ + int changeToPixelCount; /* Counts change to total number of pixels in + * file. */ int pixelReference = textPtr->pixelReference; - + changeToPixelCount = newPixelHeight - linePtr->pixels[2*pixelReference]; /* - * Increment the pixel counts in all the parent nodes of the - * current line, then rebalance the tree if necessary. + * Increment the pixel counts in all the parent nodes of the current line, + * then rebalance the tree if necessary. */ nodePtr = linePtr->parentPtr; nodePtr->numPixels[pixelReference] += changeToPixelCount; - + while (nodePtr->parentPtr != NULL) { nodePtr = nodePtr->parentPtr; nodePtr->numPixels[pixelReference] += changeToPixelCount; } linePtr->pixels[2*pixelReference] = newPixelHeight; - - /* - * Any merged logical lines must have their height set to zero. + + /* + * Any merged logical lines must have their height set to zero. */ + while (mergedLogicalLines-- > 0) { - linePtr = TkBTreeNextLine(textPtr, linePtr); + linePtr = TkBTreeNextLine(textPtr, linePtr); TkBTreeAdjustPixelHeight(textPtr, linePtr, 0, 0); } - + /* * Return total number of pixels in the tree. */ + return nodePtr->numPixels[pixelReference]; } @@ -980,69 +976,67 @@ TkBTreeAdjustPixelHeight(textPtr, linePtr, newPixelHeight, mergedLogicalLines) * None. * * Side effects: - * Characters are added to the B-tree at the given position. - * If the string contains newlines, new lines will be added, - * which could cause the structure of the B-tree to change. + * Characters are added to the B-tree at the given position. If the + * string contains newlines, new lines will be added, which could cause + * the structure of the B-tree to change. * *---------------------------------------------------------------------- */ void TkBTreeInsertChars(tree, indexPtr, string) - TkTextBTree tree; /* Tree to insert into */ - register TkTextIndex *indexPtr; /* Indicates where to insert text. - * When the procedure returns, this - * index is no longer valid because - * of changes to the segment - * structure. */ - CONST char *string; /* Pointer to bytes to insert (may - * contain newlines, must be null- - * terminated). */ + TkTextBTree tree; /* Tree to insert into */ + register TkTextIndex *indexPtr; + /* Indicates where to insert text. When the + * function returns, this index is no longer + * valid because of changes to the segment + * structure. */ + CONST char *string; /* Pointer to bytes to insert (may contain + * newlines, must be null-terminated). */ { register Node *nodePtr; - register TkTextSegment *prevPtr; /* The segment just before the first - * new segment (NULL means new segment - * is at beginning of line). */ - TkTextSegment *curPtr; /* Current segment; new characters - * are inserted just after this one. - * NULL means insert at beginning of - * line. */ - TkTextLine *linePtr; /* Current line (new segments are - * added to this line). */ + register TkTextSegment *prevPtr; + /* The segment just before the first new + * segment (NULL means new segment is at + * beginning of line). */ + TkTextSegment *curPtr; /* Current segment; new characters are + * inserted just after this one. NULL means + * insert at beginning of line. */ + TkTextLine *linePtr; /* Current line (new segments are added to + * this line). */ register TkTextSegment *segPtr; TkTextLine *newLinePtr; - int chunkSize; /* # characters in current chunk. */ - register CONST char *eol; /* Pointer to character just after last - * one in current chunk. */ - int changeToLineCount; /* Counts change to total number of - * lines in file. */ - int *changeToPixelCount; /* Counts change to total number of - * pixels in file. */ + int chunkSize; /* # characters in current chunk. */ + register CONST char *eol; /* Pointer to character just after last one in + * current chunk. */ + int changeToLineCount; /* Counts change to total number of lines in + * file. */ + int *changeToPixelCount; /* Counts change to total number of pixels in + * file. */ int ref; int pixels[PIXEL_CLIENTS]; - + BTree *treePtr = (BTree*)tree; prevPtr = SplitSeg(indexPtr); linePtr = indexPtr->linePtr; curPtr = prevPtr; /* - * Chop the string up into lines and create a new segment for - * each line, plus a new line for the leftovers from the - * previous line. + * Chop the string up into lines and create a new segment for each line, + * plus a new line for the leftovers from the previous line. */ changeToLineCount = 0; if (treePtr->pixelReferences > PIXEL_CLIENTS) { - changeToPixelCount = (int*) ckalloc(sizeof(int) * - treePtr->pixelReferences); + changeToPixelCount = (int *) + ckalloc(sizeof(int) * treePtr->pixelReferences); } else { changeToPixelCount = pixels; } for (ref = 0; ref < treePtr->pixelReferences; ref++) { changeToPixelCount[ref] = 0; } - + while (*string != 0) { for (eol = string; *eol != 0; eol++) { if (*eol == '\n') { @@ -1069,22 +1063,24 @@ TkBTreeInsertChars(tree, indexPtr, string) } /* - * The chunk ended with a newline, so create a new TkTextLine - * and move the remainder of the old line to it. + * The chunk ended with a newline, so create a new TkTextLine and move + * the remainder of the old line to it. */ newLinePtr = (TkTextLine *) ckalloc(sizeof(TkTextLine)); - newLinePtr->pixels = - (int*) ckalloc(sizeof(int)*2*treePtr->pixelReferences); - + newLinePtr->pixels = (int *) + ckalloc(sizeof(int)*2*treePtr->pixelReferences); + newLinePtr->parentPtr = linePtr->parentPtr; newLinePtr->nextPtr = linePtr->nextPtr; linePtr->nextPtr = newLinePtr; newLinePtr->segPtr = segPtr->nextPtr; + /* - * Set up a starting default height, which will be re-adjusted + * Set up a starting default height, which will be re-adjusted * later. We need to do this for each referenced widget */ + for (ref = 0; ref < treePtr->pixelReferences; ref++) { newLinePtr->pixels[2*ref] = linePtr->pixels[2*ref]; newLinePtr->pixels[1+2*ref] = 0; @@ -1095,30 +1091,30 @@ TkBTreeInsertChars(tree, indexPtr, string) linePtr = newLinePtr; curPtr = NULL; changeToLineCount++; - + string = eol; } /* - * I don't believe it's possible for either of the two lines - * passed to this function to be the last line of text, but - * the function is robust to that case anyway. (We must never - * re-calculated the line height of the last line). + * I don't believe it's possible for either of the two lines passed to + * this function to be the last line of text, but the function is robust + * to that case anyway. (We must never re-calculated the line height of + * the last line). */ - TkTextInvalidateLineMetrics(treePtr->sharedTextPtr, NULL, - indexPtr->linePtr, changeToLineCount, - TK_TEXT_INVALIDATE_INSERT); + + TkTextInvalidateLineMetrics(treePtr->sharedTextPtr, NULL, + indexPtr->linePtr, changeToLineCount, TK_TEXT_INVALIDATE_INSERT); /* - * Cleanup the starting line for the insertion, plus the ending - * line if it's different. + * Cleanup the starting line for the insertion, plus the ending line if + * it's different. */ CleanupLine(indexPtr->linePtr); if (linePtr != indexPtr->linePtr) { CleanupLine(linePtr); } - + /* * Increment the line and pixel counts in all the parent nodes of the * insertion point, then rebalance the tree if necessary. @@ -1134,7 +1130,7 @@ TkBTreeInsertChars(tree, indexPtr, string) if (treePtr->pixelReferences > PIXEL_CLIENTS) { ckfree((char*)changeToPixelCount); } - + nodePtr = linePtr->parentPtr; nodePtr->numChildren += changeToLineCount; if (nodePtr->numChildren > MAX_CHILDREN) { @@ -1151,42 +1147,40 @@ TkBTreeInsertChars(tree, indexPtr, string) * * SplitSeg -- * - * This procedure is called before adding or deleting - * segments. It does three things: (a) it finds the segment - * containing indexPtr; (b) if there are several such - * segments (because some segments have zero length) then - * it picks the first segment that does not have left - * gravity; (c) if the index refers to the middle of - * a segment then it splits the segment so that the - * index now refers to the beginning of a segment. + * This function is called before adding or deleting segments. It does + * three things: (a) it finds the segment containing indexPtr; (b) if + * there are several such segments (because some segments have zero + * length) then it picks the first segment that does not have left + * gravity; (c) if the index refers to the middle of a segment then it + * splits the segment so that the index now refers to the beginning of a + * segment. * * Results: - * The return value is a pointer to the segment just - * before the segment corresponding to indexPtr (as - * described above). If the segment corresponding to - * indexPtr is the first in its line then the return + * The return value is a pointer to the segment just before the segment + * corresponding to indexPtr (as described above). If the segment + * corresponding to indexPtr is the first in its line then the return * value is NULL. * * Side effects: - * The segment referred to by indexPtr is split unless - * indexPtr refers to its first character. + * The segment referred to by indexPtr is split unless indexPtr refers to + * its first character. * *-------------------------------------------------------------- */ static TkTextSegment * SplitSeg(indexPtr) - TkTextIndex *indexPtr; /* Index identifying position - * at which to split a segment. */ + TkTextIndex *indexPtr; /* Index identifying position at which to + * split a segment. */ { TkTextSegment *prevPtr, *segPtr; TkTextLine *linePtr; - + int count = indexPtr->byteIndex; linePtr = indexPtr->linePtr; prevPtr = NULL; segPtr = linePtr->segPtr; - + while (segPtr != NULL) { if (segPtr->size > count) { if (count == 0) { @@ -1203,15 +1197,16 @@ SplitSeg(indexPtr) && !segPtr->typePtr->leftGravity) { return prevPtr; } - + count -= segPtr->size; prevPtr = segPtr; segPtr = segPtr->nextPtr; if (segPtr == NULL) { - /* - * Two logical lines merged into one display line - * through eliding of a newline + /* + * Two logical lines merged into one display line through eliding + * of a newline */ + linePtr = TkBTreeNextLine(NULL, linePtr); if (linePtr == NULL) { /* Reached end of the text */ @@ -1228,17 +1223,16 @@ SplitSeg(indexPtr) * * CleanupLine -- * - * This procedure is called after modifications have been - * made to a line. It scans over all of the segments in - * the line, giving each a chance to clean itself up, e.g. - * by merging with the following segments, updating internal - * information, etc. + * This function is called after modifications have been made to a line. + * It scans over all of the segments in the line, giving each a chance to + * clean itself up, e.g. by merging with the following segments, updating + * internal information, etc. * * Results: * None. * * Side effects: - * Depends on what the segment-specific cleanup procedures do. + * Depends on what the segment-specific cleanup functions do. * *-------------------------------------------------------------- */ @@ -1251,13 +1245,12 @@ CleanupLine(linePtr) int anyChanges; /* - * Make a pass over all of the segments in the line, giving each - * a chance to clean itself up. This could potentially change - * the structure of the line, e.g. by merging two segments - * together or having two segments cancel themselves; if so, - * then repeat the whole process again, since the first structure - * change might make other structure changes possible. Repeat - * until eventually there are no changes. + * Make a pass over all of the segments in the line, giving each a chance + * to clean itself up. This could potentially change the structure of the + * line, e.g. by merging two segments together or having two segments + * cancel themselves; if so, then repeat the whole process again, since + * the first structure change might make other structure changes possible. + * Repeat until eventually there are no changes. */ while (1) { @@ -1283,45 +1276,45 @@ CleanupLine(linePtr) * * TkBTreeDeleteChars -- * - * Delete a range of characters from a B-tree. The caller - * must make sure that the final newline of the B-tree is - * never deleted. + * Delete a range of characters from a B-tree. The caller must make sure + * that the final newline of the B-tree is never deleted. * * Results: * None. * * Side effects: - * Information is deleted from the B-tree. This can cause the - * internal structure of the B-tree to change. Note: because - * of changes to the B-tree structure, the indices pointed - * to by index1Ptr and index2Ptr should not be used after this - * procedure returns. + * Information is deleted from the B-tree. This can cause the internal + * structure of the B-tree to change. Note: because of changes to the + * B-tree structure, the indices pointed to by index1Ptr and index2Ptr + * should not be used after this function returns. * *---------------------------------------------------------------------- */ void TkBTreeDeleteChars(tree, index1Ptr, index2Ptr) - TkTextBTree tree; /* Tree to delete from */ - register TkTextIndex *index1Ptr; /* Indicates first character that is - * to be deleted. */ - register TkTextIndex *index2Ptr; /* Indicates character just after the - * last one that is to be deleted. */ + TkTextBTree tree; /* Tree to delete from */ + register TkTextIndex *index1Ptr; + /* Indicates first character that is to be + * deleted. */ + register TkTextIndex *index2Ptr; + /* Indicates character just after the last one + * that is to be deleted. */ { - TkTextSegment *prevPtr; /* The segment just before the start - * of the deletion range. */ - TkTextSegment *lastPtr; /* The segment just after the end - * of the deletion range. */ + TkTextSegment *prevPtr; /* The segment just before the start of the + * deletion range. */ + TkTextSegment *lastPtr; /* The segment just after the end of the + * deletion range. */ TkTextSegment *segPtr, *nextPtr; TkTextLine *curLinePtr; Node *curNodePtr, *nodePtr; int changeToLineCount = 0; int ref; BTree *treePtr = (BTree*)tree; - + /* - * Tricky point: split at index2Ptr first; otherwise the split - * at index2Ptr may invalidate segPtr and/or prevPtr. + * Tricky point: split at index2Ptr first; otherwise the split at + * index2Ptr may invalidate segPtr and/or prevPtr. */ lastPtr = SplitSeg(index2Ptr); @@ -1351,9 +1344,9 @@ TkBTreeDeleteChars(tree, index1Ptr, index2Ptr) TkTextLine *nextLinePtr; /* - * We just ran off the end of a line. First find the - * next line, then go back to the old line and delete it - * (unless it's the starting line for the range). + * We just ran off the end of a line. First find the next line, + * then go back to the old line and delete it (unless it's the + * starting line for the range). */ nextLinePtr = TkBTreeNextLine(NULL, curLinePtr); @@ -1372,17 +1365,24 @@ TkBTreeDeleteChars(tree, index1Ptr, index2Ptr) } changeToLineCount++; curNodePtr->numChildren--; - /* Check if we need to adjust any partial clients */ + + /* + * Check if we need to adjust any partial clients. + */ + if (treePtr->startEnd != NULL) { int checkCount = 0; + while (checkCount < treePtr->startEndCount) { if (treePtr->startEnd[checkCount] == curLinePtr) { TkText *peer = treePtr->startEndRef[checkCount]; - /* - * We're deleting a line which is the start - * or end of a current client. This means - * we need to adjust that client. + + /* + * We're deleting a line which is the start or end + * of a current client. This means we need to + * adjust that client. */ + treePtr->startEnd[checkCount] = nextLinePtr; if (peer->start == curLinePtr) { peer->start = nextLinePtr; @@ -1429,8 +1429,8 @@ TkBTreeDeleteChars(tree, index1Ptr, index2Ptr) nextPtr = segPtr->nextPtr; if ((*segPtr->typePtr->deleteProc)(segPtr, curLinePtr, 0) != 0) { /* - * This segment refuses to die. Move it to prevPtr and - * advance prevPtr if the segment has left gravity. + * This segment refuses to die. Move it to prevPtr and advance + * prevPtr if the segment has left gravity. */ if (prevPtr == NULL) { @@ -1448,8 +1448,8 @@ TkBTreeDeleteChars(tree, index1Ptr, index2Ptr) } /* - * If the beginning and end of the deletion range are in different - * lines, join the two lines together and discard the ending line. + * If the beginning and end of the deletion range are in different lines, + * join the two lines together and discard the ending line. */ if (index1Ptr->linePtr != index2Ptr->linePtr) { @@ -1480,24 +1480,28 @@ TkBTreeDeleteChars(tree, index1Ptr, index2Ptr) } prevLinePtr->nextPtr = index2Ptr->linePtr->nextPtr; } - /* - * Check if we need to adjust any partial clients. In this case - * if we're deleting the line, we actually move back to the - * previous line for our (start,end) storage. We do this - * because we still want the portion of the second line that - * still exists to be in the start,end range. + + /* + * Check if we need to adjust any partial clients. In this case if + * we're deleting the line, we actually move back to the previous line + * for our (start,end) storage. We do this because we still want the + * portion of the second line that still exists to be in the start,end + * range. */ + if (treePtr->startEnd != NULL) { int checkCount = 0; while (treePtr->startEnd[checkCount] != NULL) { if (treePtr->startEnd[checkCount] == index2Ptr->linePtr) { TkText *peer = treePtr->startEndRef[checkCount]; - /* - * We're deleting a line which is the start - * or end of a current client. This means - * we need to adjust that client. + + /* + * We're deleting a line which is the start or end of a + * current client. This means we need to adjust that + * client. */ + treePtr->startEnd[checkCount] = index1Ptr->linePtr; if (peer->start == index2Ptr->linePtr) { peer->start = index1Ptr->linePtr; @@ -1522,17 +1526,18 @@ TkBTreeDeleteChars(tree, index1Ptr, index2Ptr) CleanupLine(index1Ptr->linePtr); /* - * This line now needs to have its height recalculated. For safety, - * ensure we don't call this function with the last artificial line - * of text. I _believe_ that it isn't possible to get this far with - * the last line, but it is good to be safe. + * This line now needs to have its height recalculated. For safety, ensure + * we don't call this function with the last artificial line of text. I + * _believe_ that it isn't possible to get this far with the last line, + * but it is good to be safe. */ + if (TkBTreeNextLine(NULL, index1Ptr->linePtr) != NULL) { - TkTextInvalidateLineMetrics(treePtr->sharedTextPtr, NULL, - index1Ptr->linePtr, changeToLineCount, - TK_TEXT_INVALIDATE_DELETE); + TkTextInvalidateLineMetrics(treePtr->sharedTextPtr, NULL, + index1Ptr->linePtr, changeToLineCount, + TK_TEXT_INVALIDATE_DELETE); } - + /* * Lastly, rebalance the first node of the range. */ @@ -1551,8 +1556,8 @@ TkBTreeDeleteChars(tree, index1Ptr, index2Ptr) * Find a particular line in a B-tree based on its line number. * * Results: - * The return value is a pointer to the line structure for the - * line whose index is "line", or NULL if no such line exists. + * The return value is a pointer to the line structure for the line whose + * index is "line", or NULL if no such line exists. * * Side effects: * None. @@ -1562,10 +1567,9 @@ TkBTreeDeleteChars(tree, index1Ptr, index2Ptr) TkTextLine * TkBTreeFindLine(tree, textPtr, line) - TkTextBTree tree; /* B-tree in which to find line. */ - CONST TkText *textPtr; /* Relative to this client of the - * B-tree */ - int line; /* Index of desired line. */ + TkTextBTree tree; /* B-tree in which to find line. */ + CONST TkText *textPtr; /* Relative to this client of the B-tree */ + int line; /* Index of desired line. */ { BTree *treePtr = (BTree *) tree; register Node *nodePtr; @@ -1574,17 +1578,18 @@ TkBTreeFindLine(tree, textPtr, line) if (treePtr == NULL) { treePtr = (BTree *) textPtr->sharedTextPtr->tree; } - + nodePtr = treePtr->rootPtr; if ((line < 0) || (line >= nodePtr->numLines)) { return NULL; } - - /* - * Check for the any start/end offset for this text widget + + /* + * Check for the any start/end offset for this text widget */ + if (textPtr != NULL) { - if (textPtr->start != NULL) { + if (textPtr->start != NULL) { line += TkBTreeLinesTo(NULL, textPtr->start); if (line >= nodePtr->numLines) { return NULL; @@ -1596,10 +1601,9 @@ TkBTreeFindLine(tree, textPtr, line) } } } - + /* - * Work down through levels of the tree until a node is found at - * level 0. + * Work down through levels of the tree until a node is found at level 0. */ while (nodePtr->level != 0) { @@ -1635,15 +1639,14 @@ TkBTreeFindLine(tree, textPtr, line) * Find a particular line in a B-tree based on its pixel count. * * Results: - * The return value is a pointer to the line structure for the - * line which contains the pixel "pixels", or NULL if no such - * line exists. If the first line is of height 20, then pixels - * 0-19 will return it, and pixels = 20 will return the next - * line. - * - * If pixelOffset is non-NULL, it is set to the amount by which - * 'pixels' exceeds the first pixel located on the returned - * line. This should always be non-negative. + * The return value is a pointer to the line structure for the line which + * contains the pixel "pixels", or NULL if no such line exists. If the + * first line is of height 20, then pixels 0-19 will return it, and + * pixels = 20 will return the next line. + * + * If pixelOffset is non-NULL, it is set to the amount by which 'pixels' + * exceeds the first pixel located on the returned line. This should + * always be non-negative. * * Side effects: * None. @@ -1653,17 +1656,16 @@ TkBTreeFindLine(tree, textPtr, line) TkTextLine * TkBTreeFindPixelLine(tree, textPtr, pixels, pixelOffset) - TkTextBTree tree; /* B-tree to use. */ - CONST TkText *textPtr; /* Relative to this client of the - * B-tree */ - int pixels; /* Pixel index of desired line. */ - int *pixelOffset; /* Used to return offset */ + TkTextBTree tree; /* B-tree to use. */ + CONST TkText *textPtr; /* Relative to this client of the B-tree */ + int pixels; /* Pixel index of desired line. */ + int *pixelOffset; /* Used to return offset */ { BTree *treePtr = (BTree *) tree; register Node *nodePtr; register TkTextLine *linePtr; int pixelReference = textPtr->pixelReference; - + nodePtr = treePtr->rootPtr; if ((pixels < 0) || (pixels > nodePtr->numPixels[pixelReference])) { @@ -1673,10 +1675,9 @@ TkBTreeFindPixelLine(tree, textPtr, pixels, pixelOffset) if (nodePtr->numPixels[pixelReference] == 0) { Tcl_Panic("TkBTreeFindPixelLine called with empty window"); } - + /* - * Work down through levels of the tree until a node is found at - * level 0. + * Work down through levels of the tree until a node is found at level 0. */ while (nodePtr->level != 0) { @@ -1694,7 +1695,7 @@ TkBTreeFindPixelLine(tree, textPtr, pixels, pixelOffset) * Work through the lines attached to the level-0 node. */ - for (linePtr = nodePtr->children.linePtr; + for (linePtr = nodePtr->children.linePtr; linePtr->pixels[2*pixelReference] < pixels; linePtr = linePtr->nextPtr) { if (linePtr == NULL) { @@ -1703,7 +1704,7 @@ TkBTreeFindPixelLine(tree, textPtr, pixels, pixelOffset) pixels -= linePtr->pixels[2*pixelReference]; } if (pixelOffset != NULL && linePtr != NULL) { - *pixelOffset = pixels; + *pixelOffset = pixels; } return linePtr; } @@ -1713,13 +1714,13 @@ TkBTreeFindPixelLine(tree, textPtr, pixels, pixelOffset) * * TkBTreeNextLine -- * - * Given an existing line in a B-tree, this procedure locates the - * next line in the B-tree. This procedure is used for scanning - * through the B-tree. + * Given an existing line in a B-tree, this function locates the next + * line in the B-tree. This function is used for scanning through the + * B-tree. * * Results: - * The return value is a pointer to the line that immediately - * follows linePtr, or NULL if there is no such line. + * The return value is a pointer to the line that immediately follows + * linePtr, or NULL if there is no such line. * * Side effects: * None. @@ -1729,10 +1730,9 @@ TkBTreeFindPixelLine(tree, textPtr, pixels, pixelOffset) TkTextLine * TkBTreeNextLine(textPtr, linePtr) - CONST TkText *textPtr; /* Next line in the context of - * this client */ - register TkTextLine *linePtr; /* Pointer to existing line in - * B-tree. */ + CONST TkText *textPtr; /* Next line in the context of this client */ + register TkTextLine *linePtr; + /* Pointer to existing line in B-tree. */ { register Node *nodePtr; @@ -1743,11 +1743,11 @@ TkBTreeNextLine(textPtr, linePtr) return linePtr->nextPtr; } } - + /* * This was the last line associated with the particular parent node. - * Search up the tree for the next node, then search down from that - * node to find the first line. + * Search up the tree for the next node, then search down from that node + * to find the first line. */ for (nodePtr = linePtr->parentPtr; ; nodePtr = nodePtr->parentPtr) { @@ -1770,13 +1770,13 @@ TkBTreeNextLine(textPtr, linePtr) * * TkBTreePreviousLine -- * - * Given an existing line in a B-tree, this procedure locates the - * previous line in the B-tree. This procedure is used for scanning - * through the B-tree in the reverse direction. + * Given an existing line in a B-tree, this function locates the previous + * line in the B-tree. This function is used for scanning through the + * B-tree in the reverse direction. * * Results: - * The return value is a pointer to the line that immediately - * preceeds linePtr, or NULL if there is no such line. + * The return value is a pointer to the line that immediately preceeds + * linePtr, or NULL if there is no such line. * * Side effects: * None. @@ -1786,23 +1786,23 @@ TkBTreeNextLine(textPtr, linePtr) TkTextLine * TkBTreePreviousLine(textPtr, linePtr) - TkText *textPtr; /* Relative to this client of the - * B-tree */ - register TkTextLine *linePtr; /* Pointer to existing line in - * B-tree. */ + TkText *textPtr; /* Relative to this client of the B-tree */ + register TkTextLine *linePtr; + /* Pointer to existing line in B-tree. */ { register Node *nodePtr; register Node *node2Ptr; register TkTextLine *prevPtr; if (textPtr != NULL && textPtr->start == linePtr) { - return NULL; + return NULL; } - + /* * Find the line under this node just before the starting line. */ - prevPtr = linePtr->parentPtr->children.linePtr; /* First line at leaf */ + + prevPtr = linePtr->parentPtr->children.linePtr; /* First line at leaf */ while (prevPtr != linePtr) { if (prevPtr->nextPtr == linePtr) { return prevPtr; @@ -1818,6 +1818,7 @@ TkBTreePreviousLine(textPtr, linePtr) * Search up the tree for the previous node, then search down from that * node to find its last line. */ + for (nodePtr = linePtr->parentPtr; ; nodePtr = nodePtr->parentPtr) { if (nodePtr == (Node *) NULL || nodePtr->parentPtr == (Node *) NULL) { return (TkTextLine *) NULL; @@ -1826,7 +1827,7 @@ TkBTreePreviousLine(textPtr, linePtr) break; } } - for (node2Ptr = nodePtr->parentPtr->children.nodePtr; ; + for (node2Ptr = nodePtr->parentPtr->children.nodePtr; ; node2Ptr = node2Ptr->children.nodePtr) { while (node2Ptr->nextPtr != nodePtr) { node2Ptr = node2Ptr->nextPtr; @@ -1848,13 +1849,13 @@ TkBTreePreviousLine(textPtr, linePtr) * * TkBTreePixelsTo -- * - * Given a pointer to a line in a B-tree, return the numerical - * pixel index of the top of that line (i.e. the result does - * not include the height of the given line). - * - * Since the last line of text (the artificial one) has zero - * height by defintion, calling this with the last line will - * return the total number of pixels in the widget. + * Given a pointer to a line in a B-tree, return the numerical pixel + * index of the top of that line (i.e. the result does not include the + * height of the given line). + * + * Since the last line of text (the artificial one) has zero height by + * defintion, calling this with the last line will return the total + * number of pixels in the widget. * * Results: * The result is the index of linePtr within the tree, where 0 @@ -1868,10 +1869,8 @@ TkBTreePreviousLine(textPtr, linePtr) int TkBTreePixelsTo(textPtr, linePtr) - CONST TkText *textPtr; /* Relative to this client of the - * B-tree */ - TkTextLine *linePtr; /* Pointer to existing line in - * B-tree. */ + CONST TkText *textPtr; /* Relative to this client of the B-tree */ + TkTextLine *linePtr; /* Pointer to existing line in B-tree. */ { register TkTextLine *linePtr2; register Node *nodePtr, *parentPtr; @@ -1879,8 +1878,7 @@ TkBTreePixelsTo(textPtr, linePtr) int pixelReference = textPtr->pixelReference; /* - * First count how many pixels precede this line in its level-0 - * node. + * First count how many pixels precede this line in its level-0 node. */ nodePtr = linePtr->parentPtr; @@ -1894,9 +1892,8 @@ TkBTreePixelsTo(textPtr, linePtr) } /* - * Now work up through the levels of the tree one at a time, - * counting how many pixels are in nodes preceding the current - * node. + * Now work up through the levels of the tree one at a time, counting how + * many pixels are in nodes preceding the current node. */ for (parentPtr = nodePtr->parentPtr ; parentPtr != NULL; @@ -1918,8 +1915,8 @@ TkBTreePixelsTo(textPtr, linePtr) * * TkBTreeLinesTo -- * - * Given a pointer to a line in a B-tree, return the numerical - * index of that line. + * Given a pointer to a line in a B-tree, return the numerical index of + * that line. * * Results: * The result is the index of linePtr within the tree, where 0 @@ -1933,18 +1930,15 @@ TkBTreePixelsTo(textPtr, linePtr) int TkBTreeLinesTo(textPtr, linePtr) - CONST TkText *textPtr; /* Relative to this client of the - * B-tree */ - TkTextLine *linePtr; /* Pointer to existing line in - * B-tree. */ + CONST TkText *textPtr; /* Relative to this client of the B-tree */ + TkTextLine *linePtr; /* Pointer to existing line in B-tree. */ { register TkTextLine *linePtr2; register Node *nodePtr, *parentPtr, *nodePtr2; int index; /* - * First count how many lines precede this one in its level-0 - * node. + * First count how many lines precede this one in its level-0 node. */ nodePtr = linePtr->parentPtr; @@ -1958,9 +1952,8 @@ TkBTreeLinesTo(textPtr, linePtr) } /* - * Now work up through the levels of the tree one at a time, - * counting how many lines are in nodes preceding the current - * node. + * Now work up through the levels of the tree one at a time, counting how + * many lines are in nodes preceding the current node. */ for (parentPtr = nodePtr->parentPtr ; parentPtr != NULL; @@ -1974,7 +1967,7 @@ TkBTreeLinesTo(textPtr, linePtr) } } if (textPtr != NULL && textPtr->start != NULL) { - index -= TkBTreeLinesTo(NULL, textPtr->start); + index -= TkBTreeLinesTo(NULL, textPtr->start); } return index; } @@ -1984,8 +1977,7 @@ TkBTreeLinesTo(textPtr, linePtr) * * TkBTreeLinkSegment -- * - * This procedure adds a new segment to a B-tree at a given - * location. + * This function adds a new segment to a B-tree at a given location. * * Results: * None. @@ -2000,11 +1992,10 @@ TkBTreeLinesTo(textPtr, linePtr) void TkBTreeLinkSegment(segPtr, indexPtr) TkTextSegment *segPtr; /* Pointer to new segment to be added to - * B-tree. Should be completely initialized - * by caller except for nextPtr field. */ - TkTextIndex *indexPtr; /* Where to add segment: it gets linked - * in just before the segment indicated - * here. */ + * B-tree. Should be completely initialized by + * caller except for nextPtr field. */ + TkTextIndex *indexPtr; /* Where to add segment: it gets linked in + * just before the segment indicated here. */ { register TkTextSegment *prevPtr; @@ -2027,14 +2018,14 @@ TkBTreeLinkSegment(segPtr, indexPtr) * * TkBTreeUnlinkSegment -- * - * This procedure unlinks a segment from its line in a B-tree. + * This function unlinks a segment from its line in a B-tree. * * Results: * None. * * Side effects: - * SegPtr will be unlinked from linePtr. The segment itself - * isn't modified by this procedure. + * SegPtr will be unlinked from linePtr. The segment itself isn't + * modified by this function. * *---------------------------------------------------------------------- */ @@ -2042,9 +2033,8 @@ TkBTreeLinkSegment(segPtr, indexPtr) /* ARGSUSED */ void TkBTreeUnlinkSegment(segPtr, linePtr) - TkTextSegment *segPtr; /* Segment to be unlinked. */ - TkTextLine *linePtr; /* Line that currently contains - * segment. */ + TkTextSegment *segPtr; /* Segment to be unlinked. */ + TkTextLine *linePtr; /* Line that currently contains segment. */ { register TkTextSegment *prevPtr; @@ -2054,12 +2044,13 @@ TkBTreeUnlinkSegment(segPtr, linePtr) prevPtr = linePtr->segPtr; while (prevPtr->nextPtr != segPtr) { prevPtr = prevPtr->nextPtr; - + if (prevPtr == NULL) { - /* - * Two logical lines merged into one display line - * through eliding of a newline + /* + * Two logical lines merged into one display line through + * eliding of a newline */ + linePtr = TkBTreeNextLine(NULL, linePtr); prevPtr = linePtr->segPtr; } @@ -2074,35 +2065,35 @@ TkBTreeUnlinkSegment(segPtr, linePtr) * * TkBTreeTag -- * - * Turn a given tag on or off for a given range of characters in - * a B-tree of text. + * Turn a given tag on or off for a given range of characters in a B-tree + * of text. * * Results: - * 1 if the tags on any characters in the range were changed, - * and zero otherwise (i.e. if the tag was already absent (add = 0) - * or present (add = 1) on the index range in question). + * 1 if the tags on any characters in the range were changed, and zero + * otherwise (i.e. if the tag was already absent (add = 0) or present + * (add = 1) on the index range in question). * * Side effects: - * The given tag is added to the given range of characters - * in the tree or removed from all those characters, depending - * on the "add" argument. The structure of the btree is modified - * enough that index1Ptr and index2Ptr are no longer valid after - * this procedure returns, and the indexes may be modified by - * this procedure. + * The given tag is added to the given range of characters in the tree or + * removed from all those characters, depending on the "add" argument. + * The structure of the btree is modified enough that index1Ptr and + * index2Ptr are no longer valid after this function returns, and the + * indexes may be modified by this function. * *---------------------------------------------------------------------- */ int TkBTreeTag(index1Ptr, index2Ptr, tagPtr, add) - register TkTextIndex *index1Ptr; /* Indicates first character in - * range. */ - register TkTextIndex *index2Ptr; /* Indicates character just after the - * last one in range. */ - TkTextTag *tagPtr; /* Tag to add or remove. */ - int add; /* One means add tag to the given - * range of characters; zero means - * remove the tag from the range. */ + register TkTextIndex *index1Ptr; + /* Indicates first character in range. */ + register TkTextIndex *index2Ptr; + /* Indicates character just after the last one + * in range. */ + TkTextTag *tagPtr; /* Tag to add or remove. */ + int add; /* One means add tag to the given range of + * characters; zero means remove the tag from + * the range. */ { TkTextSegment *segPtr, *prevPtr; TkTextSearch search; @@ -2110,11 +2101,10 @@ TkBTreeTag(index1Ptr, index2Ptr, tagPtr, add) int oldState; int changed; int anyChanges = 0; - + /* - * See whether the tag is present at the start of the range. If - * the state doesn't already match what we want then add a toggle - * there. + * See whether the tag is present at the start of the range. If the state + * doesn't already match what we want then add a toggle there. */ oldState = TkBTreeCharTagged(index1Ptr, tagPtr); @@ -2136,9 +2126,9 @@ TkBTreeTag(index1Ptr, index2Ptr, tagPtr, add) } /* - * Scan the range of characters and delete any internal tag - * transitions. Keep track of what the old state was at the end - * of the range, and add a toggle there if it's needed. + * Scan the range of characters and delete any internal tag transitions. + * Keep track of what the old state was at the end of the range, and add a + * toggle there if it's needed. */ TkBTreeStartSearch(index1Ptr, index2Ptr, tagPtr, &search); @@ -2167,24 +2157,24 @@ TkBTreeTag(index1Ptr, index2Ptr, tagPtr, add) ckfree((char *) segPtr); /* - * The code below is a bit tricky. After deleting a toggle - * we eventually have to call CleanupLine, in order to allow - * character segments to be merged together. To do this, we - * remember in cleanupLinePtr a line that needs to be - * cleaned up, but we don't clean it up until we've moved - * on to a different line. That way the cleanup process - * won't goof up segPtr. + * The code below is a bit tricky. After deleting a toggle we + * eventually have to call CleanupLine, in order to allow character + * segments to be merged together. To do this, we remember in + * cleanupLinePtr a line that needs to be cleaned up, but we don't + * clean it up until we've moved on to a different line. That way the + * cleanup process won't goof up segPtr. */ if (cleanupLinePtr != search.curIndex.linePtr) { CleanupLine(cleanupLinePtr); cleanupLinePtr = search.curIndex.linePtr; } + /* - * Quick hack. ChangeNodeToggleCount may move the tag's root - * location around and leave the search in the void. This resets - * the search. + * Quick hack. ChangeNodeToggleCount may move the tag's root location + * around and leave the search in the void. This resets the search. */ + if (changed) { TkBTreeStartSearch(index1Ptr, index2Ptr, tagPtr, &search); } @@ -2207,12 +2197,12 @@ TkBTreeTag(index1Ptr, index2Ptr, tagPtr, add) } /* - * Cleanup cleanupLinePtr and the last line of the range, if - * these are different. + * Cleanup cleanupLinePtr and the last line of the range, if these are + * different. */ if (anyChanges) { - CleanupLine(cleanupLinePtr); + CleanupLine(cleanupLinePtr); if (cleanupLinePtr != index2Ptr->linePtr) { CleanupLine(index2Ptr->linePtr); } @@ -2229,32 +2219,32 @@ TkBTreeTag(index1Ptr, index2Ptr, tagPtr, add) * * ChangeNodeToggleCount -- * - * This procedure increments or decrements the toggle count for - * a particular tag in a particular node and all its ancestors - * up to the per-tag root node. + * This function increments or decrements the toggle count for a + * particular tag in a particular node and all its ancestors up to the + * per-tag root node. * * Results: * None. * * Side effects: - * The toggle count for tag is adjusted up or down by "delta" in - * nodePtr. This routine maintains the tagRootPtr that identifies - * the root node for the tag, moving it up or down the tree as needed. + * The toggle count for tag is adjusted up or down by "delta" in nodePtr. + * This routine maintains the tagRootPtr that identifies the root node + * for the tag, moving it up or down the tree as needed. * *---------------------------------------------------------------------- */ static void ChangeNodeToggleCount(nodePtr, tagPtr, delta) - register Node *nodePtr; /* Node whose toggle count for a tag - * must be changed. */ - TkTextTag *tagPtr; /* Information about tag. */ - int delta; /* Amount to add to current toggle - * count for tag (may be negative). */ + register Node *nodePtr; /* Node whose toggle count for a tag must be + * changed. */ + TkTextTag *tagPtr; /* Information about tag. */ + int delta; /* Amount to add to current toggle count for + * tag (may be negative). */ { register Summary *summaryPtr, *prevPtr; register Node *node2Ptr; - int rootLevel; /* Level of original tag root */ + int rootLevel; /* Level of original tag root */ tagPtr->toggleCount += delta; if (tagPtr->tagRootPtr == (Node *) NULL) { @@ -2263,8 +2253,8 @@ ChangeNodeToggleCount(nodePtr, tagPtr, delta) } /* - * Note the level of the existing root for the tag so we can detect - * if it needs to be moved because of the toggle count change. + * Note the level of the existing root for the tag so we can detect if it + * needs to be moved because of the toggle count change. */ rootLevel = tagPtr->tagRootPtr->level; @@ -2277,10 +2267,10 @@ ChangeNodeToggleCount(nodePtr, tagPtr, delta) for ( ; nodePtr != tagPtr->tagRootPtr; nodePtr = nodePtr->parentPtr) { /* - * See if there's already an entry for this tag for this node. If so, + * See if there's already an entry for this tag for this node. If so, * perhaps all we have to do is adjust its count. */ - + for (prevPtr = NULL, summaryPtr = nodePtr->summaryPtr; summaryPtr != NULL; prevPtr = summaryPtr, summaryPtr = summaryPtr->nextPtr) { @@ -2304,7 +2294,7 @@ ChangeNodeToggleCount(nodePtr, tagPtr, delta) Tcl_Panic("ChangeNodeToggleCount: bad toggle count (%d) max (%d)", summaryPtr->toggleCount, tagPtr->toggleCount); } - + /* * Zero toggle count; must remove this tag from the list. */ @@ -2319,20 +2309,19 @@ ChangeNodeToggleCount(nodePtr, tagPtr, delta) /* * This tag isn't currently in the summary information list. */ - + if (rootLevel == nodePtr->level) { - + /* * The old tag root is at the same level in the tree as this - * node, but it isn't at this node. Move the tag root up - * a level, in the hopes that it will now cover this node - * as well as the old root (if not, we'll move it up again - * the next time through the loop). To push it up one level - * we copy the original toggle count into the summary - * information at the old root and change the root to its - * parent node. + * node, but it isn't at this node. Move the tag root up a + * level, in the hopes that it will now cover this node as + * well as the old root (if not, we'll move it up again the + * next time through the loop). To push it up one level we + * copy the original toggle count into the summary information + * at the old root and change the root to its parent node. */ - + Node *rootNodePtr = tagPtr->tagRootPtr; summaryPtr = (Summary *) ckalloc(sizeof(Summary)); summaryPtr->tagPtr = tagPtr; @@ -2352,8 +2341,8 @@ ChangeNodeToggleCount(nodePtr, tagPtr, delta) } /* - * If we've decremented the toggle count, then it may be necessary - * to push the tag root down one or more levels. + * If we've decremented the toggle count, then it may be necessary to push + * the tag root down one or more levels. */ if (delta >= 0) { @@ -2366,8 +2355,8 @@ ChangeNodeToggleCount(nodePtr, tagPtr, delta) nodePtr = tagPtr->tagRootPtr; while (nodePtr->level > 0) { /* - * See if a single child node accounts for all of the tag's - * toggles. If so, push the root down one level. + * See if a single child node accounts for all of the tag's toggles. + * If so, push the root down one level. */ for (node2Ptr = nodePtr->children.nodePtr; @@ -2416,10 +2405,10 @@ ChangeNodeToggleCount(nodePtr, tagPtr, delta) * Find the start of the first range of a tag. * * Results: - * The return value is a pointer to the first tag toggle segment - * for the tag. This can be either a tagon or tagoff segments because - * of the way TkBTreeAdd removes a tag. - * Sets *indexPtr to be the index of the tag toggle. + * The return value is a pointer to the first tag toggle segment for the + * tag. This can be either a tagon or tagoff segments because of the way + * TkBTreeAdd removes a tag. Sets *indexPtr to be the index of the tag + * toggle. * * Side effects: * None. @@ -2429,9 +2418,9 @@ ChangeNodeToggleCount(nodePtr, tagPtr, delta) static TkTextSegment * FindTagStart(tree, tagPtr, indexPtr) - TkTextBTree tree; /* Tree to search within */ - TkTextTag *tagPtr; /* Tag to search for. */ - TkTextIndex *indexPtr; /* Return - index information */ + TkTextBTree tree; /* Tree to search within */ + TkTextTag *tagPtr; /* Tag to search for. */ + TkTextIndex *indexPtr; /* Return - index information */ { register Node *nodePtr; register TkTextLine *linePtr; @@ -2445,8 +2434,8 @@ FindTagStart(tree, tagPtr, indexPtr) } /* - * Search from the root of the subtree that contains the tag down - * to the level 0 node. + * Search from the root of the subtree that contains the tag down to the + * level 0 node. */ while (nodePtr->level > 0) { @@ -2459,7 +2448,7 @@ FindTagStart(tree, tagPtr, indexPtr) } } } - gotNodeWithTag: + gotNodeWithTag: continue; } @@ -2475,9 +2464,10 @@ FindTagStart(tree, tagPtr, indexPtr) || (segPtr->typePtr == &tkTextToggleOffType)) && (segPtr->body.toggle.tagPtr == tagPtr)) { /* - * It is possible that this is a tagoff tag, but that - * gets cleaned up later. + * It is possible that this is a tagoff tag, but that gets + * cleaned up later. */ + indexPtr->tree = tree; indexPtr->linePtr = linePtr; indexPtr->byteIndex = offset; @@ -2496,10 +2486,10 @@ FindTagStart(tree, tagPtr, indexPtr) * Find the end of the last range of a tag. * * Results: - * The return value is a pointer to the last tag toggle segment - * for the tag. This can be either a tagon or tagoff segments because - * of the way TkBTreeAdd removes a tag. - * Sets *indexPtr to be the index of the tag toggle. + * The return value is a pointer to the last tag toggle segment for the + * tag. This can be either a tagon or tagoff segments because of the way + * TkBTreeAdd removes a tag. Sets *indexPtr to be the index of the tag + * toggle. * * Side effects: * None. @@ -2509,9 +2499,9 @@ FindTagStart(tree, tagPtr, indexPtr) static TkTextSegment * FindTagEnd(tree, tagPtr, indexPtr) - TkTextBTree tree; /* Tree to search within */ - TkTextTag *tagPtr; /* Tag to search for. */ - TkTextIndex *indexPtr; /* Return - index information */ + TkTextBTree tree; /* Tree to search within */ + TkTextTag *tagPtr; /* Tag to search for. */ + TkTextIndex *indexPtr; /* Return - index information */ { register Node *nodePtr, *lastNodePtr; register TkTextLine *linePtr ,*lastLinePtr; @@ -2525,8 +2515,8 @@ FindTagEnd(tree, tagPtr, indexPtr) } /* - * Search from the root of the subtree that contains the tag down - * to the level 0 node. + * Search from the root of the subtree that contains the tag down to the + * level 0 node. */ while (nodePtr->level > 0) { @@ -2546,13 +2536,14 @@ FindTagEnd(tree, tagPtr, indexPtr) /* * Work through the lines attached to the level-0 node. */ + last2SegPtr = NULL; lastoffset2 = 0; lastoffset = 0; for (lastLinePtr = NULL, linePtr = nodePtr->children.linePtr; linePtr != (TkTextLine *) NULL; linePtr = linePtr->nextPtr) { for (offset = 0, lastSegPtr = NULL, segPtr = linePtr->segPtr ; - segPtr != NULL; + segPtr != NULL; offset += segPtr->size, segPtr = segPtr->nextPtr) { if (((segPtr->typePtr == &tkTextToggleOnType) || (segPtr->typePtr == &tkTextToggleOffType)) @@ -2578,19 +2569,19 @@ FindTagEnd(tree, tagPtr, indexPtr) * * TkBTreeStartSearch -- * - * This procedure sets up a search for tag transitions involving - * a given tag (or all tags) in a given range of the text. + * This function sets up a search for tag transitions involving a given + * tag (or all tags) in a given range of the text. * * Results: * None. * * Side effects: - * The information at *searchPtr is set up so that subsequent calls - * to TkBTreeNextTag or TkBTreePrevTag will return information about the - * locations of tag transitions. Note that TkBTreeNextTag or - * TkBTreePrevTag must be called to get the first transition. - * Note: unlike TkBTreeNextTag and TkBTreePrevTag, this routine does not - * guarantee that searchPtr->curIndex is equal to *index1Ptr. It may be + * The information at *searchPtr is set up so that subsequent calls to + * TkBTreeNextTag or TkBTreePrevTag will return information about the + * locations of tag transitions. Note that TkBTreeNextTag or + * TkBTreePrevTag must be called to get the first transition. Note: + * unlike TkBTreeNextTag and TkBTreePrevTag, this routine does not + * guarantee that searchPtr->curIndex is equal to *index1Ptr. It may be * greater than that if *index1Ptr is less than the first tag transition. * *---------------------------------------------------------------------- @@ -2598,31 +2589,30 @@ FindTagEnd(tree, tagPtr, indexPtr) void TkBTreeStartSearch(index1Ptr, index2Ptr, tagPtr, searchPtr) - TkTextIndex *index1Ptr; /* Search starts here. Tag toggles - * at this position will not be - * returned. */ - TkTextIndex *index2Ptr; /* Search stops here. Tag toggles - * at this position *will* be - * returned. */ - TkTextTag *tagPtr; /* Tag to search for. NULL means - * search for any tag. */ - register TkTextSearch *searchPtr; /* Where to store information about - * search's progress. */ + TkTextIndex *index1Ptr; /* Search starts here. Tag toggles at this + * position will not be returned. */ + TkTextIndex *index2Ptr; /* Search stops here. Tag toggles at this + * position *will* be returned. */ + TkTextTag *tagPtr; /* Tag to search for. NULL means search for + * any tag. */ + register TkTextSearch *searchPtr; + /* Where to store information about search's + * progress. */ { int offset; TkTextIndex index0; /* First index of the tag */ TkTextSegment *seg0Ptr; /* First segment of the tag */ /* - * Find the segment that contains the first toggle for the tag. This - * may become the starting point in the search. + * Find the segment that contains the first toggle for the tag. This may + * become the starting point in the search. */ seg0Ptr = FindTagStart(index1Ptr->tree, tagPtr, &index0); if (seg0Ptr == (TkTextSegment *) NULL) { /* - * Even though there are no toggles, the display code still - * uses the search curIndex, so initialize that anyway. + * Even though there are no toggles, the display code still uses the + * search curIndex, so initialize that anyway. */ searchPtr->linesLeft = 0; @@ -2655,14 +2645,15 @@ TkBTreeStartSearch(index1Ptr, index2Ptr, tagPtr, searchPtr) /* * Starting and stopping segments are in the same line; mark the * search as over immediately if the second segment is before the - * first. A search does not return a toggle at the very start of - * the range, unless the range is artificially moved up to index0. + * first. A search does not return a toggle at the very start of the + * range, unless the range is artificially moved up to index0. */ - if (((index1Ptr == &index0) && + + if (((index1Ptr == &index0) && (index1Ptr->byteIndex > index2Ptr->byteIndex)) || - ((index1Ptr != &index0) && + ((index1Ptr != &index0) && (index1Ptr->byteIndex >= index2Ptr->byteIndex))) { - searchPtr->linesLeft = 0; + searchPtr->linesLeft = 0; } } } @@ -2672,39 +2663,37 @@ TkBTreeStartSearch(index1Ptr, index2Ptr, tagPtr, searchPtr) * * TkBTreeStartSearchBack -- * - * This procedure sets up a search backwards for tag transitions involving - * a given tag (or all tags) in a given range of the text. In the - * normal case the first index (*index1Ptr) is beyond the second - * index (*index2Ptr). - * + * This function sets up a search backwards for tag transitions involving + * a given tag (or all tags) in a given range of the text. In the normal + * case the first index (*index1Ptr) is beyond the second index + * (*index2Ptr). * * Results: * None. * * Side effects: - * The information at *searchPtr is set up so that subsequent calls - * to TkBTreePrevTag will return information about the - * locations of tag transitions. Note that TkBTreePrevTag must be called - * to get the first transition. - * Note: unlike TkBTreeNextTag and TkBTreePrevTag, this routine does not - * guarantee that searchPtr->curIndex is equal to *index1Ptr. It may be - * less than that if *index1Ptr is greater than the last tag transition. + * The information at *searchPtr is set up so that subsequent calls to + * TkBTreePrevTag will return information about the locations of tag + * transitions. Note that TkBTreePrevTag must be called to get the first + * transition. Note: unlike TkBTreeNextTag and TkBTreePrevTag, this + * routine does not guarantee that searchPtr->curIndex is equal to + * *index1Ptr. It may be less than that if *index1Ptr is greater than the + * last tag transition. * *---------------------------------------------------------------------- */ void TkBTreeStartSearchBack(index1Ptr, index2Ptr, tagPtr, searchPtr) - TkTextIndex *index1Ptr; /* Search starts here. Tag toggles - * at this position will not be - * returned. */ - TkTextIndex *index2Ptr; /* Search stops here. Tag toggles - * at this position *will* be - * returned. */ - TkTextTag *tagPtr; /* Tag to search for. NULL means - * search for any tag. */ - register TkTextSearch *searchPtr; /* Where to store information about - * search's progress. */ + TkTextIndex *index1Ptr; /* Search starts here. Tag toggles at this + * position will not be returned. */ + TkTextIndex *index2Ptr; /* Search stops here. Tag toggles at this + * position *will* be returned. */ + TkTextTag *tagPtr; /* Tag to search for. NULL means search for + * any tag. */ + register TkTextSearch *searchPtr; + /* Where to store information about + * search's progress. */ { int offset; TkTextIndex index0; /* Last index of the tag */ @@ -2712,15 +2701,15 @@ TkBTreeStartSearchBack(index1Ptr, index2Ptr, tagPtr, searchPtr) TkTextSegment *seg0Ptr; /* Last segment of the tag */ /* - * Find the segment that contains the last toggle for the tag. This - * may become the starting point in the search. + * Find the segment that contains the last toggle for the tag. This may + * become the starting point in the search. */ seg0Ptr = FindTagEnd(index1Ptr->tree, tagPtr, &index0); if (seg0Ptr == (TkTextSegment *) NULL) { /* - * Even though there are no toggles, the display code still - * uses the search curIndex, so initialize that anyway. + * Even though there are no toggles, the display code still uses the + * search curIndex, so initialize that anyway. */ searchPtr->linesLeft = 0; @@ -2739,16 +2728,16 @@ TkBTreeStartSearchBack(index1Ptr, index2Ptr, tagPtr, searchPtr) searchPtr->curIndex = index0; index1Ptr = &index0; } else { - TkTextIndexBackChars(NULL, index1Ptr, 1, &searchPtr->curIndex, - COUNT_INDICES); + TkTextIndexBackChars(NULL, index1Ptr, 1, &searchPtr->curIndex, + COUNT_INDICES); } searchPtr->segPtr = NULL; searchPtr->nextPtr = TkTextIndexToSeg(&searchPtr->curIndex, &offset); searchPtr->curIndex.byteIndex -= offset; /* - * Adjust the end of the search so it does find toggles that are right - * at the second index specified by the user. + * Adjust the end of the search so it does find toggles that are right at + * the second index specified by the user. */ if ((TkBTreeLinesTo(NULL, index2Ptr->linePtr) == 0) && @@ -2781,18 +2770,18 @@ TkBTreeStartSearchBack(index1Ptr, index2Ptr, tagPtr, searchPtr) * * TkBTreeNextTag -- * - * Once a tag search has begun, successive calls to this procedure - * return successive tag toggles. Note: it is NOT SAFE to call this - * procedure if characters have been inserted into or deleted from - * the B-tree since the call to TkBTreeStartSearch. + * Once a tag search has begun, successive calls to this function return + * successive tag toggles. Note: it is NOT SAFE to call this function if + * characters have been inserted into or deleted from the B-tree since + * the call to TkBTreeStartSearch. * * Results: * The return value is 1 if another toggle was found that met the - * criteria specified in the call to TkBTreeStartSearch; in this - * case searchPtr->curIndex gives the toggle's position and - * searchPtr->curTagPtr points to its segment. 0 is returned if - * no more matching tag transitions were found; in this case - * searchPtr->curIndex is the same as searchPtr->stopIndex. + * criteria specified in the call to TkBTreeStartSearch; in this case + * searchPtr->curIndex gives the toggle's position and + * searchPtr->curTagPtr points to its segment. 0 is returned if no more + * matching tag transitions were found; in this case searchPtr->curIndex + * is the same as searchPtr->stopIndex. * * Side effects: * Information in *searchPtr is modified to update the state of the @@ -2803,9 +2792,10 @@ TkBTreeStartSearchBack(index1Ptr, index2Ptr, tagPtr, searchPtr) int TkBTreeNextTag(searchPtr) - register TkTextSearch *searchPtr; /* Information about search in - * progress; must have been set up by - * call to TkBTreeStartSearch. */ + register TkTextSearch *searchPtr; + /* Information about search in progress; must + * have been set up by call to + * TkBTreeStartSearch. */ { register TkTextSegment *segPtr; register Node *nodePtr; @@ -2816,9 +2806,9 @@ TkBTreeNextTag(searchPtr) } /* - * The outermost loop iterates over lines that may potentially contain - * a relevant tag transition, starting from the current segment in - * the current line. + * The outermost loop iterates over lines that may potentially contain a + * relevant tag transition, starting from the current segment in the + * current line. */ segPtr = searchPtr->nextPtr; @@ -2842,11 +2832,10 @@ TkBTreeNextTag(searchPtr) } searchPtr->curIndex.byteIndex += segPtr->size; } - + /* * See if there are more lines associated with the current parent - * node. If so, go back to the top of the loop to search the next - * one. + * node. If so, go back to the top of the loop to search the next one. */ nodePtr = searchPtr->curIndex.linePtr->parentPtr; @@ -2863,14 +2852,14 @@ TkBTreeNextTag(searchPtr) if (nodePtr == searchPtr->tagPtr->tagRootPtr) { goto searchOver; } - + /* * Search across and up through the B-tree's node hierarchy looking * for the next node that has a relevant tag transition somewhere in - * its subtree. Be sure to update linesLeft as we skip over large + * its subtree. Be sure to update linesLeft as we skip over large * chunks of lines. */ - + while (1) { while (nodePtr->nextPtr == NULL) { if (nodePtr->parentPtr == NULL || @@ -2889,14 +2878,14 @@ TkBTreeNextTag(searchPtr) } searchPtr->linesLeft -= nodePtr->numLines; } - + /* * At this point we've found a subtree that has a relevant tag - * transition. Now search down (and across) through that subtree - * to find the first level-0 node that has a relevant tag transition. + * transition. Now search down (and across) through that subtree to + * find the first level-0 node that has a relevant tag transition. */ - - gotNodeWithTag: + + gotNodeWithTag: while (nodePtr->level > 0) { for (nodePtr = nodePtr->children.nodePtr; ; nodePtr = nodePtr->nextPtr) { @@ -2904,6 +2893,10 @@ TkBTreeNextTag(searchPtr) summaryPtr = summaryPtr->nextPtr) { if ((searchPtr->allTags) || (summaryPtr->tagPtr == searchPtr->tagPtr)) { + /* + * Would really like a multi-level continue here... + */ + goto nextChild; } } @@ -2912,13 +2905,13 @@ TkBTreeNextTag(searchPtr) Tcl_Panic("TkBTreeNextTag found incorrect tag summary info."); } } - nextChild: + nextChild: continue; } - + /* * Now we're down to a level-0 node that contains a line that contains - * a relevant tag transition. Set up line information and go back to + * a relevant tag transition. Set up line information and go back to * the beginning of the loop to search through lines. */ @@ -2931,7 +2924,7 @@ TkBTreeNextTag(searchPtr) continue; } - searchOver: + searchOver: searchPtr->linesLeft = 0; searchPtr->segPtr = NULL; return 0; @@ -2942,19 +2935,18 @@ TkBTreeNextTag(searchPtr) * * TkBTreePrevTag -- * - * Once a tag search has begun, successive calls to this procedure - * return successive tag toggles in the reverse direction. - * Note: it is NOT SAFE to call this - * procedure if characters have been inserted into or deleted from - * the B-tree since the call to TkBTreeStartSearch. + * Once a tag search has begun, successive calls to this function return + * successive tag toggles in the reverse direction. Note: it is NOT SAFE + * to call this function if characters have been inserted into or deleted + * from the B-tree since the call to TkBTreeStartSearch. * * Results: * The return value is 1 if another toggle was found that met the - * criteria specified in the call to TkBTreeStartSearch; in this - * case searchPtr->curIndex gives the toggle's position and - * searchPtr->curTagPtr points to its segment. 0 is returned if - * no more matching tag transitions were found; in this case - * searchPtr->curIndex is the same as searchPtr->stopIndex. + * criteria specified in the call to TkBTreeStartSearch; in this case + * searchPtr->curIndex gives the toggle's position and + * searchPtr->curTagPtr points to its segment. 0 is returned if no more + * matching tag transitions were found; in this case searchPtr->curIndex + * is the same as searchPtr->stopIndex. * * Side effects: * Information in *searchPtr is modified to update the state of the @@ -2965,16 +2957,17 @@ TkBTreeNextTag(searchPtr) int TkBTreePrevTag(searchPtr) - register TkTextSearch *searchPtr; /* Information about search in - * progress; must have been set up by - * call to TkBTreeStartSearch. */ + register TkTextSearch *searchPtr; + /* Information about search in progress; must + * have been set up by call to + * TkBTreeStartSearch. */ { register TkTextSegment *segPtr, *prevPtr; register TkTextLine *linePtr, *prevLinePtr; register Node *nodePtr, *node2Ptr, *prevNodePtr; register Summary *summaryPtr; int byteIndex; - int pastLast; /* Saw last marker during scan */ + int pastLast; /* Saw last marker during scan */ int linesSkipped; if (searchPtr->linesLeft <= 0) { @@ -2982,25 +2975,28 @@ TkBTreePrevTag(searchPtr) } /* - * The outermost loop iterates over lines that may potentially contain - * a relevant tag transition, starting from the current segment in - * the current line. "nextPtr" is maintained as the last segment in - * a line that we can look at. + * The outermost loop iterates over lines that may potentially contain a + * relevant tag transition, starting from the current segment in the + * current line. "nextPtr" is maintained as the last segment in a line + * that we can look at. */ while (1) { /* * Check for the last toggle before the current segment on this line. */ + byteIndex = 0; if (searchPtr->lastPtr == NULL) { - /* + /* * Search back to the very beginning, so pastLast is irrelevent. */ - pastLast = 1; + + pastLast = 1; } else { pastLast = 0; } + for (prevPtr = NULL, segPtr = searchPtr->curIndex.linePtr->segPtr ; segPtr != NULL && segPtr != searchPtr->nextPtr; segPtr = segPtr->nextPtr) { @@ -3012,7 +3008,7 @@ TkBTreePrevTag(searchPtr) searchPtr->curIndex.byteIndex = byteIndex; } if (segPtr == searchPtr->lastPtr) { - prevPtr = NULL; /* Segments earlier than last don't count */ + prevPtr = NULL; /* Segments earlier than last don't count */ pastLast = 1; } byteIndex += segPtr->size; @@ -3020,9 +3016,10 @@ TkBTreePrevTag(searchPtr) if (prevPtr != NULL) { if (searchPtr->linesLeft == 1 && !pastLast) { /* - * We found a segment that is before the stopping index. - * Note that it is OK if prevPtr == lastPtr. + * We found a segment that is before the stopping index. Note + * that it is OK if prevPtr == lastPtr. */ + goto searchOver; } searchPtr->segPtr = prevPtr; @@ -3030,7 +3027,7 @@ TkBTreePrevTag(searchPtr) searchPtr->tagPtr = prevPtr->body.toggle.tagPtr; return 1; } - + searchPtr->linesLeft--; if (searchPtr->linesLeft <= 0) { goto searchOver; @@ -3038,7 +3035,7 @@ TkBTreePrevTag(searchPtr) /* * See if there are more lines associated with the current parent - * node. If so, go back to the top of the loop to search the previous + * node. If so, go back to the top of the loop to search the previous * one. */ @@ -3056,17 +3053,17 @@ TkBTreePrevTag(searchPtr) if (nodePtr == searchPtr->tagPtr->tagRootPtr) { goto searchOver; } - + /* * Search across and up through the B-tree's node hierarchy looking - * for the previous node that has a relevant tag transition somewhere in - * its subtree. The search and line counting is trickier with/out - * back pointers. We'll scan all the nodes under a parent up to - * the current node, searching all of them for tag state. The last - * one we find, if any, is recorded in prevNodePtr, and any nodes - * past prevNodePtr that don't have tag state increment linesSkipped. + * for the previous node that has a relevant tag transition somewhere + * in its subtree. The search and line counting is trickier with/out + * back pointers. We'll scan all the nodes under a parent up to the + * current node, searching all of them for tag state. The last one we + * find, if any, is recorded in prevNodePtr, and any nodes past + * prevNodePtr that don't have tag state increment linesSkipped. */ - + while (1) { for (prevNodePtr = NULL, linesSkipped = 0, node2Ptr = nodePtr->parentPtr->children.nodePtr ; @@ -3082,7 +3079,7 @@ TkBTreePrevTag(searchPtr) } linesSkipped += node2Ptr->numLines; - keepLooking: + keepLooking: continue; } if (prevNodePtr != NULL) { @@ -3096,14 +3093,14 @@ TkBTreePrevTag(searchPtr) goto searchOver; } } - + /* * At this point we've found a subtree that has a relevant tag - * transition. Now search down (and across) through that subtree - * to find the last level-0 node that has a relevant tag transition. + * transition. Now search down (and across) through that subtree to + * find the last level-0 node that has a relevant tag transition. */ - - gotNodeWithTag: + + gotNodeWithTag: while (nodePtr->level > 0) { for (linesSkipped = 0, prevNodePtr = NULL, nodePtr = nodePtr->children.nodePtr; nodePtr != NULL ; @@ -3119,7 +3116,7 @@ TkBTreePrevTag(searchPtr) } linesSkipped += nodePtr->numLines; - keepLooking2: + keepLooking2: continue; } if (prevNodePtr == NULL) { @@ -3128,11 +3125,11 @@ TkBTreePrevTag(searchPtr) searchPtr->linesLeft -= linesSkipped; nodePtr = prevNodePtr; } - + /* * Now we're down to a level-0 node that contains a line that contains - * a relevant tag transition. Set up line information and go back to - * the beginning of the loop to search through lines. We start with + * a relevant tag transition. Set up line information and go back to + * the beginning of the loop to search through lines. We start with * the last line below the node. */ @@ -3149,7 +3146,7 @@ TkBTreePrevTag(searchPtr) continue; } - searchOver: + searchOver: searchPtr->linesLeft = 0; searchPtr->segPtr = NULL; return 0; @@ -3163,8 +3160,8 @@ TkBTreePrevTag(searchPtr) * Determine whether a particular character has a particular tag. * * Results: - * The return value is 1 if the given tag is in effect at the - * character given by linePtr and ch, and 0 otherwise. + * The return value is 1 if the given tag is in effect at the character + * given by linePtr and ch, and 0 otherwise. * * Side effects: * None. @@ -3174,9 +3171,9 @@ TkBTreePrevTag(searchPtr) int TkBTreeCharTagged(indexPtr, tagPtr) - CONST TkTextIndex *indexPtr; /* Indicates a character position at - * which to check for a tag. */ - TkTextTag *tagPtr; /* Tag of interest. */ + CONST TkTextIndex *indexPtr;/* Indicates a character position at which to + * check for a tag. */ + TkTextTag *tagPtr; /* Tag of interest. */ { register Node *nodePtr; register TkTextLine *siblingLinePtr; @@ -3184,10 +3181,10 @@ TkBTreeCharTagged(indexPtr, tagPtr) TkTextSegment *toggleSegPtr; int toggles, index; - /* - * Check for toggles for the tag in indexPtr's line but before - * indexPtr. If there is one, its type indicates whether or - * not the character is tagged. + /* + * Check for toggles for the tag in indexPtr's line but before indexPtr. + * If there is one, its type indicates whether or not the character is + * tagged. */ toggleSegPtr = NULL; @@ -3205,9 +3202,8 @@ TkBTreeCharTagged(indexPtr, tagPtr) } /* - * No toggle in this line. Look for toggles for the tag in lines - * that are predecessors of indexPtr->linePtr but under the same - * level-0 node. + * No toggle in this line. Look for toggles for the tag in lines that are + * predecessors of indexPtr->linePtr but under the same level-0 node. */ for (siblingLinePtr = indexPtr->linePtr->parentPtr->children.linePtr; @@ -3227,9 +3223,9 @@ TkBTreeCharTagged(indexPtr, tagPtr) } /* - * No toggle in this node. Scan upwards through the ancestors of - * this node, counting the number of toggles of the given tag in - * siblings that precede that node. + * No toggle in this node. Scan upwards through the ancestors of this + * node, counting the number of toggles of the given tag in siblings that + * precede that node. */ toggles = 0; @@ -3238,7 +3234,7 @@ TkBTreeCharTagged(indexPtr, tagPtr) register Node *siblingPtr; register Summary *summaryPtr; - for (siblingPtr = nodePtr->parentPtr->children.nodePtr; + for (siblingPtr = nodePtr->parentPtr->children.nodePtr; siblingPtr != nodePtr; siblingPtr = siblingPtr->nextPtr) { for (summaryPtr = siblingPtr->summaryPtr; summaryPtr != NULL; summaryPtr = summaryPtr->nextPtr) { @@ -3253,8 +3249,8 @@ TkBTreeCharTagged(indexPtr, tagPtr) } /* - * An odd number of toggles means that the tag is present at the - * given point. + * An odd number of toggles means that the tag is present at the given + * point. */ return toggles & 1; @@ -3265,17 +3261,17 @@ TkBTreeCharTagged(indexPtr, tagPtr) * * TkBTreeGetTags -- * - * Return information about all of the tags that are associated - * with a particular character in a B-tree of text. + * Return information about all of the tags that are associated with a + * particular character in a B-tree of text. * * Results: * The return value is a malloc-ed array containing pointers to - * information for each of the tags that is associated with - * the character at the position given by linePtr and ch. The - * word at *numTagsPtr is filled in with the number of pointers - * in the array. It is up to the caller to free the array by - * passing it to free. If there are no tags at the given character - * then a NULL pointer is returned and *numTagsPtr will be set to 0. + * information for each of the tags that is associated with the character + * at the position given by linePtr and ch. The word at *numTagsPtr is + * filled in with the number of pointers in the array. It is up to the + * caller to free the array by passing it to free. If there are no tags + * at the given character then a NULL pointer is returned and *numTagsPtr + * will be set to 0. * * Side effects: * None. @@ -3286,11 +3282,11 @@ TkBTreeCharTagged(indexPtr, tagPtr) /* ARGSUSED */ TkTextTag ** TkBTreeGetTags(indexPtr, textPtr, numTagsPtr) - CONST TkTextIndex *indexPtr;/* Indicates a particular position in - * the B-tree. */ - CONST TkText *textPtr; /* If non-NULL, then only return tags - * for this text widget (when there are - * peer widgets). */ + CONST TkTextIndex *indexPtr;/* Indicates a particular position in the + * B-tree. */ + CONST TkText *textPtr; /* If non-NULL, then only return tags for this + * text widget (when there are peer + * widgets). */ int *numTagsPtr; /* Store number of tags found at this * location. */ { @@ -3310,8 +3306,7 @@ TkBTreeGetTags(indexPtr, textPtr, numTagsPtr) NUM_TAG_INFOS*sizeof(int)); /* - * Record tag toggles within the line of indexPtr but preceding - * indexPtr. + * Record tag toggles within the line of indexPtr but preceding indexPtr. */ linePtr = indexPtr->linePtr; @@ -3324,12 +3319,13 @@ TkBTreeGetTags(indexPtr, textPtr, numTagsPtr) } index += segPtr->size; segPtr = segPtr->nextPtr; - + if (segPtr == NULL) { - /* - * Two logical lines merged into one display line - * through eliding of a newline + /* + * Two logical lines merged into one display line through eliding + * of a newline. */ + linePtr = TkBTreeNextLine(NULL, linePtr); segPtr = linePtr->segPtr; } @@ -3353,8 +3349,8 @@ TkBTreeGetTags(indexPtr, textPtr, numTagsPtr) } /* - * For each node in the ancestry of this line, record tag toggles - * for all siblings that precede that node. + * For each node in the ancestry of this line, record tag toggles for all + * siblings that precede that node. */ for (nodePtr = indexPtr->linePtr->parentPtr; nodePtr->parentPtr != NULL; @@ -3362,7 +3358,7 @@ TkBTreeGetTags(indexPtr, textPtr, numTagsPtr) register Node *siblingPtr; register Summary *summaryPtr; - for (siblingPtr = nodePtr->parentPtr->children.nodePtr; + for (siblingPtr = nodePtr->parentPtr->children.nodePtr; siblingPtr != nodePtr; siblingPtr = siblingPtr->nextPtr) { for (summaryPtr = siblingPtr->summaryPtr; summaryPtr != NULL; summaryPtr = summaryPtr->nextPtr) { @@ -3375,10 +3371,10 @@ TkBTreeGetTags(indexPtr, textPtr, numTagsPtr) } /* - * Go through the tag information and squash out all of the tags - * that have even toggle counts (these tags exist before the point - * of interest, but not at the desired character itself). Also - * squash out all tags that don't belong to the requested widget. + * Go through the tag information and squash out all of the tags that have + * even toggle counts (these tags exist before the point of interest, but + * not at the desired character itself). Also squash out all tags that + * don't belong to the requested widget. */ for (src = 0, dst = 0; src < tagInfo.numTags; src++) { @@ -3406,24 +3402,22 @@ TkBTreeGetTags(indexPtr, textPtr, numTagsPtr) * * Special case to just return information about elided attribute. * Specialized from TkBTreeGetTags(indexPtr, textPtr, numTagsPtr) and - * GetStyle(textPtr, indexPtr). Just need to keep track of - * invisibility settings for each priority, pick highest one active - * at end. - * - * Note that this returns all elide information up to and including - * the given index (quite obviously). However, this does mean that - * if indexPtr is a line-start and one then iterates from the beginning - * of that line forwards, one will actually revisit the segPtrs of - * size zero (for tag toggling, for example) which have already been - * seen here. - * - * For this reason we fill in the fields 'segPtr' and 'segOffset' - * of elideInfo, enabling our caller easily to calculate - * incremental changes from where we left off. + * GetStyle(textPtr, indexPtr). Just need to keep track of invisibility + * settings for each priority, pick highest one active at end. + * + * Note that this returns all elide information up to and including the + * given index (quite obviously). However, this does mean that if + * indexPtr is a line-start and one then iterates from the beginning of + * that line forwards, one will actually revisit the segPtrs of size zero + * (for tag toggling, for example) which have already been seen here. + * + * For this reason we fill in the fields 'segPtr' and 'segOffset' of + * elideInfo, enabling our caller easily to calculate incremental changes + * from where we left off. * * Results: * Returns whether this text should be elided or not. - * + * * Optionally returns more detailed information in elideInfo. * * Side effects: @@ -3436,11 +3430,11 @@ TkBTreeGetTags(indexPtr, textPtr, numTagsPtr) int TkTextIsElided(textPtr, indexPtr, elideInfo) CONST TkText *textPtr; /* Overall information about text widget. */ - CONST TkTextIndex *indexPtr;/* The character in the text for which - * display information is wanted. */ - TkTextElideInfo *elideInfo; /* NULL or a pointer to a structure in - * which indexPtr's elide state will - * be stored and returned. */ + CONST TkTextIndex *indexPtr;/* The character in the text for which display + * information is wanted. */ + TkTextElideInfo *elideInfo; /* NULL or a pointer to a structure in which + * indexPtr's elide state will be stored and + * returned. */ { register Node *nodePtr; register TkTextLine *siblingLinePtr; @@ -3450,33 +3444,35 @@ TkTextIsElided(textPtr, indexPtr, elideInfo) register TkTextElideInfo *infoPtr; TkTextLine *linePtr; int elide; - + if (elideInfo == NULL) { infoPtr = (TkTextElideInfo*)ckalloc((unsigned)sizeof(TkTextElideInfo)); } else { infoPtr = elideInfo; } - + infoPtr->elide = 0; /* if nobody says otherwise, it's visible */ infoPtr->tagCnts = infoPtr->deftagCnts; infoPtr->tagPtrs = infoPtr->deftagPtrs; infoPtr->numTags = textPtr->sharedTextPtr->numTags; - /* Almost always avoid malloc, so stay out of system calls */ + /* + * Almost always avoid malloc, so stay out of system calls. + */ + if (LOTSA_TAGS < infoPtr->numTags) { - infoPtr->tagCnts = (int *)ckalloc((unsigned)sizeof(int) - * infoPtr->numTags); - infoPtr->tagPtrs = (TkTextTag **)ckalloc((unsigned)sizeof(TkTextTag*) - * infoPtr->numTags); + infoPtr->tagCnts = (int *) + ckalloc((unsigned) sizeof(int) * infoPtr->numTags); + infoPtr->tagPtrs = (TkTextTag **) + ckalloc((unsigned)sizeof(TkTextTag *) * infoPtr->numTags); } - + for (i=0; i<infoPtr->numTags; i++) { infoPtr->tagCnts[i] = 0; } /* - * Record tag toggles within the line of indexPtr but preceding - * indexPtr. + * Record tag toggles within the line of indexPtr but preceding indexPtr. */ index = 0; @@ -3491,35 +3487,38 @@ TkTextIsElided(textPtr, indexPtr, elideInfo) infoPtr->tagCnts[tagPtr->priority]++; } } - + index += segPtr->size; segPtr = segPtr->nextPtr; if (segPtr == NULL) { - /* - * Two logical lines merged into one display line - * through eliding of a newline + /* + * Two logical lines merged into one display line through eliding + * of a newline. */ + linePtr = TkBTreeNextLine(NULL, linePtr); segPtr = linePtr->segPtr; } } - /* - * Store the first segPtr we haven't examined completely - * so that our caller knows where to start. + + /* + * Store the first segPtr we haven't examined completely so that our + * caller knows where to start. */ + infoPtr->segPtr = segPtr; infoPtr->segOffset = index; - + /* * Record toggles for tags in lines that are predecessors of * indexPtr->linePtr but under the same level-0 node. */ for (siblingLinePtr = indexPtr->linePtr->parentPtr->children.linePtr; - siblingLinePtr != indexPtr->linePtr; - siblingLinePtr = siblingLinePtr->nextPtr) { + siblingLinePtr != indexPtr->linePtr; + siblingLinePtr = siblingLinePtr->nextPtr) { for (segPtr = siblingLinePtr->segPtr; segPtr != NULL; - segPtr = segPtr->nextPtr) { + segPtr = segPtr->nextPtr) { if ((segPtr->typePtr == &tkTextToggleOnType) || (segPtr->typePtr == &tkTextToggleOffType)) { tagPtr = segPtr->body.toggle.tagPtr; @@ -3532,24 +3531,25 @@ TkTextIsElided(textPtr, indexPtr, elideInfo) } /* - * For each node in the ancestry of this line, record tag toggles - * for all siblings that precede that node. + * For each node in the ancestry of this line, record tag toggles for all + * siblings that precede that node. */ for (nodePtr = indexPtr->linePtr->parentPtr; nodePtr->parentPtr != NULL; - nodePtr = nodePtr->parentPtr) { + nodePtr = nodePtr->parentPtr) { register Node *siblingPtr; register Summary *summaryPtr; - for (siblingPtr = nodePtr->parentPtr->children.nodePtr; - siblingPtr != nodePtr; siblingPtr = siblingPtr->nextPtr) { + for (siblingPtr = nodePtr->parentPtr->children.nodePtr; + siblingPtr != nodePtr; siblingPtr = siblingPtr->nextPtr) { for (summaryPtr = siblingPtr->summaryPtr; summaryPtr != NULL; - summaryPtr = summaryPtr->nextPtr) { + summaryPtr = summaryPtr->nextPtr) { if (summaryPtr->toggleCount & 1) { tagPtr = summaryPtr->tagPtr; if (tagPtr->elideString != NULL) { infoPtr->tagPtrs[tagPtr->priority] = tagPtr; - infoPtr->tagCnts[tagPtr->priority] += summaryPtr->toggleCount; + infoPtr->tagCnts[tagPtr->priority] += + summaryPtr->toggleCount; } } } @@ -3557,21 +3557,28 @@ TkTextIsElided(textPtr, indexPtr, elideInfo) } /* - * Now traverse from highest priority to lowest, - * take elided value from first odd count (= on) + * Now traverse from highest priority to lowest, take elided value from + * first odd count (= on) */ infoPtr->elidePriority = -1; for (i = infoPtr->numTags-1; i >=0; i--) { if (infoPtr->tagCnts[i] & 1) { - /* Who would make the selection elided? */ + /* + * Who would make the selection elided? + */ + if ((tagPtr == textPtr->selTagPtr) && !(textPtr->flags & GOT_FOCUS) && (textPtr->inactiveSelBorder == NULL)) { continue; } infoPtr->elide = infoPtr->tagPtrs[i]->elide; - /* Note: i == infoPtr->tagPtrs[i]->priority */ + + /* + * Note: i == infoPtr->tagPtrs[i]->priority + */ + infoPtr->elidePriority = i; break; } @@ -3580,11 +3587,11 @@ TkTextIsElided(textPtr, indexPtr, elideInfo) elide = infoPtr->elide; if (elideInfo == NULL) { - if (LOTSA_TAGS < infoPtr->numTags) { + if (LOTSA_TAGS < infoPtr->numTags) { ckfree((char *) infoPtr->tagCnts); ckfree((char *) infoPtr->tagPtrs); } - + ckfree((char*) infoPtr); } @@ -3596,8 +3603,8 @@ TkTextIsElided(textPtr, indexPtr, elideInfo) * * TkTextFreeElideInfo -- * - * This is a utility procedure used to free up any memory - * allocated by the TkTextIsElided function above. + * This is a utility function used to free up any memory allocated by the + * TkTextIsElided function above. * * Results: * None. @@ -3611,7 +3618,7 @@ TkTextIsElided(textPtr, indexPtr, elideInfo) void TkTextFreeElideInfo(elideInfo) TkTextElideInfo *elideInfo; /* Free any allocated memory in this - * structure. */ + * structure. */ { if (LOTSA_TAGS < elideInfo->numTags) { ckfree((char*)elideInfo->tagCnts); @@ -3624,16 +3631,16 @@ TkTextFreeElideInfo(elideInfo) * * IncCount -- * - * This is a utility procedure used by TkBTreeGetTags. It - * increments the count for a particular tag, adding a new - * entry for that tag if there wasn't one previously. + * This is a utility function used by TkBTreeGetTags. It increments the + * count for a particular tag, adding a new entry for that tag if there + * wasn't one previously. * * Results: * None. * * Side effects: - * The information at *tagInfoPtr may be modified, and the arrays - * may be reallocated to make them larger. + * The information at *tagInfoPtr may be modified, and the arrays may be + * reallocated to make them larger. * *---------------------------------------------------------------------- */ @@ -3657,9 +3664,8 @@ IncCount(tagPtr, inc, tagInfoPtr) } /* - * There isn't currently an entry for this tag, so we have to - * make a new one. If the arrays are full, then enlarge the - * arrays first. + * There isn't currently an entry for this tag, so we have to make a new + * one. If the arrays are full, then enlarge the arrays first. */ if (tagInfoPtr->numTags == tagInfoPtr->arraySize) { @@ -3668,7 +3674,7 @@ IncCount(tagPtr, inc, tagInfoPtr) newSize = 2*tagInfoPtr->arraySize; newTags = (TkTextTag **) ckalloc((unsigned) - (newSize*sizeof(TkTextTag *))); + (newSize * sizeof(TkTextTag *))); memcpy((VOID *) newTags, (VOID *) tagInfoPtr->tagPtrs, tagInfoPtr->arraySize * sizeof(TkTextTag *)); ckfree((char *) tagInfoPtr->tagPtrs); @@ -3691,15 +3697,15 @@ IncCount(tagPtr, inc, tagInfoPtr) * * TkBTreeCheck -- * - * This procedure runs a set of consistency checks over a B-tree - * and panics if any inconsistencies are found. + * This function runs a set of consistency checks over a B-tree and + * panics if any inconsistencies are found. * * Results: * None. * * Side effects: - * If a structural defect is found, the procedure panics with an - * error message. + * If a structural defect is found, the function panics with an error + * message. * *---------------------------------------------------------------------- */ @@ -3721,14 +3727,15 @@ TkBTreeCheck(tree) /* * Make sure that the tag toggle counts and the tag root pointers are OK. */ - for (entryPtr = Tcl_FirstHashEntry(&treePtr->sharedTextPtr->tagTable, &search); + + for (entryPtr=Tcl_FirstHashEntry(&treePtr->sharedTextPtr->tagTable,&search); entryPtr != NULL ; entryPtr = Tcl_NextHashEntry(&search)) { tagPtr = (TkTextTag *) Tcl_GetHashValue(entryPtr); nodePtr = tagPtr->tagRootPtr; if (nodePtr == (Node *) NULL) { if (tagPtr->toggleCount != 0) { Tcl_Panic("TkBTreeCheck found \"%s\" with toggles (%d) but no root", - tagPtr->name, tagPtr->toggleCount); + tagPtr->name, tagPtr->toggleCount); } continue; /* no ranges for the tag */ } else if (tagPtr->toggleCount == 0) { @@ -3770,20 +3777,20 @@ TkBTreeCheck(tree) } if (count != tagPtr->toggleCount) { Tcl_Panic("TkBTreeCheck toggleCount (%d) wrong for \"%s\" should be (%d)", - tagPtr->toggleCount, tagPtr->name, count); + tagPtr->toggleCount, tagPtr->name, count); } } /* - * Call a recursive procedure to do the main body of checks. + * Call a recursive function to do the main body of checks. */ nodePtr = treePtr->rootPtr; CheckNodeConsistency(treePtr->rootPtr, treePtr->pixelReferences); /* - * Make sure that there are at least two lines in the text and - * that the last line has no characters except a newline. + * Make sure that there are at least two lines in the text and that the + * last line has no characters except a newline. */ if (nodePtr->numLines < 2) { @@ -3804,9 +3811,8 @@ TkBTreeCheck(tree) || (segPtr->typePtr == &tkTextRightMarkType) || (segPtr->typePtr == &tkTextLeftMarkType)) { /* - * It's OK to toggle a tag off in the last line, but - * not to start a new range. It's also OK to have marks - * in the last line. + * It's OK to toggle a tag off in the last line, but not to start a + * new range. It's also OK to have marks in the last line. */ segPtr = segPtr->nextPtr; @@ -3832,26 +3838,25 @@ TkBTreeCheck(tree) * * CheckNodeConsistency -- * - * This procedure is called as part of consistency checking for - * B-trees: it checks several aspects of a node and also runs - * checks recursively on the node's children. + * This function is called as part of consistency checking for B-trees: + * it checks several aspects of a node and also runs checks recursively + * on the node's children. * * Results: * None. * * Side effects: - * If anything suspicious is found in the tree structure, the - * procedure panics. + * If anything suspicious is found in the tree structure, the function + * panics. * *---------------------------------------------------------------------- */ static void CheckNodeConsistency(nodePtr, references) - register Node *nodePtr; /* Node whose subtree should be - * checked. */ - int references; /* Number of referring widgets - * which have pixel counts. */ + register Node *nodePtr; /* Node whose subtree should be checked. */ + int references; /* Number of referring widgets which have + * pixel counts. */ { register Node *childNodePtr; register Summary *summaryPtr, *summaryPtr2; @@ -3913,7 +3918,7 @@ CheckNodeConsistency(nodePtr, references) numChildren++; numLines++; for (i = 0; i<references; i++) { - numPixels[i] += linePtr->pixels[2*i]; + numPixels[i] += linePtr->pixels[2*i]; } } } else { @@ -3968,7 +3973,7 @@ CheckNodeConsistency(nodePtr, references) if (references > PIXEL_CLIENTS) { ckfree((char*)numPixels); } - + for (summaryPtr = nodePtr->summaryPtr; summaryPtr != NULL; summaryPtr = summaryPtr->nextPtr) { if (summaryPtr->tagPtr->toggleCount == summaryPtr->toggleCount) { @@ -4022,9 +4027,9 @@ CheckNodeConsistency(nodePtr, references) * * Rebalance -- * - * This procedure is called when a node of a B-tree appears to be - * out of balance (too many children, or too few). It rebalances - * that node and all of its ancestors in the tree. + * This function is called when a node of a B-tree appears to be out of + * balance (too many children, or too few). It rebalances that node and + * all of its ancestors in the tree. * * Results: * None. @@ -4037,13 +4042,12 @@ CheckNodeConsistency(nodePtr, references) static void Rebalance(treePtr, nodePtr) - BTree *treePtr; /* Tree that is being rebalanced. */ - register Node *nodePtr; /* Node that may be out of balance. */ + BTree *treePtr; /* Tree that is being rebalanced. */ + register Node *nodePtr; /* Node that may be out of balance. */ { /* - * Loop over the entire ancestral chain of the node, working up - * through the tree one node at a time until the root node has - * been processed. + * Loop over the entire ancestral chain of the node, working up through + * the tree one node at a time until the root node has been processed. */ for ( ; nodePtr != NULL; nodePtr = nodePtr->parentPtr) { @@ -4052,19 +4056,19 @@ Rebalance(treePtr, nodePtr) int i; /* - * Check to see if the node has too many children. If it does, - * then split off all but the first MIN_CHILDREN into a separate - * node following the original one. Then repeat until the - * node has a decent size. + * Check to see if the node has too many children. If it does, then + * split off all but the first MIN_CHILDREN into a separate node + * following the original one. Then repeat until the node has a decent + * size. */ if (nodePtr->numChildren > MAX_CHILDREN) { while (1) { /* - * If the node being split is the root node, then make a - * new root node above it first. + * If the node being split is the root node, then make a new + * root node above it first. */ - + if (nodePtr->parentPtr == NULL) { newPtr = (Node *) ckalloc(sizeof(Node)); newPtr->parentPtr = NULL; @@ -4074,17 +4078,17 @@ Rebalance(treePtr, nodePtr) newPtr->children.nodePtr = nodePtr; newPtr->numChildren = 1; newPtr->numLines = nodePtr->numLines; - newPtr->numPixels = (int*) ckalloc(sizeof(int)* - treePtr->pixelReferences); + newPtr->numPixels = (int *) + ckalloc(sizeof(int) * treePtr->pixelReferences); for (i=0; i<treePtr->pixelReferences; i++) { - newPtr->numPixels[i] = nodePtr->numPixels[i]; + newPtr->numPixels[i] = nodePtr->numPixels[i]; } RecomputeNodeCounts(treePtr, newPtr); treePtr->rootPtr = newPtr; } newPtr = (Node *) ckalloc(sizeof(Node)); - newPtr->numPixels = (int*) ckalloc(sizeof(int)* - treePtr->pixelReferences); + newPtr->numPixels = (int *) + ckalloc(sizeof(int) * treePtr->pixelReferences); for (i=0; i<treePtr->pixelReferences; i++) { newPtr->numPixels[i] = 0; } @@ -4123,16 +4127,16 @@ Rebalance(treePtr, nodePtr) while (nodePtr->numChildren < MIN_CHILDREN) { register Node *otherPtr; - Node *halfwayNodePtr = NULL; /* Initialization needed only */ - TkTextLine *halfwayLinePtr = NULL; /* to prevent cc warnings. */ + Node *halfwayNodePtr = NULL; /* Initialization needed only */ + TkTextLine *halfwayLinePtr = NULL; /* to prevent cc warnings. */ int totalChildren, firstChildren, i; /* - * Too few children for this node. If this is the root then, - * it's OK for it to have less than MIN_CHILDREN children - * as long as it's got at least two. If it has only one - * (and isn't at level 0), then chop the root node out of - * the tree and use its child as the new root. + * Too few children for this node. If this is the root then, it's + * OK for it to have less than MIN_CHILDREN children as long as + * it's got at least two. If it has only one (and isn't at level + * 0), then chop the root node out of the tree and use its child + * as the new root. */ if (nodePtr->parentPtr == NULL) { @@ -4146,8 +4150,8 @@ Rebalance(treePtr, nodePtr) } /* - * Not the root. Make sure that there are siblings to - * balance with. + * Not the root. Make sure that there are siblings to balance + * with. */ if (nodePtr->parentPtr->numChildren < 2) { @@ -4156,8 +4160,8 @@ Rebalance(treePtr, nodePtr) } /* - * Find a sibling neighbor to borrow from, and arrange for - * nodePtr to be the earlier of the pair. + * Find a sibling neighbor to borrow from, and arrange for nodePtr + * to be the earlier of the pair. */ if (nodePtr->nextPtr == NULL) { @@ -4171,11 +4175,10 @@ Rebalance(treePtr, nodePtr) otherPtr = nodePtr->nextPtr; /* - * We're going to either merge the two siblings together - * into one node or redivide the children among them to - * balance their loads. As preparation, join their two - * child lists into a single list and remember the half-way - * point in the list. + * We're going to either merge the two siblings together into one + * node or redivide the children among them to balance their + * loads. As preparation, join their two child lists into a single + * list and remember the half-way point in the list. */ totalChildren = nodePtr->numChildren + otherPtr->numChildren; @@ -4257,28 +4260,27 @@ Rebalance(treePtr, nodePtr) * * RecomputeNodeCounts -- * - * This procedure is called to recompute all the counts in a node - * (tags, child information, etc.) by scanning the information in - * its descendants. This procedure is called during rebalancing - * when a node's child structure has changed. + * This function is called to recompute all the counts in a node (tags, + * child information, etc.) by scanning the information in its + * descendants. This function is called during rebalancing when a node's + * child structure has changed. * * Results: * None. * * Side effects: - * The tag counts for nodePtr are modified to reflect its current - * child structure, as are its numChildren and numLines fields. - * Also, all of the childrens' parentPtr fields are made to point - * to nodePtr. + * The tag counts for nodePtr are modified to reflect its current child + * structure, as are its numChildren and numLines fields. Also, all of + * the childrens' parentPtr fields are made to point to nodePtr. * *---------------------------------------------------------------------- */ static void RecomputeNodeCounts(treePtr, nodePtr) - register BTree *treePtr; /* The whole B-tree */ - register Node *nodePtr; /* Node whose tag summary information - * must be recomputed. */ + register BTree *treePtr; /* The whole B-tree */ + register Node *nodePtr; /* Node whose tag summary information must be + * recomputed. */ { register Summary *summaryPtr, *summaryPtr2; register Node *childPtr; @@ -4286,10 +4288,10 @@ RecomputeNodeCounts(treePtr, nodePtr) register TkTextSegment *segPtr; TkTextTag *tagPtr; int ref; - + /* - * Zero out all the existing counts for the node, but don't delete - * the existing Summary records (most of them will probably be reused). + * Zero out all the existing counts for the node, but don't delete the + * existing Summary records (most of them will probably be reused). */ for (summaryPtr = nodePtr->summaryPtr; summaryPtr != NULL; @@ -4303,9 +4305,8 @@ RecomputeNodeCounts(treePtr, nodePtr) } /* - * Scan through the children, adding the childrens' tag counts into - * the node's tag counts and adding new Summary structures if - * necessary. + * Scan through the children, adding the childrens' tag counts into the + * node's tag counts and adding new Summary structures if necessary. */ if (nodePtr->level == 0) { @@ -4314,7 +4315,7 @@ RecomputeNodeCounts(treePtr, nodePtr) nodePtr->numChildren++; nodePtr->numLines++; for (ref = 0; ref<treePtr->pixelReferences; ref++) { - nodePtr->numPixels[ref] += linePtr->pixels[2*ref]; + nodePtr->numPixels[ref] += linePtr->pixels[2*ref]; } linePtr->parentPtr = nodePtr; for (segPtr = linePtr->segPtr; segPtr != NULL; @@ -4375,19 +4376,20 @@ RecomputeNodeCounts(treePtr, nodePtr) /* * Scan through the node's tag records again and delete any Summary * records that still have a zero count, or that have all the toggles. - * The node with the children that account for all the tags toggles - * have no summary information, and they become the tagRootPtr for the tag. + * The node with the children that account for all the tags toggles have + * no summary information, and they become the tagRootPtr for the tag. */ summaryPtr2 = NULL; for (summaryPtr = nodePtr->summaryPtr; summaryPtr != NULL; ) { - if (summaryPtr->toggleCount > 0 && + if (summaryPtr->toggleCount > 0 && summaryPtr->toggleCount < summaryPtr->tagPtr->toggleCount) { if (nodePtr->level == summaryPtr->tagPtr->tagRootPtr->level) { /* - * The tag's root node split and some toggles left. - * The tag root must move up a level. + * The tag's root node split and some toggles left. The tag + * root must move up a level. */ + summaryPtr->tagPtr->tagRootPtr = nodePtr->parentPtr; } summaryPtr2 = summaryPtr; @@ -4399,6 +4401,7 @@ RecomputeNodeCounts(treePtr, nodePtr) * A node merge has collected all the toggles under one node. * Push the root down to this level. */ + summaryPtr->tagPtr->tagRootPtr = nodePtr; } if (summaryPtr2 != NULL) { @@ -4418,13 +4421,13 @@ RecomputeNodeCounts(treePtr, nodePtr) * * TkBTreeNumLines -- * - * This procedure returns a count of the number of logical lines of - * text present in a given B-tree. + * This function returns a count of the number of logical lines of text + * present in a given B-tree. * * Results: - * The return value is a count of the number of usable lines - * in tree (i.e. it doesn't include the dummy line that is just - * used to mark the end of the tree). + * The return value is a count of the number of usable lines in tree + * (i.e. it doesn't include the dummy line that is just used to mark the + * end of the tree). * * Side effects: * None. @@ -4434,13 +4437,12 @@ RecomputeNodeCounts(treePtr, nodePtr) int TkBTreeNumLines(tree, textPtr) - TkTextBTree tree; /* Information about tree. */ - CONST TkText *textPtr; /* Relative to this client of the - * B-tree */ + TkTextBTree tree; /* Information about tree. */ + CONST TkText *textPtr; /* Relative to this client of the B-tree */ { BTree *treePtr = (BTree *) tree; int count; - + if (textPtr != NULL && textPtr->end != NULL) { count = TkBTreeLinesTo(NULL, textPtr->end); } else { @@ -4458,15 +4460,15 @@ TkBTreeNumLines(tree, textPtr) * * TkBTreeNumPixels -- * - * This procedure returns a count of the number of pixels of - * text present in a given widget's B-tree representation. + * This function returns a count of the number of pixels of text present + * in a given widget's B-tree representation. * * Results: - * The return value is a count of the number of usable pixels in - * tree (since the dummy line used to mark the end of the B-tree is - * maintained with zero height, as are any lines that are before or - * after the '-start -end' range of the text widget in question, - * the number stored at the root is the number we want). + * The return value is a count of the number of usable pixels in tree + * (since the dummy line used to mark the end of the B-tree is maintained + * with zero height, as are any lines that are before or after the + * '-start -end' range of the text widget in question, the number stored + * at the root is the number we want). * * Side effects: * None. @@ -4476,9 +4478,8 @@ TkBTreeNumLines(tree, textPtr) int TkBTreeNumPixels(tree, textPtr) - TkTextBTree tree; /* The B-tree */ - CONST TkText *textPtr; /* Relative to this client of the - * B-tree */ + TkTextBTree tree; /* The B-tree */ + CONST TkText *textPtr; /* Relative to this client of the B-tree */ { BTree *treePtr = (BTree *) tree; return treePtr->rootPtr->numPixels[textPtr->pixelReference]; @@ -4489,12 +4490,11 @@ TkBTreeNumPixels(tree, textPtr) * * CharSplitProc -- * - * This procedure implements splitting for character segments. + * This function implements splitting for character segments. * * Results: - * The return value is a pointer to a chain of two segments - * that have the same characters as segPtr except split - * among the two segments. + * The return value is a pointer to a chain of two segments that have the + * same characters as segPtr except split among the two segments. * * Side effects: * Storage for segPtr is freed. @@ -4504,9 +4504,9 @@ TkBTreeNumPixels(tree, textPtr) static TkTextSegment * CharSplitProc(segPtr, index) - TkTextSegment *segPtr; /* Pointer to segment to split. */ - int index; /* Position within segment at which - * to split. */ + TkTextSegment *segPtr; /* Pointer to segment to split. */ + int index; /* Position within segment at which to + * split. */ { TkTextSegment *newPtr1, *newPtr2; @@ -4531,12 +4531,12 @@ CharSplitProc(segPtr, index) * * CharCleanupProc -- * - * This procedure merges adjacent character segments into - * a single character segment, if possible. + * This function merges adjacent character segments into a single + * character segment, if possible. * * Results: - * The return value is a pointer to the first segment in - * the (new) list of segments that used to start with segPtr. + * The return value is a pointer to the first segment in the (new) list + * of segments that used to start with segPtr. * * Side effects: * Storage for the segments may be allocated and freed. @@ -4547,10 +4547,9 @@ CharSplitProc(segPtr, index) /* ARGSUSED */ static TkTextSegment * CharCleanupProc(segPtr, linePtr) - TkTextSegment *segPtr; /* Pointer to first of two adjacent - * segments to join. */ - TkTextLine *linePtr; /* Line containing segments (not - * used). */ + TkTextSegment *segPtr; /* Pointer to first of two adjacent segments + * to join. */ + TkTextLine *linePtr; /* Line containing segments (not used). */ { TkTextSegment *segPtr2, *newPtr; @@ -4575,7 +4574,7 @@ CharCleanupProc(segPtr, linePtr) * * CharDeleteProc -- * - * This procedure is invoked to delete a character segment. + * This function is invoked to delete a character segment. * * Results: * Always returns 0 to indicate that the segment was deleted. @@ -4589,11 +4588,11 @@ CharCleanupProc(segPtr, linePtr) /* ARGSUSED */ static int CharDeleteProc(segPtr, linePtr, treeGone) - TkTextSegment *segPtr; /* Segment to delete. */ - TkTextLine *linePtr; /* Line containing segment. */ - int treeGone; /* Non-zero means the entire tree is - * being deleted, so everything must - * get cleaned up. */ + TkTextSegment *segPtr; /* Segment to delete. */ + TkTextLine *linePtr; /* Line containing segment. */ + int treeGone; /* Non-zero means the entire tree is being + * deleted, so everything must get cleaned + * up. */ { ckfree((char*) segPtr); return 0; @@ -4604,15 +4603,14 @@ CharDeleteProc(segPtr, linePtr, treeGone) * * CharCheckProc -- * - * This procedure is invoked to perform consistency checks - * on character segments. + * This function is invoked to perform consistency checks on character + * segments. * * Results: * None. * * Side effects: - * If the segment isn't inconsistent then the procedure - * panics. + * If the segment isn't inconsistent then the function panics. * *-------------------------------------------------------------- */ @@ -4624,11 +4622,10 @@ CharCheckProc(segPtr, linePtr) TkTextLine *linePtr; /* Line containing segment. */ { /* - * Make sure that the segment contains the number of - * characters indicated by its header, and that the last - * segment in a line ends in a newline. Also make sure - * that there aren't ever two character segments adjacent - * to each other: they should be merged together. + * Make sure that the segment contains the number of characters indicated + * by its header, and that the last segment in a line ends in a newline. + * Also make sure that there aren't ever two character segments adjacent + * to each other: they should be merged together. */ if (segPtr->size <= 0) { @@ -4641,10 +4638,8 @@ CharCheckProc(segPtr, linePtr) if (segPtr->body.chars[segPtr->size-1] != '\n') { Tcl_Panic("CharCheckProc: line doesn't end with newline"); } - } else { - if (segPtr->nextPtr->typePtr == &tkTextCharType) { - Tcl_Panic("CharCheckProc: adjacent character segments weren't merged"); - } + } else if (segPtr->nextPtr->typePtr == &tkTextCharType) { + Tcl_Panic("CharCheckProc: adjacent character segments weren't merged"); } } @@ -4653,27 +4648,26 @@ CharCheckProc(segPtr, linePtr) * * ToggleDeleteProc -- * - * This procedure is invoked to delete toggle segments. + * This function is invoked to delete toggle segments. * * Results: - * Returns 1 to indicate that the segment may not be deleted, - * unless the entire B-tree is going away. + * Returns 1 to indicate that the segment may not be deleted, unless the + * entire B-tree is going away. * * Side effects: - * If the tree is going away then the toggle's memory is - * freed; otherwise the toggle counts in nodes above the - * segment get updated. + * If the tree is going away then the toggle's memory is freed; otherwise + * the toggle counts in nodes above the segment get updated. * *-------------------------------------------------------------- */ static int ToggleDeleteProc(segPtr, linePtr, treeGone) - TkTextSegment *segPtr; /* Segment to check. */ - TkTextLine *linePtr; /* Line containing segment. */ - int treeGone; /* Non-zero means the entire tree is - * being deleted, so everything must - * get cleaned up. */ + TkTextSegment *segPtr; /* Segment to check. */ + TkTextLine *linePtr; /* Line containing segment. */ + int treeGone; /* Non-zero means the entire tree is being + * deleted, so everything must get cleaned + * up. */ { if (treeGone) { ckfree((char *) segPtr); @@ -4681,11 +4675,11 @@ ToggleDeleteProc(segPtr, linePtr, treeGone) } /* - * This toggle is in the middle of a range of characters that's - * being deleted. Refuse to die. We'll be moved to the end of - * the deleted range and our cleanup procedure will be called - * later. Decrement node toggle counts here, and set a flag - * so we'll re-increment them in the cleanup procedure. + * This toggle is in the middle of a range of characters that's being + * deleted. Refuse to die. We'll be moved to the end of the deleted range + * and our cleanup function will be called later. Decrement node toggle + * counts here, and set a flag so we'll re-increment them in the cleanup + * function. */ if (segPtr->body.toggle.inNodeCounts) { @@ -4701,20 +4695,19 @@ ToggleDeleteProc(segPtr, linePtr, treeGone) * * ToggleCleanupProc -- * - * This procedure is called when a toggle is part of a line that's - * been modified in some way. It's invoked after the - * modifications are complete. + * This function is called when a toggle is part of a line that's been + * modified in some way. It's invoked after the modifications are + * complete. * * Results: - * The return value is the head segment in a new list - * that is to replace the tail of the line that used to - * start at segPtr. This allows the procedure to delete - * or modify segPtr. + * The return value is the head segment in a new list that is to replace + * the tail of the line that used to start at segPtr. This allows the + * function to delete or modify segPtr. * * Side effects: - * Toggle counts in the nodes above the new line will be - * updated if they're not already. Toggles may be collapsed - * if there are duplicate toggles at the same position. + * Toggle counts in the nodes above the new line will be updated if + * they're not already. Toggles may be collapsed if there are duplicate + * toggles at the same position. * *-------------------------------------------------------------- */ @@ -4728,10 +4721,10 @@ ToggleCleanupProc(segPtr, linePtr) int counts; /* - * If this is a toggle-off segment, look ahead through the next - * segments to see if there's a toggle-on segment for the same tag - * before any segments with non-zero size. If so then the two - * toggles cancel each other; remove them both. + * If this is a toggle-off segment, look ahead through the next segments + * to see if there's a toggle-on segment for the same tag before any + * segments with non-zero size. If so then the two toggles cancel each + * other; remove them both. */ if (segPtr->typePtr == &tkTextToggleOffType) { @@ -4771,8 +4764,8 @@ ToggleCleanupProc(segPtr, linePtr) * * ToggleLineChangeProc -- * - * This procedure is invoked when a toggle segment is about - * to move from one line to another. + * This function is invoked when a toggle segment is about to move from + * one line to another. * * Results: * None. @@ -4800,22 +4793,22 @@ ToggleLineChangeProc(segPtr, linePtr) * * ToggleCheckProc -- * - * This procedure is invoked to perform consistency checks - * on toggle segments. + * This function is invoked to perform consistency checks on toggle + * segments. * * Results: * None. * * Side effects: - * If a consistency problem is found the procedure panics. + * If a consistency problem is found the function panics. * *-------------------------------------------------------------- */ static void ToggleCheckProc(segPtr, linePtr) - TkTextSegment *segPtr; /* Segment to check. */ - TkTextLine *linePtr; /* Line containing segment. */ + TkTextSegment *segPtr; /* Segment to check. */ + TkTextLine *linePtr; /* Line containing segment. */ { register Summary *summaryPtr; int needSummary; @@ -4844,3 +4837,11 @@ ToggleCheckProc(segPtr, linePtr) } } } + +/* + * Local Variables: + * mode: c + * c-basic-offset: 4 + * fill-column: 78 + * End: + */ |