home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / evbl0627.zip / everblue_20010627.zip / x11 / XKBAlloc.c < prev    next >
C/C++ Source or Header  |  1999-11-02  |  16KB  |  603 lines
  1. /* $XConsortium: XKBAlloc.c /main/6 1996/02/02 14:09:14 kaleb $ */
  2. /* $XFree86: xc/lib/X11/XKBAlloc.c,v 3.2.4.1 1998/10/04 13:36:20 hohndel Exp $ */
  3. /************************************************************
  4. Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
  5.  
  6. Permission to use, copy, modify, and distribute this
  7. software and its documentation for any purpose and without
  8. fee is hereby granted, provided that the above copyright
  9. notice appear in all copies and that both that copyright
  10. notice and this permission notice appear in supporting
  11. documentation, and that the name of Silicon Graphics not be 
  12. used in advertising or publicity pertaining to distribution 
  13. of the software without specific prior written permission.
  14. Silicon Graphics makes no representation about the suitability 
  15. of this software for any purpose. It is provided "as is"
  16. without any express or implied warranty.
  17.  
  18. SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 
  19. SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
  20. AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
  21. GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
  22. DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 
  23. DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 
  24. OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
  25. THE USE OR PERFORMANCE OF THIS SOFTWARE.
  26.  
  27. ********************************************************/
  28.  
  29. #ifndef XKB_IN_SERVER
  30.  
  31. #include <stdio.h>
  32. #define NEED_REPLIES
  33. #define NEED_EVENTS
  34. #include "Xlib_private.h"
  35. #include "XKBlibint.h"
  36. #include <X11/extensions/XKBgeom.h>
  37. #include <X11/extensions/XKBproto.h>
  38. #include "XKBlibint.h"
  39.  
  40. #else 
  41.  
  42. #include <stdio.h>
  43. #include "X.h"
  44. #define    NEED_EVENTS
  45. #define    NEED_REPLIES
  46. #include "Xproto.h"
  47. #include "misc.h"
  48. #include "inputstr.h"
  49. #include "XKBsrv.h"
  50. #include "XKBgeom.h"
  51.  
  52. #endif /* XKB_IN_SERVER */
  53.  
  54. /***===================================================================***/
  55.  
  56. /*ARGSUSED*/
  57. Status
  58. #if NeedFunctionPrototypes
  59. XkbAllocCompatMap(XkbDescPtr xkb,unsigned which,unsigned nSI)
  60. #else
  61. XkbAllocCompatMap(xkb,which,nSI)
  62.     XkbDescPtr    xkb;
  63.     unsigned    which;
  64.     unsigned    nSI;
  65. #endif
  66. {
  67.     DBUG_ENTER("XkbAllocCompatMap")
  68.     XkbCompatMapPtr    compat;
  69.     XkbSymInterpretRec *prev_interpret;
  70.  
  71.     if (!xkb)
  72.     DBUG_RETURN(BadMatch);
  73.     if (xkb->compat) {
  74.     if (xkb->compat->size_si>=nSI)
  75.         DBUG_RETURN(Success);
  76.     compat= xkb->compat;
  77.     compat->size_si= nSI;
  78.     if (compat->sym_interpret==NULL)
  79.         compat->num_si= 0;
  80.     prev_interpret = compat->sym_interpret;
  81.     compat->sym_interpret= _XkbTypedRealloc(compat->sym_interpret,
  82.                              nSI,XkbSymInterpretRec);
  83.     if (compat->sym_interpret==NULL) {
  84.         _XkbFree(prev_interpret);
  85.         compat->size_si= compat->num_si= 0;
  86.         DBUG_RETURN(BadAlloc);
  87.     }
  88.     if (compat->num_si!=0) {
  89.         _XkbClearElems(compat->sym_interpret,compat->num_si,
  90.                     compat->size_si-1,XkbSymInterpretRec);
  91.     }
  92.     DBUG_RETURN(Success);
  93.     }
  94.     compat= _XkbTypedCalloc(1,XkbCompatMapRec);
  95.     if (compat==NULL)
  96.     DBUG_RETURN(BadAlloc);
  97.     if (nSI>0) {
  98.     compat->sym_interpret= _XkbTypedCalloc(nSI,XkbSymInterpretRec);
  99.     if (!compat->sym_interpret) {
  100.         _XkbFree(compat);
  101.         DBUG_RETURN(BadAlloc);
  102.     }
  103.     }
  104.     compat->size_si= nSI;
  105.     compat->num_si= 0;
  106.     bzero((char *)&compat->groups[0],XkbNumKbdGroups*sizeof(XkbModsRec));
  107.     xkb->compat= compat;
  108.     DBUG_RETURN(Success);
  109. }
  110.  
  111.  
  112. void
  113. #if NeedFunctionPrototypes
  114. XkbFreeCompatMap(XkbDescPtr xkb,unsigned which,Bool freeMap)
  115. #else
  116. XkbFreeCompatMap(xkb,which,freeMap)
  117.     XkbDescPtr    xkb;
  118.     unsigned    which;
  119.     Bool    freeMap;
  120. #endif
  121. {
  122.     DBUG_ENTER("XkbFreeCompatMap")
  123.     register XkbCompatMapPtr compat;
  124.  
  125.     if ((xkb==NULL)||(xkb->compat==NULL))
  126.     DBUG_VOID_RETURN;
  127.     compat= xkb->compat;
  128.     if (freeMap)
  129.     which= XkbAllCompatMask;
  130.     if (which&XkbGroupCompatMask)
  131.     bzero((char *)&compat->groups[0],XkbNumKbdGroups*sizeof(XkbModsRec));
  132.     if (which&XkbSymInterpMask) {
  133.     if ((compat->sym_interpret)&&(compat->size_si>0))
  134.         _XkbFree(compat->sym_interpret);
  135.     compat->size_si= compat->num_si= 0;
  136.     compat->sym_interpret= NULL;
  137.     }
  138.     if (freeMap) {
  139.     _XkbFree(compat);
  140.     xkb->compat= NULL;
  141.     }
  142.     DBUG_VOID_RETURN;
  143. }
  144.  
  145. /***===================================================================***/
  146.  
  147. Status
  148. #if NeedFunctionPrototypes
  149. XkbAllocNames(XkbDescPtr xkb,unsigned which,int nTotalRG,int nTotalAliases)
  150. #else
  151. XkbAllocNames(xkb,which,nTotalRG,nTotalAliases)
  152.     XkbDescPtr    xkb;
  153.     unsigned    which;
  154.     int        nTotalRG;
  155.     int        nTotalAliases;
  156. #endif
  157. {
  158.     DBUG_ENTER("XkbAllocNames")
  159.     XkbNamesPtr    names;
  160.  
  161.     if (xkb==NULL)
  162.     DBUG_RETURN(BadMatch);
  163.     if (xkb->names==NULL) {
  164.     xkb->names = _XkbTypedCalloc(1,XkbNamesRec);
  165.     if (xkb->names==NULL)
  166.         DBUG_RETURN(BadAlloc);
  167.     }
  168.     names= xkb->names;
  169.     if ((which&XkbKTLevelNamesMask)&&(xkb->map!=NULL)&&(xkb->map->types!=NULL)){
  170.     register int    i;
  171.     XkbKeyTypePtr    type;
  172.  
  173.     type= xkb->map->types;
  174.     for (i=0;i<xkb->map->num_types;i++,type++) {
  175.         if (type->level_names==NULL) {
  176.         type->level_names= _XkbTypedCalloc(type->num_levels,Atom);
  177.         if (type->level_names==NULL)
  178.             DBUG_RETURN(BadAlloc);
  179.         }
  180.     }
  181.     }
  182.     if ((which&XkbKeyNamesMask)&&(names->keys==NULL)) {
  183.     if ((!XkbIsLegalKeycode(xkb->min_key_code))||
  184.         (!XkbIsLegalKeycode(xkb->max_key_code))||
  185.         (xkb->max_key_code<xkb->min_key_code)) 
  186.         DBUG_RETURN(BadValue);
  187.     names->keys= _XkbTypedCalloc((xkb->max_key_code+1),XkbKeyNameRec);
  188.     if (names->keys==NULL)
  189.         DBUG_RETURN(BadAlloc);
  190.     }
  191.     if ((which&XkbKeyAliasesMask)&&(nTotalAliases>0)) {
  192.     if (names->key_aliases==NULL) {
  193.         names->key_aliases= _XkbTypedCalloc(nTotalAliases,XkbKeyAliasRec);
  194.     }
  195.     else if (nTotalAliases>names->num_key_aliases) {
  196.         XkbKeyAliasRec *prev_aliases = names->key_aliases;
  197.  
  198.         names->key_aliases= _XkbTypedRealloc(names->key_aliases,
  199.                         nTotalAliases,XkbKeyAliasRec);
  200.         if (names->key_aliases!=NULL) {
  201.         _XkbClearElems(names->key_aliases,names->num_key_aliases,
  202.                         nTotalAliases-1,XkbKeyAliasRec);
  203.         } else {
  204.         _XkbFree(prev_aliases);
  205.         }
  206.     }
  207.     if (names->key_aliases==NULL) {
  208.         names->num_key_aliases= 0;
  209.         DBUG_RETURN(BadAlloc);
  210.     }
  211.     names->num_key_aliases= nTotalAliases;
  212.     }
  213.     if ((which&XkbRGNamesMask)&&(nTotalRG>0)) {
  214.     if (names->radio_groups==NULL) {
  215.         names->radio_groups= _XkbTypedCalloc(nTotalRG,Atom);
  216.     }
  217.     else if (nTotalRG>names->num_rg) {
  218.         Atom *prev_radio_groups = names->radio_groups;
  219.  
  220.         names->radio_groups= _XkbTypedRealloc(names->radio_groups,nTotalRG,
  221.                                     Atom);
  222.         if (names->radio_groups!=NULL) {
  223.         _XkbClearElems(names->radio_groups,names->num_rg,nTotalRG-1,
  224.                                     Atom);
  225.         } else {
  226.         _XkbFree(prev_radio_groups);
  227.         }
  228.     }
  229.     if (names->radio_groups==NULL)
  230.         DBUG_RETURN(BadAlloc);
  231.     names->num_rg= nTotalRG;
  232.     }
  233.     DBUG_RETURN(Success);
  234. }
  235.  
  236. void
  237. #if NeedFunctionPrototypes
  238. XkbFreeNames(XkbDescPtr xkb,unsigned which,Bool freeMap)
  239. #else
  240. XkbFreeNames(xkb,which,freeMap)
  241.     XkbDescPtr    xkb;
  242.     unsigned    which;
  243.     Bool    freeMap;
  244. #endif
  245. {
  246.     DBUG_ENTER("XkbFreeNames")
  247.     XkbNamesPtr    names;
  248.  
  249.     if ((xkb==NULL)||(xkb->names==NULL))
  250.     DBUG_VOID_RETURN;
  251.     names= xkb->names;
  252.     if (freeMap)
  253.     which= XkbAllNamesMask; 
  254.     if (which&XkbKTLevelNamesMask) {
  255.     XkbClientMapPtr    map= xkb->map;
  256.     if ((map!=NULL)&&(map->types!=NULL)) {
  257.         register int         i;
  258.         register XkbKeyTypePtr    type;
  259.         type= map->types;
  260.         for (i=0;i<map->num_types;i++,type++) {
  261.         if (type->level_names!=NULL) {
  262.             _XkbFree(type->level_names);
  263.             type->level_names= NULL;
  264.         }
  265.         }
  266.     }
  267.     }
  268.     if ((which&XkbKeyNamesMask)&&(names->keys!=NULL)) {
  269.     _XkbFree(names->keys);
  270.     names->keys= NULL;
  271.     names->num_keys= 0;
  272.     }
  273.     if ((which&XkbKeyAliasesMask)&&(names->key_aliases)){
  274.     _XkbFree(names->key_aliases);
  275.     names->key_aliases=NULL;
  276.     names->num_key_aliases=0;
  277.     }
  278.     if ((which&XkbRGNamesMask)&&(names->radio_groups)) {
  279.     _XkbFree(names->radio_groups);
  280.     names->radio_groups= NULL;
  281.     names->num_rg= 0;
  282.     }
  283.     if (freeMap) {
  284.     _XkbFree(names);
  285.     xkb->names= NULL;
  286.     }
  287.     DBUG_VOID_RETURN;
  288. }
  289.  
  290. /***===================================================================***/
  291.  
  292. /*ARGSUSED*/
  293. Status
  294. #if NeedFunctionPrototypes
  295. XkbAllocControls(XkbDescPtr xkb,unsigned which)
  296. #else
  297. XkbAllocControls(xkb,which)
  298.     XkbDescPtr        xkb;
  299.     unsigned        which;
  300. #endif
  301. {
  302.     DBUG_ENTER("XkbAllocControls")
  303.     if (xkb==NULL)
  304.     DBUG_RETURN(BadMatch);
  305.  
  306.     if (xkb->ctrls==NULL) {
  307.     xkb->ctrls= _XkbTypedCalloc(1,XkbControlsRec);
  308.     if (!xkb->ctrls)
  309.         DBUG_RETURN(BadAlloc);
  310.     }
  311.     DBUG_RETURN(Success);
  312. }
  313.  
  314. /*ARGSUSED*/
  315. void
  316. #if NeedFunctionPrototypes
  317. XkbFreeControls(XkbDescPtr xkb,unsigned which,Bool freeMap)
  318. #else
  319. XkbFreeControls(xkb,which,freeMap)
  320.     XkbDescPtr        xkb;
  321.     unsigned        which;
  322.     Bool        freeMap;
  323. #endif
  324. {
  325.     DBUG_ENTER("XkbFreeControls")
  326.     if (freeMap && (xkb!=NULL) && (xkb->ctrls!=NULL)) {
  327.     _XkbFree(xkb->ctrls);
  328.     xkb->ctrls= NULL;
  329.     }
  330.     DBUG_VOID_RETURN;
  331. }
  332.  
  333. /***===================================================================***/
  334.  
  335. Status 
  336. #if NeedFunctionPrototypes
  337. XkbAllocIndicatorMaps(XkbDescPtr xkb)
  338. #else
  339. XkbAllocIndicatorMaps(xkb)
  340.     XkbDescPtr    xkb;
  341. #endif
  342. {
  343.     DBUG_ENTER("XkbAllocIndicatorMaps")
  344.     if (xkb==NULL)
  345.     DBUG_RETURN(BadMatch);
  346.     if (xkb->indicators==NULL) {
  347.     xkb->indicators= _XkbTypedCalloc(1,XkbIndicatorRec);
  348.     if (!xkb->indicators)
  349.         DBUG_RETURN(BadAlloc);
  350.     }
  351.     DBUG_RETURN(Success);
  352. }
  353.  
  354. void
  355. #if NeedFunctionPrototypes
  356. XkbFreeIndicatorMaps(XkbDescPtr xkb)
  357. #else
  358. XkbFreeIndicatorMaps(xkb)
  359.     XkbDescPtr    xkb;
  360. #endif
  361. {
  362.     DBUG_ENTER("XkbFreeIndicatorMaps")
  363.     if ((xkb!=NULL)&&(xkb->indicators!=NULL)) {
  364.     _XkbFree(xkb->indicators);
  365.     xkb->indicators= NULL;
  366.     }
  367.     DBUG_VOID_RETURN;
  368. }
  369.  
  370. /***====================================================================***/
  371.  
  372. XkbDescRec    *
  373. #if NeedFunctionPrototypes
  374. XkbAllocKeyboard(void)
  375. #else
  376. XkbAllocKeyboard()
  377. #endif
  378. {
  379.     DBUG_ENTER("XkbAllocKeyboard")
  380.     XkbDescRec *xkb;
  381.  
  382.     xkb = _XkbTypedCalloc(1,XkbDescRec);
  383.     if (xkb)
  384.     xkb->device_spec= XkbUseCoreKbd;
  385.     DBUG_RETURN(xkb);
  386. }
  387.  
  388. void
  389. #if NeedFunctionPrototypes
  390. XkbFreeKeyboard(XkbDescPtr xkb,unsigned which,Bool freeAll)
  391. #else
  392. XkbFreeKeyboard(xkb,which,freeAll)
  393.     XkbDescPtr    xkb;
  394.     unsigned    which;
  395.     Bool    freeAll;
  396. #endif
  397. {
  398.     DBUG_ENTER("XkbFreeKeyboard")
  399.     if (xkb==NULL)
  400.     DBUG_VOID_RETURN;
  401.     if (freeAll)
  402.     which= XkbAllComponentsMask;
  403.     if (which&XkbClientMapMask)
  404.     XkbFreeClientMap(xkb,XkbAllClientInfoMask,True);
  405.     if (which&XkbServerMapMask)
  406.     XkbFreeServerMap(xkb,XkbAllServerInfoMask,True);
  407.     if (which&XkbCompatMapMask)
  408.     XkbFreeCompatMap(xkb,XkbAllCompatMask,True);
  409.     if (which&XkbIndicatorMapMask)
  410.     XkbFreeIndicatorMaps(xkb);
  411.     if (which&XkbNamesMask)
  412.     XkbFreeNames(xkb,XkbAllNamesMask,True);
  413.     if ((which&XkbGeometryMask) && (xkb->geom!=NULL))
  414.     XkbFreeGeometry(xkb->geom,XkbGeomAllMask,True);
  415.     if (which&XkbControlsMask)
  416.     XkbFreeControls(xkb,XkbAllControlsMask,True);
  417.     if (freeAll)
  418.     _XkbFree(xkb);
  419.     DBUG_VOID_RETURN;
  420. }
  421.  
  422. /***====================================================================***/
  423.  
  424. XkbDeviceLedInfoPtr
  425. #if NeedFunctionPrototypes
  426. XkbAddDeviceLedInfo(XkbDeviceInfoPtr devi,unsigned ledClass,unsigned ledId)
  427. #else
  428. XkbAddDeviceLedInfo(devi,ledClass,ledId)
  429.     XkbDeviceInfoPtr    devi;
  430.     unsigned        ledClass;
  431.     unsigned        ledId;
  432. #endif
  433. {
  434.     DBUG_ENTER("XkbAddDeviceLedInfo")
  435.     XkbDeviceLedInfoPtr    devli;
  436.     register int        i;
  437.  
  438.     if ((!devi)||(!XkbSingleXIClass(ledClass))||(!XkbSingleXIId(ledId)))
  439.     DBUG_RETURN(NULL);
  440.     for (i=0,devli=devi->leds;i<devi->num_leds;i++,devli++) {
  441.     if ((devli->led_class==ledClass)&&(devli->led_id==ledId))
  442.         DBUG_RETURN(devli);
  443.     }
  444.     if (devi->num_leds>=devi->sz_leds) {
  445.     XkbDeviceLedInfoRec *prev_leds = devi->leds;
  446.     
  447.     if (devi->sz_leds>0)    devi->sz_leds*= 2;
  448.     else            devi->sz_leds= 1;
  449.     devi->leds= _XkbTypedRealloc(devi->leds,devi->sz_leds,
  450.                             XkbDeviceLedInfoRec);
  451.     if (!devi->leds) {
  452.         _XkbFree(prev_leds);
  453.         devi->sz_leds= devi->num_leds= 0;
  454.         DBUG_RETURN(NULL);
  455.     }
  456.     i= devi->num_leds;
  457.     for (devli=&devi->leds[i];i<devi->sz_leds;i++,devli++) {
  458.         bzero(devli,sizeof(XkbDeviceLedInfoRec));
  459.         devli->led_class= XkbXINone;
  460.         devli->led_id= XkbXINone;
  461.     }
  462.     }
  463.     devli= &devi->leds[devi->num_leds++];
  464.     bzero(devli,sizeof(XkbDeviceLedInfoRec));
  465.     devli->led_class= ledClass;
  466.     devli->led_id= ledId;
  467.     DBUG_RETURN(devli);
  468. }
  469.  
  470. Status
  471. #if NeedFunctionPrototypes
  472. XkbResizeDeviceButtonActions(XkbDeviceInfoPtr devi,unsigned newTotal)
  473. #else
  474. XkbResizeDeviceButtonActions(devi,newTotal)
  475.     XkbDeviceInfoPtr    devi;
  476.     unsigned        newTotal;
  477. #endif
  478. {
  479.     DBUG_ENTER("XkbResizeDeviceButtonActions")
  480.     XkbAction *prev_btn_acts;
  481.  
  482.     if ((!devi)||(newTotal>255))
  483.     DBUG_RETURN(BadValue);
  484.     if ((devi->btn_acts!=NULL)&&(newTotal==devi->num_btns))
  485.     DBUG_RETURN(Success);
  486.     if (newTotal==0) {
  487.     if (devi->btn_acts!=NULL) {
  488.         _XkbFree(devi->btn_acts);
  489.         devi->btn_acts= NULL;
  490.     }
  491.     devi->num_btns= 0;
  492.     DBUG_RETURN(Success);
  493.     }
  494.     prev_btn_acts = devi->btn_acts;
  495.     devi->btn_acts= _XkbTypedRealloc(devi->btn_acts,newTotal,XkbAction);
  496.     if (devi->btn_acts==NULL) {
  497.     _XkbFree(prev_btn_acts);
  498.     devi->num_btns= 0;
  499.     DBUG_RETURN(BadAlloc);
  500.     }
  501.     if (newTotal>devi->num_btns) {
  502.     XkbAction *act;
  503.     act= &devi->btn_acts[devi->num_btns];
  504.     bzero((char *)act,(newTotal-devi->num_btns)*sizeof(XkbAction));
  505.     }
  506.     devi->num_btns= newTotal;
  507.     DBUG_RETURN(Success);
  508. }
  509.  
  510. /*ARGSUSED*/
  511. XkbDeviceInfoPtr
  512. #if NeedFunctionPrototypes
  513. XkbAllocDeviceInfo(unsigned deviceSpec,unsigned nButtons,unsigned szLeds)
  514. #else
  515. XkbAllocDeviceInfo(deviceSpec,nButtons,szLeds)
  516.     unsigned    deviceSpec;
  517.     unsigned    nButtons;
  518.     unsigned    szLeds;
  519. #endif
  520. {
  521.     DBUG_ENTER("XkbAllocDeviceInfo")
  522.     XkbDeviceInfoPtr    devi;
  523.  
  524.     devi= _XkbTypedCalloc(1,XkbDeviceInfoRec);
  525.     if (devi!=NULL) {
  526.     devi->device_spec= deviceSpec;
  527.     devi->has_own_state= False;
  528.     devi->num_btns= 0;
  529.     devi->btn_acts= NULL;
  530.     if (nButtons>0) {
  531.         devi->num_btns= nButtons;
  532.         devi->btn_acts= _XkbTypedCalloc(nButtons,XkbAction);
  533.         if (!devi->btn_acts) {
  534.         _XkbFree(devi);
  535.         DBUG_RETURN(NULL);
  536.         }
  537.     }
  538.     devi->dflt_kbd_fb= XkbXINone;
  539.     devi->dflt_led_fb= XkbXINone;
  540.     devi->num_leds= 0;
  541.     devi->sz_leds= 0;
  542.     devi->leds= NULL;
  543.     if (szLeds>0) {
  544.         devi->sz_leds= szLeds;
  545.         devi->leds= _XkbTypedCalloc(szLeds,XkbDeviceLedInfoRec);
  546.         if (!devi->leds) {
  547.         if (devi->btn_acts)
  548.             _XkbFree(devi->btn_acts);
  549.         _XkbFree(devi);
  550.         DBUG_RETURN(NULL);
  551.         }
  552.     }
  553.     }
  554.     DBUG_RETURN(devi);
  555. }
  556.  
  557.  
  558. void 
  559. #if NeedFunctionPrototypes
  560. XkbFreeDeviceInfo(XkbDeviceInfoPtr devi,unsigned which,Bool freeDevI)
  561. #else
  562. XkbFreeDeviceInfo(devi,which,freeDevI)
  563.     XkbDeviceInfoPtr    devi;
  564.     unsigned        which;
  565.     Bool        freeDevI;
  566. #endif
  567. {
  568.     DBUG_ENTER("XkbFreeDeviceInfo")
  569.     if (devi) {
  570.     if (freeDevI) {
  571.         which= XkbXI_AllDeviceFeaturesMask;
  572.         if (devi->name) {
  573.         _XkbFree(devi->name);
  574.         devi->name= NULL;
  575.         }
  576.     }
  577.     if ((which&XkbXI_ButtonActionsMask)&&(devi->btn_acts)) {
  578.         _XkbFree(devi->btn_acts);
  579.         devi->num_btns= 0;
  580.         devi->btn_acts= NULL;
  581.     }
  582.     if ((which&XkbXI_IndicatorsMask)&&(devi->leds)) {
  583.         register int i;
  584.         if ((which&XkbXI_IndicatorsMask)==XkbXI_IndicatorsMask) {
  585.         _XkbFree(devi->leds);
  586.         devi->sz_leds= devi->num_leds= 0;
  587.         devi->leds= NULL;
  588.         }
  589.         else {
  590.         XkbDeviceLedInfoPtr    devli;
  591.         for (i=0,devli=devi->leds;i<devi->num_leds;i++,devli++) {
  592.             if (which&XkbXI_IndicatorMapsMask)
  593.              bzero((char *)&devli->maps[0],sizeof(devli->maps));
  594.             else bzero((char *)&devli->names[0],sizeof(devli->names));
  595.         }
  596.         }
  597.     }
  598.     if (freeDevI)
  599.         _XkbFree(devi);
  600.     }
  601.     DBUG_VOID_RETURN;
  602. }
  603.