svn merge file:///D:/svnrepos/vcxsrv/branches/released .

1 files changed, 577 insertions, 491 deletions

diff --git a/xkbcomp/parseutils.c b/xkbcomp/parseutils.c
index bae18f902..ad1b0d182 100644
--- a/xkbcomp/parseutils.c
+++ b/xkbcomp/parseutils.c
@@ -1,4 +1,3 @@
-/* $Xorg: parseutils.c,v 1.3 2000/08/17 19:54:33 cpqbld Exp $ */
 /************************************************************
  Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
 
@@ -24,9 +23,7 @@
  THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
  ********************************************************/
-/* $XFree86$ */
 
-#define DEBUG_VAR_NOT_LOCAL
 #define	DEBUG_VAR parseDebug
 #include "parseutils.h"
 #include "xkbpath.h"
@@ -34,329 +31,361 @@
 #include <X11/extensions/XKBgeom.h>
 #include <X11/Xalloca.h>
 
-XkbFile	*rtrnValue;
+XkbFile *rtrnValue;
 
 ParseCommon *
-AppendStmt(ParseCommon *to,ParseCommon *append)
+AppendStmt(ParseCommon * to, ParseCommon * append)
 {
-ParseCommon	*start= to;
+    ParseCommon *start = to;
 
-    if (append==NULL)
-	return to;
-    while ((to!=NULL) && (to->next!=NULL)) {
-	to= to->next;
+    if (append == NULL)
+        return to;
+    while ((to != NULL) && (to->next != NULL))
+    {
+        to = to->next;
     }
-    if (to) {
-	to->next= append;
-	return start;
+    if (to)
+    {
+        to->next = append;
+        return start;
     }
     return append;
 }
 
 ExprDef *
-ExprCreate(unsigned op,unsigned type)
-{
-ExprDef *expr;
-    expr= uTypedAlloc(ExprDef);
-    if (expr) {
-	expr->common.stmtType= StmtExpr;
-	expr->common.next= NULL;
-	expr->op= op;
-	expr->type= type;
-    }
-    else {
-	FATAL("Couldn't allocate expression in parser\n");
-	/* NOTREACHED */
+ExprCreate(unsigned op, unsigned type)
+{
+    ExprDef *expr;
+    expr = uTypedAlloc(ExprDef);
+    if (expr)
+    {
+        expr->common.stmtType = StmtExpr;
+        expr->common.next = NULL;
+        expr->op = op;
+        expr->type = type;
+    }
+    else
+    {
+        FATAL("Couldn't allocate expression in parser\n");
+        /* NOTREACHED */
     }
     return expr;
 }
 
 ExprDef *
-ExprCreateUnary(unsigned op,unsigned type,ExprDef *child)
-{
-ExprDef *expr;
-    expr= uTypedAlloc(ExprDef);
-    if (expr) {
-	expr->common.stmtType= StmtExpr;
-	expr->common.next= NULL;
-	expr->op= op;
-	expr->type= type;
-	expr->value.child= child;
-    }
-    else {
-	FATAL("Couldn't allocate expression in parser\n");
-	/* NOTREACHED */
+ExprCreateUnary(unsigned op, unsigned type, ExprDef * child)
+{
+    ExprDef *expr;
+    expr = uTypedAlloc(ExprDef);
+    if (expr)
+    {
+        expr->common.stmtType = StmtExpr;
+        expr->common.next = NULL;
+        expr->op = op;
+        expr->type = type;
+        expr->value.child = child;
+    }
+    else
+    {
+        FATAL("Couldn't allocate expression in parser\n");
+        /* NOTREACHED */
     }
     return expr;
 }
 
 ExprDef *
-ExprCreateBinary(unsigned op,ExprDef *left,ExprDef *right)
-{
-ExprDef *expr;
-    expr= uTypedAlloc(ExprDef);
-    if (expr) {
-	expr->common.stmtType= StmtExpr;
-	expr->common.next= NULL;
-	expr->op= op;
-	if ((op==OpAssign)||(left->type==TypeUnknown))
-	     expr->type= right->type;
-	else if ((left->type==right->type)||(right->type==TypeUnknown))
-	     expr->type= left->type;
-	else expr->type= TypeUnknown;
-	expr->value.binary.left= left;
-	expr->value.binary.right= right;
-    }
-    else {
-	FATAL("Couldn't allocate expression in parser\n");
-	/* NOTREACHED */
+ExprCreateBinary(unsigned op, ExprDef * left, ExprDef * right)
+{
+    ExprDef *expr;
+    expr = uTypedAlloc(ExprDef);
+    if (expr)
+    {
+        expr->common.stmtType = StmtExpr;
+        expr->common.next = NULL;
+        expr->op = op;
+        if ((op == OpAssign) || (left->type == TypeUnknown))
+            expr->type = right->type;
+        else if ((left->type == right->type) || (right->type == TypeUnknown))
+            expr->type = left->type;
+        else
+            expr->type = TypeUnknown;
+        expr->value.binary.left = left;
+        expr->value.binary.right = right;
+    }
+    else
+    {
+        FATAL("Couldn't allocate expression in parser\n");
+        /* NOTREACHED */
     }
     return expr;
 }
 
 KeycodeDef *
-KeycodeCreate(char *name,ExprDef *value)
+KeycodeCreate(char *name, ExprDef * value)
 {
-KeycodeDef *def;
+    KeycodeDef *def;
 
-    def= uTypedAlloc(KeycodeDef);
-    if (def) {
-	def->common.stmtType= StmtKeycodeDef;
-	def->common.next= NULL;
-	strncpy(def->name,name,XkbKeyNameLength);
-	def->name[XkbKeyNameLength]= '\0';
-	def->value= value;
+    def = uTypedAlloc(KeycodeDef);
+    if (def)
+    {
+        def->common.stmtType = StmtKeycodeDef;
+        def->common.next = NULL;
+        strncpy(def->name, name, XkbKeyNameLength);
+        def->name[XkbKeyNameLength] = '\0';
+        def->value = value;
     }
-    else {
-	FATAL("Couldn't allocate key name definition in parser\n");
-	/* NOTREACHED */
+    else
+    {
+        FATAL("Couldn't allocate key name definition in parser\n");
+        /* NOTREACHED */
     }
     return def;
 }
 
 KeyAliasDef *
-KeyAliasCreate(char *alias,char *real)
+KeyAliasCreate(char *alias, char *real)
 {
-KeyAliasDef *def;
+    KeyAliasDef *def;
 
-    def= uTypedAlloc(KeyAliasDef);
-    if (def) {
-	def->common.stmtType= StmtKeyAliasDef;
-	def->common.next= NULL;
-	strncpy(def->alias,alias,XkbKeyNameLength);
-	def->alias[XkbKeyNameLength]= '\0';
-	strncpy(def->real,real,XkbKeyNameLength);
-	def->real[XkbKeyNameLength]= '\0';
+    def = uTypedAlloc(KeyAliasDef);
+    if (def)
+    {
+        def->common.stmtType = StmtKeyAliasDef;
+        def->common.next = NULL;
+        strncpy(def->alias, alias, XkbKeyNameLength);
+        def->alias[XkbKeyNameLength] = '\0';
+        strncpy(def->real, real, XkbKeyNameLength);
+        def->real[XkbKeyNameLength] = '\0';
     }
-    else {
-	FATAL("Couldn't allocate key alias definition in parser\n");
-	/* NOTREACHED */
+    else
+    {
+        FATAL("Couldn't allocate key alias definition in parser\n");
+        /* NOTREACHED */
     }
     return def;
 }
 
 VModDef *
-VModCreate(Atom name,ExprDef *value)
-{
-VModDef *def;
-    def= uTypedAlloc(VModDef);
-    if (def) {
-	def->common.stmtType= StmtVModDef;
-	def->common.next= NULL;
-	def->name= name;
-	def->value= value;
-    }
-    else {
-	FATAL("Couldn't allocate variable definition in parser\n");
-	/* NOTREACHED */
+VModCreate(Atom name, ExprDef * value)
+{
+    VModDef *def;
+    def = uTypedAlloc(VModDef);
+    if (def)
+    {
+        def->common.stmtType = StmtVModDef;
+        def->common.next = NULL;
+        def->name = name;
+        def->value = value;
+    }
+    else
+    {
+        FATAL("Couldn't allocate variable definition in parser\n");
+        /* NOTREACHED */
     }
     return def;
 }
 
 VarDef *
-VarCreate(ExprDef *name,ExprDef *value)
-{
-VarDef *def;
-    def= uTypedAlloc(VarDef);
-    if (def) {
-	def->common.stmtType= StmtVarDef;
-	def->common.next= NULL;
-	def->name= name;
-	def->value= value;
-    }
-    else {
-	FATAL("Couldn't allocate variable definition in parser\n");
-	/* NOTREACHED */
+VarCreate(ExprDef * name, ExprDef * value)
+{
+    VarDef *def;
+    def = uTypedAlloc(VarDef);
+    if (def)
+    {
+        def->common.stmtType = StmtVarDef;
+        def->common.next = NULL;
+        def->name = name;
+        def->value = value;
+    }
+    else
+    {
+        FATAL("Couldn't allocate variable definition in parser\n");
+        /* NOTREACHED */
     }
     return def;
 }
 
 VarDef *
-BoolVarCreate(Atom nameToken,unsigned set)
+BoolVarCreate(Atom nameToken, unsigned set)
 {
-ExprDef	*name,*value;
+    ExprDef *name, *value;
 
-    name= ExprCreate(ExprIdent,TypeUnknown);
-    name->value.str= nameToken;
-    value= ExprCreate(ExprValue,TypeBoolean);
-    value->value.uval= set;
-    return VarCreate(name,value);
+    name = ExprCreate(ExprIdent, TypeUnknown);
+    name->value.str = nameToken;
+    value = ExprCreate(ExprValue, TypeBoolean);
+    value->value.uval = set;
+    return VarCreate(name, value);
 }
 
 InterpDef *
-InterpCreate(KeySym sym,ExprDef *match)
+InterpCreate(KeySym sym, ExprDef * match)
 {
-InterpDef *def;
+    InterpDef *def;
 
-    def= uTypedAlloc(InterpDef);
-    if (def) {
-	def->common.stmtType= StmtInterpDef;
-	def->common.next= NULL;
-	def->sym= sym;
-	def->match= match;
+    def = uTypedAlloc(InterpDef);
+    if (def)
+    {
+        def->common.stmtType = StmtInterpDef;
+        def->common.next = NULL;
+        def->sym = sym;
+        def->match = match;
     }
-    else {
-	FATAL("Couldn't allocate interp definition in parser\n");
-	/* NOTREACHED */
+    else
+    {
+        FATAL("Couldn't allocate interp definition in parser\n");
+        /* NOTREACHED */
     }
     return def;
 }
 
 KeyTypeDef *
-KeyTypeCreate(Atom name,VarDef *body)
+KeyTypeCreate(Atom name, VarDef * body)
 {
-KeyTypeDef *def;
+    KeyTypeDef *def;
 
-    def= uTypedAlloc(KeyTypeDef);
-    if (def) {
-	def->common.stmtType= StmtKeyTypeDef;
-	def->common.next= NULL;
-	def->merge= MergeDefault;
-	def->name= name;
-	def->body= body;
+    def = uTypedAlloc(KeyTypeDef);
+    if (def)
+    {
+        def->common.stmtType = StmtKeyTypeDef;
+        def->common.next = NULL;
+        def->merge = MergeDefault;
+        def->name = name;
+        def->body = body;
     }
-    else {
-	FATAL("Couldn't allocate key type definition in parser\n");
-	/* NOTREACHED */
+    else
+    {
+        FATAL("Couldn't allocate key type definition in parser\n");
+        /* NOTREACHED */
     }
     return def;
 }
 
 SymbolsDef *
-SymbolsCreate(char *keyName,ExprDef *symbols)
+SymbolsCreate(char *keyName, ExprDef * symbols)
 {
-SymbolsDef *def;
+    SymbolsDef *def;
 
-    def= uTypedAlloc(SymbolsDef);
-    if (def) {
-	def->common.stmtType= StmtSymbolsDef;
-	def->common.next= NULL;
-	def->merge= MergeDefault;
-	bzero(def->keyName,5);
-	strncpy(def->keyName,keyName,4);
-	def->symbols= symbols;
+    def = uTypedAlloc(SymbolsDef);
+    if (def)
+    {
+        def->common.stmtType = StmtSymbolsDef;
+        def->common.next = NULL;
+        def->merge = MergeDefault;
+        bzero(def->keyName, 5);
+        strncpy(def->keyName, keyName, 4);
+        def->symbols = symbols;
     }
-    else {
-	FATAL("Couldn't allocate symbols definition in parser\n");
-	/* NOTREACHED */
+    else
+    {
+        FATAL("Couldn't allocate symbols definition in parser\n");
+        /* NOTREACHED */
     }
     return def;
 }
 
 GroupCompatDef *
-GroupCompatCreate(int group,ExprDef *val)
+GroupCompatCreate(int group, ExprDef * val)
 {
-GroupCompatDef *def;
+    GroupCompatDef *def;
 
-    def= uTypedAlloc(GroupCompatDef);
-    if (def) {
-	def->common.stmtType= StmtGroupCompatDef;
-	def->common.next= NULL;
-	def->merge= MergeDefault;
-	def->group= group;
-	def->def= val;
+    def = uTypedAlloc(GroupCompatDef);
+    if (def)
+    {
+        def->common.stmtType = StmtGroupCompatDef;
+        def->common.next = NULL;
+        def->merge = MergeDefault;
+        def->group = group;
+        def->def = val;
     }
-    else {
-	FATAL("Couldn't allocate group compat definition in parser\n");
-	/* NOTREACHED */
+    else
+    {
+        FATAL("Couldn't allocate group compat definition in parser\n");
+        /* NOTREACHED */
     }
     return def;
 }
 
 ModMapDef *
-ModMapCreate(Atom modifier,ExprDef *keys)
+ModMapCreate(Atom modifier, ExprDef * keys)
 {
-ModMapDef *def;
+    ModMapDef *def;
 
-    def= uTypedAlloc(ModMapDef);
-    if (def) {
-	def->common.stmtType= StmtModMapDef;
-	def->common.next= NULL;
-	def->merge= MergeDefault;
-	def->modifier= modifier;
-	def->keys= keys;
+    def = uTypedAlloc(ModMapDef);
+    if (def)
+    {
+        def->common.stmtType = StmtModMapDef;
+        def->common.next = NULL;
+        def->merge = MergeDefault;
+        def->modifier = modifier;
+        def->keys = keys;
     }
-    else {
-	FATAL("Couldn't allocate mod mask definition in parser\n");
-	/* NOTREACHED */
+    else
+    {
+        FATAL("Couldn't allocate mod mask definition in parser\n");
+        /* NOTREACHED */
     }
     return def;
 }
 
 IndicatorMapDef *
-IndicatorMapCreate(Atom name,VarDef *body)
+IndicatorMapCreate(Atom name, VarDef * body)
 {
-IndicatorMapDef *def;
+    IndicatorMapDef *def;
 
-    def= uTypedAlloc(IndicatorMapDef);
-    if (def) {
-	def->common.stmtType= StmtIndicatorMapDef;
-	def->common.next= NULL;
-	def->merge= MergeDefault;
-	def->name= name;
-	def->body= body;
+    def = uTypedAlloc(IndicatorMapDef);
+    if (def)
+    {
+        def->common.stmtType = StmtIndicatorMapDef;
+        def->common.next = NULL;
+        def->merge = MergeDefault;
+        def->name = name;
+        def->body = body;
     }
-    else {
-	FATAL("Couldn't allocate indicator map definition in parser\n");
-	/* NOTREACHED */
+    else
+    {
+        FATAL("Couldn't allocate indicator map definition in parser\n");
+        /* NOTREACHED */
     }
     return def;
 }
 
 IndicatorNameDef *
-IndicatorNameCreate(int	ndx,ExprDef *name,Bool virtual)
+IndicatorNameCreate(int ndx, ExprDef * name, Bool virtual)
 {
-IndicatorNameDef *def;
+    IndicatorNameDef *def;
 
-    def= uTypedAlloc(IndicatorNameDef);
-    if (def) {
-	def->common.stmtType= StmtIndicatorNameDef;
-	def->common.next= NULL;
-	def->merge= MergeDefault;
-	def->ndx= ndx;
-	def->name= name;
-	def->virtual= virtual;
+    def = uTypedAlloc(IndicatorNameDef);
+    if (def)
+    {
+        def->common.stmtType = StmtIndicatorNameDef;
+        def->common.next = NULL;
+        def->merge = MergeDefault;
+        def->ndx = ndx;
+        def->name = name;
+        def->virtual = virtual;
     }
-    else {
-	FATAL("Couldn't allocate indicator index definition in parser\n");
-	/* NOTREACHED */
+    else
+    {
+        FATAL("Couldn't allocate indicator index definition in parser\n");
+        /* NOTREACHED */
     }
     return def;
 }
 
 ExprDef *
-ActionCreate(Atom name,ExprDef *args)
+ActionCreate(Atom name, ExprDef * args)
 {
-ExprDef *act;
+    ExprDef *act;
 
-    act= uTypedAlloc(ExprDef);
-    if (act) {
-	act->common.stmtType= StmtExpr;
-	act->common.next= NULL;
-	act->op= ExprActionDecl;
-	act->value.action.name= name;
-        act->value.action.args= args;
-	return act;
+    act = uTypedAlloc(ExprDef);
+    if (act)
+    {
+        act->common.stmtType = StmtExpr;
+        act->common.next = NULL;
+        act->op = ExprActionDecl;
+        act->value.action.name = name;
+        act->value.action.args = args;
+        return act;
     }
     FATAL("Couldn't allocate ActionDef in parser\n");
     return NULL;
@@ -365,384 +394,441 @@ ExprDef *act;
 ExprDef *
 CreateKeysymList(KeySym sym)
 {
-ExprDef	 *def;
+    ExprDef *def;
 
-    def= ExprCreate(ExprKeysymList,TypeSymbols);
-    if (def) {
-	def->value.list.nSyms= 1;
-	def->value.list.szSyms= 2;
-	def->value.list.syms= uTypedCalloc(2,KeySym);
-	if (def->value.list.syms!=NULL) {
-	    def->value.list.syms[0]= sym;
-	    return def;
-	}
+    def = ExprCreate(ExprKeysymList, TypeSymbols);
+    if (def)
+    {
+        def->value.list.nSyms = 1;
+        def->value.list.szSyms = 2;
+        def->value.list.syms = uTypedCalloc(2, KeySym);
+        if (def->value.list.syms != NULL)
+        {
+            def->value.list.syms[0] = sym;
+            return def;
+        }
     }
     FATAL("Couldn't allocate expression for keysym list in parser\n");
     return NULL;
 }
 
 ShapeDef *
-ShapeDeclCreate(Atom name,OutlineDef *outlines)
-{
-ShapeDef *	shape;
-OutlineDef *	ol;
-
-    shape= uTypedAlloc(ShapeDef);
-    if (shape!=NULL) {
-	bzero(shape,sizeof(ShapeDef));
-	shape->common.stmtType=	StmtShapeDef;
-	shape->common.next=	NULL;
-	shape->merge=		MergeDefault;
-	shape->name=		name;
-	shape->nOutlines=	0;
-	shape->outlines=	outlines;
-	for (ol=outlines;ol!=NULL;ol= (OutlineDef *)ol->common.next) {
-	    if (ol->nPoints>0)
-		shape->nOutlines++;
-	}
+ShapeDeclCreate(Atom name, OutlineDef * outlines)
+{
+    ShapeDef *shape;
+    OutlineDef *ol;
+
+    shape = uTypedAlloc(ShapeDef);
+    if (shape != NULL)
+    {
+        bzero(shape, sizeof(ShapeDef));
+        shape->common.stmtType = StmtShapeDef;
+        shape->common.next = NULL;
+        shape->merge = MergeDefault;
+        shape->name = name;
+        shape->nOutlines = 0;
+        shape->outlines = outlines;
+        for (ol = outlines; ol != NULL; ol = (OutlineDef *) ol->common.next)
+        {
+            if (ol->nPoints > 0)
+                shape->nOutlines++;
+        }
     }
     return shape;
 }
 
 OutlineDef *
-OutlineCreate(Atom field,ExprDef *points)
-{
-OutlineDef *	outline;
-ExprDef *	pt;
-
-    outline= uTypedAlloc(OutlineDef);
-    if (outline!=NULL) {
-	bzero(outline,sizeof(OutlineDef));
-	outline->common.stmtType= 	StmtOutlineDef;
-	outline->common.next=		NULL;
-	outline->field=		field;
-	outline->nPoints=	0;
-	if (points->op==ExprCoord) {
-	    for (pt=points;pt!=NULL;pt= (ExprDef *)pt->common.next) {
-		outline->nPoints++;
-	    }
-	}
-	outline->points= points;
+OutlineCreate(Atom field, ExprDef * points)
+{
+    OutlineDef *outline;
+    ExprDef *pt;
+
+    outline = uTypedAlloc(OutlineDef);
+    if (outline != NULL)
+    {
+        bzero(outline, sizeof(OutlineDef));
+        outline->common.stmtType = StmtOutlineDef;
+        outline->common.next = NULL;
+        outline->field = field;
+        outline->nPoints = 0;
+        if (points->op == ExprCoord)
+        {
+            for (pt = points; pt != NULL; pt = (ExprDef *) pt->common.next)
+            {
+                outline->nPoints++;
+            }
+        }
+        outline->points = points;
     }
     return outline;
 }
 
 KeyDef *
-KeyDeclCreate(char *name,ExprDef *expr)
+KeyDeclCreate(char *name, ExprDef * expr)
 {
-KeyDef *	key;
+    KeyDef *key;
 
-    key= uTypedAlloc(KeyDef);
-    if (key!=NULL) {
-	bzero(key,sizeof(KeyDef));
-	key->common.stmtType= StmtKeyDef;
-	key->common.next= NULL;
-	if (name)	key->name= name;
-	else		key->expr= expr;
+    key = uTypedAlloc(KeyDef);
+    if (key != NULL)
+    {
+        bzero(key, sizeof(KeyDef));
+        key->common.stmtType = StmtKeyDef;
+        key->common.next = NULL;
+        if (name)
+            key->name = name;
+        else
+            key->expr = expr;
     }
     return key;
 }
 
 KeyDef *
-KeyDeclMerge(KeyDef *into,KeyDef *from)
+KeyDeclMerge(KeyDef * into, KeyDef * from)
 {
-    into->expr= (ExprDef *)AppendStmt(&into->expr->common,&from->expr->common);
-    from->expr= NULL;
+    into->expr =
+        (ExprDef *) AppendStmt(&into->expr->common, &from->expr->common);
+    from->expr = NULL;
     uFree(from);
     return into;
 }
 
 RowDef *
-RowDeclCreate(KeyDef *	keys)
-{
-RowDef *	row;
-KeyDef *	key;
-
-    row= uTypedAlloc(RowDef);
-    if (row!=NULL) {
-	bzero(row,sizeof(RowDef));
-	row->common.stmtType= StmtRowDef;
-	row->common.next= NULL;
-	row->nKeys= 0;
-	row->keys= keys;
-	for (key=keys;key!=NULL;key=(KeyDef *)key->common.next) {
-	    if (key->common.stmtType==StmtKeyDef)
-		row->nKeys++;
-	}
+RowDeclCreate(KeyDef * keys)
+{
+    RowDef *row;
+    KeyDef *key;
+
+    row = uTypedAlloc(RowDef);
+    if (row != NULL)
+    {
+        bzero(row, sizeof(RowDef));
+        row->common.stmtType = StmtRowDef;
+        row->common.next = NULL;
+        row->nKeys = 0;
+        row->keys = keys;
+        for (key = keys; key != NULL; key = (KeyDef *) key->common.next)
+        {
+            if (key->common.stmtType == StmtKeyDef)
+                row->nKeys++;
+        }
     }
     return row;
 }
 
 SectionDef *
-SectionDeclCreate(Atom name,RowDef *rows)
-{
-SectionDef *	section;
-RowDef *	row;
-
-    section= uTypedAlloc(SectionDef);
-    if (section!=NULL) {
-	bzero(section,sizeof(SectionDef));
-	section->common.stmtType= StmtSectionDef;
-	section->common.next= NULL;
-	section->name= name;
-	section->nRows= 0;
-	section->rows= rows;
-	for (row=rows;row!=NULL;row=(RowDef *)row->common.next) {
-	    if (row->common.stmtType==StmtRowDef)
-		section->nRows++;
-	}
+SectionDeclCreate(Atom name, RowDef * rows)
+{
+    SectionDef *section;
+    RowDef *row;
+
+    section = uTypedAlloc(SectionDef);
+    if (section != NULL)
+    {
+        bzero(section, sizeof(SectionDef));
+        section->common.stmtType = StmtSectionDef;
+        section->common.next = NULL;
+        section->name = name;
+        section->nRows = 0;
+        section->rows = rows;
+        for (row = rows; row != NULL; row = (RowDef *) row->common.next)
+        {
+            if (row->common.stmtType == StmtRowDef)
+                section->nRows++;
+        }
     }
     return section;
 }
 
 OverlayKeyDef *
-OverlayKeyCreate(char *	under,char *over)
-{
-OverlayKeyDef *	key;
-
-    key= uTypedAlloc(OverlayKeyDef);
-    if (key!=NULL) {
-	bzero(key,sizeof(OverlayKeyDef));
-	key->common.stmtType= StmtOverlayKeyDef;
-	strncpy(key->over,over,XkbKeyNameLength);
-	strncpy(key->under,under,XkbKeyNameLength);
-	if (over)	uFree(over);
-	if (under)	uFree(under);
+OverlayKeyCreate(char *under, char *over)
+{
+    OverlayKeyDef *key;
+
+    key = uTypedAlloc(OverlayKeyDef);
+    if (key != NULL)
+    {
+        bzero(key, sizeof(OverlayKeyDef));
+        key->common.stmtType = StmtOverlayKeyDef;
+        strncpy(key->over, over, XkbKeyNameLength);
+        strncpy(key->under, under, XkbKeyNameLength);
+        if (over)
+            uFree(over);
+        if (under)
+            uFree(under);
     }
     return key;
 }
 
 OverlayDef *
-OverlayDeclCreate(Atom name,OverlayKeyDef *keys)
-{
-OverlayDef *	ol;
-OverlayKeyDef *	key;
-
-    ol= uTypedAlloc(OverlayDef);
-    if (ol!=NULL) {
-	bzero(ol,sizeof(OverlayDef));
-	ol->common.stmtType= 	StmtOverlayDef;
-	ol->name=		name;
-	ol->keys=		keys;
-	for (key=keys;key!=NULL;key=(OverlayKeyDef *)key->common.next) {
-	    ol->nKeys++;
-	}
+OverlayDeclCreate(Atom name, OverlayKeyDef * keys)
+{
+    OverlayDef *ol;
+    OverlayKeyDef *key;
+
+    ol = uTypedAlloc(OverlayDef);
+    if (ol != NULL)
+    {
+        bzero(ol, sizeof(OverlayDef));
+        ol->common.stmtType = StmtOverlayDef;
+        ol->name = name;
+        ol->keys = keys;
+        for (key = keys; key != NULL;
+             key = (OverlayKeyDef *) key->common.next)
+        {
+            ol->nKeys++;
+        }
     }
     return ol;
 }
 
 DoodadDef *
-DoodadCreate(unsigned type,Atom name,VarDef *body)
+DoodadCreate(unsigned type, Atom name, VarDef * body)
 {
-DoodadDef *	doodad;
+    DoodadDef *doodad;
 
-    doodad= uTypedAlloc(DoodadDef);
-    if (doodad!=NULL) {
-	bzero(doodad,sizeof(DoodadDef));
-	doodad->common.stmtType= StmtDoodadDef;
-	doodad->common.next= NULL;
-	doodad->type= type;
-	doodad->name= name;
-	doodad->body= body;
+    doodad = uTypedAlloc(DoodadDef);
+    if (doodad != NULL)
+    {
+        bzero(doodad, sizeof(DoodadDef));
+        doodad->common.stmtType = StmtDoodadDef;
+        doodad->common.next = NULL;
+        doodad->type = type;
+        doodad->name = name;
+        doodad->body = body;
     }
     return doodad;
 }
 
 ExprDef *
-AppendKeysymList(ExprDef *list,KeySym sym)
-{
-    if (list->value.list.nSyms>=list->value.list.szSyms) {
-	list->value.list.szSyms*=2;
-	list->value.list.syms= uTypedRecalloc(list->value.list.syms,
-						list->value.list.nSyms,
-						list->value.list.szSyms,
-						KeySym);
-	if (list->value.list.syms==NULL) {
-	    FATAL("Couldn't resize list of symbols for append\n");
-	    return NULL;
-	}
-    }
-    list->value.list.syms[list->value.list.nSyms++]= sym;
+AppendKeysymList(ExprDef * list, KeySym sym)
+{
+    if (list->value.list.nSyms >= list->value.list.szSyms)
+    {
+        list->value.list.szSyms *= 2;
+        list->value.list.syms = uTypedRecalloc(list->value.list.syms,
+                                               list->value.list.nSyms,
+                                               list->value.list.szSyms,
+                                               KeySym);
+        if (list->value.list.syms == NULL)
+        {
+            FATAL("Couldn't resize list of symbols for append\n");
+            return NULL;
+        }
+    }
+    list->value.list.syms[list->value.list.nSyms++] = sym;
     return list;
 }
 
 int
-LookupKeysym(char *str,KeySym *sym_rtrn)
+LookupKeysym(char *str, KeySym * sym_rtrn)
 {
-KeySym sym;
+    KeySym sym;
 
-    if ((!str)||(uStrCaseCmp(str,"any")==0)||(uStrCaseCmp(str,"nosymbol")==0)) {
-	*sym_rtrn= NoSymbol;
-	return 1;
+    if ((!str) || (uStrCaseCmp(str, "any") == 0)
+        || (uStrCaseCmp(str, "nosymbol") == 0))
+    {
+        *sym_rtrn = NoSymbol;
+        return 1;
     }
-    else if ((uStrCaseCmp(str,"none")==0)||(uStrCaseCmp(str,"voidsymbol")==0)) {
-	*sym_rtrn= XK_VoidSymbol;
-	return 1;
+    else if ((uStrCaseCmp(str, "none") == 0)
+             || (uStrCaseCmp(str, "voidsymbol") == 0))
+    {
+        *sym_rtrn = XK_VoidSymbol;
+        return 1;
     }
-    sym= XStringToKeysym(str);
-    if (sym!=NoSymbol) {
-	*sym_rtrn= sym;
-	return 1;
+    sym = XStringToKeysym(str);
+    if (sym != NoSymbol)
+    {
+        *sym_rtrn = sym;
+        return 1;
     }
     return 0;
 }
 
 IncludeStmt *
-IncludeCreate(char *str,unsigned merge)
-{
-IncludeStmt *	incl,*first;
-char *		file,*map,*stmt,*tmp, *extra_data;
-char 		nextop;
-Bool		haveSelf;
-
-    haveSelf= False;
-    incl= first= NULL;
-    file= map= NULL;
-    tmp= str;
-    stmt= uStringDup(str);
-    while ((tmp)&&(*tmp)) {
-	if (XkbParseIncludeMap(&tmp,&file,&map,&nextop,&extra_data)) {
-	    if ((file==NULL)&&(map==NULL)) {
-		if (haveSelf)
-		    goto BAIL;
-		haveSelf= True;
-	    }
-	    if (first==NULL)
-		first= incl= uTypedAlloc(IncludeStmt);
-	    else {
-		incl->next= uTypedAlloc(IncludeStmt);
-		incl= incl->next;
-	    }
-	    if (incl) {
-		incl->common.stmtType= StmtInclude;
-		incl->common.next= NULL;
-		incl->merge= merge;
-		incl->stmt= NULL;
-		incl->file= file;
-		incl->map= map;
-		incl->modifier= extra_data;
-		incl->path= NULL;
-		incl->next= NULL;
-	    }
-	    else {
-		WSGO("Allocation failure in IncludeCreate\n");
-		ACTION("Using only part of the include\n");
-		break;
-	    }
-	    if (nextop=='|')	merge= MergeAugment;
-	    else		merge= MergeOverride;
-	}
-	else {
-	    goto BAIL;
-	}
-    }
-    if (first)		first->stmt= stmt;
-    else if (stmt)	uFree(stmt);
+IncludeCreate(char *str, unsigned merge)
+{
+    IncludeStmt *incl, *first;
+    char *file, *map, *stmt, *tmp, *extra_data;
+    char nextop;
+    Bool haveSelf;
+
+    haveSelf = False;
+    incl = first = NULL;
+    file = map = NULL;
+    tmp = str;
+    stmt = uStringDup(str);
+    while ((tmp) && (*tmp))
+    {
+        if (XkbParseIncludeMap(&tmp, &file, &map, &nextop, &extra_data))
+        {
+            if ((file == NULL) && (map == NULL))
+            {
+                if (haveSelf)
+                    goto BAIL;
+                haveSelf = True;
+            }
+            if (first == NULL)
+                first = incl = uTypedAlloc(IncludeStmt);
+            else
+            {
+                incl->next = uTypedAlloc(IncludeStmt);
+                incl = incl->next;
+            }
+            if (incl)
+            {
+                incl->common.stmtType = StmtInclude;
+                incl->common.next = NULL;
+                incl->merge = merge;
+                incl->stmt = NULL;
+                incl->file = file;
+                incl->map = map;
+                incl->modifier = extra_data;
+                incl->path = NULL;
+                incl->next = NULL;
+            }
+            else
+            {
+                WSGO("Allocation failure in IncludeCreate\n");
+                ACTION("Using only part of the include\n");
+                break;
+            }
+            if (nextop == '|')
+                merge = MergeAugment;
+            else
+                merge = MergeOverride;
+        }
+        else
+        {
+            goto BAIL;
+        }
+    }
+    if (first)
+        first->stmt = stmt;
+    else if (stmt)
+        uFree(stmt);
     return first;
-BAIL:
-    ERROR1("Illegal include statement \"%s\"\n",stmt);
+  BAIL:
+    ERROR1("Illegal include statement \"%s\"\n", stmt);
     ACTION("Ignored\n");
-    while (first) {
-	incl= first->next;
-	if (first->file) uFree(first->file);
-	if (first->map) uFree(first->map);
-	if (first->modifier) uFree(first->modifier);
-	if (first->path) uFree(first->path);
-	first->file= first->map= first->path= NULL;
-	uFree(first);
-	first= incl;
+    while (first)
+    {
+        incl = first->next;
+        if (first->file)
+            uFree(first->file);
+        if (first->map)
+            uFree(first->map);
+        if (first->modifier)
+            uFree(first->modifier);
+        if (first->path)
+            uFree(first->path);
+        first->file = first->map = first->path = NULL;
+        uFree(first);
+        first = incl;
     }
     if (stmt)
-	uFree(stmt);
+        uFree(stmt);
     return NULL;
 }
 
 #ifdef DEBUG
 void
-PrintStmtAddrs(ParseCommon *stmt)
+PrintStmtAddrs(ParseCommon * stmt)
 {
-    fprintf(stderr,"0x%x",stmt);
-    if (stmt) {
-	do {
-	    fprintf(stderr,"->0x%x",stmt->next);
-	    stmt= stmt->next;
-	} while (stmt);
+    fprintf(stderr, "0x%x", stmt);
+    if (stmt)
+    {
+        do
+        {
+            fprintf(stderr, "->0x%x", stmt->next);
+            stmt = stmt->next;
+        }
+        while (stmt);
     }
-    fprintf(stderr,"\n");
+    fprintf(stderr, "\n");
 }
 #endif
 
 static void
-CheckDefaultMap(XkbFile	*maps)
-{
-XkbFile * dflt,*tmp;
-
-    dflt= NULL;
-    for (tmp=maps,dflt=NULL;tmp!=NULL;tmp=(XkbFile *)tmp->common.next) {
-	if (tmp->flags&XkbLC_Default) {
-	    if (dflt==NULL) 
-		dflt= tmp;
-	    else {
-		if (warningLevel>2) {
-		    WARN1("Multiple default components in %s\n",
-					(scanFile?scanFile:"(unknown)"));
-		    ACTION2("Using %s, ignoring %s\n",
-					(dflt->name?dflt->name:"(first)"),
-					(tmp->name?tmp->name:"(subsequent)"));
-		}
-		tmp->flags&= (~XkbLC_Default);
-	    }
-	}
+CheckDefaultMap(XkbFile * maps)
+{
+    XkbFile *dflt, *tmp;
+
+    dflt = NULL;
+    for (tmp = maps, dflt = NULL; tmp != NULL;
+         tmp = (XkbFile *) tmp->common.next)
+    {
+        if (tmp->flags & XkbLC_Default)
+        {
+            if (dflt == NULL)
+                dflt = tmp;
+            else
+            {
+                if (warningLevel > 2)
+                {
+                    WARN1("Multiple default components in %s\n",
+                          (scanFile ? scanFile : "(unknown)"));
+                    ACTION2("Using %s, ignoring %s\n",
+                            (dflt->name ? dflt->name : "(first)"),
+                            (tmp->name ? tmp->name : "(subsequent)"));
+                }
+                tmp->flags &= (~XkbLC_Default);
+            }
+        }
     }
     return;
 }
 
 int
-XKBParseFile(FILE *file,XkbFile	**pRtrn)
-{
-    if (file) {
-	yyin= file;
-	rtrnValue= NULL;
-	if (yyparse()==0) {
-	    *pRtrn= rtrnValue;
-	    CheckDefaultMap(rtrnValue);
-	    rtrnValue= NULL;
-	    return 1;
-	}
-	*pRtrn= NULL;
-	return 0;
-    }
-    *pRtrn= NULL;
+XKBParseFile(FILE * file, XkbFile ** pRtrn)
+{
+    if (file)
+    {
+        yyin = file;
+        rtrnValue = NULL;
+        if (yyparse() == 0)
+        {
+            *pRtrn = rtrnValue;
+            CheckDefaultMap(rtrnValue);
+            rtrnValue = NULL;
+            return 1;
+        }
+        *pRtrn = NULL;
+        return 0;
+    }
+    *pRtrn = NULL;
     return 1;
 }
 
 XkbFile *
-CreateXKBFile(int type,char *name,ParseCommon *defs,unsigned flags)
-{
-XkbFile *	file;
-static int	fileID;
-
-    file= uTypedAlloc(XkbFile);
-    if (file) {
-	XkbEnsureSafeMapName(name);
-	bzero(file,sizeof(XkbFile));
-	file->type= type;
-	file->topName= uStringDup(name);
-	file->name= name;
-	file->defs= defs;
-	file->id= fileID++;
-	file->compiled= False;
-	file->flags= flags;
+CreateXKBFile(int type, char *name, ParseCommon * defs, unsigned flags)
+{
+    XkbFile *file;
+    static int fileID;
+
+    file = uTypedAlloc(XkbFile);
+    if (file)
+    {
+        XkbEnsureSafeMapName(name);
+        bzero(file, sizeof(XkbFile));
+        file->type = type;
+        file->topName = uStringDup(name);
+        file->name = name;
+        file->defs = defs;
+        file->id = fileID++;
+        file->compiled = False;
+        file->flags = flags;
     }
     return file;
 }
 
-unsigned 
-StmtSetMerge(ParseCommon *stmt,unsigned	merge)
+unsigned
+StmtSetMerge(ParseCommon * stmt, unsigned merge)
 {
-    if ((merge==MergeAltForm) && (stmt->stmtType!=StmtKeycodeDef)) {
-	yyerror("illegal use of 'alternate' merge mode");
-	merge= MergeDefault;
+    if ((merge == MergeAltForm) && (stmt->stmtType != StmtKeycodeDef))
+    {
+        yyerror("illegal use of 'alternate' merge mode");
+        merge = MergeDefault;
     }
     return merge;
 }