Whitespace/style police

1 files changed, 262 insertions, 201 deletions

diff --git a/generic/tkUndo.c b/generic/tkUndo.c
index e543cac..64143f1 100644
--- a/generic/tkUndo.c
+++ b/generic/tkUndo.c
@@ -8,131 +8,154 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkUndo.c,v 1.2 2003/05/19 13:04:24 vincentdarley Exp $
+ * RCS: @(#) $Id: tkUndo.c,v 1.3 2003/10/30 23:35:14 dkf Exp $
  */
 
 #include "tkUndo.h"
 
 static int UndoScriptsEvaluate _ANSI_ARGS_ ((Tcl_Interp *interp, 
-				     Tcl_Obj *objPtr, TkUndoAtomType type));
+				    Tcl_Obj *objPtr, TkUndoAtomType type));
 
 
 /*
- * TkUndoPushStack
- *    Push elem on the stack identified by stack.
+ *----------------------------------------------------------------------
+ *
+ * TkUndoPushStack --
+ *	Push elem on the stack identified by stack.
  *
  * Results:
- *    None
+ *	None.
  *
  * Side effects:
- *    None.
+ *	None.
+ *
+ *----------------------------------------------------------------------
  */
- 
-void TkUndoPushStack ( stack, elem )
-    TkUndoAtom ** stack;
-    TkUndoAtom *  elem;
+
+void
+TkUndoPushStack(stack, elem)
+    TkUndoAtom **stack, *elem;
 { 
     elem->next = *stack;
     *stack = elem;
 }
 
 /*
+ *----------------------------------------------------------------------
+ *
  * TkUndoPopStack --
- *    Remove and return the top element from the stack identified by 
- *      stack.
+ *	Remove and return the top element from the stack identified by 
+ *	stack.
  *
  * Results:
- *    None
+ *	None.
  *
  * Side effects:
- *    None.
+ *	None.
+ *
+ *----------------------------------------------------------------------
  */
- 
-TkUndoAtom * TkUndoPopStack ( stack )
-    TkUndoAtom ** stack ;
+
+TkUndoAtom *
+TkUndoPopStack(stack)
+    TkUndoAtom **stack;
 { 
-    TkUndoAtom * elem = NULL;
-    if (*stack != NULL ) {
-        elem   = *stack;
-        *stack = elem->next;
+    TkUndoAtom *elem = NULL;
+    if (*stack != NULL) {
+	elem = *stack;
+	*stack = elem->next;
     }
     return elem;
 }
 
 /*
+ *----------------------------------------------------------------------
+ *
  * TkUndoInsertSeparator --
- *    insert a separator on the stack, indicating a border for
- *      an undo/redo chunk.
+ *	Insert a separator on the stack, indicating a border for
+ *	an undo/redo chunk.
  *
  * Results:
- *    None
+ *	None.
  *
  * Side effects:
- *    None.
+ *	None.
+ *
+ *----------------------------------------------------------------------
  */
- 
-int TkUndoInsertSeparator ( stack )
-    TkUndoAtom ** stack;
+
+int
+TkUndoInsertSeparator(stack)
+    TkUndoAtom **stack;
 {
-    TkUndoAtom * separator;
+    TkUndoAtom *separator;
 
-    if ( *stack != NULL && (*stack)->type != TK_UNDO_SEPARATOR ) {
-        separator = (TkUndoAtom *) ckalloc(sizeof(TkUndoAtom));
-        separator->type = TK_UNDO_SEPARATOR;
-        TkUndoPushStack(stack,separator);
-        return 1;
-    } else {
-        return 0;
+    if (*stack!=NULL && (*stack)->type!=TK_UNDO_SEPARATOR) {
+	separator = (TkUndoAtom *) ckalloc(sizeof(TkUndoAtom));
+	separator->type = TK_UNDO_SEPARATOR;
+	TkUndoPushStack(stack,separator);
+	return 1;
     }
+    return 0;
 }
 
 /*
+ *----------------------------------------------------------------------
+ *
  * TkUndoClearStack --
- *    Clear an entire undo or redo stack and destroy all elements in it.
+ *	Clear an entire undo or redo stack and destroy all elements in it.
  *
  * Results:
- *    None
+ *	None.
  *
  * Side effects:
- *    None.
+ *	None.
+ *
+ *----------------------------------------------------------------------
  */
 
-void TkUndoClearStack ( stack )
-    TkUndoAtom ** stack;      /* An Undo or Redo stack */
+void
+TkUndoClearStack(stack)
+    TkUndoAtom **stack;		/* An Undo or Redo stack */
 {
-    TkUndoAtom * elem;
-
-    while ( (elem = TkUndoPopStack(stack)) ) {
-        if ( elem->type != TK_UNDO_SEPARATOR ) {
-            Tcl_DecrRefCount(elem->apply);
-            Tcl_DecrRefCount(elem->revert);
-        }
-        ckfree((char *)elem);
+    TkUndoAtom *elem;
+
+    while ((elem = TkUndoPopStack(stack)) != NULL) {
+	if (elem->type != TK_UNDO_SEPARATOR) {
+	    Tcl_DecrRefCount(elem->apply);
+	    Tcl_DecrRefCount(elem->revert);
+	}
+	ckfree((char *)elem);
     }
     *stack = NULL;
 }
 
 /*
+ *----------------------------------------------------------------------
+ *
  * TkUndoPushAction
- *    Push a new elem on the stack identified by stack.
- *    action and revert are given through Tcl_Obj's to which
- *    we will retain a reference.  (So they can be passed in
- *    with a zero refCount if desired).
+ *	Push a new elem on the stack identified by stack.
+ *	action and revert are given through Tcl_Obj's to which
+ *	we will retain a reference.  (So they can be passed in
+ *	with a zero refCount if desired).
  *
  * Results:
- *    None
+ *	None.
  *
  * Side effects:
- *    None.
+ *	None.
+ *
+ *----------------------------------------------------------------------
  */
- 
-void TkUndoPushAction ( stack, actionScript, revertScript, isList )
-    TkUndoRedoStack *stack;   /* An Undo or Redo stack */
-    Tcl_Obj *actionScript;    /* The script to get the action (redo) */
-    Tcl_Obj *revertScript;    /* The script to revert the action (undo) */
-    int isList;               /* Are the given objects lists of scripts? */
+
+void
+TkUndoPushAction(stack, actionScript, revertScript, isList)
+    TkUndoRedoStack *stack;	/* An Undo or Redo stack */
+    Tcl_Obj *actionScript;	/* The script to get the action (redo) */
+    Tcl_Obj *revertScript;	/* The script to revert the action (undo) */
+    int isList;			/* Are the given objects lists of scripts? */
 { 
-    TkUndoAtom * atom;
+    TkUndoAtom *atom;
 
     atom = (TkUndoAtom *) ckalloc(sizeof(TkUndoAtom));
     if (isList) {
@@ -150,24 +173,29 @@ void TkUndoPushAction ( stack, actionScript, revertScript, isList )
     TkUndoPushStack(&(stack->undoStack), atom);
     TkUndoClearStack(&(stack->redoStack));
 }
-
 
 /*
+ *----------------------------------------------------------------------
+ *
  * TkUndoInitStack
- *    Initialize a new undo/redo stack
+ *	Initialize a new undo/redo stack.
  *
  * Results:
- *    un Undo/Redo stack pointer
+ *	An Undo/Redo stack pointer.
  *
  * Side effects:
- *    None.
+ *	None.
+ *
+ *----------------------------------------------------------------------
  */
- 
-TkUndoRedoStack * TkUndoInitStack ( interp, maxdepth )
-    Tcl_Interp * interp;          /* The interpreter */
-    int          maxdepth;        /* The maximum stack depth */
+
+TkUndoRedoStack *
+TkUndoInitStack(interp, maxdepth)
+    Tcl_Interp *interp;		/* The interpreter */
+    int maxdepth;		/* The maximum stack depth */
 { 
-    TkUndoRedoStack * stack;      /* An Undo/Redo stack */
+    TkUndoRedoStack *stack;	/* An Undo/Redo stack */
+
     stack = (TkUndoRedoStack *) ckalloc(sizeof(TkUndoRedoStack));
     stack->undoStack = NULL;
     stack->redoStack = NULL;
@@ -176,153 +204,178 @@ TkUndoRedoStack * TkUndoInitStack ( interp, maxdepth )
     stack->depth     = 0;
     return stack;
 }
-
 
 /*
+ *----------------------------------------------------------------------
+ *
  * TkUndoInitStack
- *    Initialize a new undo/redo stack
+ *	Initialize a new undo/redo stack.
  *
  * Results:
- *    un Undo/Redo stack pointer
+ *	An Undo/Redo stack pointer.
  *
  * Side effects:
- *    None.
+ *	None.
+ *
+ *----------------------------------------------------------------------
  */
- 
-void TkUndoSetDepth ( stack, maxdepth )
-    TkUndoRedoStack * stack;           /* An Undo/Redo stack */
-    int               maxdepth;        /* The maximum stack depth */
+
+void
+TkUndoSetDepth(stack, maxdepth)
+    TkUndoRedoStack *stack;	/* An Undo/Redo stack */
+    int maxdepth;		/* The maximum stack depth */
 {
-    TkUndoAtom * elem;
-    TkUndoAtom * prevelem;
+    TkUndoAtom *elem, *prevelem;
     int sepNumber = 0;
-    
+
     stack->maxdepth = maxdepth;
 
-    if ((stack->maxdepth > 0) && (stack->depth > stack->maxdepth)) {
-        /* Maximum stack depth exceeded. We have to remove the last compound
-           elements on the stack */
-        elem = stack->undoStack;
-        prevelem = NULL;
-        while ( sepNumber <= stack->maxdepth ) {
-            if (elem != NULL && (elem->type == TK_UNDO_SEPARATOR) ) {
-                sepNumber++;
-            }
-            prevelem = elem;
-            elem = elem->next;
-        }
-        prevelem->next = NULL;
-        while ( elem ) {
-           prevelem = elem;
-           elem = elem->next;
-           ckfree((char *) elem);
-        }
-        stack->depth = stack->maxdepth;
+    if (stack->maxdepth>0 && stack->depth>stack->maxdepth) {
+	/*
+	 * Maximum stack depth exceeded. We have to remove the last
+	 * compound elements on the stack
+	 */
+
+	elem = stack->undoStack;
+	prevelem = NULL;
+	while (sepNumber <= stack->maxdepth) {
+	    if (elem!=NULL && elem->type==TK_UNDO_SEPARATOR) {
+		sepNumber++;
+	    }
+	    prevelem = elem;
+	    elem = elem->next;
+	}
+	prevelem->next = NULL;
+	while (elem != NULL) {
+	    prevelem = elem;
+	    elem = elem->next;
+	    ckfree((char *) elem);
+	}
+	stack->depth = stack->maxdepth;
     }
 }
-
 
 /*
+ *----------------------------------------------------------------------
+ *
  * TkUndoClearStacks
- *    Clear both the undo and redo stack
+ *	Clear both the undo and redo stack.
  *
  * Results:
- *    None
+ *	None.
  *
  * Side effects:
- *    None.
+ *	None.
+ *
+ *----------------------------------------------------------------------
  */
- 
-void TkUndoClearStacks ( stack )
-    TkUndoRedoStack * stack;      /* An Undo/Redo stack */
+
+void
+TkUndoClearStacks(stack)
+    TkUndoRedoStack *stack;	/* An Undo/Redo stack */
 { 
     TkUndoClearStack(&(stack->undoStack));
     TkUndoClearStack(&(stack->redoStack));
     stack->depth = 0;
 }
-
 
 /*
+ *----------------------------------------------------------------------
+ *
  * TkUndoFreeStack
- *    Clear both the undo and redo stack
- *    also free the memory allocated to the u/r stack pointer
+ *	Clear both the undo and redo stack and free the memory
+ *	allocated to the u/r stack pointer.
  *
  * Results:
- *    None
+ *	None.
  *
  * Side effects:
- *    None.
+ *	None.
+ *
+ *----------------------------------------------------------------------
  */
- 
-void TkUndoFreeStack ( stack )
-    TkUndoRedoStack * stack;      /* An Undo/Redo stack */
+
+void
+TkUndoFreeStack(stack)
+    TkUndoRedoStack *stack;	/* An Undo/Redo stack */
 { 
    TkUndoClearStacks(stack);
-/*   ckfree((TkUndoRedoStack *) stack); */
+   /* ckfree((TkUndoRedoStack *) stack); */
    ckfree((char *) stack);
 }
-
 
 /*
+ *----------------------------------------------------------------------
+ *
  * TkUndoInsertUndoSeparator --
- *    insert a separator on the undo stack, indicating a border for
- *      an undo/redo chunk.
+ *	Insert a separator on the undo stack, indicating a border for
+ *	an undo/redo chunk.
  *
  * Results:
- *    None
+ *	None.
  *
  * Side effects:
- *    None.
+ *	None.
+ *
+ *----------------------------------------------------------------------
  */
- 
-void TkUndoInsertUndoSeparator ( stack )
-    TkUndoRedoStack * stack;
+
+void
+TkUndoInsertUndoSeparator(stack)
+    TkUndoRedoStack *stack;
 {
-/*    TkUndoAtom * elem;
-    TkUndoAtom * prevelem;
-    int sepNumber = 0;
-*/
-    
-    if ( TkUndoInsertSeparator(&(stack->undoStack)) ) {
-        ++(stack->depth);
-        TkUndoSetDepth(stack,stack->maxdepth);
-/*        if ((stack->maxdepth > 0) && (stack->depth > stack->maxdepth)) {
-            elem = stack->undoStack;
-            prevelem = NULL;
-            while ( sepNumber < stack->depth ) {
-                if (elem != NULL && (elem->type == TK_UNDO_SEPARATOR) ) {
-                    sepNumber++;
-                }
-                prevelem = elem;
-                elem = elem->next;
-            }
-            prevelem->next = NULL;
-            while ( elem ) {
-               prevelem = elem;
-               elem = elem->next;
-               ckfree((char *) elem);
-            }
-            stack->depth;
-        } */
+    /*
+     * TkUndoAtom * elem;
+     * TkUndoAtom * prevelem;
+     * int sepNumber = 0;
+     */
+
+    if (TkUndoInsertSeparator(&(stack->undoStack))) {
+	stack->depth++;
+	TkUndoSetDepth(stack, stack->maxdepth);
+#if 0
+	if (stack->maxdepth>0 && stack->depth>stack->maxdepth) {
+	    elem = stack->undoStack;
+	    prevelem = NULL;
+	    while (sepNumber < stack->depth) {
+		if (elem!=NULL && elem->type==TK_UNDO_SEPARATOR) {
+		    sepNumber++;
+		}
+		prevelem = elem;
+		elem = elem->next;
+	    }
+	    prevelem->next = NULL;
+	    while (elem) {
+		prevelem = elem;
+		elem = elem->next;
+		ckfree((char *) elem);
+	    }
+	    stack->depth;
+	}
+#endif
     }
 }
-
 
 /*
+ *----------------------------------------------------------------------
+ *
  * TkUndoRevert --
- *    Undo a compound action on the stack.
+ *	Undo a compound action on the stack.
  *
  * Results:
- *    A TCL status code
+ *	A Tcl status code
  *
  * Side effects:
- *    None.
+ *	None.
+ *
+ *----------------------------------------------------------------------
  */
- 
-int TkUndoRevert ( stack )
-    TkUndoRedoStack * stack;
+
+int
+TkUndoRevert(stack)
+    TkUndoRedoStack *stack;
 {
-    TkUndoAtom * elem;
+    TkUndoAtom *elem;
 
     /* insert a separator on the undo and the redo stack */
 
@@ -333,44 +386,49 @@ int TkUndoRevert ( stack )
 
     elem = TkUndoPopStack(&(stack->undoStack));
 
-    if ( elem == NULL ) {
-        return TCL_ERROR;
+    if (elem == NULL) {
+	return TCL_ERROR;
     }
 
-    if ( ( elem != NULL ) && ( elem->type == TK_UNDO_SEPARATOR ) ) {
-        ckfree((char *) elem);
-        elem = TkUndoPopStack(&(stack->undoStack));
+    if (elem!=NULL && elem->type==TK_UNDO_SEPARATOR) {
+	ckfree((char *) elem);
+	elem = TkUndoPopStack(&(stack->undoStack));
     }
-    
-    while ( elem && (elem->type != TK_UNDO_SEPARATOR) ) {
+
+    while (elem!=NULL && elem->type!=TK_UNDO_SEPARATOR) {
 	UndoScriptsEvaluate(stack->interp,elem->revert,elem->type);
-        
-        TkUndoPushStack(&(stack->redoStack),elem);
-        elem = TkUndoPopStack(&(stack->undoStack));
+
+	TkUndoPushStack(&(stack->redoStack),elem);
+	elem = TkUndoPopStack(&(stack->undoStack));
     }
-    
+
     /* insert a separator on the redo stack */
-    
+
     TkUndoInsertSeparator(&(stack->redoStack));
-    
-    --(stack->depth);
-    
+
+    stack->depth--;
+
     return TCL_OK;
 }
 
 /*
+ *----------------------------------------------------------------------
+ *
  * TkUndoApply --
- *    Redo a compound action on the stack.
+ *	Redo a compound action on the stack.
  *
  * Results:
- *    A TCL status code
+ *	A Tcl status code
  *
  * Side effects:
- *    None.
+ *	None.
+ *
+ *----------------------------------------------------------------------
  */
- 
-int TkUndoApply ( stack )
-    TkUndoRedoStack * stack;
+
+int
+TkUndoApply(stack)
+    TkUndoRedoStack *stack;
 {
     TkUndoAtom *elem;
 
@@ -382,42 +440,46 @@ int TkUndoApply ( stack )
 
     elem = TkUndoPopStack(&(stack->redoStack));
 
-    if ( elem == NULL ) {
-       return TCL_ERROR;
+    if (elem == NULL) {
+	return TCL_ERROR;
     }
 
-    if ( ( elem != NULL ) && ( elem->type == TK_UNDO_SEPARATOR ) ) {
-        ckfree((char *) elem);
-        elem = TkUndoPopStack(&(stack->redoStack));
+    if (elem!=NULL && elem->type==TK_UNDO_SEPARATOR) {
+	ckfree((char *) elem);
+	elem = TkUndoPopStack(&(stack->redoStack));
     }
 
-    while ( elem && (elem->type != TK_UNDO_SEPARATOR) ) {
+    while (elem!=NULL && elem->type!=TK_UNDO_SEPARATOR) {
 	UndoScriptsEvaluate(stack->interp,elem->apply,elem->type);
-        
-        TkUndoPushStack(&(stack->undoStack), elem);
-        elem = TkUndoPopStack(&(stack->redoStack));
+
+	TkUndoPushStack(&(stack->undoStack), elem);
+	elem = TkUndoPopStack(&(stack->redoStack));
     }
 
     /* insert a separator on the undo stack */
-    
+
     TkUndoInsertSeparator(&(stack->undoStack));
 
-    ++(stack->depth);
-    
+    stack->depth++;
+
     return TCL_OK;
 }
-
 
 /*
+ *----------------------------------------------------------------------
+ *
  * UndoScriptsEvaluate --
- *    Execute either a single script, or a set of scripts
+ *	Execute either a single script, or a set of scripts
  *
  * Results:
- *    A TCL status code
+ *	A Tcl status code
  *
  * Side effects:
- *    None.
+ *	None.
+ *
+ *----------------------------------------------------------------------
  */
+
 static int 
 UndoScriptsEvaluate(interp, objPtr, type)
     Tcl_Interp *interp;
@@ -428,19 +490,18 @@ UndoScriptsEvaluate(interp, objPtr, type)
 	int objc;
 	Tcl_Obj **objv;
 	int res, i;
+
 	res = Tcl_ListObjGetElements(interp, objPtr, &objc, &objv);
 	if (res != TCL_OK) {
 	    return res;
 	}
-	for (i=0;i<objc;i++) {
+	for (i=0 ; i<objc ; i++) {
 	    res = Tcl_EvalObjEx(interp, objv[i], TCL_EVAL_GLOBAL);
 	    if (res != TCL_OK) {
-	        return res;
+		return res;
 	    }
 	}
 	return res;
-    } else {
-	return Tcl_EvalObjEx(interp, objPtr, TCL_EVAL_GLOBAL);
     }
+    return Tcl_EvalObjEx(interp, objPtr, TCL_EVAL_GLOBAL);
 }
-