Debian Codegraph @

nx-X11/lib/src/xkb/XKBGAlloc.c

raw
1 /************************************************************
2 Copyright (c) 1993 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 #ifdef HAVE_CONFIG_H
28 #include <config.h>
29 #endif
30
31
32 #include <stdio.h>
33 #include "Xlibint.h"
34 #include "XKBlibint.h"
35 #include <nx-X11/extensions/XKBgeom.h>
36 #include <nx-X11/extensions/XKBproto.h>
37
38 /***====================================================================***/
39
40 static void
41 _XkbFreeGeomLeafElems(Bool freeAll,
42 int first,
43 int count,
44 unsigned short *num_inout,
45 unsigned short *sz_inout,
46 char **elems,
47 unsigned int elem_sz)
48 {
49 if ((freeAll) || (*elems == NULL)) {
50 *num_inout = *sz_inout = 0;
51 if (*elems != NULL) {
52 _XkbFree(*elems);
53 *elems = NULL;
54 }
55 return;
56 }
57
58 if ((first >= (*num_inout)) || (first < 0) || (count < 1))
59 return;
60
61 if (first + count >= (*num_inout)) {
62 /* truncating the array is easy */
63 (*num_inout) = first;
64 }
65 else {
66 char *ptr;
67 int extra;
68
69 ptr = *elems;
70 extra = ((*num_inout) - (first + count)) * elem_sz;
71 if (extra > 0)
72 memmove(&ptr[(unsigned) first * elem_sz], &ptr[(unsigned)(first + count) * elem_sz],
73 (size_t) extra);
74 (*num_inout) -= count;
75 }
76 return;
77 }
78
79 typedef void (*ContentsClearFunc) (
80 char * /* priv */
81 );
82
83 static void
84 _XkbFreeGeomNonLeafElems(Bool freeAll,
85 int first,
86 int count,
87 unsigned short *num_inout,
88 unsigned short *sz_inout,
89 char **elems,
90 unsigned int elem_sz,
91 ContentsClearFunc freeFunc)
92 {
93 register int i;
94 register char *ptr;
95
96 if (freeAll) {
97 first = 0;
98 count = (*num_inout);
99 }
100 else if ((first >= (*num_inout)) || (first < 0) || (count < 1))
101 return;
102 else if (first + count > (*num_inout))
103 count = (*num_inout) - first;
104 if (*elems == NULL)
105 return;
106
107 if (freeFunc) {
108 ptr = *elems;
109 ptr += first * elem_sz;
110 for (i = 0; i < count; i++) {
111 (*freeFunc) (ptr);
112 ptr += elem_sz;
113 }
114 }
115 if (freeAll) {
116 (*num_inout) = (*sz_inout) = 0;
117 if (*elems) {
118 _XkbFree(*elems);
119 *elems = NULL;
120 }
121 }
122 else if (first + count >= (*num_inout))
123 *num_inout = first;
124 else {
125 i = ((*num_inout) - (first + count)) * elem_sz;
126 ptr = *elems;
127 memmove(&ptr[(unsigned) first * elem_sz], &ptr[(unsigned)(first + count) * elem_sz], (size_t) i);
128 (*num_inout) -= count;
129 }
130 return;
131 }
132
133 /***====================================================================***/
134
135 static void
136 _XkbClearProperty(char *prop_in)
137 {
138 XkbPropertyPtr prop = (XkbPropertyPtr) prop_in;
139
140 if (prop->name) {
141 _XkbFree(prop->name);
142 prop->name = NULL;
143 }
144 if (prop->value) {
145 _XkbFree(prop->value);
146 prop->value = NULL;
147 }
148 return;
149 }
150
151 void
152 XkbFreeGeomProperties(XkbGeometryPtr geom, int first, int count, Bool freeAll)
153 {
154 _XkbFreeGeomNonLeafElems(freeAll, first, count,
155 &geom->num_properties, &geom->sz_properties,
156 (char **) &geom->properties,
157 sizeof(XkbPropertyRec), _XkbClearProperty);
158 return;
159 }
160
161 /***====================================================================***/
162
163 void
164 XkbFreeGeomKeyAliases(XkbGeometryPtr geom, int first, int count, Bool freeAll)
165 {
166 _XkbFreeGeomLeafElems(freeAll, first, count,
167 &geom->num_key_aliases, &geom->sz_key_aliases,
168 (char **) &geom->key_aliases,
169 sizeof(XkbKeyAliasRec));
170 return;
171 }
172
173 /***====================================================================***/
174
175 static void
176 _XkbClearColor(char *color_in)
177 {
178 XkbColorPtr color = (XkbColorPtr) color_in;
179
180 _XkbFree(color->spec);
181 return;
182 }
183
184 void
185 XkbFreeGeomColors(XkbGeometryPtr geom, int first, int count, Bool freeAll)
186 {
187 _XkbFreeGeomNonLeafElems(freeAll, first, count,
188 &geom->num_colors, &geom->sz_colors,
189 (char **) &geom->colors,
190 sizeof(XkbColorRec), _XkbClearColor);
191 return;
192 }
193
194 /***====================================================================***/
195
196 void
197 XkbFreeGeomPoints(XkbOutlinePtr outline, int first, int count, Bool freeAll)
198 {
199 _XkbFreeGeomLeafElems(freeAll, first, count,
200 &outline->num_points, &outline->sz_points,
201 (char **) &outline->points,
202 sizeof(XkbPointRec));
203 return;
204 }
205
206 /***====================================================================***/
207
208 static void
209 _XkbClearOutline(char *outline_in)
210 {
211 XkbOutlinePtr outline = (XkbOutlinePtr) outline_in;
212
213 if (outline->points != NULL)
214 XkbFreeGeomPoints(outline, 0, outline->num_points, True);
215 return;
216 }
217
218 void
219 XkbFreeGeomOutlines(XkbShapePtr shape, int first, int count, Bool freeAll)
220 {
221 _XkbFreeGeomNonLeafElems(freeAll, first, count,
222 &shape->num_outlines, &shape->sz_outlines,
223 (char **) &shape->outlines,
224 sizeof(XkbOutlineRec), _XkbClearOutline);
225
226 return;
227 }
228
229 /***====================================================================***/
230
231 static void
232 _XkbClearShape(char *shape_in)
233 {
234 XkbShapePtr shape = (XkbShapePtr) shape_in;
235
236 if (shape->outlines)
237 XkbFreeGeomOutlines(shape, 0, shape->num_outlines, True);
238 return;
239 }
240
241 void
242 XkbFreeGeomShapes(XkbGeometryPtr geom, int first, int count, Bool freeAll)
243 {
244 _XkbFreeGeomNonLeafElems(freeAll, first, count,
245 &geom->num_shapes, &geom->sz_shapes,
246 (char **) &geom->shapes,
247 sizeof(XkbShapeRec), _XkbClearShape);
248 return;
249 }
250
251 /***====================================================================***/
252
253 void
254 XkbFreeGeomOverlayKeys(XkbOverlayRowPtr row, int first, int count, Bool freeAll)
255 {
256 _XkbFreeGeomLeafElems(freeAll, first, count,
257 &row->num_keys, &row->sz_keys,
258 (char **) &row->keys,
259 sizeof(XkbOverlayKeyRec));
260 return;
261 }
262
263 /***====================================================================***/
264
265 static void
266 _XkbClearOverlayRow(char *row_in)
267 {
268 XkbOverlayRowPtr row = (XkbOverlayRowPtr) row_in;
269
270 if (row->keys != NULL)
271 XkbFreeGeomOverlayKeys(row, 0, row->num_keys, True);
272 return;
273 }
274
275 void
276 XkbFreeGeomOverlayRows(XkbOverlayPtr overlay, int first, int count,
277 Bool freeAll)
278 {
279 _XkbFreeGeomNonLeafElems(freeAll, first, count,
280 &overlay->num_rows, &overlay->sz_rows,
281 (char **) &overlay->rows,
282 sizeof(XkbOverlayRowRec), _XkbClearOverlayRow);
283 return;
284 }
285
286 /***====================================================================***/
287
288 static void
289 _XkbClearOverlay(char *overlay_in)
290 {
291 XkbOverlayPtr overlay = (XkbOverlayPtr) overlay_in;
292
293 if (overlay->rows != NULL)
294 XkbFreeGeomOverlayRows(overlay, 0, overlay->num_rows, True);
295 return;
296 }
297
298 void
299 XkbFreeGeomOverlays(XkbSectionPtr section, int first, int count, Bool freeAll)
300 {
301 _XkbFreeGeomNonLeafElems(freeAll, first, count,
302 &section->num_overlays, &section->sz_overlays,
303 (char **) &section->overlays,
304 sizeof(XkbOverlayRec), _XkbClearOverlay);
305 return;
306 }
307
308 /***====================================================================***/
309
310 void
311 XkbFreeGeomKeys(XkbRowPtr row, int first, int count, Bool freeAll)
312 {
313 _XkbFreeGeomLeafElems(freeAll, first, count,
314 &row->num_keys, &row->sz_keys,
315 (char **) &row->keys,
316 sizeof(XkbKeyRec));
317 return;
318 }
319
320 /***====================================================================***/
321
322 static void
323 _XkbClearRow(char *row_in)
324 {
325 XkbRowPtr row = (XkbRowPtr) row_in;
326
327 if (row->keys != NULL)
328 XkbFreeGeomKeys(row, 0, row->num_keys, True);
329 return;
330 }
331
332 void
333 XkbFreeGeomRows(XkbSectionPtr section, int first, int count, Bool freeAll)
334 {
335 _XkbFreeGeomNonLeafElems(freeAll, first, count,
336 &section->num_rows, &section->sz_rows,
337 (char **) &section->rows,
338 sizeof(XkbRowRec), _XkbClearRow);
339 }
340
341 /***====================================================================***/
342
343 static void
344 _XkbClearSection(char *section_in)
345 {
346 XkbSectionPtr section = (XkbSectionPtr) section_in;
347
348 if (section->rows != NULL)
349 XkbFreeGeomRows(section, 0, section->num_rows, True);
350 if (section->doodads != NULL) {
351 XkbFreeGeomDoodads(section->doodads, section->num_doodads, True);
352 section->doodads = NULL;
353 }
354 return;
355 }
356
357 void
358 XkbFreeGeomSections(XkbGeometryPtr geom, int first, int count, Bool freeAll)
359 {
360 _XkbFreeGeomNonLeafElems(freeAll, first, count,
361 &geom->num_sections, &geom->sz_sections,
362 (char **) &geom->sections,
363 sizeof(XkbSectionRec), _XkbClearSection);
364 return;
365 }
366
367 /***====================================================================***/
368
369 static void
370 _XkbClearDoodad(char *doodad_in)
371 {
372 XkbDoodadPtr doodad = (XkbDoodadPtr) doodad_in;
373
374 switch (doodad->any.type) {
375 case XkbTextDoodad:
376 {
377 if (doodad->text.text != NULL) {
378 _XkbFree(doodad->text.text);
379 doodad->text.text = NULL;
380 }
381 if (doodad->text.font != NULL) {
382 _XkbFree(doodad->text.font);
383 doodad->text.font = NULL;
384 }
385 }
386 break;
387 case XkbLogoDoodad:
388 {
389 if (doodad->logo.logo_name != NULL) {
390 _XkbFree(doodad->logo.logo_name);
391 doodad->logo.logo_name = NULL;
392 }
393 }
394 break;
395 }
396 return;
397 }
398
399 void
400 XkbFreeGeomDoodads(XkbDoodadPtr doodads, int nDoodads, Bool freeAll)
401 {
402 register int i;
403 register XkbDoodadPtr doodad;
404
405 if (doodads) {
406 for (i = 0, doodad = doodads; i < nDoodads; i++, doodad++) {
407 _XkbClearDoodad((char *) doodad);
408 }
409 if (freeAll)
410 _XkbFree(doodads);
411 }
412 return;
413 }
414
415 void
416 XkbFreeGeometry(XkbGeometryPtr geom, unsigned which, Bool freeMap)
417 {
418 if (geom == NULL)
419 return;
420 if (freeMap)
421 which = XkbGeomAllMask;
422 if ((which & XkbGeomPropertiesMask) && (geom->properties != NULL))
423 XkbFreeGeomProperties(geom, 0, geom->num_properties, True);
424 if ((which & XkbGeomColorsMask) && (geom->colors != NULL))
425 XkbFreeGeomColors(geom, 0, geom->num_colors, True);
426 if ((which & XkbGeomShapesMask) && (geom->shapes != NULL))
427 XkbFreeGeomShapes(geom, 0, geom->num_shapes, True);
428 if ((which & XkbGeomSectionsMask) && (geom->sections != NULL))
429 XkbFreeGeomSections(geom, 0, geom->num_sections, True);
430 if ((which & XkbGeomDoodadsMask) && (geom->doodads != NULL)) {
431 XkbFreeGeomDoodads(geom->doodads, geom->num_doodads, True);
432 geom->doodads = NULL;
433 geom->num_doodads = geom->sz_doodads = 0;
434 }
435 if ((which & XkbGeomKeyAliasesMask) && (geom->key_aliases != NULL))
436 XkbFreeGeomKeyAliases(geom, 0, geom->num_key_aliases, True);
437 if (freeMap) {
438 if (geom->label_font != NULL) {
439 _XkbFree(geom->label_font);
440 geom->label_font = NULL;
441 }
442 _XkbFree(geom);
443 }
444 return;
445 }
446
447 /***====================================================================***/
448
449 static Status
450 _XkbGeomAlloc(XPointer *old,
451 unsigned short *num,
452 unsigned short *total,
453 int num_new,
454 size_t sz_elem)
455 {
456 if (num_new < 1)
457 return Success;
458 if ((*old) == NULL)
459 *num = *total = 0;
460
461 if ((*num) + num_new <= (*total))
462 return Success;
463
464 *total = (*num) + num_new;
465 if ((*old) != NULL)
466 (*old) = (XPointer) _XkbRealloc((*old), (*total) * sz_elem);
467 else
468 (*old) = (XPointer) _XkbCalloc((*total), sz_elem);
469 if ((*old) == NULL) {
470 *total = *num = 0;
471 return BadAlloc;
472 }
473
474 if (*num > 0) {
475 char *tmp = (char *) (*old);
476 bzero(&tmp[sz_elem * (*num)], (num_new * sz_elem));
477 }
478 return Success;
479 }
480
481 #define _XkbAllocProps(g, n) _XkbGeomAlloc((XPointer *)&(g)->properties, \
482 &(g)->num_properties, &(g)->sz_properties, \
483 (n), sizeof(XkbPropertyRec))
484 #define _XkbAllocColors(g, n) _XkbGeomAlloc((XPointer *)&(g)->colors, \
485 &(g)->num_colors, &(g)->sz_colors, \
486 (n), sizeof(XkbColorRec))
487 #define _XkbAllocShapes(g, n) _XkbGeomAlloc((XPointer *)&(g)->shapes, \
488 &(g)->num_shapes, &(g)->sz_shapes, \
489 (n), sizeof(XkbShapeRec))
490 #define _XkbAllocSections(g, n) _XkbGeomAlloc((XPointer *)&(g)->sections, \
491 &(g)->num_sections, &(g)->sz_sections, \
492 (n), sizeof(XkbSectionRec))
493 #define _XkbAllocDoodads(g, n) _XkbGeomAlloc((XPointer *)&(g)->doodads, \
494 &(g)->num_doodads, &(g)->sz_doodads, \
495 (n), sizeof(XkbDoodadRec))
496 #define _XkbAllocKeyAliases(g, n) _XkbGeomAlloc((XPointer *)&(g)->key_aliases, \
497 &(g)->num_key_aliases, &(g)->sz_key_aliases, \
498 (n), sizeof(XkbKeyAliasRec))
499
500 #define _XkbAllocOutlines(s, n) _XkbGeomAlloc((XPointer *)&(s)->outlines, \
501 &(s)->num_outlines, &(s)->sz_outlines, \
502 (n), sizeof(XkbOutlineRec))
503 #define _XkbAllocRows(s, n) _XkbGeomAlloc((XPointer *)&(s)->rows, \
504 &(s)->num_rows, &(s)->sz_rows, \
505 (n), sizeof(XkbRowRec))
506 #define _XkbAllocPoints(o, n) _XkbGeomAlloc((XPointer *)&(o)->points, \
507 &(o)->num_points, &(o)->sz_points, \
508 (n), sizeof(XkbPointRec))
509 #define _XkbAllocKeys(r, n) _XkbGeomAlloc((XPointer *)&(r)->keys, \
510 &(r)->num_keys, &(r)->sz_keys, \
511 (n), sizeof(XkbKeyRec))
512 #define _XkbAllocOverlays(s, n) _XkbGeomAlloc((XPointer *)&(s)->overlays, \
513 &(s)->num_overlays, &(s)->sz_overlays, \
514 (n), sizeof(XkbOverlayRec))
515 #define _XkbAllocOverlayRows(o, n) _XkbGeomAlloc((XPointer *)&(o)->rows, \
516 &(o)->num_rows, &(o)->sz_rows, \
517 (n), sizeof(XkbOverlayRowRec))
518 #define _XkbAllocOverlayKeys(r, n) _XkbGeomAlloc((XPointer *)&(r)->keys, \
519 &(r)->num_keys, &(r)->sz_keys, \
520 (n), sizeof(XkbOverlayKeyRec))
521
522 Status
523 XkbAllocGeomProps(XkbGeometryPtr geom, int nProps)
524 {
525 return _XkbAllocProps(geom, nProps);
526 }
527
528 Status
529 XkbAllocGeomColors(XkbGeometryPtr geom, int nColors)
530 {
531 return _XkbAllocColors(geom, nColors);
532 }
533
534 Status
535 XkbAllocGeomKeyAliases(XkbGeometryPtr geom, int nKeyAliases)
536 {
537 return _XkbAllocKeyAliases(geom, nKeyAliases);
538 }
539
540 Status
541 XkbAllocGeomShapes(XkbGeometryPtr geom, int nShapes)
542 {
543 return _XkbAllocShapes(geom, nShapes);
544 }
545
546 Status
547 XkbAllocGeomSections(XkbGeometryPtr geom, int nSections)
548 {
549 return _XkbAllocSections(geom, nSections);
550 }
551
552 Status
553 XkbAllocGeomOverlays(XkbSectionPtr section, int nOverlays)
554 {
555 return _XkbAllocOverlays(section, nOverlays);
556 }
557
558 Status
559 XkbAllocGeomOverlayRows(XkbOverlayPtr overlay, int nRows)
560 {
561 return _XkbAllocOverlayRows(overlay, nRows);
562 }
563
564 Status
565 XkbAllocGeomOverlayKeys(XkbOverlayRowPtr row, int nKeys)
566 {
567 return _XkbAllocOverlayKeys(row, nKeys);
568 }
569
570 Status
571 XkbAllocGeomDoodads(XkbGeometryPtr geom, int nDoodads)
572 {
573 return _XkbAllocDoodads(geom, nDoodads);
574 }
575
576 Status
577 XkbAllocGeomSectionDoodads(XkbSectionPtr section, int nDoodads)
578 {
579 return _XkbAllocDoodads(section, nDoodads);
580 }
581
582 Status
583 XkbAllocGeomOutlines(XkbShapePtr shape, int nOL)
584 {
585 return _XkbAllocOutlines(shape, nOL);
586 }
587
588 Status
589 XkbAllocGeomRows(XkbSectionPtr section, int nRows)
590 {
591 return _XkbAllocRows(section, nRows);
592 }
593
594 Status
595 XkbAllocGeomPoints(XkbOutlinePtr ol, int nPts)
596 {
597 return _XkbAllocPoints(ol, nPts);
598 }
599
600 Status
601 XkbAllocGeomKeys(XkbRowPtr row, int nKeys)
602 {
603 return _XkbAllocKeys(row, nKeys);
604 }
605
606 Status
607 XkbAllocGeometry(XkbDescPtr xkb, XkbGeometrySizesPtr sizes)
608 {
609 XkbGeometryPtr geom;
610 Status rtrn;
611
612 if (xkb->geom == NULL) {
613 xkb->geom = _XkbTypedCalloc(1, XkbGeometryRec);
614 if (!xkb->geom)
615 return BadAlloc;
616 }
617 geom = xkb->geom;
618 if ((sizes->which & XkbGeomPropertiesMask) &&
619 ((rtrn = _XkbAllocProps(geom, sizes->num_properties)) != Success)) {
620 goto BAIL;
621 }
622 if ((sizes->which & XkbGeomColorsMask) &&
623 ((rtrn = _XkbAllocColors(geom, sizes->num_colors)) != Success)) {
624 goto BAIL;
625 }
626 if ((sizes->which & XkbGeomShapesMask) &&
627 ((rtrn = _XkbAllocShapes(geom, sizes->num_shapes)) != Success)) {
628 goto BAIL;
629 }
630 if ((sizes->which & XkbGeomSectionsMask) &&
631 ((rtrn = _XkbAllocSections(geom, sizes->num_sections)) != Success)) {
632 goto BAIL;
633 }
634 if ((sizes->which & XkbGeomDoodadsMask) &&
635 ((rtrn = _XkbAllocDoodads(geom, sizes->num_doodads)) != Success)) {
636 goto BAIL;
637 }
638 if ((sizes->which & XkbGeomKeyAliasesMask) &&
639 ((rtrn = _XkbAllocKeyAliases(geom, sizes->num_key_aliases))
640 != Success)) {
641 goto BAIL;
642 }
643 return Success;
644 BAIL:
645 XkbFreeGeometry(geom, XkbGeomAllMask, True);
646 xkb->geom = NULL;
647 return rtrn;
648 }
649
650 /***====================================================================***/
651
652 XkbPropertyPtr
653 XkbAddGeomProperty(XkbGeometryPtr geom, char *name, char *value)
654 {
655 register int i;
656 register XkbPropertyPtr prop;
657
658 if ((!geom) || (!name) || (!value))
659 return NULL;
660 for (i = 0, prop = geom->properties; i < geom->num_properties; i++, prop++) {
661 if ((prop->name) && (strcmp(name, prop->name) == 0)) {
662 _XkbFree(prop->value);
663 prop->value = strdup(value);
664 return prop;
665 }
666 }
667 if ((geom->num_properties >= geom->sz_properties) &&
668 (_XkbAllocProps(geom, 1) != Success)) {
669 return NULL;
670 }
671 prop = &geom->properties[geom->num_properties];
672 prop->name = strdup(name);
673 if (!prop->name)
674 return NULL;
675 prop->value = strdup(value);
676 if (!prop->value) {
677 _XkbFree(prop->name);
678 prop->name = NULL;
679 return NULL;
680 }
681 geom->num_properties++;
682 return prop;
683 }
684
685 XkbKeyAliasPtr
686 XkbAddGeomKeyAlias(XkbGeometryPtr geom, char *aliasStr, char *realStr)
687 {
688 register int i;
689 register XkbKeyAliasPtr alias;
690
691 if ((!geom) || (!aliasStr) || (!realStr) || (!aliasStr[0]) || (!realStr[0]))
692 return NULL;
693 for (i = 0, alias = geom->key_aliases; i < geom->num_key_aliases;
694 i++, alias++) {
695 if (strncmp(alias->alias, aliasStr, XkbKeyNameLength) == 0) {
696 bzero(alias->real, XkbKeyNameLength);
697 strncpy(alias->real, realStr, XkbKeyNameLength);
698 return alias;
699 }
700 }
701 if ((geom->num_key_aliases >= geom->sz_key_aliases) &&
702 (_XkbAllocKeyAliases(geom, 1) != Success)) {
703 return NULL;
704 }
705 alias = &geom->key_aliases[geom->num_key_aliases];
706 bzero(alias, sizeof(XkbKeyAliasRec));
707 strncpy(alias->alias, aliasStr, XkbKeyNameLength);
708 strncpy(alias->real, realStr, XkbKeyNameLength);
709 geom->num_key_aliases++;
710 return alias;
711 }
712
713 XkbColorPtr
714 XkbAddGeomColor(XkbGeometryPtr geom, char *spec, unsigned int pixel)
715 {
716 register int i;
717 register XkbColorPtr color;
718
719 if ((!geom) || (!spec))
720 return NULL;
721 for (i = 0, color = geom->colors; i < geom->num_colors; i++, color++) {
722 if ((color->spec) && (strcmp(color->spec, spec) == 0)) {
723 color->pixel = pixel;
724 return color;
725 }
726 }
727 if ((geom->num_colors >= geom->sz_colors) &&
728 (_XkbAllocColors(geom, 1) != Success)) {
729 return NULL;
730 }
731 color = &geom->colors[geom->num_colors];
732 color->pixel = pixel;
733 color->spec = strdup(spec);
734 if (!color->spec)
735 return NULL;
736 geom->num_colors++;
737 return color;
738 }
739
740 XkbOutlinePtr
741 XkbAddGeomOutline(XkbShapePtr shape, int sz_points)
742 {
743 XkbOutlinePtr outline;
744
745 if ((!shape) || (sz_points < 0))
746 return NULL;
747 if ((shape->num_outlines >= shape->sz_outlines) &&
748 (_XkbAllocOutlines(shape, 1) != Success)) {
749 return NULL;
750 }
751 outline = &shape->outlines[shape->num_outlines];
752 bzero(outline, sizeof(XkbOutlineRec));
753 if ((sz_points > 0) && (_XkbAllocPoints(outline, sz_points) != Success))
754 return NULL;
755 shape->num_outlines++;
756 return outline;
757 }
758
759 XkbShapePtr
760 XkbAddGeomShape(XkbGeometryPtr geom, Atom name, int sz_outlines)
761 {
762 XkbShapePtr shape;
763 register int i;
764
765 if ((!geom) || (!name) || (sz_outlines < 0))
766 return NULL;
767 if (geom->num_shapes > 0) {
768 for (shape = geom->shapes, i = 0; i < geom->num_shapes; i++, shape++) {
769 if (name == shape->name)
770 return shape;
771 }
772 }
773 if ((geom->num_shapes >= geom->sz_shapes) &&
774 (_XkbAllocShapes(geom, 1) != Success))
775 return NULL;
776 shape = &geom->shapes[geom->num_shapes];
777 bzero(shape, sizeof(XkbShapeRec));
778 if ((sz_outlines > 0) && (_XkbAllocOutlines(shape, sz_outlines) != Success))
779 return NULL;
780 shape->name = name;
781 shape->primary = shape->approx = NULL;
782 geom->num_shapes++;
783 return shape;
784 }
785
786 XkbKeyPtr
787 XkbAddGeomKey(XkbRowPtr row)
788 {
789 XkbKeyPtr key;
790
791 if (!row)
792 return NULL;
793 if ((row->num_keys >= row->sz_keys) && (_XkbAllocKeys(row, 1) != Success))
794 return NULL;
795 key = &row->keys[row->num_keys++];
796 bzero(key, sizeof(XkbKeyRec));
797 return key;
798 }
799
800 XkbRowPtr
801 XkbAddGeomRow(XkbSectionPtr section, int sz_keys)
802 {
803 XkbRowPtr row;
804
805 if ((!section) || (sz_keys < 0))
806 return NULL;
807 if ((section->num_rows >= section->sz_rows) &&
808 (_XkbAllocRows(section, 1) != Success))
809 return NULL;
810 row = &section->rows[section->num_rows];
811 bzero(row, sizeof(XkbRowRec));
812 if ((sz_keys > 0) && (_XkbAllocKeys(row, sz_keys) != Success))
813 return NULL;
814 section->num_rows++;
815 return row;
816 }
817
818 XkbSectionPtr
819 XkbAddGeomSection(XkbGeometryPtr geom,
820 Atom name,
821 int sz_rows,
822 int sz_doodads,
823 int sz_over)
824 {
825 register int i;
826 XkbSectionPtr section;
827
828 if ((!geom) || (name == None) || (sz_rows < 0))
829 return NULL;
830 for (i = 0, section = geom->sections; i < geom->num_sections;
831 i++, section++) {
832 if (section->name != name)
833 continue;
834 if (((sz_rows > 0) && (_XkbAllocRows(section, sz_rows) != Success)) ||
835 ((sz_doodads > 0) &&
836 (_XkbAllocDoodads(section, sz_doodads) != Success)) ||
837 ((sz_over > 0) && (_XkbAllocOverlays(section, sz_over) != Success)))
838 return NULL;
839 return section;
840 }
841 if ((geom->num_sections >= geom->sz_sections) &&
842 (_XkbAllocSections(geom, 1) != Success))
843 return NULL;
844 section = &geom->sections[geom->num_sections];
845 if ((sz_rows > 0) && (_XkbAllocRows(section, sz_rows) != Success))
846 return NULL;
847 if ((sz_doodads > 0) && (_XkbAllocDoodads(section, sz_doodads) != Success)) {
848 if (section->rows) {
849 _XkbFree(section->rows);
850 section->rows = NULL;
851 section->sz_rows = section->num_rows = 0;
852 }
853 return NULL;
854 }
855 section->name = name;
856 geom->num_sections++;
857 return section;
858 }
859
860 XkbDoodadPtr
861 XkbAddGeomDoodad(XkbGeometryPtr geom, XkbSectionPtr section, Atom name)
862 {
863 XkbDoodadPtr old, doodad;
864 register int i, nDoodads;
865
866 if ((!geom) || (name == None))
867 return NULL;
868 if ((section != NULL) && (section->num_doodads > 0)) {
869 old = section->doodads;
870 nDoodads = section->num_doodads;
871 }
872 else {
873 old = geom->doodads;
874 nDoodads = geom->num_doodads;
875 }
876 for (i = 0, doodad = old; i < nDoodads; i++, doodad++) {
877 if (doodad->any.name == name)
878 return doodad;
879 }
880 if (section) {
881 if ((section->num_doodads >= geom->sz_doodads) &&
882 (_XkbAllocDoodads(section, 1) != Success)) {
883 return NULL;
884 }
885 doodad = &section->doodads[section->num_doodads++];
886 }
887 else {
888 if ((geom->num_doodads >= geom->sz_doodads) &&
889 (_XkbAllocDoodads(geom, 1) != Success))
890 return NULL;
891 doodad = &geom->doodads[geom->num_doodads++];
892 }
893 bzero(doodad, sizeof(XkbDoodadRec));
894 doodad->any.name = name;
895 return doodad;
896 }
897
898 XkbOverlayKeyPtr
899 XkbAddGeomOverlayKey(XkbOverlayPtr overlay,
900 XkbOverlayRowPtr row,
901 char *over,
902 char *under)
903 {
904 register int i;
905 XkbOverlayKeyPtr key;
906 XkbSectionPtr section;
907 XkbRowPtr row_under;
908 Bool found;
909
910 if ((!overlay) || (!row) || (!over) || (!under))
911 return NULL;
912 section = overlay->section_under;
913 if (row->row_under >= section->num_rows)
914 return NULL;
915 row_under = &section->rows[row->row_under];
916 for (i = 0, found = False; i < row_under->num_keys; i++) {
917 if (strncmp(under, row_under->keys[i].name.name, XkbKeyNameLength) == 0) {
918 found = True;
919 break;
920 }
921 }
922 if (!found)
923 return NULL;
924 if ((row->num_keys >= row->sz_keys) &&
925 (_XkbAllocOverlayKeys(row, 1) != Success))
926 return NULL;
927 key = &row->keys[row->num_keys];
928 strncpy(key->under.name, under, XkbKeyNameLength);
929 strncpy(key->over.name, over, XkbKeyNameLength);
930 row->num_keys++;
931 return key;
932 }
933
934 XkbOverlayRowPtr
935 XkbAddGeomOverlayRow(XkbOverlayPtr overlay, int row_under, int sz_keys)
936 {
937 register int i;
938 XkbOverlayRowPtr row;
939
940 if ((!overlay) || (sz_keys < 0))
941 return NULL;
942 if (row_under >= overlay->section_under->num_rows)
943 return NULL;
944 for (i = 0; i < overlay->num_rows; i++) {
945 if (overlay->rows[i].row_under == row_under) {
946 row = &overlay->rows[i];
947 if ((row->sz_keys < sz_keys) &&
948 (_XkbAllocOverlayKeys(row, sz_keys) != Success)) {
949 return NULL;
950 }
951 return &overlay->rows[i];
952 }
953 }
954 if ((overlay->num_rows >= overlay->sz_rows) &&
955 (_XkbAllocOverlayRows(overlay, 1) != Success))
956 return NULL;
957 row = &overlay->rows[overlay->num_rows];
958 bzero(row, sizeof(XkbOverlayRowRec));
959 if ((sz_keys > 0) && (_XkbAllocOverlayKeys(row, sz_keys) != Success))
960 return NULL;
961 row->row_under = row_under;
962 overlay->num_rows++;
963 return row;
964 }
965
966 XkbOverlayPtr
967 XkbAddGeomOverlay(XkbSectionPtr section, Atom name, int sz_rows)
968 {
969 register int i;
970 XkbOverlayPtr overlay;
971
972 if ((!section) || (name == None) || (sz_rows == 0))
973 return NULL;
974
975 for (i = 0, overlay = section->overlays; i < section->num_overlays;
976 i++, overlay++) {
977 if (overlay->name == name) {
978 if ((sz_rows > 0) &&
979 (_XkbAllocOverlayRows(overlay, sz_rows) != Success))
980 return NULL;
981 return overlay;
982 }
983 }
984 if ((section->num_overlays >= section->sz_overlays) &&
985 (_XkbAllocOverlays(section, 1) != Success))
986 return NULL;
987 overlay = &section->overlays[section->num_overlays];
988 if ((sz_rows > 0) && (_XkbAllocOverlayRows(overlay, sz_rows) != Success))
989 return NULL;
990 overlay->name = name;
991 overlay->section_under = section;
992 section->num_overlays++;
993 return overlay;
994 }