/************************************************************
 Copyright (c) 1994 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.

 ********************************************************/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <X11/Xfuncs.h>
#include <X11/Xlib.h>
#include <X11/XKBlib.h>
#include <X11/extensions/XKBgeom.h>

#include "XKMformat.h"
#include "XKBfileInt.h"

typedef struct _XkmInfo {
    unsigned short bound_vmods;
    unsigned short named_vmods;
    unsigned char  num_bound;
    unsigned char  group_compat;
    unsigned short num_group_compat;
    unsigned short num_leds;
    int            total_vmodmaps;
} XkmInfo;

/***====================================================================***/

#define	xkmPutCARD8(f,v)	(putc(v,f),1)

static int
xkmPutCARD16(FILE *file, unsigned val)
{
    CARD16 tmp = val;

    fwrite(&tmp, 2, 1, file);
    return 2;
}

static int
xkmPutCARD32(FILE *file, unsigned long val)
{
    CARD32 tmp = val;

    fwrite(&tmp, 4, 1, file);
    return 4;
}

static int
xkmPutPadding(FILE *file, unsigned pad)
{
    int i;

    for (i = 0; i < pad; i++) {
        putc('\0', file);
    }
    return pad;
}

static int
xkmPutCountedBytes(FILE *file, char *ptr, unsigned count)
{
    register int nOut;
    register unsigned pad;

    if (count == 0)
        return xkmPutCARD32(file, (unsigned long) 0);

    xkmPutCARD16(file, count);
    nOut = fwrite(ptr, 1, count, file);
    if (nOut < 0)
        return 2;
    nOut = count + 2;
    pad = XkbPaddedSize(nOut) - nOut;
    if (pad)
        xkmPutPadding(file, pad);
    return nOut + pad;
}

static unsigned
xkmSizeCountedString(char *str)
{
    if (str == NULL)
        return 4;
    return XkbPaddedSize(strlen(str) + 2);
}

static int
xkmPutCountedString(FILE *file, char *str)
{
    if (str == NULL)
        return xkmPutCARD32(file, (unsigned long) 0);
    return xkmPutCountedBytes(file, str, strlen(str));
}

#define	xkmSizeCountedAtomString(d,a)	\
	xkmSizeCountedString(XkbAtomGetString((d),(a)))

#define	xkmPutCountedAtomString(d,f,a)	\
	xkmPutCountedString((f),XkbAtomGetString((d),(a)))

/***====================================================================***/

static unsigned
SizeXKMVirtualMods(XkbFileInfo *result, XkmInfo *info,
                   xkmSectionInfo *toc, int *offset_inout)
{
    Display *dpy;
    XkbDescPtr xkb;
    unsigned nBound, bound;
    unsigned nNamed, named, szNames;
    register unsigned i, bit;

    xkb = result->xkb;
    if ((!xkb) || (!xkb->names) || (!xkb->server)) {
        _XkbLibError(_XkbErrMissingVMods, "SizeXKMVirtualMods", 0);
        return 0;
    }
    dpy = xkb->dpy;
    bound = named = 0;
    for (i = nBound = nNamed = szNames = 0, bit = 1; i < XkbNumVirtualMods;
         i++, bit <<= 1) {
        if (xkb->server->vmods[i] != XkbNoModifierMask) {
            bound |= bit;
            nBound++;
        }
        if (xkb->names->vmods[i] != None) {
            named |= bit;
            szNames += xkmSizeCountedAtomString(dpy, xkb->names->vmods[i]);
            nNamed++;
        }
    }
    info->num_bound = nBound;
    info->bound_vmods = bound;
    info->named_vmods = named;
    if ((nBound == 0) && (nNamed == 0))
        return 0;
    toc->type = XkmVirtualModsIndex;
    toc->format = MSBFirst;
    toc->size = 4 + XkbPaddedSize(nBound) + szNames + SIZEOF(xkmSectionInfo);
    toc->offset = *offset_inout;
    (*offset_inout) += toc->size;
    return 1;
}

static unsigned
WriteXKMVirtualMods(FILE *file, XkbFileInfo *result, XkmInfo *info)
{
    register unsigned int i, bit;
    XkbDescPtr xkb;
    Display *dpy;
    unsigned size = 0;

    xkb = result->xkb;
    dpy = xkb->dpy;
    size += xkmPutCARD16(file, info->bound_vmods);
    size += xkmPutCARD16(file, info->named_vmods);
    for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
        if (info->bound_vmods & bit)
            size += xkmPutCARD8(file, xkb->server->vmods[i]);
    }
    if ((i = XkbPaddedSize(info->num_bound) - info->num_bound) > 0)
        size += xkmPutPadding(file, i);
    for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
        if (info->named_vmods & bit) {
            register char *name;

            name = XkbAtomGetString(dpy, xkb->names->vmods[i]);
            size += xkmPutCountedString(file, name);
        }
    }
    return size;
}

/***====================================================================***/

static unsigned
SizeXKMKeycodes(XkbFileInfo *result, xkmSectionInfo *toc, int *offset_inout)
{
    XkbDescPtr xkb;
    Atom kcName;
    int size = 0;
    Display *dpy;

    xkb = result->xkb;
    if ((!xkb) || (!xkb->names) || (!xkb->names->keys)) {
        _XkbLibError(_XkbErrMissingNames, "SizeXKMKeycodes", 0);
        return 0;
    }
    dpy = xkb->dpy;
    kcName = xkb->names->keycodes;
    size += 4;                  /* min and max keycode */
    size += xkmSizeCountedAtomString(dpy, kcName);
    size += XkbNumKeys(xkb) * sizeof(XkbKeyNameRec);
    if (xkb->names->num_key_aliases > 0) {
        if (xkb->names->key_aliases != NULL)
            size += xkb->names->num_key_aliases * sizeof(XkbKeyAliasRec);
        else
            xkb->names->num_key_aliases = 0;
    }
    toc->type = XkmKeyNamesIndex;
    toc->format = MSBFirst;
    toc->size = size + SIZEOF(xkmSectionInfo);
    toc->offset = (*offset_inout);
    (*offset_inout) += toc->size;
    return 1;
}

static unsigned
WriteXKMKeycodes(FILE *file, XkbFileInfo *result)
{
    XkbDescPtr xkb;
    Atom kcName;
    char *start;
    Display *dpy;
    unsigned tmp, size = 0;

    xkb = result->xkb;
    dpy = xkb->dpy;
    kcName = xkb->names->keycodes;
    start = xkb->names->keys[xkb->min_key_code].name;

    size += xkmPutCountedString(file, XkbAtomGetString(dpy, kcName));
    size += xkmPutCARD8(file, xkb->min_key_code);
    size += xkmPutCARD8(file, xkb->max_key_code);
    size += xkmPutCARD8(file, xkb->names->num_key_aliases);
    size += xkmPutPadding(file, 1);
    tmp = fwrite(start, sizeof(XkbKeyNameRec), XkbNumKeys(xkb), file);
    size += tmp * sizeof(XkbKeyNameRec);
    if (xkb->names->num_key_aliases > 0) {
        tmp = fwrite((char *) xkb->names->key_aliases,
                     sizeof(XkbKeyAliasRec), xkb->names->num_key_aliases, file);
        size += tmp * sizeof(XkbKeyAliasRec);
    }
    return size;
}

/***====================================================================***/

static unsigned
SizeXKMKeyTypes(XkbFileInfo *result, xkmSectionInfo *toc, int *offset_inout)
{
    register unsigned i, n, size;
    XkbKeyTypePtr type;
    XkbDescPtr xkb;
    Display *dpy;
    char *name;

    xkb = result->xkb;
    if ((!xkb) || (!xkb->map) || (!xkb->map->types)) {
        _XkbLibError(_XkbErrMissingTypes, "SizeXKBKeyTypes", 0);
        return 0;
    }
    dpy = xkb->dpy;
    if (xkb->map->num_types < XkbNumRequiredTypes) {
        _XkbLibError(_XkbErrMissingReqTypes, "SizeXKBKeyTypes", 0);
        return 0;
    }
    if (xkb->names)
        name = XkbAtomGetString(dpy, xkb->names->types);
    else
        name = NULL;
    size = xkmSizeCountedString(name);
    size += 4;                  /* room for # of key types + padding */
    for (i = 0, type = xkb->map->types; i < xkb->map->num_types; i++, type++) {
        size += SIZEOF(xkmKeyTypeDesc);
        size += SIZEOF(xkmKTMapEntryDesc) * type->map_count;
        size += xkmSizeCountedAtomString(dpy, type->name);
        if (type->preserve)
            size += SIZEOF(xkmModsDesc) * type->map_count;
        if (type->level_names) {
            Atom *names;

            names = type->level_names;
            for (n = 0; n < (unsigned) type->num_levels; n++) {
                size += xkmSizeCountedAtomString(dpy, names[n]);
            }
        }
    }
    toc->type = XkmTypesIndex;
    toc->format = MSBFirst;
    toc->size = size + SIZEOF(xkmSectionInfo);
    toc->offset = (*offset_inout);
    (*offset_inout) += toc->size;
    return 1;
}

static unsigned
WriteXKMKeyTypes(FILE *file, XkbFileInfo *result)
{
    register unsigned i, n;
    XkbDescPtr xkb;
    XkbKeyTypePtr type;
    xkmKeyTypeDesc wire;
    XkbKTMapEntryPtr entry;
    xkmKTMapEntryDesc wire_entry;
    Atom *names;
    Display *dpy;
    unsigned tmp, size = 0;
    char *name;

    xkb = result->xkb;
    dpy = xkb->dpy;
    if (xkb->names)
        name = XkbAtomGetString(dpy, xkb->names->types);
    else
        name = NULL;
    size += xkmPutCountedString(file, name);
    size += xkmPutCARD16(file, xkb->map->num_types);
    size += xkmPutPadding(file, 2);
    type = xkb->map->types;
    for (i = 0; i < xkb->map->num_types; i++, type++) {
        wire.realMods = type->mods.real_mods;
        wire.virtualMods = type->mods.vmods;
        wire.numLevels = type->num_levels;
        wire.nMapEntries = type->map_count;
        wire.preserve = (type->preserve != NULL);
        if (type->level_names != NULL)
            wire.nLevelNames = type->num_levels;
        else
            wire.nLevelNames = 0;
        tmp = fwrite(&wire, SIZEOF(xkmKeyTypeDesc), 1, file);
        size += tmp * SIZEOF(xkmKeyTypeDesc);
        for (n = 0, entry = type->map; n < type->map_count; n++, entry++) {
            wire_entry.level = entry->level;
            wire_entry.realMods = entry->mods.real_mods;
            wire_entry.virtualMods = entry->mods.vmods;
            tmp = fwrite(&wire_entry, SIZEOF(xkmKTMapEntryDesc), 1, file);
            size += tmp * SIZEOF(xkmKTMapEntryDesc);
        }
        size += xkmPutCountedString(file, XkbAtomGetString(dpy, type->name));
        if (type->preserve) {
            xkmModsDesc p_entry;

            XkbModsPtr pre;

            for (n = 0, pre = type->preserve; n < type->map_count; n++, pre++) {
                p_entry.realMods = pre->real_mods;
                p_entry.virtualMods = pre->vmods;
                tmp = fwrite(&p_entry, SIZEOF(xkmModsDesc), 1, file);
                size += tmp * SIZEOF(xkmModsDesc);
            }
        }
        if (type->level_names != NULL) {
            names = type->level_names;
            for (n = 0; n < wire.nLevelNames; n++) {
                size +=
                    xkmPutCountedString(file, XkbAtomGetString(dpy, names[n]));
            }
        }
    }
    return size;
}

/***====================================================================***/

static unsigned
SizeXKMCompatMap(XkbFileInfo *result, XkmInfo *info,
                 xkmSectionInfo *toc, int *offset_inout)
{
    XkbDescPtr xkb;
    char *name;
    int size;
    register int i;
    unsigned groups, nGroups;
    Display *dpy;

    xkb = result->xkb;
    if ((!xkb) || (!xkb->compat) || (!xkb->compat->sym_interpret)) {
        _XkbLibError(_XkbErrMissingCompatMap, "SizeXKMCompatMap", 0);
        return 0;
    }
    dpy = xkb->dpy;
    if (xkb->names)
        name = XkbAtomGetString(dpy, xkb->names->compat);
    else
        name = NULL;

    for (i = groups = nGroups = 0; i < XkbNumKbdGroups; i++) {
        if ((xkb->compat->groups[i].real_mods != 0) ||
            (xkb->compat->groups[i].vmods != 0)) {
            groups |= (1 << i);
            nGroups++;
        }
    }
    info->group_compat = groups;
    info->num_group_compat = nGroups;
    size = 4;                   /* room for num_si and group_compat mask */
    size += xkmSizeCountedString(name);
    size += (SIZEOF(xkmSymInterpretDesc) * xkb->compat->num_si);
    size += (SIZEOF(xkmModsDesc) * nGroups);
    toc->type = XkmCompatMapIndex;
    toc->format = MSBFirst;
    toc->size = size + SIZEOF(xkmSectionInfo);
    toc->offset = (*offset_inout);
    (*offset_inout) += toc->size;
    return 1;
}

static unsigned
WriteXKMCompatMap(FILE *file, XkbFileInfo *result, XkmInfo *info)
{
    register unsigned i;
    char *name;
    XkbDescPtr xkb;
    XkbSymInterpretPtr interp;
    xkmSymInterpretDesc wire;
    Display *dpy;
    unsigned tmp, size = 0;

    xkb = result->xkb;
    dpy = xkb->dpy;
    if (xkb->names)
        name = XkbAtomGetString(dpy, xkb->names->compat);
    else
        name = NULL;
    size += xkmPutCountedString(file, name);
    size += xkmPutCARD16(file, xkb->compat->num_si);
    size += xkmPutCARD8(file, info->group_compat);
    size += xkmPutPadding(file, 1);
    interp = xkb->compat->sym_interpret;
    for (i = 0; i < xkb->compat->num_si; i++, interp++) {
        wire.sym = interp->sym;
        wire.mods = interp->mods;
        wire.match = interp->match;
        wire.virtualMod = interp->virtual_mod;
        wire.flags = interp->flags;
        wire.actionType = interp->act.type;
        wire.actionData[0] = interp->act.data[0];
        wire.actionData[1] = interp->act.data[1];
        wire.actionData[2] = interp->act.data[2];
        wire.actionData[3] = interp->act.data[3];
        wire.actionData[4] = interp->act.data[4];
        wire.actionData[5] = interp->act.data[5];
        wire.actionData[6] = interp->act.data[6];
        tmp = fwrite(&wire, SIZEOF(xkmSymInterpretDesc), 1, file);
        size += tmp * SIZEOF(xkmSymInterpretDesc);
    }
    if (info->group_compat) {
        register unsigned bit;

        xkmModsDesc modsWire;

        for (i = 0, bit = 1; i < XkbNumKbdGroups; i++, bit <<= 1) {
            if (info->group_compat & bit) {
                modsWire.realMods = xkb->compat->groups[i].real_mods;
                modsWire.virtualMods = xkb->compat->groups[i].vmods;
                fwrite(&modsWire, SIZEOF(xkmModsDesc), 1, file);
                size += SIZEOF(xkmModsDesc);
            }
        }
    }
    return size;
}

/***====================================================================***/

static unsigned
SizeXKMSymbols(XkbFileInfo *result, XkmInfo *info,
               xkmSectionInfo *toc, int *offset_inout)
{
    Display *dpy;
    XkbDescPtr xkb;
    unsigned size;
    register int i, nSyms;
    char *name;

    xkb = result->xkb;
    if ((!xkb) || (!xkb->map) || ((!xkb->map->syms))) {
        _XkbLibError(_XkbErrMissingSymbols, "SizeXKMSymbols", 0);
        return 0;
    }
    dpy = xkb->dpy;
    if (xkb->names && (xkb->names->symbols != None))
        name = XkbAtomGetString(dpy, xkb->names->symbols);
    else
        name = NULL;
    size = xkmSizeCountedString(name);
    size += 4;                  /* min and max keycode, group names mask */
    for (i = 0; i < XkbNumKbdGroups; i++) {
        if (xkb->names->groups[i] != None)
            size += xkmSizeCountedAtomString(dpy, xkb->names->groups[i]);
    }
    info->total_vmodmaps = 0;
    for (i = xkb->min_key_code; i <= (int) xkb->max_key_code; i++) {
        nSyms = XkbKeyNumSyms(xkb, i);
        size += SIZEOF(xkmKeySymMapDesc) + (nSyms * 4);
        if (xkb->server) {
            if (xkb->server->explicit[i] & XkbExplicitKeyTypesMask) {
                register int g;

                for (g = XkbKeyNumGroups(xkb, i) - 1; g >= 0; g--) {
                    if (xkb->server->explicit[i] & (1 << g)) {
                        XkbKeyTypePtr type;
                        char *name;

                        type = XkbKeyKeyType(xkb, i, g);
                        name = XkbAtomGetString(dpy, type->name);
                        if (name != NULL)
                            size += xkmSizeCountedString(name);
                    }
                }
            }
            if (XkbKeyHasActions(xkb, i))
                size += nSyms * SIZEOF(xkmActionDesc);
            if (xkb->server->behaviors[i].type != XkbKB_Default)
                size += SIZEOF(xkmBehaviorDesc);
            if (xkb->server->vmodmap && (xkb->server->vmodmap[i] != 0))
                info->total_vmodmaps++;
        }
    }
    size += info->total_vmodmaps * SIZEOF(xkmVModMapDesc);
    toc->type = XkmSymbolsIndex;
    toc->format = MSBFirst;
    toc->size = size + SIZEOF(xkmSectionInfo);
    toc->offset = (*offset_inout);
    (*offset_inout) += toc->size;
    return 1;
}

static unsigned
WriteXKMSymbols(FILE *file, XkbFileInfo *result, XkmInfo *info)
{
    Display *dpy;
    XkbDescPtr xkb;
    register int i, n;
    xkmKeySymMapDesc wireMap;
    char *name;
    unsigned tmp, size = 0;

    xkb = result->xkb;
    dpy = xkb->dpy;
    if (xkb->names && (xkb->names->symbols != None))
        name = XkbAtomGetString(dpy, xkb->names->symbols);
    else
        name = NULL;
    size += xkmPutCountedString(file, name);
    for (tmp = i = 0; i < XkbNumKbdGroups; i++) {
        if (xkb->names->groups[i] != None)
            tmp |= (1 << i);
    }
    size += xkmPutCARD8(file, xkb->min_key_code);
    size += xkmPutCARD8(file, xkb->max_key_code);
    size += xkmPutCARD8(file, tmp);
    size += xkmPutCARD8(file, info->total_vmodmaps);
    for (i = 0, n = 1; i < XkbNumKbdGroups; i++, n <<= 1) {
        if ((tmp & n) == 0)
            continue;
        size += xkmPutCountedAtomString(dpy, file, xkb->names->groups[i]);
    }
    for (i = xkb->min_key_code; i <= (int) xkb->max_key_code; i++) {
        char *typeName[XkbNumKbdGroups];

        wireMap.width = XkbKeyGroupsWidth(xkb, i);
        wireMap.num_groups = XkbKeyGroupInfo(xkb, i);
        if (xkb->map && xkb->map->modmap)
            wireMap.modifier_map = xkb->map->modmap[i];
        else
            wireMap.modifier_map = 0;
        wireMap.flags = 0;
        bzero((char *) typeName, XkbNumKbdGroups * sizeof(char *));
        if (xkb->server) {
            if (xkb->server->explicit[i] & XkbExplicitKeyTypesMask) {
                register int g;

                for (g = 0; g < XkbKeyNumGroups(xkb, i); g++) {
                    if (xkb->server->explicit[i] & (1 << g)) {
                        XkbKeyTypePtr type;

                        type = XkbKeyKeyType(xkb, i, g);
                        typeName[g] = XkbAtomGetString(dpy, type->name);
                        if (typeName[g] != NULL)
                            wireMap.flags |= (1 << g);
                    }
                }
            }
            if (XkbKeyHasActions(xkb, i))
                wireMap.flags |= XkmKeyHasActions;
            if (xkb->server->behaviors[i].type != XkbKB_Default)
                wireMap.flags |= XkmKeyHasBehavior;
            if ((xkb->server->explicit[i] & XkbExplicitAutoRepeatMask) &&
                (xkb->ctrls != NULL)) {
                if (xkb->ctrls->per_key_repeat[(i / 8)] & (1 << (i % 8)))
                    wireMap.flags |= XkmRepeatingKey;
                else
                    wireMap.flags |= XkmNonRepeatingKey;
            }
        }
        tmp = fwrite(&wireMap, SIZEOF(xkmKeySymMapDesc), 1, file);
        size += tmp * SIZEOF(xkmKeySymMapDesc);
        if (xkb->server->explicit[i] & XkbExplicitKeyTypesMask) {
            register int g;

            for (g = 0; g < XkbNumKbdGroups; g++) {
                if (typeName[g] != NULL)
                    size += xkmPutCountedString(file, typeName[g]);
            }
        }
        if (XkbNumGroups(wireMap.num_groups) > 0) {
            KeySym *sym;

            sym = XkbKeySymsPtr(xkb, i);
            for (n = XkbKeyNumSyms(xkb, i); n > 0; n--, sym++) {
                size += xkmPutCARD32(file, (CARD32) *sym);
            }
            if (wireMap.flags & XkmKeyHasActions) {
                XkbAction *act;

                act = XkbKeyActionsPtr(xkb, i);
                for (n = XkbKeyNumActions(xkb, i); n > 0; n--, act++) {
                    tmp = fwrite(act, SIZEOF(xkmActionDesc), 1, file);
                    size += tmp * SIZEOF(xkmActionDesc);
                }
            }
        }
        if (wireMap.flags & XkmKeyHasBehavior) {
            xkmBehaviorDesc b;

            b.type = xkb->server->behaviors[i].type;
            b.data = xkb->server->behaviors[i].data;
            tmp = fwrite(&b, SIZEOF(xkmBehaviorDesc), 1, file);
            size += tmp * SIZEOF(xkmBehaviorDesc);
        }
    }
    if (info->total_vmodmaps > 0) {
        xkmVModMapDesc v;

        for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
            if (xkb->server->vmodmap[i] != 0) {
                v.key = i;
                v.vmods = xkb->server->vmodmap[i];
                tmp = fwrite(&v, SIZEOF(xkmVModMapDesc), 1, file);
                size += tmp * SIZEOF(xkmVModMapDesc);
            }
        }
    }
    return size;
}

/***====================================================================***/

static unsigned
SizeXKMIndicators(XkbFileInfo *result, XkmInfo *info,
                  xkmSectionInfo *toc, int *offset_inout)
{
    Display *dpy;
    XkbDescPtr xkb;
    unsigned size;
    register unsigned i, nLEDs;

    xkb = result->xkb;
    if ((xkb == NULL) || (xkb->indicators == NULL)) {
/*	_XkbLibError(_XkbErrMissingIndicators,"SizeXKMIndicators",0);*/
        return 0;
    }
    dpy = xkb->dpy;
    nLEDs = 0;
    size = 8; /* number of indicator maps/physical indicators */
    if (xkb->indicators != NULL) {
        for (i = 0; i < XkbNumIndicators; i++) {
            XkbIndicatorMapPtr map = &xkb->indicators->maps[i];

            if ((map->flags != 0) || (map->which_groups != 0) ||
                (map->groups != 0) || (map->which_mods != 0) ||
                (map->mods.real_mods != 0) || (map->mods.vmods != 0) ||
                (map->ctrls != 0) ||
                (xkb->names && (xkb->names->indicators[i] != None))) {
                char *name;

                if (xkb->names && xkb->names->indicators[i] != None) {
                    name = XkbAtomGetString(dpy, xkb->names->indicators[i]);
                }
                else
                    name = NULL;
                size += xkmSizeCountedString(name);
                size += SIZEOF(xkmIndicatorMapDesc);
                nLEDs++;
            }
        }
    }
    info->num_leds = nLEDs;
    toc->type = XkmIndicatorsIndex;
    toc->format = MSBFirst;
    toc->size = size + SIZEOF(xkmSectionInfo);
    toc->offset = (*offset_inout);
    (*offset_inout) += toc->size;
    return 1;
}

static unsigned
WriteXKMIndicators(FILE *file, XkbFileInfo *result, XkmInfo *info)
{
    Display *dpy;
    XkbDescPtr xkb;
    register unsigned i;
    xkmIndicatorMapDesc wire;
    unsigned tmp, size = 0;

    xkb = result->xkb;
    dpy = xkb->dpy;
    size += xkmPutCARD8(file, info->num_leds);
    size += xkmPutPadding(file, 3);
    if (xkb->indicators != NULL) {
        size += xkmPutCARD32(file, xkb->indicators->phys_indicators);
        for (i = 0; i < XkbNumIndicators; i++) {
            XkbIndicatorMapPtr map = &xkb->indicators->maps[i];

            if ((map->flags != 0) || (map->which_groups != 0) ||
                (map->groups != 0) || (map->which_mods != 0) ||
                (map->mods.real_mods != 0) || (map->mods.vmods != 0) ||
                (map->ctrls != 0) || (xkb->names &&
                                      (xkb->names->indicators[i] != None))) {
                char *name;

                if (xkb->names && xkb->names->indicators[i] != None) {
                    name = XkbAtomGetString(dpy, xkb->names->indicators[i]);
                }
                else
                    name = NULL;
                size += xkmPutCountedString(file, name);
                wire.indicator = i + 1;
                wire.flags = map->flags;
                wire.which_mods = map->which_mods;
                wire.real_mods = map->mods.real_mods;
                wire.vmods = map->mods.vmods;
                wire.which_groups = map->which_groups;
                wire.groups = map->groups;
                wire.ctrls = map->ctrls;
                tmp = fwrite(&wire, SIZEOF(xkmIndicatorMapDesc), 1, file);
                size += tmp * SIZEOF(xkmIndicatorMapDesc);
            }
        }
    }
    else {
        size += xkmPutCARD32(file, 0);
    }
    return size;
}

/***====================================================================***/

static unsigned
SizeXKMGeomDoodad(XkbFileInfo *result, XkbDoodadPtr doodad)
{
    unsigned size;

    size = SIZEOF(xkmAnyDoodadDesc);
    size += xkmSizeCountedAtomString(result->xkb->dpy, doodad->any.name);
    if (doodad->any.type == XkbTextDoodad) {
        size += xkmSizeCountedString(doodad->text.text);
        size += xkmSizeCountedString(doodad->text.font);
    }
    else if (doodad->any.type == XkbLogoDoodad) {
        size += xkmSizeCountedString(doodad->logo.logo_name);
    }
    return size;
}

static unsigned
SizeXKMGeomSection(XkbFileInfo *result, XkbSectionPtr section)
{
    register int i;
    unsigned size;

    size = SIZEOF(xkmSectionDesc);
    size += xkmSizeCountedAtomString(result->xkb->dpy, section->name);
    if (section->rows) {
        XkbRowPtr row;

        for (row = section->rows, i = 0; i < section->num_rows; i++, row++) {
            size += SIZEOF(xkmRowDesc);
            size += row->num_keys * SIZEOF(xkmKeyDesc);
        }
    }
    if (section->doodads) {
        XkbDoodadPtr doodad;

        for (doodad = section->doodads, i = 0; i < section->num_doodads;
             i++, doodad++) {
            size += SizeXKMGeomDoodad(result, doodad);
        }
    }
    if (section->overlays) {
        XkbOverlayPtr ol;

        for (ol = section->overlays, i = 0; i < section->num_overlays;
             i++, ol++) {
            register int r;
            XkbOverlayRowPtr row;

            size += xkmSizeCountedAtomString(result->xkb->dpy, ol->name);
            size += SIZEOF(xkmOverlayDesc);
            for (r = 0, row = ol->rows; r < ol->num_rows; r++, row++) {
                size += SIZEOF(xkmOverlayRowDesc);
                size += row->num_keys * SIZEOF(xkmOverlayKeyDesc);
            }
        }
    }
    return size;
}

static unsigned
SizeXKMGeometry(XkbFileInfo *result, xkmSectionInfo *toc, int *offset_inout)
{
    register int i;
    Display *dpy;
    XkbDescPtr xkb;
    XkbGeometryPtr geom;
    unsigned size;

    xkb = result->xkb;
    if ((!xkb) || (!xkb->geom))
        return 0;
    dpy = xkb->dpy;
    geom = xkb->geom;
    size = xkmSizeCountedAtomString(dpy, geom->name);
    size += SIZEOF(xkmGeometryDesc);
    size += xkmSizeCountedString(geom->label_font);
    if (geom->properties) {
        XkbPropertyPtr prop;

        for (i = 0, prop = geom->properties; i < geom->num_properties;
             i++, prop++) {
            size += xkmSizeCountedString(prop->name);
            size += xkmSizeCountedString(prop->value);
        }
    }
    if (geom->colors) {
        XkbColorPtr color;

        for (i = 0, color = geom->colors; i < geom->num_colors; i++, color++) {
            size += xkmSizeCountedString(color->spec);
        }
    }
    if (geom->shapes) {
        XkbShapePtr shape;

        for (i = 0, shape = geom->shapes; i < geom->num_shapes; i++, shape++) {
            register int n;
            register XkbOutlinePtr ol;

            size += xkmSizeCountedAtomString(dpy, shape->name);
            size += SIZEOF(xkmShapeDesc);
            for (n = 0, ol = shape->outlines; n < shape->num_outlines;
                 n++, ol++) {
                size += SIZEOF(xkmOutlineDesc);
                size += ol->num_points * SIZEOF(xkmPointDesc);
            }
        }
    }
    if (geom->sections) {
        XkbSectionPtr section;

        for (i = 0, section = geom->sections; i < geom->num_sections;
             i++, section++) {
            size += SizeXKMGeomSection(result, section);
        }
    }
    if (geom->doodads) {
        XkbDoodadPtr doodad;

        for (i = 0, doodad = geom->doodads; i < geom->num_doodads;
             i++, doodad++) {
            size += SizeXKMGeomDoodad(result, doodad);
        }
    }
    if (geom->key_aliases) {
        size += geom->num_key_aliases * (XkbKeyNameLength * 2);
    }
    toc->type = XkmGeometryIndex;
    toc->format = MSBFirst;
    toc->size = size + SIZEOF(xkmSectionInfo);
    toc->offset = (*offset_inout);
    (*offset_inout) += toc->size;
    return 1;
}

static unsigned
WriteXKMGeomDoodad(FILE *file, XkbFileInfo *result, XkbDoodadPtr doodad)
{
    Display *dpy;
    XkbDescPtr xkb;
    xkmDoodadDesc doodadWire;
    unsigned tmp, size = 0;

    xkb = result->xkb;
    dpy = xkb->dpy;
    bzero((char *) &doodadWire, sizeof(doodadWire));
    doodadWire.any.type = doodad->any.type;
    doodadWire.any.priority = doodad->any.priority;
    doodadWire.any.top = doodad->any.top;
    doodadWire.any.left = doodad->any.left;
    switch (doodad->any.type) {
    case XkbOutlineDoodad:
    case XkbSolidDoodad:
        doodadWire.shape.angle = doodad->shape.angle;
        doodadWire.shape.color_ndx = doodad->shape.color_ndx;
        doodadWire.shape.shape_ndx = doodad->shape.shape_ndx;
        break;
    case XkbTextDoodad:
        doodadWire.text.angle = doodad->text.angle;
        doodadWire.text.width = doodad->text.width;
        doodadWire.text.height = doodad->text.height;
        doodadWire.text.color_ndx = doodad->text.color_ndx;
        break;
    case XkbIndicatorDoodad:
        doodadWire.indicator.shape_ndx = doodad->indicator.shape_ndx;
        doodadWire.indicator.on_color_ndx = doodad->indicator.on_color_ndx;
        doodadWire.indicator.off_color_ndx = doodad->indicator.off_color_ndx;
        break;
    case XkbLogoDoodad:
        doodadWire.logo.angle = doodad->logo.angle;
        doodadWire.logo.color_ndx = doodad->logo.color_ndx;
        doodadWire.logo.shape_ndx = doodad->logo.shape_ndx;
        break;
    default:
        _XkbLibError(_XkbErrIllegalDoodad, "WriteXKMGeomDoodad",
                     doodad->any.type);
        return 0;
    }
    size += xkmPutCountedAtomString(dpy, file, doodad->any.name);
    tmp = fwrite(&doodadWire, SIZEOF(xkmDoodadDesc), 1, file);
    size += tmp * SIZEOF(xkmDoodadDesc);
    if (doodad->any.type == XkbTextDoodad) {
        size += xkmPutCountedString(file, doodad->text.text);
        size += xkmPutCountedString(file, doodad->text.font);
    }
    else if (doodad->any.type == XkbLogoDoodad) {
        size += xkmPutCountedString(file, doodad->logo.logo_name);
    }
    return size;
}

static unsigned
WriteXKMGeomOverlay(FILE *file, XkbFileInfo *result, XkbOverlayPtr ol)
{
    register int r, k;
    Display *dpy;
    XkbDescPtr xkb;
    XkbOverlayRowPtr row;
    xkmOverlayDesc olWire;
    xkmOverlayRowDesc rowWire;
    xkmOverlayKeyDesc keyWire;
    unsigned tmp, size = 0;

    xkb = result->xkb;
    dpy = xkb->dpy;
    bzero((char *) &olWire, sizeof(olWire));
    bzero((char *) &rowWire, sizeof(rowWire));
    bzero((char *) &keyWire, sizeof(keyWire));
    size += xkmPutCountedAtomString(dpy, file, ol->name);
    olWire.num_rows = ol->num_rows;
    tmp = fwrite(&olWire, SIZEOF(xkmOverlayDesc), 1, file);
    size += tmp * SIZEOF(xkmOverlayDesc);
    for (r = 0, row = ol->rows; r < ol->num_rows; r++, row++) {
        XkbOverlayKeyPtr key;

        rowWire.row_under = row->row_under;
        rowWire.num_keys = row->num_keys;
        tmp = fwrite(&rowWire, SIZEOF(xkmOverlayRowDesc), 1, file);
        size += tmp * SIZEOF(xkmOverlayRowDesc);
        for (k = 0, key = row->keys; k < row->num_keys; k++, key++) {
            memcpy(keyWire.over, key->over.name, XkbKeyNameLength);
            memcpy(keyWire.under, key->under.name, XkbKeyNameLength);
            tmp = fwrite(&keyWire, SIZEOF(xkmOverlayKeyDesc), 1, file);
            size += tmp * SIZEOF(xkmOverlayKeyDesc);
        }
    }
    return size;
}

static unsigned
WriteXKMGeomSection(FILE *file, XkbFileInfo *result, XkbSectionPtr section)
{
    register int i;
    Display *dpy;
    XkbDescPtr xkb;
    xkmSectionDesc sectionWire;
    unsigned tmp, size = 0;

    xkb = result->xkb;
    dpy = xkb->dpy;
    size += xkmPutCountedAtomString(dpy, file, section->name);
    sectionWire.top = section->top;
    sectionWire.left = section->left;
    sectionWire.width = section->width;
    sectionWire.height = section->height;
    sectionWire.angle = section->angle;
    sectionWire.priority = section->priority;
    sectionWire.num_rows = section->num_rows;
    sectionWire.num_doodads = section->num_doodads;
    sectionWire.num_overlays = section->num_overlays;
    tmp = fwrite(&sectionWire, SIZEOF(xkmSectionDesc), 1, file);
    size += tmp * SIZEOF(xkmSectionDesc);
    if (section->rows) {
        register unsigned k;
        XkbRowPtr row;
        xkmRowDesc rowWire;
        XkbKeyPtr key;
        xkmKeyDesc keyWire;

        for (i = 0, row = section->rows; i < section->num_rows; i++, row++) {
            rowWire.top = row->top;
            rowWire.left = row->left;
            rowWire.num_keys = row->num_keys;
            rowWire.vertical = row->vertical;
            tmp = fwrite(&rowWire, SIZEOF(xkmRowDesc), 1, file);
            size += tmp * SIZEOF(xkmRowDesc);
            for (k = 0, key = row->keys; k < row->num_keys; k++, key++) {
                memcpy(keyWire.name, key->name.name, XkbKeyNameLength);
                keyWire.gap = key->gap;
                keyWire.shape_ndx = key->shape_ndx;
                keyWire.color_ndx = key->color_ndx;
                tmp = fwrite(&keyWire, SIZEOF(xkmKeyDesc), 1, file);
                size += tmp * SIZEOF(xkmKeyDesc);
            }
        }
    }
    if (section->doodads) {
        XkbDoodadPtr doodad;

        for (i = 0, doodad = section->doodads; i < section->num_doodads;
             i++, doodad++) {
            size += WriteXKMGeomDoodad(file, result, doodad);
        }
    }
    if (section->overlays) {
        XkbOverlayPtr ol;

        for (i = 0, ol = section->overlays; i < section->num_overlays;
             i++, ol++) {
            size += WriteXKMGeomOverlay(file, result, ol);
        }
    }
    return size;
}

static unsigned
WriteXKMGeometry(FILE *file, XkbFileInfo *result)
{
    register int i;
    Display *dpy;
    XkbDescPtr xkb;
    XkbGeometryPtr geom;
    xkmGeometryDesc wire;
    unsigned tmp, size = 0;

    xkb = result->xkb;
    if ((!xkb) || (!xkb->geom))
        return 0;
    dpy = xkb->dpy;
    geom = xkb->geom;
    wire.width_mm = geom->width_mm;
    wire.height_mm = geom->height_mm;
    wire.base_color_ndx = XkbGeomColorIndex(geom, geom->base_color);
    wire.label_color_ndx = XkbGeomColorIndex(geom, geom->label_color);
    wire.num_properties = geom->num_properties;
    wire.num_colors = geom->num_colors;
    wire.num_shapes = geom->num_shapes;
    wire.num_sections = geom->num_sections;
    wire.num_doodads = geom->num_doodads;
    wire.num_key_aliases = geom->num_key_aliases;
    size += xkmPutCountedAtomString(dpy, file, geom->name);
    tmp = fwrite(&wire, SIZEOF(xkmGeometryDesc), 1, file);
    size += tmp * SIZEOF(xkmGeometryDesc);
    size += xkmPutCountedString(file, geom->label_font);
    if (geom->properties) {
        XkbPropertyPtr prop;

        for (i = 0, prop = geom->properties; i < geom->num_properties;
             i++, prop++) {
            size += xkmPutCountedString(file, prop->name);
            size += xkmPutCountedString(file, prop->value);
        }
    }
    if (geom->colors) {
        XkbColorPtr color;

        for (i = 0, color = geom->colors; i < geom->num_colors; i++, color++) {
            size += xkmPutCountedString(file, color->spec);
        }
    }
    if (geom->shapes) {
        XkbShapePtr shape;
        xkmShapeDesc shapeWire;

        for (i = 0, shape = geom->shapes; i < geom->num_shapes; i++, shape++) {
            register int n;
            XkbOutlinePtr ol;
            xkmOutlineDesc olWire;

            bzero((char *) &shapeWire, sizeof(xkmShapeDesc));
            size += xkmPutCountedAtomString(dpy, file, shape->name);
            shapeWire.num_outlines = shape->num_outlines;
            if (shape->primary != NULL)
                shapeWire.primary_ndx = XkbOutlineIndex(shape, shape->primary);
            else
                shapeWire.primary_ndx = XkbNoShape;
            if (shape->approx != NULL)
                shapeWire.approx_ndx = XkbOutlineIndex(shape, shape->approx);
            else
                shapeWire.approx_ndx = XkbNoShape;
            tmp = fwrite(&shapeWire, SIZEOF(xkmShapeDesc), 1, file);
            size += tmp * SIZEOF(xkmShapeDesc);
            for (n = 0, ol = shape->outlines; n < shape->num_outlines;
                 n++, ol++) {
                register int p;
                XkbPointPtr pt;
                xkmPointDesc ptWire;

                olWire.num_points = ol->num_points;
                olWire.corner_radius = ol->corner_radius;
                tmp = fwrite(&olWire, SIZEOF(xkmOutlineDesc), 1, file);
                size += tmp * SIZEOF(xkmOutlineDesc);
                for (p = 0, pt = ol->points; p < ol->num_points; p++, pt++) {
                    ptWire.x = pt->x;
                    ptWire.y = pt->y;
                    tmp = fwrite(&ptWire, SIZEOF(xkmPointDesc), 1, file);
                    size += tmp * SIZEOF(xkmPointDesc);
                }
            }
        }
    }
    if (geom->sections) {
        XkbSectionPtr section;

        for (i = 0, section = geom->sections; i < geom->num_sections;
             i++, section++) {
            size += WriteXKMGeomSection(file, result, section);
        }
    }
    if (geom->doodads) {
        XkbDoodadPtr doodad;

        for (i = 0, doodad = geom->doodads; i < geom->num_doodads;
             i++, doodad++) {
            size += WriteXKMGeomDoodad(file, result, doodad);
        }
    }
    if (geom->key_aliases) {
        tmp =
            fwrite(geom->key_aliases, 2 * XkbKeyNameLength,
                   geom->num_key_aliases, file);
        size += tmp * (2 * XkbKeyNameLength);
    }
    return size;
}

/***====================================================================***/

/*ARGSUSED*/
static int
GetXKMKeyNamesTOC(XkbFileInfo *result, XkmInfo *info,
                  int max_toc, xkmSectionInfo *toc_rtrn)
{
    int num_toc;
    int total_size;

    total_size = num_toc = 0;
    if (SizeXKMKeycodes(result, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    if (SizeXKMIndicators(result, info, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    return num_toc;
}

/*ARGSUSED*/
static int
GetXKMTypesTOC(XkbFileInfo *result, XkmInfo *info,
               int max_toc, xkmSectionInfo *toc_rtrn)
{
    int num_toc;
    int total_size;

    total_size = num_toc = 0;
    if (SizeXKMVirtualMods(result, info, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    if (SizeXKMKeyTypes(result, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    return num_toc;
}

/*ARGSUSED*/
static int
GetXKMCompatMapTOC(XkbFileInfo *result, XkmInfo *info,
                   int max_toc, xkmSectionInfo *toc_rtrn)
{
    int num_toc;
    int total_size;

    total_size = num_toc = 0;
    if (SizeXKMVirtualMods(result, info, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    if (SizeXKMCompatMap(result, info, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    if (SizeXKMIndicators(result, info, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    return num_toc;
}

/*ARGSUSED*/
static int
GetXKMSemanticsTOC(XkbFileInfo *result, XkmInfo *info,
                   int max_toc, xkmSectionInfo *toc_rtrn)
{
    int num_toc;
    int total_size;

    total_size = num_toc = 0;
    if (SizeXKMVirtualMods(result, info, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    if (SizeXKMKeyTypes(result, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    if (SizeXKMCompatMap(result, info, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    if (SizeXKMIndicators(result, info, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    return num_toc;
}

/*ARGSUSED*/
static int
GetXKMLayoutTOC(XkbFileInfo *result, XkmInfo *info,
                int max_toc, xkmSectionInfo *toc_rtrn)
{
    int num_toc;
    int total_size;

    total_size = num_toc = 0;
    if (SizeXKMVirtualMods(result, info, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    if (SizeXKMKeycodes(result, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    if (SizeXKMKeyTypes(result, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    if (SizeXKMSymbols(result, info, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    if (SizeXKMIndicators(result, info, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    if (SizeXKMGeometry(result, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    return num_toc;
}

/*ARGSUSED*/
static int
GetXKMKeymapTOC(XkbFileInfo *result, XkmInfo *info,
                int max_toc, xkmSectionInfo *toc_rtrn)
{
    int num_toc;
    int total_size;

    total_size = num_toc = 0;
    if (SizeXKMVirtualMods(result, info, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    if (SizeXKMKeycodes(result, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    if (SizeXKMKeyTypes(result, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    if (SizeXKMCompatMap(result, info, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    if (SizeXKMSymbols(result, info, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    if (SizeXKMIndicators(result, info, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    if (SizeXKMGeometry(result, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    return num_toc;
}

/*ARGSUSED*/
static int
GetXKMGeometryTOC(XkbFileInfo *result, XkmInfo *info,
                  int max_toc, xkmSectionInfo *toc_rtrn)
{
    int num_toc;
    int total_size;

    total_size = num_toc = 0;
    if (SizeXKMGeometry(result, &toc_rtrn[num_toc], &total_size))
        num_toc++;
    return num_toc;
}

static Bool
WriteXKMFile(FILE *file, XkbFileInfo *result,
             int num_toc, xkmSectionInfo *toc, XkmInfo *info)
{
    register int i;
    unsigned tmp, size, total = 0;

    for (i = 0; i < num_toc; i++) {
        tmp = fwrite(&toc[i], SIZEOF(xkmSectionInfo), 1, file);
        total += tmp * SIZEOF(xkmSectionInfo);
        switch (toc[i].type) {
        case XkmTypesIndex:
            size = WriteXKMKeyTypes(file, result);
            break;
        case XkmCompatMapIndex:
            size = WriteXKMCompatMap(file, result, info);
            break;
        case XkmSymbolsIndex:
            size = WriteXKMSymbols(file, result, info);
            break;
        case XkmIndicatorsIndex:
            size = WriteXKMIndicators(file, result, info);
            break;
        case XkmKeyNamesIndex:
            size = WriteXKMKeycodes(file, result);
            break;
        case XkmGeometryIndex:
            size = WriteXKMGeometry(file, result);
            break;
        case XkmVirtualModsIndex:
            size = WriteXKMVirtualMods(file, result, info);
            break;
        default:
            _XkbLibError(_XkbErrIllegalTOCType, "WriteXKMFile", toc[i].type);
            return False;
        }
        size += SIZEOF(xkmSectionInfo);
        if (size != toc[i].size) {
            _XkbLibError(_XkbErrBadLength,
                         XkbConfigText(toc[i].type, XkbMessage),
                         size - toc[i].size);
            return False;
        }
    }
    return True;
}


#define	MAX_TOC	16

Bool
XkbWriteXKMFile(FILE *out, XkbFileInfo *result)
{
    Bool ok;
    XkbDescPtr xkb;
    XkmInfo info;
    int size_toc, i;
    unsigned hdr, present;
    xkmFileInfo fileInfo;
    xkmSectionInfo toc[MAX_TOC];

    int (*getTOC) (XkbFileInfo *        /* result */ ,
                   XkmInfo *            /* info */ ,
                   int                  /* max_to */ ,
                   xkmSectionInfo *     /* toc_rtrn */
        );

    switch (result->type) {
    case XkmKeyNamesIndex:
        getTOC = GetXKMKeyNamesTOC;
        break;
    case XkmTypesIndex:
        getTOC = GetXKMTypesTOC;
        break;
    case XkmCompatMapIndex:
        getTOC = GetXKMCompatMapTOC;
        break;
    case XkmSemanticsFile:
        getTOC = GetXKMSemanticsTOC;
        break;
    case XkmLayoutFile:
        getTOC = GetXKMLayoutTOC;
        break;
    case XkmKeymapFile:
        getTOC = GetXKMKeymapTOC;
        break;
    case XkmGeometryFile:
    case XkmGeometryIndex:
        getTOC = GetXKMGeometryTOC;
        break;
    default:
        _XkbLibError(_XkbErrIllegalContents,
                     XkbConfigText(result->type, XkbMessage), 0);
        return False;
    }
    xkb = result->xkb;

    bzero((char *) &info, sizeof(XkmInfo));
    size_toc = (*getTOC) (result, &info, MAX_TOC, toc);
    if (size_toc < 1) {
        _XkbLibError(_XkbErrEmptyFile, "XkbWriteXKMFile", 0);
        return False;
    }
    if (out == NULL) {
        _XkbLibError(_XkbErrFileCannotOpen, "XkbWriteXKMFile", 0);
        return False;
    }
    for (i = present = 0; i < size_toc; i++) {
        toc[i].offset += 4 + SIZEOF(xkmFileInfo);
        toc[i].offset += (size_toc * SIZEOF(xkmSectionInfo));
        if (toc[i].type <= XkmLastIndex) {
            present |= (1 << toc[i].type);
        }
#ifdef DEBUG
        else {
            fprintf(stderr, "Illegal section type %d\n", toc[i].type);
            fprintf(stderr, "Ignored\n");
        }
#endif
    }
    hdr = (('x' << 24) | ('k' << 16) | ('m' << 8) | XkmFileVersion);
    xkmPutCARD32(out, (unsigned long) hdr);
    fileInfo.type = result->type;
    fileInfo.min_kc = xkb->min_key_code;
    fileInfo.max_kc = xkb->max_key_code;
    fileInfo.num_toc = size_toc;
    fileInfo.present = present;
    fileInfo.pad = 0;
    fwrite(&fileInfo, SIZEOF(xkmFileInfo), 1, out);
    fwrite(toc, SIZEOF(xkmSectionInfo), size_toc, out);
    ok = WriteXKMFile(out, result, size_toc, toc, &info);
    return ok;
}