Debian Codegraph @

nx-X11/lib/src/xlibi18n/lcDB.c

raw
1 /*
2 *
3 * Copyright IBM Corporation 1993
4 *
5 * All Rights Reserved
6 *
7 * License to use, copy, modify, and distribute this software and its
8 * documentation for any purpose and without fee is hereby granted,
9 * provided that the above copyright notice appear in all copies and that
10 * both that copyright notice and this permission notice appear in
11 * supporting documentation, and that the name of IBM not be
12 * used in advertising or publicity pertaining to distribution of the
13 * software without specific, written prior permission.
14 *
15 * IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
16 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS, AND
17 * NONINFRINGEMENT OF THIRD PARTY RIGHTS, IN NO EVENT SHALL
18 * IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
19 * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
20 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
21 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
22 * SOFTWARE.
23 *
24 */
25 /*
26 * (c) Copyright 1995 FUJITSU LIMITED
27 * This is source code modified by FUJITSU LIMITED under the Joint
28 * Development Agreement for the CDE/Motif PST.
29 */
30
31
32
33 #ifndef NOT_X_ENV
34
35 #ifdef HAVE_CONFIG_H
36 #include <config.h>
37 #endif
38 #include <nx-X11/Xlib.h>
39 #include <nx-X11/Xresource.h>
40 #include "Xlibint.h"
41 #include "XlcPubI.h"
42 #include "reallocarray.h"
43
44 #else /* NOT_X_ENV */
45
46 #define Xmalloc malloc
47 #define Xrealloc realloc
48 #define Xfree free
49
50 #endif /* NOT_X_ENV */
51
52 /* specifying NOT_X_ENV allows users to just use
53 the database parsing routine. */
54 /* For UDC/VW */
55 #ifndef BUFSIZE
56 #define BUFSIZE 2048
57 #endif
58
59 #ifdef COMMENT
60 #ifdef BUFSIZE
61 #undef BUFSIZE
62 #endif
63 #define BUFSIZE 6144 /* 2048*3 */
64 #endif
65
66 #include <stdio.h>
67
68 typedef struct _DatabaseRec {
69 char *category;
70 char *name;
71 char **value;
72 int value_num;
73 struct _DatabaseRec *next;
74 } DatabaseRec, *Database;
75
76 typedef enum {
77 S_NULL, /* outside category */
78 S_CATEGORY, /* inside category */
79 S_NAME, /* has name, expecting values */
80 S_VALUE
81 } ParseState;
82
83 typedef enum {
84 T_NEWLINE,
85 T_COMMENT,
86 T_SEMICOLON,
87 T_DOUBLE_QUOTE,
88 T_LEFT_BRACE,
89 T_RIGHT_BRACE,
90 T_SPACE,
91 T_TAB,
92 T_BACKSLASH,
93 T_NUMERIC_HEX,
94 T_NUMERIC_DEC,
95 T_NUMERIC_OCT,
96 T_DEFAULT
97 } Token;
98
99 typedef struct {
100 Token token; /* token id */
101 int len; /* length of token sequence */
102 } TokenTable;
103
104 static int f_newline (const char *str, Token token, Database *db);
105 static int f_comment (const char *str, Token token, Database *db);
106 static int f_semicolon (const char *str, Token token, Database *db);
107 static int f_double_quote (const char *str, Token token, Database *db);
108 static int f_left_brace (const char *str, Token token, Database *db);
109 static int f_right_brace (const char *str, Token token, Database *db);
110 static int f_white (const char *str, Token token, Database *db);
111 static int f_backslash (const char *str, Token token, Database *db);
112 static int f_numeric (const char *str, Token token, Database *db);
113 static int f_default (const char *str, Token token, Database *db);
114
115 static const TokenTable token_tbl[] = {
116 { T_NEWLINE, 1 },
117 { T_COMMENT, 1 },
118 { T_SEMICOLON, 1 },
119 { T_DOUBLE_QUOTE, 1 },
120 { T_LEFT_BRACE, 1 },
121 { T_RIGHT_BRACE, 1 },
122 { T_SPACE, 1 },
123 { T_TAB, 1 },
124 { T_BACKSLASH, 1 },
125 { T_NUMERIC_HEX, 2 },
126 { T_NUMERIC_DEC, 2 },
127 { T_NUMERIC_OCT, 2 },
128 { T_DEFAULT, 1 } /* any character */
129 };
130
131 #define SYM_CR '\r'
132 #define SYM_NEWLINE '\n'
133 #define SYM_COMMENT '#'
134 #define SYM_SEMICOLON ';'
135 #define SYM_DOUBLE_QUOTE '"'
136 #define SYM_LEFT_BRACE '{'
137 #define SYM_RIGHT_BRACE '}'
138 #define SYM_SPACE ' '
139 #define SYM_TAB '\t'
140 #define SYM_BACKSLASH '\\'
141
142 /************************************************************************/
143
144 #define MAX_NAME_NEST 64
145
146 typedef struct {
147 ParseState pre_state;
148 char *category;
149 char *name[MAX_NAME_NEST];
150 int nest_depth;
151 char **value;
152 int value_len;
153 int value_num;
154 int bufsize; /* bufMaxSize >= bufsize >= 0 */
155 int bufMaxSize; /* default : BUFSIZE */
156 char *buf;
157 } DBParseInfo;
158
159 static DBParseInfo parse_info;
160
161 static void
162 init_parse_info (void)
163 {
164 static int allocated /* = 0 */;
165 char *ptr;
166 int size;
167 if (!allocated) {
168 bzero(&parse_info, sizeof(DBParseInfo));
169 parse_info.buf = Xmalloc(BUFSIZE);
170 parse_info.bufMaxSize = BUFSIZE;
171 allocated = 1;
172 return;
173 }
174 ptr = parse_info.buf;
175 size = parse_info.bufMaxSize;
176 bzero(&parse_info, sizeof(DBParseInfo));
177 parse_info.buf = ptr;
178 parse_info.bufMaxSize = size;
179 }
180
181 static void
182 clear_parse_info (void)
183 {
184 int i;
185 char *ptr;
186 int size;
187 parse_info.pre_state = S_NULL;
188 if (parse_info.category != NULL) {
189 Xfree(parse_info.category);
190 }
191 for (i = 0; i <= parse_info.nest_depth; ++i) {
192 if (parse_info.name[i]) {
193 Xfree(parse_info.name[i]);
194 }
195 }
196 if (parse_info.value) {
197 if (*parse_info.value) {
198 Xfree(*parse_info.value);
199 }
200 Xfree(parse_info.value);
201 }
202 ptr = parse_info.buf;
203 size = parse_info.bufMaxSize;
204 bzero(&parse_info, sizeof(DBParseInfo));
205 parse_info.buf = ptr;
206 parse_info.bufMaxSize = size;
207 }
208
209 static Bool
210 realloc_parse_info(
211 int len)
212 {
213 char *p;
214 int newsize = BUFSIZE * ((parse_info.bufsize + len)/BUFSIZE + 1);
215
216 p = Xrealloc(parse_info.buf, newsize);
217 if (p == NULL)
218 return False;
219 parse_info.bufMaxSize = newsize;
220 parse_info.buf = p;
221
222 return True;
223 }
224
225 /************************************************************************/
226
227 typedef struct _Line {
228 char *str;
229 int cursize;
230 int maxsize;
231 int seq;
232 } Line;
233
234 static void
235 free_line(
236 Line *line)
237 {
238 if (line->str != NULL) {
239 Xfree(line->str);
240 }
241 bzero(line, sizeof(Line));
242 }
243
244 static int
245 realloc_line(
246 Line *line,
247 int size)
248 {
249 char *str = line->str;
250
251 if (str != NULL) {
252 str = Xrealloc(str, size);
253 } else {
254 str = Xmalloc(size);
255 }
256 if (str == NULL) {
257 /* malloc error */
258 if (line->str != NULL) {
259 Xfree(line->str);
260 }
261 bzero(line, sizeof(Line));
262 return 0;
263 }
264 line->str = str;
265 line->maxsize = size;
266 return 1;
267 }
268
269 #define iswhite(ch) ((ch) == SYM_SPACE || (ch) == SYM_TAB)
270
271 static void
272 zap_comment(
273 char *str,
274 int *quoted)
275 {
276 char *p = str;
277 #ifdef never
278 *quoted = 0;
279 if (*p == SYM_COMMENT) {
280 int len = strlen(str);
281 if (p[len - 1] == SYM_NEWLINE || p[len - 1] == SYM_CR) {
282 *p++ = SYM_NEWLINE;
283 }
284 *p = '\0';
285 }
286 #else
287 while (*p) {
288 if (*p == SYM_DOUBLE_QUOTE) {
289 if (p == str || p[-1] != SYM_BACKSLASH) {
290 /* unescaped double quote changes quoted state. */
291 *quoted = *quoted ? 0 : 1;
292 }
293 }
294 if (*p == SYM_COMMENT && !*quoted) {
295 int pos = p - str;
296 if (pos == 0 ||
297 (iswhite(p[-1]) && (pos == 1 || p[-2] != SYM_BACKSLASH))) {
298 int len = (int) strlen(p);
299 if (len > 0 && (p[len - 1] == SYM_NEWLINE || p[len-1] == SYM_CR)) {
300 /* newline is the identifier for finding end of value.
301 therefore, it should not be removed. */
302 *p++ = SYM_NEWLINE;
303 }
304 *p = '\0';
305 break;
306 }
307 }
308 ++p;
309 }
310 #endif
311 }
312
313 static int
314 read_line(
315 FILE *fd,
316 Line *line)
317 {
318 char buf[BUFSIZE], *p;
319 int len;
320 int quoted = 0; /* quoted by double quote? */
321 char *str;
322 int cur;
323
324 str = line->str;
325 cur = line->cursize = 0;
326
327 while ((p = fgets(buf, BUFSIZE, fd)) != NULL) {
328 ++line->seq;
329 zap_comment(p, &quoted); /* remove comment line */
330 len = (int) strlen(p);
331 if (len == 0) {
332 if (cur > 0) {
333 break;
334 }
335 continue;
336 }
337 if (cur + len + 1 > line->maxsize) {
338 /* need to reallocate buffer. */
339 if (! realloc_line(line, line->maxsize + BUFSIZE)) {
340 return -1; /* realloc error. */
341 }
342 str = line->str;
343 }
344 memcpy(str + cur, p, (size_t) len);
345
346 cur += len;
347 str[cur] = '\0';
348 if (!quoted && cur > 1 && str[cur - 2] == SYM_BACKSLASH &&
349 (str[cur - 1] == SYM_NEWLINE || str[cur-1] == SYM_CR)) {
350 /* the line is ended backslash followed by newline.
351 need to concatinate the next line. */
352 cur -= 2;
353 str[cur] = '\0';
354 } else if (len < BUFSIZE - 1 || buf[len - 1] == SYM_NEWLINE ||
355 buf[len - 1] == SYM_CR) {
356 /* the line is shorter than BUFSIZE. */
357 break;
358 }
359 }
360 if (quoted) {
361 /* error. still in quoted state. */
362 return -1;
363 }
364 return line->cursize = cur;
365 }
366
367 /************************************************************************/
368
369 static Token
370 get_token(
371 const char *str)
372 {
373 switch (*str) {
374 case SYM_NEWLINE:
375 case SYM_CR: return T_NEWLINE;
376 case SYM_COMMENT: return T_COMMENT;
377 case SYM_SEMICOLON: return T_SEMICOLON;
378 case SYM_DOUBLE_QUOTE: return T_DOUBLE_QUOTE;
379 case SYM_LEFT_BRACE: return T_LEFT_BRACE;
380 case SYM_RIGHT_BRACE: return T_RIGHT_BRACE;
381 case SYM_SPACE: return T_SPACE;
382 case SYM_TAB: return T_TAB;
383 case SYM_BACKSLASH:
384 switch (str[1]) {
385 case 'x': return T_NUMERIC_HEX;
386 case 'd': return T_NUMERIC_DEC;
387 case 'o': return T_NUMERIC_OCT;
388 }
389 return T_BACKSLASH;
390 default:
391 return T_DEFAULT;
392 }
393 }
394
395 static int
396 get_word(
397 const char *str,
398 char *word)
399 {
400 const char *p = str;
401 char *w = word;
402 Token token;
403 int token_len;
404
405 while (*p != '\0') {
406 token = get_token(p);
407 token_len = token_tbl[token].len;
408 if (token == T_BACKSLASH) {
409 p += token_len;
410 if (*p == '\0')
411 break;
412 token = get_token(p);
413 token_len = token_tbl[token].len;
414 } else if (token != T_COMMENT && token != T_DEFAULT) {
415 break;
416 }
417 strncpy(w, p, (size_t) token_len);
418 p += token_len; w += token_len;
419 }
420 *w = '\0';
421 return p - str; /* return number of scanned chars */
422 }
423
424 static int
425 get_quoted_word(
426 const char *str,
427 char *word)
428 {
429 const char *p = str;
430 char *w = word;
431 Token token;
432 int token_len;
433
434 if (*p == SYM_DOUBLE_QUOTE) {
435 ++p;
436 }
437 while (*p != '\0') {
438 token = get_token(p);
439 token_len = token_tbl[token].len;
440 if (token == T_DOUBLE_QUOTE) {
441 p += token_len;
442 goto found;
443 }
444 if (token == T_BACKSLASH) {
445 p += token_len;
446 if (*p == '\0') {
447 break;
448 }
449 token = get_token(p);
450 token_len = token_tbl[token].len;
451 }
452 strncpy(w, p, (size_t) token_len);
453 p += token_len; w += token_len;
454 }
455 /* error. cannot detect next double quote */
456 return 0;
457
458 found:;
459 *w = '\0';
460 return p - str;
461 }
462
463 /************************************************************************/
464
465 static int
466 append_value_list (void)
467 {
468 char **value_list = parse_info.value;
469 char *value;
470 int value_num = parse_info.value_num;
471 int value_len = parse_info.value_len;
472 char *str = parse_info.buf;
473 int len = parse_info.bufsize;
474 char *p;
475
476 if (len < 1) {
477 return 1; /* return with no error */
478 }
479
480 if (value_list == (char **)NULL) {
481 value_list = Xmalloc(sizeof(char *) * 2);
482 *value_list = NULL;
483 } else {
484 char **prev_list = value_list;
485
486 value_list = (char **)
487 Xreallocarray(value_list, value_num + 2, sizeof(char *));
488 if (value_list == NULL) {
489 Xfree(prev_list);
490 }
491 }
492 if (value_list == (char **)NULL)
493 goto err2;
494
495 value = *value_list;
496 if (value == NULL) {
497 value = Xmalloc(value_len + len + 1);
498 } else {
499 char *prev_value = value;
500
501 value = Xrealloc(value, value_len + len + 1);
502 if (value == NULL) {
503 Xfree(prev_value);
504 }
505 }
506 if (value == NULL) {
507 goto err1;
508 }
509 if (value != *value_list) {
510 int i;
511 char *old_list;
512 old_list = *value_list;
513 *value_list = value;
514 /* Re-derive pointers from the new realloc() result to avoid undefined
515 behaviour (and crashes on architectures with pointer bounds). */
516 for (i = 1; i < value_num; ++i) {
517 value_list[i] = value + (value_list[i] - old_list);
518 }
519 }
520
521 value_list[value_num] = p = &value[value_len];
522 value_list[value_num + 1] = NULL;
523 strncpy(p, str, (size_t) len);
524 p[len] = 0;
525
526 parse_info.value = value_list;
527 parse_info.value_num = value_num + 1;
528 parse_info.value_len = value_len + len + 1;
529 parse_info.bufsize = 0;
530 return 1;
531
532 err1:
533 if (value_list) {
534 Xfree((char **)value_list);
535 }
536 if (value) {
537 Xfree(value);
538 }
539 err2:
540 parse_info.value = (char **)NULL;
541 parse_info.value_num = 0;
542 parse_info.value_len = 0;
543 parse_info.bufsize = 0;
544 return 0;
545 }
546
547 static int
548 construct_name(
549 char *name,
550 int size)
551 {
552 int i;
553 int len = 0;
554 char *p = name;
555
556 for (i = 0; i <= parse_info.nest_depth; ++i) {
557 len = (int) ((size_t) len + (strlen(parse_info.name[i]) + 1));
558 }
559 if (len >= size)
560 return 0;
561
562 strcpy(p, parse_info.name[0]);
563 p += strlen(parse_info.name[0]);
564 for (i = 1; i <= parse_info.nest_depth; ++i) {
565 *p++ = '.';
566 strcpy(p, parse_info.name[i]);
567 p += strlen(parse_info.name[i]);
568 }
569 return *name != '\0';
570 }
571
572 static int
573 store_to_database(
574 Database *db)
575 {
576 Database new = (Database)NULL;
577 char name[BUFSIZE];
578
579 if (parse_info.pre_state == S_VALUE) {
580 if (! append_value_list()) {
581 goto err;
582 }
583 }
584
585 if (parse_info.name[parse_info.nest_depth] == NULL) {
586 goto err;
587 }
588
589 new = Xcalloc(1, sizeof(DatabaseRec));
590 if (new == (Database)NULL) {
591 goto err;
592 }
593
594 new->category = strdup(parse_info.category);
595 if (new->category == NULL) {
596 goto err;
597 }
598
599 if (! construct_name(name, sizeof(name))) {
600 goto err;
601 }
602 new->name = strdup(name);
603 if (new->name == NULL) {
604 goto err;
605 }
606 new->next = *db;
607 new->value = parse_info.value;
608 new->value_num = parse_info.value_num;
609 *db = new;
610
611 Xfree(parse_info.name[parse_info.nest_depth]);
612 parse_info.name[parse_info.nest_depth] = NULL;
613
614 parse_info.value = (char **)NULL;
615 parse_info.value_num = 0;
616 parse_info.value_len = 0;
617
618 return 1;
619
620 err:
621 if (new) {
622 if (new->category) {
623 Xfree(new->category);
624 }
625 if (new->name) {
626 Xfree(new->name);
627 }
628 Xfree(new);
629 }
630 if (parse_info.value) {
631 if (*parse_info.value) {
632 Xfree(*parse_info.value);
633 }
634 Xfree((char **)parse_info.value);
635 parse_info.value = (char **)NULL;
636 parse_info.value_num = 0;
637 parse_info.value_len = 0;
638 }
639 return 0;
640 }
641
642 #define END_MARK "END"
643 #define END_MARK_LEN 3 /*strlen(END_MARK)*/
644
645 static int
646 check_category_end(
647 const char *str)
648 {
649 const char *p;
650 int len;
651
652 p = str;
653 if (strncmp(p, END_MARK, END_MARK_LEN)) {
654 return 0;
655 }
656 p += END_MARK_LEN;
657
658 while (iswhite(*p)) {
659 ++p;
660 }
661 len = (int) strlen(parse_info.category);
662 if (strncmp(p, parse_info.category, (size_t) len)) {
663 return 0;
664 }
665 p += len;
666 return p - str;
667 }
668
669 /************************************************************************/
670
671 static int
672 f_newline(
673 const char *str,
674 Token token,
675 Database *db)
676 {
677 switch (parse_info.pre_state) {
678 case S_NULL:
679 case S_CATEGORY:
680 break;
681 case S_NAME:
682 return 0; /* no value */
683 case S_VALUE:
684 if (!store_to_database(db))
685 return 0;
686 parse_info.pre_state = S_CATEGORY;
687 break;
688 default:
689 return 0;
690 }
691 return token_tbl[token].len;
692 }
693
694 static int
695 f_comment(
696 const char *str,
697 Token token,
698 Database *db)
699 {
700 /* NOTE: comment is already handled in read_line(),
701 so this function is not necessary. */
702
703 const char *p = str;
704
705 while (*p != SYM_NEWLINE && *p != SYM_CR && *p != '\0') {
706 ++p; /* zap to the end of line */
707 }
708 return p - str;
709 }
710
711 static int
712 f_white(
713 const char *str,
714 Token token,
715 Database *db)
716 {
717 const char *p = str;
718
719 while (iswhite(*p)) {
720 ++p;
721 }
722 return p - str;
723 }
724
725 static int
726 f_semicolon(
727 const char *str,
728 Token token,
729 Database *db)
730 {
731 switch (parse_info.pre_state) {
732 case S_NULL:
733 case S_CATEGORY:
734 case S_NAME:
735 return 0;
736 case S_VALUE:
737 if (! append_value_list())
738 return 0;
739 parse_info.pre_state = S_VALUE;
740 break;
741 default:
742 return 0;
743 }
744 return token_tbl[token].len;
745 }
746
747 static int
748 f_left_brace(
749 const char *str,
750 Token token,
751 Database *db)
752 {
753 switch (parse_info.pre_state) {
754 case S_NULL:
755 case S_CATEGORY:
756 case S_VALUE:
757 return 0;
758 case S_NAME:
759 if (parse_info.name[parse_info.nest_depth] == NULL
760 || parse_info.nest_depth + 1 > MAX_NAME_NEST)
761 return 0;
762 ++parse_info.nest_depth;
763 parse_info.pre_state = S_CATEGORY;
764 break;
765 default:
766 return 0;
767 }
768 return token_tbl[token].len;
769 }
770
771 static int
772 f_right_brace(
773 const char *str,
774 Token token,
775 Database *db)
776 {
777 if (parse_info.nest_depth < 1)
778 return 0;
779
780 switch (parse_info.pre_state) {
781 case S_NULL:
782 case S_NAME:
783 return 0;
784 case S_VALUE:
785 if (! store_to_database(db))
786 return 0;
787 /* fall through - to next case */
788 case S_CATEGORY:
789 if (parse_info.name[parse_info.nest_depth] != NULL) {
790 Xfree(parse_info.name[parse_info.nest_depth]);
791 parse_info.name[parse_info.nest_depth] = NULL;
792 }
793 --parse_info.nest_depth;
794 parse_info.pre_state = S_CATEGORY;
795 break;
796 default:
797 return 0;
798 }
799 return token_tbl[token].len;
800 }
801
802 static int
803 f_double_quote(
804 const char *str,
805 Token token,
806 Database *db)
807 {
808 char word[BUFSIZE];
809 char* wordp;
810 int len;
811
812 if ((len = (int) strlen (str)) < sizeof word)
813 wordp = word;
814 else
815 wordp = Xmalloc (len + 1);
816 if (wordp == NULL)
817 return 0;
818
819 len = 0;
820 switch (parse_info.pre_state) {
821 case S_NULL:
822 case S_CATEGORY:
823 goto err;
824 case S_NAME:
825 case S_VALUE:
826 len = get_quoted_word(str, wordp);
827 if (len < 1)
828 goto err;
829 if ((parse_info.bufsize + (int)strlen(wordp) + 1)
830 >= parse_info.bufMaxSize) {
831 if (realloc_parse_info((int) strlen(wordp)+1) == False) {
832 goto err;
833 }
834 }
835 strcpy(&parse_info.buf[parse_info.bufsize], wordp);
836 parse_info.bufsize = (int) ((size_t) parse_info.bufsize + strlen(wordp));
837 parse_info.pre_state = S_VALUE;
838 break;
839 default:
840 goto err;
841 }
842 if (wordp != word)
843 Xfree (wordp);
844 return len; /* including length of token */
845
846 err:
847 if (wordp != word)
848 Xfree (wordp);
849 return 0;
850 }
851
852 static int
853 f_backslash(
854 const char *str,
855 Token token,
856 Database *db)
857 {
858 return f_default(str, token, db);
859 }
860
861 static int
862 f_numeric(
863 const char *str,
864 Token token,
865 Database *db)
866 {
867 char word[BUFSIZE];
868 const char *p;
869 char* wordp;
870 int len;
871 int token_len;
872
873 if ((len = (int) strlen (str)) < sizeof word)
874 wordp = word;
875 else
876 wordp = Xmalloc (len + 1);
877 if (wordp == NULL)
878 return 0;
879
880 switch (parse_info.pre_state) {
881 case S_NULL:
882 case S_CATEGORY:
883 goto err;
884 case S_NAME:
885 case S_VALUE:
886 token_len = token_tbl[token].len;
887 p = str + token_len;
888 len = get_word(p, wordp);
889 if (len < 1)
890 goto err;
891 if ((parse_info.bufsize + token_len + (int)strlen(wordp) + 1)
892 >= parse_info.bufMaxSize) {
893 if (realloc_parse_info((int)((size_t) token_len + strlen(wordp) + 1)) == False)
894 goto err;
895 }
896 strncpy(&parse_info.buf[parse_info.bufsize], str, (size_t) token_len);
897 strcpy(&parse_info.buf[parse_info.bufsize + token_len], wordp);
898 parse_info.bufsize = (int) ((size_t) parse_info.bufsize + ((size_t) token_len + strlen(wordp)));
899 parse_info.pre_state = S_VALUE;
900 break;
901 default:
902 goto err;
903 }
904 if (wordp != word)
905 Xfree (wordp);
906 return len + token_len;
907
908 err:
909 if (wordp != word)
910 Xfree (wordp);
911 return 0;
912 }
913
914 static int
915 f_default(
916 const char *str,
917 Token token,
918 Database *db)
919 {
920 char word[BUFSIZE], *p;
921 char* wordp;
922 int len;
923
924 if ((len = (int) strlen (str)) < sizeof word)
925 wordp = word;
926 else
927 wordp = Xmalloc (len + 1);
928 if (wordp == NULL)
929 return 0;
930
931 len = get_word(str, wordp);
932 if (len < 1)
933 goto err;
934
935 switch (parse_info.pre_state) {
936 case S_NULL:
937 if (parse_info.category != NULL)
938 goto err;
939 p = strdup(wordp);
940 if (p == NULL)
941 goto err;
942 parse_info.category = p;
943 parse_info.pre_state = S_CATEGORY;
944 break;
945 case S_CATEGORY:
946 if (parse_info.nest_depth == 0) {
947 if (check_category_end(str)) {
948 /* end of category is detected.
949 clear context and zap to end of this line */
950 clear_parse_info();
951 len = (int) strlen(str);
952 break;
953 }
954 }
955 p = strdup(wordp);
956 if (p == NULL)
957 goto err;
958 if (parse_info.name[parse_info.nest_depth] != NULL) {
959 Xfree(parse_info.name[parse_info.nest_depth]);
960 }
961 parse_info.name[parse_info.nest_depth] = p;
962 parse_info.pre_state = S_NAME;
963 break;
964 case S_NAME:
965 case S_VALUE:
966 if ((parse_info.bufsize + (int)strlen(wordp) + 1)
967 >= parse_info.bufMaxSize) {
968 if (realloc_parse_info((int) strlen(wordp) + 1) == False)
969 goto err;
970 }
971 strcpy(&parse_info.buf[parse_info.bufsize], wordp);
972 parse_info.bufsize = (int) ((size_t) parse_info.bufsize + strlen(wordp));
973 parse_info.pre_state = S_VALUE;
974 break;
975 default:
976 goto err;
977 }
978 if (wordp != word)
979 Xfree (wordp);
980 return len;
981
982 err:
983 if (wordp != word)
984 Xfree (wordp);
985 return 0;
986 }
987
988 /************************************************************************/
989
990 #ifdef DEBUG
991 static void
992 PrintDatabase(
993 Database db)
994 {
995 Database p = db;
996 int i = 0, j;
997
998 printf("***\n*** BEGIN Database\n***\n");
999 while (p) {
1000 printf("%3d: ", i++);
1001 printf("%s, %s, ", p->category, p->name);
1002 printf("\t[%d: ", p->value_num);
1003 for (j = 0; j < p->value_num; ++j) {
1004 printf("%s, ", p->value[j]);
1005 }
1006 printf("]\n");
1007 p = p->next;
1008 }
1009 printf("***\n*** END Database\n***\n");
1010 }
1011 #endif
1012
1013 static void
1014 DestroyDatabase(
1015 Database db)
1016 {
1017 Database p = db;
1018
1019 while (p) {
1020 if (p->category != NULL) {
1021 Xfree(p->category);
1022 }
1023 if (p->name != NULL) {
1024 Xfree(p->name);
1025 }
1026 if (p->value != (char **)NULL) {
1027 if (*p->value != NULL) {
1028 Xfree(*p->value);
1029 }
1030 Xfree(p->value);
1031 }
1032 db = p->next;
1033 Xfree(p);
1034 p = db;
1035 }
1036 }
1037
1038 static int
1039 CountDatabase(
1040 Database db)
1041 {
1042 Database p = db;
1043 int cnt = 0;
1044
1045 while (p) {
1046 ++cnt;
1047 p = p->next;
1048 }
1049 return cnt;
1050 }
1051
1052 static Database
1053 CreateDatabase(
1054 char *dbfile)
1055 {
1056 Database db = (Database)NULL;
1057 FILE *fd;
1058 Line line;
1059 char *p;
1060 Token token;
1061 int len;
1062 int error = 0;
1063
1064 fd = _XFopenFile(dbfile, "r");
1065 if (fd == (FILE *)NULL)
1066 return NULL;
1067
1068 bzero(&line, sizeof(Line));
1069 init_parse_info();
1070
1071 do {
1072 int rc = read_line(fd, &line);
1073 if (rc < 0) {
1074 error = 1;
1075 break;
1076 } else if (rc == 0) {
1077 break;
1078 }
1079 p = line.str;
1080 while (*p) {
1081 int (*parse_proc)(const char *str, Token token, Database *db) = NULL;
1082
1083 token = get_token(p);
1084
1085 switch (token_tbl[token].token) {
1086 case T_NEWLINE:
1087 parse_proc = f_newline;
1088 break;
1089 case T_COMMENT:
1090 parse_proc = f_comment;
1091 break;
1092 case T_SEMICOLON:
1093 parse_proc = f_semicolon;
1094 break;
1095 case T_DOUBLE_QUOTE:
1096 parse_proc = f_double_quote;
1097 break;
1098 case T_LEFT_BRACE:
1099 parse_proc = f_left_brace;
1100 break;
1101 case T_RIGHT_BRACE:
1102 parse_proc = f_right_brace;
1103 break;
1104 case T_SPACE:
1105 case T_TAB:
1106 parse_proc = f_white;
1107 break;
1108 case T_BACKSLASH:
1109 parse_proc = f_backslash;
1110 break;
1111 case T_NUMERIC_HEX:
1112 case T_NUMERIC_DEC:
1113 case T_NUMERIC_OCT:
1114 parse_proc = f_numeric;
1115 break;
1116 case T_DEFAULT:
1117 parse_proc = f_default;
1118 break;
1119 }
1120
1121 len = parse_proc(p, token, &db);
1122
1123 if (len < 1) {
1124 error = 1;
1125 break;
1126 }
1127 p += len;
1128 }
1129 } while (!error);
1130
1131 if (parse_info.pre_state != S_NULL) {
1132 clear_parse_info();
1133 error = 1;
1134 }
1135 if (error) {
1136 #ifdef DEBUG
1137 fprintf(stderr, "database format error at line %d.\n", line.seq);
1138 #endif
1139 DestroyDatabase(db);
1140 db = (Database)NULL;
1141 }
1142
1143 fclose(fd);
1144 free_line(&line);
1145
1146 #ifdef DEBUG
1147 PrintDatabase(db);
1148 #endif
1149
1150 return db;
1151 }
1152
1153 /************************************************************************/
1154
1155 #ifndef NOT_X_ENV
1156
1157 /* locale framework functions */
1158
1159 typedef struct _XlcDatabaseRec {
1160 XrmQuark category_q;
1161 XrmQuark name_q;
1162 Database db;
1163 struct _XlcDatabaseRec *next;
1164 } XlcDatabaseRec, *XlcDatabase;
1165
1166 typedef struct _XlcDatabaseListRec {
1167 XrmQuark name_q;
1168 XlcDatabase lc_db;
1169 Database database;
1170 int ref_count;
1171 struct _XlcDatabaseListRec *next;
1172 } XlcDatabaseListRec, *XlcDatabaseList;
1173
1174 /* database cache list (per file) */
1175 static XlcDatabaseList _db_list = (XlcDatabaseList)NULL;
1176
1177 /************************************************************************/
1178 /* _XlcGetResource(lcd, category, class, value, count) */
1179 /*----------------------------------------------------------------------*/
1180 /* This function retrieves XLocale database information. */
1181 /************************************************************************/
1182 void
1183 _XlcGetResource(
1184 XLCd lcd,
1185 const char *category,
1186 const char *class,
1187 char ***value,
1188 int *count)
1189 {
1190 XLCdPublicMethodsPart *methods = XLC_PUBLIC_METHODS(lcd);
1191
1192 (*methods->get_resource)(lcd, category, class, value, count);
1193 return;
1194 }
1195
1196 /************************************************************************/
1197 /* _XlcGetLocaleDataBase(lcd, category, class, value, count) */
1198 /*----------------------------------------------------------------------*/
1199 /* This function retrieves XLocale database information. */
1200 /************************************************************************/
1201 void
1202 _XlcGetLocaleDataBase(
1203 XLCd lcd,
1204 const char *category,
1205 const char *name,
1206 char ***value,
1207 int *count)
1208 {
1209 XlcDatabase lc_db = (XlcDatabase)XLC_PUBLIC(lcd, xlocale_db);
1210 XrmQuark category_q, name_q;
1211
1212 category_q = XrmStringToQuark(category);
1213 name_q = XrmStringToQuark(name);
1214 for (; lc_db->db; ++lc_db) {
1215 if (category_q == lc_db->category_q && name_q == lc_db->name_q) {
1216 *value = lc_db->db->value;
1217 *count = lc_db->db->value_num;
1218 return;
1219 }
1220 }
1221 *value = (char **)NULL;
1222 *count = 0;
1223 }
1224
1225 /************************************************************************/
1226 /* _XlcDestroyLocaleDataBase(lcd) */
1227 /*----------------------------------------------------------------------*/
1228 /* This function destroy the XLocale Database that bound to the */
1229 /* specified lcd. If the XLocale Database is referred from some */
1230 /* other lcd, this function just decreases reference count of */
1231 /* the database. If no locale refers the database, this function */
1232 /* remove it from the cache list and free work area. */
1233 /************************************************************************/
1234 void
1235 _XlcDestroyLocaleDataBase(
1236 XLCd lcd)
1237 {
1238 XlcDatabase lc_db = (XlcDatabase)XLC_PUBLIC(lcd, xlocale_db);
1239 XlcDatabaseList p, prev;
1240
1241 for (p = _db_list, prev = (XlcDatabaseList)NULL; p;
1242 prev = p, p = p->next) {
1243 if (p->lc_db == lc_db) {
1244 if ((-- p->ref_count) < 1) {
1245 if (p->lc_db != (XlcDatabase)NULL) {
1246 Xfree(p->lc_db);
1247 }
1248 DestroyDatabase(p->database);
1249 if (prev == (XlcDatabaseList)NULL) {
1250 _db_list = p->next;
1251 } else {
1252 prev->next = p->next;
1253 }
1254 Xfree((char*)p);
1255 }
1256 break;
1257 }
1258 }
1259 XLC_PUBLIC(lcd, xlocale_db) = (XPointer)NULL;
1260 }
1261
1262 /************************************************************************/
1263 /* _XlcCreateLocaleDataBase(lcd) */
1264 /*----------------------------------------------------------------------*/
1265 /* This function create an XLocale database which correspond to */
1266 /* the specified XLCd. */
1267 /************************************************************************/
1268 XPointer
1269 _XlcCreateLocaleDataBase(
1270 XLCd lcd)
1271 {
1272 XlcDatabaseList list, new;
1273 Database p, database = (Database)NULL;
1274 XlcDatabase lc_db = (XlcDatabase)NULL;
1275 XrmQuark name_q;
1276 char *name;
1277 int i, n;
1278
1279 name = _XlcFileName(lcd, "locale");
1280 if (name == NULL)
1281 return (XPointer)NULL;
1282
1283 name_q = XrmStringToQuark(name);
1284 for (list = _db_list; list; list = list->next) {
1285 if (name_q == list->name_q) {
1286 list->ref_count++;
1287 Xfree (name);
1288 return XLC_PUBLIC(lcd, xlocale_db) = (XPointer)list->lc_db;
1289 }
1290 }
1291
1292 database = CreateDatabase(name);
1293 if (database == (Database)NULL) {
1294 Xfree (name);
1295 return (XPointer)NULL;
1296 }
1297 n = CountDatabase(database);
1298 lc_db = Xcalloc(n + 1, sizeof(XlcDatabaseRec));
1299 if (lc_db == (XlcDatabase)NULL)
1300 goto err;
1301 for (p = database, i = 0; p && i < n; p = p->next, ++i) {
1302 lc_db[i].category_q = XrmStringToQuark(p->category);
1303 lc_db[i].name_q = XrmStringToQuark(p->name);
1304 lc_db[i].db = p;
1305 }
1306
1307 new = Xmalloc(sizeof(XlcDatabaseListRec));
1308 if (new == (XlcDatabaseList)NULL) {
1309 goto err;
1310 }
1311 new->name_q = name_q;
1312 new->lc_db = lc_db;
1313 new->database = database;
1314 new->ref_count = 1;
1315 new->next = _db_list;
1316 _db_list = new;
1317
1318 Xfree (name);
1319 return XLC_PUBLIC(lcd, xlocale_db) = (XPointer)lc_db;
1320
1321 err:
1322 DestroyDatabase(database);
1323 if (lc_db != (XlcDatabase)NULL) {
1324 Xfree(lc_db);
1325 }
1326 Xfree (name);
1327 return (XPointer)NULL;
1328 }
1329
1330 #endif /* NOT_X_ENV */