Debian Codegraph @

geanygendoc/src/ggd-file-type-loader.c

raw
1 /*
2 *
3 * GeanyGenDoc, a Geany plugin to ease generation of source code documentation
4 * Copyright (C) 2010-2011 Colomban Wendling <[email protected]>
5 *
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 /*
22 * FIXME: This file is a little big and have some duplicated things. Try to
23 * merge and/or what can be.
24 */
25
26
27 #ifdef HAVE_CONFIG_H
28 # include "config.h" /* for the gettext domain */
29 #endif
30
31 #include "ggd-file-type-loader.h"
32
33 #include <string.h>
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <fcntl.h>
37 #include <unistd.h>
38 #include <errno.h>
39 #include <glib.h>
40 #include <glib/gstdio.h>
41 #include <ctpl/ctpl.h>
42 #include <geanyplugin.h>
43
44 #include "ggd-doc-setting.h"
45 #include "ggd-doc-type.h"
46 #include "ggd-file-type.h"
47
48
49 /**
50 * ggd-file-type-loader:
51 *
52 * Loader for #GgdFileType, that provides ggd_file_type_load().
53 *
54 * File type is of the form:
55 *
56 * <code>
57 * string ::= ( """ .* """ | "'" .* "'" )
58 * constant ::= [_A-Z][_A-Z0-9]+
59 * integer ::= [0-9]+
60 * boolean ::= ( "True" | "False" )
61 * setting_value ::= ( string | constant | integer )
62 * setting ::= "setting-name" "=" setting_value ";"
63 * setting_list ::= ( "{" setting* "}" | setting )
64 * setting_section ::= "settings" "=" setting_list
65 *
66 * position ::= ( "BEFORE" | "AFTER" | "CURSOR" )
67 * policy ::= ( "KEEP" | "FORWARD" )
68 * children ::= ( "SPLIT" | "MERGE" )
69 * type ::= ( "class" | "enum" | "enumval" | "field" |
70 * "function" | "interface" | "member" | "method" |
71 * "namespace" | "package" | "prototype" | "struct" |
72 * "typedef" | "union" | "variable" | "extern" |
73 * "define" | "macro" | "file" )
74 * matches ::= type ( "|" type )*
75 * doctype_subsetting ::= ( "template" "=" string |
76 * "position" "=" position |
77 * "policy" "=" policy |
78 * "children" "=" children |
79 * "matches" "=" matches |
80 * "auto_doc_children" "=" boolean ) ";"
81 * match ::= type ( "." type )*
82 * doctype_setting ::= ( match "=" "{" doctype_subsetting* "}" |
83 * match "." doctype_subsetting )
84 * doctype_setting_list ::= ( "{" doctype_setting* "}" | doctype_setting )
85 * doctype ::= "doctype-name" "=" doctype_setting_list
86 * doctype_list ::= ( "{" doctype* "}" | doctype )
87 * doctype_section ::= "doctypes" "=" doctype_list
88 *
89 * document ::= ( setting_section? doctype_section? |
90 * doctype_section? setting_section? )
91 * </code>
92 */
93
94
95 /*< standard >*/
96 GQuark
97 ggd_file_type_load_error_quark (void)
98 {
99 static GQuark q = 0;
100
101 if (G_UNLIKELY (q == 0)) {
102 q = g_quark_from_static_string ("ggd-file-type-loader-error");
103 }
104
105 return q;
106 }
107
108 /* reads a boolean (True or False) */
109 static gboolean
110 ggd_file_type_read_boolean (GScanner *scanner,
111 gboolean *value_)
112 {
113 gboolean success = FALSE;
114
115 if (g_scanner_get_next_token (scanner) != G_TOKEN_IDENTIFIER) {
116 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
117 _("boolean value"), NULL, NULL, NULL, TRUE);
118 } else {
119 const gchar *bool_str = scanner->value.v_identifier;
120 gboolean value = FALSE;
121
122 success = TRUE;
123 if (strcmp (bool_str, "TRUE") == 0 ||
124 strcmp (bool_str, "True") == 0) {
125 value = TRUE;
126 } else if (strcmp (bool_str, "FALSE") == 0 ||
127 strcmp (bool_str, "False") == 0) {
128 value = FALSE;
129 } else {
130 g_scanner_error (scanner, _("invalid boolean value \"%s\""), bool_str);
131 success = FALSE;
132 }
133 if (success && value_) {
134 *value_ = value;
135 }
136 }
137
138 return success;
139 }
140
141 /* reads #GgdDocSetting:template */
142 static gboolean
143 ggd_file_type_read_setting_template (GScanner *scanner,
144 GgdDocSetting *setting)
145 {
146 gboolean success = FALSE;
147
148 if (g_scanner_get_next_token (scanner) != G_TOKEN_STRING) {
149 g_scanner_unexp_token (scanner, G_TOKEN_STRING,
150 NULL, NULL, NULL, NULL, TRUE);
151 } else {
152 GError *err = NULL;
153 CtplToken *tree;
154
155 tree = ctpl_lexer_lex_string (scanner->value.v_string, &err);
156 if (! tree) {
157 g_scanner_error (scanner, _("invalid template: %s"), err->message);
158 g_error_free (err);
159 } else {
160 ctpl_token_free (setting->template);
161 setting->template = tree;
162 success = TRUE;
163 }
164 }
165
166 return success;
167 }
168
169 /* reads #GgdDocSetting:position */
170 static gboolean
171 ggd_file_type_read_setting_position (GScanner *scanner,
172 GgdDocSetting *setting)
173 {
174 gboolean success = FALSE;
175
176 if (g_scanner_get_next_token (scanner) != G_TOKEN_IDENTIFIER) {
177 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
178 _("position name"), NULL, NULL, NULL, TRUE);
179 } else {
180 const gchar *pos_string = scanner->value.v_identifier;
181 GgdPosition pos;
182
183 pos = ggd_position_from_string (pos_string);
184 if ((gint)pos < 0) {
185 g_scanner_error (scanner, _("invalid position \"%s\""), pos_string);
186 } else {
187 setting->position = pos;
188 success = TRUE;
189 }
190 }
191
192 return success;
193 }
194
195 /* reads #GgdDocSetting:policy */
196 static gboolean
197 ggd_file_type_read_setting_policy (GScanner *scanner,
198 GgdDocSetting *setting)
199 {
200 gboolean success = FALSE;
201
202 if (g_scanner_get_next_token (scanner) != G_TOKEN_IDENTIFIER) {
203 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
204 _("policy name"), NULL, NULL, NULL, TRUE);
205 } else {
206 const gchar *policy_string = scanner->value.v_identifier;
207 GgdPolicy policy;
208
209 policy = ggd_policy_from_string (policy_string);
210 if ((gint)policy < 0) {
211 g_scanner_error (scanner, _("invalid policy \"%s\""), policy_string);
212 } else {
213 setting->policy = policy;
214 success = TRUE;
215 }
216 }
217
218 return success;
219 }
220
221 /* reads #GgdDocSetting:merge_children */
222 static gboolean
223 ggd_file_type_read_setting_children (GScanner *scanner,
224 GgdDocSetting *setting)
225 {
226 gboolean success = FALSE;
227
228 if (g_scanner_get_next_token (scanner) != G_TOKEN_IDENTIFIER) {
229 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
230 _("merge policy"), NULL, NULL, NULL, TRUE);
231 } else {
232 const gchar *merge_string = scanner->value.v_identifier;
233 gboolean merge;
234
235 merge = ggd_merge_policy_from_string (merge_string);
236 if ((gint)merge < 0) {
237 g_scanner_error (scanner, _("invalid merge policy \"%s\""), merge_string);
238 } else {
239 setting->merge_children = merge;
240 success = TRUE;
241 }
242 }
243
244 return success;
245 }
246
247 /* reads #GgdDocSetting:matches */
248 static gboolean
249 ggd_file_type_read_setting_matches (GScanner *scanner,
250 GgdDocSetting *setting)
251 {
252 gboolean success = FALSE;
253 TMTagType match = 0;
254
255 do {
256 success = FALSE;
257 if (g_scanner_get_next_token (scanner) != G_TOKEN_IDENTIFIER) {
258 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
259 _("type"), NULL, NULL, NULL, TRUE);
260 } else {
261 TMTagType type;
262 const gchar *match_string = scanner->value.v_identifier;
263
264 type = ggd_match_from_string (match_string);
265 if (! type) {
266 g_scanner_error (scanner, _("invalid type \"%s\""), match_string);
267 } else {
268 if (g_scanner_peek_next_token (scanner) == '|') {
269 g_scanner_get_next_token (scanner); /* eat it */
270 }
271 match |= type;
272 success = TRUE;
273 }
274 }
275 } while (success && g_scanner_peek_next_token (scanner) == G_TOKEN_IDENTIFIER);
276 if (success) {
277 setting->matches = match;
278 }
279
280 return success;
281 }
282
283 /* reads #GgdDocSetting:autodoc_children */
284 static gboolean
285 ggd_file_type_read_setting_auto_doc_children (GScanner *scanner,
286 GgdDocSetting *setting)
287 {
288 return ggd_file_type_read_boolean (scanner, &setting->autodoc_children);
289 }
290
291 /* dispatches read of value of doctype subsetting @name */
292 static gboolean
293 ggd_file_type_read_setting_value (GScanner *scanner,
294 const gchar *name,
295 GgdDocSetting *setting)
296 {
297 static const struct
298 {
299 const gchar *setting;
300 gboolean (*handler) (GScanner *scanner,
301 GgdDocSetting *setting);
302 } settings_table[] = {
303 { "template", ggd_file_type_read_setting_template },
304 { "position", ggd_file_type_read_setting_position },
305 { "policy", ggd_file_type_read_setting_policy },
306 { "children", ggd_file_type_read_setting_children },
307 { "matches", ggd_file_type_read_setting_matches },
308 { "auto_doc_children", ggd_file_type_read_setting_auto_doc_children }
309 };
310 gboolean success = FALSE;
311 gboolean found = FALSE;
312 guint i;
313
314 for (i = 0; ! found && i < G_N_ELEMENTS (settings_table); i++) {
315 if (strcmp (settings_table[i].setting, name) == 0) {
316 success = settings_table[i].handler (scanner, setting);
317 if (success) {
318 if (g_scanner_get_next_token (scanner) != ';') {
319 g_scanner_unexp_token (scanner, ';',
320 NULL, NULL, NULL, NULL, TRUE);
321 success = FALSE;
322 }
323 }
324 found = TRUE;
325 }
326 }
327 if (! found) {
328 g_scanner_error (scanner, _("invalid setting name \"%s\""), name);
329 success = FALSE;
330 }
331
332 return success;
333 }
334
335 static gboolean
336 ggd_file_type_read_setting (GScanner *scanner,
337 GgdDocSetting *setting)
338 {
339 gboolean success = TRUE;
340 gboolean multiple = FALSE;
341 GTokenType ttype;
342
343 do {
344 ttype = g_scanner_get_next_token (scanner);
345 switch (ttype) {
346 case G_TOKEN_LEFT_CURLY:
347 if (multiple) {
348 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
349 _("setting identifier"), NULL, NULL, NULL,
350 TRUE);
351 success = FALSE;
352 } else {
353 multiple = TRUE;
354 }
355 break;
356
357 case G_TOKEN_RIGHT_CURLY:
358 if (! multiple) {
359 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
360 _("setting identifier"), NULL, NULL, NULL,
361 TRUE);
362 success = FALSE;
363 }
364 break;
365
366 case G_TOKEN_IDENTIFIER: {
367 /* need to backup identifier as we call get_next_toekn() before using
368 * it */
369 gchar *identifier = g_strdup (scanner->value.v_identifier);
370
371 if (g_scanner_get_next_token (scanner) != G_TOKEN_EQUAL_SIGN) {
372 g_scanner_unexp_token (scanner, G_TOKEN_EQUAL_SIGN,
373 NULL, NULL, NULL, NULL, TRUE);
374 success = FALSE;
375 } else {
376 success = ggd_file_type_read_setting_value (scanner, identifier,
377 setting);
378 }
379 g_free (identifier);
380 break;
381 }
382
383 default:
384 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
385 _("setting identifier"), NULL, NULL, NULL, TRUE);
386 success = FALSE;
387 }
388 } while (success && multiple && ttype != G_TOKEN_RIGHT_CURLY);
389
390 return success;
391 }
392
393 static gchar *
394 ggd_file_type_read_match (GScanner *scanner,
395 gchar **setting)
396 {
397 GString *match_str;
398 gchar *match = NULL;
399 gboolean done = FALSE;
400 gboolean success = TRUE;
401
402 match_str = g_string_new (NULL);
403 do {
404 switch (g_scanner_get_next_token (scanner)) {
405 case G_TOKEN_IDENTIFIER: {
406 gchar *identifier;
407 gboolean is_setting_name = FALSE;
408
409 identifier = g_strdup (scanner->value.v_identifier);
410 /*g_debug ("identifier is %s", identifier);*/
411 switch ((guint) g_scanner_get_next_token (scanner)) {
412 case '.': /* skip it */ break;
413
414 case G_TOKEN_EQUAL_SIGN:
415 /* just stop here, we're done */
416 done = TRUE;
417 is_setting_name = g_scanner_peek_next_token (scanner) != G_TOKEN_LEFT_CURLY;
418 break;
419
420 default:
421 g_scanner_unexp_token (scanner, G_TOKEN_EQUAL_SIGN,
422 NULL, NULL, NULL, NULL, TRUE);
423 success = FALSE;
424 }
425 if (success) {
426 if (is_setting_name) {
427 *setting = g_strdup (identifier);
428 } else {
429 if (! ggd_match_from_string (identifier)) {
430 g_scanner_warn (scanner,
431 _("Unknown type \"%s\", is it a typo?"),
432 identifier);
433 }
434 if (match_str->len > 0) {
435 g_string_append_c (match_str, '.');
436 }
437 g_string_append (match_str, identifier);
438 }
439 }
440 g_free (identifier);
441 break;
442 }
443
444 default:
445 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
446 _("match identifier"), NULL, NULL, NULL, TRUE);
447 success = FALSE;
448 }
449 } while (success && ! done);
450 if (success && match_str->str && *match_str->str) {
451 match = g_string_free (match_str, FALSE);
452 } else {
453 if (success) {
454 g_scanner_error (scanner, _("match identifier is empty"));
455 }
456 g_string_free (match_str, TRUE);
457 success = FALSE;
458 }
459
460 return match;
461 }
462
463 static GgdDocType *
464 ggd_file_type_read_doctype (GScanner *scanner)
465 {
466 gboolean success = FALSE;
467 GgdDocType *doctype = NULL;
468 gboolean multiple = FALSE;
469
470 if (g_scanner_get_next_token (scanner) != G_TOKEN_IDENTIFIER) {
471 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
472 _("documentation type identifier"), NULL, NULL, NULL,
473 TRUE);
474 } else {
475 doctype = ggd_doc_type_new (scanner->value.v_identifier);
476 if (g_scanner_get_next_token (scanner) != G_TOKEN_EQUAL_SIGN) {
477 g_scanner_unexp_token (scanner, G_TOKEN_EQUAL_SIGN,
478 NULL, NULL, NULL, NULL, TRUE);
479 } else {
480 GTokenType ttype;
481
482 success = TRUE;
483 do {
484 ttype = g_scanner_peek_next_token (scanner);
485 switch (ttype) {
486 case G_TOKEN_LEFT_CURLY:
487 g_scanner_get_next_token (scanner); /* eat it */
488 if (multiple) {
489 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
490 _("match identifier"), NULL, NULL, NULL,
491 TRUE);
492 success = FALSE;
493 } else {
494 multiple = TRUE;
495 }
496 break;
497
498 case G_TOKEN_RIGHT_CURLY:
499 g_scanner_get_next_token (scanner); /* eat it */
500 if (! multiple) {
501 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
502 _("match identifier"), NULL, NULL, NULL,
503 TRUE);
504 success = FALSE;
505 }
506 break;
507
508 case G_TOKEN_IDENTIFIER: {
509 gchar *match;
510 gchar *setting_name = NULL;
511
512 match = ggd_file_type_read_match (scanner, &setting_name);
513 if (! match || ! *match) {
514 success = FALSE;
515 } else {
516 GgdDocSetting *setting;
517
518 setting = ggd_doc_setting_new (match);
519 if (setting_name) {
520 success = ggd_file_type_read_setting_value (scanner,
521 setting_name,
522 setting);
523 } else {
524 success = ggd_file_type_read_setting (scanner, setting);
525 }
526 if (! success) {
527 ggd_doc_setting_unref (setting);
528 } else {
529 doctype->settings = g_list_append (doctype->settings, setting);
530 }
531 }
532 g_free (match);
533 g_free (setting_name);
534 break;
535 }
536
537 default:
538 g_scanner_get_next_token (scanner); /* eat it */
539 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
540 _("match identifier"), NULL, NULL, NULL,
541 TRUE);
542 success = FALSE;
543 }
544 } while (success && multiple && ttype != G_TOKEN_RIGHT_CURLY);
545 }
546 if (! success) {
547 ggd_doc_type_unref (doctype);
548 doctype = NULL;
549 }
550 }
551
552 return doctype;
553 }
554
555 static gboolean
556 ggd_file_type_read_doctypes (GScanner *scanner,
557 GgdFileType *filetype)
558 {
559 gboolean success = FALSE;
560 gboolean multiple = FALSE;
561
562 if (g_scanner_get_next_token (scanner) != G_TOKEN_EQUAL_SIGN) {
563 g_scanner_unexp_token (scanner, G_TOKEN_EQUAL_SIGN,
564 NULL, NULL, NULL, NULL, TRUE);
565 } else {
566 GTokenType ttype;
567
568 success = TRUE;
569 do {
570 ttype = g_scanner_peek_next_token (scanner);
571 switch (ttype) {
572 case G_TOKEN_LEFT_CURLY:
573 g_scanner_get_next_token (scanner); /* eat it */
574 if (multiple) {
575 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
576 _("documentation type"), NULL, NULL, NULL,
577 TRUE);
578 success = FALSE;
579 } else {
580 multiple = TRUE;
581 }
582 break;
583
584 case G_TOKEN_RIGHT_CURLY:
585 g_scanner_get_next_token (scanner); /* eat it */
586 if (! multiple) {
587 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
588 _("documentation type"), NULL, NULL, NULL,
589 TRUE);
590 success = FALSE;
591 }
592 break;
593
594 case G_TOKEN_IDENTIFIER: {
595 GgdDocType *doctype;
596
597 doctype = ggd_file_type_read_doctype (scanner);
598 if (! doctype) {
599 success = FALSE;
600 } else {
601 ggd_file_type_add_doc (filetype, doctype);
602 ggd_doc_type_unref (doctype);
603 }
604 break;
605 }
606
607 default:
608 g_scanner_get_next_token (scanner); /* eat it */
609 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
610 _("documentation type"), NULL, NULL, NULL,
611 TRUE);
612 success = FALSE;
613 }
614 } while (success && multiple && ttype != G_TOKEN_RIGHT_CURLY);
615 }
616
617 return success;
618 }
619
620 static GRegex *
621 ggd_file_type_read_setting_regex (GScanner *scanner,
622 const gchar *name)
623 {
624 GRegex *regex = NULL;
625
626 if (g_scanner_get_next_token (scanner) != G_TOKEN_IDENTIFIER ||
627 strcmp (scanner->value.v_identifier, name) != 0) {
628 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
629 name, NULL, NULL, NULL, TRUE);
630 } else {
631 if (g_scanner_get_next_token (scanner) != G_TOKEN_EQUAL_SIGN) {
632 g_scanner_unexp_token (scanner, G_TOKEN_EQUAL_SIGN,
633 NULL, NULL, NULL, NULL, TRUE);
634 } else {
635 if (g_scanner_get_next_token (scanner) != G_TOKEN_STRING) {
636 g_scanner_unexp_token (scanner, G_TOKEN_EQUAL_SIGN,
637 NULL, NULL, NULL, NULL, TRUE);
638 } else {
639 const gchar *pattern = scanner->value.v_string;
640 GError *err = NULL;
641
642 /*g_debug ("building RE \"%s\"", pattern);*/
643 regex = g_regex_new (pattern, G_REGEX_OPTIMIZE, 0, &err);
644 if (! regex) {
645 g_scanner_error (scanner, _("invalid regular expression: %s"),
646 err->message);
647 g_error_free (err);
648 } else {
649 if (g_scanner_get_next_token (scanner) != ';') {
650 g_scanner_unexp_token (scanner, ';', NULL, NULL, NULL, NULL, TRUE);
651 g_regex_unref (regex);
652 regex = NULL;
653 }
654 }
655 }
656 }
657 }
658
659 return regex;
660 }
661
662 static gboolean
663 ggd_file_type_read_setting_match_function_arguments (GScanner *scanner,
664 const gchar *setting_name,
665 GgdFileType *filetype)
666 {
667 gboolean success = FALSE;
668 GRegex *regex;
669
670 regex = ggd_file_type_read_setting_regex (scanner, setting_name);
671 if (regex) {
672 if (filetype->match_function_arguments) {
673 g_regex_unref (filetype->match_function_arguments);
674 }
675 filetype->match_function_arguments = regex;
676 success = TRUE;
677 }
678
679 return success;
680 }
681
682 static gboolean
683 ggd_file_type_read_setting_user_environ (GScanner *scanner,
684 const gchar *setting_name,
685 GgdFileType *filetype)
686 {
687 gboolean success = FALSE;
688
689 g_scanner_get_next_token (scanner); /* eat setting identifier */
690 if (g_scanner_get_next_token (scanner) != G_TOKEN_EQUAL_SIGN) {
691 g_scanner_unexp_token (scanner, G_TOKEN_EQUAL_SIGN,
692 NULL, NULL, NULL, NULL, TRUE);
693 } else {
694 if (g_scanner_get_next_token (scanner) != G_TOKEN_STRING) {
695 g_scanner_unexp_token (scanner, G_TOKEN_STRING,
696 NULL, NULL, NULL, NULL, TRUE);
697 } else {
698 GError *err = NULL;
699
700 if (! ctpl_environ_add_from_string (filetype->user_env,
701 scanner->value.v_string, &err)) {
702 g_scanner_error (scanner, _("invalid environment description: %s"),
703 err->message);
704 g_error_free (err);
705 } else {
706 if (g_scanner_get_next_token (scanner) != ';') {
707 g_scanner_unexp_token (scanner, ';', NULL, NULL, NULL, NULL, TRUE);
708 } else {
709 success = TRUE;
710 }
711 }
712 }
713 }
714
715 return success;
716 }
717
718 static gboolean
719 ggd_file_type_read_settings (GScanner *scanner,
720 GgdFileType *filetype)
721 {
722 gboolean success = FALSE;
723 gboolean multiple = FALSE;
724
725 if (g_scanner_get_next_token (scanner) != G_TOKEN_EQUAL_SIGN) {
726 g_scanner_unexp_token (scanner, G_TOKEN_EQUAL_SIGN,
727 NULL, NULL, NULL, NULL, TRUE);
728 } else {
729 GTokenType ttype;
730
731 success = TRUE;
732 do {
733 ttype = g_scanner_peek_next_token (scanner);
734 switch (ttype) {
735 case G_TOKEN_LEFT_CURLY:
736 g_scanner_get_next_token (scanner); /* eat it */
737 if (multiple) {
738 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
739 _("setting"), NULL, NULL, NULL,TRUE);
740 success = FALSE;
741 } else {
742 multiple = TRUE;
743 }
744 break;
745
746 case G_TOKEN_RIGHT_CURLY:
747 g_scanner_get_next_token (scanner); /* eat it */
748 if (! multiple) {
749 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
750 _("setting"), NULL, NULL, NULL,TRUE);
751 success = FALSE;
752 }
753 break;
754
755 case G_TOKEN_IDENTIFIER: {
756 static const struct
757 {
758 const gchar *setting;
759 gboolean (*handler) (GScanner *scanner,
760 const gchar *setting_name,
761 GgdFileType *filetype);
762 } settings_handlers[] = {
763 { "match_function_arguments",
764 ggd_file_type_read_setting_match_function_arguments },
765 { "global_environment",
766 ggd_file_type_read_setting_user_environ }
767 };
768 const gchar *setting = scanner->next_value.v_identifier;
769 gboolean found = FALSE;
770 guint i;
771
772 for (i = 0; ! found && i < G_N_ELEMENTS (settings_handlers); i++) {
773 if (strcmp (settings_handlers[i].setting, setting) == 0) {
774 success = settings_handlers[i].handler (scanner, setting, filetype);
775 found = TRUE;
776 }
777 }
778 if (! found) {
779 g_scanner_error (scanner, _("invalid setting name \"%s\""),
780 setting);
781 success = FALSE;
782 }
783 break;
784 }
785
786 default:
787 g_scanner_get_next_token (scanner); /* eat it */
788 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
789 _("setting"), NULL, NULL, NULL, TRUE);
790 success = FALSE;
791 }
792 } while (success && multiple && ttype != G_TOKEN_RIGHT_CURLY);
793 }
794
795 return success;
796 }
797
798 static gboolean
799 ggd_file_type_read (GScanner *scanner,
800 GgdFileType *filetype)
801 {
802 static const struct
803 {
804 const gchar *section;
805 gboolean (*handler) (GScanner *scanner,
806 GgdFileType *filetype);
807 } section_handlers[] = {
808 { "settings", ggd_file_type_read_settings },
809 { "doctypes", ggd_file_type_read_doctypes }
810 };
811 gboolean read_sections[G_N_ELEMENTS (section_handlers)] = { 0 };
812 gboolean success = TRUE;
813
814 while (success && g_scanner_peek_next_token (scanner) != G_TOKEN_EOF) {
815 if (g_scanner_get_next_token (scanner) != G_TOKEN_IDENTIFIER) {
816 g_scanner_unexp_token (scanner, G_TOKEN_IDENTIFIER,
817 _("section name"), NULL, NULL, NULL, TRUE);
818 success = FALSE;
819 } else {
820 const gchar *section = scanner->value.v_identifier;
821 gboolean found = FALSE;
822 guint i;
823
824 for (i = 0; ! found && i < G_N_ELEMENTS (section_handlers); i++) {
825 if (strcmp (section, section_handlers[i].section) == 0) {
826 found = TRUE;
827 if (read_sections[i]) {
828 g_scanner_error (scanner, _("duplicated section \"%s\""), section);
829 success = FALSE;
830 } else {
831 success = section_handlers[i].handler (scanner, filetype);
832 read_sections[i] = TRUE;
833 }
834 }
835 }
836 if (! found) {
837 g_scanner_error (scanner, _("invalid section name \"%s\""), section);
838 success = FALSE;
839 }
840 }
841 }
842 if (success) {
843 gboolean none_read = TRUE;
844 guint i;
845
846 for (i = 0; none_read && i < G_N_ELEMENTS (read_sections); i++) {
847 none_read = ! read_sections[i];
848 }
849 if (none_read) {
850 g_scanner_warn (scanner, _("input is empty"));
851 }
852 }
853
854 return success;
855 }
856
857
858 static void
859 scanner_msg_handler (GScanner *scanner,
860 gchar *message,
861 gboolean error)
862 {
863 if (! error) {
864 g_warning (_("Parser warning: %s:%u:%u: %s"),
865 scanner->input_name, scanner->line, scanner->position, message);
866 } else {
867 g_critical (_("Parser error: %s:%u:%u: %s"),
868 scanner->input_name, scanner->line, scanner->position, message);
869 g_set_error (scanner->user_data,
870 GGD_FILE_TYPE_LOAD_ERROR, GGD_FILE_TYPE_LOAD_ERROR_PARSE,
871 _("%s:%u:%u: %s"),
872 scanner->input_name, scanner->line, scanner->position, message);
873 }
874 }
875
876 #if 0
877 static GList *
878 ggd_conf_read (GScanner *scanner)
879 {
880 gboolean success = TRUE;
881 GList *doctypes = NULL;
882
883 while (success && g_scanner_peek_next_token (scanner) != G_TOKEN_EOF) {
884 GgdDocType *doctype;
885
886 doctype = ggd_conf_read_doctype (scanner);
887 if (! doctype) {
888 success = FALSE;
889 } else {
890 doctypes = g_list_prepend (doctypes, doctype);
891 }
892 }
893 if (! success) {
894 while (doctypes) {
895 GList *tmp = doctypes;
896
897 doctypes = g_list_next (doctypes);
898 ggd_doc_type_unref (tmp->data);
899 g_list_free_1 (tmp);
900 }
901 } else if (! doctypes) {
902 g_scanner_warn (scanner, _("input is empty"));
903 }
904
905 return doctypes;
906 }
907
908 /**
909 * ggd_conf_load:
910 * @file: input file
911 * @error: return location for errors, or %NULL to ignore errors
912 *
913 *
914 * Returns: The list of loaded #GgdDocType<!-- -->s. Note that %NULL can be
915 * returned without failure if input is empty (or contains only
916 * comments). Thus, you should use @error to differentiate failure and
917 * empty input.
918 */
919 GList *
920 ggd_conf_load (const gchar *file,
921 GError **error)
922 {
923 GList *list = NULL;
924 gint fd;
925
926 fd = g_open (file, O_RDONLY, 0);
927 if (fd < 0) {
928 gint errnum = errno;
929
930 g_set_error (error, GGD_FILE_TYPE_LOAD_ERROR, GGD_FILE_TYPE_LOAD_ERROR_READ,
931 "%s", g_strerror (errnum));
932 } else {
933 GScanner *scanner;
934 gchar *filename;
935
936 filename = g_filename_display_name (file);
937 scanner = g_scanner_new (NULL);
938 scanner->config->scan_float = FALSE; /* disable float scanning since it
939 * prevent dot to be usable alone */
940 scanner->input_name = filename;
941 scanner->user_data = error;
942 scanner->msg_handler = scanner_msg_handler;
943 g_scanner_input_file (scanner, fd);
944 list = ggd_conf_read (scanner);
945 g_scanner_destroy (scanner);
946 g_free (filename);
947 close (fd);
948 }
949
950 return list;
951 }
952 #else
953
954 /**
955 * ggd_file_type_load:
956 * @filetype: A #GgdFileType to fill with read settings
957 * @file: a file from which load the settings, in the GLib file names encoding
958 * @error: Return location for errors, or %NULL to ignore them
959 *
960 * Tries to load a file type configuration from a file.
961 *
962 * <warning>
963 * Even if the loading failed, the filetype object may have been partially
964 * or completely filled with read settings.
965 * </warning>
966 *
967 * Returns: %TRUE on success, %FALSE otherwise in which case @error contains the
968 * error.
969 */
970 gboolean
971 ggd_file_type_load (GgdFileType *filetype,
972 const gchar *file,
973 GError **error)
974 {
975 gboolean success = FALSE;
976 gint fd;
977
978 fd = g_open (file, O_RDONLY, 0);
979 if (fd < 0) {
980 gint errnum = errno;
981
982 g_set_error (error, GGD_FILE_TYPE_LOAD_ERROR, GGD_FILE_TYPE_LOAD_ERROR_READ,
983 "%s", g_strerror (errnum));
984 } else {
985 GScanner *scanner;
986 gchar *filename;
987
988 filename = g_filename_display_name (file);
989 scanner = g_scanner_new (NULL);
990 scanner->config->scan_float = FALSE; /* disable float scanning since it
991 * prevent dot to be usable alone */
992 scanner->input_name = filename;
993 scanner->user_data = error;
994 scanner->msg_handler = scanner_msg_handler;
995 g_scanner_input_file (scanner, fd);
996 success = ggd_file_type_read (scanner, filetype);
997 g_scanner_destroy (scanner);
998 g_free (filename);
999 close (fd);
1000 }
1001
1002 return success;
1003 }
1004
1005 #endif