xkb: xkbgeom.h: drop #define's on function names

There's no use in redefining function names via preprocessor this
funny ways. Perhaps there once was back when that header used to
live outside the server tree, but that's decades ago.

Signed-off-by: Enrico Weigelt, metux IT consult <info@metux.net>

xkb/XKBGAlloc.c

@@ -34,6 +34,9 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include <xkbsrv.h>
 #include "xkbgeom.h"
 
+static void
+SrvXkbFreeGeomDoodads(XkbDoodadPtr doodads, int nDoodads, Bool freeAll);
+
 /***====================================================================***/
 
 static void
@@ -136,8 +139,8 @@ _XkbClearProperty(char *prop_in)
     return;
 }
 
-void
+static void
-XkbFreeGeomProperties(XkbGeometryPtr geom, int first, int count, Bool freeAll)
+SrvXkbFreeGeomProperties(XkbGeometryPtr geom, int first, int count, Bool freeAll)
 {
     _XkbFreeGeomNonLeafElems(freeAll, first, count,
                              &geom->num_properties, &geom->sz_properties,
@@ -148,8 +151,8 @@ XkbFreeGeomProperties(XkbGeometryPtr geom, int first, int count, Bool freeAll)
 
 /***====================================================================***/
 
-void
+static void
-XkbFreeGeomKeyAliases(XkbGeometryPtr geom, int first, int count, Bool freeAll)
+SrvXkbFreeGeomKeyAliases(XkbGeometryPtr geom, int first, int count, Bool freeAll)
 {
     _XkbFreeGeomLeafElems(freeAll, first, count,
                           &geom->num_key_aliases, &geom->sz_key_aliases,
@@ -168,8 +171,8 @@ _XkbClearColor(char *color_in)
     return;
 }
 
-void
+static void
-XkbFreeGeomColors(XkbGeometryPtr geom, int first, int count, Bool freeAll)
+SrvXkbFreeGeomColors(XkbGeometryPtr geom, int first, int count, Bool freeAll)
 {
     _XkbFreeGeomNonLeafElems(freeAll, first, count,
                              &geom->num_colors, &geom->sz_colors,
@@ -180,8 +183,8 @@ XkbFreeGeomColors(XkbGeometryPtr geom, int first, int count, Bool freeAll)
 
 /***====================================================================***/
 
-void
+static void
-XkbFreeGeomPoints(XkbOutlinePtr outline, int first, int count, Bool freeAll)
+SrvXkbFreeGeomPoints(XkbOutlinePtr outline, int first, int count, Bool freeAll)
 {
     _XkbFreeGeomLeafElems(freeAll, first, count,
                           &outline->num_points, &outline->sz_points,
@@ -197,7 +200,7 @@ _XkbClearOutline(char *outline_in)
     XkbOutlinePtr outline = (XkbOutlinePtr) outline_in;
 
     if (outline->points != NULL)
-        XkbFreeGeomPoints(outline, 0, outline->num_points, TRUE);
+        SrvXkbFreeGeomPoints(outline, 0, outline->num_points, TRUE);
     return;
 }
 
@@ -247,8 +250,8 @@ XkbFreeGeomOverlayKeys(XkbOverlayRowPtr row, int first, int count, Bool freeAll)
 
 /***====================================================================***/
 
-void
+static void
-XkbFreeGeomKeys(XkbRowPtr row, int first, int count, Bool freeAll)
+SrvXkbFreeGeomKeys(XkbRowPtr row, int first, int count, Bool freeAll)
 {
     _XkbFreeGeomLeafElems(freeAll, first, count,
                           &row->num_keys, &row->sz_keys,
@@ -264,12 +267,12 @@ _XkbClearRow(char *row_in)
     XkbRowPtr row = (XkbRowPtr) row_in;
 
     if (row->keys != NULL)
-        XkbFreeGeomKeys(row, 0, row->num_keys, TRUE);
+        SrvXkbFreeGeomKeys(row, 0, row->num_keys, TRUE);
     return;
 }
 
-void
+static void
-XkbFreeGeomRows(XkbSectionPtr section, int first, int count, Bool freeAll)
+SrvXkbFreeGeomRows(XkbSectionPtr section, int first, int count, Bool freeAll)
 {
     _XkbFreeGeomNonLeafElems(freeAll, first, count,
                              &section->num_rows, &section->sz_rows,
@@ -285,16 +288,16 @@ _XkbClearSection(char *section_in)
     XkbSectionPtr section = (XkbSectionPtr) section_in;
 
     if (section->rows != NULL)
-        XkbFreeGeomRows(section, 0, section->num_rows, TRUE);
+        SrvXkbFreeGeomRows(section, 0, section->num_rows, TRUE);
     if (section->doodads != NULL) {
-        XkbFreeGeomDoodads(section->doodads, section->num_doodads, TRUE);
+        SrvXkbFreeGeomDoodads(section->doodads, section->num_doodads, TRUE);
         section->doodads = NULL;
     }
     return;
 }
 
-void
+static void
-XkbFreeGeomSections(XkbGeometryPtr geom, int first, int count, Bool freeAll)
+SrvXkbFreeGeomSections(XkbGeometryPtr geom, int first, int count, Bool freeAll)
 {
     _XkbFreeGeomNonLeafElems(freeAll, first, count,
                              &geom->num_sections, &geom->sz_sections,
@@ -329,8 +332,8 @@ _XkbClearDoodad(char *doodad_in)
     return;
 }
 
-void
+static void
-XkbFreeGeomDoodads(XkbDoodadPtr doodads, int nDoodads, Bool freeAll)
+SrvXkbFreeGeomDoodads(XkbDoodadPtr doodads, int nDoodads, Bool freeAll)
 {
     register int i;
     register XkbDoodadPtr doodad;
@@ -353,20 +356,20 @@ XkbFreeGeometry(XkbGeometryPtr geom, unsigned which, Bool freeMap)
     if (freeMap)
         which = XkbGeomAllMask;
     if ((which & XkbGeomPropertiesMask) && (geom->properties != NULL))
-        XkbFreeGeomProperties(geom, 0, geom->num_properties, TRUE);
+        SrvXkbFreeGeomProperties(geom, 0, geom->num_properties, TRUE);
     if ((which & XkbGeomColorsMask) && (geom->colors != NULL))
-        XkbFreeGeomColors(geom, 0, geom->num_colors, TRUE);
+        SrvXkbFreeGeomColors(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);
+        SrvXkbFreeGeomSections(geom, 0, geom->num_sections, TRUE);
     if ((which & XkbGeomDoodadsMask) && (geom->doodads != NULL)) {
-        XkbFreeGeomDoodads(geom->doodads, geom->num_doodads, TRUE);
+        SrvXkbFreeGeomDoodads(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);
+        SrvXkbFreeGeomKeyAliases(geom, 0, geom->num_key_aliases, TRUE);
     if (freeMap) {
         free(geom->label_font);
         geom->label_font = NULL;
@@ -496,7 +499,7 @@ _XkbGeomAlloc(void **old,
 				(n),sizeof(XkbOverlayKeyRec))
 
 Status
-XkbAllocGeometry(XkbDescPtr xkb, XkbGeometrySizesPtr sizes)
+SrvXkbAllocGeometry(XkbDescPtr xkb, XkbGeometrySizesPtr sizes)
 {
     XkbGeometryPtr geom;
     Status rtrn;
@@ -542,7 +545,7 @@ XkbAllocGeometry(XkbDescPtr xkb, XkbGeometrySizesPtr sizes)
 /***====================================================================***/
 
 XkbPropertyPtr
-XkbAddGeomProperty(XkbGeometryPtr geom, char *name, char *value)
+SrvXkbAddGeomProperty(XkbGeometryPtr geom, char *name, char *value)
 {
     register int i;
     register XkbPropertyPtr prop;
@@ -575,7 +578,7 @@ XkbAddGeomProperty(XkbGeometryPtr geom, char *name, char *value)
 }
 
 XkbKeyAliasPtr
-XkbAddGeomKeyAlias(XkbGeometryPtr geom, char *aliasStr, char *realStr)
+SrvXkbAddGeomKeyAlias(XkbGeometryPtr geom, char *aliasStr, char *realStr)
 {
     register int i;
     register XkbKeyAliasPtr alias;
@@ -603,7 +606,7 @@ XkbAddGeomKeyAlias(XkbGeometryPtr geom, char *aliasStr, char *realStr)
 }
 
 XkbColorPtr
-XkbAddGeomColor(XkbGeometryPtr geom, char *spec, unsigned int pixel)
+SrvXkbAddGeomColor(XkbGeometryPtr geom, char *spec, unsigned int pixel)
 {
     register int i;
     register XkbColorPtr color;
@@ -630,7 +633,7 @@ XkbAddGeomColor(XkbGeometryPtr geom, char *spec, unsigned int pixel)
 }
 
 XkbOutlinePtr
-XkbAddGeomOutline(XkbShapePtr shape, int sz_points)
+SrvXkbAddGeomOutline(XkbShapePtr shape, int sz_points)
 {
     XkbOutlinePtr outline;
 
@@ -649,7 +652,7 @@ XkbAddGeomOutline(XkbShapePtr shape, int sz_points)
 }
 
 XkbShapePtr
-XkbAddGeomShape(XkbGeometryPtr geom, Atom name, int sz_outlines)
+SrvXkbAddGeomShape(XkbGeometryPtr geom, Atom name, int sz_outlines)
 {
     XkbShapePtr shape;
     register int i;
@@ -676,7 +679,7 @@ XkbAddGeomShape(XkbGeometryPtr geom, Atom name, int sz_outlines)
 }
 
 XkbKeyPtr
-XkbAddGeomKey(XkbRowPtr row)
+SrvXkbAddGeomKey(XkbRowPtr row)
 {
     XkbKeyPtr key;
 
@@ -690,7 +693,7 @@ XkbAddGeomKey(XkbRowPtr row)
 }
 
 XkbRowPtr
-XkbAddGeomRow(XkbSectionPtr section, int sz_keys)
+SrvXkbAddGeomRow(XkbSectionPtr section, int sz_keys)
 {
     XkbRowPtr row;
 
@@ -708,8 +711,8 @@ XkbAddGeomRow(XkbSectionPtr section, int sz_keys)
 }
 
 XkbSectionPtr
-XkbAddGeomSection(XkbGeometryPtr geom,
+SrvXkbAddGeomSection(XkbGeometryPtr geom,
-                  Atom name, int sz_rows, int sz_doodads, int sz_over)
+                     Atom name, int sz_rows, int sz_doodads, int sz_over)
 {
     register int i;
     XkbSectionPtr section;
@@ -747,7 +750,7 @@ XkbAddGeomSection(XkbGeometryPtr geom,
 }
 
 XkbDoodadPtr
-XkbAddGeomDoodad(XkbGeometryPtr geom, XkbSectionPtr section, Atom name)
+SrvXkbAddGeomDoodad(XkbGeometryPtr geom, XkbSectionPtr section, Atom name)
 {
     XkbDoodadPtr old, doodad;
     register int i, nDoodads;
@@ -785,8 +788,8 @@ XkbAddGeomDoodad(XkbGeometryPtr geom, XkbSectionPtr section, Atom name)
 }
 
 XkbOverlayKeyPtr
-XkbAddGeomOverlayKey(XkbOverlayPtr overlay,
+SrvXkbAddGeomOverlayKey(XkbOverlayPtr overlay,
-                     XkbOverlayRowPtr row, char *over, char *under)
+                        XkbOverlayRowPtr row, char *over, char *under)
 {
     register int i;
     XkbOverlayKeyPtr key;
@@ -819,7 +822,7 @@ XkbAddGeomOverlayKey(XkbOverlayPtr overlay,
 }
 
 XkbOverlayRowPtr
-XkbAddGeomOverlayRow(XkbOverlayPtr overlay, int row_under, int sz_keys)
+SrvXkbAddGeomOverlayRow(XkbOverlayPtr overlay, int row_under, int sz_keys)
 {
     register int i;
     XkbOverlayRowPtr row;
@@ -851,7 +854,7 @@ XkbAddGeomOverlayRow(XkbOverlayPtr overlay, int row_under, int sz_keys)
 }
 
 XkbOverlayPtr
-XkbAddGeomOverlay(XkbSectionPtr section, Atom name, int sz_rows)
+SrvXkbAddGeomOverlay(XkbSectionPtr section, Atom name, int sz_rows)
 {
     register int i;
     XkbOverlayPtr overlay;

xkb/xkb.c

@@ -5179,7 +5179,7 @@ _CheckSetDoodad(char **wire_inout, xkbSetGeometryReq *req,
         swaps(&any.angle);
     }
     CHK_ATOM_ONLY(dWire->any.name);
-    doodad = XkbAddGeomDoodad(geom, section, any.name);
+    doodad = SrvXkbAddGeomDoodad(geom, section, any.name);
     if (!doodad)
         return BadAlloc;
     doodad->any.type = dWire->any.type;
@@ -5290,7 +5290,7 @@ _CheckSetOverlay(char **wire_inout, xkbSetGeometryReq *req,
         swapl(&olWire->name);
     }
     CHK_ATOM_ONLY(olWire->name);
-    ol = XkbAddGeomOverlay(section, olWire->name, olWire->nRows);
+    ol = SrvXkbAddGeomOverlay(section, olWire->name, olWire->nRows);
     rWire = (xkbOverlayRowWireDesc *) &olWire[1];
     for (r = 0; r < olWire->nRows; r++) {
         register int k;
@@ -5305,15 +5305,15 @@ _CheckSetOverlay(char **wire_inout, xkbSetGeometryReq *req,
                                               rWire->rowUnder);
             return BadMatch;
         }
-        row = XkbAddGeomOverlayRow(ol, rWire->rowUnder, rWire->nKeys);
+        row = SrvXkbAddGeomOverlayRow(ol, rWire->rowUnder, rWire->nKeys);
         kWire = (xkbOverlayKeyWireDesc *) &rWire[1];
         for (k = 0; k < rWire->nKeys; k++, kWire++) {
             if (!_XkbCheckRequestBounds(client, req, kWire, kWire + 1))
                 return BadLength;
 
-            if (XkbAddGeomOverlayKey(ol, row,
+            if (SrvXkbAddGeomOverlayKey(ol, row,
-                                     (char *) kWire->over,
+                                        (char *) kWire->over,
-                                     (char *) kWire->under) == NULL) {
+                                        (char *) kWire->under) == NULL) {
                 client->errorValue = _XkbErrCode3(0x21, r, k);
                 return BadMatch;
             }
@@ -5356,8 +5356,8 @@ _CheckSetSections(XkbGeometryPtr geom,
             swaps(&sWire->angle);
         }
         CHK_ATOM_ONLY(sWire->name);
-        section = XkbAddGeomSection(geom, sWire->name, sWire->nRows,
+        section = SrvXkbAddGeomSection(geom, sWire->name, sWire->nRows,
-                                    sWire->nDoodads, sWire->nOverlays);
+                                       sWire->nDoodads, sWire->nOverlays);
         if (!section)
             return BadAlloc;
         section->priority = sWire->priority;
@@ -5379,7 +5379,7 @@ _CheckSetSections(XkbGeometryPtr geom,
                 swaps(&rWire->top);
                 swaps(&rWire->left);
             }
-            row = XkbAddGeomRow(section, rWire->nKeys);
+            row = SrvXkbAddGeomRow(section, rWire->nKeys);
             if (!row)
                 return BadAlloc;
             row->top = rWire->top;
@@ -5392,7 +5392,7 @@ _CheckSetSections(XkbGeometryPtr geom,
                 if (!_XkbCheckRequestBounds(client, req, kWire, kWire + 1))
                     return BadLength;
 
-                key = XkbAddGeomKey(row);
+                key = SrvXkbAddGeomKey(row);
                 if (!key)
                     return BadAlloc;
                 memcpy(key->name.name, kWire->name, XkbKeyNameLength);
@@ -5464,7 +5464,7 @@ _CheckSetShapes(XkbGeometryPtr geom,
                 return BadLength;
 
             shape =
-                XkbAddGeomShape(geom, shapeWire->name, shapeWire->nOutlines);
+                SrvXkbAddGeomShape(geom, shapeWire->name, shapeWire->nOutlines);
             if (!shape)
                 return BadAlloc;
             olWire = (xkbOutlineWireDesc *) (&shapeWire[1]);
@@ -5476,7 +5476,7 @@ _CheckSetShapes(XkbGeometryPtr geom,
                 if (!_XkbCheckRequestBounds(client, req, olWire, olWire + 1))
                     return BadLength;
 
-                ol = XkbAddGeomOutline(shape, olWire->nPoints);
+                ol = SrvXkbAddGeomOutline(shape, olWire->nPoints);
                 if (!ol)
                     return BadAlloc;
                 ol->corner_radius = olWire->cornerRadius;
@@ -5535,7 +5535,7 @@ _CheckSetGeom(XkbGeometryPtr geom, xkbSetGeometryReq * req, ClientPtr client)
             free(name);
             return status;
         }
-        if (XkbAddGeomProperty(geom, name, val) == NULL) {
+        if (SrvXkbAddGeomProperty(geom, name, val) == NULL) {
             free(name);
             free(val);
             return BadAlloc;
@@ -5570,7 +5570,7 @@ _CheckSetGeom(XkbGeometryPtr geom, xkbSetGeometryReq * req, ClientPtr client)
         status = _GetCountedString(&wire, client, &name);
         if (status != Success)
             return status;
-        if (!XkbAddGeomColor(geom, name, geom->num_colors)) {
+        if (!SrvXkbAddGeomColor(geom, name, geom->num_colors)) {
             free(name);
             return BadAlloc;
         }
@@ -5599,7 +5599,7 @@ _CheckSetGeom(XkbGeometryPtr geom, xkbSetGeometryReq * req, ClientPtr client)
         if (!_XkbCheckRequestBounds(client, req, wire, wire + XkbKeyNameLength))
                 return BadLength;
 
-        if (XkbAddGeomKeyAlias(geom, &wire[XkbKeyNameLength], wire) == NULL)
+        if (SrvXkbAddGeomKeyAlias(geom, &wire[XkbKeyNameLength], wire) == NULL)
             return BadAlloc;
         wire += 2 * XkbKeyNameLength;
     }
@@ -5627,7 +5627,7 @@ _XkbSetGeometry(ClientPtr client, DeviceIntPtr dev, xkbSetGeometryReq * stuff)
     sizes.num_sections = stuff->nSections;
     sizes.num_doodads = stuff->nDoodads;
     sizes.num_key_aliases = stuff->nKeyAliases;
-    if ((status = XkbAllocGeometry(xkb, &sizes)) != Success) {
+    if ((status = SrvXkbAllocGeometry(xkb, &sizes)) != Success) {
         xkb->geom = old;
         return status;
     }

xkb/xkbgeom.h

@@ -29,31 +29,6 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 #include "xkbstr.h"
 
-#define XkbAddGeomKeyAlias 		SrvXkbAddGeomKeyAlias
-#define XkbAddGeomColor 		SrvXkbAddGeomColor
-#define XkbAddGeomDoodad		SrvXkbAddGeomDoodad
-#define XkbAddGeomKey			SrvXkbAddGeomKey
-#define XkbAddGeomOutline		SrvXkbAddGeomOutline
-#define XkbAddGeomOverlay		SrvXkbAddGeomOverlay
-#define XkbAddGeomOverlayRow		SrvXkbAddGeomOverlayRow
-#define	XkbAddGeomOverlayKey		SrvXkbAddGeomOverlayKey
-#define XkbAddGeomProperty		SrvXkbAddGeomProperty
-#define XkbAddGeomRow			SrvXkbAddGeomRow
-#define XkbAddGeomSection		SrvXkbAddGeomSection
-#define XkbAddGeomShape			SrvXkbAddGeomShape
-#define XkbAllocGeometry		SrvXkbAllocGeometry
-#define XkbFreeGeomKeyAliases		SrvXkbFreeGeomKeyAliases
-#define XkbFreeGeomColors		SrvXkbFreeGeomColors
-#define XkbFreeGeomDoodads		SrvXkbFreeGeomDoodads
-#define XkbFreeGeomProperties		SrvXkbFreeGeomProperties
-#define	XkbFreeGeomKeys			SrvXkbFreeGeomKeys
-#define	XkbFreeGeomRows			SrvXkbFreeGeomRows
-#define XkbFreeGeomSections		SrvXkbFreeGeomSections
-#define	XkbFreeGeomPoints		SrvXkbFreeGeomPoints
-#define	XkbFreeGeomOutlines		SrvXkbFreeGeomOutlines
-#define XkbFreeGeomShapes		SrvXkbFreeGeomShapes
-#define XkbFreeGeometry			SrvXkbFreeGeometry
-
 typedef struct _XkbProperty {
     char *name;
     char *value;
@@ -312,91 +287,49 @@ typedef enum {
     XKB_GEOM_CLEAR_ALL          /* Clear all items after reallocation.       */
 } XkbGeomClearance;
 
-extern XkbPropertyPtr XkbAddGeomProperty(XkbGeometryPtr /* geom */ ,
+XkbPropertyPtr SrvXkbAddGeomProperty(XkbGeometryPtr geom,
-                                         char * /* name */ ,
+                                     char *name,
-                                         char * /* value */
+                                     char *value);
-    );
 
-extern XkbKeyAliasPtr XkbAddGeomKeyAlias(XkbGeometryPtr /* geom */ ,
+XkbKeyAliasPtr SrvXkbAddGeomKeyAlias(XkbGeometryPtr geom,
-                                         char * /* alias */ ,
+                                     char *alias,
-                                         char * /* real */
+                                     char *real);
-    );
 
-extern XkbColorPtr XkbAddGeomColor(XkbGeometryPtr /* geom */ ,
+XkbColorPtr SrvXkbAddGeomColor(XkbGeometryPtr geom,
-                                   char * /* spec */ ,
+                               char *spec,
-                                   unsigned int /* pixel */
+                               unsigned int pixel);
-    );
 
-extern XkbOutlinePtr XkbAddGeomOutline(XkbShapePtr /* shape */ ,
+XkbOutlinePtr SrvXkbAddGeomOutline(XkbShapePtr shape, int sz_points);
-                                       int      /* sz_points */
-    );
 
-extern XkbShapePtr XkbAddGeomShape(XkbGeometryPtr /* geom */ ,
+XkbShapePtr SrvXkbAddGeomShape(XkbGeometryPtr geom,
-                                   Atom /* name */ ,
+                               Atom name,
-                                   int  /* sz_outlines */
+                               int sz_outlines);
-    );
 
-extern XkbKeyPtr XkbAddGeomKey(XkbRowPtr        /* row */
+XkbKeyPtr SrvXkbAddGeomKey(XkbRowPtr row);
-    );
+XkbRowPtr SrvXkbAddGeomRow(XkbSectionPtr section, int sz_keys);
 
-extern XkbRowPtr XkbAddGeomRow(XkbSectionPtr /* section */ ,
+XkbSectionPtr SrvXkbAddGeomSection(XkbGeometryPtr geom,
-                               int      /* sz_keys */
+                                   Atom name,
-    );
+                                   int sz_rows,
+                                   int sz_doodads,
+                                   int sz_overlays);
 
-extern XkbSectionPtr XkbAddGeomSection(XkbGeometryPtr /* geom */ ,
+XkbOverlayPtr SrvXkbAddGeomOverlay(XkbSectionPtr section,
-                                       Atom /* name */ ,
+                                   Atom name,
-                                       int /* sz_rows */ ,
+                                   int sz_rows);
-                                       int /* sz_doodads */ ,
-                                       int      /* sz_overlays */
-    );
 
-extern XkbOverlayPtr XkbAddGeomOverlay(XkbSectionPtr /* section */ ,
+XkbOverlayRowPtr SrvXkbAddGeomOverlayRow(XkbOverlayPtr overlay,
-                                       Atom /* name */ ,
+                                         int row_under,
-                                       int      /* sz_rows */
+                                         int sz_keys);
-    );
 
-extern XkbOverlayRowPtr XkbAddGeomOverlayRow(XkbOverlayPtr /* overlay */ ,
+XkbOverlayKeyPtr SrvXkbAddGeomOverlayKey(XkbOverlayPtr overlay,
-                                             int /* row_under */ ,
+                                         XkbOverlayRowPtr row,
-                                             int        /* sz_keys */
+                                         char *over,
-    );
+                                         char *under);
 
-extern XkbOverlayKeyPtr XkbAddGeomOverlayKey(XkbOverlayPtr /* overlay */ ,
+XkbDoodadPtr SrvXkbAddGeomDoodad(XkbGeometryPtr geom,
-                                             XkbOverlayRowPtr /* row */ ,
+                                 XkbSectionPtr section,
-                                             char * /* over */ ,
+                                 Atom name);
-                                             char *     /* under */
-    );
-
-extern XkbDoodadPtr XkbAddGeomDoodad(XkbGeometryPtr /* geom */ ,
-                                     XkbSectionPtr /* section */ ,
-                                     Atom       /* name */
-    );
-
-extern void
- XkbFreeGeomKeyAliases(XkbGeometryPtr /* geom */ ,
-                       int /* first */ ,
-                       int /* count */ ,
-                       Bool     /* freeAll */
-    );
-
-extern void
- XkbFreeGeomColors(XkbGeometryPtr /* geom */ ,
-                   int /* first */ ,
-                   int /* count */ ,
-                   Bool         /* freeAll */
-    );
-
-extern void
- XkbFreeGeomDoodads(XkbDoodadPtr /* doodads */ ,
-                    int /* nDoodads */ ,
-                    Bool        /* freeAll */
-    );
-
-extern void
- XkbFreeGeomProperties(XkbGeometryPtr /* geom */ ,
-                       int /* first */ ,
-                       int /* count */ ,
-                       Bool     /* freeAll */
-    );
 
 extern void
  XkbFreeGeomOverlayKeys(XkbOverlayRowPtr /* row */ ,
@@ -419,34 +352,6 @@ extern void
                      Bool       /* freeAll */
     );
 
-extern void
- XkbFreeGeomKeys(XkbRowPtr /* row */ ,
-                 int /* first */ ,
-                 int /* count */ ,
-                 Bool           /* freeAll */
-    );
-
-extern void
- XkbFreeGeomRows(XkbSectionPtr /* section */ ,
-                 int /* first */ ,
-                 int /* count */ ,
-                 Bool           /* freeAll */
-    );
-
-extern void
- XkbFreeGeomSections(XkbGeometryPtr /* geom */ ,
-                     int /* first */ ,
-                     int /* count */ ,
-                     Bool       /* freeAll */
-    );
-
-extern void
- XkbFreeGeomPoints(XkbOutlinePtr /* outline */ ,
-                   int /* first */ ,
-                   int /* count */ ,
-                   Bool         /* freeAll */
-    );
-
 extern void
  XkbFreeGeomOutlines(XkbShapePtr /* shape */ ,
                      int /* first */ ,
@@ -531,9 +436,7 @@ extern Status XkbAllocGeomKeys(XkbRowPtr /* row */ ,
                                int      /* nKeys */
     );
 
-extern Status XkbAllocGeometry(XkbDescPtr /* xkb */ ,
+Status SrvXkbAllocGeometry(XkbDescPtr xkb, XkbGeometrySizesPtr sizes);
-                               XkbGeometrySizesPtr      /* sizes */
-    );
 
 extern Bool
  XkbComputeShapeTop(XkbShapePtr /* shape */ ,

xkb/xkmread.c

@@ -868,7 +868,7 @@ ReadXkmGeomDoodad(FILE * file, XkbGeometryPtr geom, XkbSectionPtr section)
     nRead += XkmGetCountedString(file, buf, 100);
     tmp = fread(&doodadWire, SIZEOF(xkmDoodadDesc), 1, file);
     nRead += SIZEOF(xkmDoodadDesc) * tmp;
-    doodad = XkbAddGeomDoodad(geom, section, XkbInternAtom(buf, FALSE));
+    doodad = SrvXkbAddGeomDoodad(geom, section, XkbInternAtom(buf, FALSE));
     if (!doodad)
         return nRead;
     doodad->any.type = doodadWire.any.type;
@@ -926,7 +926,7 @@ ReadXkmGeomOverlay(FILE * file, XkbGeometryPtr geom, XkbSectionPtr section)
     nRead += XkmGetCountedString(file, buf, 100);
     tmp = fread(&olWire, SIZEOF(xkmOverlayDesc), 1, file);
     nRead += tmp * SIZEOF(xkmOverlayDesc);
-    ol = XkbAddGeomOverlay(section, XkbInternAtom(buf, FALSE), olWire.num_rows);
+    ol = SrvXkbAddGeomOverlay(section, XkbInternAtom(buf, FALSE), olWire.num_rows);
     if (!ol)
         return nRead;
     for (r = 0; r < olWire.num_rows; r++) {
@@ -935,7 +935,7 @@ ReadXkmGeomOverlay(FILE * file, XkbGeometryPtr geom, XkbSectionPtr section)
 
         tmp = fread(&rowWire, SIZEOF(xkmOverlayRowDesc), 1, file);
         nRead += tmp * SIZEOF(xkmOverlayRowDesc);
-        row = XkbAddGeomOverlayRow(ol, rowWire.row_under, rowWire.num_keys);
+        row = SrvXkbAddGeomOverlayRow(ol, rowWire.row_under, rowWire.num_keys);
         if (!row) {
             _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeomOverlay", 0);
             return nRead;
@@ -966,9 +966,9 @@ ReadXkmGeomSection(FILE * file, XkbGeometryPtr geom)
     nameAtom = XkbInternAtom(buf, FALSE);
     tmp = fread(&sectionWire, SIZEOF(xkmSectionDesc), 1, file);
     nRead += SIZEOF(xkmSectionDesc) * tmp;
-    section = XkbAddGeomSection(geom, nameAtom, sectionWire.num_rows,
+    section = SrvXkbAddGeomSection(geom, nameAtom, sectionWire.num_rows,
-                                sectionWire.num_doodads,
+                                   sectionWire.num_doodads,
-                                sectionWire.num_overlays);
+                                   sectionWire.num_overlays);
     if (!section) {
         _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeomSection", 0);
         return nRead;
@@ -989,7 +989,7 @@ ReadXkmGeomSection(FILE * file, XkbGeometryPtr geom)
         for (i = 0; i < sectionWire.num_rows; i++) {
             tmp = fread(&rowWire, SIZEOF(xkmRowDesc), 1, file);
             nRead += SIZEOF(xkmRowDesc) * tmp;
-            row = XkbAddGeomRow(section, rowWire.num_keys);
+            row = SrvXkbAddGeomRow(section, rowWire.num_keys);
             if (!row) {
                 _XkbLibError(_XkbErrBadAlloc, "ReadXkmKeycodes", 0);
                 return nRead;
@@ -1000,7 +1000,7 @@ ReadXkmGeomSection(FILE * file, XkbGeometryPtr geom)
             for (k = 0; k < rowWire.num_keys; k++) {
                 tmp = fread(&keyWire, SIZEOF(xkmKeyDesc), 1, file);
                 nRead += SIZEOF(xkmKeyDesc) * tmp;
-                key = XkbAddGeomKey(row);
+                key = SrvXkbAddGeomKey(row);
                 if (!key) {
                     _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeomSection", 0);
                     return nRead;
@@ -1052,7 +1052,7 @@ ReadXkmGeometry(FILE * file, XkbDescPtr xkb)
     sizes.num_sections = wireGeom.num_sections;
     sizes.num_doodads = wireGeom.num_doodads;
     sizes.num_key_aliases = wireGeom.num_key_aliases;
-    if (XkbAllocGeometry(xkb, &sizes) != Success) {
+    if (SrvXkbAllocGeometry(xkb, &sizes) != Success) {
         _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeometry", 0);
         return nRead;
     }
@@ -1068,7 +1068,7 @@ ReadXkmGeometry(FILE * file, XkbDescPtr xkb)
         for (i = 0; i < wireGeom.num_properties; i++) {
             nRead += XkmGetCountedString(file, buf, 100);
             nRead += XkmGetCountedString(file, val, 1024);
-            if (XkbAddGeomProperty(geom, buf, val) == NULL) {
+            if (SrvXkbAddGeomProperty(geom, buf, val) == NULL) {
                 _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeometry", 0);
                 return nRead;
             }
@@ -1077,7 +1077,7 @@ ReadXkmGeometry(FILE * file, XkbDescPtr xkb)
     if (wireGeom.num_colors > 0) {
         for (i = 0; i < wireGeom.num_colors; i++) {
             nRead += XkmGetCountedString(file, buf, 100);
-            if (XkbAddGeomColor(geom, buf, i) == NULL) {
+            if (SrvXkbAddGeomColor(geom, buf, i) == NULL) {
                 _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeometry", 0);
                 return nRead;
             }
@@ -1099,7 +1099,7 @@ ReadXkmGeometry(FILE * file, XkbDescPtr xkb)
             nameAtom = XkbInternAtom(buf, FALSE);
             tmp = fread(&shapeWire, SIZEOF(xkmShapeDesc), 1, file);
             nRead += tmp * SIZEOF(xkmShapeDesc);
-            shape = XkbAddGeomShape(geom, nameAtom, shapeWire.num_outlines);
+            shape = SrvXkbAddGeomShape(geom, nameAtom, shapeWire.num_outlines);
             if (!shape) {
                 _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeometry", 0);
                 return nRead;
@@ -1110,7 +1110,7 @@ ReadXkmGeometry(FILE * file, XkbDescPtr xkb)
 
                 tmp = fread(&olWire, SIZEOF(xkmOutlineDesc), 1, file);
                 nRead += tmp * SIZEOF(xkmOutlineDesc);
-                ol = XkbAddGeomOutline(shape, olWire.num_points);
+                ol = SrvXkbAddGeomOutline(shape, olWire.num_points);
                 if (!ol) {
                     _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeometry", 0);
                     return nRead;