← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/vnc4/gutsy

« back to all changes in this revision

Viewing changes to unix/xc/programs/xkbcomp/parseutils.c

  • Committer: Bazaar Package Importer
  • Author(s): Ola Lundqvist
  • Date: 2006-05-15 20:35:17 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20060515203517-l4lre1ku942mn26k
Tags: 4.1.1+X4.3.0-10
* Correction of critical security issue. Thanks to Martin Kogler
  <e9925248@student.tuwien.ac.at> that informed me about the issue,
  and provided the patch.
  This flaw was originally found by Steve Wiseman of intelliadmin.com.
* Applied patch from Javier Kohen <jkohen@users.sourceforge.net> that
  inform the user that only 8 first characters of the password will
  actually be used when typing more than 8 characters, closes:
  #355619.

Show diffs side-by-side

added added

removed removed

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