1 /************************************************************
2 Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
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.
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.
25 ********************************************************/
27 #include "parseutils.h"
29 #include <X11/keysym.h>
32 AppendStmt(ParseCommon * to, ParseCommon * append)
34 ParseCommon *start = to;
38 while ((to != NULL) && (to->next != NULL))
51 ExprCreate(unsigned op, unsigned type)
54 expr = uTypedAlloc(ExprDef);
57 expr->common.stmtType = StmtExpr;
58 expr->common.next = NULL;
64 FATAL("Couldn't allocate expression in parser\n");
71 ExprCreateUnary(unsigned op, unsigned type, ExprDef * child)
74 expr = uTypedAlloc(ExprDef);
77 expr->common.stmtType = StmtExpr;
78 expr->common.next = NULL;
81 expr->value.child = child;
85 FATAL("Couldn't allocate expression in parser\n");
92 ExprCreateBinary(unsigned op, ExprDef * left, ExprDef * right)
95 expr = uTypedAlloc(ExprDef);
98 expr->common.stmtType = StmtExpr;
99 expr->common.next = NULL;
101 if ((op == OpAssign) || (left->type == TypeUnknown))
102 expr->type = right->type;
103 else if ((left->type == right->type) || (right->type == TypeUnknown))
104 expr->type = left->type;
106 expr->type = TypeUnknown;
107 expr->value.binary.left = left;
108 expr->value.binary.right = right;
112 FATAL("Couldn't allocate expression in parser\n");
119 KeycodeCreate(const char *name, unsigned long value)
123 def = uTypedAlloc(KeycodeDef);
126 def->common.stmtType = StmtKeycodeDef;
127 def->common.next = NULL;
128 strncpy(def->name, name, XkbKeyNameLength);
129 def->name[XkbKeyNameLength] = '\0';
134 FATAL("Couldn't allocate key name definition in parser\n");
141 KeyAliasCreate(const char *alias, const char *real)
145 def = uTypedAlloc(KeyAliasDef);
148 def->common.stmtType = StmtKeyAliasDef;
149 def->common.next = NULL;
150 strncpy(def->alias, alias, XkbKeyNameLength);
151 def->alias[XkbKeyNameLength] = '\0';
152 strncpy(def->real, real, XkbKeyNameLength);
153 def->real[XkbKeyNameLength] = '\0';
157 FATAL("Couldn't allocate key alias definition in parser\n");
164 VModCreate(xkb_atom_t name, ExprDef * value)
167 def = uTypedAlloc(VModDef);
170 def->common.stmtType = StmtVModDef;
171 def->common.next = NULL;
177 FATAL("Couldn't allocate variable definition in parser\n");
184 VarCreate(ExprDef * name, ExprDef * value)
187 def = uTypedAlloc(VarDef);
190 def->common.stmtType = StmtVarDef;
191 def->common.next = NULL;
197 FATAL("Couldn't allocate variable definition in parser\n");
204 BoolVarCreate(xkb_atom_t nameToken, unsigned set)
206 ExprDef *name, *value;
208 name = ExprCreate(ExprIdent, TypeUnknown);
209 name->value.str = nameToken;
210 value = ExprCreate(ExprValue, TypeBoolean);
211 value->value.uval = set;
212 return VarCreate(name, value);
216 InterpCreate(char *sym, ExprDef * match)
220 def = uTypedAlloc(InterpDef);
223 def->common.stmtType = StmtInterpDef;
224 def->common.next = NULL;
230 FATAL("Couldn't allocate interp definition in parser\n");
237 KeyTypeCreate(xkb_atom_t name, VarDef * body)
241 def = uTypedAlloc(KeyTypeDef);
244 def->common.stmtType = StmtKeyTypeDef;
245 def->common.next = NULL;
246 def->merge = MergeDefault;
252 FATAL("Couldn't allocate key type definition in parser\n");
259 SymbolsCreate(const char *keyName, ExprDef *symbols)
263 def = uTypedAlloc(SymbolsDef);
266 def->common.stmtType = StmtSymbolsDef;
267 def->common.next = NULL;
268 def->merge = MergeDefault;
269 memset(def->keyName, 0, 5);
270 strncpy(def->keyName, keyName, 4);
271 def->symbols = symbols;
275 FATAL("Couldn't allocate symbols definition in parser\n");
282 GroupCompatCreate(int group, ExprDef * val)
286 def = uTypedAlloc(GroupCompatDef);
289 def->common.stmtType = StmtGroupCompatDef;
290 def->common.next = NULL;
291 def->merge = MergeDefault;
297 FATAL("Couldn't allocate group compat definition in parser\n");
304 ModMapCreate(uint32_t modifier, ExprDef * keys)
308 def = uTypedAlloc(ModMapDef);
311 def->common.stmtType = StmtModMapDef;
312 def->common.next = NULL;
313 def->merge = MergeDefault;
314 def->modifier = modifier;
319 FATAL("Couldn't allocate mod mask definition in parser\n");
326 IndicatorMapCreate(xkb_atom_t name, VarDef * body)
328 IndicatorMapDef *def;
330 def = uTypedAlloc(IndicatorMapDef);
333 def->common.stmtType = StmtIndicatorMapDef;
334 def->common.next = NULL;
335 def->merge = MergeDefault;
341 FATAL("Couldn't allocate indicator map definition in parser\n");
348 IndicatorNameCreate(int ndx, ExprDef * name, bool virtual)
350 IndicatorNameDef *def;
352 def = uTypedAlloc(IndicatorNameDef);
355 def->common.stmtType = StmtIndicatorNameDef;
356 def->common.next = NULL;
357 def->merge = MergeDefault;
360 def->virtual = virtual;
364 FATAL("Couldn't allocate indicator index definition in parser\n");
371 ActionCreate(xkb_atom_t name, ExprDef * args)
375 act = uTypedAlloc(ExprDef);
378 act->common.stmtType = StmtExpr;
379 act->common.next = NULL;
380 act->op = ExprActionDecl;
381 act->value.action.name = name;
382 act->value.action.args = args;
385 FATAL("Couldn't allocate ActionDef in parser\n");
390 ResizeKeysymList(ExprDef *list, unsigned int extra)
394 if (list->value.list.nSyms + extra > list->value.list.szSyms)
396 list->value.list.szSyms *= 2;
397 list->value.list.szSyms += extra;
398 if (list->value.list.szSyms == 1)
399 list->value.list.szSyms = 4;
400 list->value.list.syms = uTypedRecalloc(list->value.list.syms,
401 list->value.list.nSyms,
402 list->value.list.szSyms,
404 if (list->value.list.syms == NULL)
406 FATAL("Couldn't resize list of symbols for append\n");
410 if (list->value.list.nLevels >= list->value.list.szLevels)
412 list->value.list.szLevels *= 2;
413 if (list->value.list.szLevels == 0)
414 list->value.list.szLevels = 4;
415 list->value.list.symsMapIndex =
416 uTypedRecalloc(list->value.list.symsMapIndex,
417 list->value.list.nLevels,
418 list->value.list.szLevels,
420 if (list->value.list.symsMapIndex == NULL)
422 FATAL("Couldn't resize keysym index map for append\n");
425 list->value.list.symsNumEntries =
426 uTypedRecalloc(list->value.list.symsNumEntries,
427 list->value.list.nLevels,
428 list->value.list.szLevels,
430 if (list->value.list.symsNumEntries == NULL)
432 FATAL("Couldn't resize num keysym entries for append\n");
435 for (i = list->value.list.nLevels; i < list->value.list.szLevels; i++)
436 list->value.list.symsMapIndex[i] = -1;
443 CreateKeysymList(char *sym)
447 def = ExprCreate(ExprKeysymList, TypeSymbols);
450 FATAL("Couldn't allocate expression for keysym list in parser\n");
454 def->value.list.nSyms = 0;
455 def->value.list.szSyms = 0;
456 def->value.list.nLevels = 0;
457 def->value.list.szLevels = 0;
458 def->value.list.syms = NULL;
459 def->value.list.symsMapIndex = NULL;
460 def->value.list.symsNumEntries = NULL;
462 if (!ResizeKeysymList(def, 1))
464 FreeStmt(&def->common);
468 def->value.list.syms[0] = sym;
469 def->value.list.symsMapIndex[0] = 0;
470 def->value.list.symsNumEntries[0] = 1;
471 def->value.list.nLevels = 1;
472 def->value.list.nSyms = 1;
478 CreateMultiKeysymList(ExprDef *list)
482 for (i = 1; i < list->value.list.szLevels; i++)
484 list->value.list.symsMapIndex[i] = -1;
485 list->value.list.symsNumEntries[i] = 0;
487 list->value.list.symsMapIndex[0] = 0;
488 list->value.list.symsNumEntries[0] = list->value.list.nLevels;
489 list->value.list.nLevels = 1;
495 AppendKeysymList(ExprDef * list, char *sym)
497 if (!ResizeKeysymList(list, 1))
500 list->value.list.symsMapIndex[list->value.list.nLevels] =
501 list->value.list.nSyms;
502 list->value.list.symsNumEntries[list->value.list.nLevels] = 1;
503 list->value.list.syms[list->value.list.nSyms++] = sym;
504 list->value.list.nLevels++;
509 AppendMultiKeysymList(ExprDef * list, ExprDef * append)
513 if (!ResizeKeysymList(list, append->value.list.nSyms))
516 list->value.list.symsMapIndex[list->value.list.nLevels] =
517 list->value.list.nSyms;
518 list->value.list.symsNumEntries[list->value.list.nLevels] =
519 append->value.list.nSyms;
520 for (i = 0; i < append->value.list.nSyms; i++) {
521 list->value.list.syms[list->value.list.nSyms++] =
522 append->value.list.syms[i];
523 append->value.list.syms[i] = NULL;
525 list->value.list.nLevels++;
527 FreeStmt(&append->common);
533 LookupKeysym(const char *str, xkb_keysym_t *sym_rtrn)
537 if ((!str) || (strcasecmp(str, "any") == 0) ||
538 (strcasecmp(str, "nosymbol") == 0))
540 *sym_rtrn = XKB_KEYSYM_NO_SYMBOL;
543 else if ((strcasecmp(str, "none") == 0) ||
544 (strcasecmp(str, "voidsymbol") == 0))
546 *sym_rtrn = XK_VoidSymbol;
549 sym = xkb_string_to_keysym(str);
550 if (sym != XKB_KEYSYM_NO_SYMBOL)
559 FreeInclude(IncludeStmt *incl);
562 IncludeCreate(char *str, unsigned merge)
564 IncludeStmt *incl, *first;
565 char *file, *map, *stmt, *tmp, *extra_data;
573 stmt = uDupString(str);
574 while ((tmp) && (*tmp))
576 if (XkbParseIncludeMap(&tmp, &file, &map, &nextop, &extra_data))
578 if ((file == NULL) && (map == NULL))
585 first = incl = uTypedAlloc(IncludeStmt);
588 incl->next = uTypedAlloc(IncludeStmt);
593 incl->common.stmtType = StmtInclude;
594 incl->common.next = NULL;
599 incl->modifier = extra_data;
605 WSGO("Allocation failure in IncludeCreate\n");
606 ACTION("Using only part of the include\n");
610 merge = MergeAugment;
612 merge = MergeOverride;
626 ERROR("Illegal include statement \"%s\"\n", stmt);
634 CheckDefaultMap(XkbFile * maps, const char *fileName)
639 for (tmp = maps, dflt = NULL; tmp != NULL;
640 tmp = (XkbFile *) tmp->common.next)
642 if (tmp->flags & XkbLC_Default)
648 if (warningLevel > 2)
650 WARN("Multiple default components in %s\n",
651 (fileName ? fileName : "(unknown)"));
652 ACTION("Using %s, ignoring %s\n",
653 (dflt->name ? dflt->name : "(first)"),
654 (tmp->name ? tmp->name : "(subsequent)"));
656 tmp->flags &= (~XkbLC_Default);
663 * All latin-1 alphanumerics, plus parens, slash, minus, underscore and
666 static const unsigned char componentSpecLegal[] = {
667 0x00, 0x00, 0x00, 0x00, 0x00, 0xa7, 0xff, 0x83,
668 0xfe, 0xff, 0xff, 0x87, 0xfe, 0xff, 0xff, 0x07,
669 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
670 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff
674 EnsureSafeMapName(char *name)
679 while (*name!='\0') {
680 if ((componentSpecLegal[(*name) / 8] & (1 << ((*name) % 8))) == 0)
687 CreateXKBFile(int type, char *name, ParseCommon * defs, unsigned flags)
692 file = uTypedAlloc(XkbFile);
695 EnsureSafeMapName(name);
696 memset(file, 0, sizeof(XkbFile));
698 file->topName = uDupString(name);
708 StmtSetMerge(ParseCommon * stmt, unsigned merge, struct YYLTYPE *loc, void *scanner)
710 if ((merge == MergeAltForm) && (stmt->stmtType != StmtKeycodeDef))
712 yyerror(loc, scanner, "illegal use of 'alternate' merge mode");
713 merge = MergeDefault;
719 FreeExpr(ExprDef *expr)
733 FreeStmt(&expr->value.child->common);
740 FreeStmt(&expr->value.binary.left->common);
741 FreeStmt(&expr->value.binary.right->common);
744 FreeStmt(&expr->value.action.args->common);
747 FreeStmt(&expr->value.array.entry->common);
750 for (i = 0; i < expr->value.list.nSyms; i++)
751 free(expr->value.list.syms[i]);
752 free(expr->value.list.syms);
753 free(expr->value.list.symsMapIndex);
754 free(expr->value.list.symsNumEntries);
762 FreeInclude(IncludeStmt *incl)
772 free(incl->modifier);
782 FreeStmt(ParseCommon *stmt)
792 switch (stmt->stmtType)
795 FreeInclude((IncludeStmt *)stmt);
796 /* stmt is already free'd here. */
803 FreeStmt(&u.var->name->common);
804 FreeStmt(&u.var->value->common);
807 FreeStmt(&u.keyType->body->common);
811 FreeStmt(&u.interp->match->common);
812 FreeStmt(&u.interp->def->common);
815 FreeStmt(&u.vmod->value->common);
818 FreeStmt(&u.syms->symbols->common);
821 FreeStmt(&u.modMask->keys->common);
823 case StmtGroupCompatDef:
824 FreeStmt(&u.groupCompat->def->common);
826 case StmtIndicatorMapDef:
827 FreeStmt(&u.ledMap->body->common);
829 case StmtIndicatorNameDef:
830 FreeStmt(&u.ledName->name->common);
842 FreeXKBFile(XkbFile *file)
848 next = (XkbFile *)file->common.next;
853 case XkmSemanticsFile:
855 FreeXKBFile((XkbFile *)file->defs);
858 case XkmCompatMapIndex:
859 case XkmSymbolsIndex:
860 case XkmKeyNamesIndex:
861 case XkmGeometryIndex:
862 FreeStmt(file->defs);