Getting more systematic about style

Also start removing _ANSI_ARGS_; the core's required ANSI C for a while now
Also fix [Bug 1252702]; size_t doesn't mix with Tcl_GetStringFromObj

1 files changed, 635 insertions, 571 deletions

diff --git a/generic/tkTextIndex.c b/generic/tkTextIndex.c
index e9469ee..127b397 100644
--- a/generic/tkTextIndex.c
+++ b/generic/tkTextIndex.c
@@ -1,16 +1,16 @@
-/* 
+/*
  * tkTextIndex.c --
  *
- *	This module provides procedures that manipulate indices for
- *	text widgets.
+ *	This module provides functions that manipulate indices for text
+ *	widgets.
  *
  * Copyright (c) 1992-1994 The Regents of the University of California.
  * Copyright (c) 1994-1997 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: tkTextIndex.c,v 1.21 2005/02/14 23:00:46 vincentdarley Exp $
+ * RCS: @(#) $Id: tkTextIndex.c,v 1.22 2005/08/10 22:02:22 dkf Exp $
  */
 
 #include "default.h"
@@ -27,62 +27,72 @@
 /*
  * Modifiers for index parsing: 'display', 'any' or nothing.
  */
-#define TKINDEX_NONE 0
-#define TKINDEX_DISPLAY 1
-#define TKINDEX_ANY 2
+
+#define TKINDEX_NONE	0
+#define TKINDEX_DISPLAY	1
+#define TKINDEX_ANY	2
 
 /*
- * Forward declarations for procedures defined later in this file:
+ * Forward declarations for functions defined later in this file:
  */
 
-static CONST char *	ForwBack _ANSI_ARGS_((TkText *textPtr, 
-			    CONST char *string, TkTextIndex *indexPtr));
-static CONST char *	StartEnd _ANSI_ARGS_((TkText *textPtr, 
-			    CONST char *string, TkTextIndex *indexPtr));
-static int		GetIndex _ANSI_ARGS_((Tcl_Interp *interp,
-			    TkSharedText *sharedPtr, TkText *textPtr, 
-			    CONST char *string,
-			    TkTextIndex *indexPtr, int *canCachePtr));
+static CONST char *	ForwBack(TkText *textPtr, CONST char *string,
+			    TkTextIndex *indexPtr);
+static CONST char *	StartEnd(TkText *textPtr, CONST char *string,
+			    TkTextIndex *indexPtr);
+static int		GetIndex(Tcl_Interp *interp, TkSharedText *sharedPtr,
+			    TkText *textPtr, CONST char *string,
+			    TkTextIndex *indexPtr, int *canCachePtr);
 
 /*
  * The "textindex" Tcl_Obj definition:
  */
 
-static void		DupTextIndexInternalRep _ANSI_ARGS_((Tcl_Obj *srcPtr,
-			    Tcl_Obj *copyPtr));
-static void		FreeTextIndexInternalRep _ANSI_ARGS_((Tcl_Obj *listPtr));
-static int		SetTextIndexFromAny _ANSI_ARGS_((Tcl_Interp *interp,
-			    Tcl_Obj *objPtr));
-static void		UpdateStringOfTextIndex _ANSI_ARGS_((Tcl_Obj *objPtr));
+static void		DupTextIndexInternalRep(Tcl_Obj *srcPtr,
+			    Tcl_Obj *copyPtr);
+static void		FreeTextIndexInternalRep(Tcl_Obj *listPtr);
+static int		SetTextIndexFromAny(Tcl_Interp *interp,
+			    Tcl_Obj *objPtr);
+static void		UpdateStringOfTextIndex(Tcl_Obj *objPtr);
+
+/*
+ * Accessor macros for the "textindex" type.
+ */
 
 #define GET_TEXTINDEX(objPtr) \
-		((TkTextIndex *) (objPtr)->internalRep.twoPtrValue.ptr1)
+	((TkTextIndex *) (objPtr)->internalRep.twoPtrValue.ptr1)
 #define GET_INDEXEPOCH(objPtr) \
-		((int) (objPtr)->internalRep.twoPtrValue.ptr2)
+	((int) (objPtr)->internalRep.twoPtrValue.ptr2)
 #define SET_TEXTINDEX(objPtr, indexPtr) \
-		(objPtr)->internalRep.twoPtrValue.ptr1 = (VOID*) (indexPtr)
+	((objPtr)->internalRep.twoPtrValue.ptr1 = (VOID *) (indexPtr))
 #define SET_INDEXEPOCH(objPtr, epoch) \
-		(objPtr)->internalRep.twoPtrValue.ptr2 = (VOID*) (epoch)
+	((objPtr)->internalRep.twoPtrValue.ptr2 = (VOID *) (epoch))
+
 /*
- * Define the 'textindex' object type, which Tk uses to represent
- * indices in text widgets internally.
+ * Define the 'textindex' object type, which Tk uses to represent indices in
+ * text widgets internally.
  */
+
 Tcl_ObjType tkTextIndexType = {
-    "textindex",			/* name */
-    FreeTextIndexInternalRep,		/* freeIntRepProc */
-    DupTextIndexInternalRep,	        /* dupIntRepProc */
-    NULL,                               /* updateStringProc */
-    SetTextIndexFromAny		        /* setFromAnyProc */
+    "textindex",		/* name */
+    FreeTextIndexInternalRep,	/* freeIntRepProc */
+    DupTextIndexInternalRep,	/* dupIntRepProc */
+    NULL,			/* updateStringProc */
+    SetTextIndexFromAny		/* setFromAnyProc */
 };
-
+
 static void
 FreeTextIndexInternalRep(indexObjPtr)
-    Tcl_Obj *indexObjPtr;   /* TextIndex object with internal rep to free. */
+    Tcl_Obj *indexObjPtr;	/* TextIndex object with internal rep to
+				 * free. */
 {
     TkTextIndex *indexPtr = GET_TEXTINDEX(indexObjPtr);
     if (indexPtr->textPtr != NULL) {
-        if (--indexPtr->textPtr->refCount == 0) {
-	    /* The text widget has been deleted and we need to free it now */
+	if (--indexPtr->textPtr->refCount == 0) {
+	    /*
+	     * The text widget has been deleted and we need to free it now.
+	     */
+
 	    ckfree((char *) (indexPtr->textPtr));
 	}
     }
@@ -99,19 +109,21 @@ DupTextIndexInternalRep(srcPtr, copyPtr)
     dupIndexPtr = (TkTextIndex*) ckalloc(sizeof(TkTextIndex));
     indexPtr = GET_TEXTINDEX(srcPtr);
     epoch = GET_INDEXEPOCH(srcPtr);
-    
+
     dupIndexPtr->tree = indexPtr->tree;
     dupIndexPtr->linePtr = indexPtr->linePtr;
     dupIndexPtr->byteIndex = indexPtr->byteIndex;
-    
+
     SET_TEXTINDEX(copyPtr, dupIndexPtr);
     SET_INDEXEPOCH(copyPtr, epoch);
 }
-/* 
- * This will not be called except by TkTextNewIndexObj below.
- * This is because if a TkTextIndex is no longer valid, it is
- * not possible to regenerate the string representation.
+
+/*
+ * This will not be called except by TkTextNewIndexObj below. This is because
+ * if a TkTextIndex is no longer valid, it is not possible to regenerate the
+ * string representation.
  */
+
 static void
 UpdateStringOfTextIndex(objPtr)
     Tcl_Obj *objPtr;
@@ -127,14 +139,15 @@ UpdateStringOfTextIndex(objPtr)
     strcpy(objPtr->bytes, buffer);
     objPtr->length = len;
 }
+
 static int
 SetTextIndexFromAny(interp, objPtr)
     Tcl_Interp *interp;		/* Used for error reporting if not NULL. */
     Tcl_Obj *objPtr;		/* The object to convert. */
 {
     Tcl_AppendToObj(Tcl_GetObjResult(interp),
-	"can't convert value to textindex except via TkTextGetIndexFromObj API",
-	-1);
+	    "can't convert value to textindex except via TkTextGetIndexFromObj API",
+	    -1);
     return TCL_ERROR;
 }
 
@@ -142,19 +155,19 @@ SetTextIndexFromAny(interp, objPtr)
  *---------------------------------------------------------------------------
  *
  * MakeObjIndex --
- *	
- *	This procedure generates a Tcl_Obj description of an index,
- *	suitable for reading in again later.  If the 'textPtr' is NULL
- *	then we still generate an index object, but it's internal
- *	description is deemed non-cacheable, and therefore effectively
- *	useless (apart from as a temporary memory storage).  This is used
- *	for indices whose meaning is very temporary (like @0,0 or the
- *	name of a mark or tag).  The mapping from such strings/objects to
- *	actual TkTextIndex pointers is not stable to minor text widget
- *	changes which we do not track (we track insertions/deletions).
+ *
+ *	This function generates a Tcl_Obj description of an index, suitable
+ *	for reading in again later. If the 'textPtr' is NULL then we still
+ *	generate an index object, but it's internal description is deemed
+ *	non-cacheable, and therefore effectively useless (apart from as a
+ *	temporary memory storage). This is used for indices whose meaning is
+ *	very temporary (like @0,0 or the name of a mark or tag). The mapping
+ *	from such strings/objects to actual TkTextIndex pointers is not stable
+ *	to minor text widget changes which we do not track (we track
+ *	insertions/deletions).
  *
  * Results:
- *	A pointer to an allocated TkTextIndex which will be freed 
+ *	A pointer to an allocated TkTextIndex which will be freed
  *	automatically when the Tcl_Obj is used for other purposes.
  *
  * Side effects:
@@ -162,13 +175,15 @@ SetTextIndexFromAny(interp, objPtr)
  *
  *---------------------------------------------------------------------------
  */
-static TkTextIndex*
-MakeObjIndex(textPtr, objPtr, origPtr) 
+
+static TkTextIndex *
+MakeObjIndex(textPtr, objPtr, origPtr)
     TkText *textPtr;		/* Information about text widget. */
-    Tcl_Obj *objPtr;		/* Object containing description of position. */
-    CONST TkTextIndex *origPtr; /* Pointer to index. */
+    Tcl_Obj *objPtr;		/* Object containing description of
+				 * position. */
+    CONST TkTextIndex *origPtr;	/* Pointer to index. */
 {
-    TkTextIndex *indexPtr = (TkTextIndex*) ckalloc(sizeof(TkTextIndex));
+    TkTextIndex *indexPtr = (TkTextIndex *) ckalloc(sizeof(TkTextIndex));
 
     indexPtr->tree = origPtr->tree;
     indexPtr->linePtr = origPtr->linePtr;
@@ -190,18 +205,19 @@ CONST TkTextIndex*
 TkTextGetIndexFromObj(interp, textPtr, objPtr)
     Tcl_Interp *interp;		/* Use this for error reporting. */
     TkText *textPtr;		/* Information about text widget. */
-    Tcl_Obj *objPtr;		/* Object containing description of position. */
+    Tcl_Obj *objPtr;		/* Object containing description of
+				 * position. */
 {
     TkTextIndex index;
     TkTextIndex *indexPtr = NULL;
     int cache;
-    
+
     if (objPtr->typePtr == &tkTextIndexType) {
 	int epoch;
-	
+
 	indexPtr = GET_TEXTINDEX(objPtr);
 	epoch = GET_INDEXEPOCH(objPtr);
-	
+
 	if (epoch == textPtr->sharedTextPtr->stateEpoch) {
 	    if (indexPtr->textPtr == textPtr) {
 		return indexPtr;
@@ -209,17 +225,17 @@ TkTextGetIndexFromObj(interp, textPtr, objPtr)
 	}
     }
 
-    /* 
-     * The object is either not an index type or referred to a different
-     * text widget, or referred to the correct widget, but it is out of
-     * date (text has been added/deleted since).
+    /*
+     * The object is either not an index type or referred to a different text
+     * widget, or referred to the correct widget, but it is out of date (text
+     * has been added/deleted since).
      */
-    
-    if (GetIndex(interp, NULL, textPtr, Tcl_GetString(objPtr), 
-		 &index, &cache) != TCL_OK) {
+
+    if (GetIndex(interp, NULL, textPtr, Tcl_GetString(objPtr), &index,
+	    &cache) != TCL_OK) {
 	return NULL;
     }
-    
+
     if (objPtr->typePtr != NULL) {
 	if (objPtr->bytes == NULL) {
 	    objPtr->typePtr->updateStringProc(objPtr);
@@ -228,7 +244,7 @@ TkTextGetIndexFromObj(interp, textPtr, objPtr)
 	    (*objPtr->typePtr->freeIntRepProc)(objPtr);
 	}
     }
-    
+
     if (cache) {
 	return MakeObjIndex(textPtr, objPtr, &index);
     } else {
@@ -240,11 +256,10 @@ TkTextGetIndexFromObj(interp, textPtr, objPtr)
  *---------------------------------------------------------------------------
  *
  * TkTextNewIndexObj --
- *	
- *	This procedure generates a Tcl_Obj description of an index,
- *	suitable for reading in again later.  The index generated is
- *	effectively stable to all except insertion/deletion operations on
- *	the widget.
+ *
+ *	This function generates a Tcl_Obj description of an index, suitable
+ *	for reading in again later. The index generated is effectively stable
+ *	to all except insertion/deletion operations on the widget.
  *
  * Results:
  *	A new Tcl_Obj with refCount zero.
@@ -257,25 +272,27 @@ TkTextGetIndexFromObj(interp, textPtr, objPtr)
 
 Tcl_Obj*
 TkTextNewIndexObj(textPtr, indexPtr)
-    TkText *textPtr;             /* text widget for this index */
-    CONST TkTextIndex *indexPtr; /* Pointer to index. */
+    TkText *textPtr;		/* Text widget for this index */
+    CONST TkTextIndex *indexPtr;/* Pointer to index. */
 {
     Tcl_Obj *retVal;
 
     retVal = Tcl_NewObj();
     retVal->bytes = NULL;
 
-    /* 
-     * Assumption that the above call returns an object with
+    /*
+     * Assumption that the above call returns an object with:
      * retVal->typePtr == NULL
      */
+
     MakeObjIndex(textPtr, retVal, indexPtr);
-    
-    /* 
-     * Unfortunately, it isn't possible for us to regenerate the
-     * string representation so we have to create it here, while we
-     * can be sure the contents of the index are still valid.
+
+    /*
+     * Unfortunately, it isn't possible for us to regenerate the string
+     * representation so we have to create it here, while we can be sure the
+     * contents of the index are still valid.
      */
+
     UpdateStringOfTextIndex(retVal);
     return retVal;
 }
@@ -285,23 +302,22 @@ TkTextNewIndexObj(textPtr, indexPtr)
  *
  * TkTextMakePixelIndex --
  *
- *	Given a pixel index and a byte index, look things up in the B-tree
- *	and fill in a TkTextIndex structure.
- *	
- *	The valid input range for pixelIndex is from 0 to the number
- *	of pixels in the widget-1.  Anything outside that range will
- *	be rounded to the closest acceptable value. 
+ *	Given a pixel index and a byte index, look things up in the B-tree and
+ *	fill in a TkTextIndex structure.
+ *
+ *	The valid input range for pixelIndex is from 0 to the number of pixels
+ *	in the widget-1. Anything outside that range will be rounded to the
+ *	closest acceptable value.
  *
  * Results:
- * 
- *	The structure at *indexPtr is filled in with information about
- *	the character at pixelIndex (or the closest existing character,
- *	if the specified one doesn't exist), and the number of excess
- *	pixels is returned as a result.  This means if the given pixel
- *	index is exactly correct for the top-edge of the indexPtr, then
- *	zero will be returned, and otherwise we will return the
- *	calculation 'desired pixelIndex' - 'actual pixel index of
- *	indexPtr'.
+ *
+ *	The structure at *indexPtr is filled in with information about the
+ *	character at pixelIndex (or the closest existing character, if the
+ *	specified one doesn't exist), and the number of excess pixels is
+ *	returned as a result. This means if the given pixel index is exactly
+ *	correct for the top-edge of the indexPtr, then zero will be returned,
+ *	and otherwise we will return the calculation 'desired pixelIndex' -
+ *	'actual pixel index of indexPtr'.
  *
  * Side effects:
  *	None.
@@ -312,7 +328,7 @@ TkTextNewIndexObj(textPtr, indexPtr)
 int
 TkTextMakePixelIndex(textPtr, pixelIndex, indexPtr)
     TkText* textPtr;		/* The Text Widget */
-    int pixelIndex;		/* pixel-index of desired line (0 means first
+    int pixelIndex;		/* Pixel-index of desired line (0 means first
 				 * pixel of first line of text). */
     TkTextIndex *indexPtr;	/* Structure to fill in. */
 {
@@ -320,24 +336,24 @@ TkTextMakePixelIndex(textPtr, pixelIndex, indexPtr)
 
     indexPtr->tree = textPtr->sharedTextPtr->tree;
     indexPtr->textPtr = textPtr;
-    
+
     if (pixelIndex < 0) {
 	pixelIndex = 0;
     }
-    indexPtr->linePtr = TkBTreeFindPixelLine(textPtr->sharedTextPtr->tree, 
-					     textPtr,
-					     pixelIndex, 
-					     &pixelOffset);
-    /* 
-     * 'pixedlIndex' was too large, so we try again, just to find
-     * the last pixel in the window
+    indexPtr->linePtr = TkBTreeFindPixelLine(textPtr->sharedTextPtr->tree,
+	    textPtr, pixelIndex, &pixelOffset);
+
+    /*
+     * 'pixelIndex' was too large, so we try again, just to find the last
+     * pixel in the window
      */
+
     if (indexPtr->linePtr == NULL) {
 	int lastMinusOne = TkBTreeNumPixels(textPtr->sharedTextPtr->tree,
-					    textPtr)-1;
-	indexPtr->linePtr = TkBTreeFindPixelLine(textPtr->sharedTextPtr->tree, 
-						 textPtr, 
-						 lastMinusOne, &pixelOffset);
+		textPtr)-1;
+
+	indexPtr->linePtr = TkBTreeFindPixelLine(textPtr->sharedTextPtr->tree,
+		textPtr, lastMinusOne, &pixelOffset);
 	indexPtr->byteIndex = 0;
 	return pixelOffset;
     }
@@ -354,8 +370,8 @@ TkTextMakePixelIndex(textPtr, pixelIndex, indexPtr)
  *
  * TkTextMakeByteIndex --
  *
- *	Given a line index and a byte index, look things up in the B-tree
- *	and fill in a TkTextIndex structure.
+ *	Given a line index and a byte index, look things up in the B-tree and
+ *	fill in a TkTextIndex structure.
  *
  * Results:
  *	The structure at *indexPtr is filled in with information about the
@@ -374,8 +390,8 @@ TkTextMakeByteIndex(tree, textPtr, lineIndex, byteIndex, indexPtr)
     TkTextBTree tree;		/* Tree that lineIndex and byteIndex refer
 				 * to. */
     CONST TkText *textPtr;
-    int lineIndex;		/* Index of desired line (0 means first
-				 * line of text). */
+    int lineIndex;		/* Index of desired line (0 means first line
+				 * of text). */
     int byteIndex;		/* Byte index of desired character. */
     TkTextIndex *indexPtr;	/* Structure to fill in. */
 {
@@ -394,8 +410,8 @@ TkTextMakeByteIndex(tree, textPtr, lineIndex, byteIndex, indexPtr)
     }
     indexPtr->linePtr = TkBTreeFindLine(tree, textPtr, lineIndex);
     if (indexPtr->linePtr == NULL) {
-	indexPtr->linePtr = TkBTreeFindLine(tree, textPtr, 
-					    TkBTreeNumLines(tree, textPtr));
+	indexPtr->linePtr = TkBTreeFindLine(tree, textPtr,
+		TkBTreeNumLines(tree, textPtr));
 	byteIndex = 0;
     }
     if (byteIndex == 0) {
@@ -404,19 +420,19 @@ TkTextMakeByteIndex(tree, textPtr, lineIndex, byteIndex, indexPtr)
     }
 
     /*
-     * Verify that the index is within the range of the line and points
-     * to a valid character boundary.  
+     * Verify that the index is within the range of the line and points to a
+     * valid character boundary.
      */
 
     index = 0;
     for (segPtr = indexPtr->linePtr->segPtr; ; segPtr = segPtr->nextPtr) {
 	if (segPtr == NULL) {
 	    /*
-	     * Use the index of the last character in the line.  Since
-	     * the last character on the line is guaranteed to be a '\n',
-	     * we can back up a constant sizeof(char) bytes.
+	     * Use the index of the last character in the line. Since the last
+	     * character on the line is guaranteed to be a '\n', we can back
+	     * up a constant sizeof(char) bytes.
 	     */
-	     
+
 	    indexPtr->byteIndex = index - sizeof(char);
 	    break;
 	}
@@ -425,7 +441,7 @@ TkTextMakeByteIndex(tree, textPtr, lineIndex, byteIndex, indexPtr)
 	    if ((byteIndex > index) && (segPtr->typePtr == &tkTextCharType)) {
 		/*
 		 * Prevent UTF-8 character from being split up by ensuring
-		 * that byteIndex falls on a character boundary.  If index
+		 * that byteIndex falls on a character boundary. If index
 		 * falls in the middle of a UTF-8 character, it will be
 		 * adjusted to the end of that UTF-8 character.
 		 */
@@ -447,8 +463,8 @@ TkTextMakeByteIndex(tree, textPtr, lineIndex, byteIndex, indexPtr)
  *
  * TkTextMakeCharIndex --
  *
- *	Given a line index and a character index, look things up in the
- *	B-tree and fill in a TkTextIndex structure.
+ *	Given a line index and a character index, look things up in the B-tree
+ *	and fill in a TkTextIndex structure.
  *
  * Results:
  *	The structure at *indexPtr is filled in with information about the
@@ -467,8 +483,8 @@ TkTextMakeCharIndex(tree, textPtr, lineIndex, charIndex, indexPtr)
     TkTextBTree tree;		/* Tree that lineIndex and charIndex refer
 				 * to. */
     TkText *textPtr;
-    int lineIndex;		/* Index of desired line (0 means first
-				 * line of text). */
+    int lineIndex;		/* Index of desired line (0 means first line
+				 * of text). */
     int charIndex;		/* Index of desired character. */
     TkTextIndex *indexPtr;	/* Structure to fill in. */
 {
@@ -487,25 +503,25 @@ TkTextMakeCharIndex(tree, textPtr, lineIndex, charIndex, indexPtr)
     }
     indexPtr->linePtr = TkBTreeFindLine(tree, textPtr, lineIndex);
     if (indexPtr->linePtr == NULL) {
-	indexPtr->linePtr = TkBTreeFindLine(tree, textPtr, 
-					    TkBTreeNumLines(tree, textPtr));
+	indexPtr->linePtr = TkBTreeFindLine(tree, textPtr,
+		TkBTreeNumLines(tree, textPtr));
 	charIndex = 0;
     }
 
     /*
-     * Verify that the index is within the range of the line.
-     * If not, just use the index of the last character in the line.
+     * Verify that the index is within the range of the line. If not, just use
+     * the index of the last character in the line.
      */
 
     index = 0;
     for (segPtr = indexPtr->linePtr->segPtr; ; segPtr = segPtr->nextPtr) {
 	if (segPtr == NULL) {
 	    /*
-	     * Use the index of the last character in the line.  Since
-	     * the last character on the line is guaranteed to be a '\n',
-	     * we can back up a constant sizeof(char) bytes.
+	     * Use the index of the last character in the line. Since the last
+	     * character on the line is guaranteed to be a '\n', we can back
+	     * up a constant sizeof(char) bytes.
 	     */
-	     
+
 	    indexPtr->byteIndex = index - sizeof(char);
 	    break;
 	}
@@ -542,14 +558,14 @@ TkTextMakeCharIndex(tree, textPtr, lineIndex, charIndex, indexPtr)
  *
  * TkTextIndexToSeg --
  *
- *	Given an index, this procedure returns the segment and offset
- *	within segment for the index.
+ *	Given an index, this function returns the segment and offset within
+ *	segment for the index.
  *
  * Results:
- *	The return value is a pointer to the segment referred to by
- *	indexPtr; this will always be a segment with non-zero size.  The
- *	variable at *offsetPtr is set to hold the integer offset within
- *	the segment of the character given by indexPtr.
+ *	The return value is a pointer to the segment referred to by indexPtr;
+ *	this will always be a segment with non-zero size. The variable at
+ *	*offsetPtr is set to hold the integer offset within the segment of the
+ *	character given by indexPtr.
  *
  * Side effects:
  *	None.
@@ -582,7 +598,7 @@ TkTextIndexToSeg(indexPtr, offsetPtr)
  *
  * TkTextSegToOffset --
  *
- *	Given a segment pointer and the line containing it, this procedure
+ *	Given a segment pointer and the line containing it, this function
  *	returns the offset of the segment within its line.
  *
  * Results:
@@ -615,16 +631,16 @@ TkTextSegToOffset(segPtr, linePtr)
  *---------------------------------------------------------------------------
  *
  * TkTextGetObjIndex --
- * 
- *    Simpler wrapper around the string based function, but could be
- *    enhanced with a new object type in the future.
+ *
+ *	Simpler wrapper around the string based function, but could be
+ *	enhanced with a new object type in the future.
  *
  * Results:
- *    see TkTextGetIndex
+ *	see TkTextGetIndex
  *
  * Side effects:
- *    None.
- *    
+ *	None.
+ *
  *---------------------------------------------------------------------------
  */
 
@@ -632,27 +648,28 @@ int
 TkTextGetObjIndex(interp, textPtr, idxObj, indexPtr)
     Tcl_Interp *interp;		/* Use this for error reporting. */
     TkText *textPtr;		/* Information about text widget. */
-    Tcl_Obj *idxObj;	        /* Object containing textual description 
-				 * of position. */
+    Tcl_Obj *idxObj;		/* Object containing textual description of
+				 * position. */
     TkTextIndex *indexPtr;	/* Index structure to fill in. */
 {
-    return GetIndex(interp, NULL, textPtr, Tcl_GetString(idxObj), indexPtr, NULL);
+    return GetIndex(interp, NULL, textPtr, Tcl_GetString(idxObj), indexPtr,
+	    NULL);
 }
 
 /*
  *---------------------------------------------------------------------------
  *
  * TkTextSharedGetObjIndex --
- * 
- *    Simpler wrapper around the string based function, but could be
- *    enhanced with a new object type in the future.
+ *
+ *	Simpler wrapper around the string based function, but could be
+ *	enhanced with a new object type in the future.
  *
  * Results:
- *    see TkTextGetIndex
+ *	see TkTextGetIndex
  *
  * Side effects:
- *    None.
- *    
+ *	None.
+ *
  *---------------------------------------------------------------------------
  */
 
@@ -660,12 +677,12 @@ int
 TkTextSharedGetObjIndex(interp, sharedTextPtr, idxObj, indexPtr)
     Tcl_Interp *interp;		/* Use this for error reporting. */
     TkSharedText *sharedTextPtr;/* Information about text widget. */
-    Tcl_Obj *idxObj;	        /* Object containing textual description 
-				 * of position. */
+    Tcl_Obj *idxObj;		/* Object containing textual description of
+				 * position. */
     TkTextIndex *indexPtr;	/* Index structure to fill in. */
 {
-    return GetIndex(interp, sharedTextPtr, NULL, 
-		    Tcl_GetString(idxObj), indexPtr, NULL);
+    return GetIndex(interp, sharedTextPtr, NULL, Tcl_GetString(idxObj),
+	    indexPtr, NULL);
 }
 
 /*
@@ -676,10 +693,10 @@ TkTextSharedGetObjIndex(interp, sharedTextPtr, idxObj, indexPtr)
  *	Given a string, return the index that is described.
  *
  * Results:
- *	The return value is a standard Tcl return result.  If TCL_OK is
+ *	The return value is a standard Tcl return result. If TCL_OK is
  *	returned, then everything went well and the index at *indexPtr is
- *	filled in; otherwise TCL_ERROR is returned and an error message
- *	is left in the interp's result.
+ *	filled in; otherwise TCL_ERROR is returned and an error message is
+ *	left in the interp's result.
  *
  * Side effects:
  *	None.
@@ -705,14 +722,14 @@ TkTextGetIndex(interp, textPtr, string, indexPtr)
  *	Given a string, return the index that is described.
  *
  * Results:
- *	The return value is a standard Tcl return result.  If TCL_OK is
+ *	The return value is a standard Tcl return result. If TCL_OK is
  *	returned, then everything went well and the index at *indexPtr is
- *	filled in; otherwise TCL_ERROR is returned and an error message
- *	is left in the interp's result.
- *	
- *	If *canCachePtr is non-NULL, and everything went well, the
- *	integer it points to is set to 1 if the indexPtr is something
- *	which can be cached, and zero otherwise.
+ *	filled in; otherwise TCL_ERROR is returned and an error message is
+ *	left in the interp's result.
+ *
+ *	If *canCachePtr is non-NULL, and everything went well, the integer it
+ *	points to is set to 1 if the indexPtr is something which can be
+ *	cached, and zero otherwise.
  *
  * Side effects:
  *	None.
@@ -727,8 +744,8 @@ GetIndex(interp, sharedPtr, textPtr, string, indexPtr, canCachePtr)
     TkText *textPtr;		/* Information about text widget. */
     CONST char *string;		/* Textual description of position. */
     TkTextIndex *indexPtr;	/* Index structure to fill in. */
-    int *canCachePtr;           /* Pointer to integer to store whether
-                                 * we can cache the index (or NULL) */
+    int *canCachePtr;		/* Pointer to integer to store whether we can
+				 * cache the index (or NULL). */
 {
     char *p, *end, *endOfBase;
     TkTextIndex first, last;
@@ -737,17 +754,16 @@ GetIndex(interp, sharedPtr, textPtr, string, indexPtr, canCachePtr)
     CONST char *cp;
     Tcl_DString copy;
     int canCache = 0;
-    
+
     if (sharedPtr == NULL) {
 	sharedPtr = textPtr->sharedTextPtr;
     }
-    
+
     /*
      *---------------------------------------------------------------------
-     * Stage 1: check to see if the index consists of nothing but a mark
-     * name.  We do this check now even though it's also done later, in
-     * order to allow mark names that include funny characters such as
-     * spaces or "+1c".
+     * Stage 1: check to see if the index consists of nothing but a mark name.
+     * We do this check now even though it's also done later, in order to
+     * allow mark names that include funny characters such as spaces or "+1c".
      *---------------------------------------------------------------------
      */
 
@@ -764,11 +780,11 @@ GetIndex(interp, sharedPtr, textPtr, string, indexPtr, canCachePtr)
     indexPtr->tree = sharedPtr->tree;
 
     /*
-     * First look for the form "tag.first" or "tag.last" where "tag"
-     * is the name of a valid tag.  Try to use up as much as possible
-     * of the string in this check (strrchr instead of strchr below).
-     * Doing the check now, and in this way, allows tag names to include
-     * funny characters like "@" or "+1c".
+     * First look for the form "tag.first" or "tag.last" where "tag" is the
+     * name of a valid tag. Try to use up as much as possible of the string in
+     * this check (strrchr instead of strchr below). Doing the check now, and
+     * in this way, allows tag names to include funny characters like "@" or
+     * "+1c".
      */
 
     Tcl_DStringInit(&copy);
@@ -778,7 +794,7 @@ GetIndex(interp, sharedPtr, textPtr, string, indexPtr, canCachePtr)
 	TkTextTag *tagPtr;
 	Tcl_HashEntry *hPtr = NULL;
 	CONST char *tagName;
-	
+
 	if ((p[1] == 'f') && (strncmp(p+1, "first", 5) == 0)) {
 	    wantLast = 0;
 	    endOfBase = p+6;
@@ -788,13 +804,14 @@ GetIndex(interp, sharedPtr, textPtr, string, indexPtr, canCachePtr)
 	} else {
 	    goto tryxy;
 	}
+
 	tagPtr = NULL;
 	tagName = Tcl_DStringValue(&copy);
 	if (((p - tagName) == 3) && !strncmp(tagName, "sel", 3)) {
-	    /* 
-	     * Special case for sel tag which is not stored in
-	     * the hash table.
+	    /*
+	     * Special case for sel tag which is not stored in the hash table.
 	     */
+
 	    tagPtr = textPtr->selTagPtr;
 	} else {
 	    *p = 0;
@@ -804,17 +821,18 @@ GetIndex(interp, sharedPtr, textPtr, string, indexPtr, canCachePtr)
 		tagPtr = (TkTextTag *) Tcl_GetHashValue(hPtr);
 	    }
 	}
+
 	if (tagPtr == NULL) {
 	    goto tryxy;
 	}
+
 	TkTextMakeByteIndex(sharedPtr->tree, textPtr, 0, 0, &first);
-	TkTextMakeByteIndex(sharedPtr->tree, textPtr, 
-		    TkBTreeNumLines(sharedPtr->tree, textPtr), 
-		    0, &last);
+	TkTextMakeByteIndex(sharedPtr->tree, textPtr,
+		TkBTreeNumLines(sharedPtr->tree, textPtr), 0, &last);
 	TkBTreeStartSearch(&first, &last, tagPtr, &search);
 	if (!TkBTreeCharTagged(&first, tagPtr) && !TkBTreeNextTag(&search)) {
 	    if (tagPtr == textPtr->selTagPtr) {
-	        tagName = "sel";
+		tagName = "sel";
 	    } else {
 		tagName = Tcl_GetHashKey(&sharedPtr->tagTable, hPtr);
 	    }
@@ -834,7 +852,7 @@ GetIndex(interp, sharedPtr, textPtr, string, indexPtr, canCachePtr)
 	goto gotBase;
     }
 
-    tryxy:
+  tryxy:
     if (string[0] == '@') {
 	/*
 	 * Find character at a given x,y location in the window.
@@ -854,7 +872,7 @@ GetIndex(interp, sharedPtr, textPtr, string, indexPtr, canCachePtr)
 	}
 	TkTextPixelIndex(textPtr, x, y, indexPtr, NULL);
 	endOfBase = end;
-	goto gotBase; 
+	goto gotBase;
     }
 
     if (isdigit(UCHAR(string[0])) || (string[0] == '-')) {
@@ -879,8 +897,8 @@ GetIndex(interp, sharedPtr, textPtr, string, indexPtr, canCachePtr)
 	    }
 	    endOfBase = end;
 	}
-	TkTextMakeCharIndex(sharedPtr->tree, textPtr, lineIndex, 
-			    charIndex, indexPtr);
+	TkTextMakeCharIndex(sharedPtr->tree, textPtr, lineIndex, charIndex,
+		indexPtr);
 	canCache = 1;
 	goto gotBase;
     }
@@ -912,8 +930,7 @@ GetIndex(interp, sharedPtr, textPtr, string, indexPtr, canCachePtr)
 	 */
 
 	TkTextMakeByteIndex(sharedPtr->tree, textPtr,
-		    TkBTreeNumLines(sharedPtr->tree, textPtr),
-		    0, indexPtr);
+		TkBTreeNumLines(sharedPtr->tree, textPtr), 0, indexPtr);
 	canCache = 1;
 	goto gotBase;
     } else {
@@ -946,14 +963,14 @@ GetIndex(interp, sharedPtr, textPtr, string, indexPtr, canCachePtr)
 
     /*
      *-------------------------------------------------------------------
-     * Stage 3: process zero or more modifiers.  Each modifier is either
-     * a keyword like "wordend" or "linestart", or it has the form
-     * "op count units" where op is + or -, count is a number, and units
-     * is "chars" or "lines".
+     * Stage 3: process zero or more modifiers. Each modifier is either a
+     * keyword like "wordend" or "linestart", or it has the form "op count
+     * units" where op is + or -, count is a number, and units is "chars" or
+     * "lines".
      *-------------------------------------------------------------------
      */
 
-    gotBase:
+  gotBase:
     cp = endOfBase;
     while (1) {
 	while (isspace(UCHAR(*cp))) {
@@ -962,7 +979,7 @@ GetIndex(interp, sharedPtr, textPtr, string, indexPtr, canCachePtr)
 	if (*cp == 0) {
 	    break;
 	}
-    
+
 	if ((*cp == '+') || (*cp == '-')) {
 	    cp = ForwBack(textPtr, cp, indexPtr);
 	} else {
@@ -973,7 +990,8 @@ GetIndex(interp, sharedPtr, textPtr, string, indexPtr, canCachePtr)
 	}
     }
     Tcl_DStringFree(&copy);
-    done:
+
+  done:
     if (canCachePtr != NULL) {
 	*canCachePtr = canCache;
     }
@@ -982,11 +1000,10 @@ GetIndex(interp, sharedPtr, textPtr, string, indexPtr, canCachePtr)
     }
     return TCL_OK;
 
-    error:
+  error:
     Tcl_DStringFree(&copy);
     Tcl_ResetResult(interp);
-    Tcl_AppendResult(interp, "bad text index \"", string, "\"",
-	    (char *) NULL);
+    Tcl_AppendResult(interp, "bad text index \"", string, "\"", (char *)NULL);
     return TCL_ERROR;
 }
 
@@ -994,13 +1011,13 @@ GetIndex(interp, sharedPtr, textPtr, string, indexPtr, canCachePtr)
  *---------------------------------------------------------------------------
  *
  * TkTextPrintIndex --
- *	
- *	This procedure generates a string description of an index, suitable
- *	for reading in again later.
+ *
+ *	This function generates a string description of an index, suitable for
+ *	reading in again later.
  *
  * Results:
- *	The characters pointed to by string are modified.  Returns the
- *	number of characters in the string.
+ *	The characters pointed to by string are modified. Returns the number
+ *	of characters in the string.
  *
  * Side effects:
  *	None.
@@ -1012,8 +1029,8 @@ int
 TkTextPrintIndex(textPtr, indexPtr, string)
     CONST TkText *textPtr;
     CONST TkTextIndex *indexPtr;/* Pointer to index. */
-    char *string;		/* Place to store the position.  Must have
-				 * at least TK_POS_CHARS characters. */
+    char *string;		/* Place to store the position. Must have at
+				 * least TK_POS_CHARS characters. */
 {
     TkTextSegment *segPtr;
     TkTextLine *linePtr;
@@ -1022,12 +1039,14 @@ TkTextPrintIndex(textPtr, indexPtr, string)
     numBytes = indexPtr->byteIndex;
     charIndex = 0;
     linePtr = indexPtr->linePtr;
+
     for (segPtr = linePtr->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);
 	    segPtr = linePtr->segPtr;
 	}
@@ -1041,14 +1060,15 @@ TkTextPrintIndex(textPtr, indexPtr, string)
 	}
 	numBytes -= segPtr->size;
     }
+
     if (segPtr->typePtr == &tkTextCharType) {
 	charIndex += Tcl_NumUtfChars(segPtr->body.chars, numBytes);
     } else {
 	charIndex += numBytes;
     }
-    return sprintf(string, "%d.%d", 
-		   TkBTreeLinesTo(textPtr, indexPtr->linePtr) + 1,
-		   charIndex);
+
+    return sprintf(string, "%d.%d",
+	    TkBTreeLinesTo(textPtr, indexPtr->linePtr) + 1, charIndex);
 }
 
 /*
@@ -1085,13 +1105,14 @@ TkTextIndexCmp(index1Ptr, index2Ptr)
 	    return 0;
 	}
     }
-    /* 
-     * Assumption here that it is ok for comparisons to reflect
-     * the full B-tree and not just the portion that is available
-     * to any client.  This should be true because the only
-     * indexPtr's we should be given are ones which are valid
-     * for the current client.
+
+    /*
+     * Assumption here that it is ok for comparisons to reflect the full
+     * B-tree and not just the portion that is available to any client. This
+     * should be true because the only indexPtr's we should be given are ones
+     * which are valid for the current client.
      */
+
     line1 = TkBTreeLinesTo(NULL, index1Ptr->linePtr);
     line2 = TkBTreeLinesTo(NULL, index2Ptr->linePtr);
     if (line1 < line2) {
@@ -1108,14 +1129,14 @@ TkTextIndexCmp(index1Ptr, index2Ptr)
  *
  * ForwBack --
  *
- *	This procedure handles +/- modifiers for indices to adjust the
- *	index forwards or backwards.
+ *	This function handles +/- modifiers for indices to adjust the index
+ *	forwards or backwards.
  *
  * Results:
- *	If the modifier in string is successfully parsed then the return
- *	value is the address of the first character after the modifier,
- *	and *indexPtr is updated to reflect the modifier.  If there is a
- *	syntax error in the modifier then NULL is returned.
+ *	If the modifier in string is successfully parsed then the return value
+ *	is the address of the first character after the modifier, and
+ *	*indexPtr is updated to reflect the modifier. If there is a syntax
+ *	error in the modifier then NULL is returned.
  *
  * Side effects:
  *	None.
@@ -1126,10 +1147,9 @@ TkTextIndexCmp(index1Ptr, index2Ptr)
 static CONST char *
 ForwBack(textPtr, string, indexPtr)
     TkText *textPtr;		/* Information about text widget. */
-    CONST char *string;		/* String to parse for additional info
-				 * about modifier (count and units). 
-				 * Points to "+" or "-" that starts
-				 * modifier. */
+    CONST char *string;		/* String to parse for additional info about
+				 * modifier (count and units). Points to "+"
+				 * or "-" that starts modifier. */
     TkTextIndex *indexPtr;	/* Index to update as specified in string. */
 {
     register CONST char *p, *units;
@@ -1155,28 +1175,27 @@ ForwBack(textPtr, string, indexPtr)
     }
 
     /*
-     * Find the end of this modifier (next space or + or - character),
-     * then check if there is a textual 'display' or 'any' modifier.
-     * These modifiers can be their own word (in which case they can 
-     * be abbreviated) or they can follow on to the actual unit in
-     * a single word (in which case no abbreviation is allowed).  So,
-     * 'display lines', 'd lines', 'displaylin' are all ok, but 'dline'
-     * is not.
+     * Find the end of this modifier (next space or + or - character), then
+     * check if there is a textual 'display' or 'any' modifier. These
+     * modifiers can be their own word (in which case they can be abbreviated)
+     * or they can follow on to the actual unit in a single word (in which
+     * case no abbreviation is allowed). So, 'display lines', 'd lines',
+     * 'displaylin' are all ok, but 'dline' is not.
      */
 
-    units = p; 
+    units = p;
     while ((*p != '\0') && !isspace(UCHAR(*p)) && (*p != '+') && (*p != '-')) {
 	p++;
     }
     length = p - units;
-    if ((*units == 'd') && (strncmp(units, "display", 
+    if ((*units == 'd') && (strncmp(units, "display",
 				    (length > 7 ? 7 : length)) == 0)) {
 	modifier = TKINDEX_DISPLAY;
 	if (length > 7) {
 	    p -= (length - 7);
 	}
-    } else if ((*units == 'a') && (strncmp(units, "any", 
-					   (length > 3 ? 3 : length)) == 0)) {
+    } else if ((*units == 'a') &&
+	    (strncmp(units, "any", (length > 3 ? 3 : length)) == 0)) {
 	modifier = TKINDEX_ANY;
 	if (length > 3) {
 	    p -= (length - 3);
@@ -1185,16 +1204,17 @@ ForwBack(textPtr, string, indexPtr)
 	modifier = TKINDEX_NONE;
     }
 
-    /* 
-     * If we had a modifier, which we interpreted ok, so now forward
-     * to the actual units.
+    /*
+     * If we had a modifier, which we interpreted ok, so now forward to the
+     * actual units.
      */
+
     if (modifier != TKINDEX_NONE) {
 	while (isspace(UCHAR(*p))) {
 	    p++;
 	}
-	units = p; 
-	while ((*p != '\0') && !isspace(UCHAR(*p)) && (*p != '+') && (*p != '-')) {
+	units = p;
+	while (*p!='\0' && !isspace(UCHAR(*p)) && *p!='+' && *p!='-') {
 	    p++;
 	}
 	length = p - units;
@@ -1203,8 +1223,10 @@ ForwBack(textPtr, string, indexPtr)
     /*
      * Finally parse the units.
      */
+
     if ((*units == 'c') && (strncmp(units, "chars", length) == 0)) {
 	TkTextCountType type;
+
 	if (modifier == TKINDEX_NONE) {
 	    type = COUNT_INDICES;
 	} else if (modifier == TKINDEX_ANY) {
@@ -1212,6 +1234,7 @@ ForwBack(textPtr, string, indexPtr)
 	} else {
 	    type = COUNT_DISPLAY_CHARS;
 	}
+
 	if (*string == '+') {
 	    TkTextIndexForwChars(textPtr, indexPtr, count, indexPtr, type);
 	} else {
@@ -1219,11 +1242,13 @@ ForwBack(textPtr, string, indexPtr)
 	}
     } else if ((*units == 'i') && (strncmp(units, "indices", length) == 0)) {
 	TkTextCountType type;
+
 	if (modifier == TKINDEX_DISPLAY) {
 	    type = COUNT_DISPLAY_INDICES;
 	} else {
 	    type = COUNT_INDICES;
 	}
+
 	if (*string == '+') {
 	    TkTextIndexForwChars(textPtr, indexPtr, count, indexPtr, type);
 	} else {
@@ -1231,68 +1256,79 @@ ForwBack(textPtr, string, indexPtr)
 	}
     } else if ((*units == 'l') && (strncmp(units, "lines", length) == 0)) {
 	if (modifier == TKINDEX_DISPLAY) {
-	    /* 
+	    /*
 	     * Find the appropriate pixel offset of the current position
-	     * within its display line.  This also has the side-effect of
-	     * moving indexPtr, but that doesn't matter since we will do
-	     * it again below.
-	     * 
-	     * Then find the right display line, and finally calculated
-	     * the index we want in that display line, based on the
-	     * original pixel offset.
+	     * within its display line. This also has the side-effect of
+	     * moving indexPtr, but that doesn't matter since we will do it
+	     * again below.
+	     *
+	     * Then find the right display line, and finally calculated the
+	     * index we want in that display line, based on the original pixel
+	     * offset.
 	     */
+
 	    int xOffset, forward;
+
 	    if (TkTextIsElided(textPtr, indexPtr, NULL)) {
-	        /* Go forward to the first non-elided index */
-		TkTextIndexForwChars(textPtr, indexPtr, 0, indexPtr, 
-				     COUNT_DISPLAY_INDICES);
+		/*
+		 * Go forward to the first non-elided index.
+		 */
+
+		TkTextIndexForwChars(textPtr, indexPtr, 0, indexPtr,
+			COUNT_DISPLAY_INDICES);
 	    }
-	    /* 
-	     * Unlike the Forw/BackChars code, the display line code
-	     * is sensitive to whether we are genuinely going
-	     * forwards or backwards.  So, we need to determine that.
-	     * This is important in the case where we have "+ -3
-	     * displaylines", for example.
+
+	    /*
+	     * Unlike the Forw/BackChars code, the display line code is
+	     * sensitive to whether we are genuinely going forwards or
+	     * backwards. So, we need to determine that. This is important in
+	     * the case where we have "+ -3 displaylines", for example.
 	     */
+
 	    if ((count < 0) ^ (*string == '-')) {
 		forward = 0;
 	    } else {
 		forward = 1;
 	    }
+
 	    count = abs(count);
 	    if (count == 0) {
 		return p;
 	    }
+
 	    if (forward) {
 		TkTextFindDisplayLineEnd(textPtr, indexPtr, 1, &xOffset);
 		while (count-- > 0) {
-		    /* 
-		     * Go to the end of the line, then forward one
-		     * char/byte to get to the beginning of the next
-		     * line.
+		    /*
+		     * Go to the end of the line, then forward one char/byte
+		     * to get to the beginning of the next line.
 		     */
+
 		    TkTextFindDisplayLineEnd(textPtr, indexPtr, 1, NULL);
-		    TkTextIndexForwChars(textPtr, indexPtr, 1, indexPtr, 
-					 COUNT_DISPLAY_INDICES);
+		    TkTextIndexForwChars(textPtr, indexPtr, 1, indexPtr,
+			    COUNT_DISPLAY_INDICES);
 		}
 	    } else {
 		TkTextFindDisplayLineEnd(textPtr, indexPtr, 0, &xOffset);
 		while (count-- > 0) {
-		    /* 
+		    /*
 		     * Go to the beginning of the line, then backward one
 		     * char/byte to get to the end of the previous line
 		     */
+
 		    TkTextFindDisplayLineEnd(textPtr, indexPtr, 0, NULL);
-		    TkTextIndexBackChars(textPtr, indexPtr, 1, indexPtr, 
-					 COUNT_DISPLAY_INDICES);
+		    TkTextIndexBackChars(textPtr, indexPtr, 1, indexPtr,
+			    COUNT_DISPLAY_INDICES);
 		}
 		TkTextFindDisplayLineEnd(textPtr, indexPtr, 0, NULL);
 	    }
-	    /* 
+
+	    /*
 	     * This call assumes indexPtr is the beginning of a display line
 	     * and moves it to the 'xOffset' position of that line, which is
 	     * just what we want.
 	     */
+
 	    TkTextIndexOfX(textPtr, xOffset, indexPtr);
 	} else {
 	    lineIndex = TkBTreeLinesTo(textPtr, indexPtr->linePtr);
@@ -1302,31 +1338,29 @@ ForwBack(textPtr, string, indexPtr)
 		lineIndex -= count;
 
 		/*
-		 * The check below retains the character position, even
-		 * if the line runs off the start of the file.  Without
-		 * it, the character position will get reset to 0 by
-		 * TkTextMakeIndex.
+		 * The check below retains the character position, even if the
+		 * line runs off the start of the file. Without it, the
+		 * character position will get reset to 0 by TkTextMakeIndex.
 		 */
 
 		if (lineIndex < 0) {
 		    lineIndex = 0;
 		}
 	    }
+
 	    /*
 	     * This doesn't work quite right if using a proportional font or
-	     * UTF-8 characters with varying numbers of bytes, or if there
-	     * are embedded windows, images, etc.  The cursor will bop
-	     * around, keeping a constant number of bytes (not characters)
-	     * from the left edge (but making sure not to split any UTF-8
-	     * characters), regardless of the x-position the index
-	     * corresponds to.  The proper way to do this is to get the
-	     * x-position of the index and then pick the character at the
-	     * same x-position in the new line.
+	     * UTF-8 characters with varying numbers of bytes, or if there are
+	     * embedded windows, images, etc. The cursor will bop around,
+	     * keeping a constant number of bytes (not characters) from the
+	     * left edge (but making sure not to split any UTF-8 characters),
+	     * regardless of the x-position the index corresponds to. The
+	     * proper way to do this is to get the x-position of the index and
+	     * then pick the character at the same x-position in the new line.
 	     */
 
-	    TkTextMakeByteIndex(indexPtr->tree, textPtr, 
-				lineIndex, indexPtr->byteIndex,
-				indexPtr);
+	    TkTextMakeByteIndex(indexPtr->tree, textPtr, lineIndex,
+		    indexPtr->byteIndex, indexPtr);
 	}
     } else {
 	return NULL;
@@ -1339,16 +1373,16 @@ ForwBack(textPtr, string, indexPtr)
  *
  * TkTextIndexForwBytes --
  *
- *	Given an index for a text widget, this procedure creates a new
- *	index that points "count" bytes ahead of the source index.
+ *	Given an index for a text widget, this function creates a new index
+ *	that points "count" bytes ahead of the source index.
  *
  * Results:
  *	*dstPtr is modified to refer to the character "count" bytes after
- *	srcPtr, or to the last character in the TkText if there aren't
- *	"count" bytes left.
- *	
- *	In this latter case, the function returns '1' to indicate
- *	that not all of 'byteCount' could be used.
+ *	srcPtr, or to the last character in the TkText if there aren't "count"
+ *	bytes left.
+ *
+ *	In this latter case, the function returns '1' to indicate that not all
+ *	of 'byteCount' could be used.
  *
  * Side effects:
  *	None.
@@ -1360,7 +1394,7 @@ int
 TkTextIndexForwBytes(textPtr, srcPtr, byteCount, dstPtr)
     CONST TkText *textPtr;
     CONST TkTextIndex *srcPtr;	/* Source index. */
-    int byteCount;		/* How many bytes forward to move.  May be
+    int byteCount;		/* How many bytes forward to move. May be
 				 * negative. */
     TkTextIndex *dstPtr;	/* Destination index: gets modified. */
 {
@@ -1387,8 +1421,8 @@ TkTextIndexForwBytes(textPtr, srcPtr, byteCount, dstPtr)
 	}
 
 	/*
-	 * If the new index is in the same line then we're done.
-	 * Otherwise go on to the next line.
+	 * If the new index is in the same line then we're done. Otherwise go
+	 * on to the next line.
 	 */
 
 	if (dstPtr->byteIndex < lineLength) {
@@ -1409,19 +1443,18 @@ TkTextIndexForwBytes(textPtr, srcPtr, byteCount, dstPtr)
  *
  * TkTextIndexForwChars --
  *
- *	Given an index for a text widget, this procedure creates a new
- *	index that points "count" items of type given by "type" ahead of
- *	the source index.  "count" can be zero, which is useful in
- *	the case where one wishes to move forward by display
- *	(non-elided) chars or indices or one wishes to move forward
- *	by chars, skipping any intervening indices.  In this case
- *	dstPtr will point to the first acceptable index which is
+ *	Given an index for a text widget, this function creates a new index
+ *	that points "count" items of type given by "type" ahead of the source
+ *	index. "count" can be zero, which is useful in the case where one
+ *	wishes to move forward by display (non-elided) chars or indices or one
+ *	wishes to move forward by chars, skipping any intervening indices. In
+ *	this case dstPtr will point to the first acceptable index which is
  *	encountered.
  *
  * Results:
- *	*dstPtr is modified to refer to the character "count" items
- *	after srcPtr, or to the last character in the TkText if there
- *	aren't sufficient items left in the widget.
+ *	*dstPtr is modified to refer to the character "count" items after
+ *	srcPtr, or to the last character in the TkText if there aren't
+ *	sufficient items left in the widget.
  *
  * Side effects:
  *	None.
@@ -1431,12 +1464,12 @@ TkTextIndexForwBytes(textPtr, srcPtr, byteCount, dstPtr)
 
 void
 TkTextIndexForwChars(textPtr, srcPtr, charCount, dstPtr, type)
-    CONST TkText *textPtr;      /* Overall information about text widget. */
+    CONST TkText *textPtr;	/* Overall information about text widget. */
     CONST TkTextIndex *srcPtr;	/* Source index. */
-    int charCount;		/* How many characters forward to move.
-				 * May be negative. */
+    int charCount;		/* How many characters forward to move. May
+				 * be negative. */
     TkTextIndex *dstPtr;	/* Destination index: gets modified. */
-    TkTextCountType type;       /* The type of item to count */
+    TkTextCountType type;	/* The type of item to count */
 {
     TkTextLine *linePtr;
     TkTextSegment *segPtr;
@@ -1446,7 +1479,7 @@ TkTextIndexForwChars(textPtr, srcPtr, charCount, dstPtr, type)
     Tcl_UniChar ch;
     int elide = 0;
     int checkElided = (type & COUNT_DISPLAY);
-    
+
     if (charCount < 0) {
 	TkTextIndexBackChars(textPtr, srcPtr, -charCount, dstPtr, type);
 	return;
@@ -1459,21 +1492,22 @@ TkTextIndexForwChars(textPtr, srcPtr, charCount, dstPtr, type)
     *dstPtr = *srcPtr;
 
     /*
-     * Find seg that contains src byteIndex.
-     * Move forward specified number of chars.
+     * Find seg that contains src byteIndex. Move forward specified number of
+     * chars.
      */
 
     if (checkElided) {
-	/* 
-	 * In this case we have already calculated the information
-	 * we need, so no need to use TkTextIndexToSeg()
+	/*
+	 * In this case we have already calculated the information we need, so
+	 * no need to use TkTextIndexToSeg()
 	 */
+
 	segPtr = infoPtr->segPtr;
 	byteOffset = dstPtr->byteIndex - infoPtr->segOffset;
     } else {
 	segPtr = TkTextIndexToSeg(dstPtr, &byteOffset);
     }
-    
+
     while (1) {
 	/*
 	 * Go through each segment in line looking for specified character
@@ -1483,61 +1517,62 @@ TkTextIndexForwChars(textPtr, srcPtr, charCount, dstPtr, type)
 	for ( ; segPtr != NULL; segPtr = segPtr->nextPtr) {
 	    /*
 	     * If we do need to pay attention to the visibility of
-	     * characters/indices, check that first.  If the current
-	     * segment isn't visible, then we simply continue the
-	     * loop
+	     * characters/indices, check that first. If the current segment
+	     * isn't visible, then we simply continue the loop
 	     */
-	    if (checkElided) {
-		if ((segPtr->typePtr == &tkTextToggleOffType)
-		    || (segPtr->typePtr == &tkTextToggleOnType)) {		
-		    TkTextTag *tagPtr = segPtr->body.toggle.tagPtr;
-		    /*
-		     * The elide state only changes if this tag is
-		     * either the current highest priority tag
-		     * (and is therefore being toggled off), or it's
-		     * a new tag with higher priority.
-		     */
-		    if (tagPtr->elideString != NULL) {
-			infoPtr->tagCnts[tagPtr->priority]++;
-			if (infoPtr->tagCnts[tagPtr->priority] & 1) {
-			    infoPtr->tagPtrs[tagPtr->priority] = tagPtr;
-			}
-			if (tagPtr->priority >= infoPtr->elidePriority) {
-			    if (segPtr->typePtr == &tkTextToggleOffType) {
-				/* 
-				 * If it is being toggled off, and it has
-				 * an elide string, it must actually be the
-				 * current highest priority tag, so this
-				 * check is redundant:
-				 */
-				if (tagPtr->priority != infoPtr->elidePriority) {
-				    Tcl_Panic("Bad tag priority being toggled off");
-				}
-			    
-				/* 
-				 * Find previous elide tag, if any (if not
-				 * then elide will be zero, of course).
-				 */
-				elide = 0;
-				while (--infoPtr->elidePriority > 0) {
-				    if (infoPtr->tagCnts[infoPtr->elidePriority] 
+
+	    if (checkElided && ((segPtr->typePtr == &tkTextToggleOffType)
+		    || (segPtr->typePtr == &tkTextToggleOnType))) {
+		TkTextTag *tagPtr = segPtr->body.toggle.tagPtr;
+
+		/*
+		 * The elide state only changes if this tag is either the
+		 * current highest priority tag (and is therefore being
+		 * toggled off), or it's a new tag with higher priority.
+		 */
+
+		if (tagPtr->elideString != NULL) {
+		    infoPtr->tagCnts[tagPtr->priority]++;
+		    if (infoPtr->tagCnts[tagPtr->priority] & 1) {
+			infoPtr->tagPtrs[tagPtr->priority] = tagPtr;
+		    }
+
+		    if (tagPtr->priority >= infoPtr->elidePriority) {
+			if (segPtr->typePtr == &tkTextToggleOffType) {
+			    /*
+			     * If it is being toggled off, and it has an elide
+			     * string, it must actually be the current highest
+			     * priority tag, so this check is redundant:
+			     */
+
+			    if (tagPtr->priority != infoPtr->elidePriority) {
+				Tcl_Panic("Bad tag priority being toggled off");
+			    }
+
+			    /*
+			     * Find previous elide tag, if any (if not then
+			     * elide will be zero, of course).
+			     */
+
+			    elide = 0;
+			    while (--infoPtr->elidePriority > 0) {
+				if (infoPtr->tagCnts[infoPtr->elidePriority]
 					& 1) {
-					elide = infoPtr->tagPtrs
+				    elide = infoPtr->tagPtrs
 					    [infoPtr->elidePriority]->elide;
-					break;
-				    }
+				    break;
 				}
-			    } else {
-				elide = tagPtr->elide;
-				infoPtr->elidePriority = tagPtr->priority;
 			    }
+			} else {
+			    elide = tagPtr->elide;
+			    infoPtr->elidePriority = tagPtr->priority;
 			}
 		    }
 		}
 	    }
 
 	    if (!elide) {
-	        if (segPtr->typePtr == &tkTextCharType) {
+		if (segPtr->typePtr == &tkTextCharType) {
 		    start = segPtr->body.chars + byteOffset;
 		    end = segPtr->body.chars + segPtr->size;
 		    for (p = start; p < end; p += Tcl_UtfToUniChar(p, &ch)) {
@@ -1547,27 +1582,24 @@ TkTextIndexForwChars(textPtr, srcPtr, charCount, dstPtr, type)
 			}
 			charCount--;
 		    }
-		} else {
-		    if (type & COUNT_INDICES) {
-			if (charCount < segPtr->size - byteOffset) {
-			    dstPtr->byteIndex += charCount;
-			    goto forwardCharDone;
-			}
-			charCount -= segPtr->size - byteOffset;
+		} else if (type & COUNT_INDICES) {
+		    if (charCount < segPtr->size - byteOffset) {
+			dstPtr->byteIndex += charCount;
+			goto forwardCharDone;
 		    }
+		    charCount -= segPtr->size - byteOffset;
 		}
 	    }
-	    
+
 	    dstPtr->byteIndex += segPtr->size - byteOffset;
 	    byteOffset = 0;
 	}
 
 	/*
-	 * Go to the next line.  If we are at the end of the text item,
-	 * back up one byte (for the terminal '\n' character) and return
-	 * that index.
+	 * Go to the next line. If we are at the end of the text item, back up
+	 * one byte (for the terminal '\n' character) and return that index.
 	 */
-	 
+
 	linePtr = TkBTreeNextLine(textPtr, dstPtr->linePtr);
 	if (linePtr == NULL) {
 	    dstPtr->byteIndex -= sizeof(char);
@@ -1577,6 +1609,7 @@ TkTextIndexForwChars(textPtr, srcPtr, charCount, dstPtr, type)
 	dstPtr->byteIndex = 0;
 	segPtr = dstPtr->linePtr->segPtr;
     }
+
   forwardCharDone:
     if (infoPtr != NULL) {
 	TkTextFreeElideInfo(infoPtr);
@@ -1589,19 +1622,18 @@ TkTextIndexForwChars(textPtr, srcPtr, charCount, dstPtr, type)
  *
  * TkTextIndexCount --
  *
- *	Given an ordered pair of indices in a text widget, this
- *	procedure counts how many characters (not bytes) are between 
- *	the two indices.
- *	
- *	It is illegal to call this procedure with unordered indices.
- *	
- *	Note that 'textPtr' is only used if we need to check for
- *	elided attributes, i.e. if type is COUNT_DISPLAY_INDICES or
+ *	Given an ordered pair of indices in a text widget, this function
+ *	counts how many characters (not bytes) are between the two indices.
+ *
+ *	It is illegal to call this function with unordered indices.
+ *
+ *	Note that 'textPtr' is only used if we need to check for elided
+ *	attributes, i.e. if type is COUNT_DISPLAY_INDICES or
  *	COUNT_DISPLAY_CHARS.
  *
  * Results:
- *	The number of characters in the given range, which meet
- *	the appropriate 'type' attributes.
+ *	The number of characters in the given range, which meet the
+ *	appropriate 'type' attributes.
  *
  * Side effects:
  *	None.
@@ -1611,13 +1643,14 @@ TkTextIndexForwChars(textPtr, srcPtr, charCount, dstPtr, type)
 
 int
 TkTextIndexCount(textPtr, indexPtr1, indexPtr2, type)
-    CONST TkText *textPtr;	 /* Overall information about text widget. */
-    CONST TkTextIndex *indexPtr1;/* Index describing location of
-                                  * character from which to count. */
-    CONST TkTextIndex *indexPtr2;/* Index describing location of last
-				  * character at which to stop the
-				  * count. */
-    TkTextCountType type;        /* The kind of indices to count */
+    CONST TkText *textPtr;	/* Overall information about text widget. */
+    CONST TkTextIndex *indexPtr1;
+				/* Index describing location of character from
+				 * which to count. */
+    CONST TkTextIndex *indexPtr2;
+				/* Index describing location of last character
+				 * at which to stop the count. */
+    TkTextCountType type;	/* The kind of indices to count. */
 {
     TkTextLine *linePtr1;
     TkTextSegment *segPtr, *seg2Ptr = NULL;
@@ -1628,43 +1661,43 @@ TkTextIndexCount(textPtr, indexPtr1, indexPtr2, type)
     int checkElided = (type & COUNT_DISPLAY);
 
     /*
-     * Find seg that contains src index, and remember
-     * how many bytes not to count in the given segment.
+     * Find seg that contains src index, and remember how many bytes not to
+     * count in the given segment.
      */
 
     segPtr = TkTextIndexToSeg(indexPtr1, &byteOffset);
     linePtr1 = indexPtr1->linePtr;
-    
+
     seg2Ptr = TkTextIndexToSeg(indexPtr2, &maxBytes);
 
     if (checkElided) {
 	infoPtr = (TkTextElideInfo*)ckalloc((unsigned)sizeof(TkTextElideInfo));
 	elide = TkTextIsElided(textPtr, indexPtr1, infoPtr);
     }
-	
+
     while (1) {
 	/*
-	 * Go through each segment in line adding up the number
-	 * of characters.
+	 * Go through each segment in line adding up the number of characters.
 	 */
-	
+
 	for ( ; segPtr != NULL; segPtr = segPtr->nextPtr) {
 	    /*
 	     * If we do need to pay attention to the visibility of
-	     * characters/indices, check that first.  If the current
-	     * segment isn't visible, then we simply continue the
-	     * loop
+	     * characters/indices, check that first. If the current segment
+	     * isn't visible, then we simply continue the loop.
 	     */
+
 	    if (checkElided) {
 		if ((segPtr->typePtr == &tkTextToggleOffType)
-		  || (segPtr->typePtr == &tkTextToggleOnType)) {
+			|| (segPtr->typePtr == &tkTextToggleOnType)) {
 		    TkTextTag *tagPtr = segPtr->body.toggle.tagPtr;
+
 		    /*
-		     * The elide state only changes if this tag is
-		     * either the current highest priority tag
-		     * (and is therefore being toggled off), or it's
-		     * a new tag with higher priority.
+		     * The elide state only changes if this tag is either the
+		     * current highest priority tag (and is therefore being
+		     * toggled off), or it's a new tag with higher priority.
 		     */
+
 		    if (tagPtr->elideString != NULL) {
 			infoPtr->tagCnts[tagPtr->priority]++;
 			if (infoPtr->tagCnts[tagPtr->priority] & 1) {
@@ -1672,26 +1705,28 @@ TkTextIndexCount(textPtr, indexPtr1, indexPtr2, type)
 			}
 			if (tagPtr->priority >= infoPtr->elidePriority) {
 			    if (segPtr->typePtr == &tkTextToggleOffType) {
-				/* 
-				 * If it is being toggled off, and it has
-				 * an elide string, it must actually be the
-				 * current highest priority tag, so this
-				 * check is redundant:
+				/*
+				 * If it is being toggled off, and it has an
+				 * elide string, it must actually be the
+				 * current highest priority tag, so this check
+				 * is redundant:
 				 */
-				if (tagPtr->priority != infoPtr->elidePriority) {
+
+				if (tagPtr->priority!=infoPtr->elidePriority) {
 				    Tcl_Panic("Bad tag priority being toggled off");
 				}
-				
-				/* 
+
+				/*
 				 * Find previous elide tag, if any (if not
 				 * then elide will be zero, of course).
 				 */
+
 				elide = 0;
 				while (--infoPtr->elidePriority > 0) {
-				    if (infoPtr->tagCnts[infoPtr->elidePriority] 
-					& 1) {
-					elide = infoPtr->tagPtrs
-					  [infoPtr->elidePriority]->elide;
+				    if (infoPtr->tagCnts[
+					    infoPtr->elidePriority] & 1) {
+					elide = infoPtr->tagPtrs[
+						infoPtr->elidePriority]->elide;
 					break;
 				    }
 				}
@@ -1710,29 +1745,34 @@ TkTextIndexCount(textPtr, indexPtr1, indexPtr2, type)
 		    continue;
 		}
 	    }
-	    
+
 	    if (segPtr->typePtr == &tkTextCharType) {
 		int byteLen = segPtr->size - byteOffset;
-		register unsigned char *str = 
-                  (unsigned char *) segPtr->body.chars + byteOffset;
+		register unsigned char *str = (unsigned char *)
+			segPtr->body.chars + byteOffset;
 		register int i;
 
 		if (segPtr == seg2Ptr) {
 		    if (byteLen > (maxBytes - byteOffset)) {
-		        byteLen = maxBytes - byteOffset;
+			byteLen = maxBytes - byteOffset;
 		    }
 		}
 		i = byteLen;
-		
+
 		/*
-		 * This is a speed sensitive function, so run specially over the
-		 * string to count continuous ascii characters before resorting
-		 * to the Tcl_NumUtfChars call.  This is a long form of:
-		 * stringPtr->numChars = 
-		 *   Tcl_NumUtfChars(objPtr->bytes, objPtr->length);
+		 * This is a speed sensitive function, so run specially over
+		 * the string to count continuous ascii characters before
+		 * resorting to the Tcl_NumUtfChars call. This is a long form
+		 * of:
+		 *
+		 *   stringPtr->numChars =
+		 *	     Tcl_NumUtfChars(objPtr->bytes, objPtr->length);
 		 */
 
-		while (i && (*str < 0xC0)) { i--; str++; }
+		while (i && (*str < 0xC0)) {
+		    i--;
+		    str++;
+		}
 		count += byteLen - i;
 		if (i) {
 		    count += Tcl_NumUtfChars(segPtr->body.chars + byteOffset
@@ -1741,6 +1781,7 @@ TkTextIndexCount(textPtr, indexPtr1, indexPtr2, type)
 	    } else {
 		if (type & COUNT_INDICES) {
 		    int byteLen = segPtr->size - byteOffset;
+
 		    if (segPtr == seg2Ptr) {
 			if (byteLen > (maxBytes - byteOffset)) {
 			    byteLen = maxBytes - byteOffset;
@@ -1756,17 +1797,17 @@ TkTextIndexCount(textPtr, indexPtr1, indexPtr2, type)
 	}
 
 	/*
-	 * Go to the next line.  If we are at the end of the text item,
-	 * back up one byte (for the terminal '\n' character) and return
-	 * that index.
+	 * Go to the next line. If we are at the end of the text item, back up
+	 * one byte (for the terminal '\n' character) and return that index.
 	 */
-	 
+
 	linePtr1 = TkBTreeNextLine(textPtr, linePtr1);
 	if (linePtr1 == NULL) {
 	    Tcl_Panic("Reached end of text widget when counting characters");
 	}
 	segPtr = linePtr1->segPtr;
     }
+
   countDone:
     if (infoPtr != NULL) {
 	TkTextFreeElideInfo(infoPtr);
@@ -1774,22 +1815,22 @@ TkTextIndexCount(textPtr, indexPtr1, indexPtr2, type)
     }
     return count;
 }
-	
+
 /*
  *---------------------------------------------------------------------------
  *
  * TkTextIndexBackBytes --
  *
- *	Given an index for a text widget, this procedure creates a new
- *	index that points "count" bytes earlier than the source index.
+ *	Given an index for a text widget, this function creates a new index
+ *	that points "count" bytes earlier than the source index.
  *
  * Results:
  *	*dstPtr is modified to refer to the character "count" bytes before
  *	srcPtr, or to the first character in the TkText if there aren't
  *	"count" bytes earlier than srcPtr.
- *	
- *	Returns 1 if we couldn't use all of 'byteCount' because we 
- *	have run into the beginning or end of the text, and zero otherwise.
+ *
+ *	Returns 1 if we couldn't use all of 'byteCount' because we have run
+ *	into the beginning or end of the text, and zero otherwise.
  *
  * Side effects:
  *	None.
@@ -1801,7 +1842,7 @@ int
 TkTextIndexBackBytes(textPtr, srcPtr, byteCount, dstPtr)
     CONST TkText *textPtr;
     CONST TkTextIndex *srcPtr;	/* Source index. */
-    int byteCount;		/* How many bytes backward to move.  May be
+    int byteCount;		/* How many bytes backward to move. May be
 				 * negative. */
     TkTextIndex *dstPtr;	/* Destination index: gets modified. */
 {
@@ -1817,8 +1858,8 @@ TkTextIndexBackBytes(textPtr, srcPtr, byteCount, dstPtr)
     lineIndex = -1;
     while (dstPtr->byteIndex < 0) {
 	/*
-	 * Move back one line in the text.  If we run off the beginning
-	 * of the file then just return the first character in the text.
+	 * Move back one line in the text. If we run off the beginning of the
+	 * file then just return the first character in the text.
 	 */
 
 	if (lineIndex < 0) {
@@ -1848,19 +1889,18 @@ TkTextIndexBackBytes(textPtr, srcPtr, byteCount, dstPtr)
  *
  * TkTextIndexBackChars --
  *
- *	Given an index for a text widget, this procedure creates a new
- *	index that points "count" items of type given by "type" earlier
- *	than the source index.  "count" can be zero, which is useful in
- *	the case where one wishes to move backward by display
- *	(non-elided) chars or indices or one wishes to move backward by
- *	chars, skipping any intervening indices.  In this case the
- *	returned index *dstPtr will point just _after_ the first
- *	acceptable index which is encountered.
+ *	Given an index for a text widget, this function creates a new index
+ *	that points "count" items of type given by "type" earlier than the
+ *	source index. "count" can be zero, which is useful in the case where
+ *	one wishes to move backward by display (non-elided) chars or indices
+ *	or one wishes to move backward by chars, skipping any intervening
+ *	indices. In this case the returned index *dstPtr will point just
+ *	_after_ the first acceptable index which is encountered.
  *
  * Results:
- *	*dstPtr is modified to refer to the character "count" items
- *	before srcPtr, or to the first index in the window if there
- *	aren't sufficient items earlier than srcPtr.
+ *	*dstPtr is modified to refer to the character "count" items before
+ *	srcPtr, or to the first index in the window if there aren't sufficient
+ *	items earlier than srcPtr.
  *
  * Side effects:
  *	None.
@@ -1870,12 +1910,12 @@ TkTextIndexBackBytes(textPtr, srcPtr, byteCount, dstPtr)
 
 void
 TkTextIndexBackChars(textPtr, srcPtr, charCount, dstPtr, type)
-    CONST TkText *textPtr;      /* Overall information about text widget. */
+    CONST TkText *textPtr;	/* Overall information about text widget. */
     CONST TkTextIndex *srcPtr;	/* Source index. */
-    int charCount;		/* How many characters backward to move.
-				 * May be negative. */
+    int charCount;		/* How many characters backward to move. May
+				 * be negative. */
     TkTextIndex *dstPtr;	/* Destination index: gets modified. */
-    TkTextCountType type;       /* The type of item to count */
+    TkTextCountType type;	/* The type of item to count */
 {
     TkTextSegment *segPtr, *oldPtr;
     TkTextElideInfo *infoPtr = NULL;
@@ -1889,21 +1929,21 @@ TkTextIndexBackChars(textPtr, srcPtr, charCount, dstPtr, type)
 	return;
     }
     if (checkElided) {
-	infoPtr = (TkTextElideInfo*)ckalloc((unsigned)sizeof(TkTextElideInfo));
+	infoPtr = (TkTextElideInfo *) ckalloc(sizeof(TkTextElideInfo));
 	elide = TkTextIsElided(textPtr, srcPtr, infoPtr);
     }
-    
+
     *dstPtr = *srcPtr;
 
     /*
-     * Find offset within seg that contains byteIndex.
-     * Move backward specified number of chars.
+     * Find offset within seg that contains byteIndex. Move backward specified
+     * number of chars.
      */
 
     lineIndex = -1;
-    
+
     segSize = dstPtr->byteIndex;
-    
+
     if (checkElided) {
 	segPtr = infoPtr->segPtr;
 	segSize -= infoPtr->segOffset;
@@ -1911,10 +1951,11 @@ TkTextIndexBackChars(textPtr, srcPtr, charCount, dstPtr, type)
 	TkTextLine *linePtr = dstPtr->linePtr;
 	for (segPtr = linePtr->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);
 		segPtr = linePtr->segPtr;
 	    }
@@ -1924,59 +1965,61 @@ TkTextIndexBackChars(textPtr, srcPtr, charCount, dstPtr, type)
 	    segSize -= segPtr->size;
 	}
     }
-    /* 
+
+    /*
      * Now segPtr points to the segment containing the starting index
      */
+
     while (1) {
 	/*
 	 * If we do need to pay attention to the visibility of
-	 * characters/indices, check that first.  If the current
-	 * segment isn't visible, then we simply continue the
-	 * loop
+	 * characters/indices, check that first. If the current segment isn't
+	 * visible, then we simply continue the loop.
 	 */
-	if (checkElided) {
-	    if ((segPtr->typePtr == &tkTextToggleOffType)
-	      || (segPtr->typePtr == &tkTextToggleOnType)) {		
-		TkTextTag *tagPtr = segPtr->body.toggle.tagPtr;
-		/*
-		 * The elide state only changes if this tag is
-		 * either the current highest priority tag
-		 * (and is therefore being toggled off), or it's
-		 * a new tag with higher priority.
-		 */
-		if (tagPtr->elideString != NULL) {
-		    infoPtr->tagCnts[tagPtr->priority]++;
-		    if (infoPtr->tagCnts[tagPtr->priority] & 1) {
-			infoPtr->tagPtrs[tagPtr->priority] = tagPtr;
-		    }
-		    if (tagPtr->priority >= infoPtr->elidePriority) {
-			if (segPtr->typePtr == &tkTextToggleOnType) {
-			    /* 
-			     * If it is being toggled on, and it has
-			     * an elide string, it must actually be the
-			     * current highest priority tag, so this
-			     * check is redundant:
-			     */
-			    if (tagPtr->priority != infoPtr->elidePriority) {
-				Tcl_Panic("Bad tag priority being toggled on");
-			    }
-						    
-			    /* 
-			     * Find previous elide tag, if any (if not
-			     * then elide will be zero, of course).
-			     */
-			    elide = 0;
-			    while (--infoPtr->elidePriority > 0) {
-				if (infoPtr->tagCnts[infoPtr->elidePriority] & 1) {
-				    elide = infoPtr->tagPtrs
-				              [infoPtr->elidePriority]->elide;
-				    break;
-				}
+
+	if (checkElided && ((segPtr->typePtr == &tkTextToggleOffType)
+		|| (segPtr->typePtr == &tkTextToggleOnType))) {
+	    TkTextTag *tagPtr = segPtr->body.toggle.tagPtr;
+
+	    /*
+	     * The elide state only changes if this tag is either the current
+	     * highest priority tag (and is therefore being toggled off), or
+	     * it's a new tag with higher priority.
+	     */
+
+	    if (tagPtr->elideString != NULL) {
+		infoPtr->tagCnts[tagPtr->priority]++;
+		if (infoPtr->tagCnts[tagPtr->priority] & 1) {
+		    infoPtr->tagPtrs[tagPtr->priority] = tagPtr;
+		}
+		if (tagPtr->priority >= infoPtr->elidePriority) {
+		    if (segPtr->typePtr == &tkTextToggleOnType) {
+			/*
+			 * If it is being toggled on, and it has an elide
+			 * string, it must actually be the current highest
+			 * priority tag, so this check is redundant:
+			 */
+
+			if (tagPtr->priority != infoPtr->elidePriority) {
+			    Tcl_Panic("Bad tag priority being toggled on");
+			}
+
+			/*
+			 * Find previous elide tag, if any (if not then elide
+			 * will be zero, of course).
+			 */
+
+			elide = 0;
+			while (--infoPtr->elidePriority > 0) {
+			    if (infoPtr->tagCnts[infoPtr->elidePriority] & 1) {
+				elide = infoPtr->tagPtrs[
+					infoPtr->elidePriority]->elide;
+				break;
 			    }
-			} else {
-			    elide = tagPtr->elide;
-			    infoPtr->elidePriority = tagPtr->priority;
 			}
+		    } else {
+			elide = tagPtr->elide;
+			infoPtr->elidePriority = tagPtr->priority;
 		    }
 		}
 	    }
@@ -2048,6 +2091,7 @@ TkTextIndexBackChars(textPtr, srcPtr, charCount, dstPtr, type)
 	segPtr = oldPtr;
 	segSize = segPtr->size;
     }
+
   backwardCharDone:
     if (infoPtr != NULL) {
 	TkTextFreeElideInfo(infoPtr);
@@ -2060,14 +2104,14 @@ TkTextIndexBackChars(textPtr, srcPtr, charCount, dstPtr, type)
  *
  * StartEnd --
  *
- *	This procedure handles modifiers like "wordstart" and "lineend"
- *	to adjust indices forwards or backwards.
+ *	This function handles modifiers like "wordstart" and "lineend" to
+ *	adjust indices forwards or backwards.
  *
  * Results:
- *	If the modifier is successfully parsed then the return value
- *	is the address of the first character after the modifier, and
- *	*indexPtr is updated to reflect the modifier. If there is a
- *	syntax error in the modifier then NULL is returned.
+ *	If the modifier is successfully parsed then the return value is the
+ *	address of the first character after the modifier, and *indexPtr is
+ *	updated to reflect the modifier. If there is a syntax error in the
+ *	modifier then NULL is returned.
  *
  * Side effects:
  *	None.
@@ -2078,17 +2122,16 @@ TkTextIndexBackChars(textPtr, srcPtr, charCount, dstPtr, type)
 static CONST char *
 StartEnd(textPtr, string, indexPtr)
     TkText *textPtr;		/* Information about text widget. */
-    CONST char *string;		/* String to parse for additional info
-				 * about modifier (count and units). 
-				 * Points to first character of modifer
-				 * word. */
+    CONST char *string;		/* String to parse for additional info about
+				 * modifier (count and units). Points to first
+				 * character of modifer word. */
     TkTextIndex *indexPtr;	/* Index to modify based on string. */
 {
     CONST char *p;
     size_t length;
     register TkTextSegment *segPtr;
     int modifier;
-    
+
     /*
      * Find the end of the modifier word.
      */
@@ -2096,15 +2139,16 @@ StartEnd(textPtr, string, indexPtr)
     for (p = string; isalnum(UCHAR(*p)); p++) {
 	/* Empty loop body. */
     }
+
     length = p-string;
-    if ((*string == 'd') && (strncmp(string, "display", 
-				     (length > 7 ? 7 : length)) == 0)) {
+    if ((*string == 'd') &&
+	    (strncmp(string, "display", (length > 7 ? 7 : length)) == 0)) {
 	modifier = TKINDEX_DISPLAY;
 	if (length > 7) {
 	    p -= (length - 7);
 	}
-    } else if ((*string == 'a') && (strncmp(string, "any", 
-					    (length > 3 ? 3 : length)) == 0)) {
+    } else if ((*string == 'a') &&
+	    (strncmp(string, "any", (length > 3 ? 3 : length)) == 0)) {
 	modifier = TKINDEX_ANY;
 	if (length > 3) {
 	    p -= (length - 3);
@@ -2112,17 +2156,18 @@ StartEnd(textPtr, string, indexPtr)
     } else {
 	modifier = TKINDEX_NONE;
     }
-    
-    /* 
-     * If we had a modifier, which we interpreted ok, so now forward
-     * to the actual units.
+
+    /*
+     * If we had a modifier, which we interpreted ok, so now forward to the
+     * actual units.
      */
+
     if (modifier != TKINDEX_NONE) {
 	while (isspace(UCHAR(*p))) {
 	    p++;
 	}
-	string = p; 
-	while ((*p != '\0') && !isspace(UCHAR(*p)) && (*p != '+') && (*p != '-')) {
+	string = p;
+	while ((*p!='\0') && !isspace(UCHAR(*p)) && (*p!='+') && (*p!='-')) {
 	    p++;
 	}
 	length = p - string;
@@ -2138,7 +2183,11 @@ StartEnd(textPtr, string, indexPtr)
 		    segPtr = segPtr->nextPtr) {
 		indexPtr->byteIndex += segPtr->size;
 	    }
-	    /* We know '\n' is encoded with a single byte index */
+
+	    /*
+	     * We know '\n' is encoded with a single byte index.
+	     */
+
 	    indexPtr->byteIndex -= sizeof(char);
 	}
     } else if ((*string == 'l') && (strncmp(string, "linestart", length) == 0)
@@ -2155,19 +2204,21 @@ StartEnd(textPtr, string, indexPtr)
 
 	/*
 	 * If the current character isn't part of a word then just move
-	 * forward one character.  Otherwise move forward until finding
-	 * a character that isn't part of a word and stop there.
+	 * forward one character. Otherwise move forward until finding a
+	 * character that isn't part of a word and stop there.
 	 */
 
 	if (modifier == TKINDEX_DISPLAY) {
-	    TkTextIndexForwChars(textPtr, indexPtr, 0, indexPtr, 
-				 COUNT_DISPLAY_INDICES);
+	    TkTextIndexForwChars(textPtr, indexPtr, 0, indexPtr,
+		    COUNT_DISPLAY_INDICES);
 	}
 	segPtr = TkTextIndexToSeg(indexPtr, &offset);
 	while (1) {
 	    int chSize = 1;
+
 	    if (segPtr->typePtr == &tkTextCharType) {
 		Tcl_UniChar ch;
+
 		chSize = Tcl_UtfToUniChar(segPtr->body.chars + offset, &ch);
 		if (!Tcl_UniCharIsWordChar(ch)) {
 		    break;
@@ -2182,11 +2233,11 @@ StartEnd(textPtr, string, indexPtr)
 	}
 	if (firstChar) {
 	    if (modifier == TKINDEX_DISPLAY) {
-		TkTextIndexForwChars(textPtr, indexPtr, 1, indexPtr, 
-				     COUNT_DISPLAY_INDICES);
+		TkTextIndexForwChars(textPtr, indexPtr, 1, indexPtr,
+			COUNT_DISPLAY_INDICES);
 	    } else {
-		TkTextIndexForwChars(NULL, indexPtr, 1, indexPtr, 
-				     COUNT_INDICES);
+		TkTextIndexForwChars(NULL, indexPtr, 1, indexPtr,
+			COUNT_INDICES);
 	    }
 	}
     } else if ((*string == 'w') && (strncmp(string, "wordstart", length) == 0)
@@ -2195,29 +2246,32 @@ StartEnd(textPtr, string, indexPtr)
 	int offset;
 
 	if (modifier == TKINDEX_DISPLAY) {
-	    TkTextIndexForwChars(NULL, indexPtr, 0, indexPtr, 
-				 COUNT_DISPLAY_INDICES);
+	    TkTextIndexForwChars(NULL, indexPtr, 0, indexPtr,
+		    COUNT_DISPLAY_INDICES);
 	}
+
 	/*
-	 * Starting with the current character, look for one that's not
-	 * part of a word and keep moving backward until you find one.
-	 * Then if the character found wasn't the first one, move forward
-	 * again one position.
+	 * Starting with the current character, look for one that's not part
+	 * of a word and keep moving backward until you find one. Then if the
+	 * character found wasn't the first one, move forward again one
+	 * position.
 	 */
 
 	segPtr = TkTextIndexToSeg(indexPtr, &offset);
 	while (1) {
 	    int chSize = 1;
+
 	    if (segPtr->typePtr == &tkTextCharType) {
 		Tcl_UniChar ch;
+
 		Tcl_UtfToUniChar(segPtr->body.chars + offset, &ch);
 		if (!Tcl_UniCharIsWordChar(ch)) {
 		    break;
 		}
 		if (offset > 0) {
-		    chSize = (segPtr->body.chars + offset 
-			      - Tcl_UtfPrev(segPtr->body.chars + offset, 
-					    segPtr->body.chars));
+		    chSize = (segPtr->body.chars + offset
+			    - Tcl_UtfPrev(segPtr->body.chars + offset,
+			    segPtr->body.chars));
 		}
 		firstChar = 0;
 	    } else {
@@ -2232,18 +2286,28 @@ StartEnd(textPtr, string, indexPtr)
 		segPtr = TkTextIndexToSeg(indexPtr, &offset);
 	    }
 	}
+
 	if (!firstChar) {
 	    if (modifier == TKINDEX_DISPLAY) {
-		TkTextIndexForwChars(textPtr, indexPtr, 1, indexPtr, 
-				     COUNT_DISPLAY_INDICES);
+		TkTextIndexForwChars(textPtr, indexPtr, 1, indexPtr,
+			COUNT_DISPLAY_INDICES);
 	    } else {
-		TkTextIndexForwChars(NULL, indexPtr, 1, indexPtr, 
-				     COUNT_INDICES);
+		TkTextIndexForwChars(NULL, indexPtr, 1, indexPtr,
+			COUNT_INDICES);
 	    }
 	}
     } else {
 	return NULL;
     }
-    done:
+
+  done:
     return p;
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */