]> git.ipfire.org Git - thirdparty/vala.git/commitdiff
libvaladoc: importer: drop gir support
authorFlorian Brosch <flo.brosch@gmail.com>
Thu, 28 Jul 2011 11:08:16 +0000 (13:08 +0200)
committerFlorian Brosch <flo.brosch@gmail.com>
Fri, 29 Jul 2011 00:45:26 +0000 (02:45 +0200)
src/libvaladoc/Makefile.am
src/libvaladoc/documentation/documentationparser.vala
src/libvaladoc/documentation/girdocumentationscanner.vala [deleted file]
src/libvaladoc/importer/gircomment.vala [deleted file]
src/libvaladoc/importer/girdocumentationimporter.vala [deleted file]
src/libvaladoc/parser/tokentype.vala
src/valadoc/valadoc.vala

index 2bccc57d5db67f330a87d766d22f3456bcb28a65..4b925914d2fa977b6df5984f2b82cf0e1f4fb327 100755 (executable)
@@ -31,15 +31,12 @@ libvaladoc_la_VALASOURCES = \
        markupsourcelocation.vala \
        markuptokentype.vala \
        markupreader.vala \
-       documentation/girdocumentationscanner.vala \
        documentation/commentscanner.vala \
        documentation/documentation.vala \
        documentation/documentationparser.vala \
        documentation/wiki.vala \
        documentation/wikiscanner.vala \
-       importer/girdocumentationimporter.vala \
        importer/documentationimporter.vala \
-       importer/gircomment.vala \
        importer/valadocdocumentationimporter.vala \
        importer/valadocdocumentationimporterscanner.vala \
        api/symbolaccessibility.vala \
index 5a08227f562039139ac051f6e44b435947d5c7ff..ddafabcd3555ee1255a42819f91c762193450993 100755 (executable)
@@ -43,16 +43,7 @@ public class Valadoc.DocumentationParser : Object, ResourceLocator {
                _comment_parser = new Parser (_settings, _comment_scanner, _reporter);
                _comment_scanner.set_parser (_comment_parser);
 
-               _gir_scanner = new GirDocumentationScanner (_settings);
-               _gir_parser = new Parser (_settings, _gir_scanner, _reporter);
-               _gir_scanner.set_parser (_gir_parser);
-
-               _gir_taglet_scanner = new GirDocumentationScanner (_settings);
-               _gir_taglet_parser = new Parser (_settings, _gir_taglet_scanner, _reporter);
-               _gir_taglet_scanner.set_parser (_gir_taglet_parser);
-
                init_valadoc_rules ();
-               init_girdoc_rules ();
        }
 
        private Settings _settings;
@@ -61,12 +52,8 @@ public class Valadoc.DocumentationParser : Object, ResourceLocator {
        private ModuleLoader _modules;
 
        private ContentFactory _factory;
-       private GirDocumentationScanner _gir_taglet_scanner;
-       private GirDocumentationScanner _gir_scanner;
        private WikiScanner _wiki_scanner;
        private CommentScanner _comment_scanner;
-       private Parser _gir_parser;
-       private Parser _gir_taglet_parser;
        private Parser _wiki_parser;
        private Parser _comment_parser;
        
@@ -87,48 +74,6 @@ public class Valadoc.DocumentationParser : Object, ResourceLocator {
                }
        }
 
-       public Comment? parse_gir_comment (Api.Node element, GirComment doc) {
-               try {
-                       _stack.clear ();
-
-                       if (doc.content != null) {
-                               _parser = _gir_parser;
-                               _scanner = _gir_scanner;
-                               _gir_parser.parse (doc.content, doc.file.get_name (), doc.first_line, doc.first_column);
-                       } else {
-                               push (_factory.create_comment ());
-                       }
-
-
-                       _parser = _gir_taglet_parser;
-                       _scanner = _gir_taglet_scanner;
-
-                       if (doc.return_value != null && !(element is Api.Method && ((Api.Method) element).is_constructor)) {
-                               push (_factory.create_taglet ("return"));
-                               _gir_taglet_parser.parse (doc.return_value.content, doc.return_value.file.get_name (), doc.return_value.first_line, doc.return_value.first_column);
-                       }
-
-                       var iter = doc.parameters.map_iterator ();
-                       for (iter.next (); iter.has_next (); iter.next ()) {
-                               var val = iter.get_value ();
-                               var key = iter.get_key ();
-                               if (key != "self") {
-                                       var param = _factory.create_taglet ("param") as Taglets.Param;
-                                       param.parameter_name = key;
-                                       push (param);
-                                       _gir_taglet_parser.parse (val.content, val.file.get_name (), val.first_line, val.first_column);
-                               }
-                       }
-
-                       var doc_comment = (Comment) pop ();
-                       doc_comment.check (_tree, element, _reporter, _settings);
-
-                       return doc_comment;
-               } catch (ParserError error) {
-                       return null;
-               }
-       }
-
        public Page? parse_wikipage (WikiPage page, Api.Package pkg) {
                if (page.documentation != null) {
                        return page.documentation;
@@ -293,520 +238,6 @@ public class Valadoc.DocumentationParser : Object, ResourceLocator {
                }
        }
 
-       private void gir_append_link (Token token) throws ParserError {
-               var taglet = _factory.create_taglet ("link") as Taglets.Link;
-               if (!(taglet is Inline)) {
-                       _parser.error (null, "Invalid taglet in this context: link");
-               }
-               taglet.symbol_name = "c::"+token.to_string ();
-               push (taglet);
-       }
-
-       private bool _gir_is_first_paragraph = true;
-
-       private void init_girdoc_rules () {
-               StubRule run = new StubRule ();
-               run.set_name ("Run");
-
-               TokenType.Action add_text = (token) => {
-                       add_content_string (token.to_string ());
-               };
-
-               TokenType dot = TokenType.GTKDOC_DOT.action ((token) => { add_content_string ("."); });
-               TokenType word = TokenType.GTKDOC_ANY_WORD.action (add_text);
-               TokenType space = TokenType.GTKDOC_SPACE.action (add_text);
-               TokenType newline = TokenType.GTKDOC_EOL.action ((token) => { add_content_string (" "); });
-               Rule unprinted_space = Rule.one_of ({ space.action ((token) => {}), newline.action ((token) => {}) });
-               Rule unprinted_spaces = Rule.many ({ unprinted_space });
-               Rule optional_unprinted_spaces = Rule.option ({ unprinted_spaces });
-
-               Rule raw_text = Rule.many ({
-                       Rule.one_of ({
-                               word, space, newline, dot
-                       })
-                       .set_reduce (() => {
-                               var head = (Inline) pop ();
-                               ((InlineContent) peek ()).content.add (head);
-                       })
-               })
-               .set_name ("RawText");
-
-               Rule run_with_dot = Rule.many ({
-                       Rule.one_of ({
-                               run, dot
-                       })
-                       .set_reduce (() => {
-                               var head = (Inline) pop ();
-                               ((InlineContent) peek ()).content.add (head);
-                       })
-               })
-               .set_name ("FormatedText");
-
-               Rule xml_comment_raw = Rule.seq ({
-                       TokenType.GTKDOC_XML_COMMENT_START,
-                       Rule.option ({
-                               Rule.many ({
-                                       Rule.one_of ({
-                                               word.action ((token) => {}),
-                                               space.action ((token) => {}),
-                                               newline.action ((token) => {}),
-                                               dot.action ((token) => {})
-                                               //TODO
-                                       })
-                               })
-                       }),
-                       TokenType.GTKDOC_XML_COMMENT_END
-               });
-               
-
-               Rule xml_comment = Rule.seq ({
-                       xml_comment_raw
-               })
-               .set_name ("XmlComment")
-               .set_start (() => { push (_factory.create_text ("")); });
-
-
-               Rule word_or_function = Rule.seq ({
-                       TokenType.GTKDOC_ANY_WORD.action ((token) => { push (token); }),
-                       Rule.option ({
-                               Rule.many ({
-                                       Rule.one_of ({
-                                               space.action ((token) => {
-                                                       if (((Token) peek ()).is_word) {
-                                                               push (token);
-                                                       }
-                                               }),
-                                               xml_comment_raw
-                                       })
-                               })
-                       }),
-                       Rule.option ({
-                               TokenType.GTKDOC_FUNCTION_BRACKETS.action ((token) => {
-                                       var last_token = (Token) pop ();
-                                       if (!last_token.is_word) {
-                                               last_token = (Token) pop ();
-                                       }
-
-                                       gir_append_link (last_token);
-                               })
-                       }).set_skip (() => {
-                               var last_token = (Token) pop ();
-                               if (last_token.is_word) {
-                                       add_content_string (last_token.to_string ());
-                               } else {
-                                       add_content_string (((Token) pop ()).to_string ());
-                                       add_content_string (last_token.to_string ());
-                               }
-                       })
-               });
-
-               Rule node_link = Rule.one_of ({
-                       Rule.seq ({
-                               TokenType.GTKDOC_SYMBOL,
-                               word.action ((token) => {
-                                       switch (token.to_string ()) {
-                                       case "FALSE":
-                                       case "TRUE":
-                                       case "NULL":
-                                               var myrun = _factory.create_run (Run.Style.MONOSPACED);
-                                               var mytext = _factory.create_text ();
-                                               mytext.content = token.to_string ().down ();
-                                               myrun.content.add (mytext);
-                                               push (myrun);
-                                               break;
-
-                                       default:
-                                               gir_append_link (token);
-                                               break;
-                                       }
-                               })
-                       })
-               })
-               .set_name ("TypeLink");
-
-               Rule link_element = Rule.seq ({
-                       TokenType.GTKDOC_LINK_ELEMENT_OPEN,
-                       run_with_dot,
-                       TokenType.GTKDOC_LINK_ELEMENT_CLOSE
-               })
-               .set_name ("Link")
-               .set_start (() => { push (_factory.create_run (Run.Style.NONE)); });
-
-               Rule filename_element = Rule.seq ({
-                       TokenType.GTKDOC_FILENAME_ELEMENT_OPEN,
-                       raw_text,
-                       TokenType.GTKDOC_FILENAME_ELEMENT_CLOSE
-               })
-               .set_name ("Filename")
-               .set_start (() => { push (_factory.create_run (Run.Style.MONOSPACED)); });
-
-               Rule envar_element = Rule.seq ({
-                       TokenType.GTKDOC_ENVAR_ELEMENT_OPEN,
-                       run_with_dot,
-                       TokenType.GTKDOC_ENVAR_ELEMENT_CLOSE
-               })
-               .set_name ("Envar")
-               .set_start (() => { push (_factory.create_run (Run.Style.MONOSPACED)); });
-
-               Rule emphasis_element = Rule.seq ({
-                       TokenType.GTKDOC_EMPHASIS_ELEMENT_OPEN,
-                       run_with_dot,
-                       TokenType.GTKDOC_EMPHASIS_ELEMENT_CLOSE
-               })
-               .set_name ("Emphasis")
-               .set_start (() => { push (_factory.create_run (Run.Style.ITALIC)); });
-
-               Rule option_element = Rule.seq ({
-                       TokenType.GTKDOC_OPTION_ELEMENT_OPEN,
-                       run_with_dot,
-                       TokenType.GTKDOC_OPTION_ELEMENT_CLOSE
-               })
-               .set_name ("Option")
-               .set_start (() => { push (_factory.create_run (Run.Style.MONOSPACED)); });
-
-               Rule term_element = Rule.seq ({
-                       TokenType.GTKDOC_TERM_ELEMENT_OPEN,
-                       run_with_dot,
-                       TokenType.GTKDOC_TERM_ELEMENT_CLOSE
-               })
-               .set_name ("Term")
-               .set_start (() => { push (_factory.create_run (Run.Style.MONOSPACED)); });
-
-               Rule literal_element = Rule.seq ({
-                       TokenType.GTKDOC_LITERAL_ELEMENT_OPEN,
-                       run_with_dot,
-                       TokenType.GTKDOC_LITERAL_ELEMENT_CLOSE
-               })
-               .set_name ("Literal")
-               .set_start (() => { push (_factory.create_run (Run.Style.MONOSPACED)); });
-
-               Rule replaceable_element = Rule.seq ({
-                       TokenType.GTKDOC_REPLACEABLE_ELEMENT_OPEN,
-                       raw_text,
-                       TokenType.GTKDOC_REPLACEABLE_ELEMENT_CLOSE
-               })
-               .set_name ("Replaceable")
-               .set_start (() => { push (_factory.create_run (Run.Style.MONOSPACED)); });
-
-               Rule guimenuitem_element = Rule.seq ({
-                       TokenType.GTKDOC_GUI_MENU_ITEM_ELEMENT_OPEN,
-                       raw_text,
-                       TokenType.GTKDOC_GUI_MENU_ITEM_ELEMENT_CLOSE
-               })
-               .set_name ("GuiMenuItem")
-               .set_start (() => { push (_factory.create_run (Run.Style.MONOSPACED)); });
-
-               Rule struct_name_element = Rule.seq ({
-                       TokenType.GTKDOC_STRUCTNAME_ELEMENT_OPEN,
-                       word.action ((token) => {
-                               gir_append_link (token);
-                       }),
-                       TokenType.GTKDOC_STRUCTNAME_ELEMENT_CLOSE
-               })
-               .set_name ("Structname");
-
-               Rule param = Rule.one_of ({
-                       Rule.seq ({
-                               TokenType.GTKDOC_PARAM,
-                               word
-                       })
-               })
-               .set_name ("Parameter")
-               .set_start (() => { push (_factory.create_run (Run.Style.MONOSPACED)); })
-               .set_reduce (() => {
-                       var head = (Inline) pop ();
-                       ((InlineContent) peek ()).content.add (head);
-               });
-
-               run.set_rule (
-                       Rule.many ({
-                               Rule.one_of ({
-                                       newline, space, word_or_function, node_link, param, struct_name_element, link_element, xml_comment,
-                                       literal_element, guimenuitem_element, replaceable_element, envar_element, emphasis_element,
-                                       option_element,  term_element, filename_element
-                               })
-                       })
-                       .set_name ("Run")
-               );
-
-               Rule paragraph_element = Rule.seq ({
-                       TokenType.GTKDOC_PARA_ELEMENT_OPEN,
-                       run_with_dot,
-                       TokenType.GTKDOC_PARA_ELEMENT_CLOSE,
-                       Rule.option ({
-                               Rule.many({
-                                       Rule.one_of ({
-                                               space.action ((token) => {}),
-                                               newline.action ((token) => {})
-                                       })
-                               })
-                       })
-               })
-               .set_name ("ParagraphElement")
-               .set_start (() => { push (_factory.create_paragraph ()); })
-               .set_reduce (() => {
-                       var head = (Block) pop ();
-                       ((BlockContent) peek ()).content.add (head);
-               });
-
-               Rule source = Rule.seq ({
-                       TokenType.GTKDOC_SOURCE_OPEN.action ((token) => { ((GirDocumentationScanner) _scanner).set_code_escape_mode (true); }),
-                       Rule.many ({
-                               word.action ((token) => { ((SourceCode) peek ()).code = token.to_string (); })
-                       })
-                       .set_start (() => { push (_factory.create_source_code ()); })
-                       .set_reduce (() => {
-                               var head = (Inline) pop ();
-                               ((Paragraph) peek ()).content.add (head);
-                       }),
-                       TokenType.GTKDOC_SOURCE_CLOSE.action ((token) => { ((GirDocumentationScanner) _scanner).set_code_escape_mode (false); }),
-                       optional_unprinted_spaces
-               })
-               .set_name ("Source")
-               .set_start (() => { push (_factory.create_paragraph ()); })
-               .set_reduce (() => {
-                       var head = (Block) pop ();
-                       ((BlockContent) peek ()).content.add (head);
-               });
-
-               Rule program_listing_element = Rule.seq ({
-                       TokenType.GTKDOC_PROGRAMLISTING_ELEMENT_OPEN.action ((token) => { ((GirDocumentationScanner) _scanner).set_code_element_escape_mode (true); }),
-                       Rule.many ({
-                               word.action ((token) => { ((SourceCode) peek ()).code = token.to_string (); })
-                       })
-                       .set_start (() => { push (_factory.create_source_code ()); })
-                       .set_reduce (() => {
-                               var head = (Inline) pop ();
-                               ((Paragraph) peek ()).content.add (head);
-                       }),
-                       TokenType.GTKDOC_PROGRAMLISTING_ELEMENT_CLOSE.action ((token) => { ((GirDocumentationScanner) _scanner).set_code_element_escape_mode (false); }),
-                       optional_unprinted_spaces
-               })
-               .set_name ("ProgramListing")
-               .set_start (() => { push (_factory.create_paragraph ()); })
-               .set_reduce (() => {
-                       var head = (Block) pop ();
-                       ((BlockContent) peek ()).content.add (head);
-               });
-
-               Rule example_element = Rule.seq ({
-                       Rule.one_of ({
-                               program_listing_element,
-                               Rule.seq ({
-                                       TokenType.GTKDOC_EXAMPLE_ELEMENT_OPEN,
-                                       optional_unprinted_spaces,
-                                       Rule.option ({
-                                               TokenType.GTKDOC_TITLE_ELEMENT_OPEN,
-                                               Rule.many ({
-                                                       Rule.one_of ({ word.action ((token) => {}) })
-                                               }),
-                                               TokenType.GTKDOC_TITLE_ELEMENT_CLOSE,
-                                               optional_unprinted_spaces
-                                       }),
-                                       program_listing_element,
-                                       TokenType.GTKDOC_EXAMPLE_ELEMENT_CLOSE
-                               })
-                       }),
-                       optional_unprinted_spaces
-               })
-               .set_name ("SourceElement");
-
-               Rule paragraph = Rule.seq ({
-                       run_with_dot
-               })
-               .set_name ("Paragraph")
-               .set_start (() => { push (_factory.create_paragraph ()); })
-               .set_reduce (() => {
-                       var head = (Block) pop ();
-                       ((BlockContent) peek ()).content.add (head);
-               });
-
-               Rule note_element = Rule.seq ({
-                       TokenType.GTKDOC_NOTE_ELEMENT_OPEN,
-                       optional_unprinted_spaces,
-                       Rule.option ({
-                               paragraph
-                       }),
-                       Rule.option ({
-                               Rule.many ({
-                                       paragraph_element,
-                                       Rule.option ({ paragraph })
-                               })
-                       }),
-                       TokenType.GTKDOC_NOTE_ELEMENT_CLOSE,
-                       optional_unprinted_spaces
-               })
-               .set_name ("Note");
-
-               Rule warning_element = Rule.seq ({
-                       TokenType.GTKDOC_WARNING_ELEMENT_OPEN,
-                       optional_unprinted_spaces,
-                       Rule.option ({
-                               paragraph
-                       }),
-                       Rule.option ({
-                               Rule.many ({
-                                       paragraph_element,
-                                       Rule.option ({ paragraph })
-                               })
-                       }),
-                       TokenType.GTKDOC_WARNING_ELEMENT_CLOSE,
-                       optional_unprinted_spaces
-               })
-               .set_name ("Warning");
-
-               Rule variable_list_element = Rule.seq ({
-                       TokenType.GTKDOC_VARIABLE_LIST_ELEMENT_OPEN,
-                       optional_unprinted_spaces,
-                       Rule.many ({
-                               Rule.seq ({
-                                       TokenType.GTKDOC_VARIABLE_LIST_ENTRY_ELEMENT_OPEN,
-                                       optional_unprinted_spaces,
-
-                                       TokenType.GTKDOC_TERM_ELEMENT_OPEN,
-                                       optional_unprinted_spaces,
-                                       run_with_dot,
-                                       TokenType.GTKDOC_TERM_ELEMENT_CLOSE.action ((token) => { add_content_string (": "); }),
-                                       optional_unprinted_spaces,
-
-                                       TokenType.GTKDOC_LIST_ITEM_ELEMENT_OPEN,
-                                       optional_unprinted_spaces,
-                                       run_with_dot,
-                                       TokenType.GTKDOC_LIST_ITEM_ELEMENT_CLOSE,
-                                       optional_unprinted_spaces,
-
-                                       TokenType.GTKDOC_VARIABLE_LIST_ENTRY_ELEMENT_CLOSE,
-                                       optional_unprinted_spaces
-                               })
-                               .set_start (() => { push (_factory.create_list_item ()); })
-                               .set_reduce (() => {
-                                       var head = (Content.ListItem) pop ();
-                                       ((Content.List) peek ()).items.add (head);
-                               })
-                       }),
-                       TokenType.GTKDOC_VARIABLE_LIST_ELEMENT_CLOSE,
-                       optional_unprinted_spaces
-               })
-               .set_name ("VariableList")
-               .set_start (() => { push (_factory.create_list ()); })
-               .set_reduce (() => {
-                       var head = (Block) pop ();
-                       ((BlockContent) peek ()).content.add (head);
-               });
-
-               Rule list_element = Rule.seq ({
-                       TokenType.GTKDOC_ITEMIZED_LIST_ELEMENT_OPEN,
-                       optional_unprinted_spaces,
-                       Rule.many ({
-                               Rule.seq ({
-                                       TokenType.GTKDOC_LIST_ITEM_ELEMENT_OPEN,
-                                       optional_unprinted_spaces,
-                                       run_with_dot,
-                                       TokenType.GTKDOC_LIST_ITEM_ELEMENT_CLOSE,
-                                       optional_unprinted_spaces
-                               })
-                               .set_start (() => { push (_factory.create_list_item ()); })
-                               .set_reduce (() => {
-                                       var head = (Content.ListItem) pop ();
-                                       ((Content.List) peek ()).items.add (head);
-                               })
-                       }),
-                       TokenType.GTKDOC_ITEMIZED_LIST_ELEMENT_CLOSE,
-                       optional_unprinted_spaces
-               })
-               .set_name ("ItemizedList")
-               .set_start (() => { push (_factory.create_list ()); })
-               .set_reduce (() => {
-                       var head = (Block) pop ();
-                       ((BlockContent) peek ()).content.add (head);
-               });
-
-               Rule simple_list_element = Rule.seq ({
-                       TokenType.GTKDOC_SIMPLELIST_ELEMENT_OPEN,
-                       optional_unprinted_spaces,
-                       Rule.many ({
-                               Rule.seq ({
-                                       TokenType.GTKDOC_MEMBER_ELEMENT_OPEN,
-                                       optional_unprinted_spaces,
-                                       run_with_dot,
-                                       TokenType.GTKDOC_MEMBER_ELEMENT_CLOSE,
-                                       optional_unprinted_spaces
-                               })
-                               .set_start (() => { push (_factory.create_list_item ()); })
-                               .set_reduce (() => {
-                                       var head = (Content.ListItem) pop ();
-                                       ((Content.List) peek ()).items.add (head);
-                               })
-                       }),
-                       TokenType.GTKDOC_SIMPLELIST_ELEMENT_CLOSE,
-                       optional_unprinted_spaces
-               })
-               .set_name ("SimpleList")
-               .set_start (() => { push (_factory.create_list ()); })
-               .set_reduce (() => {
-                       var head = (Block) pop ();
-                       ((BlockContent) peek ()).content.add (head);
-               });
-
-               Rule block_element = Rule.one_of ({
-                       paragraph_element, list_element, note_element, warning_element, source,
-                       example_element, variable_list_element, simple_list_element
-               })
-               .set_name ("Block");
-
-               // TODO: find out why the clean version does not work ...
-               Rule first_paragraph = Rule.many ({
-                       Rule.one_of ({
-                               Rule.seq ({ run }).set_reduce (() => {
-                                       var head = (Inline) pop ();
-                                       ((InlineContent) peek ()).content.add (head);
-                               }),
-                               TokenType.GTKDOC_DOT.action ((token) => {
-                                       ((InlineContent) peek ()).content.add (_factory.create_text ("."));
-                                       if (_gir_is_first_paragraph) {
-                                               var head = (Block) pop ();
-                                               ((BlockContent) peek ()).content.add (head);
-                                               push (_factory.create_paragraph ());
-                                               _gir_is_first_paragraph = false;
-                                       }
-                               })
-                       })
-               })
-               .set_name ("BriefDescription")
-               .set_start (() => { push (_factory.create_paragraph ()); })
-               .set_reduce (() => {
-                       var head = (Block) pop ();
-                       ((BlockContent) peek ()).content.add (head);
-                       _gir_is_first_paragraph = true;
-               });
-
-               Rule comment = Rule.seq ({
-                       Rule.option ({
-                               first_paragraph
-                       }),
-                       Rule.option ({
-                               Rule.many ({
-                                       block_element,
-                                       Rule.option ({ paragraph })
-                               })
-                       })
-               })
-               .set_name ("Comment")
-               .set_start (() => { push (_factory.create_comment ()); });
-
-               Rule taglet = Rule.many ({
-                       run_with_dot
-               })
-               .set_name ("Taglet")
-               .set_reduce (() => {
-                       var head = (Taglet) pop ();
-                       ((Comment) peek ()).taglets.add (head);
-               });
-
-               _gir_taglet_parser.set_root_rule (taglet);
-               _gir_parser.set_root_rule (comment);
-       }
-
        private void init_valadoc_rules () {
                // Inline rules
 
diff --git a/src/libvaladoc/documentation/girdocumentationscanner.vala b/src/libvaladoc/documentation/girdocumentationscanner.vala
deleted file mode 100755 (executable)
index aed78db..0000000
+++ /dev/null
@@ -1,610 +0,0 @@
-/* girdocuscanner.vala
- *
- * Copyright (C) 2010 Florian Brosch
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
- *
- * Author:
- *     Florian Brosch <flo.brosch@gmail.com>
- */
-
-using Valadoc;
-
-public class Valadoc.Importer.GirDocumentationScanner : Object, Scanner {
-
-       public GirDocumentationScanner (Settings settings) {
-               _settings = settings;
-       }
-
-       private Settings _settings;
-       private Parser _parser;
-
-       private string _content;
-       private int _index;
-       private bool _stop;
-       private int _last_index;
-       private int _last_line;
-       private int _last_column;
-       private int _line;
-       private int _column;
-       private bool _code_element_escape_mode;
-       private bool _code_escape_mode;
-       private bool _node_name;
-       private unichar _last_char;
-       private int _skip;
-       private StringBuilder _current_string = new StringBuilder ();
-
-       public void set_parser (Parser parser) {
-               _parser = parser;
-       }
-
-       public void reset () {
-               _stop = false;
-               _last_index = 0;
-               _last_line = 0;
-               _last_column = 0;
-               _line = 0;
-               _column = 0;
-               _code_element_escape_mode = false;
-               _code_escape_mode = false;
-               _node_name = false;
-               _last_char = 0;
-               _skip = 0;
-               _current_string.erase (0, -1);
-       }
-
-       public void scan (string _content) throws ParserError {
-               this._content = _content;
-               for (_index = 0; !_stop && _index < _content.length; _index++) {
-                       unichar c = _content[_index];
-                       accept (c);
-               }
-       }
-
-       public void end () throws ParserError {
-               emit_token (TokenType.GTKDOC_EOF);
-       }
-
-       public void stop () {
-               _stop = true;
-       }
-
-       public void set_code_element_escape_mode (bool escape_mode) {
-               _code_element_escape_mode = escape_mode;
-       }
-
-       public void set_code_escape_mode (bool escape_mode) {
-               _code_escape_mode = escape_mode;
-       }
-
-       public int get_line () {
-               return _line;
-       }
-
-       public virtual string get_line_content () {
-               int i = _index;
-               while (i > 0 && _content[i-1] != '\n') {
-                       i--;
-               }
-               StringBuilder builder = new StringBuilder ();
-               while (i < _content.length && _content[i] != '\n') {
-                       unichar c = _content[i++];
-                       if (c == '\t') {
-                               builder.append (" ");
-                       } else {
-                               builder.append_unichar (c);
-                       }
-               }
-               return builder.str;
-       }
-
-       protected unichar get_next_char (int offset = 1) {
-               return _content[_index + offset];
-       }
-
-       private void emit_xml_node_open_token (string name, int offset) throws ParserError {
-               switch (name) {
-               case "structname":
-                       emit_token (TokenType.GTKDOC_STRUCTNAME_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "link":
-                       emit_token (TokenType.GTKDOC_LINK_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "literal":
-                       emit_token (TokenType.GTKDOC_LITERAL_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "guimenuitem":
-                       emit_token (TokenType.GTKDOC_GUI_MENU_ITEM_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "replaceable":
-                       emit_token (TokenType.GTKDOC_REPLACEABLE_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "para":
-                       emit_token (TokenType.GTKDOC_PARA_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "note":
-                       emit_token (TokenType.GTKDOC_NOTE_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "itemizedlist":
-                       emit_token (TokenType.GTKDOC_ITEMIZED_LIST_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "listitem":
-                       emit_token (TokenType.GTKDOC_LIST_ITEM_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "warning":
-                       emit_token (TokenType.GTKDOC_WARNING_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "programlisting":
-                       emit_token (TokenType.GTKDOC_PROGRAMLISTING_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "informalexample":
-                       emit_token (TokenType.GTKDOC_EXAMPLE_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "variablelist":
-                       emit_token (TokenType.GTKDOC_VARIABLE_LIST_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "varlistentry":
-                       emit_token (TokenType.GTKDOC_VARIABLE_LIST_ENTRY_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "term":
-                       emit_token (TokenType.GTKDOC_TERM_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "envar":
-                       emit_token (TokenType.GTKDOC_ENVAR_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "option":
-                       emit_token (TokenType.GTKDOC_OPTION_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "emphasis":
-                       emit_token (TokenType.GTKDOC_EMPHASIS_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "filename":
-                       emit_token (TokenType.GTKDOC_FILENAME_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "simplelist":
-                       emit_token (TokenType.GTKDOC_SIMPLELIST_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               case "member":
-                       emit_token (TokenType.GTKDOC_MEMBER_ELEMENT_OPEN);
-                       _skip = offset;
-                       break;
-
-               default:
-                       append_char ('<');
-                       break;
-               }
-       }
-
-       private void emit_xml_node_close_token (string name, int offset) throws ParserError {
-               switch (name) {
-               case "structname":
-                       emit_token (TokenType.GTKDOC_STRUCTNAME_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "link":
-                       emit_token (TokenType.GTKDOC_LINK_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "literal":
-                       emit_token (TokenType.GTKDOC_LITERAL_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "guimenuitem":
-                       emit_token (TokenType.GTKDOC_GUI_MENU_ITEM_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "replaceable":
-                       emit_token (TokenType.GTKDOC_REPLACEABLE_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "para":
-                       emit_token (TokenType.GTKDOC_PARA_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "note":
-                       emit_token (TokenType.GTKDOC_NOTE_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "itemizedlist":
-                       emit_token (TokenType.GTKDOC_ITEMIZED_LIST_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "listitem":
-                       emit_token (TokenType.GTKDOC_LIST_ITEM_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "warning":
-                       emit_token (TokenType.GTKDOC_WARNING_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "programlisting":
-                       emit_token (TokenType.GTKDOC_PROGRAMLISTING_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "informalexample":
-                       emit_token (TokenType.GTKDOC_EXAMPLE_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "variablelist":
-                       emit_token (TokenType.GTKDOC_VARIABLE_LIST_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "varlistentry":
-                       emit_token (TokenType.GTKDOC_VARIABLE_LIST_ENTRY_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "term":
-                       emit_token (TokenType.GTKDOC_TERM_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "envar":
-                       emit_token (TokenType.GTKDOC_ENVAR_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "option":
-                       emit_token (TokenType.GTKDOC_OPTION_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "emphasis":
-                       emit_token (TokenType.GTKDOC_EMPHASIS_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "filename":
-                       emit_token (TokenType.GTKDOC_FILENAME_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "simplelist":
-                       emit_token (TokenType.GTKDOC_SIMPLELIST_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               case "member":
-                       emit_token (TokenType.GTKDOC_MEMBER_ELEMENT_CLOSE);
-                       _skip = offset;
-                       break;
-
-               default:
-                       append_char ('<');
-                       break;
-               }
-       }
-
-       private inline bool is_numeric (unichar c) {
-               return c >= '0' && c <= '9';
-       }
-
-       private inline bool is_letter (unichar c) {
-               return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
-       }
-
-       private void emmit_qualified_function_name (int offset) throws ParserError {
-               unichar c = get_next_char (offset);
-
-               if (!is_letter (c) && c != '_') {
-                       emit_current_word ();
-                       return;
-               }
-
-               append_char (c);
-
-               for (offset++; ; offset++) {
-                       c = get_next_char (offset);
-
-                       if (!is_letter (c) && c != '_' && !is_numeric (c) && c != '\0') {
-                               break;
-                       }
-
-                       append_char (c);
-               }
-
-               unichar nc = get_next_char (offset+1);
-
-               if (c == '\0' || !((c == ':' && nc == ':' && is_letter (get_next_char (offset+2))) || (c == ':' && is_letter (nc)))) {
-                       emit_current_word ();
-                       _skip = offset-1;
-                       return;
-               }
-
-               append_char (c);
-
-               if (nc == ':') {
-                       append_char (nc);
-                       offset++;
-               }
-
-               for (offset++; ; offset++) {
-                       c = get_next_char (offset);
-
-                       if (!is_letter (c) && c != '_' && !is_numeric (c)&& c != '-' && c != '\0') {
-                               break;
-                       }
-
-                       append_char (c);
-               }
-
-               emit_current_word ();
-               _skip = offset-1;
-       }
-
-       protected void accept (unichar c) throws ParserError {
-               _column++;
-
-               if (_skip == 0) {
-                       if (_code_element_escape_mode == true) {
-                               switch (c) {
-                               case '<':
-                                       if (get_next_char (1) == '/' && get_next_char (2) == 'p' &&
-                                               get_next_char (3) == 'r' && get_next_char (4) == 'o' &&
-                                               get_next_char (5) == 'g' && get_next_char (6) == 'r' &&
-                                               get_next_char (7) == 'a' && get_next_char (8) == 'm' &&
-                                               get_next_char (9) == 'l' && get_next_char (10) == 'i' &&
-                                               get_next_char (11) == 's' && get_next_char (12) == 't' &&
-                                               get_next_char (13) == 'i' && get_next_char (14) == 'n' &&
-                                               get_next_char (15) == 'g' && get_next_char (16) == '>') {
-
-                                               _code_element_escape_mode = false;
-                                               emit_token (TokenType.GTKDOC_PROGRAMLISTING_ELEMENT_CLOSE);
-                                               _skip = 16;
-                                       } else {
-                                               append_char (c);
-                                       }
-                                       return;
-                               default:
-                                       append_char (c);
-                                       return;
-                               }
-                       } else if (_code_escape_mode == true) {
-                               switch (c) {
-                               case ']':
-                                       if (get_next_char (1) == '|') {
-                                               _code_escape_mode = false;
-                                               emit_token (TokenType.GTKDOC_SOURCE_CLOSE);
-                                               _skip = 2;
-                                       } else {
-                                               append_char (c);
-                                       }
-                                       return;
-                               default:
-                                       append_char (c);
-                                       return;
-                               }
-                       } else {
-                               switch (c) {
-                               case '#':
-                               case '%':
-                                       unichar nc = get_next_char (1);
-                                       if (is_letter (nc) || nc == '_') {
-                                               emit_token (TokenType.GTKDOC_SYMBOL);
-                                               emmit_qualified_function_name (1);
-                                       } else {
-                                               append_char (c);
-                                       }
-                                       break;
-
-                               case '@':
-                                       if (_last_char.isspace ()) {
-                                               emit_token (TokenType.GTKDOC_PARAM);
-                                       } else {
-                                               append_char (c);
-                                       }
-                                       break;
-
-                               case '-':
-                                       if (get_next_char (1) == '-' && get_next_char (2) == '>') {
-                                               emit_token (TokenType.GTKDOC_XML_COMMENT_END);
-                                               _skip = 2;
-                                       } else {
-                                               append_char (c);
-                                       }
-                                       break;
-
-                               case '(': // "(<spaces>?)"
-                                       int i = 1;
-
-                                       for (; get_next_char(i).isspace (); i++);
-                                       if (get_next_char(i) == ')') {
-                                               emit_token (TokenType.GTKDOC_FUNCTION_BRACKETS);
-                                               _skip = i;
-                                       } else {
-                                               append_char (c);
-                                       }
-                                       break;
-
-                               case '<':
-                                       if (get_next_char(1) == '!' && get_next_char(2) == '-' && get_next_char(3) == '-') {
-                                               emit_token (TokenType.GTKDOC_XML_COMMENT_START);
-                                               _skip = 3;
-                                               break;
-                                       }
-
-                                       var name = new StringBuilder ();
-                                       bool is_end_tag = false;
-                                       int i = 1;
-
-                                       if (get_next_char(i) == '/') {
-                                               is_end_tag = true;
-                                               i++;
-                                       }
-
-
-                                       for (; get_next_char(i) != '>' && !get_next_char(i).isspace (); i++) {
-                                               name.append_unichar (get_next_char(i));
-                                       }
-
-                                       if (name.len == 0) {
-                                               append_char (c);
-                                               break;
-                                       }
-
-                                       if (is_end_tag) {
-                                               if (get_next_char(i) != '>') {
-                                                       append_char (c);
-                                                       break;
-                                               }
-                                               emit_xml_node_close_token (name.str, i);
-                                       } else {
-                                               for (; get_next_char(i) != '>' && get_next_char(i) != '\0'; i++);
-                                               if (get_next_char(i) == '\0') {
-                                                       append_char (c);
-                                                       break;
-                                               }
-                                               emit_xml_node_open_token (name.str, i);
-                                       }
-                                       break;
-
-                               case '|':
-                                       if (get_next_char (1) == '[') {
-                                               emit_token (TokenType.GTKDOC_SOURCE_OPEN);
-                                               _skip = 1;
-                                       } else {
-                                               append_char (c);
-                                       }
-                                       break;
-
-                               case ']':
-                                       if (get_next_char (1) == '|') {
-                                               emit_token (TokenType.GTKDOC_SOURCE_CLOSE);
-                                               _skip = 1;
-                                       } else {
-                                               append_char (c);
-                                       }
-                                       break;
-
-                               case '\r':
-                                       break;
-
-                               case '\n':
-                                       emit_token (TokenType.GTKDOC_EOL);
-                                       _line++;
-                                       _column = 0;
-                                       _last_column = 0;
-                                       break;
-
-                               case '\t':
-                               case ' ':
-                                       emit_token (TokenType.GTKDOC_SPACE);
-                                       break;
-
-                               case '.':
-                                       emit_token (TokenType.GTKDOC_DOT);
-                                       break;
-
-                               default:
-                                       append_char (c);
-                                       break;
-                               }
-                       }
-               } else {
-                       _skip--;
-               }
-               _last_char = c;
-       }
-
-       private void append_char (unichar c) {
-               _current_string.append_unichar (c);
-       }
-
-       public int get_line_start_column () {
-               return 0;
-       }
-
-       private SourceLocation get_begin () {
-               return SourceLocation (_last_line, get_line_start_column () + _last_column);
-       }
-
-       private SourceLocation get_end (int offset = 0) {
-               return SourceLocation (_line, get_line_start_column () + _column + offset);
-       }
-
-       private void emit_current_word () throws ParserError {
-               if (_current_string.len > 0) {
-                       _parser.accept_token (new Token.from_word (_current_string.str, get_begin (), get_end (-1)));
-                       _current_string.erase (0, -1);
-
-                       _last_index = _index;
-                       _last_line = _line;
-                       _last_column = _column - 1;
-               }
-       }
-
-       private void emit_token (TokenType type) throws ParserError {
-               emit_current_word ();
-
-               _parser.accept_token (new Token.from_type (type, get_begin (), get_end (_skip)));
-
-               _last_index = _index;
-               _last_line = _line;
-               _last_column = _column;
-       }
-}
diff --git a/src/libvaladoc/importer/gircomment.vala b/src/libvaladoc/importer/gircomment.vala
deleted file mode 100755 (executable)
index 7caa679..0000000
+++ /dev/null
@@ -1,56 +0,0 @@
-/* DocumentationBuilderimporter.vala
- *
- * Copyright (C) 2010-2011 Florian Brosch
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
- *
- * Author:
- *     Florian Brosch <flo.brosch@gmail.com>
- */
-
-
-using Valadoc;
-using Gee;
-
-
-/**
- * A documentation comment used by valadoc
- */
-public class Valadoc.Importer.GirComment : Valadoc.Api.SourceComment {
-       private HashMap<string, Api.SourceComment> _parameters = new HashMap<string, Api.SourceComment> ();
-
-       public Map<string, Api.SourceComment> parameters {
-               owned get { return _parameters.read_only_view; }
-       }
-
-       public Api.SourceComment? return_value {
-               internal set;
-               get;
-       }
-
-       public GirComment (string content, Api.SourceFile file, int first_line, int first_column, int last_line, int last_column) {
-               base (content, file, first_line, first_column, last_line, last_column);
-               return_value = null;
-       }
-
-       internal void add_parameter (string name, Api.SourceComment comment) {
-               _parameters.set (name, comment);
-       }
-
-       public bool is_empty () {
-               return return_value == null && (content == null || content == "") && parameters.is_empty;
-       }
-}
-
diff --git a/src/libvaladoc/importer/girdocumentationimporter.vala b/src/libvaladoc/importer/girdocumentationimporter.vala
deleted file mode 100755 (executable)
index d83bc2d..0000000
+++ /dev/null
@@ -1,708 +0,0 @@
-/* DocumentationBuilderimporter.vala
- *
- * Copyright (C) 2010-2011 Florian Brosch
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
- *
- * Author:
- *     Florian Brosch <flo.brosch@gmail.com>
- */
-
-// based on valagirparser.vala
-
-using Gee;
-
-public class Valadoc.Importer.GirDocumentationImporter : DocumentationImporter {
-       DocumentationParser docparser;
-       MarkupReader reader;
-
-       ErrorReporter reporter;
-
-       Api.SourceFile current_source_file;
-       MarkupSourceLocation begin;
-       MarkupSourceLocation end;
-       MarkupTokenType current_token;
-
-       LinkedList<string> type_cname_stack = new LinkedList<string> ();
-
-       int anonymous_param_count = 0;
-
-       public override string file_extension {
-               get { return "gir"; }
-       }
-
-       private GirComment create_empty_gir_comment () {
-               return new GirComment ("", current_source_file, begin.line, begin.column, end.line, end.column);
-       }
-
-       private GirComment create_gir_comment (Api.SourceComment sc) {
-               return new GirComment (sc.content, sc.file, sc.first_line, sc.first_column, sc.last_line, sc.last_column);
-       }
-
-       private void error (string msg_format, ...) {
-               va_list args = va_list();
-               string msg = msg_format.vprintf (args);
-
-               string code_line = null;
-
-               unowned string start_src_line = ((string) begin.pos).utf8_offset (-begin.column);
-               int offset = start_src_line.index_of_char ('\n');
-               if (offset == -1) {
-                       code_line = start_src_line;
-               } else {
-                       code_line = start_src_line.substring (0, offset);
-               }
-
-               reporter.error (current_source_file.get_name (), begin.line, begin.column, end.column, code_line, msg);
-       }
-
-       public GirDocumentationImporter (Api.Tree tree, DocumentationParser docparser, ModuleLoader modules, Settings settings, ErrorReporter reporter) {
-               base (tree, modules, settings);
-               this.docparser = docparser;
-               this.reporter = reporter;
-       }
-
-       public override void process (string filename) {
-               parse_file (filename);
-       }
-
-       void parse_file (string gir_file) {
-               this.current_source_file = new Api.SourceFile (gir_file, null);
-               reader = new MarkupReader (gir_file, reporter);
-
-               // xml prolog
-               next ();
-               next ();
-
-               next ();
-               parse_repository ();
-               this.current_source_file = null;
-       }
-
-       Api.SourceComment? parse_doc () {
-               start_element ("doc");
-
-               Api.SourceComment comment = null;
-               next ();
-
-               if (current_token == MarkupTokenType.TEXT) {
-                       comment = new Api.SourceComment (reader.content, current_source_file, begin.line, begin.column, end.line, end.column);
-                       next ();
-               }
-
-               end_element ("doc");
-               return comment;
-       }
-
-       void next () {
-               current_token = reader.read_token (out begin, out end);
-       }
-
-       void start_element (string name) {
-               if (current_token != MarkupTokenType.START_ELEMENT || reader.name != name) {
-                       error ("expected start element of `%s' instead of `%s'", name, reader.name);
-               }
-       }
-
-       void end_element (string name) {
-               if (current_token != MarkupTokenType.END_ELEMENT || reader.name != name) {
-                       error ("expected end element of `%s' instead of `%s'", name, reader.name);
-               }
-               next ();
-       }
-
-       void parse_repository () {
-               start_element ("repository");
-               next ();
-               while (current_token == MarkupTokenType.START_ELEMENT) {
-                       if (reader.name == "namespace") {
-                               parse_namespace ();
-                       } else if (reader.name == "include") {
-                               parse_include ();
-                       } else if (reader.name == "package") {
-                               parse_package ();
-                       } else if (reader.name == "c:include") {
-                               parse_c_include ();
-                       } else {
-                               error ("unknown child element `%s' in `repository'", reader.name);
-                               break;
-                       }
-               }
-               end_element ("repository");
-       }
-
-       void parse_include () {
-               start_element ("include");
-               next ();
-               end_element ("include");
-       }
-
-       void parse_package () {
-               start_element ("package");
-               next ();
-               end_element ("package");
-       }
-
-       void parse_c_include () {
-               start_element ("c:include");
-               next ();
-               end_element ("c:include");
-       }
-
-       void skip_element () {
-               next ();
-
-               int level = 1;
-               while (level > 0) {
-                       if (current_token == MarkupTokenType.START_ELEMENT) {
-                               level++;
-                       } else if (current_token == MarkupTokenType.END_ELEMENT) {
-                               level--;
-                       } else if (current_token == MarkupTokenType.EOF) {
-                               error ("unexpected end of file");
-                               break;
-                       }
-                       next ();
-               }
-       }
-
-       void parse_namespace () {
-               start_element ("namespace");
-               next ();
-
-               while (current_token == MarkupTokenType.START_ELEMENT) {
-                       if (reader.get_attribute ("introspectable") == "0") {
-                               skip_element ();
-                               continue;
-                       }
-
-                       if (reader.name == "alias") {
-                               parse_alias ();
-                       } else if (reader.name == "enumeration") {
-                               parse_enumeration ();
-                       } else if (reader.name == "bitfield") {
-                               parse_bitfield ();
-                       } else if (reader.name == "function") {
-                               parse_method ("function");
-                       } else if (reader.name == "callback") {
-                               parse_callback ();
-                       } else if (reader.name == "record") {
-                               if (reader.get_attribute ("glib:get-type") != null) {
-                                       parse_boxed ();
-                               } else {
-                                       parse_record ();
-                               }
-                       } else if (reader.name == "class") {
-                               parse_class ();
-                       } else if (reader.name == "interface") {
-                               parse_interface ();
-                       } else if (reader.name == "glib:boxed") {
-                               parse_boxed ();
-                       } else if (reader.name == "union") {
-                               parse_union ();
-                       } else if (reader.name == "constant") {
-                               parse_constant ();
-                       } else {
-                               error ("unknown child element `%s' in `namespace'", reader.name);
-                               break;
-                       }
-               }
-               end_element ("namespace");
-       }
-
-       void parse_alias () {
-               start_element ("alias");
-               next ();
-
-               while (current_token == MarkupTokenType.START_ELEMENT) {
-                       if (reader.name != "alias") {
-                               skip_element ();
-                       }
-               }
-
-               end_element ("alias");
-       }
-
-       void parse_enumeration () {
-               start_element ("enumeration");
-               string cname = reader.get_attribute ("c:type");
-               type_cname_stack.add (cname);
-               next ();
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "doc") {
-                       process_documentation (cname, create_gir_comment (parse_doc ()));
-               }
-
-               while (current_token == MarkupTokenType.START_ELEMENT) {
-                       if (reader.get_attribute ("introspectable") == "0") {
-                               skip_element ();
-                               continue;
-                       }
-
-                       if (reader.name == "member") {
-                               parse_enumeration_member ();
-                       } else {
-                               // error
-                               break;
-                       }
-               }
-
-               type_cname_stack.poll_head ();
-               end_element ("enumeration");
-       }
-
-       void parse_bitfield () {
-               start_element ("bitfield");
-               string cname = reader.get_attribute ("c:type");
-               type_cname_stack.add (cname);
-               next ();
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "doc") {
-                       process_documentation (cname, create_gir_comment (parse_doc ()));
-               }
-
-               while (current_token == MarkupTokenType.START_ELEMENT) {
-                       if (reader.get_attribute ("introspectable") == "0") {
-                               skip_element ();
-                               continue;
-                       }
-
-                       if (reader.name == "member") {
-                               parse_enumeration_member ();
-                       } else {
-                               // error
-                               break;
-                       }
-               }
-
-               type_cname_stack.poll_head ();
-               end_element ("bitfield");
-       }
-
-       void parse_enumeration_member () {
-               start_element ("member");
-               string cname = reader.get_attribute ("c:identifier");
-               next ();
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "doc") {
-                       process_documentation (cname, create_gir_comment (parse_doc ()));
-               }
-
-               end_element ("member");
-       }
-
-       void parse_return_value (GirComment doc) {
-               start_element ("return-value");
-               next ();
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "doc") {
-                       doc.return_value = parse_doc ();
-               }
-
-               parse_type ();
-
-               end_element ("return-value");
-       }
-
-       void parse_parameter (GirComment doc) {
-               start_element ("parameter");
-               string name = reader.get_attribute ("name");
-
-               if (name == null) {
-                       name = "param%d".printf (anonymous_param_count);
-                       anonymous_param_count++;
-               }
-
-               next ();
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "doc") {
-                       doc.add_parameter (name, parse_doc ());
-               }
-
-               if (reader.name == "varargs") {
-                       start_element ("varargs");
-                       next ();
-                       end_element ("varargs");
-               } else {
-                       parse_type ();
-               }
-
-               end_element ("parameter");
-       }
-
-       void parse_type () {
-               if (reader.name == "array" || reader.name == "callback" || reader.name == "type") {
-                       skip_element ();
-               }
-       }
-
-       void parse_record () {
-               start_element ("record");
-               string glib_is_gtype_struct_for = reader.get_attribute ("glib:is-gtype-struct-for");
-               string cname = reader.get_attribute ("c:type");
-               type_cname_stack.add (cname);
-               next ();
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "doc") {
-                       process_documentation (cname, create_gir_comment (parse_doc ()));
-               }
-
-               while (current_token == MarkupTokenType.START_ELEMENT) {
-                       if (reader.get_attribute ("introspectable") == "0") {
-                               skip_element ();
-                               continue;
-                       }
-
-                       if (reader.name == "field") {
-                               parse_field ();
-                       } else if (reader.name == "callback") {
-                               if (glib_is_gtype_struct_for != null) {
-                                       parse_method ("callback");
-                               } else {
-                                       parse_callback ();
-                               }
-                       } else if (reader.name == "constructor") {
-                               parse_constructor ();
-                       } else if (reader.name == "method") {
-                               parse_method ("method");
-                       } else if (reader.name == "union") {
-                               parse_union ();
-                       } else {
-                               error ("unknown child element `%s' in `record'", reader.name);
-                               break;
-                       }
-               }
-
-               type_cname_stack.poll_head ();
-               end_element ("record");
-       }
-
-       void parse_class () {
-               start_element ("class");
-               string cname = reader.get_attribute ("c:type");
-               type_cname_stack.add (cname);
-               next ();
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "doc") {
-                       process_documentation (cname, create_gir_comment (parse_doc ()));
-               }
-
-               while (current_token == MarkupTokenType.START_ELEMENT) {
-                       if (reader.get_attribute ("introspectable") == "0") {
-                               skip_element ();
-                               continue;
-                       }
-
-                       if (reader.name == "implements") {
-                               start_element ("implements");
-                               next ();
-                               end_element ("implements");
-                       } else if (reader.name == "constant") {
-                               parse_constant ();
-                       } else if (reader.name == "field") {
-                               parse_field ();
-                       } else if (reader.name == "property") {
-                               parse_property ();
-                       } else if (reader.name == "constructor") {
-                               parse_constructor (cname);
-                       } else if (reader.name == "function") {
-                               parse_method ("function");
-                       } else if (reader.name == "method") {
-                               parse_method ("method");
-                       } else if (reader.name == "virtual-method") {
-                               parse_method ("virtual-method");
-                       } else if (reader.name == "union") {
-                               parse_union ();
-                       } else if (reader.name == "glib:signal") {
-                               parse_signal ();
-                       } else {
-                               error ("unknown child element `%s' in `class'", reader.name);
-                               break;
-                       }
-               }
-
-               type_cname_stack.poll_head ();
-               end_element ("class");
-       }
-
-       void parse_interface () {
-               start_element ("interface");
-               string cname = reader.get_attribute ("c:type");
-               type_cname_stack.add (cname);
-               next ();
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "doc") {
-                       process_documentation (cname, create_gir_comment (parse_doc ()));
-               }
-
-               while (current_token == MarkupTokenType.START_ELEMENT) {
-                       if (reader.get_attribute ("introspectable") == "0") {
-                               skip_element ();
-                               continue;
-                       }
-
-                       if (reader.name == "prerequisite") {
-                               start_element ("prerequisite");
-                               next ();
-                               end_element ("prerequisite");
-                       } else if (reader.name == "field") {
-                               parse_field ();
-                       } else if (reader.name == "property") {
-                               parse_property ();
-                       } else if (reader.name == "virtual-method") {
-                               parse_method ("virtual-method");
-                       } else if (reader.name == "function") {
-                               parse_method ("function");
-                       } else if (reader.name == "method") {
-                               parse_method ("method");
-                       } else if (reader.name == "glib:signal") {
-                               parse_signal ();
-                       } else {
-                               error ("unknown child element `%s' in `interface'", reader.name);
-                               break;
-                       }
-               }
-
-               type_cname_stack.poll_head ();
-               end_element ("interface");
-       }
-
-       void parse_field () {
-               start_element ("field");
-               string cname = reader.get_attribute ("name");
-               next ();
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "doc" && cname != null) {
-                       string real_cname = type_cname_stack.peek();
-                       real_cname = (real_cname == null)? cname : real_cname+"."+cname;
-                       process_documentation (real_cname, create_gir_comment (parse_doc ()));
-               }
-
-               parse_type ();
-
-               end_element ("field");
-       }
-
-       void parse_property () {
-               start_element ("property");
-               string cname = reader.get_attribute ("name");
-               next ();
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "doc" && cname != null) {
-                       process_documentation (type_cname_stack.peek()+":"+cname, create_gir_comment (parse_doc ()));
-               }
-
-               parse_type ();
-
-               end_element ("property");
-       }
-
-       void parse_callback () {
-               this.parse_function ("callback");
-       }
-
-       void parse_constructor (string? parent_ctype = null) {
-               start_element ("constructor");
-               string cname = reader.get_attribute ("c:identifier");
-               next ();
-
-               GirComment doc;
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "doc") {
-                       doc = create_gir_comment (parse_doc ());
-               } else {
-                       doc = create_empty_gir_comment ();
-               }
-
-               parse_return_value (doc);
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "parameters") {
-                       start_element ("parameters");
-                       next ();
-                       while (current_token == MarkupTokenType.START_ELEMENT) {
-                               parse_parameter (doc);
-                       }
-                       end_element ("parameters");
-               }
-
-               if (!doc.is_empty ()) {
-                       process_documentation (cname, doc);
-               }
-
-               end_element ("constructor");
-       }
-
-       void parse_function (string element_name) {
-               start_element (element_name);
-               string cname = reader.get_attribute ("c:identifier");
-               next ();
-
-               GirComment doc;
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "doc") {
-                       doc = create_gir_comment (parse_doc ());
-               } else {
-                       doc = create_empty_gir_comment ();
-               }
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "return-value") {
-                       parse_return_value (doc);
-               }
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "parameters") {
-                       start_element ("parameters");
-                       next ();
-
-                       while (current_token == MarkupTokenType.START_ELEMENT) {
-                               parse_parameter (doc);
-                       }
-
-                       end_element ("parameters");
-               }
-
-               if (!doc.is_empty ()) {
-                       process_documentation (cname, doc);
-               }
-
-               end_element (element_name);
-       }
-
-       void parse_method (string element_name) {
-               this.parse_function (element_name);
-       }
-
-       void parse_signal () {
-               start_element ("glib:signal");
-               string cname = reader.get_attribute ("name");
-               next ();
-
-               GirComment doc;
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "doc") {
-                       doc = create_gir_comment (parse_doc ());
-               } else {
-                       doc = create_empty_gir_comment ();
-               }
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "return-value") {
-                       parse_return_value (doc);
-               }
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "parameters") {
-                       start_element ("parameters");
-                       next ();
-                       while (current_token == MarkupTokenType.START_ELEMENT) {
-                               parse_parameter (doc);
-                       }
-                       end_element ("parameters");
-               }
-               if (!doc.is_empty ()) {
-                       process_documentation (type_cname_stack.peek()+"::"+cname, doc);
-               }
-               end_element ("glib:signal");
-       }
-
-       void parse_boxed () {
-               string cname = reader.get_attribute ("c:type");
-               next ();
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "doc") {
-                       process_documentation (cname, create_gir_comment (parse_doc ()));
-               }
-
-               while (current_token == MarkupTokenType.START_ELEMENT) {
-                       if (reader.get_attribute ("introspectable") == "0") {
-                               skip_element ();
-                               continue;
-                       }
-
-                       if (reader.name == "field") {
-                               parse_field ();
-                       } else if (reader.name == "constructor") {
-                               parse_constructor ();
-                       } else if (reader.name == "union") {
-                               parse_union ();
-                       } else if (reader.name == "method") {
-                               parse_method ("method");
-                       } else {
-                               error ("unknown child element `%s' in `class'", reader.name);
-                               break;
-                       }
-               }
-
-               if (current_token != MarkupTokenType.END_ELEMENT) {
-                       error ("expected end element");
-               }
-               next ();
-       }
-
-       void parse_union () {
-               start_element ("union");
-               string cname = reader.get_attribute ("c:type");
-               type_cname_stack.add (cname);
-               next ();
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "doc") {
-                       process_documentation (cname, create_gir_comment (parse_doc ()));
-               }
-
-               while (current_token == MarkupTokenType.START_ELEMENT) {
-                       if (reader.get_attribute ("introspectable") == "0") {
-                               skip_element ();
-                               continue;
-                       }
-
-                       if (reader.name == "field") {
-                               parse_field ();
-                       } else if (reader.name == "constructor") {
-                               parse_constructor ();
-                       } else if (reader.name == "method") {
-                               parse_method ("method");
-                       } else if (reader.name == "record") {
-                               parse_record ();
-                       }
-               }
-
-               type_cname_stack.poll_head ();
-               end_element ("union");
-       }
-
-       void parse_constant () {
-               start_element ("constant");
-               string name = reader.get_attribute ("name");
-               next ();
-
-               if (current_token == MarkupTokenType.START_ELEMENT && reader.name == "doc") {
-                       process_documentation (name, create_gir_comment (parse_doc ()));
-               }
-
-               parse_type ();
-
-               end_element ("constant");
-       }
-
-       void process_documentation (string? cname, GirComment? doc) {
-               if (cname == null || doc == null) {
-                       return;
-               }
-       
-               var node = tree.search_symbol_cstr (cname);
-               
-               if (node != null) {
-                       node.documentation = docparser.parse_gir_comment (node, doc);
-               }
-       }
-}
-
index 03ecdcea88aafc72f868808fa4b862ae6aa85de8..490194a33adcb9b82da2e4cd77d39d3536bc9063 100755 (executable)
@@ -60,65 +60,8 @@ public class Valadoc.TokenType : Object {
        public static TokenType ALIGN_RIGHT;
        public static TokenType ALIGN_CENTER;
 
-       // Gir, doc-nodes:
-       public static TokenType GTKDOC_FUNCTION_BRACKETS;
-       public static TokenType GTKDOC_XML_COMMENT_START;
-       public static TokenType GTKDOC_XML_COMMENT_END;
-       public static TokenType GTKDOC_PARAM;
-       public static TokenType GTKDOC_SYMBOL;
-       public static TokenType GTKDOC_ANY_WORD;
-       public static TokenType GTKDOC_SPACE;
-       public static TokenType GTKDOC_EOF;
-       public static TokenType GTKDOC_EOL;
-       public static TokenType GTKDOC_STRUCTNAME_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_STRUCTNAME_ELEMENT_OPEN;
-       public static TokenType GTKDOC_LINK_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_LINK_ELEMENT_OPEN;
-       public static TokenType GTKDOC_ITEMIZED_LIST_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_ITEMIZED_LIST_ELEMENT_OPEN;
-       public static TokenType GTKDOC_LIST_ITEM_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_LIST_ITEM_ELEMENT_OPEN;
-       public static TokenType GTKDOC_NOTE_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_NOTE_ELEMENT_OPEN;
-       public static TokenType GTKDOC_PARA_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_PARA_ELEMENT_OPEN;
-       public static TokenType GTKDOC_LITERAL_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_LITERAL_ELEMENT_OPEN;
-       public static TokenType GTKDOC_GUI_MENU_ITEM_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_GUI_MENU_ITEM_ELEMENT_OPEN;
-       public static TokenType GTKDOC_REPLACEABLE_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_REPLACEABLE_ELEMENT_OPEN;
-       public static TokenType GTKDOC_WARNING_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_WARNING_ELEMENT_OPEN;
-       public static TokenType GTKDOC_SOURCE_CLOSE;
-       public static TokenType GTKDOC_SOURCE_OPEN;
-       public static TokenType GTKDOC_EXAMPLE_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_EXAMPLE_ELEMENT_OPEN;
-       public static TokenType GTKDOC_TITLE_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_TITLE_ELEMENT_OPEN;
-       public static TokenType GTKDOC_PROGRAMLISTING_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_PROGRAMLISTING_ELEMENT_OPEN;
-       public static TokenType GTKDOC_VARIABLE_LIST_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_VARIABLE_LIST_ELEMENT_OPEN;
-       public static TokenType GTKDOC_VARIABLE_LIST_ENTRY_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_VARIABLE_LIST_ENTRY_ELEMENT_OPEN;
-       public static TokenType GTKDOC_TERM_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_TERM_ELEMENT_OPEN;
-       public static TokenType GTKDOC_ENVAR_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_ENVAR_ELEMENT_OPEN;
-       public static TokenType GTKDOC_OPTION_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_OPTION_ELEMENT_OPEN;
-       public static TokenType GTKDOC_EMPHASIS_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_EMPHASIS_ELEMENT_OPEN;
-       public static TokenType GTKDOC_FILENAME_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_FILENAME_ELEMENT_OPEN;
-       public static TokenType GTKDOC_SIMPLELIST_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_SIMPLELIST_ELEMENT_OPEN;
-       public static TokenType GTKDOC_MEMBER_ELEMENT_CLOSE;
-       public static TokenType GTKDOC_MEMBER_ELEMENT_OPEN;
-       public static TokenType GTKDOC_DOT;
 
-       // .valadoc
+       // .valadoc (importer)
        public static TokenType VALADOC_COMMENT_START;
        public static TokenType VALADOC_COMMENT_END;
        public static TokenType VALADOC_ANY_WORD;
@@ -130,6 +73,7 @@ public class Valadoc.TokenType : Object {
 
        internal static void init_token_types () {
                if (!initialized) {
+                       // valadoc-comments:
                        ANY = new TokenType.basic ("<any>");
                        ANY_WORD = new TokenType.basic ("<any-word>");
                        ANY_NUMBER = new TokenType.basic ("<any-number>");
@@ -166,63 +110,7 @@ public class Valadoc.TokenType : Object {
                        ALIGN_RIGHT = new TokenType.basic ("))");
                        ALIGN_CENTER = new TokenType.basic (")(");
 
-                       GTKDOC_FUNCTION_BRACKETS = new TokenType.basic ("()");
-                       GTKDOC_XML_COMMENT_START = new TokenType.basic ("<!--");
-                       GTKDOC_XML_COMMENT_END = new TokenType.basic ("-->");
-                       GTKDOC_PARAM = new TokenType.basic ("<c-parameter>");
-                       GTKDOC_SYMBOL = new TokenType.basic ("<symbol>");
-                       GTKDOC_STRUCTNAME_ELEMENT_CLOSE = new TokenType.basic ("</structname>");
-                       GTKDOC_STRUCTNAME_ELEMENT_OPEN = new TokenType.basic ("<structname>");
-                       GTKDOC_LINK_ELEMENT_CLOSE = new TokenType.basic ("</link>");
-                       GTKDOC_LINK_ELEMENT_OPEN = new TokenType.basic ("<link>");
-                       GTKDOC_ITEMIZED_LIST_ELEMENT_CLOSE = new TokenType.basic ("</itemizedlist>");
-                       GTKDOC_ITEMIZED_LIST_ELEMENT_OPEN = new TokenType.basic ("<itemizedlist>");
-                       GTKDOC_LIST_ITEM_ELEMENT_CLOSE = new TokenType.basic ("</listitem>");
-                       GTKDOC_LIST_ITEM_ELEMENT_OPEN = new TokenType.basic ("<listitem>");
-                       GTKDOC_NOTE_ELEMENT_CLOSE = new TokenType.basic ("</note>");
-                       GTKDOC_NOTE_ELEMENT_OPEN = new TokenType.basic ("<note>");
-                       GTKDOC_PARA_ELEMENT_CLOSE = new TokenType.basic ("</para>");
-                       GTKDOC_PARA_ELEMENT_OPEN = new TokenType.basic ("<para>");
-                       GTKDOC_LITERAL_ELEMENT_CLOSE = new TokenType.basic ("</literal>");
-                       GTKDOC_LITERAL_ELEMENT_OPEN = new TokenType.basic ("<literal>");
-                       GTKDOC_GUI_MENU_ITEM_ELEMENT_CLOSE = new TokenType.basic ("</guimenuitem>");
-                       GTKDOC_GUI_MENU_ITEM_ELEMENT_OPEN = new TokenType.basic ("<guimenuitem>");
-                       GTKDOC_REPLACEABLE_ELEMENT_CLOSE = new TokenType.basic ("</replaceable>");
-                       GTKDOC_REPLACEABLE_ELEMENT_OPEN = new TokenType.basic ("<replaceable>");
-                       GTKDOC_WARNING_ELEMENT_CLOSE = new TokenType.basic ("</warning>");
-                       GTKDOC_WARNING_ELEMENT_OPEN = new TokenType.basic ("<warning>");
-                       GTKDOC_SOURCE_CLOSE = new TokenType.basic ("|]");
-                       GTKDOC_SOURCE_OPEN = new TokenType.basic ("[|");
-                       GTKDOC_EXAMPLE_ELEMENT_CLOSE = new TokenType.basic ("</example>");
-                       GTKDOC_EXAMPLE_ELEMENT_OPEN = new TokenType.basic ("<example>");
-                       GTKDOC_TITLE_ELEMENT_CLOSE = new TokenType.basic ("</title>");
-                       GTKDOC_TITLE_ELEMENT_OPEN = new TokenType.basic ("<title>");
-                       GTKDOC_PROGRAMLISTING_ELEMENT_CLOSE = new TokenType.basic ("</programlisting>");
-                       GTKDOC_PROGRAMLISTING_ELEMENT_OPEN = new TokenType.basic ("<programlisting>");
-                       GTKDOC_VARIABLE_LIST_ELEMENT_CLOSE = new TokenType.basic ("</variablelist>");
-                       GTKDOC_VARIABLE_LIST_ELEMENT_OPEN = new TokenType.basic ("<variablelist>");
-                       GTKDOC_VARIABLE_LIST_ENTRY_ELEMENT_CLOSE = new TokenType.basic ("</varlistentry>");
-                       GTKDOC_VARIABLE_LIST_ENTRY_ELEMENT_OPEN = new TokenType.basic ("<varlistentry>");
-                       GTKDOC_TERM_ELEMENT_CLOSE = new TokenType.basic ("</term>");
-                       GTKDOC_TERM_ELEMENT_OPEN = new TokenType.basic ("<term>");
-                       GTKDOC_ENVAR_ELEMENT_CLOSE = new TokenType.basic ("</envar>");
-                       GTKDOC_ENVAR_ELEMENT_OPEN = new TokenType.basic ("<envar>");
-                       GTKDOC_OPTION_ELEMENT_CLOSE = new TokenType.basic ("</option>");
-                       GTKDOC_OPTION_ELEMENT_OPEN = new TokenType.basic ("<option>");
-                       GTKDOC_EMPHASIS_ELEMENT_CLOSE = new TokenType.basic ("</emphasis>");
-                       GTKDOC_EMPHASIS_ELEMENT_OPEN = new TokenType.basic ("<emphasis>");
-                       GTKDOC_FILENAME_ELEMENT_CLOSE = new TokenType.basic ("</filename>");
-                       GTKDOC_FILENAME_ELEMENT_OPEN = new TokenType.basic ("<filename>");
-                       GTKDOC_SIMPLELIST_ELEMENT_CLOSE = new TokenType.basic ("</simplelist>");
-                       GTKDOC_SIMPLELIST_ELEMENT_OPEN = new TokenType.basic ("<simplelist>");
-                       GTKDOC_MEMBER_ELEMENT_CLOSE = new TokenType.basic ("</member>");
-                       GTKDOC_MEMBER_ELEMENT_OPEN = new TokenType.basic ("<member>");
-                       GTKDOC_DOT = new TokenType.basic (".");
-                       GTKDOC_ANY_WORD = ANY_WORD;
-                       GTKDOC_EOL = TokenType.EOL;
-                       GTKDOC_SPACE = SPACE;
-                       GTKDOC_EOF = EOF;
-
+                       // .valadoc (importer)
                        VALADOC_COMMENT_START = new TokenType.basic ("/*");
                        VALADOC_COMMENT_END = new TokenType.basic ("*/");
                        VALADOC_ANY_WORD = ANY_WORD;
@@ -230,7 +118,6 @@ public class Valadoc.TokenType : Object {
                        VALADOC_TAB = TAB;
                        VALADOC_EOL = EOL;
 
-
                        initialized = true;
                }
        }
index 4969deb8ec8320fd1425b84ffd82c28a398805a4..52acb978ce1c1232a08fe1805a898124cd8ae725 100755 (executable)
@@ -350,7 +350,6 @@ public class ValaDoc : Object {
                }
 
                DocumentationImporter[] importers = {
-                       new GirDocumentationImporter (doctree, docparser, modules, settings, reporter),
                        new ValadocDocumentationImporter (doctree, docparser, modules, settings, reporter)
                };