From ded6147bfb5d75ff1e67c858040a628b61bc17d1 Mon Sep 17 00:00:00 2001 From: Kaleb Keithley Date: Fri, 14 Nov 2003 15:54:54 +0000 Subject: R6.6 is the Xorg base-line --- xkb/XKBGAlloc.c | 1377 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1377 insertions(+) create mode 100644 xkb/XKBGAlloc.c (limited to 'xkb/XKBGAlloc.c') diff --git a/xkb/XKBGAlloc.c b/xkb/XKBGAlloc.c new file mode 100644 index 000000000..c89e1197c --- /dev/null +++ b/xkb/XKBGAlloc.c @@ -0,0 +1,1377 @@ +/* $Xorg: XKBGAlloc.c,v 1.3 2000/08/17 19:45:01 cpqbld Exp $ */ +/************************************************************ +Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc. + +Permission to use, copy, modify, and distribute this +software and its documentation for any purpose and without +fee is hereby granted, provided that the above copyright +notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting +documentation, and that the name of Silicon Graphics not be +used in advertising or publicity pertaining to distribution +of the software without specific prior written permission. +Silicon Graphics makes no representation about the suitability +of this software for any purpose. It is provided "as is" +without any express or implied warranty. + +SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS +SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON +GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE +OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH +THE USE OR PERFORMANCE OF THIS SOFTWARE. + +********************************************************/ + +#define NEED_EVENTS +#define NEED_REPLIES + +#ifndef XKB_IN_SERVER + +#include +#include "Xlibint.h" +#include "XKBlibint.h" +#include +#include + +#else + +#include +#include "X.h" +#include "Xproto.h" +#include "misc.h" +#include "inputstr.h" +#include "XKBsrv.h" +#include "XKBgeom.h" + +#endif /* XKB_IN_SERVER */ + +#ifdef X_NOT_POSIX +#define Size_t unsigned int +#else +#define Size_t size_t +#endif + +/***====================================================================***/ + +static void +#if NeedFunctionPrototypes +_XkbFreeGeomLeafElems( Bool freeAll, + int first, + int count, + unsigned short * num_inout, + unsigned short * sz_inout, + char ** elems, + unsigned int elem_sz) +#else +_XkbFreeGeomLeafElems(freeAll,first,count,num_inout,sz_inout,elems,elem_sz) + Bool freeAll; + int first; + int count; + unsigned short * num_inout; + unsigned short * sz_inout; + char ** elems; + unsigned int elem_sz; +#endif +{ + if ((freeAll)||(*elems==NULL)) { + *num_inout= *sz_inout= 0; + if (*elems!=NULL) { + _XkbFree(*elems); + *elems= NULL; + } + return; + } + + if ((first>=(*num_inout))||(first<0)||(count<1)) + return; + + if (first+count>=(*num_inout)) { + /* truncating the array is easy */ + (*num_inout)= first; + } + else { + char * ptr; + int extra; + ptr= *elems; + extra= ((*num_inout)-(first+count))*elem_sz; + if (extra>0) + memmove(&ptr[first*elem_sz],&ptr[(first+count)*elem_sz],extra); + (*num_inout)-= count; + } + return; +} + +typedef void (*ContentsClearFunc)( +#if NeedFunctionPrototypes + char * /* priv */ +#endif +); + +static void +#if NeedFunctionPrototypes +_XkbFreeGeomNonLeafElems( Bool freeAll, + int first, + int count, + unsigned short * num_inout, + unsigned short * sz_inout, + char ** elems, + unsigned int elem_sz, + ContentsClearFunc freeFunc) +#else +_XkbFreeGeomNonLeafElems(freeAll,first,count,num_inout,sz_inout,elems,elem_sz, + freeFunc) + Bool freeAll; + int first; + int count; + unsigned short * num_inout; + unsigned short * sz_inout; + char ** elems; + unsigned int elem_sz; + ContentsClearFunc freeFunc; +#endif +{ +register int i; +register char *ptr; + + if (freeAll) { + first= 0; + count= (*num_inout); + } + else if ((first>=(*num_inout))||(first<0)||(count<1)) + return; + else if (first+count>(*num_inout)) + count= (*num_inout)-first; + if (*elems==NULL) + return; + + if (freeFunc) { + ptr= *elems; + ptr+= first*elem_sz; + for (i=0;i=(*num_inout)) + *num_inout= first; + else { + i= ((*num_inout)-(first+count))*elem_sz; + ptr= *elems; + memmove(&ptr[first*elem_sz],&ptr[(first+count)*elem_sz],i); + (*num_inout)-= count; + } + return; +} + +/***====================================================================***/ + +static void +#if NeedFunctionPrototypes +_XkbClearProperty(char *prop_in) +#else +_XkbClearProperty(prop_in) + char * prop_in; +#endif +{ +XkbPropertyPtr prop= (XkbPropertyPtr)prop_in; + + if (prop->name) { + _XkbFree(prop->name); + prop->name= NULL; + } + if (prop->value) { + _XkbFree(prop->value); + prop->value= NULL; + } + return; +} + +void +#if NeedFunctionPrototypes +XkbFreeGeomProperties( XkbGeometryPtr geom, + int first, + int count, + Bool freeAll) +#else +XkbFreeGeomProperties(geom,first,count,freeAll) + XkbGeometryPtr geom; + int first; + int count; + Bool freeAll; +#endif +{ + _XkbFreeGeomNonLeafElems(freeAll,first,count, + &geom->num_properties,&geom->sz_properties, + (char **)&geom->properties, + sizeof(XkbPropertyRec),_XkbClearProperty); + return; +} + +/***====================================================================***/ + +void +#if NeedFunctionPrototypes +XkbFreeGeomKeyAliases( XkbGeometryPtr geom, + int first, + int count, + Bool freeAll) +#else +XkbFreeGeomKeyAliases(geom,first,count,freeAll) + XkbGeometryPtr geom; + int first; + int count; + Bool freeAll; +#endif +{ + _XkbFreeGeomLeafElems(freeAll,first,count, + &geom->num_key_aliases,&geom->sz_key_aliases, + (char **)&geom->key_aliases, + sizeof(XkbKeyAliasRec)); + return; +} + +/***====================================================================***/ + +static void +#if NeedFunctionPrototypes +_XkbClearColor(char *color_in) +#else +_XkbClearColor(color_in) + char * color_in; +#endif +{ +XkbColorPtr color= (XkbColorPtr)color_in; + + if (color->spec) + _XkbFree(color->spec); + return; +} + +void +#if NeedFunctionPrototypes +XkbFreeGeomColors(XkbGeometryPtr geom,int first,int count,Bool freeAll) +#else +XkbFreeGeomColors(geom,first,count,freeAll) + XkbGeometryPtr geom; + int first; + int count; + Bool freeAll; +#endif +{ + _XkbFreeGeomNonLeafElems(freeAll,first,count, + &geom->num_colors,&geom->sz_colors, + (char **)&geom->colors, + sizeof(XkbColorRec),_XkbClearColor); + return; +} + +/***====================================================================***/ + +void +#if NeedFunctionPrototypes +XkbFreeGeomPoints(XkbOutlinePtr outline,int first,int count,Bool freeAll) +#else +XkbFreeGeomPoints(outline,first,count,freeAll) + XkbOutlinePtr outline; + int first; + int count; + Bool freeAll; +#endif +{ + _XkbFreeGeomLeafElems(freeAll,first,count, + &outline->num_points,&outline->sz_points, + (char **)&outline->points, + sizeof(XkbPointRec)); + return; +} + +/***====================================================================***/ + +static void +#if NeedFunctionPrototypes +_XkbClearOutline(char *outline_in) +#else +_XkbClearOutline(outline_in) + char * outline_in; +#endif +{ +XkbOutlinePtr outline= (XkbOutlinePtr)outline_in; + + if (outline->points!=NULL) + XkbFreeGeomPoints(outline,0,outline->num_points,True); + return; +} + +void +#if NeedFunctionPrototypes +XkbFreeGeomOutlines(XkbShapePtr shape,int first,int count,Bool freeAll) +#else +XkbFreeGeomOutlines(shape,first,count,freeAll) + XkbShapePtr shape; + int first; + int count; + Bool freeAll; +#endif +{ + _XkbFreeGeomNonLeafElems(freeAll,first,count, + &shape->num_outlines,&shape->sz_outlines, + (char **)&shape->outlines, + sizeof(XkbOutlineRec),_XkbClearOutline); + + return; +} + +/***====================================================================***/ + +static void +#if NeedFunctionPrototypes +_XkbClearShape(char *shape_in) +#else +_XkbClearShape(shape_in) + char * shape_in; +#endif +{ +XkbShapePtr shape= (XkbShapePtr)shape_in; + + if (shape->outlines) + XkbFreeGeomOutlines(shape,0,shape->num_outlines,True); + return; +} + +void +#if NeedFunctionPrototypes +XkbFreeGeomShapes(XkbGeometryPtr geom,int first,int count,Bool freeAll) +#else +XkbFreeGeomShapes(geom,first,count,freeAll) + XkbGeometryPtr geom; + int first; + int count; + Bool freeAll; +#endif +{ + _XkbFreeGeomNonLeafElems(freeAll,first,count, + &geom->num_shapes,&geom->sz_shapes, + (char **)&geom->shapes, + sizeof(XkbShapeRec),_XkbClearShape); + return; +} + +/***====================================================================***/ + +void +#if NeedFunctionPrototypes +XkbFreeGeomOverlayKeys(XkbOverlayRowPtr row,int first,int count,Bool freeAll) +#else +XkbFreeGeomOverlayKeys(row,first,count,freeAll) + XkbOverlayRowPtr row; + int first; + int count; + Bool freeAll; +#endif +{ + _XkbFreeGeomLeafElems(freeAll,first,count, + &row->num_keys,&row->sz_keys, + (char **)&row->keys, + sizeof(XkbOverlayKeyRec)); + return; +} + +/***====================================================================***/ + +static void +#if NeedFunctionPrototypes +_XkbClearOverlayRow(char *row_in) +#else +_XkbClearOverlayRow(row_in) + char * row_in; +#endif +{ +XkbOverlayRowPtr row= (XkbOverlayRowPtr)row_in; + + if (row->keys!=NULL) + XkbFreeGeomOverlayKeys(row,0,row->num_keys,True); + return; +} + +void +#if NeedFunctionPrototypes +XkbFreeGeomOverlayRows(XkbOverlayPtr overlay,int first,int count,Bool freeAll) +#else +XkbFreeGeomOverlayRows(overlay,first,count,freeAll) + XkbOverlayPtr overlay; + int first; + int count; + Bool freeAll; +#endif +{ + _XkbFreeGeomNonLeafElems(freeAll,first,count, + &overlay->num_rows,&overlay->sz_rows, + (char **)&overlay->rows, + sizeof(XkbOverlayRowRec),_XkbClearOverlayRow); + return; +} + +/***====================================================================***/ + +static void +#if NeedFunctionPrototypes +_XkbClearOverlay(char *overlay_in) +#else +_XkbClearOverlay(overlay_in) + char * overlay_in; +#endif +{ +XkbOverlayPtr overlay= (XkbOverlayPtr)overlay_in; + + if (overlay->rows!=NULL) + XkbFreeGeomOverlayRows(overlay,0,overlay->num_rows,True); + return; +} + +void +#if NeedFunctionPrototypes +XkbFreeGeomOverlays(XkbSectionPtr section,int first,int count,Bool freeAll) +#else +XkbFreeGeomOverlays(section,first,count,freeAll) + XkbSectionPtr section; + int first; + int count; + Bool freeAll; +#endif +{ + _XkbFreeGeomNonLeafElems(freeAll,first,count, + §ion->num_overlays,§ion->sz_overlays, + (char **)§ion->overlays, + sizeof(XkbOverlayRec),_XkbClearOverlay); + return; +} + +/***====================================================================***/ + +void +#if NeedFunctionPrototypes +XkbFreeGeomKeys(XkbRowPtr row,int first,int count,Bool freeAll) +#else +XkbFreeGeomKeys(row,first,count,freeAll) + XkbRowPtr row; + int first; + int count; + Bool freeAll; +#endif +{ + _XkbFreeGeomLeafElems(freeAll,first,count, + &row->num_keys,&row->sz_keys, + (char **)&row->keys, + sizeof(XkbKeyRec)); + return; +} + +/***====================================================================***/ + +static void +#if NeedFunctionPrototypes +_XkbClearRow(char *row_in) +#else +_XkbClearRow(row_in) + char * row_in; +#endif +{ +XkbRowPtr row= (XkbRowPtr)row_in; + + if (row->keys!=NULL) + XkbFreeGeomKeys(row,0,row->num_keys,True); + return; +} + +void +#if NeedFunctionPrototypes +XkbFreeGeomRows(XkbSectionPtr section,int first,int count,Bool freeAll) +#else +XkbFreeGeomRows(section,first,count,freeAll) + XkbSectionPtr section; + int first; + int count; + Bool freeAll; +#endif +{ + _XkbFreeGeomNonLeafElems(freeAll,first,count, + §ion->num_rows,§ion->sz_rows, + (char **)§ion->rows, + sizeof(XkbRowRec),_XkbClearRow); +} + +/***====================================================================***/ + +static void +#if NeedFunctionPrototypes +_XkbClearSection(char *section_in) +#else +_XkbClearSection(section_in) + char * section_in; +#endif +{ +XkbSectionPtr section= (XkbSectionPtr)section_in; + + if (section->rows!=NULL) + XkbFreeGeomRows(section,0,section->num_rows,True); + if (section->doodads!=NULL) { + XkbFreeGeomDoodads(section->doodads,section->num_doodads,True); + section->doodads= NULL; + } + return; +} + +void +#if NeedFunctionPrototypes +XkbFreeGeomSections(XkbGeometryPtr geom,int first,int count,Bool freeAll) +#else +XkbFreeGeomSections(geom,first,count,freeAll) + XkbGeometryPtr geom; + int first; + int count; + Bool freeAll; +#endif +{ + _XkbFreeGeomNonLeafElems(freeAll,first,count, + &geom->num_sections,&geom->sz_sections, + (char **)&geom->sections, + sizeof(XkbSectionRec),_XkbClearSection); + return; +} + +/***====================================================================***/ + +static void +#if NeedFunctionPrototypes +_XkbClearDoodad(char *doodad_in) +#else +_XkbClearDoodad(doodad_in) + char * doodad_in; +#endif +{ +XkbDoodadPtr doodad= (XkbDoodadPtr)doodad_in; + + switch (doodad->any.type) { + case XkbTextDoodad: + { + if (doodad->text.text!=NULL) { + _XkbFree(doodad->text.text); + doodad->text.text= NULL; + } + if (doodad->text.font!=NULL) { + _XkbFree(doodad->text.font); + doodad->text.font= NULL; + } + } + break; + case XkbLogoDoodad: + { + if (doodad->logo.logo_name!=NULL) { + _XkbFree(doodad->logo.logo_name); + doodad->logo.logo_name= NULL; + } + } + break; + } + return; +} + +void +#if NeedFunctionPrototypes +XkbFreeGeomDoodads(XkbDoodadPtr doodads,int nDoodads,Bool freeAll) +#else +XkbFreeGeomDoodads(doodads,nDoodads,freeAll) + XkbDoodadPtr doodads; + int nDoodads; + Bool freeAll; +#endif +{ +register int i; +register XkbDoodadPtr doodad; + + if (doodads) { + for (i=0,doodad= doodads;iproperties!=NULL)) + XkbFreeGeomProperties(geom,0,geom->num_properties,True); + if ((which&XkbGeomColorsMask)&&(geom->colors!=NULL)) + XkbFreeGeomColors(geom,0,geom->num_colors,True); + if ((which&XkbGeomShapesMask)&&(geom->shapes!=NULL)) + XkbFreeGeomShapes(geom,0,geom->num_shapes,True); + if ((which&XkbGeomSectionsMask)&&(geom->sections!=NULL)) + XkbFreeGeomSections(geom,0,geom->num_sections,True); + if ((which&XkbGeomDoodadsMask)&&(geom->doodads!= NULL)) { + XkbFreeGeomDoodads(geom->doodads,geom->num_doodads,True); + geom->doodads= NULL; + geom->num_doodads= geom->sz_doodads= 0; + } + if ((which&XkbGeomKeyAliasesMask)&&(geom->key_aliases!=NULL)) + XkbFreeGeomKeyAliases(geom,0,geom->num_key_aliases,True); + if (freeMap) { + if (geom->label_font!=NULL) { + _XkbFree(geom->label_font); + geom->label_font= NULL; + } + _XkbFree(geom); + } + return; +} + +/***====================================================================***/ + +static Status +#if NeedFunctionPrototypes +_XkbGeomAlloc( XPointer * old, + unsigned short * num, + unsigned short * total, + int num_new, + Size_t sz_elem) +#else +_XkbGeomAlloc(old,num,total,num_new,sz_elem) + XPointer * old; + unsigned short * num; + unsigned short * total; + int num_new; + Size_t sz_elem; +#endif +{ + if (num_new<1) + return Success; + if ((*old)==NULL) + *num= *total= 0; + + if ((*num)+num_new<=(*total)) + return Success; + + *total= (*num)+num_new; + if ((*old)!=NULL) + (*old)= (XPointer)_XkbRealloc((*old),(*total)*sz_elem); + else (*old)= (XPointer)_XkbCalloc((*total),sz_elem); + if ((*old)==NULL) { + *total= *num= 0; + return BadAlloc; + } + + if (*num>0) { + char *tmp= (char *)(*old); + bzero(&tmp[sz_elem*(*num)],(num_new*sz_elem)); + } + return Success; +} + +#define _XkbAllocProps(g,n) _XkbGeomAlloc((XPointer *)&(g)->properties,\ + &(g)->num_properties,&(g)->sz_properties,\ + (n),sizeof(XkbPropertyRec)) +#define _XkbAllocColors(g,n) _XkbGeomAlloc((XPointer *)&(g)->colors,\ + &(g)->num_colors,&(g)->sz_colors,\ + (n),sizeof(XkbColorRec)) +#define _XkbAllocShapes(g,n) _XkbGeomAlloc((XPointer *)&(g)->shapes,\ + &(g)->num_shapes,&(g)->sz_shapes,\ + (n),sizeof(XkbShapeRec)) +#define _XkbAllocSections(g,n) _XkbGeomAlloc((XPointer *)&(g)->sections,\ + &(g)->num_sections,&(g)->sz_sections,\ + (n),sizeof(XkbSectionRec)) +#define _XkbAllocDoodads(g,n) _XkbGeomAlloc((XPointer *)&(g)->doodads,\ + &(g)->num_doodads,&(g)->sz_doodads,\ + (n),sizeof(XkbDoodadRec)) +#define _XkbAllocKeyAliases(g,n) _XkbGeomAlloc((XPointer *)&(g)->key_aliases,\ + &(g)->num_key_aliases,&(g)->sz_key_aliases,\ + (n),sizeof(XkbKeyAliasRec)) + +#define _XkbAllocOutlines(s,n) _XkbGeomAlloc((XPointer *)&(s)->outlines,\ + &(s)->num_outlines,&(s)->sz_outlines,\ + (n),sizeof(XkbOutlineRec)) +#define _XkbAllocRows(s,n) _XkbGeomAlloc((XPointer *)&(s)->rows,\ + &(s)->num_rows,&(s)->sz_rows,\ + (n),sizeof(XkbRowRec)) +#define _XkbAllocPoints(o,n) _XkbGeomAlloc((XPointer *)&(o)->points,\ + &(o)->num_points,&(o)->sz_points,\ + (n),sizeof(XkbPointRec)) +#define _XkbAllocKeys(r,n) _XkbGeomAlloc((XPointer *)&(r)->keys,\ + &(r)->num_keys,&(r)->sz_keys,\ + (n),sizeof(XkbKeyRec)) +#define _XkbAllocOverlays(s,n) _XkbGeomAlloc((XPointer *)&(s)->overlays,\ + &(s)->num_overlays,&(s)->sz_overlays,\ + (n),sizeof(XkbOverlayRec)) +#define _XkbAllocOverlayRows(o,n) _XkbGeomAlloc((XPointer *)&(o)->rows,\ + &(o)->num_rows,&(o)->sz_rows,\ + (n),sizeof(XkbOverlayRowRec)) +#define _XkbAllocOverlayKeys(r,n) _XkbGeomAlloc((XPointer *)&(r)->keys,\ + &(r)->num_keys,&(r)->sz_keys,\ + (n),sizeof(XkbOverlayKeyRec)) + +Status +#if NeedFunctionPrototypes +XkbAllocGeomProps(XkbGeometryPtr geom,int nProps) +#else +XkbAllocGeomProps(geom,nProps) + XkbGeometryPtr geom; + int nProps; +#endif +{ + return _XkbAllocProps(geom,nProps); +} + +Status +#if NeedFunctionPrototypes +XkbAllocGeomColors(XkbGeometryPtr geom,int nColors) +#else +XkbAllocGeomColors(geom,nColors) + XkbGeometryPtr geom; + int nColors; +#endif +{ + return _XkbAllocColors(geom,nColors); +} + +Status +#if NeedFunctionPrototypes +XkbAllocGeomKeyAliases(XkbGeometryPtr geom,int nKeyAliases) +#else +XkbAllocGeomKeyAliases(geom,nKeyAliases) + XkbGeometryPtr geom; + int nKeyAliases; +#endif +{ + return _XkbAllocKeyAliases(geom,nKeyAliases); +} + +Status +#if NeedFunctionPrototypes +XkbAllocGeomShapes(XkbGeometryPtr geom,int nShapes) +#else +XkbAllocGeomShapes(geom,nShapes) + XkbGeometryPtr geom; + int nShapes; +#endif +{ + return _XkbAllocShapes(geom,nShapes); +} + +Status +#if NeedFunctionPrototypes +XkbAllocGeomSections(XkbGeometryPtr geom,int nSections) +#else +XkbAllocGeomSections(geom,nSections) + XkbGeometryPtr geom; + int nSections; +#endif +{ + return _XkbAllocSections(geom,nSections); +} + +Status +#if NeedFunctionPrototypes +XkbAllocGeomOverlays(XkbSectionPtr section,int nOverlays) +#else +XkbAllocGeomOverlays(section,nOverlays) + XkbSectionPtr section; + int nOverlays; +#endif +{ + return _XkbAllocOverlays(section,nOverlays); +} + +Status +#if NeedFunctionPrototypes +XkbAllocGeomOverlayRows(XkbOverlayPtr overlay,int nRows) +#else +XkbAllocGeomOverlayRows(overlay,nRows) + XkbOverlayPtr overlay; + int nRows; +#endif +{ + return _XkbAllocOverlayRows(overlay,nRows); +} + +Status +#if NeedFunctionPrototypes +XkbAllocGeomOverlayKeys(XkbOverlayRowPtr row,int nKeys) +#else +XkbAllocGeomOverlayKeys(row,nKeys) + XkbOverlayRowPtr row; + int nKeys; +#endif +{ + return _XkbAllocOverlayKeys(row,nKeys); +} + +Status +#if NeedFunctionPrototypes +XkbAllocGeomDoodads(XkbGeometryPtr geom,int nDoodads) +#else +XkbAllocGeomDoodads(geom,nDoodads) + XkbGeometryPtr geom; + int nDoodads; +#endif +{ + return _XkbAllocDoodads(geom,nDoodads); +} + +Status +#if NeedFunctionPrototypes +XkbAllocGeomSectionDoodads(XkbSectionPtr section,int nDoodads) +#else +XkbAllocGeomSectionDoodads(section,nDoodads) + XkbSectionPtr section; + int nDoodads; +#endif +{ + return _XkbAllocDoodads(section,nDoodads); +} + +Status +#if NeedFunctionPrototypes +XkbAllocGeomOutlines(XkbShapePtr shape,int nOL) +#else +XkbAllocGeomOutlines(shape,nOL) + XkbShapePtr shape; + int nOL; +#endif +{ + return _XkbAllocOutlines(shape,nOL); +} + +Status +#if NeedFunctionPrototypes +XkbAllocGeomRows(XkbSectionPtr section,int nRows) +#else +XkbAllocGeomRows(section,nRows) + XkbSectionPtr section; + int nRows; +#endif +{ + return _XkbAllocRows(section,nRows); +} + +Status +#if NeedFunctionPrototypes +XkbAllocGeomPoints(XkbOutlinePtr ol,int nPts) +#else +XkbAllocGeomPoints(ol,nPts) + XkbOutlinePtr ol; + int nPts; +#endif +{ + return _XkbAllocPoints(ol,nPts); +} + +Status +#if NeedFunctionPrototypes +XkbAllocGeomKeys(XkbRowPtr row,int nKeys) +#else +XkbAllocGeomKeys(row,nKeys) + XkbRowPtr row; + int nKeys; +#endif +{ + return _XkbAllocKeys(row,nKeys); +} + +Status +#if NeedFunctionPrototypes +XkbAllocGeometry(XkbDescPtr xkb,XkbGeometrySizesPtr sizes) +#else +XkbAllocGeometry(xkb,sizes) + XkbDescPtr xkb; + XkbGeometrySizesPtr sizes; +#endif +{ +XkbGeometryPtr geom; +Status rtrn; + + if (xkb->geom==NULL) { + xkb->geom= _XkbTypedCalloc(1,XkbGeometryRec); + if (!xkb->geom) + return BadAlloc; + } + geom= xkb->geom; + if ((sizes->which&XkbGeomPropertiesMask)&& + ((rtrn=_XkbAllocProps(geom,sizes->num_properties))!=Success)) { + goto BAIL; + } + if ((sizes->which&XkbGeomColorsMask)&& + ((rtrn=_XkbAllocColors(geom,sizes->num_colors))!=Success)) { + goto BAIL; + } + if ((sizes->which&XkbGeomShapesMask)&& + ((rtrn=_XkbAllocShapes(geom,sizes->num_shapes))!=Success)) { + goto BAIL; + } + if ((sizes->which&XkbGeomSectionsMask)&& + ((rtrn=_XkbAllocSections(geom,sizes->num_sections))!=Success)) { + goto BAIL; + } + if ((sizes->which&XkbGeomDoodadsMask)&& + ((rtrn=_XkbAllocDoodads(geom,sizes->num_doodads))!=Success)) { + goto BAIL; + } + if ((sizes->which&XkbGeomKeyAliasesMask)&& + ((rtrn=_XkbAllocKeyAliases(geom,sizes->num_key_aliases))!=Success)) { + goto BAIL; + } + return Success; +BAIL: + XkbFreeGeometry(geom,XkbGeomAllMask,True); + xkb->geom= NULL; + return rtrn; +} + +/***====================================================================***/ + +XkbPropertyPtr +#if NeedFunctionPrototypes +XkbAddGeomProperty(XkbGeometryPtr geom,char *name,char *value) +#else +XkbAddGeomProperty(geom,name,value) + XkbGeometryPtr geom; + char * name; + char * value; +#endif +{ +register int i; +register XkbPropertyPtr prop; + + if ((!geom)||(!name)||(!value)) + return NULL; + for (i=0,prop=geom->properties;inum_properties;i++,prop++) { + if ((prop->name)&&(strcmp(name,prop->name)==0)) { + if (prop->value) + _XkbFree(prop->value); + prop->value= (char *)_XkbAlloc(strlen(value)+1); + if (prop->value) + strcpy(prop->value,value); + return prop; + } + } + if ((geom->num_properties>=geom->sz_properties)&& + (_XkbAllocProps(geom,1)!=Success)) { + return NULL; + } + prop= &geom->properties[geom->num_properties]; + prop->name= (char *)_XkbAlloc(strlen(name)+1); + if (!name) + return NULL; + strcpy(prop->name,name); + prop->value= (char *)_XkbAlloc(strlen(value)+1); + if (!value) { + _XkbFree(prop->name); + prop->name= NULL; + return NULL; + } + strcpy(prop->value,value); + geom->num_properties++; + return prop; +} + +XkbKeyAliasPtr +#if NeedFunctionPrototypes +XkbAddGeomKeyAlias(XkbGeometryPtr geom,char *aliasStr,char *realStr) +#else +XkbAddGeomKeyAlias(geom,aliasStr,realStr) + XkbGeometryPtr geom; + char * aliasStr; + char * realStr; +#endif +{ +register int i; +register XkbKeyAliasPtr alias; + + if ((!geom)||(!aliasStr)||(!realStr)||(!aliasStr[0])||(!realStr[0])) + return NULL; + for (i=0,alias=geom->key_aliases;inum_key_aliases;i++,alias++) { + if (strncmp(alias->alias,aliasStr,XkbKeyNameLength)==0) { + bzero(alias->real,XkbKeyNameLength); + strncpy(alias->real,realStr,XkbKeyNameLength); + return alias; + } + } + if ((geom->num_key_aliases>=geom->sz_key_aliases)&& + (_XkbAllocKeyAliases(geom,1)!=Success)) { + return NULL; + } + alias= &geom->key_aliases[geom->num_key_aliases]; + bzero(alias,sizeof(XkbKeyAliasRec)); + strncpy(alias->alias,aliasStr,XkbKeyNameLength); + strncpy(alias->real,realStr,XkbKeyNameLength); + geom->num_key_aliases++; + return alias; +} + +XkbColorPtr +#if NeedFunctionPrototypes +XkbAddGeomColor(XkbGeometryPtr geom,char *spec,unsigned int pixel) +#else +XkbAddGeomColor(geom,spec,pixel) + XkbGeometryPtr geom; + char * spec; + unsigned int pixel; +#endif +{ +register int i; +register XkbColorPtr color; + + if ((!geom)||(!spec)) + return NULL; + for (i=0,color=geom->colors;inum_colors;i++,color++) { + if ((color->spec)&&(strcmp(color->spec,spec)==0)) { + color->pixel= pixel; + return color; + } + } + if ((geom->num_colors>=geom->sz_colors)&& + (_XkbAllocColors(geom,1)!=Success)) { + return NULL; + } + color= &geom->colors[geom->num_colors]; + color->pixel= pixel; + color->spec= (char *)_XkbAlloc(strlen(spec)+1); + if (!color->spec) + return NULL; + strcpy(color->spec,spec); + geom->num_colors++; + return color; +} + +XkbOutlinePtr +#if NeedFunctionPrototypes +XkbAddGeomOutline(XkbShapePtr shape,int sz_points) +#else +XkbAddGeomOutline(shape,sz_points) + XkbShapePtr shape; + int sz_points; +#endif +{ +XkbOutlinePtr outline; + + if ((!shape)||(sz_points<0)) + return NULL; + if ((shape->num_outlines>=shape->sz_outlines)&& + (_XkbAllocOutlines(shape,1)!=Success)) { + return NULL; + } + outline= &shape->outlines[shape->num_outlines]; + bzero(outline,sizeof(XkbOutlineRec)); + if ((sz_points>0)&&(_XkbAllocPoints(outline,sz_points)!=Success)) + return NULL; + shape->num_outlines++; + return outline; +} + +XkbShapePtr +#if NeedFunctionPrototypes +XkbAddGeomShape(XkbGeometryPtr geom,Atom name,int sz_outlines) +#else +XkbAddGeomShape(geom,name,sz_outlines) + XkbGeometryPtr geom; + Atom name; + int sz_outlines; +#endif +{ +XkbShapePtr shape; +register int i; + + if ((!geom)||(!name)||(sz_outlines<0)) + return NULL; + if (geom->num_shapes>0) { + for (shape=geom->shapes,i=0;inum_shapes;i++,shape++) { + if (name==shape->name) + return shape; + } + } + if ((geom->num_shapes>=geom->sz_shapes)&& + (_XkbAllocShapes(geom,1)!=Success)) + return NULL; + shape= &geom->shapes[geom->num_shapes]; + bzero(shape,sizeof(XkbShapeRec)); + if ((sz_outlines>0)&&(_XkbAllocOutlines(shape,sz_outlines)!=Success)) + return NULL; + shape->name= name; + shape->primary= shape->approx= NULL; + geom->num_shapes++; + return shape; +} + +XkbKeyPtr +#if NeedFunctionPrototypes +XkbAddGeomKey(XkbRowPtr row) +#else +XkbAddGeomKey(row) + XkbRowPtr row; +#endif +{ +XkbKeyPtr key; + if (!row) + return NULL; + if ((row->num_keys>=row->sz_keys)&&(_XkbAllocKeys(row,1)!=Success)) + return NULL; + key= &row->keys[row->num_keys++]; + bzero(key,sizeof(XkbKeyRec)); + return key; +} + +XkbRowPtr +#if NeedFunctionPrototypes +XkbAddGeomRow(XkbSectionPtr section,int sz_keys) +#else +XkbAddGeomRow(section,sz_keys) + XkbSectionPtr section; + int sz_keys; +#endif +{ +XkbRowPtr row; + + if ((!section)||(sz_keys<0)) + return NULL; + if ((section->num_rows>=section->sz_rows)&& + (_XkbAllocRows(section,1)!=Success)) + return NULL; + row= §ion->rows[section->num_rows]; + bzero(row,sizeof(XkbRowRec)); + if ((sz_keys>0)&&(_XkbAllocKeys(row,sz_keys)!=Success)) + return NULL; + section->num_rows++; + return row; +} + +XkbSectionPtr +#if NeedFunctionPrototypes +XkbAddGeomSection( XkbGeometryPtr geom, + Atom name, + int sz_rows, + int sz_doodads, + int sz_over) +#else +XkbAddGeomSection(geom,name,sz_rows,sz_doodads,sz_over) + XkbGeometryPtr geom; + Atom name; + int sz_rows; + int sz_doodads; + int sz_over; +#endif +{ +register int i; +XkbSectionPtr section; + + if ((!geom)||(name==None)||(sz_rows<0)) + return NULL; + for (i=0,section=geom->sections;inum_sections;i++,section++) { + if (section->name!=name) + continue; + if (((sz_rows>0)&&(_XkbAllocRows(section,sz_rows)!=Success))|| + ((sz_doodads>0)&&(_XkbAllocDoodads(section,sz_doodads)!=Success))|| + ((sz_over>0)&&(_XkbAllocOverlays(section,sz_over)!=Success))) + return NULL; + return section; + } + if ((geom->num_sections>=geom->sz_sections)&& + (_XkbAllocSections(geom,1)!=Success)) + return NULL; + section= &geom->sections[geom->num_sections]; + if ((sz_rows>0)&&(_XkbAllocRows(section,sz_rows)!=Success)) + return NULL; + if ((sz_doodads>0)&&(_XkbAllocDoodads(section,sz_doodads)!=Success)) { + if (section->rows) { + _XkbFree(section->rows); + section->rows= NULL; + section->sz_rows= section->num_rows= 0; + } + return NULL; + } + section->name= name; + geom->num_sections++; + return section; +} + +XkbDoodadPtr +#if NeedFunctionPrototypes +XkbAddGeomDoodad(XkbGeometryPtr geom,XkbSectionPtr section,Atom name) +#else +XkbAddGeomDoodad(geom,section,name) + XkbGeometryPtr geom; + XkbSectionPtr section; + Atom name; +#endif +{ +XkbDoodadPtr old,doodad; +register int i,nDoodads; + + if ((!geom)||(name==None)) + return NULL; + if ((section!=NULL)&&(section->num_doodads>0)) { + old= section->doodads; + nDoodads= section->num_doodads; + } + else { + old= geom->doodads; + nDoodads= geom->num_doodads; + } + for (i=0,doodad=old;iany.name==name) + return doodad; + } + if (section) { + if ((section->num_doodads>=geom->sz_doodads)&& + (_XkbAllocDoodads(section,1)!=Success)) { + return NULL; + } + doodad= §ion->doodads[section->num_doodads++]; + } + else { + if ((geom->num_doodads>=geom->sz_doodads)&& + (_XkbAllocDoodads(geom,1)!=Success)) + return NULL; + doodad= &geom->doodads[geom->num_doodads++]; + } + bzero(doodad,sizeof(XkbDoodadRec)); + doodad->any.name= name; + return doodad; +} + +XkbOverlayKeyPtr +#if NeedFunctionPrototypes +XkbAddGeomOverlayKey( XkbOverlayPtr overlay, + XkbOverlayRowPtr row, + char * over, + char * under) +#else +XkbAddGeomOverlayKey(overlay,row,over,under) + XkbOverlayPtr overlay; + XkbOverlayRowPtr row; + char * over; + char * under; +#endif +{ +register int i; +XkbOverlayKeyPtr key; +XkbSectionPtr section; +XkbRowPtr row_under; +Bool found; + + if ((!overlay)||(!row)||(!over)||(!under)) + return NULL; + section= overlay->section_under; + if (row->row_under>=section->num_rows) + return NULL; + row_under= §ion->rows[row->row_under]; + for (i=0,found=False;inum_keys;i++) { + if (strncmp(under,row_under->keys[i].name.name,XkbKeyNameLength)==0) { + found= True; + break; + } + } + if (!found) + return NULL; + if ((row->num_keys>=row->sz_keys)&&(_XkbAllocOverlayKeys(row,1)!=Success)) + return NULL; + key= &row->keys[row->num_keys]; + strncpy(key->under.name,under,XkbKeyNameLength); + strncpy(key->over.name,over,XkbKeyNameLength); + row->num_keys++; + return key; +} + +XkbOverlayRowPtr +#if NeedFunctionPrototypes +XkbAddGeomOverlayRow(XkbOverlayPtr overlay,int row_under,int sz_keys) +#else +XkbAddGeomOverlayRow(overlay,row_under,sz_keys) + XkbOverlayPtr overlay; + int row_under; + int sz_keys; +#endif +{ +register int i; +XkbOverlayRowPtr row; + + if ((!overlay)||(sz_keys<0)) + return NULL; + if (row_under>=overlay->section_under->num_rows) + return NULL; + for (i=0;inum_rows;i++) { + if (overlay->rows[i].row_under==row_under) { + row= &overlay->rows[i]; + if ((row->sz_keysrows[i]; + } + } + if ((overlay->num_rows>=overlay->sz_rows)&& + (_XkbAllocOverlayRows(overlay,1)!=Success)) + return NULL; + row= &overlay->rows[overlay->num_rows]; + bzero(row,sizeof(XkbOverlayRowRec)); + if ((sz_keys>0)&&(_XkbAllocOverlayKeys(row,sz_keys)!=Success)) + return NULL; + row->row_under= row_under; + overlay->num_rows++; + return row; +} + +XkbOverlayPtr +#if NeedFunctionPrototypes +XkbAddGeomOverlay(XkbSectionPtr section,Atom name,int sz_rows) +#else +XkbAddGeomOverlay(section,name,sz_rows) + XkbSectionPtr section; + Atom name; + int sz_rows; +#endif +{ +register int i; +XkbOverlayPtr overlay; + + if ((!section)||(name==None)||(sz_rows==0)) + return NULL; + + for (i=0,overlay=section->overlays;inum_overlays;i++,overlay++) { + if (overlay->name==name) { + if ((sz_rows>0)&&(_XkbAllocOverlayRows(overlay,sz_rows)!=Success)) + return NULL; + return overlay; + } + } + if ((section->num_overlays>=section->sz_overlays)&& + (_XkbAllocOverlays(section,1)!=Success)) + return NULL; + overlay= §ion->overlays[section->num_overlays]; + if ((sz_rows>0)&&(_XkbAllocOverlayRows(overlay,sz_rows)!=Success)) + return NULL; + overlay->name= name; + overlay->section_under= section; + section->num_overlays++; + return overlay; +} -- cgit v1.2.3