From 3af1ae2a76b789f89793d64b8d6eff7f9c24ca75 Mon Sep 17 00:00:00 2001 From: "Thomas E. Dickey" Date: Sun, 14 Jul 2019 14:45:28 -0400 Subject: indent'd like "x-indent.sh", but with a more complete set of typedefs - see https://github.com/ThomasDickey/cindent-snapshots/blob/master/scripts/xxx-profile Signed-off-by: Thomas E. Dickey --- src/TMaction.c | 1285 +++++++++++++++++++++++++++----------------------------- 1 file changed, 624 insertions(+), 661 deletions(-) (limited to 'src/TMaction.c') diff --git a/src/TMaction.c b/src/TMaction.c index a8122f7..b4c522b 100644 --- a/src/TMaction.c +++ b/src/TMaction.c @@ -1,5 +1,3 @@ -/*LINTLIBRARY*/ - /*********************************************************** Copyright (c) 1993, Oracle and/or its affiliates. All rights reserved. @@ -85,220 +83,220 @@ in this Software without prior written authorization from The Open Group. #else #define RConst /**/ #endif - static _Xconst _XtString XtNtranslationError = "translationError"; -typedef struct _CompiledAction{ - XrmQuark signature; - XtActionProc proc; -}CompiledAction, *CompiledActionTable; - +typedef struct _CompiledAction { + XrmQuark signature; + XtActionProc proc; +} CompiledAction, *CompiledActionTable; #define GetClassActions(wc) \ - ((wc->core_class.actions) \ -? (((TMClassCache)wc->core_class.actions)->actions) \ -: NULL) - -static CompiledActionTable CompileActionTable( - register RConst struct _XtActionsRec *actions, - register Cardinal count, /* may be 0 */ - Boolean stat, /* if False, copy before compiling in place */ - Boolean perm) /* if False, use XrmStringToQuark */ + ((wc->core_class.actions) \ + ? (((TMClassCache)wc->core_class.actions)->actions) \ + : NULL) + +static CompiledActionTable +CompileActionTable(register RConst struct _XtActionsRec *actions, register Cardinal count, /* may be 0 */ + Boolean stat, /* if False, copy before compiling in place */ + Boolean perm) /* if False, use XrmStringToQuark */ { register CompiledActionTable cActions; register int i; CompiledAction hold; CompiledActionTable cTableHold; - XrmQuark (*func)(_Xconst char*); + XrmQuark (*func) (_Xconst char *); if (!count) - return (CompiledActionTable) NULL; + return (CompiledActionTable) NULL; func = (perm ? XrmPermStringToQuark : XrmStringToQuark); - if (! stat) { - cTableHold = cActions = (CompiledActionTable) - __XtMalloc((Cardinal)((size_t)count * sizeof(CompiledAction))); + if (!stat) { + cTableHold = cActions = (CompiledActionTable) + __XtMalloc((Cardinal) ((size_t) count * sizeof(CompiledAction))); - for (i= (int)count; --i >= 0; cActions++, actions++) { - cActions->proc = actions->proc; - cActions->signature = (*func)(actions->string); - } - } else { - cTableHold = (CompiledActionTable) actions; + for (i = (int) count; --i >= 0; cActions++, actions++) { + cActions->proc = actions->proc; + cActions->signature = (*func) (actions->string); + } + } + else { + cTableHold = (CompiledActionTable) actions; - for (i= (int)count; --i >= 0; actions++) - ((CompiledActionTable) actions)->signature = - (*func)(actions->string); + for (i = (int) count; --i >= 0; actions++) + ((CompiledActionTable) actions)->signature = + (*func) (actions->string); } cActions = cTableHold; /* Insertion sort. Whatever sort is used, it must be stable. */ - for (i=1; (Cardinal) i <= count - 1; i++) { - register Cardinal j; - hold = cActions[i]; - j = (Cardinal)i; - while (j && cActions[j-1].signature > hold.signature) { - cActions[j] = cActions[j-1]; - j--; - } - cActions[j] = hold; + for (i = 1; (Cardinal) i <= count - 1; i++) { + register Cardinal j; + + hold = cActions[i]; + j = (Cardinal) i; + while (j && cActions[j - 1].signature > hold.signature) { + cActions[j] = cActions[j - 1]; + j--; + } + cActions[j] = hold; } return cActions; } - typedef struct _ActionListRec *ActionList; typedef struct _ActionListRec { - ActionList next; + ActionList next; CompiledActionTable table; - TMShortCard count; + TMShortCard count; } ActionListRec; -static void ReportUnboundActions( - XtTranslations xlations, - TMBindData bindData) +static void +ReportUnboundActions(XtTranslations xlations, TMBindData bindData) { - TMSimpleStateTree stateTree; + TMSimpleStateTree stateTree; Cardinal num_unbound = 0; Cardinal num_params = 1; - char* message; + char *message; char messagebuf[1000]; register Cardinal num_chars = 0; register Cardinal i, j; XtActionProc *procs; - for (i=0; i < xlations->numStateTrees; i++) { - if (bindData->simple.isComplex) - procs = TMGetComplexBindEntry(bindData, i)->procs; - else - procs = TMGetSimpleBindEntry(bindData, i)->procs; - - stateTree = (TMSimpleStateTree)xlations->stateTreeTbl[i]; - for (j=0; j < stateTree->numQuarks; j++) { - if (procs[j] == NULL) { - String s = XrmQuarkToString(stateTree->quarkTbl[j]); - if (num_unbound != 0) - num_chars += 2; - num_chars += (Cardinal)strlen(s); - num_unbound++; - } - } + for (i = 0; i < xlations->numStateTrees; i++) { + if (bindData->simple.isComplex) + procs = TMGetComplexBindEntry(bindData, i)->procs; + else + procs = TMGetSimpleBindEntry(bindData, i)->procs; + + stateTree = (TMSimpleStateTree) xlations->stateTreeTbl[i]; + for (j = 0; j < stateTree->numQuarks; j++) { + if (procs[j] == NULL) { + String s = XrmQuarkToString(stateTree->quarkTbl[j]); + + if (num_unbound != 0) + num_chars += 2; + num_chars += (Cardinal) strlen(s); + num_unbound++; + } + } } if (num_unbound == 0) - return; - message = XtStackAlloc (num_chars + 1, messagebuf); + return; + message = XtStackAlloc(num_chars + 1, messagebuf); if (message != NULL) { - String params[1]; - - *message = '\0'; - num_unbound = 0; - for (i=0; i < xlations->numStateTrees; i++) { - if (bindData->simple.isComplex) - procs = TMGetComplexBindEntry(bindData, i)->procs; - else - procs = TMGetSimpleBindEntry(bindData, i)->procs; - - stateTree = (TMSimpleStateTree)xlations->stateTreeTbl[i]; - for (j=0; j < stateTree->numQuarks; j++) { - if (procs[j] == NULL) { - String s = XrmQuarkToString(stateTree->quarkTbl[j]); - if (num_unbound != 0) - (void) strcat(message, ", "); - (void) strcat(message, s); - num_unbound++; - } - } - } - message[num_chars] = '\0'; - params[0] = message; - XtWarningMsg(XtNtranslationError,"unboundActions",XtCXtToolkitError, - "Actions not found: %s", - params, &num_params); - XtStackFree (message, messagebuf); + String params[1]; + + *message = '\0'; + num_unbound = 0; + for (i = 0; i < xlations->numStateTrees; i++) { + if (bindData->simple.isComplex) + procs = TMGetComplexBindEntry(bindData, i)->procs; + else + procs = TMGetSimpleBindEntry(bindData, i)->procs; + + stateTree = (TMSimpleStateTree) xlations->stateTreeTbl[i]; + for (j = 0; j < stateTree->numQuarks; j++) { + if (procs[j] == NULL) { + String s = XrmQuarkToString(stateTree->quarkTbl[j]); + + if (num_unbound != 0) + (void) strcat(message, ", "); + (void) strcat(message, s); + num_unbound++; + } + } + } + message[num_chars] = '\0'; + params[0] = message; + XtWarningMsg(XtNtranslationError, "unboundActions", XtCXtToolkitError, + "Actions not found: %s", params, &num_params); + XtStackFree(message, messagebuf); } } - -static CompiledAction *SearchActionTable( - XrmQuark signature, - CompiledActionTable actionTable, - Cardinal numActions) +static CompiledAction * +SearchActionTable(XrmQuark signature, + CompiledActionTable actionTable, + Cardinal numActions) { int left, right; left = 0; - right = (int)numActions - 1; + right = (int) numActions - 1; while (left <= right) { - int i = (left + right) >> 1; - if (signature < actionTable[i].signature) - right = i - 1; - else if (signature > actionTable[i].signature) - left = i + 1; - else { - while (i && actionTable[i - 1].signature == signature) - i--; - return &actionTable[i]; - } + int i = (left + right) >> 1; + + if (signature < actionTable[i].signature) + right = i - 1; + else if (signature > actionTable[i].signature) + left = i + 1; + else { + while (i && actionTable[i - 1].signature == signature) + i--; + return &actionTable[i]; + } } return (CompiledAction *) NULL; } -static int BindActions( - TMSimpleStateTree stateTree, - XtActionProc *procs, - CompiledActionTable compiledActionTable, - TMShortCard numActions, - Cardinal *ndxP) +static int +BindActions(TMSimpleStateTree stateTree, + XtActionProc * procs, + CompiledActionTable compiledActionTable, + TMShortCard numActions, + Cardinal * ndxP) { - register int unbound = (int)(stateTree->numQuarks - *ndxP); - CompiledAction* action; + register int unbound = (int) (stateTree->numQuarks - *ndxP); + CompiledAction *action; register Cardinal ndx; register Boolean savedNdx = False; for (ndx = *ndxP; ndx < stateTree->numQuarks; ndx++) { - if (procs[ndx] == NULL) { - /* attempt to bind it */ - XrmQuark q = stateTree->quarkTbl[ndx]; - - action = SearchActionTable(q, compiledActionTable, numActions); - if (action) { - procs[ndx] = action->proc; - unbound--; - } else if (!savedNdx) { - *ndxP= ndx; - savedNdx = True; - } - } else { - /* already bound, leave it alone */ - unbound--; - } + if (procs[ndx] == NULL) { + /* attempt to bind it */ + XrmQuark q = stateTree->quarkTbl[ndx]; + + action = SearchActionTable(q, compiledActionTable, numActions); + if (action) { + procs[ndx] = action->proc; + unbound--; + } + else if (!savedNdx) { + *ndxP = ndx; + savedNdx = True; + } + } + else { + /* already bound, leave it alone */ + unbound--; + } } return unbound; } -typedef struct _TMBindCacheStatusRec{ - unsigned int boundInClass:1; - unsigned int boundInHierarchy:1; - unsigned int boundInContext:1; - unsigned int notFullyBound:1; - unsigned int refCount:28; -}TMBindCacheStatusRec, *TMBindCacheStatus; +typedef struct _TMBindCacheStatusRec { + unsigned int boundInClass:1; + unsigned int boundInHierarchy:1; + unsigned int boundInContext:1; + unsigned int notFullyBound:1; + unsigned int refCount:28; +} TMBindCacheStatusRec, *TMBindCacheStatus; -typedef struct _TMBindCacheRec{ +typedef struct _TMBindCacheRec { struct _TMBindCacheRec *next; TMBindCacheStatusRec status; - TMStateTree stateTree; + TMStateTree stateTree; #ifdef TRACE_TM - WidgetClass widgetClass; -#endif /* TRACE_TM */ - XtActionProc procs[1]; /* variable length */ -}TMBindCacheRec, *TMBindCache; + WidgetClass widgetClass; +#endif /* TRACE_TM */ + XtActionProc procs[1]; /* variable length */ +} TMBindCacheRec, *TMBindCache; typedef struct _TMClassCacheRec { - CompiledActionTable actions; - TMBindCacheRec *bindCache; -}TMClassCacheRec, *TMClassCache; + CompiledActionTable actions; + TMBindCacheRec *bindCache; +} TMClassCacheRec, *TMClassCache; #define IsPureClassBind(bc) \ (bc->status.boundInClass && \ @@ -309,464 +307,428 @@ typedef struct _TMClassCacheRec { #define GetClassCache(w) \ ((TMClassCache)w->core.widget_class->core_class.actions) - -static int BindProcs( - Widget widget, - TMSimpleStateTree stateTree, - XtActionProc *procs, - TMBindCacheStatus bindStatus) +static int +BindProcs(Widget widget, + TMSimpleStateTree stateTree, + XtActionProc * procs, + TMBindCacheStatus bindStatus) { - register WidgetClass class; - register ActionList actionList; - int unbound = -1, newUnbound = -1; - Cardinal ndx = 0; - Widget w = widget; + register WidgetClass class; + register ActionList actionList; + int unbound = -1, newUnbound = -1; + Cardinal ndx = 0; + Widget w = widget; LOCK_PROCESS; do { class = w->core.widget_class; do { if (class->core_class.actions != NULL) - unbound = - BindActions(stateTree, - procs, - GetClassActions(class), - (TMShortCard) class->core_class.num_actions, - &ndx); - class = class->core_class.superclass; + unbound = + BindActions(stateTree, + procs, + GetClassActions(class), + (TMShortCard) class->core_class.num_actions, + &ndx); + class = class->core_class.superclass; } while (unbound != 0 && class != NULL); - if (unbound < (int)stateTree->numQuarks) - bindStatus->boundInClass = True; - else - bindStatus->boundInClass = False; - if (newUnbound == -1) - newUnbound = unbound; - w = XtParent(w); + if (unbound < (int) stateTree->numQuarks) + bindStatus->boundInClass = True; + else + bindStatus->boundInClass = False; + if (newUnbound == -1) + newUnbound = unbound; + w = XtParent(w); } while (unbound != 0 && w != NULL); if (newUnbound > unbound) - bindStatus->boundInHierarchy = True; + bindStatus->boundInHierarchy = True; else - bindStatus->boundInHierarchy = False; + bindStatus->boundInHierarchy = False; if (unbound) { - XtAppContext app = XtWidgetToApplicationContext(widget); - newUnbound = unbound; - for (actionList = app->action_table; - unbound != 0 && actionList != NULL; - actionList = actionList->next) { - unbound = BindActions(stateTree, - procs, - actionList->table, - actionList->count, - &ndx); - } - if (newUnbound > unbound) - bindStatus->boundInContext = True; - else - bindStatus->boundInContext = False; - - } else { - bindStatus->boundInContext = False; + XtAppContext app = XtWidgetToApplicationContext(widget); + + newUnbound = unbound; + for (actionList = app->action_table; + unbound != 0 && actionList != NULL; + actionList = actionList->next) { + unbound = BindActions(stateTree, + procs, + actionList->table, actionList->count, &ndx); + } + if (newUnbound > unbound) + bindStatus->boundInContext = True; + else + bindStatus->boundInContext = False; + + } + else { + bindStatus->boundInContext = False; } UNLOCK_PROCESS; return unbound; } -static XtActionProc *TryBindCache( - Widget widget, - TMStateTree stateTree) +static XtActionProc * +TryBindCache(Widget widget, TMStateTree stateTree) { - TMClassCache classCache; + TMClassCache classCache; LOCK_PROCESS; classCache = GetClassCache(widget); - if (classCache == NULL) - { - WidgetClass wc = XtClass(widget); + if (classCache == NULL) { + WidgetClass wc = XtClass(widget); - wc->core_class.actions = (XtActionList) - _XtInitializeActionData(NULL, 0, True); - } - else - { - TMBindCache bindCache = - (TMBindCache)(classCache->bindCache); - for (; bindCache; bindCache = bindCache->next) - { - if (IsPureClassBind(bindCache) && - (stateTree == bindCache->stateTree)) - { - bindCache->status.refCount++; - UNLOCK_PROCESS; - return &bindCache->procs[0]; - } - } - } + wc->core_class.actions = (XtActionList) + _XtInitializeActionData(NULL, 0, True); + } + else { + TMBindCache bindCache = (TMBindCache) (classCache->bindCache); + + for (; bindCache; bindCache = bindCache->next) { + if (IsPureClassBind(bindCache) && + (stateTree == bindCache->stateTree)) { + bindCache->status.refCount++; + UNLOCK_PROCESS; + return &bindCache->procs[0]; + } + } + } UNLOCK_PROCESS; return NULL; } - - /* * The class record actions field will point to the bind cache header * after this call is made out of coreClassPartInit. */ -XtPointer _XtInitializeActionData( - register struct _XtActionsRec *actions, - register Cardinal count, - _XtBoolean inPlace) +XtPointer +_XtInitializeActionData(register struct _XtActionsRec * actions, + register Cardinal count, + _XtBoolean inPlace) { - TMClassCache classCache; + TMClassCache classCache; classCache = XtNew(TMClassCacheRec); - classCache->actions = CompileActionTable(actions, count, (Boolean) inPlace, True); + classCache->actions = + CompileActionTable(actions, count, (Boolean) inPlace, True); classCache->bindCache = NULL; - return (XtPointer)classCache; + return (XtPointer) classCache; } +#define TM_BIND_CACHE_REALLOC 2 -#define TM_BIND_CACHE_REALLOC 2 - -static XtActionProc *EnterBindCache( - Widget w, - TMSimpleStateTree stateTree, - XtActionProc *procs, - TMBindCacheStatus bindStatus) +static XtActionProc * +EnterBindCache(Widget w, + TMSimpleStateTree stateTree, + XtActionProc * procs, + TMBindCacheStatus bindStatus) { - TMClassCache classCache; - TMBindCache* bindCachePtr; - TMShortCard procsSize; - TMBindCache bindCache; + TMClassCache classCache; + TMBindCache *bindCachePtr; + TMShortCard procsSize; + TMBindCache bindCache; LOCK_PROCESS; classCache = GetClassCache(w); bindCachePtr = &classCache->bindCache; - procsSize = (TMShortCard)(stateTree->numQuarks * sizeof(XtActionProc)); + procsSize = (TMShortCard) (stateTree->numQuarks * sizeof(XtActionProc)); for (bindCache = *bindCachePtr; - (*bindCachePtr); - bindCachePtr = &(*bindCachePtr)->next, bindCache = *bindCachePtr) - { - TMBindCacheStatus cacheStatus = &bindCache->status; - - if ((bindStatus->boundInClass == cacheStatus->boundInClass) && - (bindStatus->boundInHierarchy == cacheStatus->boundInHierarchy) && - (bindStatus->boundInContext == cacheStatus->boundInContext) && - (bindCache->stateTree == (TMStateTree)stateTree) && - !XtMemcmp(&bindCache->procs[0], procs, procsSize)) - { - bindCache->status.refCount++; - break; - } - } - if (*bindCachePtr == NULL) - { - *bindCachePtr = - bindCache = (TMBindCache) - __XtMalloc((Cardinal)(sizeof(TMBindCacheRec) + - (size_t)(procsSize - sizeof(XtActionProc)))); - bindCache->next = NULL; - bindCache->status = *bindStatus; - bindCache->status.refCount = 1; - bindCache->stateTree = (TMStateTree)stateTree; + (*bindCachePtr); + bindCachePtr = &(*bindCachePtr)->next, bindCache = *bindCachePtr) { + TMBindCacheStatus cacheStatus = &bindCache->status; + + if ((bindStatus->boundInClass == cacheStatus->boundInClass) && + (bindStatus->boundInHierarchy == cacheStatus->boundInHierarchy) && + (bindStatus->boundInContext == cacheStatus->boundInContext) && + (bindCache->stateTree == (TMStateTree) stateTree) && + !XtMemcmp(&bindCache->procs[0], procs, procsSize)) { + bindCache->status.refCount++; + break; + } + } + if (*bindCachePtr == NULL) { + *bindCachePtr = bindCache = (TMBindCache) + __XtMalloc((Cardinal) (sizeof(TMBindCacheRec) + + (size_t) (procsSize - + sizeof(XtActionProc)))); + bindCache->next = NULL; + bindCache->status = *bindStatus; + bindCache->status.refCount = 1; + bindCache->stateTree = (TMStateTree) stateTree; #ifdef TRACE_TM - bindCache->widgetClass = XtClass(w); - if (_XtGlobalTM.numBindCache == _XtGlobalTM.bindCacheTblSize) - { - _XtGlobalTM.bindCacheTblSize = - (TMShortCard)(_XtGlobalTM.bindCacheTblSize + 16); - _XtGlobalTM.bindCacheTbl = (TMBindCache *) - XtRealloc((char *)_XtGlobalTM.bindCacheTbl, - (Cardinal)((_XtGlobalTM.bindCacheTblSize) * - sizeof(TMBindCache))); - } - _XtGlobalTM.bindCacheTbl[_XtGlobalTM.numBindCache++] = bindCache; -#endif /* TRACE_TM */ - XtMemmove((XtPointer)&bindCache->procs[0], - (XtPointer)procs, procsSize); - } + bindCache->widgetClass = XtClass(w); + if (_XtGlobalTM.numBindCache == _XtGlobalTM.bindCacheTblSize) { + _XtGlobalTM.bindCacheTblSize = + (TMShortCard) (_XtGlobalTM.bindCacheTblSize + 16); + _XtGlobalTM.bindCacheTbl = (TMBindCache *) + XtRealloc((char *) _XtGlobalTM.bindCacheTbl, + (Cardinal) ((_XtGlobalTM.bindCacheTblSize) * + sizeof(TMBindCache))); + } + _XtGlobalTM.bindCacheTbl[_XtGlobalTM.numBindCache++] = bindCache; +#endif /* TRACE_TM */ + XtMemmove((XtPointer) & bindCache->procs[0], + (XtPointer) procs, procsSize); + } UNLOCK_PROCESS; return &bindCache->procs[0]; } -static void RemoveFromBindCache( - Widget w, - XtActionProc *procs) +static void +RemoveFromBindCache(Widget w, XtActionProc * procs) { - TMClassCache classCache; - TMBindCache* bindCachePtr; - TMBindCache bindCache; - XtAppContext app = XtWidgetToApplicationContext (w); + TMClassCache classCache; + TMBindCache *bindCachePtr; + TMBindCache bindCache; + XtAppContext app = XtWidgetToApplicationContext(w); LOCK_PROCESS; classCache = GetClassCache(w); - bindCachePtr = (TMBindCache *)&classCache->bindCache; + bindCachePtr = (TMBindCache *) & classCache->bindCache; for (bindCache = *bindCachePtr; - *bindCachePtr; - bindCachePtr = &(*bindCachePtr)->next, bindCache = *bindCachePtr) - { - if (&bindCache->procs[0] == procs) - { - if (--bindCache->status.refCount == 0) - { + *bindCachePtr; + bindCachePtr = &(*bindCachePtr)->next, bindCache = *bindCachePtr) { + if (&bindCache->procs[0] == procs) { + if (--bindCache->status.refCount == 0) { #ifdef TRACE_TM - TMShortCard j; - Boolean found = False; - TMBindCache *tbl = _XtGlobalTM.bindCacheTbl; - - for (j = 0; j < _XtGlobalTM.numBindCache; j++) { - if (found) - tbl[j-1] = tbl[j]; - if (tbl[j] == bindCache) - found = True; - } - if (!found) - XtWarning("where's the action ??? "); - else - _XtGlobalTM.numBindCache--; -#endif /* TRACE_TM */ - *bindCachePtr = bindCache->next; - bindCache->next = app->free_bindings; - app->free_bindings = bindCache; - } - break; - } - } - UNLOCK_PROCESS; + TMShortCard j; + Boolean found = False; + TMBindCache *tbl = _XtGlobalTM.bindCacheTbl; + + for (j = 0; j < _XtGlobalTM.numBindCache; j++) { + if (found) + tbl[j - 1] = tbl[j]; + if (tbl[j] == bindCache) + found = True; + } + if (!found) + XtWarning("where's the action ??? "); + else + _XtGlobalTM.numBindCache--; +#endif /* TRACE_TM */ + *bindCachePtr = bindCache->next; + bindCache->next = app->free_bindings; + app->free_bindings = bindCache; + } + break; + } + } + UNLOCK_PROCESS; } /* ARGSUSED */ -static void RemoveAccelerators( - Widget widget, - XtPointer closure, XtPointer data _X_UNUSED) +static void +RemoveAccelerators(Widget widget, XtPointer closure, XtPointer data _X_UNUSED) { - Widget destination = (Widget)closure; - TMComplexBindProcs bindProcs; - XtTranslations stackXlations[16]; - XtTranslations *xlationsList, destXlations; - TMShortCard i, numXlations = 0; + Widget destination = (Widget) closure; + TMComplexBindProcs bindProcs; + XtTranslations stackXlations[16]; + XtTranslations *xlationsList, destXlations; + TMShortCard i, numXlations = 0; if ((destXlations = destination->core.tm.translations) == NULL) { XtAppWarningMsg(XtWidgetToApplicationContext(widget), - XtNtranslationError,"nullTable",XtCXtToolkitError, - "Can't remove accelerators from NULL table", - NULL, NULL); + XtNtranslationError, "nullTable", XtCXtToolkitError, + "Can't remove accelerators from NULL table", + NULL, NULL); return; } xlationsList = (XtTranslations *) - XtStackAlloc((destXlations->numStateTrees * sizeof(XtTranslations)), - stackXlations); - - for (i = 0, bindProcs = TMGetComplexBindEntry(destination->core.tm.proc_table, i); - i < destXlations->numStateTrees; - i++, bindProcs++) { - if (bindProcs->widget == widget) { - /* - * if it's being destroyed don't do all the work - */ - if (destination->core.being_destroyed) { - bindProcs->procs = NULL; - } - else - xlationsList[numXlations] = bindProcs->aXlations; - numXlations++; - } + XtStackAlloc((destXlations->numStateTrees * sizeof(XtTranslations)), + stackXlations); + + for (i = 0, bindProcs = + TMGetComplexBindEntry(destination->core.tm.proc_table, i); + i < destXlations->numStateTrees; i++, bindProcs++) { + if (bindProcs->widget == widget) { + /* + * if it's being destroyed don't do all the work + */ + if (destination->core.being_destroyed) { + bindProcs->procs = NULL; + } + else + xlationsList[numXlations] = bindProcs->aXlations; + numXlations++; + } } if (numXlations == 0) - XtAppWarningMsg(XtWidgetToApplicationContext(widget), - XtNtranslationError,"nullTable",XtCXtToolkitError, - "Tried to remove nonexistent accelerators", - NULL, NULL); + XtAppWarningMsg(XtWidgetToApplicationContext(widget), + XtNtranslationError, "nullTable", XtCXtToolkitError, + "Tried to remove nonexistent accelerators", NULL, NULL); else { - if (!destination->core.being_destroyed) - for (i = 0; i < numXlations; i++) - _XtUnmergeTranslations(destination, xlationsList[i]); + if (!destination->core.being_destroyed) + for (i = 0; i < numXlations; i++) + _XtUnmergeTranslations(destination, xlationsList[i]); } - XtStackFree((char *)xlationsList, stackXlations); + XtStackFree((char *) xlationsList, stackXlations); } -void _XtBindActions( - Widget widget, - XtTM tm) +void +_XtBindActions(Widget widget, XtTM tm) { - XtTranslations xlations = tm->translations; - TMSimpleStateTree stateTree; - int globalUnbound = 0; - Cardinal i; - TMBindData bindData = (TMBindData)tm->proc_table; - TMSimpleBindProcs simpleBindProcs = NULL; - TMComplexBindProcs complexBindProcs = NULL; - XtActionProc *newProcs; - Widget bindWidget; + XtTranslations xlations = tm->translations; + TMSimpleStateTree stateTree; + int globalUnbound = 0; + Cardinal i; + TMBindData bindData = (TMBindData) tm->proc_table; + TMSimpleBindProcs simpleBindProcs = NULL; + TMComplexBindProcs complexBindProcs = NULL; + XtActionProc *newProcs; + Widget bindWidget; if ((xlations == NULL) || widget->core.being_destroyed) - return; - - for (i = 0; i < xlations->numStateTrees; i++) - { - stateTree = (TMSimpleStateTree)xlations->stateTreeTbl[i]; - if (bindData->simple.isComplex) { - complexBindProcs = TMGetComplexBindEntry(bindData, i); - if (complexBindProcs->widget) { - bindWidget = complexBindProcs->widget; - - if (bindWidget->core.destroy_callbacks != NULL) - _XtAddCallbackOnce((InternalCallbackList *) - &bindWidget->core.destroy_callbacks, - RemoveAccelerators, - (XtPointer)widget); - else - _XtAddCallback((InternalCallbackList *) - &bindWidget->core.destroy_callbacks, - RemoveAccelerators, - (XtPointer)widget); - } - else - bindWidget = widget; - } - else { - simpleBindProcs = TMGetSimpleBindEntry(bindData, i); - bindWidget = widget; - } - if ((newProcs = - TryBindCache(bindWidget,(TMStateTree)stateTree)) == NULL) - { - XtActionProc *procs, stackProcs[256]; - int localUnbound; - TMBindCacheStatusRec bcStatusRec; - - procs = (XtActionProc *) - XtStackAlloc(stateTree->numQuarks * sizeof(XtActionProc), - stackProcs); - XtBZero((XtPointer)procs, - stateTree->numQuarks * sizeof(XtActionProc)); - - localUnbound = BindProcs(bindWidget, - stateTree, - procs, - &bcStatusRec); - - if (localUnbound) - bcStatusRec.notFullyBound = True; - else - bcStatusRec.notFullyBound = False; - - newProcs = - EnterBindCache(bindWidget, - stateTree, - procs, - &bcStatusRec); - XtStackFree((XtPointer)procs, (XtPointer)stackProcs); - globalUnbound += localUnbound; - } - if (bindData->simple.isComplex) - complexBindProcs->procs = newProcs; - else - simpleBindProcs->procs = newProcs; - } + return; + + for (i = 0; i < xlations->numStateTrees; i++) { + stateTree = (TMSimpleStateTree) xlations->stateTreeTbl[i]; + if (bindData->simple.isComplex) { + complexBindProcs = TMGetComplexBindEntry(bindData, i); + if (complexBindProcs->widget) { + bindWidget = complexBindProcs->widget; + + if (bindWidget->core.destroy_callbacks != NULL) + _XtAddCallbackOnce((InternalCallbackList *) + & bindWidget->core.destroy_callbacks, + RemoveAccelerators, (XtPointer) widget); + else + _XtAddCallback((InternalCallbackList *) + & bindWidget->core.destroy_callbacks, + RemoveAccelerators, (XtPointer) widget); + } + else + bindWidget = widget; + } + else { + simpleBindProcs = TMGetSimpleBindEntry(bindData, i); + bindWidget = widget; + } + if ((newProcs = + TryBindCache(bindWidget, (TMStateTree) stateTree)) == NULL) { + XtActionProc *procs, stackProcs[256]; + int localUnbound; + TMBindCacheStatusRec bcStatusRec; + + procs = (XtActionProc *) + XtStackAlloc(stateTree->numQuarks * sizeof(XtActionProc), + stackProcs); + XtBZero((XtPointer) procs, + stateTree->numQuarks * sizeof(XtActionProc)); + + localUnbound = BindProcs(bindWidget, + stateTree, procs, &bcStatusRec); + + if (localUnbound) + bcStatusRec.notFullyBound = True; + else + bcStatusRec.notFullyBound = False; + + newProcs = + EnterBindCache(bindWidget, stateTree, procs, &bcStatusRec); + XtStackFree((XtPointer) procs, (XtPointer) stackProcs); + globalUnbound += localUnbound; + } + if (bindData->simple.isComplex) + complexBindProcs->procs = newProcs; + else + simpleBindProcs->procs = newProcs; + } if (globalUnbound) - ReportUnboundActions(xlations, - (TMBindData)tm->proc_table); + ReportUnboundActions(xlations, (TMBindData) tm->proc_table); } - -void _XtUnbindActions( - Widget widget, - XtTranslations xlations, - TMBindData bindData) +void +_XtUnbindActions(Widget widget, XtTranslations xlations, TMBindData bindData) { - Cardinal i; - Widget bindWidget; - XtActionProc *procs; + Cardinal i; + Widget bindWidget; + XtActionProc *procs; - if ((xlations == NULL) || !XtIsRealized(widget)) return; + if ((xlations == NULL) || !XtIsRealized(widget)) + return; for (i = 0; i < xlations->numStateTrees; i++) { - if (bindData->simple.isComplex) { - TMComplexBindProcs complexBindProcs; - - complexBindProcs = TMGetComplexBindEntry(bindData, i); - - if (complexBindProcs->widget) { - /* - * check for this being an accelerator binding whose - * source is gone ( set by RemoveAccelerators) - */ - if (complexBindProcs->procs == NULL) - continue; - - XtRemoveCallback(complexBindProcs->widget, - XtNdestroyCallback, - RemoveAccelerators, - (XtPointer)widget); - bindWidget = complexBindProcs->widget; - } - else - bindWidget = widget; - procs = complexBindProcs->procs; - complexBindProcs->procs = NULL; - } - else { - TMSimpleBindProcs simpleBindProcs; - simpleBindProcs = TMGetSimpleBindEntry(bindData,i); - procs = simpleBindProcs->procs; - simpleBindProcs->procs = NULL; - bindWidget = widget; - } - RemoveFromBindCache(bindWidget, procs); - } + if (bindData->simple.isComplex) { + TMComplexBindProcs complexBindProcs; + + complexBindProcs = TMGetComplexBindEntry(bindData, i); + + if (complexBindProcs->widget) { + /* + * check for this being an accelerator binding whose + * source is gone ( set by RemoveAccelerators) + */ + if (complexBindProcs->procs == NULL) + continue; + + XtRemoveCallback(complexBindProcs->widget, + XtNdestroyCallback, + RemoveAccelerators, (XtPointer) widget); + bindWidget = complexBindProcs->widget; + } + else + bindWidget = widget; + procs = complexBindProcs->procs; + complexBindProcs->procs = NULL; + } + else { + TMSimpleBindProcs simpleBindProcs; + + simpleBindProcs = TMGetSimpleBindEntry(bindData, i); + procs = simpleBindProcs->procs; + simpleBindProcs->procs = NULL; + bindWidget = widget; + } + RemoveFromBindCache(bindWidget, procs); + } } #ifdef notdef -void _XtRemoveBindProcsByIndex( - Widget w, - TMBindData bindData, - TMShortCard ndx) +void +_XtRemoveBindProcsByIndex(Widget w, TMBindData bindData, TMShortCard ndx) { - TMShortCard i = ndx; - TMBindProcs bindProcs = (TMBindProcs)&bindData->bindTbl[0]; + TMShortCard i = ndx; + TMBindProcs bindProcs = (TMBindProcs) & bindData->bindTbl[0]; RemoveFromBindCache(bindProcs->widget ? bindProcs->widget : w, - bindProcs[i].procs); + bindProcs[i].procs); for (; i < bindData->bindTblSize; i++) - bindProcs[i] = bindProcs[i+1]; + bindProcs[i] = bindProcs[i + 1]; } -#endif /* notdef */ +#endif /* notdef */ /* * used to free all copied action tables, called from DestroyAppContext */ -void _XtFreeActions( - ActionList actions) +void +_XtFreeActions(ActionList actions) { - ActionList curr, next; + ActionList curr, next; for (curr = actions; curr;) { - next = curr->next; - XtFree((char *)curr->table); - XtFree((char *)curr); - curr = next; + next = curr->next; + XtFree((char *) curr->table); + XtFree((char *) curr); + curr = next; } } -void XtAddActions( - XtActionList actions, - Cardinal num_actions) +void +XtAddActions(XtActionList actions, Cardinal num_actions) { XtAppAddActions(_XtDefaultAppContext(), actions, num_actions); } -void XtAppAddActions( - XtAppContext app, - XtActionList actions, - Cardinal num_actions) +void +XtAppAddActions(XtAppContext app, XtActionList actions, Cardinal num_actions) { register ActionList rec; @@ -779,10 +741,10 @@ void XtAppAddActions( UNLOCK_APP(app); } -void XtGetActionList( - WidgetClass widget_class, - XtActionList* actions_return, - Cardinal* num_actions_return) +void +XtGetActionList(WidgetClass widget_class, + XtActionList * actions_return, + Cardinal * num_actions_return) { CompiledActionTable table; @@ -790,28 +752,30 @@ void XtGetActionList( *num_actions_return = 0; LOCK_PROCESS; - if (! widget_class->core_class.class_inited) { - UNLOCK_PROCESS; - return; + if (!widget_class->core_class.class_inited) { + UNLOCK_PROCESS; + return; } - if (! (widget_class->core_class.class_inited & WidgetClassFlag)) { - UNLOCK_PROCESS; - return; + if (!(widget_class->core_class.class_inited & WidgetClassFlag)) { + UNLOCK_PROCESS; + return; } *num_actions_return = widget_class->core_class.num_actions; if (*num_actions_return) { - XtActionList list = *actions_return = (XtActionList) - __XtMalloc((Cardinal)((size_t)*num_actions_return * sizeof(XtActionsRec))); - - table = GetClassActions(widget_class); - - if (table != NULL) { - int i; - for (i= (int)(*num_actions_return); --i >= 0; list++, table++) { - list->string = XrmQuarkToString(table->signature); - list->proc = table->proc; - } - } + XtActionList list = *actions_return = (XtActionList) + __XtMalloc((Cardinal) + ((size_t) * num_actions_return * sizeof(XtActionsRec))); + + table = GetClassActions(widget_class); + + if (table != NULL) { + int i; + + for (i = (int) (*num_actions_return); --i >= 0; list++, table++) { + list->string = XrmQuarkToString(table->signature); + list->proc = table->proc; + } + } } UNLOCK_PROCESS; } @@ -822,9 +786,8 @@ void XtGetActionList( * ***********************************************************************/ -static Widget _XtFindPopup( - Widget widget, - String name) +static Widget +_XtFindPopup(Widget widget, String name) { register Cardinal i; register XrmQuark q; @@ -832,19 +795,19 @@ static Widget _XtFindPopup( q = XrmStringToQuark(name); - for (w=widget; w != NULL; w=w->core.parent) - for (i=0; icore.num_popups; i++) - if (w->core.popup_list[i]->core.xrm_name == q) - return w->core.popup_list[i]; + for (w = widget; w != NULL; w = w->core.parent) + for (i = 0; i < w->core.num_popups; i++) + if (w->core.popup_list[i]->core.xrm_name == q) + return w->core.popup_list[i]; return NULL; } -void XtMenuPopupAction( - Widget widget, - XEvent *event, - String *params, - Cardinal *num_params) +void +XtMenuPopupAction(Widget widget, + XEvent *event, + String * params, + Cardinal * num_params) { Boolean spring_loaded; register Widget popup_shell; @@ -852,87 +815,91 @@ void XtMenuPopupAction( LOCK_APP(app); if (*num_params != 1) { - XtAppWarningMsg(app, - "invalidParameters","xtMenuPopupAction",XtCXtToolkitError, - "MenuPopup wants exactly one argument", - NULL, NULL); - UNLOCK_APP(app); - return; + XtAppWarningMsg(app, + "invalidParameters", "xtMenuPopupAction", + XtCXtToolkitError, + "MenuPopup wants exactly one argument", NULL, NULL); + UNLOCK_APP(app); + return; } if (event->type == ButtonPress) - spring_loaded = True; + spring_loaded = True; else if (event->type == KeyPress || event->type == EnterNotify) - spring_loaded = False; + spring_loaded = False; else { - XtAppWarningMsg(app, - "invalidPopup","unsupportedOperation",XtCXtToolkitError, -"Pop-up menu creation is only supported on ButtonPress, KeyPress or EnterNotify events.", - NULL, NULL); - UNLOCK_APP(app); - return; + XtAppWarningMsg(app, + "invalidPopup", "unsupportedOperation", + XtCXtToolkitError, + "Pop-up menu creation is only supported on ButtonPress, KeyPress or EnterNotify events.", + NULL, NULL); + UNLOCK_APP(app); + return; } popup_shell = _XtFindPopup(widget, params[0]); if (popup_shell == NULL) { - XtAppWarningMsg(app, - "invalidPopup","xtMenuPopup",XtCXtToolkitError, - "Can't find popup widget \"%s\" in XtMenuPopup", - params, num_params); - UNLOCK_APP(app); - return; + XtAppWarningMsg(app, + "invalidPopup", "xtMenuPopup", XtCXtToolkitError, + "Can't find popup widget \"%s\" in XtMenuPopup", + params, num_params); + UNLOCK_APP(app); + return; } - if (spring_loaded) _XtPopup(popup_shell, XtGrabExclusive, TRUE); - else _XtPopup(popup_shell, XtGrabNonexclusive, FALSE); + if (spring_loaded) + _XtPopup(popup_shell, XtGrabExclusive, TRUE); + else + _XtPopup(popup_shell, XtGrabNonexclusive, FALSE); UNLOCK_APP(app); } - -/*ARGSUSED*/ -static void _XtMenuPopdownAction( - Widget widget, - XEvent *event _X_UNUSED, - String *params, - Cardinal *num_params) + /*ARGSUSED*/ static void +_XtMenuPopdownAction(Widget widget, + XEvent *event _X_UNUSED, + String * params, + Cardinal * num_params) { Widget popup_shell; if (*num_params == 0) { - XtPopdown(widget); - } else if (*num_params == 1) { - popup_shell = _XtFindPopup(widget, params[0]); - if (popup_shell == NULL) { + XtPopdown(widget); + } + else if (*num_params == 1) { + popup_shell = _XtFindPopup(widget, params[0]); + if (popup_shell == NULL) { XtAppWarningMsg(XtWidgetToApplicationContext(widget), - "invalidPopup","xtMenuPopdown",XtCXtToolkitError, - "Can't find popup widget \"%s\" in XtMenuPopdown", - params, num_params); - return; - } - XtPopdown(popup_shell); - } else { - XtAppWarningMsg(XtWidgetToApplicationContext(widget), - "invalidParameters","xtMenuPopdown",XtCXtToolkitError, - "XtMenuPopdown called with num_params != 0 or 1", - NULL, NULL); + "invalidPopup", "xtMenuPopdown", XtCXtToolkitError, + "Can't find popup widget \"%s\" in XtMenuPopdown", + params, num_params); + return; + } + XtPopdown(popup_shell); + } + else { + XtAppWarningMsg(XtWidgetToApplicationContext(widget), + "invalidParameters", "xtMenuPopdown", XtCXtToolkitError, + "XtMenuPopdown called with num_params != 0 or 1", + NULL, NULL); } } +/* *INDENT-OFF* */ static XtActionsRec RConst tmActions[] = { - {"XtMenuPopup", XtMenuPopupAction}, - {"XtMenuPopdown", _XtMenuPopdownAction}, - {"MenuPopup", XtMenuPopupAction}, /* old & obsolete */ - {"MenuPopdown", _XtMenuPopdownAction}, /* ditto */ + {"XtMenuPopup", XtMenuPopupAction}, + {"XtMenuPopdown", _XtMenuPopdownAction}, + {"MenuPopup", XtMenuPopupAction}, /* old & obsolete */ + {"MenuPopdown", _XtMenuPopdownAction}, /* ditto */ #ifndef NO_MIT_HACKS - {"XtDisplayTranslations", _XtDisplayTranslations}, - {"XtDisplayAccelerators", _XtDisplayAccelerators}, + {"XtDisplayTranslations", _XtDisplayTranslations}, + {"XtDisplayAccelerators", _XtDisplayAccelerators}, {"XtDisplayInstalledAccelerators", _XtDisplayInstalledAccelerators}, #endif }; +/* *INDENT-ON* */ - -void _XtPopupInitialize( - XtAppContext app) +void +_XtPopupInitialize(XtAppContext app) { register ActionList rec; @@ -954,21 +921,20 @@ void _XtPopupInitialize( app->action_table = rec; LOCK_PROCESS; rec->table = CompileActionTable(tmActions, XtNumber(tmActions), False, - True); + True); rec->count = XtNumber(tmActions); UNLOCK_PROCESS; _XtGrabInitialize(app); } - -void XtCallActionProc( - Widget widget, - _Xconst char* action, - XEvent *event, - String *params, - Cardinal num_params) +void +XtCallActionProc(Widget widget, + _Xconst char *action, + XEvent *event, + String * params, + Cardinal num_params) { - CompiledAction* actionP; + CompiledAction *actionP; XrmQuark q = XrmStringToQuark(action); Widget w = widget; XtAppContext app = XtWidgetToApplicationContext(widget); @@ -977,91 +943,88 @@ void XtCallActionProc( LOCK_APP(app); XtCheckSubclass(widget, coreWidgetClass, - "XtCallActionProc first argument is not a subclass of Core"); + "XtCallActionProc first argument is not a subclass of Core"); LOCK_PROCESS; do { - WidgetClass class = XtClass(w); - do { - if ((actionP = GetClassActions(class)) != NULL) - for (i = 0; - i < class->core_class.num_actions; - i++, actionP++) { - - if (actionP->signature == q) { - ActionHook hook = app->action_hook_list; - while (hook != NULL) { - (*hook->proc)( widget, - hook->closure, - (String)action, - event, - params, - &num_params - ); - hook= hook->next; - } - (*(actionP->proc)) - (widget, event, params, &num_params); - UNLOCK_PROCESS; - UNLOCK_APP(app); - return; - } - } - class = class->core_class.superclass; - } while (class != NULL); - w = XtParent(w); + WidgetClass class = XtClass(w); + + do { + if ((actionP = GetClassActions(class)) != NULL) + for (i = 0; i < class->core_class.num_actions; i++, actionP++) { + + if (actionP->signature == q) { + ActionHook hook = app->action_hook_list; + + while (hook != NULL) { + (*hook->proc) (widget, + hook->closure, + (String) action, + event, + params, + &num_params); + hook = hook->next; + } + (*(actionP->proc)) + (widget, event, params, &num_params); + UNLOCK_PROCESS; + UNLOCK_APP(app); + return; + } + } + class = class->core_class.superclass; + } while (class != NULL); + w = XtParent(w); } while (w != NULL); UNLOCK_PROCESS; for (actionList = app->action_table; - actionList != NULL; - actionList = actionList->next) { - - for (i = 0, actionP = actionList->table; - i < actionList->count; - i++, actionP++) { - if (actionP->signature == q) { - ActionHook hook = app->action_hook_list; - while (hook != NULL) { - (*hook->proc)( widget, - hook->closure, - (String)action, - event, - params, - &num_params - ); - hook= hook->next; - } - (*(actionP->proc)) - (widget, event, params, &num_params); - UNLOCK_APP(app); - return; - } - } + actionList != NULL; actionList = actionList->next) { + + for (i = 0, actionP = actionList->table; + i < actionList->count; i++, actionP++) { + if (actionP->signature == q) { + ActionHook hook = app->action_hook_list; + + while (hook != NULL) { + (*hook->proc) (widget, + hook->closure, + (String) action, + event, + params, + &num_params); + hook = hook->next; + } + (*(actionP->proc)) + (widget, event, params, &num_params); + UNLOCK_APP(app); + return; + } + } } { - String par[2]; - Cardinal num_par = 2; - par[0] = (String)action; - par[1] = XtName(widget); - XtAppWarningMsg(app, - "noActionProc", "xtCallActionProc", XtCXtToolkitError, - "No action proc named \"%s\" is registered for widget \"%s\"", - par, &num_par - ); + String par[2]; + Cardinal num_par = 2; + + par[0] = (String) action; + par[1] = XtName(widget); + XtAppWarningMsg(app, + "noActionProc", "xtCallActionProc", XtCXtToolkitError, + "No action proc named \"%s\" is registered for widget \"%s\"", + par, &num_par); } UNLOCK_APP(app); } -void _XtDoFreeBindings( - XtAppContext app) +void +_XtDoFreeBindings(XtAppContext app) { TMBindCache bcp; while (app->free_bindings) { - bcp = app->free_bindings->next; - XtFree ((char *) app->free_bindings); - app->free_bindings = bcp; + bcp = app->free_bindings->next; + XtFree((char *) app->free_bindings); + app->free_bindings = bcp; } } -- cgit v1.2.3