src/xkbcomp/parseutils.c

   1 /************************************************************
   2  Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
   3
   4  Permission to use, copy, modify, and distribute this
   5  software and its documentation for any purpose and without
   6  fee is hereby granted, provided that the above copyright
   7  notice appear in all copies and that both that copyright
   8  notice and this permission notice appear in supporting
   9  documentation, and that the name of Silicon Graphics not be
  10  used in advertising or publicity pertaining to distribution
  11  of the software without specific prior written permission.
  12  Silicon Graphics makes no representation about the suitability
  13  of this software for any purpose. It is provided "as is"
  14  without any express or implied warranty.
  15
  16  SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  17  SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  18  AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
  19  GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  20  DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  21  DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  22  OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
  23  THE USE OR PERFORMANCE OF THIS SOFTWARE.
  24
  25  ********************************************************/
  26
  27 #define DEBUG_VAR parseDebug
  28 #include "parseutils.h"
  29 #include "xkbmisc.h"
  30 #include "xkbpath.h"
  31 #include <X11/keysym.h>
  32 #include <X11/Xalloca.h>
  33
  34 XkbFile *rtrnValue;
  35
  36 ParseCommon *
  37 AppendStmt(ParseCommon * to, ParseCommon * append)
  38 {
  39     ParseCommon *start = to;
  40
  41     if (append == NULL)
  42         return to;
  43     while ((to != NULL) && (to->next != NULL))
  44     {
  45         to = to->next;
  46     }
  47     if (to)
  48     {
  49         to->next = append;
  50         return start;
  51     }
  52     return append;
  53 }
  54
  55 ExprDef *
  56 ExprCreate(unsigned op, unsigned type)
  57 {
  58     ExprDef *expr;
  59     expr = uTypedAlloc(ExprDef);
  60     if (expr)
  61     {
  62         expr->common.stmtType = StmtExpr;
  63         expr->common.next = NULL;
  64         expr->op = op;
  65         expr->type = type;
  66     }
  67     else
  68     {
  69         FATAL("Couldn't allocate expression in parser\n");
  70         /* NOTREACHED */
  71     }
  72     return expr;
  73 }
  74
  75 ExprDef *
  76 ExprCreateUnary(unsigned op, unsigned type, ExprDef * child)
  77 {
  78     ExprDef *expr;
  79     expr = uTypedAlloc(ExprDef);
  80     if (expr)
  81     {
  82         expr->common.stmtType = StmtExpr;
  83         expr->common.next = NULL;
  84         expr->op = op;
  85         expr->type = type;
  86         expr->value.child = child;
  87     }
  88     else
  89     {
  90         FATAL("Couldn't allocate expression in parser\n");
  91         /* NOTREACHED */
  92     }
  93     return expr;
  94 }
  95
  96 ExprDef *
  97 ExprCreateBinary(unsigned op, ExprDef * left, ExprDef * right)
  98 {
  99     ExprDef *expr;
 100     expr = uTypedAlloc(ExprDef);
 101     if (expr)
 102     {
 103         expr->common.stmtType = StmtExpr;
 104         expr->common.next = NULL;
 105         expr->op = op;
 106         if ((op == OpAssign) || (left->type == TypeUnknown))
 107             expr->type = right->type;
 108         else if ((left->type == right->type) || (right->type == TypeUnknown))
 109             expr->type = left->type;
 110         else
 111             expr->type = TypeUnknown;
 112         expr->value.binary.left = left;
 113         expr->value.binary.right = right;
 114     }
 115     else
 116     {
 117         FATAL("Couldn't allocate expression in parser\n");
 118         /* NOTREACHED */
 119     }
 120     return expr;
 121 }
 122
 123 KeycodeDef *
 124 KeycodeCreate(char *name, ExprDef * value)
 125 {
 126     KeycodeDef *def;
 127
 128     def = uTypedAlloc(KeycodeDef);
 129     if (def)
 130     {
 131         def->common.stmtType = StmtKeycodeDef;
 132         def->common.next = NULL;
 133         strncpy(def->name, name, XkbKeyNameLength);
 134         def->name[XkbKeyNameLength] = '\0';
 135         def->value = value;
 136     }
 137     else
 138     {
 139         FATAL("Couldn't allocate key name definition in parser\n");
 140         /* NOTREACHED */
 141     }
 142     return def;
 143 }
 144
 145 KeyAliasDef *
 146 KeyAliasCreate(char *alias, char *real)
 147 {
 148     KeyAliasDef *def;
 149
 150     def = uTypedAlloc(KeyAliasDef);
 151     if (def)
 152     {
 153         def->common.stmtType = StmtKeyAliasDef;
 154         def->common.next = NULL;
 155         strncpy(def->alias, alias, XkbKeyNameLength);
 156         def->alias[XkbKeyNameLength] = '\0';
 157         strncpy(def->real, real, XkbKeyNameLength);
 158         def->real[XkbKeyNameLength] = '\0';
 159     }
 160     else
 161     {
 162         FATAL("Couldn't allocate key alias definition in parser\n");
 163         /* NOTREACHED */
 164     }
 165     return def;
 166 }
 167
 168 VModDef *
 169 VModCreate(CARD32 name, ExprDef * value)
 170 {
 171     VModDef *def;
 172     def = uTypedAlloc(VModDef);
 173     if (def)
 174     {
 175         def->common.stmtType = StmtVModDef;
 176         def->common.next = NULL;
 177         def->name = name;
 178         def->value = value;
 179     }
 180     else
 181     {
 182         FATAL("Couldn't allocate variable definition in parser\n");
 183         /* NOTREACHED */
 184     }
 185     return def;
 186 }
 187
 188 VarDef *
 189 VarCreate(ExprDef * name, ExprDef * value)
 190 {
 191     VarDef *def;
 192     def = uTypedAlloc(VarDef);
 193     if (def)
 194     {
 195         def->common.stmtType = StmtVarDef;
 196         def->common.next = NULL;
 197         def->name = name;
 198         def->value = value;
 199     }
 200     else
 201     {
 202         FATAL("Couldn't allocate variable definition in parser\n");
 203         /* NOTREACHED */
 204     }
 205     return def;
 206 }
 207
 208 VarDef *
 209 BoolVarCreate(CARD32 nameToken, unsigned set)
 210 {
 211     ExprDef *name, *value;
 212
 213     name = ExprCreate(ExprIdent, TypeUnknown);
 214     name->value.str = nameToken;
 215     value = ExprCreate(ExprValue, TypeBoolean);
 216     value->value.uval = set;
 217     return VarCreate(name, value);
 218 }
 219
 220 InterpDef *
 221 InterpCreate(char *sym, ExprDef * match)
 222 {
 223     InterpDef *def;
 224
 225     def = uTypedAlloc(InterpDef);
 226     if (def)
 227     {
 228         def->common.stmtType = StmtInterpDef;
 229         def->common.next = NULL;
 230         def->sym = strdup(sym);
 231         def->match = match;
 232     }
 233     else
 234     {
 235         FATAL("Couldn't allocate interp definition in parser\n");
 236         /* NOTREACHED */
 237     }
 238     return def;
 239 }
 240
 241 KeyTypeDef *
 242 KeyTypeCreate(CARD32 name, VarDef * body)
 243 {
 244     KeyTypeDef *def;
 245
 246     def = uTypedAlloc(KeyTypeDef);
 247     if (def)
 248     {
 249         def->common.stmtType = StmtKeyTypeDef;
 250         def->common.next = NULL;
 251         def->merge = MergeDefault;
 252         def->name = name;
 253         def->body = body;
 254     }
 255     else
 256     {
 257         FATAL("Couldn't allocate key type definition in parser\n");
 258         /* NOTREACHED */
 259     }
 260     return def;
 261 }
 262
 263 SymbolsDef *
 264 SymbolsCreate(char *keyName, ExprDef * symbols)
 265 {
 266     SymbolsDef *def;
 267
 268     def = uTypedAlloc(SymbolsDef);
 269     if (def)
 270     {
 271         def->common.stmtType = StmtSymbolsDef;
 272         def->common.next = NULL;
 273         def->merge = MergeDefault;
 274         bzero(def->keyName, 5);
 275         strncpy(def->keyName, keyName, 4);
 276         def->symbols = symbols;
 277     }
 278     else
 279     {
 280         FATAL("Couldn't allocate symbols definition in parser\n");
 281         /* NOTREACHED */
 282     }
 283     return def;
 284 }
 285
 286 GroupCompatDef *
 287 GroupCompatCreate(int group, ExprDef * val)
 288 {
 289     GroupCompatDef *def;
 290
 291     def = uTypedAlloc(GroupCompatDef);
 292     if (def)
 293     {
 294         def->common.stmtType = StmtGroupCompatDef;
 295         def->common.next = NULL;
 296         def->merge = MergeDefault;
 297         def->group = group;
 298         def->def = val;
 299     }
 300     else
 301     {
 302         FATAL("Couldn't allocate group compat definition in parser\n");
 303         /* NOTREACHED */
 304     }
 305     return def;
 306 }
 307
 308 ModMapDef *
 309 ModMapCreate(CARD32 modifier, ExprDef * keys)
 310 {
 311     ModMapDef *def;
 312
 313     def = uTypedAlloc(ModMapDef);
 314     if (def)
 315     {
 316         def->common.stmtType = StmtModMapDef;
 317         def->common.next = NULL;
 318         def->merge = MergeDefault;
 319         def->modifier = modifier;
 320         def->keys = keys;
 321     }
 322     else
 323     {
 324         FATAL("Couldn't allocate mod mask definition in parser\n");
 325         /* NOTREACHED */
 326     }
 327     return def;
 328 }
 329
 330 IndicatorMapDef *
 331 IndicatorMapCreate(CARD32 name, VarDef * body)
 332 {
 333     IndicatorMapDef *def;
 334
 335     def = uTypedAlloc(IndicatorMapDef);
 336     if (def)
 337     {
 338         def->common.stmtType = StmtIndicatorMapDef;
 339         def->common.next = NULL;
 340         def->merge = MergeDefault;
 341         def->name = name;
 342         def->body = body;
 343     }
 344     else
 345     {
 346         FATAL("Couldn't allocate indicator map definition in parser\n");
 347         /* NOTREACHED */
 348     }
 349     return def;
 350 }
 351
 352 IndicatorNameDef *
 353 IndicatorNameCreate(int ndx, ExprDef * name, Bool virtual)
 354 {
 355     IndicatorNameDef *def;
 356
 357     def = uTypedAlloc(IndicatorNameDef);
 358     if (def)
 359     {
 360         def->common.stmtType = StmtIndicatorNameDef;
 361         def->common.next = NULL;
 362         def->merge = MergeDefault;
 363         def->ndx = ndx;
 364         def->name = name;
 365         def->virtual = virtual;
 366     }
 367     else
 368     {
 369         FATAL("Couldn't allocate indicator index definition in parser\n");
 370         /* NOTREACHED */
 371     }
 372     return def;
 373 }
 374
 375 ExprDef *
 376 ActionCreate(CARD32 name, ExprDef * args)
 377 {
 378     ExprDef *act;
 379
 380     act = uTypedAlloc(ExprDef);
 381     if (act)
 382     {
 383         act->common.stmtType = StmtExpr;
 384         act->common.next = NULL;
 385         act->op = ExprActionDecl;
 386         act->value.action.name = name;
 387         act->value.action.args = args;
 388         return act;
 389     }
 390     FATAL("Couldn't allocate ActionDef in parser\n");
 391     return NULL;
 392 }
 393
 394 ExprDef *
 395 CreateKeysymList(char *sym)
 396 {
 397     ExprDef *def;
 398
 399     def = ExprCreate(ExprKeysymList, TypeSymbols);
 400     if (def)
 401     {
 402         def->value.list.nSyms = 1;
 403         def->value.list.szSyms = 4;
 404         def->value.list.syms = uTypedCalloc(4, char *);
 405         if (def->value.list.syms != NULL)
 406         {
 407             def->value.list.syms[0] = sym;
 408             return def;
 409         }
 410     }
 411     FATAL("Couldn't allocate expression for keysym list in parser\n");
 412     return NULL;
 413 }
 414
 415 ShapeDef *
 416 ShapeDeclCreate(CARD32 name, OutlineDef * outlines)
 417 {
 418     ShapeDef *shape;
 419     OutlineDef *ol;
 420
 421     shape = uTypedAlloc(ShapeDef);
 422     if (shape != NULL)
 423     {
 424         bzero(shape, sizeof(ShapeDef));
 425         shape->common.stmtType = StmtShapeDef;
 426         shape->common.next = NULL;
 427         shape->merge = MergeDefault;
 428         shape->name = name;
 429         shape->nOutlines = 0;
 430         shape->outlines = outlines;
 431         for (ol = outlines; ol != NULL; ol = (OutlineDef *) ol->common.next)
 432         {
 433             if (ol->nPoints > 0)
 434                 shape->nOutlines++;
 435         }
 436     }
 437     return shape;
 438 }
 439
 440 OutlineDef *
 441 OutlineCreate(CARD32 field, ExprDef * points)
 442 {
 443     OutlineDef *outline;
 444     ExprDef *pt;
 445
 446     outline = uTypedAlloc(OutlineDef);
 447     if (outline != NULL)
 448     {
 449         bzero(outline, sizeof(OutlineDef));
 450         outline->common.stmtType = StmtOutlineDef;
 451         outline->common.next = NULL;
 452         outline->field = field;
 453         outline->nPoints = 0;
 454         if (points->op == ExprCoord)
 455         {
 456             for (pt = points; pt != NULL; pt = (ExprDef *) pt->common.next)
 457             {
 458                 outline->nPoints++;
 459             }
 460         }
 461         outline->points = points;
 462     }
 463     return outline;
 464 }
 465
 466 KeyDef *
 467 KeyDeclCreate(char *name, ExprDef * expr)
 468 {
 469     KeyDef *key;
 470
 471     key = uTypedAlloc(KeyDef);
 472     if (key != NULL)
 473     {
 474         bzero(key, sizeof(KeyDef));
 475         key->common.stmtType = StmtKeyDef;
 476         key->common.next = NULL;
 477         if (name)
 478             key->name = name;
 479         else
 480             key->expr = expr;
 481     }
 482     return key;
 483 }
 484
 485 KeyDef *
 486 KeyDeclMerge(KeyDef * into, KeyDef * from)
 487 {
 488     into->expr =
 489         (ExprDef *) AppendStmt(&into->expr->common, &from->expr->common);
 490     from->expr = NULL;
 491     uFree(from);
 492     return into;
 493 }
 494
 495 RowDef *
 496 RowDeclCreate(KeyDef * keys)
 497 {
 498     RowDef *row;
 499     KeyDef *key;
 500
 501     row = uTypedAlloc(RowDef);
 502     if (row != NULL)
 503     {
 504         bzero(row, sizeof(RowDef));
 505         row->common.stmtType = StmtRowDef;
 506         row->common.next = NULL;
 507         row->nKeys = 0;
 508         row->keys = keys;
 509         for (key = keys; key != NULL; key = (KeyDef *) key->common.next)
 510         {
 511             if (key->common.stmtType == StmtKeyDef)
 512                 row->nKeys++;
 513         }
 514     }
 515     return row;
 516 }
 517
 518 SectionDef *
 519 SectionDeclCreate(CARD32 name, RowDef * rows)
 520 {
 521     SectionDef *section;
 522     RowDef *row;
 523
 524     section = uTypedAlloc(SectionDef);
 525     if (section != NULL)
 526     {
 527         bzero(section, sizeof(SectionDef));
 528         section->common.stmtType = StmtSectionDef;
 529         section->common.next = NULL;
 530         section->name = name;
 531         section->nRows = 0;
 532         section->rows = rows;
 533         for (row = rows; row != NULL; row = (RowDef *) row->common.next)
 534         {
 535             if (row->common.stmtType == StmtRowDef)
 536                 section->nRows++;
 537         }
 538     }
 539     return section;
 540 }
 541
 542 OverlayKeyDef *
 543 OverlayKeyCreate(char *under, char *over)
 544 {
 545     OverlayKeyDef *key;
 546
 547     key = uTypedAlloc(OverlayKeyDef);
 548     if (key != NULL)
 549     {
 550         bzero(key, sizeof(OverlayKeyDef));
 551         key->common.stmtType = StmtOverlayKeyDef;
 552         strncpy(key->over, over, XkbKeyNameLength);
 553         strncpy(key->under, under, XkbKeyNameLength);
 554         if (over)
 555             uFree(over);
 556         if (under)
 557             uFree(under);
 558     }
 559     return key;
 560 }
 561
 562 OverlayDef *
 563 OverlayDeclCreate(CARD32 name, OverlayKeyDef * keys)
 564 {
 565     OverlayDef *ol;
 566     OverlayKeyDef *key;
 567
 568     ol = uTypedAlloc(OverlayDef);
 569     if (ol != NULL)
 570     {
 571         bzero(ol, sizeof(OverlayDef));
 572         ol->common.stmtType = StmtOverlayDef;
 573         ol->name = name;
 574         ol->keys = keys;
 575         for (key = keys; key != NULL;
 576              key = (OverlayKeyDef *) key->common.next)
 577         {
 578             ol->nKeys++;
 579         }
 580     }
 581     return ol;
 582 }
 583
 584 DoodadDef *
 585 DoodadCreate(unsigned type, CARD32 name, VarDef * body)
 586 {
 587     DoodadDef *doodad;
 588
 589     doodad = uTypedAlloc(DoodadDef);
 590     if (doodad != NULL)
 591     {
 592         bzero(doodad, sizeof(DoodadDef));
 593         doodad->common.stmtType = StmtDoodadDef;
 594         doodad->common.next = NULL;
 595         doodad->type = type;
 596         doodad->name = name;
 597         doodad->body = body;
 598     }
 599     return doodad;
 600 }
 601
 602 ExprDef *
 603 AppendKeysymList(ExprDef * list, char *sym)
 604 {
 605     if (list->value.list.nSyms >= list->value.list.szSyms)
 606     {
 607         list->value.list.szSyms *= 2;
 608         list->value.list.syms = uTypedRecalloc(list->value.list.syms,
 609                                                list->value.list.nSyms,
 610                                                list->value.list.szSyms,
 611                                                char *);
 612         if (list->value.list.syms == NULL)
 613         {
 614             FATAL("Couldn't resize list of symbols for append\n");
 615             return NULL;
 616         }
 617     }
 618     list->value.list.syms[list->value.list.nSyms++] = sym;
 619     return list;
 620 }
 621
 622 int
 623 LookupKeysym(char *str, CARD32 * sym_rtrn)
 624 {
 625     CARD32 sym;
 626
 627     if ((!str) || (uStrCaseCmp(str, "any") == 0)
 628         || (uStrCaseCmp(str, "nosymbol") == 0))
 629     {
 630         *sym_rtrn = NoSymbol;
 631         return 1;
 632     }
 633     else if ((uStrCaseCmp(str, "none") == 0)
 634              || (uStrCaseCmp(str, "voidsymbol") == 0))
 635     {
 636         *sym_rtrn = XK_VoidSymbol;
 637         return 1;
 638     }
 639     sym = XkbcStringToKeysym(str);
 640     if (sym != NoSymbol)
 641     {
 642         *sym_rtrn = sym;
 643         return 1;
 644     }
 645     return 0;
 646 }
 647
 648 IncludeStmt *
 649 IncludeCreate(char *str, unsigned merge)
 650 {
 651     IncludeStmt *incl, *first;
 652     char *file, *map, *stmt, *tmp, *extra_data;
 653     char nextop;
 654     Bool haveSelf;
 655
 656     haveSelf = False;
 657     incl = first = NULL;
 658     file = map = NULL;
 659     tmp = str;
 660     stmt = _XkbDupString(str);
 661     while ((tmp) && (*tmp))
 662     {
 663         if (XkbParseIncludeMap(&tmp, &file, &map, &nextop, &extra_data))
 664         {
 665             if ((file == NULL) && (map == NULL))
 666             {
 667                 if (haveSelf)
 668                     goto BAIL;
 669                 haveSelf = True;
 670             }
 671             if (first == NULL)
 672                 first = incl = uTypedAlloc(IncludeStmt);
 673             else
 674             {
 675                 incl->next = uTypedAlloc(IncludeStmt);
 676                 incl = incl->next;
 677             }
 678             if (incl)
 679             {
 680                 incl->common.stmtType = StmtInclude;
 681                 incl->common.next = NULL;
 682                 incl->merge = merge;
 683                 incl->stmt = NULL;
 684                 incl->file = file;
 685                 incl->map = map;
 686                 incl->modifier = extra_data;
 687                 incl->path = NULL;
 688                 incl->next = NULL;
 689             }
 690             else
 691             {
 692                 WSGO("Allocation failure in IncludeCreate\n");
 693                 ACTION("Using only part of the include\n");
 694                 break;
 695             }
 696             if (nextop == '|')
 697                 merge = MergeAugment;
 698             else
 699                 merge = MergeOverride;
 700         }
 701         else
 702         {
 703             goto BAIL;
 704         }
 705     }
 706     if (first)
 707         first->stmt = stmt;
 708     else if (stmt)
 709         uFree(stmt);
 710     return first;
 711   BAIL:
 712     ERROR("Illegal include statement \"%s\"\n", stmt);
 713     ACTION("Ignored\n");
 714     while (first)
 715     {
 716         incl = first->next;
 717         if (first->file)
 718             uFree(first->file);
 719         if (first->map)
 720             uFree(first->map);
 721         if (first->modifier)
 722             uFree(first->modifier);
 723         if (first->path)
 724             uFree(first->path);
 725         first->file = first->map = first->path = NULL;
 726         uFree(first);
 727         first = incl;
 728     }
 729     if (stmt)
 730         uFree(stmt);
 731     return NULL;
 732 }
 733
 734 #ifdef DEBUG
 735 void
 736 PrintStmtAddrs(ParseCommon * stmt)
 737 {
 738     fprintf(stderr, "0x%x", stmt);
 739     if (stmt)
 740     {
 741         do
 742         {
 743             fprintf(stderr, "->0x%x", stmt->next);
 744             stmt = stmt->next;
 745         }
 746         while (stmt);
 747     }
 748     fprintf(stderr, "\n");
 749 }
 750 #endif
 751
 752 static void
 753 CheckDefaultMap(XkbFile * maps)
 754 {
 755     XkbFile *dflt, *tmp;
 756
 757     dflt = NULL;
 758     for (tmp = maps, dflt = NULL; tmp != NULL;
 759          tmp = (XkbFile *) tmp->common.next)
 760     {
 761         if (tmp->flags & XkbLC_Default)
 762         {
 763             if (dflt == NULL)
 764                 dflt = tmp;
 765             else
 766             {
 767                 if (warningLevel > 2)
 768                 {
 769                     WARN("Multiple default components in %s\n",
 770                           (scanFile ? scanFile : "(unknown)"));
 771                     ACTION("Using %s, ignoring %s\n",
 772                             (dflt->name ? dflt->name : "(first)"),
 773                             (tmp->name ? tmp->name : "(subsequent)"));
 774                 }
 775                 tmp->flags &= (~XkbLC_Default);
 776             }
 777         }
 778     }
 779     return;
 780 }
 781
 782 int
 783 XKBParseFile(FILE * file, XkbFile ** pRtrn)
 784 {
 785     if (file)
 786     {
 787         yyin = file;
 788         rtrnValue = NULL;
 789         if (yyparse() == 0)
 790         {
 791             *pRtrn = rtrnValue;
 792             CheckDefaultMap(rtrnValue);
 793             rtrnValue = NULL;
 794             return 1;
 795         }
 796         *pRtrn = NULL;
 797         return 0;
 798     }
 799     *pRtrn = NULL;
 800     return 1;
 801 }
 802
 803 XkbFile *
 804 CreateXKBFile(int type, char *name, ParseCommon * defs, unsigned flags)
 805 {
 806     XkbFile *file;
 807     static int fileID;
 808
 809     file = uTypedAlloc(XkbFile);
 810     if (file)
 811     {
 812         XkbcEnsureSafeMapName(name);
 813         bzero(file, sizeof(XkbFile));
 814         file->type = type;
 815         file->topName = _XkbDupString(name);
 816         file->name = name;
 817         file->defs = defs;
 818         file->id = fileID++;
 819         file->compiled = False;
 820         file->flags = flags;
 821     }
 822     return file;
 823 }
 824
 825 unsigned
 826 StmtSetMerge(ParseCommon * stmt, unsigned merge)
 827 {
 828     if ((merge == MergeAltForm) && (stmt->stmtType != StmtKeycodeDef))
 829     {
 830         yyerror("illegal use of 'alternate' merge mode");
 831         merge = MergeDefault;
 832     }
 833     return merge;
 834 }