3
* Copyright 2002 Red Hat Inc., Durham, North Carolina.
7
* Permission is hereby granted, free of charge, to any person obtaining
8
* a copy of this software and associated documentation files (the
9
* "Software"), to deal in the Software without restriction, including
10
* without limitation on the rights to use, copy, modify, merge,
11
* publish, distribute, sublicense, and/or sell copies of the Software,
12
* and to permit persons to whom the Software is furnished to do so,
13
* subject to the following conditions:
15
* The above copyright notice and this permission notice (including the
16
* next paragraph) shall be included in all copies or substantial
17
* portions of the Software.
19
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
20
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
22
* NON-INFRINGEMENT. IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
23
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
24
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
25
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31
* Rickard E. (Rik) Faith <faith@redhat.com>
37
* This file provides support routines and helper functions to be used
38
* by the DMX configuration file parser.
40
* Because the DMX configuration file parsing should be capable of being
41
* used in a stand-alone fashion (i.e., independent from the DMX server
42
* source tree), no dependencies on other DMX routines are made. */
44
#ifdef HAVE_DMX_CONFIG_H
45
#include <dmx-config.h>
54
/** A general error logging routine that does not depend on the dmxLog
56
void dmxConfigLog(const char *format, ...)
60
va_start(args, format);
61
vprintf(format, args); /* RATS: All calls to dmxConfigLog from
62
* dmxparse.c and dmxprint.c use a
67
void *dmxConfigAlloc(unsigned long bytes)
69
void *area = malloc(bytes);
71
dmxConfigLog("dmxConfigAlloc: out of memory\n");
74
memset(area, 0, bytes);
78
void *dmxConfigRealloc(void *orig, unsigned long orig_bytes,
81
unsigned char *area = realloc(orig, bytes);
83
dmxConfigLog("dmxConfigRealloc: out of memory\n");
86
memset(area + orig_bytes, 0, bytes - orig_bytes);
90
const char *dmxConfigCopyString(const char *string, int length)
94
if (!length) length = strlen(string);
95
copy = dmxConfigAlloc(length + 1);
96
if (length) strncpy(copy, string, length);
101
void dmxConfigFree(void *area)
103
if (area) free(area);
106
DMXConfigTokenPtr dmxConfigCreateToken(int token, int line,
109
DMXConfigTokenPtr pToken = dmxConfigAlloc(sizeof(*pToken));
110
pToken->token = token;
112
pToken->comment = comment;
116
void dmxConfigFreeToken(DMXConfigTokenPtr p)
119
dmxConfigFree((void *)p->comment);
123
DMXConfigStringPtr dmxConfigCreateString(int token, int line,
127
DMXConfigStringPtr pString = dmxConfigAlloc(sizeof(*pString));
129
pString->token = token;
130
pString->line = line;
131
pString->comment = comment;
132
pString->string = string;
136
void dmxConfigFreeString(DMXConfigStringPtr p)
138
DMXConfigStringPtr next;
143
dmxConfigFree((void *)p->comment);
144
dmxConfigFree((void *)p->string);
146
} while ((p = next));
149
DMXConfigNumberPtr dmxConfigCreateNumber(int token, int line,
153
DMXConfigNumberPtr pNumber = dmxConfigAlloc(sizeof(*pNumber));
155
pNumber->token = token;
156
pNumber->line = line;
157
pNumber->comment = comment;
158
pNumber->number = number;
162
void dmxConfigFreeNumber(DMXConfigNumberPtr p)
165
dmxConfigFree((void *)p->comment);
169
DMXConfigPairPtr dmxConfigCreatePair(int token, int line,
172
int xsign, int ysign)
174
DMXConfigPairPtr pPair = dmxConfigAlloc(sizeof(*pPair));
176
pPair->token = token;
178
pPair->comment = comment;
181
pPair->xsign = (xsign < 0) ? -1 : 1;
182
pPair->ysign = (ysign < 0) ? -1 : 1;
186
void dmxConfigFreePair(DMXConfigPairPtr p)
189
dmxConfigFree((void *)p->comment);
193
DMXConfigCommentPtr dmxConfigCreateComment(int token, int line,
196
DMXConfigCommentPtr pComment = dmxConfigAlloc(sizeof(*pComment));
198
pComment->token = token;
199
pComment->line = line;
200
pComment->comment = comment;
204
void dmxConfigFreeComment(DMXConfigCommentPtr p)
207
dmxConfigFree((void *)p->comment);
211
DMXConfigPartDimPtr dmxConfigCreatePartDim(DMXConfigPairPtr pDim,
212
DMXConfigPairPtr pOffset)
214
DMXConfigPartDimPtr pPart = dmxConfigAlloc(sizeof(*pPart));
216
pPart->offset = pOffset;
220
void dmxConfigFreePartDim(DMXConfigPartDimPtr p)
223
dmxConfigFreePair(p->dim);
224
dmxConfigFreePair(p->offset);
228
DMXConfigFullDimPtr dmxConfigCreateFullDim(DMXConfigPartDimPtr pScrn,
229
DMXConfigPartDimPtr pRoot)
231
DMXConfigFullDimPtr pFull = dmxConfigAlloc(sizeof(*pFull));
237
void dmxConfigFreeFullDim(DMXConfigFullDimPtr p)
240
dmxConfigFreePartDim(p->scrn);
241
dmxConfigFreePartDim(p->root);
245
DMXConfigDisplayPtr dmxConfigCreateDisplay(DMXConfigTokenPtr pStart,
246
DMXConfigStringPtr pName,
247
DMXConfigFullDimPtr pDim,
248
DMXConfigPairPtr pOrigin,
249
DMXConfigTokenPtr pEnd)
251
DMXConfigDisplayPtr pDisplay = dmxConfigAlloc(sizeof(*pDisplay));
253
memset(pDisplay, 0, sizeof(*pDisplay));
255
pDisplay->start = pStart;
256
pDisplay->dname = pName;
257
pDisplay->dim = pDim;
258
pDisplay->origin = pOrigin;
259
pDisplay->end = pEnd;
261
pDisplay->name = pName ? pName->string : NULL;
262
pDisplay->rootXOrigin = pOrigin ? pOrigin->x : 0;
263
pDisplay->rootYOrigin = pOrigin ? pOrigin->y : 0;
265
if (pDim && pDim->scrn && pDim->scrn->dim) {
266
pDisplay->scrnWidth = pDim->scrn->dim->x;
267
pDisplay->scrnHeight = pDim->scrn->dim->y;
269
if (pDim && pDim->scrn && pDim->scrn->offset) {
270
pDisplay->scrnX = pDim->scrn->offset->x;
271
pDisplay->scrnY = pDim->scrn->offset->y;
272
pDisplay->scrnXSign = pDim->scrn->offset->xsign;
273
pDisplay->scrnYSign = pDim->scrn->offset->ysign;
276
if (pDim && pDim->root) {
277
if (pDim->root->dim) {
278
pDisplay->rootWidth = pDim->root->dim->x;
279
pDisplay->rootHeight = pDim->root->dim->y;
281
if (pDim->root->offset) {
282
pDisplay->rootX = pDim->root->offset->x;
283
pDisplay->rootY = pDim->root->offset->y;
284
pDisplay->rootXSign = pDim->root->offset->xsign;
285
pDisplay->rootYSign = pDim->root->offset->ysign;
287
} else { /* If no root specification, copy width
288
* and height from scrn -- leave offset
289
* as zero, since it is relative to
291
pDisplay->rootWidth = pDisplay->scrnWidth;
292
pDisplay->rootHeight = pDisplay->scrnHeight;
299
void dmxConfigFreeDisplay(DMXConfigDisplayPtr p)
302
dmxConfigFreeToken(p->start);
303
dmxConfigFreeString(p->dname);
304
dmxConfigFreeFullDim(p->dim);
305
dmxConfigFreeToken(p->end);
309
DMXConfigWallPtr dmxConfigCreateWall(DMXConfigTokenPtr pStart,
310
DMXConfigPairPtr pWallDim,
311
DMXConfigPairPtr pDisplayDim,
312
DMXConfigStringPtr pNameList,
313
DMXConfigTokenPtr pEnd)
315
DMXConfigWallPtr pWall = dmxConfigAlloc(sizeof(*pWall));
317
pWall->start = pStart;
318
pWall->wallDim = pWallDim;
319
pWall->displayDim = pDisplayDim;
320
pWall->nameList = pNameList;
323
pWall->width = pDisplayDim ? pDisplayDim->x : 0;
324
pWall->height = pDisplayDim ? pDisplayDim->y : 0;
325
pWall->xwall = pWallDim ? pWallDim->x : 0;
326
pWall->ywall = pWallDim ? pWallDim->y : 0;
331
void dmxConfigFreeWall(DMXConfigWallPtr p)
334
dmxConfigFreeToken(p->start);
335
dmxConfigFreePair(p->wallDim);
336
dmxConfigFreePair(p->displayDim);
337
dmxConfigFreeString(p->nameList);
338
dmxConfigFreeToken(p->end);
342
DMXConfigOptionPtr dmxConfigCreateOption(DMXConfigTokenPtr pStart,
343
DMXConfigStringPtr pOption,
344
DMXConfigTokenPtr pEnd)
348
DMXConfigStringPtr p;
349
DMXConfigOptionPtr option = dmxConfigAlloc(sizeof(*option));
351
for (p = pOption; p; p = p->next) {
352
if (p->string) length += strlen(p->string) + 1;
355
option->string = dmxConfigAlloc(length + 1);
357
for (p = pOption; p; p = p->next) {
359
int len = strlen(p->string);
360
strncpy(option->string + offset, p->string, len);
362
if (p->next) option->string[offset++] = ' ';
365
option->string[offset] = '\0';
367
option->start = pStart;
368
option->option = pOption;
374
void dmxConfigFreeOption(DMXConfigOptionPtr p)
377
if (p->string) free(p->string);
378
dmxConfigFreeToken(p->start);
379
dmxConfigFreeString(p->option);
380
dmxConfigFreeToken(p->end);
384
const char **dmxConfigLookupParam(DMXConfigParamPtr p, const char *key,
387
DMXConfigParamPtr pt;
389
for (pt = p; pt; pt = pt->next) {
390
if (pt->argv && !strcasecmp(pt->argv[0], key)) {
399
DMXConfigParamPtr dmxConfigCreateParam(DMXConfigTokenPtr pStart,
400
DMXConfigTokenPtr pOpen,
401
DMXConfigStringPtr pParam,
402
DMXConfigTokenPtr pClose,
403
DMXConfigTokenPtr pEnd)
405
DMXConfigParamPtr param = dmxConfigAlloc(sizeof(*param));
406
DMXConfigStringPtr pt;
410
for (pt = pParam; pt; pt = pt->next) {
412
param->argv = realloc(param->argv,
413
(param->argc+2) * sizeof(*param->argv));
414
param->argv[param->argc] = pt->string;
418
if (param->argv) param->argv[param->argc] = NULL;
420
param->start = pStart;
422
param->param = pParam;
423
param->close = pClose;
429
void dmxConfigFreeParam(DMXConfigParamPtr p)
431
DMXConfigParamPtr next;
436
dmxConfigFreeToken(p->start);
437
dmxConfigFreeToken(p->open);
438
dmxConfigFreeString(p->param);
439
dmxConfigFreeToken(p->close);
440
dmxConfigFreeToken(p->end);
441
dmxConfigFree(p->argv);
443
} while ((p = next));
446
DMXConfigSubPtr dmxConfigCreateSub(DMXConfigType type,
447
DMXConfigCommentPtr comment,
448
DMXConfigDisplayPtr display,
449
DMXConfigWallPtr wall,
450
DMXConfigOptionPtr option,
451
DMXConfigParamPtr param)
453
DMXConfigSubPtr pSub = dmxConfigAlloc(sizeof(*pSub));
456
case dmxConfigComment: pSub->comment = comment; break;
457
case dmxConfigDisplay: pSub->display = display; break;
458
case dmxConfigWall: pSub->wall = wall; break;
459
case dmxConfigOption: pSub->option = option; break;
460
case dmxConfigParam: pSub->param = param; break;
461
default: dmxConfigLog("Type %d not supported in subentry\n", type); break;
466
void dmxConfigFreeSub(DMXConfigSubPtr sub)
470
for (pt = sub; pt; pt = pt->next) {
472
case dmxConfigComment: dmxConfigFreeComment(pt->comment); break;
473
case dmxConfigDisplay: dmxConfigFreeDisplay(pt->display); break;
474
case dmxConfigWall: dmxConfigFreeWall(pt->wall); break;
475
case dmxConfigOption: dmxConfigFreeOption(pt->option); break;
476
case dmxConfigParam: dmxConfigFreeParam(pt->param); break;
478
dmxConfigLog("Type %d not supported in subentry\n", pt->type);
485
DMXConfigSubPtr dmxConfigSubComment(DMXConfigCommentPtr comment)
487
return dmxConfigCreateSub(dmxConfigComment, comment, NULL, NULL, NULL,
491
DMXConfigSubPtr dmxConfigSubDisplay(DMXConfigDisplayPtr display)
493
return dmxConfigCreateSub(dmxConfigDisplay, NULL, display, NULL, NULL,
497
DMXConfigSubPtr dmxConfigSubWall(DMXConfigWallPtr wall)
499
return dmxConfigCreateSub(dmxConfigWall, NULL, NULL, wall, NULL, NULL);
502
DMXConfigSubPtr dmxConfigSubOption(DMXConfigOptionPtr option)
504
return dmxConfigCreateSub(dmxConfigOption, NULL, NULL, NULL, option, NULL);
507
DMXConfigSubPtr dmxConfigSubParam(DMXConfigParamPtr param)
509
return dmxConfigCreateSub(dmxConfigParam, NULL, NULL, NULL, NULL, param);
512
extern DMXConfigSubPtr dmxConfigAddSub(DMXConfigSubPtr head,
517
if (!head) return sub;
518
for (pt = head; pt->next; pt = pt->next);
523
DMXConfigVirtualPtr dmxConfigCreateVirtual(DMXConfigTokenPtr pStart,
524
DMXConfigStringPtr pName,
525
DMXConfigPairPtr pDim,
526
DMXConfigTokenPtr pOpen,
527
DMXConfigSubPtr pSubentry,
528
DMXConfigTokenPtr pClose)
530
DMXConfigVirtualPtr pVirtual = dmxConfigAlloc(sizeof(*pVirtual));
532
pVirtual->start = pStart;
533
pVirtual->vname = pName;
534
pVirtual->dim = pDim;
535
pVirtual->open = pOpen;
536
pVirtual->subentry = pSubentry;
537
pVirtual->close = pClose;
539
pVirtual->name = pName ? pName->string : NULL;
540
pVirtual->width = pDim ? pDim->x : 0;
541
pVirtual->height = pDim ? pDim->y : 0;
546
void dmxConfigFreeVirtual(DMXConfigVirtualPtr virtual)
548
dmxConfigFreeToken(virtual->start);
549
dmxConfigFreeString(virtual->vname);
550
dmxConfigFreePair(virtual->dim);
551
dmxConfigFreeToken(virtual->open);
552
dmxConfigFreeSub(virtual->subentry);
553
dmxConfigFreeToken(virtual->close);
554
dmxConfigFree(virtual);
557
DMXConfigEntryPtr dmxConfigCreateEntry(DMXConfigType type,
558
DMXConfigCommentPtr comment,
559
DMXConfigVirtualPtr virtual)
561
DMXConfigEntryPtr pEntry = dmxConfigAlloc(sizeof(*pEntry));
564
case dmxConfigComment: pEntry->comment = comment; break;
565
case dmxConfigVirtual: pEntry->virtual = virtual; break;
566
default: dmxConfigLog("Type %d not supported in entry\n", type); break;
571
void dmxConfigFreeEntry(DMXConfigEntryPtr entry)
573
DMXConfigEntryPtr pt;
575
for (pt = entry; pt; pt = pt->next) {
577
case dmxConfigComment: dmxConfigFreeComment(pt->comment); break;
578
case dmxConfigVirtual: dmxConfigFreeVirtual(pt->virtual); break;
580
dmxConfigLog("Type %d not supported in entry\n", pt->type);
584
dmxConfigFree(entry);
587
DMXConfigEntryPtr dmxConfigAddEntry(DMXConfigEntryPtr head,
589
DMXConfigCommentPtr comment,
590
DMXConfigVirtualPtr virtual)
592
DMXConfigEntryPtr child = dmxConfigCreateEntry(type, comment, virtual);
593
DMXConfigEntryPtr pt;
595
if (!head) return child;
597
for (pt = head; pt->next; pt = pt->next);
603
DMXConfigEntryPtr dmxConfigEntryComment(DMXConfigCommentPtr comment)
605
return dmxConfigCreateEntry(dmxConfigComment, comment, NULL);
608
DMXConfigEntryPtr dmxConfigEntryVirtual(DMXConfigVirtualPtr virtual)
610
return dmxConfigCreateEntry(dmxConfigVirtual, NULL, virtual);