1 /* gtkdoccommentparser.c generated by valac, the Vala compiler
2 * generated from gtkdoccommentparser.vala, do not modify */
3
4 /* gtkcommentparser.vala
5 *
6 * Copyright (C) 2011-2014 Florian Brosch
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 *
22 * Author:
23 * Florian Brosch <flo.brosch@gmail.com>
24 */
25
26 #include "valadoc.h"
27 #include <valagee.h>
28 #include <glib-object.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <glib.h>
32
33 enum {
34 VALADOC_GTKDOC_PARSER_0_PROPERTY,
35 VALADOC_GTKDOC_PARSER_NUM_PROPERTIES
36 };
37 static GParamSpec* valadoc_gtkdoc_parser_properties[VALADOC_GTKDOC_PARSER_NUM_PROPERTIES];
38 #define _valadoc_gtkdoc_scanner_unref0(var) ((var == NULL) ? NULL : (var = (valadoc_gtkdoc_scanner_unref (var), NULL)))
39 #define _valadoc_gtkdoc_token_unref0(var) ((var == NULL) ? NULL : (var = (valadoc_gtkdoc_token_unref (var), NULL)))
40 #define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
41 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
42 #define _valadoc_api_tree_unref0(var) ((var == NULL) ? NULL : (var = (valadoc_api_tree_unref (var), NULL)))
43 #define _valadoc_api_source_comment_unref0(var) ((var == NULL) ? NULL : (var = (valadoc_api_source_comment_unref (var), NULL)))
44 #define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
45 #define _valadoc_importer_internal_id_registrar_unref0(var) ((var == NULL) ? NULL : (var = (valadoc_importer_internal_id_registrar_unref (var), NULL)))
46 #define _g_free0(var) (var = (g_free (var), NULL))
47 #define _vala_map_iterator_unref0(var) ((var == NULL) ? NULL : (var = (vala_map_iterator_unref (var), NULL)))
48 #define _g_string_free0(var) ((var == NULL) ? NULL : (var = (g_string_free (var, TRUE), NULL)))
49 #define _g_match_info_unref0(var) ((var == NULL) ? NULL : (var = (g_match_info_unref (var), NULL)))
50 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
51 #define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
52 #define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; }
53 #define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
54
55 struct _ValadocGtkdocParserPrivate {
56 ValadocGtkdocScanner* scanner;
57 ValadocGtkdocToken* current;
58 ValaList* stack;
59 ValaList* footnotes;
60 ValadocContentContentFactory* factory;
61 ValadocErrorReporter* reporter;
62 ValadocSettings* settings;
63 ValadocApiTree* tree;
64 ValadocApiNode* element;
65 gboolean show_warnings;
66 ValadocApiSourceComment* comment;
67 const gchar* instance_param_name;
68 gchar** comment_lines;
69 gint comment_lines_length1;
70 gint _comment_lines_size_;
71 GRegex* is_numeric_regex;
72 GRegex* normalize_regex;
73 GRegex* regex_source_lang;
74 ValadocImporterInternalIdRegistrar* id_registrar;
75 ValadocGirMetaData* current_metadata;
76 };
77
78 static gint ValadocGtkdocParser_private_offset;
79 static gpointer valadoc_gtkdoc_parser_parent_class = NULL;
80 static ValadocResourceLocatorIface * valadoc_gtkdoc_parser_valadoc_resource_locator_parent_iface = NULL;
81
82 static inline gchar* valadoc_gtkdoc_parser_fix_resource_path (ValadocGtkdocParser* self,
83 const gchar* path);
84 static void valadoc_gtkdoc_parser_reset (ValadocGtkdocParser* self,
85 ValadocApiSourceComment* comment);
86 static gchar* valadoc_gtkdoc_parser_normalize (ValadocGtkdocParser* self,
87 const gchar* text);
88 static gboolean valadoc_gtkdoc_parser_is_numeric (ValadocGtkdocParser* self,
89 const gchar* str);
90 static void valadoc_gtkdoc_parser_report_unexpected_token (ValadocGtkdocParser* self,
91 ValadocGtkdocToken* got,
92 const gchar* expected);
93 static void valadoc_gtkdoc_parser_report_warning (ValadocGtkdocParser* self,
94 ValadocGtkdocToken* got,
95 const gchar* message);
96 static ValadocContentNote* _valadoc_gtkdoc_parser_parse_note (ValadocGtkdocParser* self,
97 ValadocApiSourceComment* comment);
98 static ValadocContentComment* valadoc_gtkdoc_parser_parse_root_content (ValadocGtkdocParser* self,
99 ValadocApiSourceComment* gir_comment);
100 static void valadoc_gtkdoc_parser_add_note (ValadocGtkdocParser* self,
101 ValadocContentComment* * comment,
102 ValadocContentNote* note);
103 static void valadoc_gtkdoc_parser_add_taglet (ValadocGtkdocParser* self,
104 ValadocContentComment* * comment,
105 ValadocContentTaglet* taglet);
106 G_GNUC_INTERNAL void valadoc_importer_helper_extract_short_desc (ValadocContentComment* comment,
107 ValadocContentContentFactory* factory);
108 static ValadocContentTaglet* valadoc_gtkdoc_parser_parse_block_taglet (ValadocGtkdocParser* self,
109 ValadocApiSourceComment* gir_comment,
110 const gchar* taglet_name);
111 G_GNUC_INTERNAL void valadoc_taglets_param_set_is_c_self_param (ValadocTagletsParam* self,
112 gboolean value);
113 G_GNUC_INTERNAL void valadoc_taglets_param_set_parameter_name (ValadocTagletsParam* self,
114 const gchar* value);
115 static ValadocGtkdocToken* valadoc_gtkdoc_parser_next (ValadocGtkdocParser* self);
116 static void valadoc_gtkdoc_parser_parse_docbook_spaces (ValadocGtkdocParser* self,
117 gboolean accept_paragraphs);
118 static ValadocContentRun* valadoc_gtkdoc_parser_parse_inline_content (ValadocGtkdocParser* self);
119 static ValaCollection* valadoc_gtkdoc_parser_parse_block_content (ValadocGtkdocParser* self);
120 static gboolean valadoc_gtkdoc_parser_ignore_current_xml_close (ValadocGtkdocParser* self);
121 static gboolean valadoc_gtkdoc_parser_check_xml_open_tag (ValadocGtkdocParser* self,
122 const gchar* tagname);
123 static gboolean valadoc_gtkdoc_parser_check_xml_close_tag (ValadocGtkdocParser* self,
124 const gchar* tagname);
125 static ValadocContentInline* valadoc_gtkdoc_parser_parse_docbook_link_tempalte (ValadocGtkdocParser* self,
126 const gchar* tagname,
127 gboolean is_internal);
128 G_GNUC_INTERNAL void valadoc_content_link_set_id_registrar (ValadocContentLink* self,
129 ValadocImporterInternalIdRegistrar* value);
130 static ValadocContentInlineTaglet* valadoc_gtkdoc_parser_parse_symbol_link (ValadocGtkdocParser* self,
131 const gchar* tagname);
132 static ValadocContentInline* valadoc_gtkdoc_parser_create_type_link (ValadocGtkdocParser* self,
133 const gchar* name,
134 gboolean c_accept_plural);
135 static void valadoc_gtkdoc_parser_parse_anchor (ValadocGtkdocParser* self);
136 static ValadocContentLink* valadoc_gtkdoc_parser_parse_xref (ValadocGtkdocParser* self);
137 static ValadocContentRun* valadoc_gtkdoc_parser_parse_highlighted_template (ValadocGtkdocParser* self,
138 const gchar* tag_name,
139 ValadocContentRunStyle style);
140 static ValadocContentListItem* valadoc_gtkdoc_parser_parse_docbook_listitem (ValadocGtkdocParser* self);
141 static ValaCollection* valadoc_gtkdoc_parser_parse_mixed_content (ValadocGtkdocParser* self);
142 static ValadocContentBlockContent* valadoc_gtkdoc_parser_parse_docbook_information_box_template (ValadocGtkdocParser* self,
143 const gchar* tagname,
144 ValadocContentBlockContent* container);
145 static ValadocContentNote* valadoc_gtkdoc_parser_parse_docbook_important (ValadocGtkdocParser* self);
146 static ValadocContentNote* valadoc_gtkdoc_parser_parse_docbook_note (ValadocGtkdocParser* self);
147 static ValadocContentWarning* valadoc_gtkdoc_parser_parse_docbook_warning (ValadocGtkdocParser* self);
148 static inline ValaCollection* valadoc_gtkdoc_parser_parse_docbook_orderedlist (ValadocGtkdocParser* self);
149 static ValaCollection* valadoc_gtkdoc_parser_parse_docbook_itemizedlist (ValadocGtkdocParser* self,
150 const gchar* tag_name,
151 ValadocContentListBullet bullet_type);
152 static inline void valadoc_gtkdoc_parser_append_block_content_not_null (ValadocGtkdocParser* self,
153 ValaCollection* run,
154 ValadocContentBlock* element);
155 static ValadocContentParagraph* valadoc_gtkdoc_parser_parse_docbook_title (ValadocGtkdocParser* self);
156 static ValadocContentParagraph* valadoc_gtkdoc_parser_parse_gtkdoc_paragraph (ValadocGtkdocParser* self);
157 static inline ValaCollection* valadoc_gtkdoc_parser_parse_docbook_simpara (ValadocGtkdocParser* self);
158 static ValaCollection* valadoc_gtkdoc_parser_parse_docbook_para (ValadocGtkdocParser* self,
159 const gchar* tag_name);
160 static ValadocContentParagraph* valadoc_gtkdoc_parser_parse_gtkdoc_source (ValadocGtkdocParser* self);
161 static ValadocContentSourceCodeLanguage* _valadoc_content_source_code_language_dup (ValadocContentSourceCodeLanguage* self);
162 G_GNUC_INTERNAL gboolean valadoc_highlighter_xml_scanner_is_xml (const gchar* source);
163 static ValadocContentParagraph* valadoc_gtkdoc_parser_parse_docbook_graphic (ValadocGtkdocParser* self);
164 static ValadocContentEmbedded* valadoc_gtkdoc_parser_parse_docbook_inlinegraphic (ValadocGtkdocParser* self,
165 const gchar* tag_name);
166 static ValadocContentParagraph* valadoc_gtkdoc_parser_parse_docbook_programlisting (ValadocGtkdocParser* self);
167 static inline ValaCollection* valadoc_gtkdoc_parser_parse_docbook_informalexample (ValadocGtkdocParser* self);
168 static ValaCollection* valadoc_gtkdoc_parser_parse_docbook_example (ValadocGtkdocParser* self,
169 const gchar* tag_name);
170 static ValaList* valadoc_gtkdoc_parser_parse_docbook_refsect2 (ValadocGtkdocParser* self,
171 gint nr);
172 static inline void valadoc_gtkdoc_parser_append_block_content_not_null_all (ValadocGtkdocParser* self,
173 ValaCollection* run,
174 ValaCollection* elements);
175 static ValaList* valadoc_gtkdoc_parser_parse_docbook_figure (ValadocGtkdocParser* self);
176 static ValadocContentRun* valadoc_gtkdoc_parser_parse_docbook_footnote (ValadocGtkdocParser* self);
177 static ValadocContentTableRow* valadoc_gtkdoc_parser_parse_docbook_thead (ValadocGtkdocParser* self);
178 static ValadocContentTableRow* valadoc_gtkdoc_parser_parse_docbook_row (ValadocGtkdocParser* self,
179 ValadocContentRunStyle default_style);
180 static ValadocContentTableCell* valadoc_gtkdoc_parser_parse_docbook_entry (ValadocGtkdocParser* self,
181 ValadocContentRunStyle default_style);
182 static ValaCollection* valadoc_gtkdoc_parser_parse_docbook_tbody (ValadocGtkdocParser* self);
183 static ValadocContentTable* valadoc_gtkdoc_parser_parse_docbook_tgroup (ValadocGtkdocParser* self);
184 static ValadocContentTable* valadoc_gtkdoc_parser_parse_docbook_informaltable (ValadocGtkdocParser* self);
185 static ValaCollection* valadoc_gtkdoc_parser_parse_docbook_section (ValadocGtkdocParser* self);
186 static ValadocContentListItem* valadoc_gtkdoc_parser_parse_docbook_member (ValadocGtkdocParser* self);
187 static ValadocContentList* valadoc_gtkdoc_parser_parse_docbook_simplelist (ValadocGtkdocParser* self);
188 static ValadocContentParagraph* valadoc_gtkdoc_parser_parse_docbook_term (ValadocGtkdocParser* self);
189 static ValadocContentListItem* valadoc_gtkdoc_parser_parse_docbook_varlistentry (ValadocGtkdocParser* self);
190 static ValaCollection* valadoc_gtkdoc_parser_parse_docbook_variablelist (ValadocGtkdocParser* self);
191 static ValadocContentRun* valadoc_gtkdoc_parser_parse_xml_tag (ValadocGtkdocParser* self);
192 static void valadoc_gtkdoc_parser_append_inline_content_string (ValadocGtkdocParser* self,
193 ValadocContentRun* run,
194 const gchar* current);
195 G_GNUC_INTERNAL void valadoc_taglets_link_set_c_accept_plural (ValadocTagletsLink* self,
196 gboolean value);
197 G_GNUC_INTERNAL void valadoc_taglets_link_set_symbol_name (ValadocTagletsLink* self,
198 const gchar* value);
199 static inline void valadoc_gtkdoc_parser_append_inline_content_not_null (ValadocGtkdocParser* self,
200 ValadocContentRun* run,
201 ValadocContentInline* element);
202 G_GNUC_INTERNAL gchar* valadoc_importer_helper_resolve_parameter_ctype (ValadocApiTree* tree,
203 ValadocApiNode* element,
204 const gchar* parameter_name,
205 gchar* * param_name,
206 gchar* * param_array_name,
207 gboolean* is_return_type_len);
208 static gchar* valadoc_gtkdoc_parser_real_resolve (ValadocResourceLocator* base,
209 const gchar* path);
210 static void valadoc_gtkdoc_parser_finalize (GObject * obj);
211 static GType valadoc_gtkdoc_parser_get_type_once (void);
212 static void _vala_array_destroy (gpointer array,
213 gint array_length,
214 GDestroyNotify destroy_func);
215 static void _vala_array_free (gpointer array,
216 gint array_length,
217 GDestroyNotify destroy_func);
218 static gint _vala_array_length (gpointer array);
219
220 static inline gpointer
valadoc_gtkdoc_parser_get_instance_private(ValadocGtkdocParser * self)221 valadoc_gtkdoc_parser_get_instance_private (ValadocGtkdocParser* self)
222 {
223 return G_STRUCT_MEMBER_P (self, ValadocGtkdocParser_private_offset);
224 }
225
226 static inline gchar*
valadoc_gtkdoc_parser_fix_resource_path(ValadocGtkdocParser * self,const gchar * path)227 valadoc_gtkdoc_parser_fix_resource_path (ValadocGtkdocParser* self,
228 const gchar* path)
229 {
230 ValadocGirMetaData* _tmp0_;
231 gchar* _tmp1_;
232 gchar* result = NULL;
233 g_return_val_if_fail (self != NULL, NULL);
234 g_return_val_if_fail (path != NULL, NULL);
235 _tmp0_ = self->priv->current_metadata;
236 _tmp1_ = valadoc_gir_meta_data_get_resource_path (_tmp0_, path);
237 result = _tmp1_;
238 return result;
239 }
240
241 static gpointer
_valadoc_api_source_comment_ref0(gpointer self)242 _valadoc_api_source_comment_ref0 (gpointer self)
243 {
244 return self ? valadoc_api_source_comment_ref (self) : NULL;
245 }
246
247 static void
valadoc_gtkdoc_parser_reset(ValadocGtkdocParser * self,ValadocApiSourceComment * comment)248 valadoc_gtkdoc_parser_reset (ValadocGtkdocParser* self,
249 ValadocApiSourceComment* comment)
250 {
251 ValadocGtkdocScanner* _tmp0_;
252 const gchar* _tmp1_;
253 const gchar* _tmp2_;
254 ValadocApiSourceFile* _tmp3_;
255 ValadocApiSourceFile* _tmp4_;
256 ValadocApiPackage* _tmp5_;
257 ValadocApiPackage* _tmp6_;
258 gboolean _tmp7_;
259 gboolean _tmp8_;
260 ValaList* _tmp9_;
261 ValadocApiSourceComment* _tmp10_;
262 ValaList* _tmp11_;
263 g_return_if_fail (self != NULL);
264 g_return_if_fail (comment != NULL);
265 _tmp0_ = self->priv->scanner;
266 _tmp1_ = valadoc_api_source_comment_get_content (comment);
267 _tmp2_ = _tmp1_;
268 valadoc_gtkdoc_scanner_reset (_tmp0_, _tmp2_);
269 _tmp3_ = valadoc_api_source_comment_get_file (comment);
270 _tmp4_ = _tmp3_;
271 _tmp5_ = valadoc_api_source_file_get_package (_tmp4_);
272 _tmp6_ = _tmp5_;
273 _tmp7_ = valadoc_api_package_get_is_package (_tmp6_);
274 _tmp8_ = _tmp7_;
275 self->priv->show_warnings = !_tmp8_;
276 self->priv->comment_lines = (_vala_array_free (self->priv->comment_lines, self->priv->comment_lines_length1, (GDestroyNotify) g_free), NULL);
277 self->priv->comment_lines = NULL;
278 self->priv->comment_lines_length1 = 0;
279 self->priv->_comment_lines_size_ = self->priv->comment_lines_length1;
280 _tmp9_ = self->priv->footnotes;
281 vala_collection_clear ((ValaCollection*) _tmp9_);
282 _tmp10_ = _valadoc_api_source_comment_ref0 (comment);
283 _valadoc_api_source_comment_unref0 (self->priv->comment);
284 self->priv->comment = _tmp10_;
285 _valadoc_gtkdoc_token_unref0 (self->priv->current);
286 self->priv->current = NULL;
287 _tmp11_ = self->priv->stack;
288 vala_collection_clear ((ValaCollection*) _tmp11_);
289 }
290
291 static gchar*
valadoc_gtkdoc_parser_normalize(ValadocGtkdocParser * self,const gchar * text)292 valadoc_gtkdoc_parser_normalize (ValadocGtkdocParser* self,
293 const gchar* text)
294 {
295 GError* _inner_error0_ = NULL;
296 gchar* result = NULL;
297 g_return_val_if_fail (self != NULL, NULL);
298 g_return_val_if_fail (text != NULL, NULL);
299 {
300 gchar* _tmp0_ = NULL;
301 GRegex* _tmp1_;
302 gchar* _tmp2_;
303 gchar* _tmp3_;
304 _tmp1_ = self->priv->normalize_regex;
305 _tmp2_ = g_regex_replace (_tmp1_, text, (gssize) -1, 0, " ", 0, &_inner_error0_);
306 _tmp0_ = _tmp2_;
307 if (G_UNLIKELY (_inner_error0_ != NULL)) {
308 if (_inner_error0_->domain == G_REGEX_ERROR) {
309 goto __catch0_g_regex_error;
310 }
311 g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
312 g_clear_error (&_inner_error0_);
313 return NULL;
314 }
315 _tmp3_ = _tmp0_;
316 _tmp0_ = NULL;
317 result = _tmp3_;
318 _g_free0 (_tmp0_);
319 return result;
320 }
321 goto __finally0;
322 __catch0_g_regex_error:
323 {
324 g_clear_error (&_inner_error0_);
325 g_assert_not_reached ();
326 }
327 __finally0:
328 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
329 g_clear_error (&_inner_error0_);
330 return NULL;
331 }
332
333 static gboolean
valadoc_gtkdoc_parser_is_numeric(ValadocGtkdocParser * self,const gchar * str)334 valadoc_gtkdoc_parser_is_numeric (ValadocGtkdocParser* self,
335 const gchar* str)
336 {
337 GRegex* _tmp0_;
338 gboolean result = FALSE;
339 g_return_val_if_fail (self != NULL, FALSE);
340 g_return_val_if_fail (str != NULL, FALSE);
341 _tmp0_ = self->priv->is_numeric_regex;
342 result = g_regex_match (_tmp0_, str, 0, NULL);
343 return result;
344 }
345
346 static void
valadoc_gtkdoc_parser_report_unexpected_token(ValadocGtkdocParser * self,ValadocGtkdocToken * got,const gchar * expected)347 valadoc_gtkdoc_parser_report_unexpected_token (ValadocGtkdocParser* self,
348 ValadocGtkdocToken* got,
349 const gchar* expected)
350 {
351 gchar* _tmp0_;
352 gchar* _tmp1_;
353 gchar* _tmp2_;
354 gchar* _tmp3_;
355 g_return_if_fail (self != NULL);
356 g_return_if_fail (got != NULL);
357 g_return_if_fail (expected != NULL);
358 _tmp0_ = valadoc_gtkdoc_token_to_string (got);
359 _tmp1_ = _tmp0_;
360 _tmp2_ = g_strdup_printf ("Unexpected Token: %s (Expected: %s)", _tmp1_, expected);
361 _tmp3_ = _tmp2_;
362 valadoc_gtkdoc_parser_report_warning (self, got, _tmp3_);
363 _g_free0 (_tmp3_);
364 _g_free0 (_tmp1_);
365 }
366
367 static void
valadoc_gtkdoc_parser_report_warning(ValadocGtkdocParser * self,ValadocGtkdocToken * got,const gchar * message)368 valadoc_gtkdoc_parser_report_warning (ValadocGtkdocParser* self,
369 ValadocGtkdocToken* got,
370 const gchar* message)
371 {
372 gint _tmp0_ = 0;
373 gint startpos = 0;
374 gint _tmp4_ = 0;
375 gint endpos = 0;
376 gchar** _tmp8_;
377 gint _tmp8__length1;
378 ValadocErrorReporter* _tmp14_;
379 ValadocApiSourceComment* _tmp15_;
380 ValadocApiSourceFile* _tmp16_;
381 ValadocApiSourceFile* _tmp17_;
382 gchar* _tmp18_;
383 gchar* _tmp19_;
384 ValadocApiSourceComment* _tmp20_;
385 gint _tmp21_;
386 gint _tmp22_;
387 gchar** _tmp23_;
388 gint _tmp23__length1;
389 const gchar* _tmp24_;
390 g_return_if_fail (self != NULL);
391 g_return_if_fail (got != NULL);
392 g_return_if_fail (message != NULL);
393 if (!self->priv->show_warnings) {
394 return;
395 }
396 if (got->line == 0) {
397 ValadocApiSourceComment* _tmp1_;
398 gint _tmp2_;
399 gint _tmp3_;
400 _tmp1_ = self->priv->comment;
401 _tmp2_ = valadoc_api_source_comment_get_first_column (_tmp1_);
402 _tmp3_ = _tmp2_;
403 _tmp0_ = _tmp3_ + got->first_column;
404 } else {
405 _tmp0_ = got->first_column;
406 }
407 startpos = _tmp0_;
408 if (got->line == 0) {
409 ValadocApiSourceComment* _tmp5_;
410 gint _tmp6_;
411 gint _tmp7_;
412 _tmp5_ = self->priv->comment;
413 _tmp6_ = valadoc_api_source_comment_get_first_column (_tmp5_);
414 _tmp7_ = _tmp6_;
415 _tmp4_ = _tmp7_ + got->last_column;
416 } else {
417 _tmp4_ = got->last_column;
418 }
419 endpos = _tmp4_;
420 _tmp8_ = self->priv->comment_lines;
421 _tmp8__length1 = self->priv->comment_lines_length1;
422 if (_tmp8_ == NULL) {
423 ValadocApiSourceComment* _tmp9_;
424 const gchar* _tmp10_;
425 const gchar* _tmp11_;
426 gchar** _tmp12_;
427 gchar** _tmp13_;
428 _tmp9_ = self->priv->comment;
429 _tmp10_ = valadoc_api_source_comment_get_content (_tmp9_);
430 _tmp11_ = _tmp10_;
431 _tmp13_ = _tmp12_ = g_strsplit (_tmp11_, "\n", 0);
432 self->priv->comment_lines = (_vala_array_free (self->priv->comment_lines, self->priv->comment_lines_length1, (GDestroyNotify) g_free), NULL);
433 self->priv->comment_lines = _tmp13_;
434 self->priv->comment_lines_length1 = _vala_array_length (_tmp12_);
435 self->priv->_comment_lines_size_ = self->priv->comment_lines_length1;
436 }
437 _tmp14_ = self->priv->reporter;
438 _tmp15_ = self->priv->comment;
439 _tmp16_ = valadoc_api_source_comment_get_file (_tmp15_);
440 _tmp17_ = _tmp16_;
441 _tmp18_ = valadoc_api_source_file_get_name (_tmp17_);
442 _tmp19_ = _tmp18_;
443 _tmp20_ = self->priv->comment;
444 _tmp21_ = valadoc_api_source_comment_get_first_line (_tmp20_);
445 _tmp22_ = _tmp21_;
446 _tmp23_ = self->priv->comment_lines;
447 _tmp23__length1 = self->priv->comment_lines_length1;
448 _tmp24_ = _tmp23_[got->line];
449 valadoc_error_reporter_warning (_tmp14_, _tmp19_, (glong) (_tmp22_ + got->line), (glong) (startpos + 1), (glong) (endpos + 1), _tmp24_, "%s", message);
450 _g_free0 (_tmp19_);
451 }
452
453 static gpointer
_g_object_ref0(gpointer self)454 _g_object_ref0 (gpointer self)
455 {
456 return self ? g_object_ref (self) : NULL;
457 }
458
459 static gpointer
_valadoc_api_tree_ref0(gpointer self)460 _valadoc_api_tree_ref0 (gpointer self)
461 {
462 return self ? valadoc_api_tree_ref (self) : NULL;
463 }
464
465 ValadocGtkdocParser*
valadoc_gtkdoc_parser_construct(GType object_type,ValadocSettings * settings,ValadocErrorReporter * reporter,ValadocApiTree * tree,ValadocModuleLoader * modules)466 valadoc_gtkdoc_parser_construct (GType object_type,
467 ValadocSettings* settings,
468 ValadocErrorReporter* reporter,
469 ValadocApiTree* tree,
470 ValadocModuleLoader* modules)
471 {
472 ValadocGtkdocParser * self = NULL;
473 ValadocContentContentFactory* _tmp0_;
474 ValadocErrorReporter* _tmp1_;
475 ValadocSettings* _tmp2_;
476 ValadocApiTree* _tmp3_;
477 GError* _inner_error0_ = NULL;
478 g_return_val_if_fail (settings != NULL, NULL);
479 g_return_val_if_fail (reporter != NULL, NULL);
480 g_return_val_if_fail (tree != NULL, NULL);
481 g_return_val_if_fail (modules != NULL, NULL);
482 self = (ValadocGtkdocParser*) g_object_new (object_type, NULL);
483 _tmp0_ = valadoc_content_content_factory_new (settings, (ValadocResourceLocator*) self, modules);
484 _g_object_unref0 (self->priv->factory);
485 self->priv->factory = _tmp0_;
486 _tmp1_ = _g_object_ref0 (reporter);
487 _g_object_unref0 (self->priv->reporter);
488 self->priv->reporter = _tmp1_;
489 _tmp2_ = _g_object_ref0 (settings);
490 _g_object_unref0 (self->priv->settings);
491 self->priv->settings = _tmp2_;
492 _tmp3_ = _valadoc_api_tree_ref0 (tree);
493 _valadoc_api_tree_unref0 (self->priv->tree);
494 self->priv->tree = _tmp3_;
495 {
496 GRegex* _tmp4_ = NULL;
497 GRegex* _tmp5_;
498 GRegex* _tmp6_;
499 GRegex* _tmp7_ = NULL;
500 GRegex* _tmp8_;
501 GRegex* _tmp9_;
502 GRegex* _tmp10_ = NULL;
503 GRegex* _tmp11_;
504 GRegex* _tmp12_;
505 _tmp5_ = g_regex_new ("^[+-]?([0-9]*\\.?[0-9]+|[0-9]+\\.?[0-9]*)([eE][+-]?[0-9]+)?$", G_REGEX_OPTIMIZE, 0, &_inner_error0_);
506 _tmp4_ = _tmp5_;
507 if (G_UNLIKELY (_inner_error0_ != NULL)) {
508 if (_inner_error0_->domain == G_REGEX_ERROR) {
509 goto __catch0_g_regex_error;
510 }
511 g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
512 g_clear_error (&_inner_error0_);
513 return NULL;
514 }
515 _tmp6_ = _tmp4_;
516 _tmp4_ = NULL;
517 _g_regex_unref0 (self->priv->is_numeric_regex);
518 self->priv->is_numeric_regex = _tmp6_;
519 _tmp8_ = g_regex_new ("( |\n|\t)+", G_REGEX_OPTIMIZE, 0, &_inner_error0_);
520 _tmp7_ = _tmp8_;
521 if (G_UNLIKELY (_inner_error0_ != NULL)) {
522 _g_regex_unref0 (_tmp4_);
523 if (_inner_error0_->domain == G_REGEX_ERROR) {
524 goto __catch0_g_regex_error;
525 }
526 g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
527 g_clear_error (&_inner_error0_);
528 return NULL;
529 }
530 _tmp9_ = _tmp7_;
531 _tmp7_ = NULL;
532 _g_regex_unref0 (self->priv->normalize_regex);
533 self->priv->normalize_regex = _tmp9_;
534 _tmp11_ = g_regex_new ("^<!--[ \t]+language=\"([A-Za-z]*)\"[ \t]+-->", 0, 0, &_inner_error0_);
535 _tmp10_ = _tmp11_;
536 if (G_UNLIKELY (_inner_error0_ != NULL)) {
537 _g_regex_unref0 (_tmp7_);
538 _g_regex_unref0 (_tmp4_);
539 if (_inner_error0_->domain == G_REGEX_ERROR) {
540 goto __catch0_g_regex_error;
541 }
542 g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
543 g_clear_error (&_inner_error0_);
544 return NULL;
545 }
546 _tmp12_ = _tmp10_;
547 _tmp10_ = NULL;
548 _g_regex_unref0 (self->priv->regex_source_lang);
549 self->priv->regex_source_lang = _tmp12_;
550 _g_regex_unref0 (_tmp10_);
551 _g_regex_unref0 (_tmp7_);
552 _g_regex_unref0 (_tmp4_);
553 }
554 goto __finally0;
555 __catch0_g_regex_error:
556 {
557 g_clear_error (&_inner_error0_);
558 g_assert_not_reached ();
559 }
560 __finally0:
561 if (G_UNLIKELY (_inner_error0_ != NULL)) {
562 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
563 g_clear_error (&_inner_error0_);
564 return NULL;
565 }
566 return self;
567 }
568
569 ValadocGtkdocParser*
valadoc_gtkdoc_parser_new(ValadocSettings * settings,ValadocErrorReporter * reporter,ValadocApiTree * tree,ValadocModuleLoader * modules)570 valadoc_gtkdoc_parser_new (ValadocSettings* settings,
571 ValadocErrorReporter* reporter,
572 ValadocApiTree* tree,
573 ValadocModuleLoader* modules)
574 {
575 return valadoc_gtkdoc_parser_construct (VALADOC_GTKDOC_TYPE_PARSER, settings, reporter, tree, modules);
576 }
577
578 static ValadocContentNote*
_valadoc_gtkdoc_parser_parse_note(ValadocGtkdocParser * self,ValadocApiSourceComment * comment)579 _valadoc_gtkdoc_parser_parse_note (ValadocGtkdocParser* self,
580 ValadocApiSourceComment* comment)
581 {
582 ValadocContentComment* cmnt = NULL;
583 ValadocContentComment* _tmp0_;
584 ValadocContentComment* _tmp1_;
585 ValadocContentNote* note = NULL;
586 ValadocContentContentFactory* _tmp2_;
587 ValadocContentNote* _tmp3_;
588 ValadocContentNote* _tmp4_;
589 ValaList* _tmp5_;
590 ValaList* _tmp6_;
591 ValadocContentComment* _tmp7_;
592 ValaList* _tmp8_;
593 ValaList* _tmp9_;
594 ValadocContentNote* result = NULL;
595 g_return_val_if_fail (self != NULL, NULL);
596 g_return_val_if_fail (comment != NULL, NULL);
597 _tmp0_ = valadoc_gtkdoc_parser_parse_root_content (self, comment);
598 cmnt = _tmp0_;
599 _tmp1_ = cmnt;
600 if (_tmp1_ == NULL) {
601 result = NULL;
602 _g_object_unref0 (cmnt);
603 return result;
604 }
605 _tmp2_ = self->priv->factory;
606 _tmp3_ = valadoc_content_content_factory_create_note (_tmp2_);
607 note = _tmp3_;
608 _tmp4_ = note;
609 _tmp5_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) _tmp4_);
610 _tmp6_ = _tmp5_;
611 _tmp7_ = cmnt;
612 _tmp8_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) _tmp7_);
613 _tmp9_ = _tmp8_;
614 vala_collection_add_all ((ValaCollection*) _tmp6_, (ValaCollection*) _tmp9_);
615 result = note;
616 _g_object_unref0 (cmnt);
617 return result;
618 }
619
620 static void
valadoc_gtkdoc_parser_add_note(ValadocGtkdocParser * self,ValadocContentComment ** comment,ValadocContentNote * note)621 valadoc_gtkdoc_parser_add_note (ValadocGtkdocParser* self,
622 ValadocContentComment* * comment,
623 ValadocContentNote* note)
624 {
625 ValaList* _tmp2_;
626 ValaList* _tmp3_;
627 gint _tmp4_;
628 gint _tmp5_;
629 ValaList* _tmp11_;
630 ValaList* _tmp12_;
631 g_return_if_fail (self != NULL);
632 if (note == NULL) {
633 return;
634 }
635 if ((*comment) == NULL) {
636 ValadocContentContentFactory* _tmp0_;
637 ValadocContentComment* _tmp1_;
638 _tmp0_ = self->priv->factory;
639 _tmp1_ = valadoc_content_content_factory_create_comment (_tmp0_);
640 _g_object_unref0 (*comment);
641 *comment = _tmp1_;
642 }
643 _tmp2_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) (*comment));
644 _tmp3_ = _tmp2_;
645 _tmp4_ = vala_collection_get_size ((ValaCollection*) _tmp3_);
646 _tmp5_ = _tmp4_;
647 if (_tmp5_ == 0) {
648 ValaList* _tmp6_;
649 ValaList* _tmp7_;
650 ValadocContentContentFactory* _tmp8_;
651 ValadocContentParagraph* _tmp9_;
652 ValadocContentParagraph* _tmp10_;
653 _tmp6_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) (*comment));
654 _tmp7_ = _tmp6_;
655 _tmp8_ = self->priv->factory;
656 _tmp9_ = valadoc_content_content_factory_create_paragraph (_tmp8_);
657 _tmp10_ = _tmp9_;
658 vala_collection_add ((ValaCollection*) _tmp7_, (ValadocContentBlock*) _tmp10_);
659 _g_object_unref0 (_tmp10_);
660 }
661 _tmp11_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) (*comment));
662 _tmp12_ = _tmp11_;
663 vala_list_insert (_tmp12_, 1, (ValadocContentBlock*) note);
664 }
665
666 static void
valadoc_gtkdoc_parser_add_taglet(ValadocGtkdocParser * self,ValadocContentComment ** comment,ValadocContentTaglet * taglet)667 valadoc_gtkdoc_parser_add_taglet (ValadocGtkdocParser* self,
668 ValadocContentComment* * comment,
669 ValadocContentTaglet* taglet)
670 {
671 ValaList* _tmp2_;
672 ValaList* _tmp3_;
673 g_return_if_fail (self != NULL);
674 if (taglet == NULL) {
675 return;
676 }
677 if ((*comment) == NULL) {
678 ValadocContentContentFactory* _tmp0_;
679 ValadocContentComment* _tmp1_;
680 _tmp0_ = self->priv->factory;
681 _tmp1_ = valadoc_content_content_factory_create_comment (_tmp0_);
682 _g_object_unref0 (*comment);
683 *comment = _tmp1_;
684 }
685 _tmp2_ = valadoc_content_comment_get_taglets (*comment);
686 _tmp3_ = _tmp2_;
687 vala_collection_add ((ValaCollection*) _tmp3_, taglet);
688 }
689
690 static gpointer
_valadoc_importer_internal_id_registrar_ref0(gpointer self)691 _valadoc_importer_internal_id_registrar_ref0 (gpointer self)
692 {
693 return self ? valadoc_importer_internal_id_registrar_ref (self) : NULL;
694 }
695
696 static gpointer
_vala_iterable_ref0(gpointer self)697 _vala_iterable_ref0 (gpointer self)
698 {
699 return self ? vala_iterable_ref (self) : NULL;
700 }
701
702 ValadocContentComment*
valadoc_gtkdoc_parser_parse(ValadocGtkdocParser * self,ValadocApiNode * element,ValadocApiGirSourceComment * gir_comment,ValadocGirMetaData * gir_metadata,ValadocImporterInternalIdRegistrar * id_registrar)703 valadoc_gtkdoc_parser_parse (ValadocGtkdocParser* self,
704 ValadocApiNode* element,
705 ValadocApiGirSourceComment* gir_comment,
706 ValadocGirMetaData* gir_metadata,
707 ValadocImporterInternalIdRegistrar* id_registrar)
708 {
709 const gchar* _tmp0_;
710 const gchar* _tmp1_;
711 ValadocGirMetaData* _tmp2_;
712 ValadocImporterInternalIdRegistrar* _tmp3_;
713 ValadocApiNode* _tmp4_;
714 ValadocContentComment* cmnt = NULL;
715 ValadocContentComment* _tmp5_;
716 ValadocContentComment* _tmp6_;
717 ValadocApiSourceComment* _tmp9_;
718 ValadocApiSourceComment* _tmp10_;
719 ValadocApiSourceComment* _tmp15_;
720 ValadocApiSourceComment* _tmp16_;
721 ValadocApiSourceComment* _tmp21_;
722 ValadocApiSourceComment* _tmp22_;
723 ValadocApiSourceComment* _tmp27_;
724 ValadocApiSourceComment* _tmp28_;
725 ValaMapIterator* iter = NULL;
726 ValaMapIterator* _tmp33_;
727 gboolean first = FALSE;
728 ValadocContentComment* result = NULL;
729 g_return_val_if_fail (self != NULL, NULL);
730 g_return_val_if_fail (element != NULL, NULL);
731 g_return_val_if_fail (gir_comment != NULL, NULL);
732 g_return_val_if_fail (gir_metadata != NULL, NULL);
733 g_return_val_if_fail (id_registrar != NULL, NULL);
734 _tmp0_ = valadoc_api_gir_source_comment_get_instance_param_name (gir_comment);
735 _tmp1_ = _tmp0_;
736 self->priv->instance_param_name = _tmp1_;
737 _tmp2_ = _g_object_ref0 (gir_metadata);
738 _g_object_unref0 (self->priv->current_metadata);
739 self->priv->current_metadata = _tmp2_;
740 _tmp3_ = _valadoc_importer_internal_id_registrar_ref0 (id_registrar);
741 _valadoc_importer_internal_id_registrar_unref0 (self->priv->id_registrar);
742 self->priv->id_registrar = _tmp3_;
743 _tmp4_ = _g_object_ref0 (element);
744 _g_object_unref0 (self->priv->element);
745 self->priv->element = _tmp4_;
746 _tmp5_ = valadoc_gtkdoc_parser_parse_root_content (self, (ValadocApiSourceComment*) gir_comment);
747 cmnt = _tmp5_;
748 _tmp6_ = cmnt;
749 if (_tmp6_ != NULL) {
750 ValadocContentComment* _tmp7_;
751 ValadocContentContentFactory* _tmp8_;
752 _tmp7_ = cmnt;
753 _tmp8_ = self->priv->factory;
754 valadoc_importer_helper_extract_short_desc (_tmp7_, _tmp8_);
755 }
756 _tmp9_ = valadoc_api_gir_source_comment_get_deprecated_comment (gir_comment);
757 _tmp10_ = _tmp9_;
758 if (_tmp10_ != NULL) {
759 ValadocContentNote* note = NULL;
760 ValadocApiSourceComment* _tmp11_;
761 ValadocApiSourceComment* _tmp12_;
762 ValadocContentNote* _tmp13_;
763 ValadocContentNote* _tmp14_;
764 _tmp11_ = valadoc_api_gir_source_comment_get_deprecated_comment (gir_comment);
765 _tmp12_ = _tmp11_;
766 _tmp13_ = _valadoc_gtkdoc_parser_parse_note (self, _tmp12_);
767 note = _tmp13_;
768 _tmp14_ = note;
769 valadoc_gtkdoc_parser_add_note (self, &cmnt, _tmp14_);
770 _g_object_unref0 (note);
771 }
772 _tmp15_ = valadoc_api_gir_source_comment_get_version_comment (gir_comment);
773 _tmp16_ = _tmp15_;
774 if (_tmp16_ != NULL) {
775 ValadocContentNote* note = NULL;
776 ValadocApiSourceComment* _tmp17_;
777 ValadocApiSourceComment* _tmp18_;
778 ValadocContentNote* _tmp19_;
779 ValadocContentNote* _tmp20_;
780 _tmp17_ = valadoc_api_gir_source_comment_get_version_comment (gir_comment);
781 _tmp18_ = _tmp17_;
782 _tmp19_ = _valadoc_gtkdoc_parser_parse_note (self, _tmp18_);
783 note = _tmp19_;
784 _tmp20_ = note;
785 valadoc_gtkdoc_parser_add_note (self, &cmnt, _tmp20_);
786 _g_object_unref0 (note);
787 }
788 _tmp21_ = valadoc_api_gir_source_comment_get_stability_comment (gir_comment);
789 _tmp22_ = _tmp21_;
790 if (_tmp22_ != NULL) {
791 ValadocContentNote* note = NULL;
792 ValadocApiSourceComment* _tmp23_;
793 ValadocApiSourceComment* _tmp24_;
794 ValadocContentNote* _tmp25_;
795 ValadocContentNote* _tmp26_;
796 _tmp23_ = valadoc_api_gir_source_comment_get_stability_comment (gir_comment);
797 _tmp24_ = _tmp23_;
798 _tmp25_ = _valadoc_gtkdoc_parser_parse_note (self, _tmp24_);
799 note = _tmp25_;
800 _tmp26_ = note;
801 valadoc_gtkdoc_parser_add_note (self, &cmnt, _tmp26_);
802 _g_object_unref0 (note);
803 }
804 _tmp27_ = valadoc_api_gir_source_comment_get_return_comment (gir_comment);
805 _tmp28_ = _tmp27_;
806 if (_tmp28_ != NULL) {
807 ValadocContentTaglet* taglet = NULL;
808 ValadocApiSourceComment* _tmp29_;
809 ValadocApiSourceComment* _tmp30_;
810 ValadocContentTaglet* _tmp31_;
811 ValadocContentTaglet* _tmp32_;
812 _tmp29_ = valadoc_api_gir_source_comment_get_return_comment (gir_comment);
813 _tmp30_ = _tmp29_;
814 _tmp31_ = valadoc_gtkdoc_parser_parse_block_taglet (self, _tmp30_, "return");
815 taglet = _tmp31_;
816 _tmp32_ = taglet;
817 valadoc_gtkdoc_parser_add_taglet (self, &cmnt, _tmp32_);
818 _g_object_unref0 (taglet);
819 }
820 _tmp33_ = valadoc_api_gir_source_comment_parameter_iterator (gir_comment);
821 iter = _tmp33_;
822 {
823 gboolean has_next = FALSE;
824 ValaMapIterator* _tmp34_;
825 _tmp34_ = iter;
826 has_next = vala_map_iterator_next (_tmp34_);
827 {
828 gboolean _tmp35_ = FALSE;
829 _tmp35_ = TRUE;
830 while (TRUE) {
831 ValadocTagletsParam* taglet = NULL;
832 ValaMapIterator* _tmp37_;
833 gpointer _tmp38_;
834 ValadocApiSourceComment* _tmp39_;
835 ValadocContentTaglet* _tmp40_;
836 ValadocTagletsParam* _tmp41_;
837 ValadocTagletsParam* _tmp42_;
838 gchar* param_name = NULL;
839 ValaMapIterator* _tmp43_;
840 gpointer _tmp44_;
841 ValadocTagletsParam* _tmp45_;
842 const gchar* _tmp46_;
843 const gchar* _tmp47_;
844 const gchar* _tmp48_;
845 ValadocTagletsParam* _tmp49_;
846 const gchar* _tmp50_;
847 ValadocTagletsParam* _tmp51_;
848 if (!_tmp35_) {
849 ValaMapIterator* _tmp36_;
850 _tmp36_ = iter;
851 has_next = vala_map_iterator_next (_tmp36_);
852 }
853 _tmp35_ = FALSE;
854 if (!has_next) {
855 break;
856 }
857 _tmp37_ = iter;
858 _tmp38_ = vala_map_iterator_get_value (_tmp37_);
859 _tmp39_ = (ValadocApiSourceComment*) _tmp38_;
860 _tmp40_ = valadoc_gtkdoc_parser_parse_block_taglet (self, _tmp39_, "param");
861 _tmp41_ = VALADOC_TAGLETS_IS_PARAM (_tmp40_) ? ((ValadocTagletsParam*) _tmp40_) : NULL;
862 if (_tmp41_ == NULL) {
863 _g_object_unref0 (_tmp40_);
864 }
865 _tmp42_ = _tmp41_;
866 _valadoc_api_source_comment_unref0 (_tmp39_);
867 taglet = _tmp42_;
868 _tmp43_ = iter;
869 _tmp44_ = vala_map_iterator_get_key (_tmp43_);
870 param_name = (gchar*) _tmp44_;
871 _tmp45_ = taglet;
872 _tmp46_ = param_name;
873 _tmp47_ = valadoc_api_gir_source_comment_get_instance_param_name (gir_comment);
874 _tmp48_ = _tmp47_;
875 valadoc_taglets_param_set_is_c_self_param (_tmp45_, g_strcmp0 (_tmp46_, _tmp48_) == 0);
876 _tmp49_ = taglet;
877 _tmp50_ = param_name;
878 valadoc_taglets_param_set_parameter_name (_tmp49_, _tmp50_);
879 _tmp51_ = taglet;
880 valadoc_gtkdoc_parser_add_taglet (self, &cmnt, (ValadocContentTaglet*) _tmp51_);
881 _g_free0 (param_name);
882 _g_object_unref0 (taglet);
883 }
884 }
885 }
886 first = TRUE;
887 {
888 ValaList* _note_list = NULL;
889 ValaList* _tmp52_;
890 ValaList* _tmp53_;
891 gint _note_size = 0;
892 ValaList* _tmp54_;
893 gint _tmp55_;
894 gint _tmp56_;
895 gint _note_index = 0;
896 _tmp52_ = self->priv->footnotes;
897 _tmp53_ = _vala_iterable_ref0 (_tmp52_);
898 _note_list = _tmp53_;
899 _tmp54_ = _note_list;
900 _tmp55_ = vala_collection_get_size ((ValaCollection*) _tmp54_);
901 _tmp56_ = _tmp55_;
902 _note_size = _tmp56_;
903 _note_index = -1;
904 while (TRUE) {
905 gint _tmp57_;
906 gint _tmp58_;
907 ValaList* note = NULL;
908 ValaList* _tmp59_;
909 gpointer _tmp60_;
910 gboolean _tmp61_ = FALSE;
911 ValadocContentComment* _tmp82_;
912 ValaList* _tmp83_;
913 ValaList* _tmp84_;
914 ValaList* _tmp85_;
915 _note_index = _note_index + 1;
916 _tmp57_ = _note_index;
917 _tmp58_ = _note_size;
918 if (!(_tmp57_ < _tmp58_)) {
919 break;
920 }
921 _tmp59_ = _note_list;
922 _tmp60_ = vala_list_get (_tmp59_, _note_index);
923 note = (ValaList*) _tmp60_;
924 if (first == TRUE) {
925 ValaList* _tmp62_;
926 gint _tmp63_;
927 gint _tmp64_;
928 _tmp62_ = note;
929 _tmp63_ = vala_collection_get_size ((ValaCollection*) _tmp62_);
930 _tmp64_ = _tmp63_;
931 _tmp61_ = _tmp64_ > 0;
932 } else {
933 _tmp61_ = FALSE;
934 }
935 if (_tmp61_) {
936 ValadocContentParagraph* p = NULL;
937 ValaList* _tmp65_;
938 gpointer _tmp66_;
939 ValadocContentBlock* _tmp67_;
940 ValadocContentParagraph* _tmp68_;
941 ValadocContentParagraph* _tmp69_;
942 ValadocContentParagraph* _tmp76_;
943 ValaList* _tmp77_;
944 ValaList* _tmp78_;
945 ValadocContentContentFactory* _tmp79_;
946 ValadocContentText* _tmp80_;
947 ValadocContentText* _tmp81_;
948 _tmp65_ = note;
949 _tmp66_ = vala_list_first (_tmp65_);
950 _tmp67_ = (ValadocContentBlock*) _tmp66_;
951 _tmp68_ = VALADOC_CONTENT_IS_PARAGRAPH (_tmp67_) ? ((ValadocContentParagraph*) _tmp67_) : NULL;
952 if (_tmp68_ == NULL) {
953 _g_object_unref0 (_tmp67_);
954 }
955 p = _tmp68_;
956 _tmp69_ = p;
957 if (_tmp69_ == NULL) {
958 ValadocContentContentFactory* _tmp70_;
959 ValadocContentParagraph* _tmp71_;
960 ValadocContentComment* _tmp72_;
961 ValaList* _tmp73_;
962 ValaList* _tmp74_;
963 ValadocContentParagraph* _tmp75_;
964 _tmp70_ = self->priv->factory;
965 _tmp71_ = valadoc_content_content_factory_create_paragraph (_tmp70_);
966 _g_object_unref0 (p);
967 p = _tmp71_;
968 _tmp72_ = cmnt;
969 _tmp73_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) _tmp72_);
970 _tmp74_ = _tmp73_;
971 _tmp75_ = p;
972 vala_collection_add ((ValaCollection*) _tmp74_, (ValadocContentBlock*) _tmp75_);
973 }
974 _tmp76_ = p;
975 _tmp77_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp76_);
976 _tmp78_ = _tmp77_;
977 _tmp79_ = self->priv->factory;
978 _tmp80_ = valadoc_content_content_factory_create_text (_tmp79_, "\n");
979 _tmp81_ = _tmp80_;
980 vala_list_insert (_tmp78_, 0, (ValadocContentInline*) _tmp81_);
981 _g_object_unref0 (_tmp81_);
982 _g_object_unref0 (p);
983 }
984 _tmp82_ = cmnt;
985 _tmp83_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) _tmp82_);
986 _tmp84_ = _tmp83_;
987 _tmp85_ = note;
988 vala_collection_add_all ((ValaCollection*) _tmp84_, (ValaCollection*) _tmp85_);
989 first = FALSE;
990 _vala_iterable_unref0 (note);
991 }
992 _vala_iterable_unref0 (_note_list);
993 }
994 result = cmnt;
995 _vala_map_iterator_unref0 (iter);
996 return result;
997 }
998
999 static ValadocContentTaglet*
valadoc_gtkdoc_parser_parse_block_taglet(ValadocGtkdocParser * self,ValadocApiSourceComment * gir_comment,const gchar * taglet_name)1000 valadoc_gtkdoc_parser_parse_block_taglet (ValadocGtkdocParser* self,
1001 ValadocApiSourceComment* gir_comment,
1002 const gchar* taglet_name)
1003 {
1004 ValadocGtkdocToken* _tmp0_;
1005 ValadocGtkdocToken* _tmp1_;
1006 ValadocContentRun* ic = NULL;
1007 ValadocContentRun* _tmp2_;
1008 ValadocContentBlockContent* taglet = NULL;
1009 ValadocContentContentFactory* _tmp3_;
1010 ValadocContentTaglet* _tmp4_;
1011 ValadocContentBlockContent* _tmp5_;
1012 ValadocContentBlockContent* _tmp6_;
1013 ValadocContentParagraph* paragraph = NULL;
1014 ValadocContentContentFactory* _tmp7_;
1015 ValadocContentParagraph* _tmp8_;
1016 ValadocGtkdocToken* _tmp9_;
1017 ValadocGtkdocTokenType _tmp10_;
1018 ValadocContentBlockContent* _tmp16_;
1019 ValaList* _tmp17_;
1020 ValaList* _tmp18_;
1021 ValadocContentParagraph* _tmp19_;
1022 ValadocContentBlockContent* _tmp20_;
1023 ValadocContentTaglet* _tmp21_;
1024 ValadocContentTaglet* result = NULL;
1025 g_return_val_if_fail (self != NULL, NULL);
1026 g_return_val_if_fail (gir_comment != NULL, NULL);
1027 g_return_val_if_fail (taglet_name != NULL, NULL);
1028 valadoc_gtkdoc_parser_reset (self, gir_comment);
1029 _valadoc_gtkdoc_token_unref0 (self->priv->current);
1030 self->priv->current = NULL;
1031 _tmp0_ = valadoc_gtkdoc_parser_next (self);
1032 _tmp1_ = _tmp0_;
1033 _valadoc_gtkdoc_token_unref0 (_tmp1_);
1034 valadoc_gtkdoc_parser_parse_docbook_spaces (self, FALSE);
1035 _tmp2_ = valadoc_gtkdoc_parser_parse_inline_content (self);
1036 ic = _tmp2_;
1037 valadoc_gtkdoc_parser_parse_docbook_spaces (self, FALSE);
1038 _tmp3_ = self->priv->factory;
1039 _tmp4_ = valadoc_content_content_factory_create_taglet (_tmp3_, taglet_name);
1040 _tmp5_ = VALADOC_CONTENT_IS_BLOCK_CONTENT (_tmp4_) ? ((ValadocContentBlockContent*) _tmp4_) : NULL;
1041 if (_tmp5_ == NULL) {
1042 _g_object_unref0 (_tmp4_);
1043 }
1044 taglet = _tmp5_;
1045 _tmp6_ = taglet;
1046 _vala_assert (_tmp6_ != NULL, "taglet != null");
1047 _tmp7_ = self->priv->factory;
1048 _tmp8_ = valadoc_content_content_factory_create_paragraph (_tmp7_);
1049 paragraph = _tmp8_;
1050 _tmp9_ = self->priv->current;
1051 _tmp10_ = _tmp9_->type;
1052 if (_tmp10_ == VALADOC_GTKDOC_TOKEN_TYPE_EOF) {
1053 ValadocContentParagraph* _tmp11_;
1054 ValaList* _tmp12_;
1055 ValaList* _tmp13_;
1056 ValadocContentRun* _tmp14_;
1057 _tmp11_ = paragraph;
1058 _tmp12_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp11_);
1059 _tmp13_ = _tmp12_;
1060 _tmp14_ = ic;
1061 vala_collection_add ((ValaCollection*) _tmp13_, (ValadocContentInline*) _tmp14_);
1062 } else {
1063 ValadocGtkdocToken* _tmp15_;
1064 _tmp15_ = self->priv->current;
1065 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp15_, "<EOF>");
1066 }
1067 _tmp16_ = taglet;
1068 _tmp17_ = valadoc_content_block_content_get_content (_tmp16_);
1069 _tmp18_ = _tmp17_;
1070 _tmp19_ = paragraph;
1071 vala_collection_add ((ValaCollection*) _tmp18_, (ValadocContentBlock*) _tmp19_);
1072 _tmp20_ = taglet;
1073 _tmp21_ = _g_object_ref0 (VALADOC_CONTENT_IS_TAGLET (_tmp20_) ? ((ValadocContentTaglet*) _tmp20_) : NULL);
1074 result = _tmp21_;
1075 _g_object_unref0 (paragraph);
1076 _g_object_unref0 (taglet);
1077 _g_object_unref0 (ic);
1078 return result;
1079 }
1080
1081 static gpointer
_valadoc_gtkdoc_token_ref0(gpointer self)1082 _valadoc_gtkdoc_token_ref0 (gpointer self)
1083 {
1084 return self ? valadoc_gtkdoc_token_ref (self) : NULL;
1085 }
1086
1087 static ValadocContentComment*
valadoc_gtkdoc_parser_parse_root_content(ValadocGtkdocParser * self,ValadocApiSourceComment * gir_comment)1088 valadoc_gtkdoc_parser_parse_root_content (ValadocGtkdocParser* self,
1089 ValadocApiSourceComment* gir_comment)
1090 {
1091 ValadocGtkdocToken* _tmp0_;
1092 ValadocGtkdocToken* _tmp1_;
1093 ValadocGtkdocToken* tmp = NULL;
1094 ValadocContentComment* comment = NULL;
1095 ValadocContentContentFactory* _tmp2_;
1096 ValadocContentComment* _tmp3_;
1097 ValadocGtkdocToken* _tmp39_;
1098 ValadocGtkdocTokenType _tmp40_;
1099 ValadocContentComment* _tmp42_;
1100 ValadocContentContentFactory* _tmp43_;
1101 ValadocContentComment* result = NULL;
1102 g_return_val_if_fail (self != NULL, NULL);
1103 g_return_val_if_fail (gir_comment != NULL, NULL);
1104 valadoc_gtkdoc_parser_reset (self, gir_comment);
1105 _valadoc_gtkdoc_token_unref0 (self->priv->current);
1106 self->priv->current = NULL;
1107 _tmp0_ = valadoc_gtkdoc_parser_next (self);
1108 _tmp1_ = _tmp0_;
1109 _valadoc_gtkdoc_token_unref0 (_tmp1_);
1110 tmp = NULL;
1111 valadoc_gtkdoc_parser_parse_docbook_spaces (self, FALSE);
1112 _tmp2_ = self->priv->factory;
1113 _tmp3_ = valadoc_content_content_factory_create_comment (_tmp2_);
1114 comment = _tmp3_;
1115 while (TRUE) {
1116 gboolean _tmp4_ = FALSE;
1117 ValadocGtkdocToken* _tmp5_;
1118 ValadocGtkdocTokenType _tmp6_;
1119 ValadocGtkdocToken* _tmp9_;
1120 ValadocGtkdocToken* _tmp10_;
1121 ValadocContentRun* ic = NULL;
1122 ValadocContentRun* _tmp11_;
1123 gboolean _tmp12_ = FALSE;
1124 ValadocContentRun* _tmp13_;
1125 ValaCollection* bc = NULL;
1126 ValaCollection* _tmp29_;
1127 gboolean _tmp30_ = FALSE;
1128 ValaCollection* _tmp31_;
1129 _tmp5_ = self->priv->current;
1130 _tmp6_ = _tmp5_->type;
1131 if (_tmp6_ != VALADOC_GTKDOC_TOKEN_TYPE_EOF) {
1132 ValadocGtkdocToken* _tmp7_;
1133 ValadocGtkdocToken* _tmp8_;
1134 _tmp7_ = tmp;
1135 _tmp8_ = self->priv->current;
1136 _tmp4_ = _tmp7_ != _tmp8_;
1137 } else {
1138 _tmp4_ = FALSE;
1139 }
1140 if (!_tmp4_) {
1141 break;
1142 }
1143 _tmp9_ = self->priv->current;
1144 _tmp10_ = _valadoc_gtkdoc_token_ref0 (_tmp9_);
1145 _valadoc_gtkdoc_token_unref0 (tmp);
1146 tmp = _tmp10_;
1147 _tmp11_ = valadoc_gtkdoc_parser_parse_inline_content (self);
1148 ic = _tmp11_;
1149 _tmp13_ = ic;
1150 if (_tmp13_ != NULL) {
1151 ValadocContentRun* _tmp14_;
1152 ValaList* _tmp15_;
1153 ValaList* _tmp16_;
1154 gint _tmp17_;
1155 gint _tmp18_;
1156 _tmp14_ = ic;
1157 _tmp15_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp14_);
1158 _tmp16_ = _tmp15_;
1159 _tmp17_ = vala_collection_get_size ((ValaCollection*) _tmp16_);
1160 _tmp18_ = _tmp17_;
1161 _tmp12_ = _tmp18_ > 0;
1162 } else {
1163 _tmp12_ = FALSE;
1164 }
1165 if (_tmp12_) {
1166 ValadocContentParagraph* p = NULL;
1167 ValadocContentContentFactory* _tmp19_;
1168 ValadocContentParagraph* _tmp20_;
1169 ValadocContentParagraph* _tmp21_;
1170 ValaList* _tmp22_;
1171 ValaList* _tmp23_;
1172 ValadocContentRun* _tmp24_;
1173 ValadocContentComment* _tmp25_;
1174 ValaList* _tmp26_;
1175 ValaList* _tmp27_;
1176 ValadocContentParagraph* _tmp28_;
1177 _tmp19_ = self->priv->factory;
1178 _tmp20_ = valadoc_content_content_factory_create_paragraph (_tmp19_);
1179 p = _tmp20_;
1180 _tmp21_ = p;
1181 _tmp22_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp21_);
1182 _tmp23_ = _tmp22_;
1183 _tmp24_ = ic;
1184 vala_collection_add ((ValaCollection*) _tmp23_, (ValadocContentInline*) _tmp24_);
1185 _tmp25_ = comment;
1186 _tmp26_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) _tmp25_);
1187 _tmp27_ = _tmp26_;
1188 _tmp28_ = p;
1189 vala_collection_add ((ValaCollection*) _tmp27_, (ValadocContentBlock*) _tmp28_);
1190 _g_object_unref0 (p);
1191 }
1192 _tmp29_ = valadoc_gtkdoc_parser_parse_block_content (self);
1193 bc = _tmp29_;
1194 _tmp31_ = bc;
1195 if (_tmp31_ != NULL) {
1196 ValaCollection* _tmp32_;
1197 gint _tmp33_;
1198 gint _tmp34_;
1199 _tmp32_ = bc;
1200 _tmp33_ = vala_collection_get_size (_tmp32_);
1201 _tmp34_ = _tmp33_;
1202 _tmp30_ = _tmp34_ > 0;
1203 } else {
1204 _tmp30_ = FALSE;
1205 }
1206 if (_tmp30_) {
1207 ValadocContentComment* _tmp35_;
1208 ValaList* _tmp36_;
1209 ValaList* _tmp37_;
1210 ValaCollection* _tmp38_;
1211 _tmp35_ = comment;
1212 _tmp36_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) _tmp35_);
1213 _tmp37_ = _tmp36_;
1214 _tmp38_ = bc;
1215 vala_collection_add_all ((ValaCollection*) _tmp37_, _tmp38_);
1216 }
1217 _vala_iterable_unref0 (bc);
1218 _g_object_unref0 (ic);
1219 }
1220 _tmp39_ = self->priv->current;
1221 _tmp40_ = _tmp39_->type;
1222 if (_tmp40_ != VALADOC_GTKDOC_TOKEN_TYPE_EOF) {
1223 ValadocGtkdocToken* _tmp41_;
1224 _tmp41_ = self->priv->current;
1225 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp41_, "<INLINE|BLOCK>");
1226 result = NULL;
1227 _g_object_unref0 (comment);
1228 _valadoc_gtkdoc_token_unref0 (tmp);
1229 return result;
1230 }
1231 _tmp42_ = comment;
1232 _tmp43_ = self->priv->factory;
1233 valadoc_importer_helper_extract_short_desc (_tmp42_, _tmp43_);
1234 result = comment;
1235 _valadoc_gtkdoc_token_unref0 (tmp);
1236 return result;
1237 }
1238
1239 static ValadocGtkdocToken*
valadoc_gtkdoc_parser_next(ValadocGtkdocParser * self)1240 valadoc_gtkdoc_parser_next (ValadocGtkdocParser* self)
1241 {
1242 ValadocGtkdocScanner* _tmp0_;
1243 ValadocGtkdocToken* _tmp1_;
1244 ValadocGtkdocToken* _tmp2_;
1245 ValadocGtkdocToken* _tmp3_;
1246 ValadocGtkdocToken* result = NULL;
1247 g_return_val_if_fail (self != NULL, NULL);
1248 _tmp0_ = self->priv->scanner;
1249 _tmp1_ = valadoc_gtkdoc_scanner_next (_tmp0_);
1250 _valadoc_gtkdoc_token_unref0 (self->priv->current);
1251 self->priv->current = _tmp1_;
1252 _tmp2_ = self->priv->current;
1253 _tmp3_ = _valadoc_gtkdoc_token_ref0 (_tmp2_);
1254 result = _tmp3_;
1255 return result;
1256 }
1257
1258 static gboolean
valadoc_gtkdoc_parser_ignore_current_xml_close(ValadocGtkdocParser * self)1259 valadoc_gtkdoc_parser_ignore_current_xml_close (ValadocGtkdocParser* self)
1260 {
1261 ValadocGtkdocToken* _tmp0_;
1262 ValadocGtkdocTokenType _tmp1_;
1263 gchar* name = NULL;
1264 ValadocGtkdocToken* _tmp2_;
1265 const gchar* _tmp3_;
1266 gchar* _tmp4_;
1267 ValaList* _tmp5_;
1268 const gchar* _tmp6_;
1269 gboolean result = FALSE;
1270 g_return_val_if_fail (self != NULL, FALSE);
1271 _tmp0_ = self->priv->current;
1272 _tmp1_ = _tmp0_->type;
1273 if (_tmp1_ != VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE) {
1274 result = FALSE;
1275 return result;
1276 }
1277 _tmp2_ = self->priv->current;
1278 _tmp3_ = _tmp2_->content;
1279 _tmp4_ = g_strdup (_tmp3_);
1280 name = _tmp4_;
1281 _tmp5_ = self->priv->stack;
1282 _tmp6_ = name;
1283 if (vala_collection_contains ((ValaCollection*) _tmp5_, _tmp6_) == FALSE) {
1284 result = TRUE;
1285 _g_free0 (name);
1286 return result;
1287 }
1288 result = FALSE;
1289 _g_free0 (name);
1290 return result;
1291 }
1292
1293 static gboolean
valadoc_gtkdoc_parser_check_xml_open_tag(ValadocGtkdocParser * self,const gchar * tagname)1294 valadoc_gtkdoc_parser_check_xml_open_tag (ValadocGtkdocParser* self,
1295 const gchar* tagname)
1296 {
1297 gboolean _tmp0_ = FALSE;
1298 gboolean _tmp1_ = FALSE;
1299 ValadocGtkdocToken* _tmp2_;
1300 ValadocGtkdocTokenType _tmp3_;
1301 ValaList* _tmp8_;
1302 gboolean result = FALSE;
1303 g_return_val_if_fail (self != NULL, FALSE);
1304 g_return_val_if_fail (tagname != NULL, FALSE);
1305 _tmp2_ = self->priv->current;
1306 _tmp3_ = _tmp2_->type;
1307 if (_tmp3_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
1308 ValadocGtkdocToken* _tmp4_;
1309 const gchar* _tmp5_;
1310 _tmp4_ = self->priv->current;
1311 _tmp5_ = _tmp4_->content;
1312 _tmp1_ = g_strcmp0 (_tmp5_, tagname) != 0;
1313 } else {
1314 _tmp1_ = FALSE;
1315 }
1316 if (_tmp1_) {
1317 _tmp0_ = TRUE;
1318 } else {
1319 ValadocGtkdocToken* _tmp6_;
1320 ValadocGtkdocTokenType _tmp7_;
1321 _tmp6_ = self->priv->current;
1322 _tmp7_ = _tmp6_->type;
1323 _tmp0_ = _tmp7_ != VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN;
1324 }
1325 if (_tmp0_) {
1326 result = FALSE;
1327 return result;
1328 }
1329 _tmp8_ = self->priv->stack;
1330 vala_list_insert (_tmp8_, 0, tagname);
1331 result = TRUE;
1332 return result;
1333 }
1334
1335 static gboolean
valadoc_gtkdoc_parser_check_xml_close_tag(ValadocGtkdocParser * self,const gchar * tagname)1336 valadoc_gtkdoc_parser_check_xml_close_tag (ValadocGtkdocParser* self,
1337 const gchar* tagname)
1338 {
1339 gboolean _tmp0_ = FALSE;
1340 gboolean _tmp1_ = FALSE;
1341 ValadocGtkdocToken* _tmp2_;
1342 ValadocGtkdocTokenType _tmp3_;
1343 ValaList* _tmp8_;
1344 gpointer _tmp9_;
1345 gchar* _tmp10_;
1346 gboolean result = FALSE;
1347 g_return_val_if_fail (self != NULL, FALSE);
1348 g_return_val_if_fail (tagname != NULL, FALSE);
1349 _tmp2_ = self->priv->current;
1350 _tmp3_ = _tmp2_->type;
1351 if (_tmp3_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE) {
1352 ValadocGtkdocToken* _tmp4_;
1353 const gchar* _tmp5_;
1354 _tmp4_ = self->priv->current;
1355 _tmp5_ = _tmp4_->content;
1356 _tmp1_ = g_strcmp0 (_tmp5_, tagname) != 0;
1357 } else {
1358 _tmp1_ = FALSE;
1359 }
1360 if (_tmp1_) {
1361 _tmp0_ = TRUE;
1362 } else {
1363 ValadocGtkdocToken* _tmp6_;
1364 ValadocGtkdocTokenType _tmp7_;
1365 _tmp6_ = self->priv->current;
1366 _tmp7_ = _tmp6_->type;
1367 _tmp0_ = _tmp7_ != VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE;
1368 }
1369 if (_tmp0_) {
1370 result = FALSE;
1371 return result;
1372 }
1373 _tmp8_ = self->priv->stack;
1374 _tmp9_ = vala_list_remove_at (_tmp8_, 0);
1375 _tmp10_ = (gchar*) _tmp9_;
1376 _vala_assert (g_strcmp0 (_tmp10_, tagname) == 0, "stack.remove_at (0) == tagname");
1377 _g_free0 (_tmp10_);
1378 result = TRUE;
1379 return result;
1380 }
1381
1382 static void
valadoc_gtkdoc_parser_parse_docbook_spaces(ValadocGtkdocParser * self,gboolean accept_paragraphs)1383 valadoc_gtkdoc_parser_parse_docbook_spaces (ValadocGtkdocParser* self,
1384 gboolean accept_paragraphs)
1385 {
1386 g_return_if_fail (self != NULL);
1387 while (TRUE) {
1388 ValadocGtkdocToken* _tmp0_;
1389 ValadocGtkdocTokenType _tmp1_;
1390 _tmp0_ = self->priv->current;
1391 _tmp1_ = _tmp0_->type;
1392 if (_tmp1_ == VALADOC_GTKDOC_TOKEN_TYPE_SPACE) {
1393 ValadocGtkdocToken* _tmp2_;
1394 ValadocGtkdocToken* _tmp3_;
1395 _tmp2_ = valadoc_gtkdoc_parser_next (self);
1396 _tmp3_ = _tmp2_;
1397 _valadoc_gtkdoc_token_unref0 (_tmp3_);
1398 } else {
1399 ValadocGtkdocToken* _tmp4_;
1400 ValadocGtkdocTokenType _tmp5_;
1401 _tmp4_ = self->priv->current;
1402 _tmp5_ = _tmp4_->type;
1403 if (_tmp5_ == VALADOC_GTKDOC_TOKEN_TYPE_NEWLINE) {
1404 ValadocGtkdocToken* _tmp6_;
1405 ValadocGtkdocToken* _tmp7_;
1406 _tmp6_ = valadoc_gtkdoc_parser_next (self);
1407 _tmp7_ = _tmp6_;
1408 _valadoc_gtkdoc_token_unref0 (_tmp7_);
1409 } else {
1410 gboolean _tmp8_ = FALSE;
1411 if (accept_paragraphs) {
1412 ValadocGtkdocToken* _tmp9_;
1413 ValadocGtkdocTokenType _tmp10_;
1414 _tmp9_ = self->priv->current;
1415 _tmp10_ = _tmp9_->type;
1416 _tmp8_ = _tmp10_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_PARAGRAPH;
1417 } else {
1418 _tmp8_ = FALSE;
1419 }
1420 if (_tmp8_) {
1421 ValadocGtkdocToken* _tmp11_;
1422 ValadocGtkdocToken* _tmp12_;
1423 _tmp11_ = valadoc_gtkdoc_parser_next (self);
1424 _tmp12_ = _tmp11_;
1425 _valadoc_gtkdoc_token_unref0 (_tmp12_);
1426 } else {
1427 break;
1428 }
1429 }
1430 }
1431 }
1432 }
1433
1434 static ValadocContentInline*
valadoc_gtkdoc_parser_parse_docbook_link_tempalte(ValadocGtkdocParser * self,const gchar * tagname,gboolean is_internal)1435 valadoc_gtkdoc_parser_parse_docbook_link_tempalte (ValadocGtkdocParser* self,
1436 const gchar* tagname,
1437 gboolean is_internal)
1438 {
1439 GString* builder = NULL;
1440 GString* _tmp3_;
1441 gchar* url = NULL;
1442 ValadocGtkdocToken* _tmp10_;
1443 ValadocGtkdocToken* _tmp11_;
1444 ValadocContentLink* link = NULL;
1445 ValadocContentContentFactory* _tmp31_;
1446 ValadocContentLink* _tmp32_;
1447 ValadocContentLink* _tmp35_;
1448 const gchar* _tmp36_;
1449 GString* _tmp37_;
1450 ValadocGtkdocToken* _tmp58_;
1451 ValadocGtkdocToken* _tmp59_;
1452 ValadocContentInline* result = NULL;
1453 g_return_val_if_fail (self != NULL, NULL);
1454 g_return_val_if_fail (tagname != NULL, NULL);
1455 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, tagname)) {
1456 ValadocGtkdocToken* _tmp0_;
1457 gchar* _tmp1_;
1458 gchar* _tmp2_;
1459 _tmp0_ = self->priv->current;
1460 _tmp1_ = g_strdup_printf ("<%s>", tagname);
1461 _tmp2_ = _tmp1_;
1462 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, _tmp2_);
1463 _g_free0 (_tmp2_);
1464 result = NULL;
1465 return result;
1466 }
1467 _tmp3_ = g_string_new ("");
1468 builder = _tmp3_;
1469 if (is_internal) {
1470 ValadocGtkdocToken* _tmp4_;
1471 ValaHashMap* _tmp5_;
1472 gpointer _tmp6_;
1473 _tmp4_ = self->priv->current;
1474 _tmp5_ = _tmp4_->attributes;
1475 _tmp6_ = vala_map_get ((ValaMap*) _tmp5_, "linkend");
1476 _g_free0 (url);
1477 url = (gchar*) _tmp6_;
1478 } else {
1479 ValadocGtkdocToken* _tmp7_;
1480 ValaHashMap* _tmp8_;
1481 gpointer _tmp9_;
1482 _tmp7_ = self->priv->current;
1483 _tmp8_ = _tmp7_->attributes;
1484 _tmp9_ = vala_map_get ((ValaMap*) _tmp8_, "url");
1485 _g_free0 (url);
1486 url = (gchar*) _tmp9_;
1487 }
1488 _tmp10_ = valadoc_gtkdoc_parser_next (self);
1489 _tmp11_ = _tmp10_;
1490 _valadoc_gtkdoc_token_unref0 (_tmp11_);
1491 while (TRUE) {
1492 gboolean _tmp12_ = FALSE;
1493 gboolean _tmp13_ = FALSE;
1494 ValadocGtkdocToken* _tmp14_;
1495 ValadocGtkdocTokenType _tmp15_;
1496 ValadocGtkdocToken* _tmp20_;
1497 ValadocGtkdocTokenType _tmp21_;
1498 ValadocGtkdocToken* _tmp29_;
1499 ValadocGtkdocToken* _tmp30_;
1500 _tmp14_ = self->priv->current;
1501 _tmp15_ = _tmp14_->type;
1502 if (_tmp15_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE) {
1503 ValadocGtkdocToken* _tmp16_;
1504 const gchar* _tmp17_;
1505 _tmp16_ = self->priv->current;
1506 _tmp17_ = _tmp16_->content;
1507 _tmp13_ = g_strcmp0 (_tmp17_, tagname) == 0;
1508 } else {
1509 _tmp13_ = FALSE;
1510 }
1511 if (!_tmp13_) {
1512 ValadocGtkdocToken* _tmp18_;
1513 ValadocGtkdocTokenType _tmp19_;
1514 _tmp18_ = self->priv->current;
1515 _tmp19_ = _tmp18_->type;
1516 _tmp12_ = _tmp19_ != VALADOC_GTKDOC_TOKEN_TYPE_EOF;
1517 } else {
1518 _tmp12_ = FALSE;
1519 }
1520 if (!_tmp12_) {
1521 break;
1522 }
1523 _tmp20_ = self->priv->current;
1524 _tmp21_ = _tmp20_->type;
1525 if (_tmp21_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
1526 } else {
1527 ValadocGtkdocToken* _tmp22_;
1528 ValadocGtkdocTokenType _tmp23_;
1529 _tmp22_ = self->priv->current;
1530 _tmp23_ = _tmp22_->type;
1531 if (_tmp23_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE) {
1532 } else {
1533 ValadocGtkdocToken* _tmp24_;
1534 ValadocGtkdocTokenType _tmp25_;
1535 _tmp24_ = self->priv->current;
1536 _tmp25_ = _tmp24_->type;
1537 if (_tmp25_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_COMMENT) {
1538 } else {
1539 GString* _tmp26_;
1540 ValadocGtkdocToken* _tmp27_;
1541 const gchar* _tmp28_;
1542 _tmp26_ = builder;
1543 _tmp27_ = self->priv->current;
1544 _tmp28_ = _tmp27_->content;
1545 g_string_append (_tmp26_, _tmp28_);
1546 }
1547 }
1548 }
1549 _tmp29_ = valadoc_gtkdoc_parser_next (self);
1550 _tmp30_ = _tmp29_;
1551 _valadoc_gtkdoc_token_unref0 (_tmp30_);
1552 }
1553 _tmp31_ = self->priv->factory;
1554 _tmp32_ = valadoc_content_content_factory_create_link (_tmp31_);
1555 link = _tmp32_;
1556 if (is_internal) {
1557 ValadocContentLink* _tmp33_;
1558 ValadocImporterInternalIdRegistrar* _tmp34_;
1559 _tmp33_ = link;
1560 _tmp34_ = self->priv->id_registrar;
1561 valadoc_content_link_set_id_registrar (_tmp33_, _tmp34_);
1562 }
1563 _tmp35_ = link;
1564 _tmp36_ = url;
1565 valadoc_content_link_set_url (_tmp35_, _tmp36_);
1566 _tmp37_ = builder;
1567 if (_tmp37_->len == ((gssize) 0)) {
1568 ValadocContentLink* _tmp38_;
1569 ValaList* _tmp39_;
1570 ValaList* _tmp40_;
1571 ValadocContentContentFactory* _tmp41_;
1572 const gchar* _tmp42_;
1573 ValadocContentText* _tmp43_;
1574 ValadocContentText* _tmp44_;
1575 _tmp38_ = link;
1576 _tmp39_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp38_);
1577 _tmp40_ = _tmp39_;
1578 _tmp41_ = self->priv->factory;
1579 _tmp42_ = url;
1580 _tmp43_ = valadoc_content_content_factory_create_text (_tmp41_, _tmp42_);
1581 _tmp44_ = _tmp43_;
1582 vala_collection_add ((ValaCollection*) _tmp40_, (ValadocContentInline*) _tmp44_);
1583 _g_object_unref0 (_tmp44_);
1584 } else {
1585 ValadocContentLink* _tmp45_;
1586 ValaList* _tmp46_;
1587 ValaList* _tmp47_;
1588 ValadocContentContentFactory* _tmp48_;
1589 GString* _tmp49_;
1590 const gchar* _tmp50_;
1591 gchar* _tmp51_;
1592 gchar* _tmp52_;
1593 ValadocContentText* _tmp53_;
1594 ValadocContentText* _tmp54_;
1595 _tmp45_ = link;
1596 _tmp46_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp45_);
1597 _tmp47_ = _tmp46_;
1598 _tmp48_ = self->priv->factory;
1599 _tmp49_ = builder;
1600 _tmp50_ = _tmp49_->str;
1601 _tmp51_ = valadoc_gtkdoc_parser_normalize (self, _tmp50_);
1602 _tmp52_ = _tmp51_;
1603 _tmp53_ = valadoc_content_content_factory_create_text (_tmp48_, _tmp52_);
1604 _tmp54_ = _tmp53_;
1605 vala_collection_add ((ValaCollection*) _tmp47_, (ValadocContentInline*) _tmp54_);
1606 _g_object_unref0 (_tmp54_);
1607 _g_free0 (_tmp52_);
1608 }
1609 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, tagname)) {
1610 ValadocGtkdocToken* _tmp55_;
1611 gchar* _tmp56_;
1612 gchar* _tmp57_;
1613 _tmp55_ = self->priv->current;
1614 _tmp56_ = g_strdup_printf ("</%s>", tagname);
1615 _tmp57_ = _tmp56_;
1616 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp55_, _tmp57_);
1617 _g_free0 (_tmp57_);
1618 result = (ValadocContentInline*) link;
1619 _g_free0 (url);
1620 _g_string_free0 (builder);
1621 return result;
1622 }
1623 _tmp58_ = valadoc_gtkdoc_parser_next (self);
1624 _tmp59_ = _tmp58_;
1625 _valadoc_gtkdoc_token_unref0 (_tmp59_);
1626 result = (ValadocContentInline*) link;
1627 _g_free0 (url);
1628 _g_string_free0 (builder);
1629 return result;
1630 }
1631
1632 static ValadocContentInlineTaglet*
valadoc_gtkdoc_parser_parse_symbol_link(ValadocGtkdocParser * self,const gchar * tagname)1633 valadoc_gtkdoc_parser_parse_symbol_link (ValadocGtkdocParser* self,
1634 const gchar* tagname)
1635 {
1636 ValadocGtkdocToken* _tmp3_;
1637 ValadocGtkdocToken* _tmp4_;
1638 ValadocGtkdocTokenType _tmp5_;
1639 gboolean _tmp6_;
1640 ValadocContentInlineTaglet* taglet = NULL;
1641 gboolean _tmp9_ = FALSE;
1642 ValadocGtkdocToken* _tmp10_;
1643 ValadocGtkdocTokenType _tmp11_;
1644 gboolean _tmp22_ = FALSE;
1645 gboolean _tmp23_ = FALSE;
1646 gboolean _tmp24_ = FALSE;
1647 gboolean _tmp25_ = FALSE;
1648 gboolean _tmp26_ = FALSE;
1649 ValadocGtkdocToken* _tmp27_;
1650 ValadocGtkdocTokenType _tmp28_;
1651 ValadocGtkdocToken* _tmp44_;
1652 ValadocGtkdocToken* _tmp45_;
1653 ValadocGtkdocTokenType _tmp46_;
1654 gboolean _tmp47_;
1655 ValadocGtkdocToken* _tmp53_;
1656 ValadocGtkdocToken* _tmp54_;
1657 ValadocContentInlineTaglet* result = NULL;
1658 g_return_val_if_fail (self != NULL, NULL);
1659 g_return_val_if_fail (tagname != NULL, NULL);
1660 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, tagname)) {
1661 ValadocGtkdocToken* _tmp0_;
1662 gchar* _tmp1_;
1663 gchar* _tmp2_;
1664 _tmp0_ = self->priv->current;
1665 _tmp1_ = g_strdup_printf ("<%s>", tagname);
1666 _tmp2_ = _tmp1_;
1667 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, _tmp2_);
1668 _g_free0 (_tmp2_);
1669 result = NULL;
1670 return result;
1671 }
1672 _tmp3_ = valadoc_gtkdoc_parser_next (self);
1673 _tmp4_ = _tmp3_;
1674 _tmp5_ = _tmp4_->type;
1675 _tmp6_ = _tmp5_ == VALADOC_GTKDOC_TOKEN_TYPE_SPACE;
1676 _valadoc_gtkdoc_token_unref0 (_tmp4_);
1677 if (_tmp6_) {
1678 ValadocGtkdocToken* _tmp7_;
1679 ValadocGtkdocToken* _tmp8_;
1680 _tmp7_ = valadoc_gtkdoc_parser_next (self);
1681 _tmp8_ = _tmp7_;
1682 _valadoc_gtkdoc_token_unref0 (_tmp8_);
1683 }
1684 taglet = NULL;
1685 _tmp10_ = self->priv->current;
1686 _tmp11_ = _tmp10_->type;
1687 if (_tmp11_ == VALADOC_GTKDOC_TOKEN_TYPE_WORD) {
1688 ValadocGtkdocToken* _tmp12_;
1689 const gchar* _tmp13_;
1690 _tmp12_ = self->priv->current;
1691 _tmp13_ = _tmp12_->content;
1692 _tmp9_ = g_strcmp0 (_tmp13_, "struct") == 0;
1693 } else {
1694 _tmp9_ = FALSE;
1695 }
1696 if (_tmp9_) {
1697 ValadocGtkdocToken* _tmp14_;
1698 ValadocGtkdocToken* _tmp15_;
1699 ValadocGtkdocToken* _tmp16_;
1700 ValadocGtkdocToken* _tmp17_;
1701 ValadocGtkdocTokenType _tmp18_;
1702 gboolean _tmp19_;
1703 _tmp14_ = valadoc_gtkdoc_parser_next (self);
1704 _tmp15_ = _tmp14_;
1705 _valadoc_gtkdoc_token_unref0 (_tmp15_);
1706 _tmp16_ = valadoc_gtkdoc_parser_next (self);
1707 _tmp17_ = _tmp16_;
1708 _tmp18_ = _tmp17_->type;
1709 _tmp19_ = _tmp18_ == VALADOC_GTKDOC_TOKEN_TYPE_SPACE;
1710 _valadoc_gtkdoc_token_unref0 (_tmp17_);
1711 if (_tmp19_) {
1712 ValadocGtkdocToken* _tmp20_;
1713 ValadocGtkdocToken* _tmp21_;
1714 _tmp20_ = valadoc_gtkdoc_parser_next (self);
1715 _tmp21_ = _tmp20_;
1716 _valadoc_gtkdoc_token_unref0 (_tmp21_);
1717 }
1718 }
1719 _tmp27_ = self->priv->current;
1720 _tmp28_ = _tmp27_->type;
1721 if (_tmp28_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_FUNCTION) {
1722 _tmp26_ = TRUE;
1723 } else {
1724 ValadocGtkdocToken* _tmp29_;
1725 ValadocGtkdocTokenType _tmp30_;
1726 _tmp29_ = self->priv->current;
1727 _tmp30_ = _tmp29_->type;
1728 _tmp26_ = _tmp30_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_CONST;
1729 }
1730 if (_tmp26_) {
1731 _tmp25_ = TRUE;
1732 } else {
1733 ValadocGtkdocToken* _tmp31_;
1734 ValadocGtkdocTokenType _tmp32_;
1735 _tmp31_ = self->priv->current;
1736 _tmp32_ = _tmp31_->type;
1737 _tmp25_ = _tmp32_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_TYPE;
1738 }
1739 if (_tmp25_) {
1740 _tmp24_ = TRUE;
1741 } else {
1742 ValadocGtkdocToken* _tmp33_;
1743 ValadocGtkdocTokenType _tmp34_;
1744 _tmp33_ = self->priv->current;
1745 _tmp34_ = _tmp33_->type;
1746 _tmp24_ = _tmp34_ == VALADOC_GTKDOC_TOKEN_TYPE_WORD;
1747 }
1748 if (_tmp24_) {
1749 _tmp23_ = TRUE;
1750 } else {
1751 ValadocGtkdocToken* _tmp35_;
1752 ValadocGtkdocTokenType _tmp36_;
1753 _tmp35_ = self->priv->current;
1754 _tmp36_ = _tmp35_->type;
1755 _tmp23_ = _tmp36_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_PROPERTY;
1756 }
1757 if (_tmp23_) {
1758 _tmp22_ = TRUE;
1759 } else {
1760 ValadocGtkdocToken* _tmp37_;
1761 ValadocGtkdocTokenType _tmp38_;
1762 _tmp37_ = self->priv->current;
1763 _tmp38_ = _tmp37_->type;
1764 _tmp22_ = _tmp38_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_SIGNAL;
1765 }
1766 if (_tmp22_) {
1767 ValadocGtkdocToken* _tmp39_;
1768 const gchar* _tmp40_;
1769 ValadocContentInline* _tmp41_;
1770 ValadocContentInlineTaglet* _tmp42_;
1771 ValadocContentInlineTaglet* _tmp43_;
1772 _tmp39_ = self->priv->current;
1773 _tmp40_ = _tmp39_->content;
1774 _tmp41_ = valadoc_gtkdoc_parser_create_type_link (self, _tmp40_, FALSE);
1775 _tmp42_ = VALADOC_CONTENT_IS_INLINE_TAGLET (_tmp41_) ? ((ValadocContentInlineTaglet*) _tmp41_) : NULL;
1776 if (_tmp42_ == NULL) {
1777 _g_object_unref0 (_tmp41_);
1778 }
1779 _g_object_unref0 (taglet);
1780 taglet = _tmp42_;
1781 _tmp43_ = taglet;
1782 _vala_assert (_tmp43_ != NULL, "taglet != null");
1783 }
1784 _tmp44_ = valadoc_gtkdoc_parser_next (self);
1785 _tmp45_ = _tmp44_;
1786 _tmp46_ = _tmp45_->type;
1787 _tmp47_ = _tmp46_ == VALADOC_GTKDOC_TOKEN_TYPE_SPACE;
1788 _valadoc_gtkdoc_token_unref0 (_tmp45_);
1789 if (_tmp47_) {
1790 ValadocGtkdocToken* _tmp48_;
1791 ValadocGtkdocToken* _tmp49_;
1792 _tmp48_ = valadoc_gtkdoc_parser_next (self);
1793 _tmp49_ = _tmp48_;
1794 _valadoc_gtkdoc_token_unref0 (_tmp49_);
1795 }
1796 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, tagname)) {
1797 ValadocGtkdocToken* _tmp50_;
1798 gchar* _tmp51_;
1799 gchar* _tmp52_;
1800 _tmp50_ = self->priv->current;
1801 _tmp51_ = g_strdup_printf ("</%s>", tagname);
1802 _tmp52_ = _tmp51_;
1803 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp50_, _tmp52_);
1804 _g_free0 (_tmp52_);
1805 result = taglet;
1806 return result;
1807 }
1808 _tmp53_ = valadoc_gtkdoc_parser_next (self);
1809 _tmp54_ = _tmp53_;
1810 _valadoc_gtkdoc_token_unref0 (_tmp54_);
1811 result = taglet;
1812 return result;
1813 }
1814
1815 static void
valadoc_gtkdoc_parser_parse_anchor(ValadocGtkdocParser * self)1816 valadoc_gtkdoc_parser_parse_anchor (ValadocGtkdocParser* self)
1817 {
1818 gchar* id = NULL;
1819 ValadocGtkdocToken* _tmp1_;
1820 ValaHashMap* _tmp2_;
1821 gpointer _tmp3_;
1822 const gchar* _tmp4_;
1823 ValadocGtkdocToken* _tmp8_;
1824 ValadocGtkdocToken* _tmp9_;
1825 ValadocGtkdocToken* _tmp11_;
1826 ValadocGtkdocToken* _tmp12_;
1827 g_return_if_fail (self != NULL);
1828 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "anchor")) {
1829 ValadocGtkdocToken* _tmp0_;
1830 _tmp0_ = self->priv->current;
1831 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<anchor>");
1832 return;
1833 }
1834 _tmp1_ = self->priv->current;
1835 _tmp2_ = _tmp1_->attributes;
1836 _tmp3_ = vala_map_get ((ValaMap*) _tmp2_, "id");
1837 id = (gchar*) _tmp3_;
1838 _tmp4_ = id;
1839 if (_tmp4_ != NULL) {
1840 ValadocImporterInternalIdRegistrar* _tmp5_;
1841 const gchar* _tmp6_;
1842 ValadocApiNode* _tmp7_;
1843 _tmp5_ = self->priv->id_registrar;
1844 _tmp6_ = id;
1845 _tmp7_ = self->priv->element;
1846 valadoc_importer_internal_id_registrar_register_symbol (_tmp5_, _tmp6_, _tmp7_);
1847 }
1848 _tmp8_ = valadoc_gtkdoc_parser_next (self);
1849 _tmp9_ = _tmp8_;
1850 _valadoc_gtkdoc_token_unref0 (_tmp9_);
1851 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "anchor")) {
1852 ValadocGtkdocToken* _tmp10_;
1853 _tmp10_ = self->priv->current;
1854 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp10_, "</anchor>");
1855 _g_free0 (id);
1856 return;
1857 }
1858 _tmp11_ = valadoc_gtkdoc_parser_next (self);
1859 _tmp12_ = _tmp11_;
1860 _valadoc_gtkdoc_token_unref0 (_tmp12_);
1861 _g_free0 (id);
1862 }
1863
1864 static ValadocContentLink*
valadoc_gtkdoc_parser_parse_xref(ValadocGtkdocParser * self)1865 valadoc_gtkdoc_parser_parse_xref (ValadocGtkdocParser* self)
1866 {
1867 gchar* linkend = NULL;
1868 ValadocGtkdocToken* _tmp1_;
1869 ValaHashMap* _tmp2_;
1870 gpointer _tmp3_;
1871 ValadocGtkdocToken* _tmp4_;
1872 ValadocGtkdocToken* _tmp5_;
1873 ValadocContentLink* link = NULL;
1874 ValadocContentContentFactory* _tmp6_;
1875 ValadocContentLink* _tmp7_;
1876 ValadocContentLink* _tmp8_;
1877 ValaList* _tmp9_;
1878 ValaList* _tmp10_;
1879 ValadocContentContentFactory* _tmp11_;
1880 const gchar* _tmp12_;
1881 ValadocContentText* _tmp13_;
1882 ValadocContentText* _tmp14_;
1883 ValadocContentLink* _tmp15_;
1884 ValadocImporterInternalIdRegistrar* _tmp16_;
1885 ValadocContentLink* _tmp17_;
1886 const gchar* _tmp18_;
1887 ValadocGtkdocToken* _tmp20_;
1888 ValadocGtkdocToken* _tmp21_;
1889 ValadocContentLink* result = NULL;
1890 g_return_val_if_fail (self != NULL, NULL);
1891 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "xref")) {
1892 ValadocGtkdocToken* _tmp0_;
1893 _tmp0_ = self->priv->current;
1894 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<xref>");
1895 result = NULL;
1896 return result;
1897 }
1898 _tmp1_ = self->priv->current;
1899 _tmp2_ = _tmp1_->attributes;
1900 _tmp3_ = vala_map_get ((ValaMap*) _tmp2_, "linkend");
1901 linkend = (gchar*) _tmp3_;
1902 _tmp4_ = valadoc_gtkdoc_parser_next (self);
1903 _tmp5_ = _tmp4_;
1904 _valadoc_gtkdoc_token_unref0 (_tmp5_);
1905 _tmp6_ = self->priv->factory;
1906 _tmp7_ = valadoc_content_content_factory_create_link (_tmp6_);
1907 link = _tmp7_;
1908 _tmp8_ = link;
1909 _tmp9_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp8_);
1910 _tmp10_ = _tmp9_;
1911 _tmp11_ = self->priv->factory;
1912 _tmp12_ = linkend;
1913 _tmp13_ = valadoc_content_content_factory_create_text (_tmp11_, _tmp12_);
1914 _tmp14_ = _tmp13_;
1915 vala_collection_add ((ValaCollection*) _tmp10_, (ValadocContentInline*) _tmp14_);
1916 _g_object_unref0 (_tmp14_);
1917 _tmp15_ = link;
1918 _tmp16_ = self->priv->id_registrar;
1919 valadoc_content_link_set_id_registrar (_tmp15_, _tmp16_);
1920 _tmp17_ = link;
1921 _tmp18_ = linkend;
1922 valadoc_content_link_set_url (_tmp17_, _tmp18_);
1923 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "xref")) {
1924 ValadocGtkdocToken* _tmp19_;
1925 _tmp19_ = self->priv->current;
1926 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp19_, "</xref>");
1927 result = link;
1928 _g_free0 (linkend);
1929 return result;
1930 }
1931 _tmp20_ = valadoc_gtkdoc_parser_next (self);
1932 _tmp21_ = _tmp20_;
1933 _valadoc_gtkdoc_token_unref0 (_tmp21_);
1934 result = link;
1935 _g_free0 (linkend);
1936 return result;
1937 }
1938
1939 static ValadocContentRun*
valadoc_gtkdoc_parser_parse_highlighted_template(ValadocGtkdocParser * self,const gchar * tag_name,ValadocContentRunStyle style)1940 valadoc_gtkdoc_parser_parse_highlighted_template (ValadocGtkdocParser* self,
1941 const gchar* tag_name,
1942 ValadocContentRunStyle style)
1943 {
1944 ValadocGtkdocToken* _tmp3_;
1945 ValadocGtkdocToken* _tmp4_;
1946 ValadocContentRun* run = NULL;
1947 ValadocContentRun* _tmp5_;
1948 gboolean _tmp6_ = FALSE;
1949 ValadocContentRun* _tmp7_;
1950 ValadocContentRunStyle _tmp8_;
1951 ValadocContentRunStyle _tmp9_;
1952 ValadocGtkdocToken* _tmp25_;
1953 ValadocGtkdocToken* _tmp26_;
1954 ValadocContentRun* result = NULL;
1955 g_return_val_if_fail (self != NULL, NULL);
1956 g_return_val_if_fail (tag_name != NULL, NULL);
1957 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, tag_name)) {
1958 ValadocGtkdocToken* _tmp0_;
1959 gchar* _tmp1_;
1960 gchar* _tmp2_;
1961 _tmp0_ = self->priv->current;
1962 _tmp1_ = g_strdup_printf ("<%s>", tag_name);
1963 _tmp2_ = _tmp1_;
1964 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, _tmp2_);
1965 _g_free0 (_tmp2_);
1966 result = NULL;
1967 return result;
1968 }
1969 _tmp3_ = valadoc_gtkdoc_parser_next (self);
1970 _tmp4_ = _tmp3_;
1971 _valadoc_gtkdoc_token_unref0 (_tmp4_);
1972 _tmp5_ = valadoc_gtkdoc_parser_parse_inline_content (self);
1973 run = _tmp5_;
1974 _tmp7_ = run;
1975 _tmp8_ = valadoc_content_run_get_style (_tmp7_);
1976 _tmp9_ = _tmp8_;
1977 if (_tmp9_ != VALADOC_CONTENT_RUN_STYLE_NONE) {
1978 ValadocContentRun* _tmp10_;
1979 ValadocContentRunStyle _tmp11_;
1980 ValadocContentRunStyle _tmp12_;
1981 _tmp10_ = run;
1982 _tmp11_ = valadoc_content_run_get_style (_tmp10_);
1983 _tmp12_ = _tmp11_;
1984 _tmp6_ = _tmp12_ != style;
1985 } else {
1986 _tmp6_ = FALSE;
1987 }
1988 if (_tmp6_) {
1989 ValadocContentRun* tmp = NULL;
1990 ValadocContentContentFactory* _tmp13_;
1991 ValadocContentRun* _tmp14_;
1992 ValadocContentRun* _tmp15_;
1993 ValaList* _tmp16_;
1994 ValaList* _tmp17_;
1995 ValadocContentRun* _tmp18_;
1996 ValadocContentRun* _tmp19_;
1997 ValadocContentRun* _tmp20_;
1998 _tmp13_ = self->priv->factory;
1999 _tmp14_ = valadoc_content_content_factory_create_run (_tmp13_, style);
2000 tmp = _tmp14_;
2001 _tmp15_ = tmp;
2002 _tmp16_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp15_);
2003 _tmp17_ = _tmp16_;
2004 _tmp18_ = run;
2005 vala_collection_add ((ValaCollection*) _tmp17_, (ValadocContentInline*) _tmp18_);
2006 _tmp19_ = tmp;
2007 _tmp20_ = _g_object_ref0 (_tmp19_);
2008 _g_object_unref0 (run);
2009 run = _tmp20_;
2010 _g_object_unref0 (tmp);
2011 } else {
2012 ValadocContentRun* _tmp21_;
2013 _tmp21_ = run;
2014 valadoc_content_run_set_style (_tmp21_, style);
2015 }
2016 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, tag_name)) {
2017 ValadocGtkdocToken* _tmp22_;
2018 gchar* _tmp23_;
2019 gchar* _tmp24_;
2020 _tmp22_ = self->priv->current;
2021 _tmp23_ = g_strdup_printf ("</%s>", tag_name);
2022 _tmp24_ = _tmp23_;
2023 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp22_, _tmp24_);
2024 _g_free0 (_tmp24_);
2025 result = run;
2026 return result;
2027 }
2028 _tmp25_ = valadoc_gtkdoc_parser_next (self);
2029 _tmp26_ = _tmp25_;
2030 _valadoc_gtkdoc_token_unref0 (_tmp26_);
2031 result = run;
2032 return result;
2033 }
2034
2035 static ValadocContentListItem*
valadoc_gtkdoc_parser_parse_docbook_listitem(ValadocGtkdocParser * self)2036 valadoc_gtkdoc_parser_parse_docbook_listitem (ValadocGtkdocParser* self)
2037 {
2038 ValadocGtkdocToken* _tmp1_;
2039 ValadocGtkdocToken* _tmp2_;
2040 ValadocContentListItem* item = NULL;
2041 ValadocContentContentFactory* _tmp3_;
2042 ValadocContentListItem* _tmp4_;
2043 ValadocContentListItem* _tmp5_;
2044 ValaList* _tmp6_;
2045 ValaList* _tmp7_;
2046 ValaCollection* _tmp8_;
2047 ValaCollection* _tmp9_;
2048 ValadocGtkdocToken* _tmp11_;
2049 ValadocGtkdocToken* _tmp12_;
2050 ValadocContentListItem* result = NULL;
2051 g_return_val_if_fail (self != NULL, NULL);
2052 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "listitem")) {
2053 ValadocGtkdocToken* _tmp0_;
2054 _tmp0_ = self->priv->current;
2055 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<listitem>");
2056 result = NULL;
2057 return result;
2058 }
2059 _tmp1_ = valadoc_gtkdoc_parser_next (self);
2060 _tmp2_ = _tmp1_;
2061 _valadoc_gtkdoc_token_unref0 (_tmp2_);
2062 _tmp3_ = self->priv->factory;
2063 _tmp4_ = valadoc_content_content_factory_create_list_item (_tmp3_);
2064 item = _tmp4_;
2065 _tmp5_ = item;
2066 _tmp6_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) _tmp5_);
2067 _tmp7_ = _tmp6_;
2068 _tmp8_ = valadoc_gtkdoc_parser_parse_mixed_content (self);
2069 _tmp9_ = _tmp8_;
2070 vala_collection_add_all ((ValaCollection*) _tmp7_, _tmp9_);
2071 _vala_iterable_unref0 (_tmp9_);
2072 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "listitem")) {
2073 ValadocGtkdocToken* _tmp10_;
2074 _tmp10_ = self->priv->current;
2075 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp10_, "</listitem>");
2076 result = item;
2077 return result;
2078 }
2079 _tmp11_ = valadoc_gtkdoc_parser_next (self);
2080 _tmp12_ = _tmp11_;
2081 _valadoc_gtkdoc_token_unref0 (_tmp12_);
2082 result = item;
2083 return result;
2084 }
2085
2086 static ValadocContentBlockContent*
valadoc_gtkdoc_parser_parse_docbook_information_box_template(ValadocGtkdocParser * self,const gchar * tagname,ValadocContentBlockContent * container)2087 valadoc_gtkdoc_parser_parse_docbook_information_box_template (ValadocGtkdocParser* self,
2088 const gchar* tagname,
2089 ValadocContentBlockContent* container)
2090 {
2091 ValadocGtkdocToken* _tmp3_;
2092 ValadocGtkdocToken* _tmp4_;
2093 ValadocGtkdocToken* tmp = NULL;
2094 ValadocGtkdocToken* _tmp42_;
2095 ValadocGtkdocToken* _tmp43_;
2096 ValadocContentBlockContent* _tmp44_;
2097 ValadocContentBlockContent* result = NULL;
2098 g_return_val_if_fail (self != NULL, NULL);
2099 g_return_val_if_fail (tagname != NULL, NULL);
2100 g_return_val_if_fail (container != NULL, NULL);
2101 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, tagname)) {
2102 ValadocGtkdocToken* _tmp0_;
2103 gchar* _tmp1_;
2104 gchar* _tmp2_;
2105 _tmp0_ = self->priv->current;
2106 _tmp1_ = g_strdup_printf ("<%s>", tagname);
2107 _tmp2_ = _tmp1_;
2108 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, _tmp2_);
2109 _g_free0 (_tmp2_);
2110 result = NULL;
2111 return result;
2112 }
2113 _tmp3_ = valadoc_gtkdoc_parser_next (self);
2114 _tmp4_ = _tmp3_;
2115 _valadoc_gtkdoc_token_unref0 (_tmp4_);
2116 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
2117 tmp = NULL;
2118 while (TRUE) {
2119 gboolean _tmp5_ = FALSE;
2120 ValadocGtkdocToken* _tmp6_;
2121 ValadocGtkdocTokenType _tmp7_;
2122 ValadocGtkdocToken* _tmp10_;
2123 ValadocGtkdocToken* _tmp11_;
2124 ValadocContentRun* ic = NULL;
2125 ValadocContentRun* _tmp12_;
2126 gboolean _tmp13_ = FALSE;
2127 ValadocContentRun* _tmp14_;
2128 ValaCollection* bc = NULL;
2129 ValaCollection* _tmp29_;
2130 gboolean _tmp30_ = FALSE;
2131 ValaCollection* _tmp31_;
2132 _tmp6_ = self->priv->current;
2133 _tmp7_ = _tmp6_->type;
2134 if (_tmp7_ != VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE) {
2135 ValadocGtkdocToken* _tmp8_;
2136 ValadocGtkdocTokenType _tmp9_;
2137 _tmp8_ = self->priv->current;
2138 _tmp9_ = _tmp8_->type;
2139 _tmp5_ = _tmp9_ != VALADOC_GTKDOC_TOKEN_TYPE_EOF;
2140 } else {
2141 _tmp5_ = FALSE;
2142 }
2143 if (!_tmp5_) {
2144 break;
2145 }
2146 _tmp10_ = self->priv->current;
2147 _tmp11_ = _valadoc_gtkdoc_token_ref0 (_tmp10_);
2148 _valadoc_gtkdoc_token_unref0 (tmp);
2149 tmp = _tmp11_;
2150 _tmp12_ = valadoc_gtkdoc_parser_parse_inline_content (self);
2151 ic = _tmp12_;
2152 _tmp14_ = ic;
2153 if (_tmp14_ != NULL) {
2154 ValadocContentRun* _tmp15_;
2155 ValaList* _tmp16_;
2156 ValaList* _tmp17_;
2157 gint _tmp18_;
2158 gint _tmp19_;
2159 _tmp15_ = ic;
2160 _tmp16_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp15_);
2161 _tmp17_ = _tmp16_;
2162 _tmp18_ = vala_collection_get_size ((ValaCollection*) _tmp17_);
2163 _tmp19_ = _tmp18_;
2164 _tmp13_ = _tmp19_ > 0;
2165 } else {
2166 _tmp13_ = FALSE;
2167 }
2168 if (_tmp13_) {
2169 ValadocContentParagraph* p = NULL;
2170 ValadocContentContentFactory* _tmp20_;
2171 ValadocContentParagraph* _tmp21_;
2172 ValadocContentParagraph* _tmp22_;
2173 ValaList* _tmp23_;
2174 ValaList* _tmp24_;
2175 ValadocContentRun* _tmp25_;
2176 ValaList* _tmp26_;
2177 ValaList* _tmp27_;
2178 ValadocContentParagraph* _tmp28_;
2179 _tmp20_ = self->priv->factory;
2180 _tmp21_ = valadoc_content_content_factory_create_paragraph (_tmp20_);
2181 p = _tmp21_;
2182 _tmp22_ = p;
2183 _tmp23_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp22_);
2184 _tmp24_ = _tmp23_;
2185 _tmp25_ = ic;
2186 vala_collection_add ((ValaCollection*) _tmp24_, (ValadocContentInline*) _tmp25_);
2187 _tmp26_ = valadoc_content_block_content_get_content (container);
2188 _tmp27_ = _tmp26_;
2189 _tmp28_ = p;
2190 vala_collection_add ((ValaCollection*) _tmp27_, (ValadocContentBlock*) _tmp28_);
2191 _g_object_unref0 (p);
2192 }
2193 _tmp29_ = valadoc_gtkdoc_parser_parse_block_content (self);
2194 bc = _tmp29_;
2195 _tmp31_ = bc;
2196 if (_tmp31_ != NULL) {
2197 ValaCollection* _tmp32_;
2198 gint _tmp33_;
2199 gint _tmp34_;
2200 _tmp32_ = bc;
2201 _tmp33_ = vala_collection_get_size (_tmp32_);
2202 _tmp34_ = _tmp33_;
2203 _tmp30_ = _tmp34_ > 0;
2204 } else {
2205 _tmp30_ = FALSE;
2206 }
2207 if (_tmp30_) {
2208 ValaList* _tmp35_;
2209 ValaList* _tmp36_;
2210 ValaCollection* _tmp37_;
2211 _tmp35_ = valadoc_content_block_content_get_content (container);
2212 _tmp36_ = _tmp35_;
2213 _tmp37_ = bc;
2214 vala_collection_add_all ((ValaCollection*) _tmp36_, _tmp37_);
2215 }
2216 _vala_iterable_unref0 (bc);
2217 _g_object_unref0 (ic);
2218 }
2219 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
2220 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, tagname)) {
2221 ValadocGtkdocToken* _tmp38_;
2222 gchar* _tmp39_;
2223 gchar* _tmp40_;
2224 ValadocContentBlockContent* _tmp41_;
2225 _tmp38_ = self->priv->current;
2226 _tmp39_ = g_strdup_printf ("</%s>", tagname);
2227 _tmp40_ = _tmp39_;
2228 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp38_, _tmp40_);
2229 _g_free0 (_tmp40_);
2230 _tmp41_ = _g_object_ref0 (container);
2231 result = _tmp41_;
2232 _valadoc_gtkdoc_token_unref0 (tmp);
2233 return result;
2234 }
2235 _tmp42_ = valadoc_gtkdoc_parser_next (self);
2236 _tmp43_ = _tmp42_;
2237 _valadoc_gtkdoc_token_unref0 (_tmp43_);
2238 _tmp44_ = _g_object_ref0 (container);
2239 result = _tmp44_;
2240 _valadoc_gtkdoc_token_unref0 (tmp);
2241 return result;
2242 }
2243
2244 static ValadocContentNote*
valadoc_gtkdoc_parser_parse_docbook_important(ValadocGtkdocParser * self)2245 valadoc_gtkdoc_parser_parse_docbook_important (ValadocGtkdocParser* self)
2246 {
2247 ValadocContentContentFactory* _tmp0_;
2248 ValadocContentNote* _tmp1_;
2249 ValadocContentNote* _tmp2_;
2250 ValadocContentBlockContent* _tmp3_;
2251 ValadocContentNote* _tmp4_;
2252 ValadocContentNote* result = NULL;
2253 g_return_val_if_fail (self != NULL, NULL);
2254 _tmp0_ = self->priv->factory;
2255 _tmp1_ = valadoc_content_content_factory_create_note (_tmp0_);
2256 _tmp2_ = _tmp1_;
2257 _tmp3_ = valadoc_gtkdoc_parser_parse_docbook_information_box_template (self, "important", (ValadocContentBlockContent*) _tmp2_);
2258 _tmp4_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp3_, VALADOC_CONTENT_TYPE_NOTE, ValadocContentNote);
2259 _g_object_unref0 (_tmp2_);
2260 result = _tmp4_;
2261 return result;
2262 }
2263
2264 static ValadocContentNote*
valadoc_gtkdoc_parser_parse_docbook_note(ValadocGtkdocParser * self)2265 valadoc_gtkdoc_parser_parse_docbook_note (ValadocGtkdocParser* self)
2266 {
2267 ValadocContentContentFactory* _tmp0_;
2268 ValadocContentNote* _tmp1_;
2269 ValadocContentNote* _tmp2_;
2270 ValadocContentBlockContent* _tmp3_;
2271 ValadocContentNote* _tmp4_;
2272 ValadocContentNote* result = NULL;
2273 g_return_val_if_fail (self != NULL, NULL);
2274 _tmp0_ = self->priv->factory;
2275 _tmp1_ = valadoc_content_content_factory_create_note (_tmp0_);
2276 _tmp2_ = _tmp1_;
2277 _tmp3_ = valadoc_gtkdoc_parser_parse_docbook_information_box_template (self, "note", (ValadocContentBlockContent*) _tmp2_);
2278 _tmp4_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp3_, VALADOC_CONTENT_TYPE_NOTE, ValadocContentNote);
2279 _g_object_unref0 (_tmp2_);
2280 result = _tmp4_;
2281 return result;
2282 }
2283
2284 static ValadocContentWarning*
valadoc_gtkdoc_parser_parse_docbook_warning(ValadocGtkdocParser * self)2285 valadoc_gtkdoc_parser_parse_docbook_warning (ValadocGtkdocParser* self)
2286 {
2287 ValadocContentContentFactory* _tmp0_;
2288 ValadocContentWarning* _tmp1_;
2289 ValadocContentWarning* _tmp2_;
2290 ValadocContentBlockContent* _tmp3_;
2291 ValadocContentWarning* _tmp4_;
2292 ValadocContentWarning* result = NULL;
2293 g_return_val_if_fail (self != NULL, NULL);
2294 _tmp0_ = self->priv->factory;
2295 _tmp1_ = valadoc_content_content_factory_create_warning (_tmp0_);
2296 _tmp2_ = _tmp1_;
2297 _tmp3_ = valadoc_gtkdoc_parser_parse_docbook_information_box_template (self, "warning", (ValadocContentBlockContent*) _tmp2_);
2298 _tmp4_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp3_, VALADOC_CONTENT_TYPE_WARNING, ValadocContentWarning);
2299 _g_object_unref0 (_tmp2_);
2300 result = _tmp4_;
2301 return result;
2302 }
2303
2304 static inline ValaCollection*
valadoc_gtkdoc_parser_parse_docbook_orderedlist(ValadocGtkdocParser * self)2305 valadoc_gtkdoc_parser_parse_docbook_orderedlist (ValadocGtkdocParser* self)
2306 {
2307 ValaCollection* _tmp0_;
2308 ValaCollection* result = NULL;
2309 g_return_val_if_fail (self != NULL, NULL);
2310 _tmp0_ = valadoc_gtkdoc_parser_parse_docbook_itemizedlist (self, "orderedlist", VALADOC_CONTENT_LIST_BULLET_ORDERED);
2311 result = _tmp0_;
2312 return result;
2313 }
2314
2315 static ValaCollection*
valadoc_gtkdoc_parser_parse_docbook_itemizedlist(ValadocGtkdocParser * self,const gchar * tag_name,ValadocContentListBullet bullet_type)2316 valadoc_gtkdoc_parser_parse_docbook_itemizedlist (ValadocGtkdocParser* self,
2317 const gchar* tag_name,
2318 ValadocContentListBullet bullet_type)
2319 {
2320 ValadocGtkdocToken* _tmp3_;
2321 ValadocGtkdocToken* _tmp4_;
2322 ValaCollection* content = NULL;
2323 GEqualFunc _tmp5_;
2324 ValaArrayList* _tmp6_;
2325 gboolean _tmp7_ = FALSE;
2326 ValadocGtkdocToken* _tmp8_;
2327 ValadocGtkdocTokenType _tmp9_;
2328 ValadocContentList* list = NULL;
2329 ValadocContentContentFactory* _tmp15_;
2330 ValadocContentList* _tmp16_;
2331 ValadocContentList* _tmp17_;
2332 ValaCollection* _tmp18_;
2333 ValadocContentList* _tmp19_;
2334 ValadocGtkdocToken* _tmp32_;
2335 ValadocGtkdocToken* _tmp33_;
2336 ValaCollection* result = NULL;
2337 g_return_val_if_fail (self != NULL, NULL);
2338 g_return_val_if_fail (tag_name != NULL, NULL);
2339 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, tag_name)) {
2340 ValadocGtkdocToken* _tmp0_;
2341 gchar* _tmp1_;
2342 gchar* _tmp2_;
2343 _tmp0_ = self->priv->current;
2344 _tmp1_ = g_strdup_printf ("<%s>", tag_name);
2345 _tmp2_ = _tmp1_;
2346 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, _tmp2_);
2347 _g_free0 (_tmp2_);
2348 result = NULL;
2349 return result;
2350 }
2351 _tmp3_ = valadoc_gtkdoc_parser_next (self);
2352 _tmp4_ = _tmp3_;
2353 _valadoc_gtkdoc_token_unref0 (_tmp4_);
2354 _tmp5_ = g_direct_equal;
2355 _tmp6_ = vala_array_list_new (VALADOC_CONTENT_TYPE_BLOCK, (GBoxedCopyFunc) g_object_ref, (GDestroyNotify) g_object_unref, _tmp5_);
2356 content = (ValaCollection*) _tmp6_;
2357 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
2358 _tmp8_ = self->priv->current;
2359 _tmp9_ = _tmp8_->type;
2360 if (_tmp9_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
2361 ValadocGtkdocToken* _tmp10_;
2362 const gchar* _tmp11_;
2363 _tmp10_ = self->priv->current;
2364 _tmp11_ = _tmp10_->content;
2365 _tmp7_ = g_strcmp0 (_tmp11_, "title") == 0;
2366 } else {
2367 _tmp7_ = FALSE;
2368 }
2369 if (_tmp7_) {
2370 ValaCollection* _tmp12_;
2371 ValadocContentParagraph* _tmp13_;
2372 ValadocContentParagraph* _tmp14_;
2373 _tmp12_ = content;
2374 _tmp13_ = valadoc_gtkdoc_parser_parse_docbook_title (self);
2375 _tmp14_ = _tmp13_;
2376 valadoc_gtkdoc_parser_append_block_content_not_null (self, _tmp12_, (ValadocContentBlock*) _tmp14_);
2377 _g_object_unref0 (_tmp14_);
2378 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
2379 }
2380 _tmp15_ = self->priv->factory;
2381 _tmp16_ = valadoc_content_content_factory_create_list (_tmp15_);
2382 list = _tmp16_;
2383 _tmp17_ = list;
2384 valadoc_content_list_set_bullet (_tmp17_, bullet_type);
2385 _tmp18_ = content;
2386 _tmp19_ = list;
2387 vala_collection_add (_tmp18_, (ValadocContentBlock*) _tmp19_);
2388 while (TRUE) {
2389 ValadocGtkdocToken* _tmp20_;
2390 ValadocGtkdocTokenType _tmp21_;
2391 ValadocGtkdocToken* _tmp22_;
2392 const gchar* _tmp23_;
2393 _tmp20_ = self->priv->current;
2394 _tmp21_ = _tmp20_->type;
2395 if (!(_tmp21_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN)) {
2396 break;
2397 }
2398 _tmp22_ = self->priv->current;
2399 _tmp23_ = _tmp22_->content;
2400 if (g_strcmp0 (_tmp23_, "listitem") == 0) {
2401 ValadocContentList* _tmp24_;
2402 ValaList* _tmp25_;
2403 ValaList* _tmp26_;
2404 ValadocContentListItem* _tmp27_;
2405 ValadocContentListItem* _tmp28_;
2406 _tmp24_ = list;
2407 _tmp25_ = valadoc_content_list_get_items (_tmp24_);
2408 _tmp26_ = _tmp25_;
2409 _tmp27_ = valadoc_gtkdoc_parser_parse_docbook_listitem (self);
2410 _tmp28_ = _tmp27_;
2411 vala_collection_add ((ValaCollection*) _tmp26_, _tmp28_);
2412 _g_object_unref0 (_tmp28_);
2413 } else {
2414 break;
2415 }
2416 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
2417 }
2418 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, tag_name)) {
2419 ValadocGtkdocToken* _tmp29_;
2420 gchar* _tmp30_;
2421 gchar* _tmp31_;
2422 _tmp29_ = self->priv->current;
2423 _tmp30_ = g_strdup_printf ("</%s>", tag_name);
2424 _tmp31_ = _tmp30_;
2425 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp29_, _tmp31_);
2426 _g_free0 (_tmp31_);
2427 result = content;
2428 _g_object_unref0 (list);
2429 return result;
2430 }
2431 _tmp32_ = valadoc_gtkdoc_parser_next (self);
2432 _tmp33_ = _tmp32_;
2433 _valadoc_gtkdoc_token_unref0 (_tmp33_);
2434 result = content;
2435 _g_object_unref0 (list);
2436 return result;
2437 }
2438
2439 static ValadocContentParagraph*
valadoc_gtkdoc_parser_parse_gtkdoc_paragraph(ValadocGtkdocParser * self)2440 valadoc_gtkdoc_parser_parse_gtkdoc_paragraph (ValadocGtkdocParser* self)
2441 {
2442 ValadocGtkdocToken* _tmp0_;
2443 ValadocGtkdocTokenType _tmp1_;
2444 ValadocGtkdocToken* _tmp3_;
2445 ValadocGtkdocToken* _tmp4_;
2446 ValadocContentParagraph* p = NULL;
2447 ValadocContentContentFactory* _tmp5_;
2448 ValadocContentParagraph* _tmp6_;
2449 ValadocContentRun* run = NULL;
2450 ValadocContentRun* _tmp7_;
2451 ValadocContentParagraph* _tmp8_;
2452 ValaList* _tmp9_;
2453 ValaList* _tmp10_;
2454 ValadocContentRun* _tmp11_;
2455 ValadocContentParagraph* result = NULL;
2456 g_return_val_if_fail (self != NULL, NULL);
2457 _tmp0_ = self->priv->current;
2458 _tmp1_ = _tmp0_->type;
2459 if (_tmp1_ != VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_PARAGRAPH) {
2460 ValadocGtkdocToken* _tmp2_;
2461 _tmp2_ = self->priv->current;
2462 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp2_, "<GTKDOC-PARAGRAPH>");
2463 result = NULL;
2464 return result;
2465 }
2466 _tmp3_ = valadoc_gtkdoc_parser_next (self);
2467 _tmp4_ = _tmp3_;
2468 _valadoc_gtkdoc_token_unref0 (_tmp4_);
2469 _tmp5_ = self->priv->factory;
2470 _tmp6_ = valadoc_content_content_factory_create_paragraph (_tmp5_);
2471 p = _tmp6_;
2472 _tmp7_ = valadoc_gtkdoc_parser_parse_inline_content (self);
2473 run = _tmp7_;
2474 _tmp8_ = p;
2475 _tmp9_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp8_);
2476 _tmp10_ = _tmp9_;
2477 _tmp11_ = run;
2478 vala_collection_add ((ValaCollection*) _tmp10_, (ValadocContentInline*) _tmp11_);
2479 result = p;
2480 _g_object_unref0 (run);
2481 return result;
2482 }
2483
2484 static ValaCollection*
valadoc_gtkdoc_parser_parse_mixed_content(ValadocGtkdocParser * self)2485 valadoc_gtkdoc_parser_parse_mixed_content (ValadocGtkdocParser* self)
2486 {
2487 ValaCollection* content = NULL;
2488 GEqualFunc _tmp0_;
2489 ValaArrayList* _tmp1_;
2490 ValadocGtkdocToken* tmp = NULL;
2491 ValaCollection* result = NULL;
2492 g_return_val_if_fail (self != NULL, NULL);
2493 _tmp0_ = g_direct_equal;
2494 _tmp1_ = vala_array_list_new (VALADOC_CONTENT_TYPE_BLOCK, (GBoxedCopyFunc) g_object_ref, (GDestroyNotify) g_object_unref, _tmp0_);
2495 content = (ValaCollection*) _tmp1_;
2496 tmp = NULL;
2497 while (TRUE) {
2498 ValadocGtkdocToken* _tmp2_;
2499 ValadocGtkdocToken* _tmp3_;
2500 ValadocGtkdocToken* _tmp4_;
2501 ValadocGtkdocToken* _tmp5_;
2502 ValadocContentRun* run = NULL;
2503 ValadocContentRun* _tmp6_;
2504 gboolean _tmp7_ = FALSE;
2505 ValadocContentRun* _tmp8_;
2506 ValaCollection* lst = NULL;
2507 ValaCollection* _tmp22_;
2508 gboolean _tmp23_ = FALSE;
2509 ValaCollection* _tmp24_;
2510 _tmp2_ = tmp;
2511 _tmp3_ = self->priv->current;
2512 if (!(_tmp2_ != _tmp3_)) {
2513 break;
2514 }
2515 _tmp4_ = self->priv->current;
2516 _tmp5_ = _valadoc_gtkdoc_token_ref0 (_tmp4_);
2517 _valadoc_gtkdoc_token_unref0 (tmp);
2518 tmp = _tmp5_;
2519 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
2520 _tmp6_ = valadoc_gtkdoc_parser_parse_inline_content (self);
2521 run = _tmp6_;
2522 _tmp8_ = run;
2523 if (_tmp8_ != NULL) {
2524 ValadocContentRun* _tmp9_;
2525 ValaList* _tmp10_;
2526 ValaList* _tmp11_;
2527 gint _tmp12_;
2528 gint _tmp13_;
2529 _tmp9_ = run;
2530 _tmp10_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp9_);
2531 _tmp11_ = _tmp10_;
2532 _tmp12_ = vala_collection_get_size ((ValaCollection*) _tmp11_);
2533 _tmp13_ = _tmp12_;
2534 _tmp7_ = _tmp13_ > 0;
2535 } else {
2536 _tmp7_ = FALSE;
2537 }
2538 if (_tmp7_) {
2539 ValadocContentParagraph* p = NULL;
2540 ValadocContentContentFactory* _tmp14_;
2541 ValadocContentParagraph* _tmp15_;
2542 ValadocContentParagraph* _tmp16_;
2543 ValaList* _tmp17_;
2544 ValaList* _tmp18_;
2545 ValadocContentRun* _tmp19_;
2546 ValaCollection* _tmp20_;
2547 ValadocContentParagraph* _tmp21_;
2548 _tmp14_ = self->priv->factory;
2549 _tmp15_ = valadoc_content_content_factory_create_paragraph (_tmp14_);
2550 p = _tmp15_;
2551 _tmp16_ = p;
2552 _tmp17_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp16_);
2553 _tmp18_ = _tmp17_;
2554 _tmp19_ = run;
2555 vala_collection_add ((ValaCollection*) _tmp18_, (ValadocContentInline*) _tmp19_);
2556 _tmp20_ = content;
2557 _tmp21_ = p;
2558 vala_collection_add (_tmp20_, (ValadocContentBlock*) _tmp21_);
2559 _g_object_unref0 (p);
2560 _g_object_unref0 (run);
2561 continue;
2562 }
2563 _tmp22_ = valadoc_gtkdoc_parser_parse_block_content (self);
2564 lst = _tmp22_;
2565 _tmp24_ = lst;
2566 if (_tmp24_ != NULL) {
2567 ValaCollection* _tmp25_;
2568 gint _tmp26_;
2569 gint _tmp27_;
2570 _tmp25_ = lst;
2571 _tmp26_ = vala_collection_get_size (_tmp25_);
2572 _tmp27_ = _tmp26_;
2573 _tmp23_ = _tmp27_ > 0;
2574 } else {
2575 _tmp23_ = FALSE;
2576 }
2577 if (_tmp23_) {
2578 ValaCollection* _tmp28_;
2579 ValaCollection* _tmp29_;
2580 _tmp28_ = content;
2581 _tmp29_ = lst;
2582 vala_collection_add_all (_tmp28_, _tmp29_);
2583 _vala_iterable_unref0 (lst);
2584 _g_object_unref0 (run);
2585 continue;
2586 }
2587 _vala_iterable_unref0 (lst);
2588 _g_object_unref0 (run);
2589 }
2590 result = content;
2591 _valadoc_gtkdoc_token_unref0 (tmp);
2592 return result;
2593 }
2594
2595 static inline ValaCollection*
valadoc_gtkdoc_parser_parse_docbook_simpara(ValadocGtkdocParser * self)2596 valadoc_gtkdoc_parser_parse_docbook_simpara (ValadocGtkdocParser* self)
2597 {
2598 ValaCollection* _tmp0_;
2599 ValaCollection* result = NULL;
2600 g_return_val_if_fail (self != NULL, NULL);
2601 _tmp0_ = valadoc_gtkdoc_parser_parse_docbook_para (self, "simpara");
2602 result = _tmp0_;
2603 return result;
2604 }
2605
2606 static ValaCollection*
valadoc_gtkdoc_parser_parse_docbook_para(ValadocGtkdocParser * self,const gchar * tag_name)2607 valadoc_gtkdoc_parser_parse_docbook_para (ValadocGtkdocParser* self,
2608 const gchar* tag_name)
2609 {
2610 ValadocGtkdocToken* _tmp3_;
2611 ValadocGtkdocToken* _tmp4_;
2612 ValaCollection* content = NULL;
2613 ValaCollection* _tmp5_;
2614 gboolean _tmp6_ = FALSE;
2615 ValadocGtkdocToken* _tmp12_;
2616 ValadocGtkdocToken* _tmp13_;
2617 ValaCollection* result = NULL;
2618 g_return_val_if_fail (self != NULL, NULL);
2619 g_return_val_if_fail (tag_name != NULL, NULL);
2620 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, tag_name)) {
2621 ValadocGtkdocToken* _tmp0_;
2622 gchar* _tmp1_;
2623 gchar* _tmp2_;
2624 _tmp0_ = self->priv->current;
2625 _tmp1_ = g_strdup_printf ("<%s>", tag_name);
2626 _tmp2_ = _tmp1_;
2627 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, _tmp2_);
2628 _g_free0 (_tmp2_);
2629 result = NULL;
2630 return result;
2631 }
2632 _tmp3_ = valadoc_gtkdoc_parser_next (self);
2633 _tmp4_ = _tmp3_;
2634 _valadoc_gtkdoc_token_unref0 (_tmp4_);
2635 _tmp5_ = valadoc_gtkdoc_parser_parse_mixed_content (self);
2636 content = _tmp5_;
2637 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, tag_name)) {
2638 ValadocGtkdocToken* _tmp7_;
2639 ValadocGtkdocTokenType _tmp8_;
2640 _tmp7_ = self->priv->current;
2641 _tmp8_ = _tmp7_->type;
2642 _tmp6_ = _tmp8_ != VALADOC_GTKDOC_TOKEN_TYPE_EOF;
2643 } else {
2644 _tmp6_ = FALSE;
2645 }
2646 if (_tmp6_) {
2647 ValadocGtkdocToken* _tmp9_;
2648 gchar* _tmp10_;
2649 gchar* _tmp11_;
2650 _tmp9_ = self->priv->current;
2651 _tmp10_ = g_strdup_printf ("</%s>", tag_name);
2652 _tmp11_ = _tmp10_;
2653 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp9_, _tmp11_);
2654 _g_free0 (_tmp11_);
2655 result = content;
2656 return result;
2657 }
2658 _tmp12_ = valadoc_gtkdoc_parser_next (self);
2659 _tmp13_ = _tmp12_;
2660 _valadoc_gtkdoc_token_unref0 (_tmp13_);
2661 result = content;
2662 return result;
2663 }
2664
2665 static ValadocContentSourceCodeLanguage*
_valadoc_content_source_code_language_dup(ValadocContentSourceCodeLanguage * self)2666 _valadoc_content_source_code_language_dup (ValadocContentSourceCodeLanguage* self)
2667 {
2668 ValadocContentSourceCodeLanguage* dup;
2669 dup = g_new0 (ValadocContentSourceCodeLanguage, 1);
2670 memcpy (dup, self, sizeof (ValadocContentSourceCodeLanguage));
2671 return dup;
2672 }
2673
2674 static gpointer
__valadoc_content_source_code_language_dup0(gpointer self)2675 __valadoc_content_source_code_language_dup0 (gpointer self)
2676 {
2677 return self ? _valadoc_content_source_code_language_dup (self) : NULL;
2678 }
2679
2680 static const gchar*
string_offset(const gchar * self,glong offset)2681 string_offset (const gchar* self,
2682 glong offset)
2683 {
2684 const gchar* result = NULL;
2685 g_return_val_if_fail (self != NULL, NULL);
2686 result = (const gchar*) (((gchar*) self) + offset);
2687 return result;
2688 }
2689
2690 static gint
string_index_of_char(const gchar * self,gunichar c,gint start_index)2691 string_index_of_char (const gchar* self,
2692 gunichar c,
2693 gint start_index)
2694 {
2695 gchar* _result_ = NULL;
2696 gchar* _tmp0_;
2697 gchar* _tmp1_;
2698 gint result = 0;
2699 g_return_val_if_fail (self != NULL, 0);
2700 _tmp0_ = g_utf8_strchr (((gchar*) self) + start_index, (gssize) -1, c);
2701 _result_ = _tmp0_;
2702 _tmp1_ = _result_;
2703 if (_tmp1_ != NULL) {
2704 gchar* _tmp2_;
2705 _tmp2_ = _result_;
2706 result = (gint) (_tmp2_ - ((gchar*) self));
2707 return result;
2708 } else {
2709 result = -1;
2710 return result;
2711 }
2712 }
2713
2714 static ValadocContentParagraph*
valadoc_gtkdoc_parser_parse_gtkdoc_source(ValadocGtkdocParser * self)2715 valadoc_gtkdoc_parser_parse_gtkdoc_source (ValadocGtkdocParser* self)
2716 {
2717 ValadocGtkdocToken* _tmp0_;
2718 ValadocGtkdocTokenType _tmp1_;
2719 GString* builder = NULL;
2720 GString* _tmp3_;
2721 ValadocGtkdocToken* source_token = NULL;
2722 ValadocGtkdocToken* _tmp4_;
2723 ValadocGtkdocToken* _tmp5_;
2724 ValadocContentSourceCode* code = NULL;
2725 ValadocContentContentFactory* _tmp27_;
2726 ValadocContentSourceCode* _tmp28_;
2727 GMatchInfo* info = NULL;
2728 const gchar* source = NULL;
2729 GString* _tmp29_;
2730 const gchar* _tmp30_;
2731 GRegex* _tmp31_;
2732 const gchar* _tmp32_;
2733 GMatchInfo* _tmp33_ = NULL;
2734 gboolean _tmp34_;
2735 ValadocContentSourceCode* _tmp56_;
2736 const gchar* _tmp57_;
2737 ValadocContentParagraph* p = NULL;
2738 ValadocContentContentFactory* _tmp58_;
2739 ValadocContentParagraph* _tmp59_;
2740 ValadocContentParagraph* _tmp60_;
2741 ValaList* _tmp61_;
2742 ValaList* _tmp62_;
2743 ValadocContentSourceCode* _tmp63_;
2744 ValadocGtkdocToken* _tmp64_;
2745 ValadocGtkdocTokenType _tmp65_;
2746 ValadocGtkdocToken* _tmp67_;
2747 ValadocGtkdocToken* _tmp68_;
2748 ValadocContentParagraph* result = NULL;
2749 g_return_val_if_fail (self != NULL, NULL);
2750 _tmp0_ = self->priv->current;
2751 _tmp1_ = _tmp0_->type;
2752 if (_tmp1_ != VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_SOURCE_OPEN) {
2753 ValadocGtkdocToken* _tmp2_;
2754 _tmp2_ = self->priv->current;
2755 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp2_, "|[");
2756 result = NULL;
2757 return result;
2758 }
2759 _tmp3_ = g_string_new ("");
2760 builder = _tmp3_;
2761 _tmp4_ = self->priv->current;
2762 _tmp5_ = _valadoc_gtkdoc_token_ref0 (_tmp4_);
2763 source_token = _tmp5_;
2764 {
2765 ValadocGtkdocToken* _tmp6_;
2766 ValadocGtkdocToken* _tmp7_;
2767 gboolean _tmp8_ = FALSE;
2768 _tmp6_ = valadoc_gtkdoc_parser_next (self);
2769 _tmp7_ = _tmp6_;
2770 _valadoc_gtkdoc_token_unref0 (_tmp7_);
2771 _tmp8_ = TRUE;
2772 while (TRUE) {
2773 gboolean _tmp11_ = FALSE;
2774 ValadocGtkdocToken* _tmp12_;
2775 ValadocGtkdocTokenType _tmp13_;
2776 ValadocGtkdocToken* _tmp16_;
2777 ValadocGtkdocTokenType _tmp17_;
2778 if (!_tmp8_) {
2779 ValadocGtkdocToken* _tmp9_;
2780 ValadocGtkdocToken* _tmp10_;
2781 _tmp9_ = valadoc_gtkdoc_parser_next (self);
2782 _tmp10_ = _tmp9_;
2783 _valadoc_gtkdoc_token_unref0 (_tmp10_);
2784 }
2785 _tmp8_ = FALSE;
2786 _tmp12_ = self->priv->current;
2787 _tmp13_ = _tmp12_->type;
2788 if (_tmp13_ != VALADOC_GTKDOC_TOKEN_TYPE_EOF) {
2789 ValadocGtkdocToken* _tmp14_;
2790 ValadocGtkdocTokenType _tmp15_;
2791 _tmp14_ = self->priv->current;
2792 _tmp15_ = _tmp14_->type;
2793 _tmp11_ = _tmp15_ != VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_SOURCE_CLOSE;
2794 } else {
2795 _tmp11_ = FALSE;
2796 }
2797 if (!_tmp11_) {
2798 break;
2799 }
2800 _tmp16_ = self->priv->current;
2801 _tmp17_ = _tmp16_->type;
2802 if (_tmp17_ == VALADOC_GTKDOC_TOKEN_TYPE_WORD) {
2803 GString* _tmp18_;
2804 ValadocGtkdocToken* _tmp19_;
2805 const gchar* _tmp20_;
2806 _tmp18_ = builder;
2807 _tmp19_ = self->priv->current;
2808 _tmp20_ = _tmp19_->content;
2809 g_string_append (_tmp18_, _tmp20_);
2810 } else {
2811 ValadocGtkdocToken* _tmp21_;
2812 ValadocGtkdocTokenType _tmp22_;
2813 _tmp21_ = self->priv->current;
2814 _tmp22_ = _tmp21_->type;
2815 if (_tmp22_ != VALADOC_GTKDOC_TOKEN_TYPE_XML_COMMENT) {
2816 GString* _tmp23_;
2817 ValadocGtkdocToken* _tmp24_;
2818 const gchar* _tmp25_;
2819 ValadocGtkdocToken* _tmp26_;
2820 _tmp23_ = builder;
2821 _tmp24_ = self->priv->current;
2822 _tmp25_ = _tmp24_->start;
2823 _tmp26_ = self->priv->current;
2824 g_string_append_len (_tmp23_, _tmp25_, (gssize) _tmp26_->length);
2825 }
2826 }
2827 }
2828 }
2829 _tmp27_ = self->priv->factory;
2830 _tmp28_ = valadoc_content_content_factory_create_source_code (_tmp27_);
2831 code = _tmp28_;
2832 _tmp29_ = builder;
2833 _tmp30_ = _tmp29_->str;
2834 source = _tmp30_;
2835 _tmp31_ = self->priv->regex_source_lang;
2836 _tmp32_ = source;
2837 _tmp34_ = g_regex_match (_tmp31_, _tmp32_, 0, &_tmp33_);
2838 _g_match_info_unref0 (info);
2839 info = _tmp33_;
2840 if (_tmp34_) {
2841 gchar* lang_name = NULL;
2842 GMatchInfo* _tmp35_;
2843 gchar* _tmp36_;
2844 gchar* _tmp37_;
2845 gchar* _tmp38_;
2846 gchar* _tmp39_;
2847 ValadocContentSourceCodeLanguage* lang = NULL;
2848 const gchar* _tmp40_;
2849 ValadocContentSourceCodeLanguage _tmp41_;
2850 ValadocContentSourceCodeLanguage* _tmp42_;
2851 ValadocContentSourceCode* _tmp43_;
2852 ValadocContentSourceCodeLanguage* _tmp44_;
2853 ValadocContentSourceCodeLanguage* _tmp45_;
2854 const gchar* _tmp50_;
2855 const gchar* _tmp51_;
2856 const gchar* _tmp52_;
2857 _tmp35_ = info;
2858 _tmp36_ = g_match_info_fetch (_tmp35_, 1);
2859 _tmp37_ = _tmp36_;
2860 _tmp38_ = g_ascii_strdown (_tmp37_, (gssize) -1);
2861 _tmp39_ = _tmp38_;
2862 _g_free0 (_tmp37_);
2863 lang_name = _tmp39_;
2864 _tmp40_ = lang_name;
2865 _tmp41_ = valadoc_content_source_code_language_from_string (_tmp40_, FALSE);
2866 _tmp42_ = __valadoc_content_source_code_language_dup0 (&_tmp41_);
2867 lang = _tmp42_;
2868 _tmp43_ = code;
2869 _tmp44_ = lang;
2870 valadoc_content_source_code_set_language (_tmp43_, *_tmp44_);
2871 _tmp45_ = lang;
2872 if (_tmp45_ == NULL) {
2873 ValadocGtkdocToken* _tmp46_;
2874 const gchar* _tmp47_;
2875 gchar* _tmp48_;
2876 gchar* _tmp49_;
2877 _tmp46_ = source_token;
2878 _tmp47_ = lang_name;
2879 _tmp48_ = g_strdup_printf ("Unknown language `%s' in source code block |[<!-- language=\"\"", _tmp47_);
2880 _tmp49_ = _tmp48_;
2881 valadoc_gtkdoc_parser_report_warning (self, _tmp46_, _tmp49_);
2882 _g_free0 (_tmp49_);
2883 }
2884 _tmp50_ = source;
2885 _tmp51_ = source;
2886 _tmp52_ = string_offset (_tmp50_, (glong) (string_index_of_char (_tmp51_, (gunichar) '>', 0) + 1));
2887 source = _tmp52_;
2888 _g_free0 (lang);
2889 _g_free0 (lang_name);
2890 } else {
2891 ValadocContentSourceCodeLanguage _tmp53_ = 0;
2892 const gchar* _tmp54_;
2893 ValadocContentSourceCode* _tmp55_;
2894 _tmp54_ = source;
2895 if (valadoc_highlighter_xml_scanner_is_xml (_tmp54_)) {
2896 _tmp53_ = VALADOC_CONTENT_SOURCE_CODE_LANGUAGE_XML;
2897 } else {
2898 _tmp53_ = VALADOC_CONTENT_SOURCE_CODE_LANGUAGE_C;
2899 }
2900 _tmp55_ = code;
2901 valadoc_content_source_code_set_language (_tmp55_, _tmp53_);
2902 }
2903 _tmp56_ = code;
2904 _tmp57_ = source;
2905 valadoc_content_source_code_set_code (_tmp56_, _tmp57_);
2906 _tmp58_ = self->priv->factory;
2907 _tmp59_ = valadoc_content_content_factory_create_paragraph (_tmp58_);
2908 p = _tmp59_;
2909 _tmp60_ = p;
2910 _tmp61_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp60_);
2911 _tmp62_ = _tmp61_;
2912 _tmp63_ = code;
2913 vala_collection_add ((ValaCollection*) _tmp62_, (ValadocContentInline*) _tmp63_);
2914 _tmp64_ = self->priv->current;
2915 _tmp65_ = _tmp64_->type;
2916 if (_tmp65_ != VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_SOURCE_CLOSE) {
2917 ValadocGtkdocToken* _tmp66_;
2918 _tmp66_ = self->priv->current;
2919 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp66_, "|]");
2920 result = p;
2921 _g_match_info_unref0 (info);
2922 _g_object_unref0 (code);
2923 _valadoc_gtkdoc_token_unref0 (source_token);
2924 _g_string_free0 (builder);
2925 return result;
2926 }
2927 _tmp67_ = valadoc_gtkdoc_parser_next (self);
2928 _tmp68_ = _tmp67_;
2929 _valadoc_gtkdoc_token_unref0 (_tmp68_);
2930 result = p;
2931 _g_match_info_unref0 (info);
2932 _g_object_unref0 (code);
2933 _valadoc_gtkdoc_token_unref0 (source_token);
2934 _g_string_free0 (builder);
2935 return result;
2936 }
2937
2938 static ValadocContentParagraph*
valadoc_gtkdoc_parser_parse_docbook_title(ValadocGtkdocParser * self)2939 valadoc_gtkdoc_parser_parse_docbook_title (ValadocGtkdocParser* self)
2940 {
2941 ValadocGtkdocToken* _tmp1_;
2942 ValadocGtkdocToken* _tmp2_;
2943 ValadocContentParagraph* p = NULL;
2944 ValadocContentContentFactory* _tmp3_;
2945 ValadocContentParagraph* _tmp4_;
2946 ValadocContentRun* content = NULL;
2947 ValadocContentRun* _tmp5_;
2948 ValadocContentRun* _tmp6_;
2949 ValaList* _tmp7_;
2950 ValaList* _tmp8_;
2951 ValadocContentContentFactory* _tmp9_;
2952 ValadocContentText* _tmp10_;
2953 ValadocContentText* _tmp11_;
2954 ValadocContentRun* _tmp12_;
2955 ValadocContentParagraph* _tmp13_;
2956 ValaList* _tmp14_;
2957 ValaList* _tmp15_;
2958 ValadocContentRun* _tmp16_;
2959 ValadocGtkdocToken* _tmp18_;
2960 ValadocGtkdocToken* _tmp19_;
2961 ValadocContentParagraph* result = NULL;
2962 g_return_val_if_fail (self != NULL, NULL);
2963 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "title")) {
2964 ValadocGtkdocToken* _tmp0_;
2965 _tmp0_ = self->priv->current;
2966 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<title>");
2967 result = NULL;
2968 return result;
2969 }
2970 _tmp1_ = valadoc_gtkdoc_parser_next (self);
2971 _tmp2_ = _tmp1_;
2972 _valadoc_gtkdoc_token_unref0 (_tmp2_);
2973 _tmp3_ = self->priv->factory;
2974 _tmp4_ = valadoc_content_content_factory_create_paragraph (_tmp3_);
2975 p = _tmp4_;
2976 _tmp5_ = valadoc_gtkdoc_parser_parse_inline_content (self);
2977 content = _tmp5_;
2978 _tmp6_ = content;
2979 _tmp7_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp6_);
2980 _tmp8_ = _tmp7_;
2981 _tmp9_ = self->priv->factory;
2982 _tmp10_ = valadoc_content_content_factory_create_text (_tmp9_, ":");
2983 _tmp11_ = _tmp10_;
2984 vala_collection_add ((ValaCollection*) _tmp8_, (ValadocContentInline*) _tmp11_);
2985 _g_object_unref0 (_tmp11_);
2986 _tmp12_ = content;
2987 valadoc_content_run_set_style (_tmp12_, VALADOC_CONTENT_RUN_STYLE_BOLD);
2988 _tmp13_ = p;
2989 _tmp14_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp13_);
2990 _tmp15_ = _tmp14_;
2991 _tmp16_ = content;
2992 vala_collection_add ((ValaCollection*) _tmp15_, (ValadocContentInline*) _tmp16_);
2993 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "title")) {
2994 ValadocGtkdocToken* _tmp17_;
2995 _tmp17_ = self->priv->current;
2996 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp17_, "</title>");
2997 result = p;
2998 _g_object_unref0 (content);
2999 return result;
3000 }
3001 _tmp18_ = valadoc_gtkdoc_parser_next (self);
3002 _tmp19_ = _tmp18_;
3003 _valadoc_gtkdoc_token_unref0 (_tmp19_);
3004 result = p;
3005 _g_object_unref0 (content);
3006 return result;
3007 }
3008
3009 static ValadocContentParagraph*
valadoc_gtkdoc_parser_parse_docbook_graphic(ValadocGtkdocParser * self)3010 valadoc_gtkdoc_parser_parse_docbook_graphic (ValadocGtkdocParser* self)
3011 {
3012 ValadocContentEmbedded* tmp = NULL;
3013 ValadocContentEmbedded* _tmp0_;
3014 ValadocContentEmbedded* _tmp1_;
3015 ValadocContentParagraph* p = NULL;
3016 ValadocContentContentFactory* _tmp2_;
3017 ValadocContentParagraph* _tmp3_;
3018 ValadocContentParagraph* _tmp4_;
3019 ValaList* _tmp5_;
3020 ValaList* _tmp6_;
3021 ValadocContentEmbedded* _tmp7_;
3022 ValadocContentParagraph* result = NULL;
3023 g_return_val_if_fail (self != NULL, NULL);
3024 _tmp0_ = valadoc_gtkdoc_parser_parse_docbook_inlinegraphic (self, "graphic");
3025 tmp = _tmp0_;
3026 _tmp1_ = tmp;
3027 if (_tmp1_ == NULL) {
3028 result = NULL;
3029 _g_object_unref0 (tmp);
3030 return result;
3031 }
3032 _tmp2_ = self->priv->factory;
3033 _tmp3_ = valadoc_content_content_factory_create_paragraph (_tmp2_);
3034 p = _tmp3_;
3035 _tmp4_ = p;
3036 _tmp5_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp4_);
3037 _tmp6_ = _tmp5_;
3038 _tmp7_ = tmp;
3039 vala_collection_add ((ValaCollection*) _tmp6_, (ValadocContentInline*) _tmp7_);
3040 result = p;
3041 _g_object_unref0 (tmp);
3042 return result;
3043 }
3044
3045 static ValadocContentEmbedded*
valadoc_gtkdoc_parser_parse_docbook_inlinegraphic(ValadocGtkdocParser * self,const gchar * tag_name)3046 valadoc_gtkdoc_parser_parse_docbook_inlinegraphic (ValadocGtkdocParser* self,
3047 const gchar* tag_name)
3048 {
3049 ValadocContentEmbedded* e = NULL;
3050 ValadocContentContentFactory* _tmp3_;
3051 ValadocContentEmbedded* _tmp4_;
3052 ValadocContentEmbedded* _tmp5_;
3053 ValadocGtkdocToken* _tmp6_;
3054 ValaHashMap* _tmp7_;
3055 gpointer _tmp8_;
3056 gchar* _tmp9_;
3057 gchar* _tmp10_;
3058 gchar* _tmp11_;
3059 ValadocGtkdocToken* _tmp12_;
3060 ValadocGtkdocToken* _tmp13_;
3061 ValadocGtkdocToken* _tmp17_;
3062 ValadocGtkdocToken* _tmp18_;
3063 ValadocContentEmbedded* result = NULL;
3064 g_return_val_if_fail (self != NULL, NULL);
3065 g_return_val_if_fail (tag_name != NULL, NULL);
3066 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, tag_name)) {
3067 ValadocGtkdocToken* _tmp0_;
3068 gchar* _tmp1_;
3069 gchar* _tmp2_;
3070 _tmp0_ = self->priv->current;
3071 _tmp1_ = g_strdup_printf ("<%s>", tag_name);
3072 _tmp2_ = _tmp1_;
3073 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, _tmp2_);
3074 _g_free0 (_tmp2_);
3075 result = NULL;
3076 return result;
3077 }
3078 _tmp3_ = self->priv->factory;
3079 _tmp4_ = valadoc_content_content_factory_create_embedded (_tmp3_);
3080 e = _tmp4_;
3081 _tmp5_ = e;
3082 _tmp6_ = self->priv->current;
3083 _tmp7_ = _tmp6_->attributes;
3084 _tmp8_ = vala_map_get ((ValaMap*) _tmp7_, "fileref");
3085 _tmp9_ = (gchar*) _tmp8_;
3086 _tmp10_ = valadoc_gtkdoc_parser_fix_resource_path (self, _tmp9_);
3087 _tmp11_ = _tmp10_;
3088 valadoc_content_embedded_set_url (_tmp5_, _tmp11_);
3089 _g_free0 (_tmp11_);
3090 _g_free0 (_tmp9_);
3091 _tmp12_ = valadoc_gtkdoc_parser_next (self);
3092 _tmp13_ = _tmp12_;
3093 _valadoc_gtkdoc_token_unref0 (_tmp13_);
3094 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
3095 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, tag_name)) {
3096 ValadocGtkdocToken* _tmp14_;
3097 gchar* _tmp15_;
3098 gchar* _tmp16_;
3099 _tmp14_ = self->priv->current;
3100 _tmp15_ = g_strdup_printf ("</%s>", tag_name);
3101 _tmp16_ = _tmp15_;
3102 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp14_, _tmp16_);
3103 _g_free0 (_tmp16_);
3104 result = e;
3105 return result;
3106 }
3107 _tmp17_ = valadoc_gtkdoc_parser_next (self);
3108 _tmp18_ = _tmp17_;
3109 _valadoc_gtkdoc_token_unref0 (_tmp18_);
3110 result = e;
3111 return result;
3112 }
3113
3114 static ValadocContentParagraph*
valadoc_gtkdoc_parser_parse_docbook_programlisting(ValadocGtkdocParser * self)3115 valadoc_gtkdoc_parser_parse_docbook_programlisting (ValadocGtkdocParser* self)
3116 {
3117 GString* builder = NULL;
3118 GString* _tmp1_;
3119 ValadocContentSourceCode* src = NULL;
3120 ValadocContentContentFactory* _tmp26_;
3121 ValadocContentSourceCode* _tmp27_;
3122 ValadocContentSourceCode* _tmp28_;
3123 ValadocContentSourceCode* _tmp29_;
3124 GString* _tmp30_;
3125 const gchar* _tmp31_;
3126 ValadocContentParagraph* p = NULL;
3127 ValadocContentContentFactory* _tmp32_;
3128 ValadocContentParagraph* _tmp33_;
3129 ValadocContentParagraph* _tmp34_;
3130 ValaList* _tmp35_;
3131 ValaList* _tmp36_;
3132 ValadocContentSourceCode* _tmp37_;
3133 ValadocGtkdocToken* _tmp39_;
3134 ValadocGtkdocToken* _tmp40_;
3135 ValadocContentParagraph* result = NULL;
3136 g_return_val_if_fail (self != NULL, NULL);
3137 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "programlisting")) {
3138 ValadocGtkdocToken* _tmp0_;
3139 _tmp0_ = self->priv->current;
3140 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<programlisting>");
3141 result = NULL;
3142 return result;
3143 }
3144 _tmp1_ = g_string_new ("");
3145 builder = _tmp1_;
3146 {
3147 ValadocGtkdocToken* _tmp2_;
3148 ValadocGtkdocToken* _tmp3_;
3149 gboolean _tmp4_ = FALSE;
3150 _tmp2_ = valadoc_gtkdoc_parser_next (self);
3151 _tmp3_ = _tmp2_;
3152 _valadoc_gtkdoc_token_unref0 (_tmp3_);
3153 _tmp4_ = TRUE;
3154 while (TRUE) {
3155 gboolean _tmp7_ = FALSE;
3156 ValadocGtkdocToken* _tmp8_;
3157 ValadocGtkdocTokenType _tmp9_;
3158 ValadocGtkdocToken* _tmp15_;
3159 ValadocGtkdocTokenType _tmp16_;
3160 if (!_tmp4_) {
3161 ValadocGtkdocToken* _tmp5_;
3162 ValadocGtkdocToken* _tmp6_;
3163 _tmp5_ = valadoc_gtkdoc_parser_next (self);
3164 _tmp6_ = _tmp5_;
3165 _valadoc_gtkdoc_token_unref0 (_tmp6_);
3166 }
3167 _tmp4_ = FALSE;
3168 _tmp8_ = self->priv->current;
3169 _tmp9_ = _tmp8_->type;
3170 if (_tmp9_ != VALADOC_GTKDOC_TOKEN_TYPE_EOF) {
3171 gboolean _tmp10_ = FALSE;
3172 ValadocGtkdocToken* _tmp11_;
3173 ValadocGtkdocTokenType _tmp12_;
3174 _tmp11_ = self->priv->current;
3175 _tmp12_ = _tmp11_->type;
3176 if (_tmp12_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE) {
3177 ValadocGtkdocToken* _tmp13_;
3178 const gchar* _tmp14_;
3179 _tmp13_ = self->priv->current;
3180 _tmp14_ = _tmp13_->content;
3181 _tmp10_ = g_strcmp0 (_tmp14_, "programlisting") == 0;
3182 } else {
3183 _tmp10_ = FALSE;
3184 }
3185 _tmp7_ = !_tmp10_;
3186 } else {
3187 _tmp7_ = FALSE;
3188 }
3189 if (!_tmp7_) {
3190 break;
3191 }
3192 _tmp15_ = self->priv->current;
3193 _tmp16_ = _tmp15_->type;
3194 if (_tmp16_ == VALADOC_GTKDOC_TOKEN_TYPE_WORD) {
3195 GString* _tmp17_;
3196 ValadocGtkdocToken* _tmp18_;
3197 const gchar* _tmp19_;
3198 _tmp17_ = builder;
3199 _tmp18_ = self->priv->current;
3200 _tmp19_ = _tmp18_->content;
3201 g_string_append (_tmp17_, _tmp19_);
3202 } else {
3203 ValadocGtkdocToken* _tmp20_;
3204 ValadocGtkdocTokenType _tmp21_;
3205 _tmp20_ = self->priv->current;
3206 _tmp21_ = _tmp20_->type;
3207 if (_tmp21_ != VALADOC_GTKDOC_TOKEN_TYPE_XML_COMMENT) {
3208 GString* _tmp22_;
3209 ValadocGtkdocToken* _tmp23_;
3210 const gchar* _tmp24_;
3211 ValadocGtkdocToken* _tmp25_;
3212 _tmp22_ = builder;
3213 _tmp23_ = self->priv->current;
3214 _tmp24_ = _tmp23_->start;
3215 _tmp25_ = self->priv->current;
3216 g_string_append_len (_tmp22_, _tmp24_, (gssize) _tmp25_->length);
3217 }
3218 }
3219 }
3220 }
3221 _tmp26_ = self->priv->factory;
3222 _tmp27_ = valadoc_content_content_factory_create_source_code (_tmp26_);
3223 src = _tmp27_;
3224 _tmp28_ = src;
3225 valadoc_content_source_code_set_language (_tmp28_, VALADOC_CONTENT_SOURCE_CODE_LANGUAGE_C);
3226 _tmp29_ = src;
3227 _tmp30_ = builder;
3228 _tmp31_ = _tmp30_->str;
3229 valadoc_content_source_code_set_code (_tmp29_, _tmp31_);
3230 _tmp32_ = self->priv->factory;
3231 _tmp33_ = valadoc_content_content_factory_create_paragraph (_tmp32_);
3232 p = _tmp33_;
3233 _tmp34_ = p;
3234 _tmp35_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp34_);
3235 _tmp36_ = _tmp35_;
3236 _tmp37_ = src;
3237 vala_collection_add ((ValaCollection*) _tmp36_, (ValadocContentInline*) _tmp37_);
3238 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "programlisting")) {
3239 ValadocGtkdocToken* _tmp38_;
3240 _tmp38_ = self->priv->current;
3241 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp38_, "</programlisting>");
3242 result = p;
3243 _g_object_unref0 (src);
3244 _g_string_free0 (builder);
3245 return result;
3246 }
3247 _tmp39_ = valadoc_gtkdoc_parser_next (self);
3248 _tmp40_ = _tmp39_;
3249 _valadoc_gtkdoc_token_unref0 (_tmp40_);
3250 result = p;
3251 _g_object_unref0 (src);
3252 _g_string_free0 (builder);
3253 return result;
3254 }
3255
3256 static inline ValaCollection*
valadoc_gtkdoc_parser_parse_docbook_informalexample(ValadocGtkdocParser * self)3257 valadoc_gtkdoc_parser_parse_docbook_informalexample (ValadocGtkdocParser* self)
3258 {
3259 ValaCollection* _tmp0_;
3260 ValaCollection* result = NULL;
3261 g_return_val_if_fail (self != NULL, NULL);
3262 _tmp0_ = valadoc_gtkdoc_parser_parse_docbook_example (self, "informalexample");
3263 result = _tmp0_;
3264 return result;
3265 }
3266
3267 static ValaCollection*
valadoc_gtkdoc_parser_parse_docbook_example(ValadocGtkdocParser * self,const gchar * tag_name)3268 valadoc_gtkdoc_parser_parse_docbook_example (ValadocGtkdocParser* self,
3269 const gchar* tag_name)
3270 {
3271 ValadocGtkdocToken* _tmp3_;
3272 ValadocGtkdocToken* _tmp4_;
3273 ValaCollection* content = NULL;
3274 GEqualFunc _tmp5_;
3275 ValaArrayList* _tmp6_;
3276 ValaCollection* _tmp7_;
3277 ValaCollection* _tmp8_;
3278 ValaCollection* _tmp9_;
3279 ValadocGtkdocToken* _tmp13_;
3280 ValadocGtkdocToken* _tmp14_;
3281 ValaCollection* result = NULL;
3282 g_return_val_if_fail (self != NULL, NULL);
3283 g_return_val_if_fail (tag_name != NULL, NULL);
3284 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, tag_name)) {
3285 ValadocGtkdocToken* _tmp0_;
3286 gchar* _tmp1_;
3287 gchar* _tmp2_;
3288 _tmp0_ = self->priv->current;
3289 _tmp1_ = g_strdup_printf ("<%s>", tag_name);
3290 _tmp2_ = _tmp1_;
3291 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, _tmp2_);
3292 _g_free0 (_tmp2_);
3293 result = NULL;
3294 return result;
3295 }
3296 _tmp3_ = valadoc_gtkdoc_parser_next (self);
3297 _tmp4_ = _tmp3_;
3298 _valadoc_gtkdoc_token_unref0 (_tmp4_);
3299 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
3300 _tmp5_ = g_direct_equal;
3301 _tmp6_ = vala_array_list_new (VALADOC_CONTENT_TYPE_BLOCK, (GBoxedCopyFunc) g_object_ref, (GDestroyNotify) g_object_unref, _tmp5_);
3302 content = (ValaCollection*) _tmp6_;
3303 _tmp7_ = content;
3304 _tmp8_ = valadoc_gtkdoc_parser_parse_mixed_content (self);
3305 _tmp9_ = _tmp8_;
3306 vala_collection_add_all (_tmp7_, _tmp9_);
3307 _vala_iterable_unref0 (_tmp9_);
3308 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, tag_name)) {
3309 ValadocGtkdocToken* _tmp10_;
3310 gchar* _tmp11_;
3311 gchar* _tmp12_;
3312 _tmp10_ = self->priv->current;
3313 _tmp11_ = g_strdup_printf ("</%s>", tag_name);
3314 _tmp12_ = _tmp11_;
3315 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp10_, _tmp12_);
3316 _g_free0 (_tmp12_);
3317 result = content;
3318 return result;
3319 }
3320 _tmp13_ = valadoc_gtkdoc_parser_next (self);
3321 _tmp14_ = _tmp13_;
3322 _valadoc_gtkdoc_token_unref0 (_tmp14_);
3323 result = content;
3324 return result;
3325 }
3326
3327 static ValaList*
valadoc_gtkdoc_parser_parse_docbook_refsect2(ValadocGtkdocParser * self,gint nr)3328 valadoc_gtkdoc_parser_parse_docbook_refsect2 (ValadocGtkdocParser* self,
3329 gint nr)
3330 {
3331 gchar* _tmp0_;
3332 gchar* _tmp1_;
3333 gboolean _tmp2_;
3334 gchar* id = NULL;
3335 ValadocGtkdocToken* _tmp6_;
3336 ValaHashMap* _tmp7_;
3337 gpointer _tmp8_;
3338 const gchar* _tmp9_;
3339 ValadocGtkdocToken* _tmp13_;
3340 ValadocGtkdocToken* _tmp14_;
3341 ValaList* content = NULL;
3342 GEqualFunc _tmp15_;
3343 ValaArrayList* _tmp16_;
3344 ValaList* _tmp17_;
3345 ValaCollection* _tmp18_;
3346 ValaCollection* _tmp19_;
3347 gchar* _tmp20_;
3348 gchar* _tmp21_;
3349 gboolean _tmp22_;
3350 ValadocGtkdocToken* _tmp26_;
3351 ValadocGtkdocToken* _tmp27_;
3352 ValaList* result = NULL;
3353 g_return_val_if_fail (self != NULL, NULL);
3354 _tmp0_ = g_strdup_printf ("refsect%d", nr);
3355 _tmp1_ = _tmp0_;
3356 _tmp2_ = !valadoc_gtkdoc_parser_check_xml_open_tag (self, _tmp1_);
3357 _g_free0 (_tmp1_);
3358 if (_tmp2_) {
3359 ValadocGtkdocToken* _tmp3_;
3360 gchar* _tmp4_;
3361 gchar* _tmp5_;
3362 _tmp3_ = self->priv->current;
3363 _tmp4_ = g_strdup_printf ("<refsect%d>", nr);
3364 _tmp5_ = _tmp4_;
3365 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp3_, _tmp5_);
3366 _g_free0 (_tmp5_);
3367 result = NULL;
3368 return result;
3369 }
3370 _tmp6_ = self->priv->current;
3371 _tmp7_ = _tmp6_->attributes;
3372 _tmp8_ = vala_map_get ((ValaMap*) _tmp7_, "id");
3373 id = (gchar*) _tmp8_;
3374 _tmp9_ = id;
3375 if (_tmp9_ != NULL) {
3376 ValadocImporterInternalIdRegistrar* _tmp10_;
3377 const gchar* _tmp11_;
3378 ValadocApiNode* _tmp12_;
3379 _tmp10_ = self->priv->id_registrar;
3380 _tmp11_ = id;
3381 _tmp12_ = self->priv->element;
3382 valadoc_importer_internal_id_registrar_register_symbol (_tmp10_, _tmp11_, _tmp12_);
3383 }
3384 _tmp13_ = valadoc_gtkdoc_parser_next (self);
3385 _tmp14_ = _tmp13_;
3386 _valadoc_gtkdoc_token_unref0 (_tmp14_);
3387 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
3388 _tmp15_ = g_direct_equal;
3389 _tmp16_ = vala_array_list_new (VALADOC_CONTENT_TYPE_BLOCK, (GBoxedCopyFunc) g_object_ref, (GDestroyNotify) g_object_unref, _tmp15_);
3390 content = (ValaList*) _tmp16_;
3391 _tmp17_ = content;
3392 _tmp18_ = valadoc_gtkdoc_parser_parse_mixed_content (self);
3393 _tmp19_ = _tmp18_;
3394 valadoc_gtkdoc_parser_append_block_content_not_null_all (self, (ValaCollection*) _tmp17_, _tmp19_);
3395 _vala_iterable_unref0 (_tmp19_);
3396 _tmp20_ = g_strdup_printf ("refsect%d", nr);
3397 _tmp21_ = _tmp20_;
3398 _tmp22_ = !valadoc_gtkdoc_parser_check_xml_close_tag (self, _tmp21_);
3399 _g_free0 (_tmp21_);
3400 if (_tmp22_) {
3401 ValadocGtkdocToken* _tmp23_;
3402 gchar* _tmp24_;
3403 gchar* _tmp25_;
3404 _tmp23_ = self->priv->current;
3405 _tmp24_ = g_strdup_printf ("</refsect%d>", nr);
3406 _tmp25_ = _tmp24_;
3407 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp23_, _tmp25_);
3408 _g_free0 (_tmp25_);
3409 result = content;
3410 _g_free0 (id);
3411 return result;
3412 }
3413 _tmp26_ = valadoc_gtkdoc_parser_next (self);
3414 _tmp27_ = _tmp26_;
3415 _valadoc_gtkdoc_token_unref0 (_tmp27_);
3416 result = content;
3417 _g_free0 (id);
3418 return result;
3419 }
3420
3421 static ValaList*
valadoc_gtkdoc_parser_parse_docbook_figure(ValadocGtkdocParser * self)3422 valadoc_gtkdoc_parser_parse_docbook_figure (ValadocGtkdocParser* self)
3423 {
3424 ValadocGtkdocToken* _tmp1_;
3425 ValadocGtkdocToken* _tmp2_;
3426 ValaList* content = NULL;
3427 GEqualFunc _tmp3_;
3428 ValaArrayList* _tmp4_;
3429 gboolean _tmp5_ = FALSE;
3430 ValadocGtkdocToken* _tmp6_;
3431 ValadocGtkdocTokenType _tmp7_;
3432 ValadocGtkdocToken* _tmp45_;
3433 ValadocGtkdocToken* _tmp46_;
3434 ValaList* result = NULL;
3435 g_return_val_if_fail (self != NULL, NULL);
3436 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "figure")) {
3437 ValadocGtkdocToken* _tmp0_;
3438 _tmp0_ = self->priv->current;
3439 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<figure>");
3440 result = NULL;
3441 return result;
3442 }
3443 _tmp1_ = valadoc_gtkdoc_parser_next (self);
3444 _tmp2_ = _tmp1_;
3445 _valadoc_gtkdoc_token_unref0 (_tmp2_);
3446 _tmp3_ = g_direct_equal;
3447 _tmp4_ = vala_array_list_new (VALADOC_CONTENT_TYPE_BLOCK, (GBoxedCopyFunc) g_object_ref, (GDestroyNotify) g_object_unref, _tmp3_);
3448 content = (ValaList*) _tmp4_;
3449 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
3450 _tmp6_ = self->priv->current;
3451 _tmp7_ = _tmp6_->type;
3452 if (_tmp7_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
3453 ValadocGtkdocToken* _tmp8_;
3454 const gchar* _tmp9_;
3455 _tmp8_ = self->priv->current;
3456 _tmp9_ = _tmp8_->content;
3457 _tmp5_ = g_strcmp0 (_tmp9_, "title") == 0;
3458 } else {
3459 _tmp5_ = FALSE;
3460 }
3461 if (_tmp5_) {
3462 ValaList* _tmp10_;
3463 ValadocContentParagraph* _tmp11_;
3464 ValadocContentParagraph* _tmp12_;
3465 _tmp10_ = content;
3466 _tmp11_ = valadoc_gtkdoc_parser_parse_docbook_title (self);
3467 _tmp12_ = _tmp11_;
3468 valadoc_gtkdoc_parser_append_block_content_not_null (self, (ValaCollection*) _tmp10_, (ValadocContentBlock*) _tmp12_);
3469 _g_object_unref0 (_tmp12_);
3470 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
3471 }
3472 while (TRUE) {
3473 ValadocGtkdocToken* _tmp13_;
3474 ValadocGtkdocTokenType _tmp14_;
3475 ValadocGtkdocToken* _tmp15_;
3476 const gchar* _tmp16_;
3477 _tmp13_ = self->priv->current;
3478 _tmp14_ = _tmp13_->type;
3479 if (!(_tmp14_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN)) {
3480 break;
3481 }
3482 _tmp15_ = self->priv->current;
3483 _tmp16_ = _tmp15_->content;
3484 if (g_strcmp0 (_tmp16_, "inlinegraphic") == 0) {
3485 ValadocContentParagraph* _tmp17_ = NULL;
3486 ValaList* _tmp18_;
3487 gint _tmp19_;
3488 gint _tmp20_;
3489 ValadocContentParagraph* p = NULL;
3490 ValadocContentParagraph* _tmp25_;
3491 ValadocContentParagraph* _tmp26_;
3492 _tmp18_ = content;
3493 _tmp19_ = vala_collection_get_size ((ValaCollection*) _tmp18_);
3494 _tmp20_ = _tmp19_;
3495 if (_tmp20_ > 0) {
3496 ValaList* _tmp21_;
3497 gpointer _tmp22_;
3498 ValadocContentBlock* _tmp23_;
3499 ValadocContentParagraph* _tmp24_;
3500 _tmp21_ = content;
3501 _tmp22_ = vala_list_get (_tmp21_, 0);
3502 _tmp23_ = (ValadocContentBlock*) _tmp22_;
3503 _tmp24_ = VALADOC_CONTENT_IS_PARAGRAPH (_tmp23_) ? ((ValadocContentParagraph*) _tmp23_) : NULL;
3504 if (_tmp24_ == NULL) {
3505 _g_object_unref0 (_tmp23_);
3506 }
3507 _g_object_unref0 (_tmp17_);
3508 _tmp17_ = _tmp24_;
3509 } else {
3510 _g_object_unref0 (_tmp17_);
3511 _tmp17_ = NULL;
3512 }
3513 _tmp25_ = _g_object_ref0 (_tmp17_);
3514 p = _tmp25_;
3515 _tmp26_ = p;
3516 if (_tmp26_ == NULL) {
3517 ValadocContentContentFactory* _tmp27_;
3518 ValadocContentParagraph* _tmp28_;
3519 _tmp27_ = self->priv->factory;
3520 _tmp28_ = valadoc_content_content_factory_create_paragraph (_tmp27_);
3521 _g_object_unref0 (p);
3522 p = _tmp28_;
3523 }
3524 while (TRUE) {
3525 gboolean _tmp29_ = FALSE;
3526 ValadocGtkdocToken* _tmp30_;
3527 ValadocGtkdocTokenType _tmp31_;
3528 ValadocContentParagraph* _tmp34_;
3529 ValaList* _tmp35_;
3530 ValaList* _tmp36_;
3531 ValadocContentEmbedded* _tmp37_;
3532 ValadocContentEmbedded* _tmp38_;
3533 _tmp30_ = self->priv->current;
3534 _tmp31_ = _tmp30_->type;
3535 if (_tmp31_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
3536 ValadocGtkdocToken* _tmp32_;
3537 const gchar* _tmp33_;
3538 _tmp32_ = self->priv->current;
3539 _tmp33_ = _tmp32_->content;
3540 _tmp29_ = g_strcmp0 (_tmp33_, "inlinegraphic") == 0;
3541 } else {
3542 _tmp29_ = FALSE;
3543 }
3544 if (!_tmp29_) {
3545 break;
3546 }
3547 _tmp34_ = p;
3548 _tmp35_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp34_);
3549 _tmp36_ = _tmp35_;
3550 _tmp37_ = valadoc_gtkdoc_parser_parse_docbook_inlinegraphic (self, "inlinegraphic");
3551 _tmp38_ = _tmp37_;
3552 vala_collection_add ((ValaCollection*) _tmp36_, (ValadocContentInline*) _tmp38_);
3553 _g_object_unref0 (_tmp38_);
3554 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
3555 }
3556 _g_object_unref0 (p);
3557 _g_object_unref0 (_tmp17_);
3558 } else {
3559 ValadocGtkdocToken* _tmp39_;
3560 const gchar* _tmp40_;
3561 _tmp39_ = self->priv->current;
3562 _tmp40_ = _tmp39_->content;
3563 if (g_strcmp0 (_tmp40_, "graphic") == 0) {
3564 ValaList* _tmp41_;
3565 ValadocContentParagraph* _tmp42_;
3566 ValadocContentParagraph* _tmp43_;
3567 _tmp41_ = content;
3568 _tmp42_ = valadoc_gtkdoc_parser_parse_docbook_graphic (self);
3569 _tmp43_ = _tmp42_;
3570 valadoc_gtkdoc_parser_append_block_content_not_null (self, (ValaCollection*) _tmp41_, (ValadocContentBlock*) _tmp43_);
3571 _g_object_unref0 (_tmp43_);
3572 } else {
3573 break;
3574 }
3575 }
3576 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
3577 }
3578 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "figure")) {
3579 ValadocGtkdocToken* _tmp44_;
3580 _tmp44_ = self->priv->current;
3581 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp44_, "</figure>");
3582 result = content;
3583 return result;
3584 }
3585 _tmp45_ = valadoc_gtkdoc_parser_next (self);
3586 _tmp46_ = _tmp45_;
3587 _valadoc_gtkdoc_token_unref0 (_tmp46_);
3588 result = content;
3589 return result;
3590 }
3591
3592 static ValadocContentRun*
valadoc_gtkdoc_parser_parse_docbook_footnote(ValadocGtkdocParser * self)3593 valadoc_gtkdoc_parser_parse_docbook_footnote (ValadocGtkdocParser* self)
3594 {
3595 ValadocGtkdocToken* _tmp1_;
3596 ValadocGtkdocToken* _tmp2_;
3597 gint counter = 0;
3598 ValaList* _tmp3_;
3599 gint _tmp4_;
3600 gint _tmp5_;
3601 ValadocContentRun* nr = NULL;
3602 ValadocContentContentFactory* _tmp6_;
3603 ValadocContentRun* _tmp7_;
3604 ValadocContentRun* _tmp8_;
3605 ValaList* _tmp9_;
3606 ValaList* _tmp10_;
3607 ValadocContentContentFactory* _tmp11_;
3608 gchar* _tmp12_;
3609 gchar* _tmp13_;
3610 ValadocContentText* _tmp14_;
3611 ValadocContentText* _tmp15_;
3612 ValaList* content = NULL;
3613 GEqualFunc _tmp16_;
3614 ValaArrayList* _tmp17_;
3615 ValaList* _tmp18_;
3616 ValaList* _tmp19_;
3617 ValaList* _tmp20_;
3618 ValaCollection* _tmp21_;
3619 ValaCollection* _tmp22_;
3620 ValadocContentParagraph* _tmp23_ = NULL;
3621 ValaList* _tmp24_;
3622 gboolean _tmp25_;
3623 gboolean _tmp26_;
3624 ValadocContentParagraph* first = NULL;
3625 ValadocContentParagraph* _tmp31_;
3626 ValadocContentParagraph* _tmp32_;
3627 ValadocContentRun* entry = NULL;
3628 ValadocContentContentFactory* _tmp37_;
3629 ValadocContentRun* _tmp38_;
3630 ValadocContentRun* _tmp39_;
3631 ValaList* _tmp40_;
3632 ValaList* _tmp41_;
3633 ValadocContentContentFactory* _tmp42_;
3634 gchar* _tmp43_;
3635 gchar* _tmp44_;
3636 gchar* _tmp45_;
3637 gchar* _tmp46_;
3638 ValadocContentText* _tmp47_;
3639 ValadocContentText* _tmp48_;
3640 ValadocContentParagraph* _tmp49_;
3641 ValaList* _tmp50_;
3642 ValaList* _tmp51_;
3643 ValadocContentRun* _tmp52_;
3644 ValadocGtkdocToken* _tmp54_;
3645 ValadocGtkdocToken* _tmp55_;
3646 ValadocContentRun* result = NULL;
3647 g_return_val_if_fail (self != NULL, NULL);
3648 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "footnote")) {
3649 ValadocGtkdocToken* _tmp0_;
3650 _tmp0_ = self->priv->current;
3651 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<footnote>");
3652 result = NULL;
3653 return result;
3654 }
3655 _tmp1_ = valadoc_gtkdoc_parser_next (self);
3656 _tmp2_ = _tmp1_;
3657 _valadoc_gtkdoc_token_unref0 (_tmp2_);
3658 _tmp3_ = self->priv->footnotes;
3659 _tmp4_ = vala_collection_get_size ((ValaCollection*) _tmp3_);
3660 _tmp5_ = _tmp4_;
3661 counter = _tmp5_ + 1;
3662 _tmp6_ = self->priv->factory;
3663 _tmp7_ = valadoc_content_content_factory_create_run (_tmp6_, VALADOC_CONTENT_RUN_STYLE_ITALIC);
3664 nr = _tmp7_;
3665 _tmp8_ = nr;
3666 _tmp9_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp8_);
3667 _tmp10_ = _tmp9_;
3668 _tmp11_ = self->priv->factory;
3669 _tmp12_ = g_strdup_printf ("[%d] ", counter);
3670 _tmp13_ = _tmp12_;
3671 _tmp14_ = valadoc_content_content_factory_create_text (_tmp11_, _tmp13_);
3672 _tmp15_ = _tmp14_;
3673 vala_collection_add ((ValaCollection*) _tmp10_, (ValadocContentInline*) _tmp15_);
3674 _g_object_unref0 (_tmp15_);
3675 _g_free0 (_tmp13_);
3676 _tmp16_ = g_direct_equal;
3677 _tmp17_ = vala_array_list_new (VALADOC_CONTENT_TYPE_BLOCK, (GBoxedCopyFunc) g_object_ref, (GDestroyNotify) g_object_unref, _tmp16_);
3678 content = (ValaList*) _tmp17_;
3679 _tmp18_ = self->priv->footnotes;
3680 _tmp19_ = content;
3681 vala_collection_add ((ValaCollection*) _tmp18_, _tmp19_);
3682 _tmp20_ = content;
3683 _tmp21_ = valadoc_gtkdoc_parser_parse_mixed_content (self);
3684 _tmp22_ = _tmp21_;
3685 vala_collection_add_all ((ValaCollection*) _tmp20_, _tmp22_);
3686 _vala_iterable_unref0 (_tmp22_);
3687 _tmp24_ = content;
3688 _tmp25_ = vala_collection_get_is_empty ((ValaCollection*) _tmp24_);
3689 _tmp26_ = _tmp25_;
3690 if (_tmp26_) {
3691 _g_object_unref0 (_tmp23_);
3692 _tmp23_ = NULL;
3693 } else {
3694 ValaList* _tmp27_;
3695 gpointer _tmp28_;
3696 ValadocContentBlock* _tmp29_;
3697 ValadocContentParagraph* _tmp30_;
3698 _tmp27_ = content;
3699 _tmp28_ = vala_list_first (_tmp27_);
3700 _tmp29_ = (ValadocContentBlock*) _tmp28_;
3701 _tmp30_ = VALADOC_CONTENT_IS_PARAGRAPH (_tmp29_) ? ((ValadocContentParagraph*) _tmp29_) : NULL;
3702 if (_tmp30_ == NULL) {
3703 _g_object_unref0 (_tmp29_);
3704 }
3705 _g_object_unref0 (_tmp23_);
3706 _tmp23_ = _tmp30_;
3707 }
3708 _tmp31_ = _g_object_ref0 (_tmp23_);
3709 first = _tmp31_;
3710 _tmp32_ = first;
3711 if (_tmp32_ == NULL) {
3712 ValadocContentContentFactory* _tmp33_;
3713 ValadocContentParagraph* _tmp34_;
3714 ValaList* _tmp35_;
3715 ValadocContentParagraph* _tmp36_;
3716 _tmp33_ = self->priv->factory;
3717 _tmp34_ = valadoc_content_content_factory_create_paragraph (_tmp33_);
3718 _g_object_unref0 (first);
3719 first = _tmp34_;
3720 _tmp35_ = content;
3721 _tmp36_ = first;
3722 vala_list_insert (_tmp35_, 0, (ValadocContentBlock*) _tmp36_);
3723 }
3724 _tmp37_ = self->priv->factory;
3725 _tmp38_ = valadoc_content_content_factory_create_run (_tmp37_, VALADOC_CONTENT_RUN_STYLE_ITALIC);
3726 entry = _tmp38_;
3727 _tmp39_ = entry;
3728 _tmp40_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp39_);
3729 _tmp41_ = _tmp40_;
3730 _tmp42_ = self->priv->factory;
3731 _tmp43_ = g_strdup_printf ("%i", counter);
3732 _tmp44_ = _tmp43_;
3733 _tmp45_ = g_strconcat (_tmp44_, ": ", NULL);
3734 _tmp46_ = _tmp45_;
3735 _tmp47_ = valadoc_content_content_factory_create_text (_tmp42_, _tmp46_);
3736 _tmp48_ = _tmp47_;
3737 vala_collection_add ((ValaCollection*) _tmp41_, (ValadocContentInline*) _tmp48_);
3738 _g_object_unref0 (_tmp48_);
3739 _g_free0 (_tmp46_);
3740 _g_free0 (_tmp44_);
3741 _tmp49_ = first;
3742 _tmp50_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp49_);
3743 _tmp51_ = _tmp50_;
3744 _tmp52_ = entry;
3745 vala_list_insert (_tmp51_, 0, (ValadocContentInline*) _tmp52_);
3746 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "footnote")) {
3747 ValadocGtkdocToken* _tmp53_;
3748 _tmp53_ = self->priv->current;
3749 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp53_, "</footnote>");
3750 result = nr;
3751 _g_object_unref0 (entry);
3752 _g_object_unref0 (first);
3753 _g_object_unref0 (_tmp23_);
3754 _vala_iterable_unref0 (content);
3755 return result;
3756 }
3757 _tmp54_ = valadoc_gtkdoc_parser_next (self);
3758 _tmp55_ = _tmp54_;
3759 _valadoc_gtkdoc_token_unref0 (_tmp55_);
3760 result = nr;
3761 _g_object_unref0 (entry);
3762 _g_object_unref0 (first);
3763 _g_object_unref0 (_tmp23_);
3764 _vala_iterable_unref0 (content);
3765 return result;
3766 }
3767
3768 static inline void
valadoc_gtkdoc_parser_append_block_content_not_null_all(ValadocGtkdocParser * self,ValaCollection * run,ValaCollection * elements)3769 valadoc_gtkdoc_parser_append_block_content_not_null_all (ValadocGtkdocParser* self,
3770 ValaCollection* run,
3771 ValaCollection* elements)
3772 {
3773 g_return_if_fail (self != NULL);
3774 g_return_if_fail (run != NULL);
3775 if (elements != NULL) {
3776 vala_collection_add_all (run, elements);
3777 }
3778 }
3779
3780 static inline void
valadoc_gtkdoc_parser_append_block_content_not_null(ValadocGtkdocParser * self,ValaCollection * run,ValadocContentBlock * element)3781 valadoc_gtkdoc_parser_append_block_content_not_null (ValadocGtkdocParser* self,
3782 ValaCollection* run,
3783 ValadocContentBlock* element)
3784 {
3785 g_return_if_fail (self != NULL);
3786 g_return_if_fail (run != NULL);
3787 if (element != NULL) {
3788 vala_collection_add (run, element);
3789 }
3790 }
3791
3792 static ValadocContentTableRow*
valadoc_gtkdoc_parser_parse_docbook_thead(ValadocGtkdocParser * self)3793 valadoc_gtkdoc_parser_parse_docbook_thead (ValadocGtkdocParser* self)
3794 {
3795 ValadocGtkdocToken* _tmp1_;
3796 ValadocGtkdocToken* _tmp2_;
3797 ValadocContentTableRow* row = NULL;
3798 ValadocContentTableRow* _tmp3_;
3799 ValadocGtkdocToken* _tmp5_;
3800 ValadocGtkdocToken* _tmp6_;
3801 ValadocContentTableRow* result = NULL;
3802 g_return_val_if_fail (self != NULL, NULL);
3803 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "thead")) {
3804 ValadocGtkdocToken* _tmp0_;
3805 _tmp0_ = self->priv->current;
3806 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<thead>");
3807 result = NULL;
3808 return result;
3809 }
3810 _tmp1_ = valadoc_gtkdoc_parser_next (self);
3811 _tmp2_ = _tmp1_;
3812 _valadoc_gtkdoc_token_unref0 (_tmp2_);
3813 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
3814 _tmp3_ = valadoc_gtkdoc_parser_parse_docbook_row (self, VALADOC_CONTENT_RUN_STYLE_BOLD);
3815 row = _tmp3_;
3816 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
3817 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "thead")) {
3818 ValadocGtkdocToken* _tmp4_;
3819 _tmp4_ = self->priv->current;
3820 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp4_, "</thead>");
3821 result = row;
3822 return result;
3823 }
3824 _tmp5_ = valadoc_gtkdoc_parser_next (self);
3825 _tmp6_ = _tmp5_;
3826 _valadoc_gtkdoc_token_unref0 (_tmp6_);
3827 result = row;
3828 return result;
3829 }
3830
3831 static ValadocContentTableCell*
valadoc_gtkdoc_parser_parse_docbook_entry(ValadocGtkdocParser * self,ValadocContentRunStyle default_style)3832 valadoc_gtkdoc_parser_parse_docbook_entry (ValadocGtkdocParser* self,
3833 ValadocContentRunStyle default_style)
3834 {
3835 ValadocGtkdocToken* _tmp1_;
3836 ValadocGtkdocToken* _tmp2_;
3837 ValadocContentTableCell* cell = NULL;
3838 ValadocContentContentFactory* _tmp3_;
3839 ValadocContentTableCell* _tmp4_;
3840 ValadocContentRun* run = NULL;
3841 ValadocContentContentFactory* _tmp5_;
3842 ValadocContentRun* _tmp6_;
3843 ValadocContentRun* _tmp7_;
3844 ValaList* _tmp8_;
3845 ValaList* _tmp9_;
3846 ValadocContentRun* _tmp10_;
3847 ValadocContentRun* _tmp11_;
3848 ValadocContentTableCell* _tmp12_;
3849 ValaList* _tmp13_;
3850 ValaList* _tmp14_;
3851 ValadocContentRun* _tmp15_;
3852 ValadocGtkdocToken* _tmp17_;
3853 ValadocGtkdocToken* _tmp18_;
3854 ValadocContentTableCell* result = NULL;
3855 g_return_val_if_fail (self != NULL, NULL);
3856 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "entry")) {
3857 ValadocGtkdocToken* _tmp0_;
3858 _tmp0_ = self->priv->current;
3859 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<entry>");
3860 result = NULL;
3861 return result;
3862 }
3863 _tmp1_ = valadoc_gtkdoc_parser_next (self);
3864 _tmp2_ = _tmp1_;
3865 _valadoc_gtkdoc_token_unref0 (_tmp2_);
3866 _tmp3_ = self->priv->factory;
3867 _tmp4_ = valadoc_content_content_factory_create_table_cell (_tmp3_);
3868 cell = _tmp4_;
3869 _tmp5_ = self->priv->factory;
3870 _tmp6_ = valadoc_content_content_factory_create_run (_tmp5_, default_style);
3871 run = _tmp6_;
3872 _tmp7_ = run;
3873 _tmp8_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp7_);
3874 _tmp9_ = _tmp8_;
3875 _tmp10_ = valadoc_gtkdoc_parser_parse_inline_content (self);
3876 _tmp11_ = _tmp10_;
3877 vala_collection_add ((ValaCollection*) _tmp9_, (ValadocContentInline*) _tmp11_);
3878 _g_object_unref0 (_tmp11_);
3879 _tmp12_ = cell;
3880 _tmp13_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp12_);
3881 _tmp14_ = _tmp13_;
3882 _tmp15_ = run;
3883 vala_collection_add ((ValaCollection*) _tmp14_, (ValadocContentInline*) _tmp15_);
3884 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "entry")) {
3885 ValadocGtkdocToken* _tmp16_;
3886 _tmp16_ = self->priv->current;
3887 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp16_, "</entry>");
3888 result = cell;
3889 _g_object_unref0 (run);
3890 return result;
3891 }
3892 _tmp17_ = valadoc_gtkdoc_parser_next (self);
3893 _tmp18_ = _tmp17_;
3894 _valadoc_gtkdoc_token_unref0 (_tmp18_);
3895 result = cell;
3896 _g_object_unref0 (run);
3897 return result;
3898 }
3899
3900 static ValadocContentTableRow*
valadoc_gtkdoc_parser_parse_docbook_row(ValadocGtkdocParser * self,ValadocContentRunStyle default_style)3901 valadoc_gtkdoc_parser_parse_docbook_row (ValadocGtkdocParser* self,
3902 ValadocContentRunStyle default_style)
3903 {
3904 ValadocGtkdocToken* _tmp1_;
3905 ValadocGtkdocToken* _tmp2_;
3906 ValadocContentTableRow* row = NULL;
3907 ValadocContentContentFactory* _tmp3_;
3908 ValadocContentTableRow* _tmp4_;
3909 ValadocGtkdocToken* _tmp17_;
3910 ValadocGtkdocToken* _tmp18_;
3911 ValadocContentTableRow* result = NULL;
3912 g_return_val_if_fail (self != NULL, NULL);
3913 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "row")) {
3914 ValadocGtkdocToken* _tmp0_;
3915 _tmp0_ = self->priv->current;
3916 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<row>");
3917 result = NULL;
3918 return result;
3919 }
3920 _tmp1_ = valadoc_gtkdoc_parser_next (self);
3921 _tmp2_ = _tmp1_;
3922 _valadoc_gtkdoc_token_unref0 (_tmp2_);
3923 _tmp3_ = self->priv->factory;
3924 _tmp4_ = valadoc_content_content_factory_create_table_row (_tmp3_);
3925 row = _tmp4_;
3926 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
3927 while (TRUE) {
3928 gboolean _tmp5_ = FALSE;
3929 ValadocGtkdocToken* _tmp6_;
3930 ValadocGtkdocTokenType _tmp7_;
3931 ValadocContentTableCell* table_cell = NULL;
3932 ValadocContentTableCell* _tmp10_;
3933 ValadocContentTableCell* _tmp11_;
3934 ValadocContentTableRow* _tmp12_;
3935 ValaList* _tmp13_;
3936 ValaList* _tmp14_;
3937 ValadocContentTableCell* _tmp15_;
3938 _tmp6_ = self->priv->current;
3939 _tmp7_ = _tmp6_->type;
3940 if (_tmp7_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
3941 ValadocGtkdocToken* _tmp8_;
3942 const gchar* _tmp9_;
3943 _tmp8_ = self->priv->current;
3944 _tmp9_ = _tmp8_->content;
3945 _tmp5_ = g_strcmp0 (_tmp9_, "entry") == 0;
3946 } else {
3947 _tmp5_ = FALSE;
3948 }
3949 if (!_tmp5_) {
3950 break;
3951 }
3952 _tmp10_ = valadoc_gtkdoc_parser_parse_docbook_entry (self, default_style);
3953 table_cell = _tmp10_;
3954 _tmp11_ = table_cell;
3955 if (_tmp11_ == NULL) {
3956 _g_object_unref0 (table_cell);
3957 break;
3958 }
3959 _tmp12_ = row;
3960 _tmp13_ = valadoc_content_table_row_get_cells (_tmp12_);
3961 _tmp14_ = _tmp13_;
3962 _tmp15_ = table_cell;
3963 vala_collection_add ((ValaCollection*) _tmp14_, _tmp15_);
3964 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
3965 _g_object_unref0 (table_cell);
3966 }
3967 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "row")) {
3968 ValadocGtkdocToken* _tmp16_;
3969 _tmp16_ = self->priv->current;
3970 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp16_, "</row>");
3971 result = row;
3972 return result;
3973 }
3974 _tmp17_ = valadoc_gtkdoc_parser_next (self);
3975 _tmp18_ = _tmp17_;
3976 _valadoc_gtkdoc_token_unref0 (_tmp18_);
3977 result = row;
3978 return result;
3979 }
3980
3981 static ValaCollection*
valadoc_gtkdoc_parser_parse_docbook_tbody(ValadocGtkdocParser * self)3982 valadoc_gtkdoc_parser_parse_docbook_tbody (ValadocGtkdocParser* self)
3983 {
3984 ValadocGtkdocToken* _tmp1_;
3985 ValadocGtkdocToken* _tmp2_;
3986 ValaCollection* rows = NULL;
3987 GEqualFunc _tmp3_;
3988 ValaArrayList* _tmp4_;
3989 ValadocGtkdocToken* _tmp15_;
3990 ValadocGtkdocToken* _tmp16_;
3991 ValaCollection* result = NULL;
3992 g_return_val_if_fail (self != NULL, NULL);
3993 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "tbody")) {
3994 ValadocGtkdocToken* _tmp0_;
3995 _tmp0_ = self->priv->current;
3996 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<tbody>");
3997 result = NULL;
3998 return result;
3999 }
4000 _tmp1_ = valadoc_gtkdoc_parser_next (self);
4001 _tmp2_ = _tmp1_;
4002 _valadoc_gtkdoc_token_unref0 (_tmp2_);
4003 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
4004 _tmp3_ = g_direct_equal;
4005 _tmp4_ = vala_array_list_new (VALADOC_CONTENT_TYPE_TABLE_ROW, (GBoxedCopyFunc) g_object_ref, (GDestroyNotify) g_object_unref, _tmp3_);
4006 rows = (ValaCollection*) _tmp4_;
4007 while (TRUE) {
4008 gboolean _tmp5_ = FALSE;
4009 ValadocGtkdocToken* _tmp6_;
4010 ValadocGtkdocTokenType _tmp7_;
4011 ValadocContentTableRow* row = NULL;
4012 ValadocContentTableRow* _tmp10_;
4013 ValadocContentTableRow* _tmp11_;
4014 ValaCollection* _tmp12_;
4015 ValadocContentTableRow* _tmp13_;
4016 _tmp6_ = self->priv->current;
4017 _tmp7_ = _tmp6_->type;
4018 if (_tmp7_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
4019 ValadocGtkdocToken* _tmp8_;
4020 const gchar* _tmp9_;
4021 _tmp8_ = self->priv->current;
4022 _tmp9_ = _tmp8_->content;
4023 _tmp5_ = g_strcmp0 (_tmp9_, "row") == 0;
4024 } else {
4025 _tmp5_ = FALSE;
4026 }
4027 if (!_tmp5_) {
4028 break;
4029 }
4030 _tmp10_ = valadoc_gtkdoc_parser_parse_docbook_row (self, VALADOC_CONTENT_RUN_STYLE_NONE);
4031 row = _tmp10_;
4032 _tmp11_ = row;
4033 if (_tmp11_ == NULL) {
4034 _g_object_unref0 (row);
4035 break;
4036 }
4037 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
4038 _tmp12_ = rows;
4039 _tmp13_ = row;
4040 vala_collection_add (_tmp12_, _tmp13_);
4041 _g_object_unref0 (row);
4042 }
4043 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "tbody")) {
4044 ValadocGtkdocToken* _tmp14_;
4045 _tmp14_ = self->priv->current;
4046 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp14_, "</tbody>");
4047 result = rows;
4048 return result;
4049 }
4050 _tmp15_ = valadoc_gtkdoc_parser_next (self);
4051 _tmp16_ = _tmp15_;
4052 _valadoc_gtkdoc_token_unref0 (_tmp16_);
4053 result = rows;
4054 return result;
4055 }
4056
4057 static ValadocContentTable*
valadoc_gtkdoc_parser_parse_docbook_tgroup(ValadocGtkdocParser * self)4058 valadoc_gtkdoc_parser_parse_docbook_tgroup (ValadocGtkdocParser* self)
4059 {
4060 ValadocGtkdocToken* _tmp1_;
4061 ValadocGtkdocToken* _tmp2_;
4062 ValadocContentTable* table = NULL;
4063 ValadocContentContentFactory* _tmp3_;
4064 ValadocContentTable* _tmp4_;
4065 gboolean _tmp5_ = FALSE;
4066 ValadocGtkdocToken* _tmp6_;
4067 ValadocGtkdocTokenType _tmp7_;
4068 gboolean _tmp16_ = FALSE;
4069 ValadocGtkdocToken* _tmp17_;
4070 ValadocGtkdocTokenType _tmp18_;
4071 ValadocGtkdocToken* _tmp28_;
4072 ValadocGtkdocToken* _tmp29_;
4073 ValadocContentTable* result = NULL;
4074 g_return_val_if_fail (self != NULL, NULL);
4075 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "tgroup")) {
4076 ValadocGtkdocToken* _tmp0_;
4077 _tmp0_ = self->priv->current;
4078 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<tgroup>");
4079 result = NULL;
4080 return result;
4081 }
4082 _tmp1_ = valadoc_gtkdoc_parser_next (self);
4083 _tmp2_ = _tmp1_;
4084 _valadoc_gtkdoc_token_unref0 (_tmp2_);
4085 _tmp3_ = self->priv->factory;
4086 _tmp4_ = valadoc_content_content_factory_create_table (_tmp3_);
4087 table = _tmp4_;
4088 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
4089 _tmp6_ = self->priv->current;
4090 _tmp7_ = _tmp6_->type;
4091 if (_tmp7_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
4092 ValadocGtkdocToken* _tmp8_;
4093 const gchar* _tmp9_;
4094 _tmp8_ = self->priv->current;
4095 _tmp9_ = _tmp8_->content;
4096 _tmp5_ = g_strcmp0 (_tmp9_, "thead") == 0;
4097 } else {
4098 _tmp5_ = FALSE;
4099 }
4100 if (_tmp5_) {
4101 ValadocContentTableRow* row = NULL;
4102 ValadocContentTableRow* _tmp10_;
4103 ValadocContentTableRow* _tmp11_;
4104 _tmp10_ = valadoc_gtkdoc_parser_parse_docbook_thead (self);
4105 row = _tmp10_;
4106 _tmp11_ = row;
4107 if (_tmp11_ != NULL) {
4108 ValadocContentTable* _tmp12_;
4109 ValaList* _tmp13_;
4110 ValaList* _tmp14_;
4111 ValadocContentTableRow* _tmp15_;
4112 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
4113 _tmp12_ = table;
4114 _tmp13_ = valadoc_content_table_get_rows (_tmp12_);
4115 _tmp14_ = _tmp13_;
4116 _tmp15_ = row;
4117 vala_collection_add ((ValaCollection*) _tmp14_, _tmp15_);
4118 }
4119 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
4120 _g_object_unref0 (row);
4121 }
4122 _tmp17_ = self->priv->current;
4123 _tmp18_ = _tmp17_->type;
4124 if (_tmp18_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
4125 ValadocGtkdocToken* _tmp19_;
4126 const gchar* _tmp20_;
4127 _tmp19_ = self->priv->current;
4128 _tmp20_ = _tmp19_->content;
4129 _tmp16_ = g_strcmp0 (_tmp20_, "tbody") == 0;
4130 } else {
4131 _tmp16_ = FALSE;
4132 }
4133 if (_tmp16_) {
4134 ValaCollection* rows = NULL;
4135 ValaCollection* _tmp21_;
4136 ValaCollection* _tmp22_;
4137 _tmp21_ = valadoc_gtkdoc_parser_parse_docbook_tbody (self);
4138 rows = _tmp21_;
4139 _tmp22_ = rows;
4140 if (_tmp22_ != NULL) {
4141 ValadocContentTable* _tmp23_;
4142 ValaList* _tmp24_;
4143 ValaList* _tmp25_;
4144 ValaCollection* _tmp26_;
4145 _tmp23_ = table;
4146 _tmp24_ = valadoc_content_table_get_rows (_tmp23_);
4147 _tmp25_ = _tmp24_;
4148 _tmp26_ = rows;
4149 vala_collection_add_all ((ValaCollection*) _tmp25_, _tmp26_);
4150 }
4151 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
4152 _vala_iterable_unref0 (rows);
4153 }
4154 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "tgroup")) {
4155 ValadocGtkdocToken* _tmp27_;
4156 _tmp27_ = self->priv->current;
4157 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp27_, "</tgroup>");
4158 result = table;
4159 return result;
4160 }
4161 _tmp28_ = valadoc_gtkdoc_parser_next (self);
4162 _tmp29_ = _tmp28_;
4163 _valadoc_gtkdoc_token_unref0 (_tmp29_);
4164 result = table;
4165 return result;
4166 }
4167
4168 static ValadocContentTable*
valadoc_gtkdoc_parser_parse_docbook_informaltable(ValadocGtkdocParser * self)4169 valadoc_gtkdoc_parser_parse_docbook_informaltable (ValadocGtkdocParser* self)
4170 {
4171 ValadocGtkdocToken* _tmp1_;
4172 ValadocGtkdocToken* _tmp2_;
4173 ValadocContentTable* table = NULL;
4174 ValadocContentTable* _tmp3_;
4175 ValadocGtkdocToken* _tmp5_;
4176 ValadocGtkdocToken* _tmp6_;
4177 ValadocContentTable* result = NULL;
4178 g_return_val_if_fail (self != NULL, NULL);
4179 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "informaltable")) {
4180 ValadocGtkdocToken* _tmp0_;
4181 _tmp0_ = self->priv->current;
4182 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<informaltable>");
4183 result = NULL;
4184 return result;
4185 }
4186 _tmp1_ = valadoc_gtkdoc_parser_next (self);
4187 _tmp2_ = _tmp1_;
4188 _valadoc_gtkdoc_token_unref0 (_tmp2_);
4189 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
4190 _tmp3_ = valadoc_gtkdoc_parser_parse_docbook_tgroup (self);
4191 table = _tmp3_;
4192 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
4193 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "informaltable")) {
4194 ValadocGtkdocToken* _tmp4_;
4195 _tmp4_ = self->priv->current;
4196 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp4_, "</informaltable>");
4197 result = table;
4198 return result;
4199 }
4200 _tmp5_ = valadoc_gtkdoc_parser_next (self);
4201 _tmp6_ = _tmp5_;
4202 _valadoc_gtkdoc_token_unref0 (_tmp6_);
4203 result = table;
4204 return result;
4205 }
4206
4207 static ValaCollection*
valadoc_gtkdoc_parser_parse_docbook_section(ValadocGtkdocParser * self)4208 valadoc_gtkdoc_parser_parse_docbook_section (ValadocGtkdocParser* self)
4209 {
4210 gchar* id = NULL;
4211 ValadocGtkdocToken* _tmp1_;
4212 ValaHashMap* _tmp2_;
4213 gpointer _tmp3_;
4214 const gchar* _tmp4_;
4215 ValadocGtkdocToken* _tmp8_;
4216 ValadocGtkdocToken* _tmp9_;
4217 ValaCollection* content = NULL;
4218 ValaCollection* _tmp10_;
4219 ValadocGtkdocToken* _tmp12_;
4220 ValadocGtkdocToken* _tmp13_;
4221 ValaCollection* result = NULL;
4222 g_return_val_if_fail (self != NULL, NULL);
4223 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "section")) {
4224 ValadocGtkdocToken* _tmp0_;
4225 _tmp0_ = self->priv->current;
4226 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<section>");
4227 result = NULL;
4228 return result;
4229 }
4230 _tmp1_ = self->priv->current;
4231 _tmp2_ = _tmp1_->attributes;
4232 _tmp3_ = vala_map_get ((ValaMap*) _tmp2_, "id");
4233 id = (gchar*) _tmp3_;
4234 _tmp4_ = id;
4235 if (_tmp4_ != NULL) {
4236 ValadocImporterInternalIdRegistrar* _tmp5_;
4237 const gchar* _tmp6_;
4238 ValadocApiNode* _tmp7_;
4239 _tmp5_ = self->priv->id_registrar;
4240 _tmp6_ = id;
4241 _tmp7_ = self->priv->element;
4242 valadoc_importer_internal_id_registrar_register_symbol (_tmp5_, _tmp6_, _tmp7_);
4243 }
4244 _tmp8_ = valadoc_gtkdoc_parser_next (self);
4245 _tmp9_ = _tmp8_;
4246 _valadoc_gtkdoc_token_unref0 (_tmp9_);
4247 _tmp10_ = valadoc_gtkdoc_parser_parse_mixed_content (self);
4248 content = _tmp10_;
4249 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "section")) {
4250 ValadocGtkdocToken* _tmp11_;
4251 _tmp11_ = self->priv->current;
4252 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp11_, "</section>");
4253 result = content;
4254 _g_free0 (id);
4255 return result;
4256 }
4257 _tmp12_ = valadoc_gtkdoc_parser_next (self);
4258 _tmp13_ = _tmp12_;
4259 _valadoc_gtkdoc_token_unref0 (_tmp13_);
4260 result = content;
4261 _g_free0 (id);
4262 return result;
4263 }
4264
4265 static ValadocContentListItem*
valadoc_gtkdoc_parser_parse_docbook_member(ValadocGtkdocParser * self)4266 valadoc_gtkdoc_parser_parse_docbook_member (ValadocGtkdocParser* self)
4267 {
4268 ValadocGtkdocToken* _tmp1_;
4269 ValadocGtkdocToken* _tmp2_;
4270 ValadocContentListItem* item = NULL;
4271 ValadocContentContentFactory* _tmp3_;
4272 ValadocContentListItem* _tmp4_;
4273 ValadocContentParagraph* para = NULL;
4274 ValadocContentContentFactory* _tmp5_;
4275 ValadocContentParagraph* _tmp6_;
4276 ValadocContentListItem* _tmp7_;
4277 ValaList* _tmp8_;
4278 ValaList* _tmp9_;
4279 ValadocContentParagraph* _tmp10_;
4280 ValadocContentParagraph* _tmp11_;
4281 ValaList* _tmp12_;
4282 ValaList* _tmp13_;
4283 ValadocContentRun* _tmp14_;
4284 ValadocContentRun* _tmp15_;
4285 ValadocGtkdocToken* _tmp17_;
4286 ValadocGtkdocToken* _tmp18_;
4287 ValadocContentListItem* result = NULL;
4288 g_return_val_if_fail (self != NULL, NULL);
4289 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "member")) {
4290 ValadocGtkdocToken* _tmp0_;
4291 _tmp0_ = self->priv->current;
4292 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<member>");
4293 result = NULL;
4294 return result;
4295 }
4296 _tmp1_ = valadoc_gtkdoc_parser_next (self);
4297 _tmp2_ = _tmp1_;
4298 _valadoc_gtkdoc_token_unref0 (_tmp2_);
4299 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
4300 _tmp3_ = self->priv->factory;
4301 _tmp4_ = valadoc_content_content_factory_create_list_item (_tmp3_);
4302 item = _tmp4_;
4303 _tmp5_ = self->priv->factory;
4304 _tmp6_ = valadoc_content_content_factory_create_paragraph (_tmp5_);
4305 para = _tmp6_;
4306 _tmp7_ = item;
4307 _tmp8_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) _tmp7_);
4308 _tmp9_ = _tmp8_;
4309 _tmp10_ = para;
4310 vala_collection_add ((ValaCollection*) _tmp9_, (ValadocContentBlock*) _tmp10_);
4311 _tmp11_ = para;
4312 _tmp12_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp11_);
4313 _tmp13_ = _tmp12_;
4314 _tmp14_ = valadoc_gtkdoc_parser_parse_inline_content (self);
4315 _tmp15_ = _tmp14_;
4316 vala_collection_add ((ValaCollection*) _tmp13_, (ValadocContentInline*) _tmp15_);
4317 _g_object_unref0 (_tmp15_);
4318 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
4319 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "member")) {
4320 ValadocGtkdocToken* _tmp16_;
4321 _tmp16_ = self->priv->current;
4322 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp16_, "</member>");
4323 result = item;
4324 _g_object_unref0 (para);
4325 return result;
4326 }
4327 _tmp17_ = valadoc_gtkdoc_parser_next (self);
4328 _tmp18_ = _tmp17_;
4329 _valadoc_gtkdoc_token_unref0 (_tmp18_);
4330 result = item;
4331 _g_object_unref0 (para);
4332 return result;
4333 }
4334
4335 static ValadocContentList*
valadoc_gtkdoc_parser_parse_docbook_simplelist(ValadocGtkdocParser * self)4336 valadoc_gtkdoc_parser_parse_docbook_simplelist (ValadocGtkdocParser* self)
4337 {
4338 ValadocGtkdocToken* _tmp1_;
4339 ValadocGtkdocToken* _tmp2_;
4340 ValadocContentList* list = NULL;
4341 ValadocContentContentFactory* _tmp3_;
4342 ValadocContentList* _tmp4_;
4343 ValadocGtkdocToken* _tmp17_;
4344 ValadocGtkdocToken* _tmp18_;
4345 ValadocContentList* result = NULL;
4346 g_return_val_if_fail (self != NULL, NULL);
4347 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "simplelist")) {
4348 ValadocGtkdocToken* _tmp0_;
4349 _tmp0_ = self->priv->current;
4350 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<simplelist>");
4351 result = NULL;
4352 return result;
4353 }
4354 _tmp1_ = valadoc_gtkdoc_parser_next (self);
4355 _tmp2_ = _tmp1_;
4356 _valadoc_gtkdoc_token_unref0 (_tmp2_);
4357 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
4358 _tmp3_ = self->priv->factory;
4359 _tmp4_ = valadoc_content_content_factory_create_list (_tmp3_);
4360 list = _tmp4_;
4361 while (TRUE) {
4362 gboolean _tmp5_ = FALSE;
4363 ValadocGtkdocToken* _tmp6_;
4364 ValadocGtkdocTokenType _tmp7_;
4365 ValadocContentListItem* item = NULL;
4366 ValadocContentListItem* _tmp10_;
4367 ValadocContentListItem* _tmp11_;
4368 ValadocContentList* _tmp12_;
4369 ValaList* _tmp13_;
4370 ValaList* _tmp14_;
4371 ValadocContentListItem* _tmp15_;
4372 _tmp6_ = self->priv->current;
4373 _tmp7_ = _tmp6_->type;
4374 if (_tmp7_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
4375 ValadocGtkdocToken* _tmp8_;
4376 const gchar* _tmp9_;
4377 _tmp8_ = self->priv->current;
4378 _tmp9_ = _tmp8_->content;
4379 _tmp5_ = g_strcmp0 (_tmp9_, "member") == 0;
4380 } else {
4381 _tmp5_ = FALSE;
4382 }
4383 if (!_tmp5_) {
4384 break;
4385 }
4386 _tmp10_ = valadoc_gtkdoc_parser_parse_docbook_member (self);
4387 item = _tmp10_;
4388 _tmp11_ = item;
4389 if (_tmp11_ == NULL) {
4390 _g_object_unref0 (item);
4391 break;
4392 }
4393 _tmp12_ = list;
4394 _tmp13_ = valadoc_content_list_get_items (_tmp12_);
4395 _tmp14_ = _tmp13_;
4396 _tmp15_ = item;
4397 vala_collection_add ((ValaCollection*) _tmp14_, _tmp15_);
4398 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
4399 _g_object_unref0 (item);
4400 }
4401 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "simplelist")) {
4402 ValadocGtkdocToken* _tmp16_;
4403 _tmp16_ = self->priv->current;
4404 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp16_, "</simplelist>");
4405 result = list;
4406 return result;
4407 }
4408 _tmp17_ = valadoc_gtkdoc_parser_next (self);
4409 _tmp18_ = _tmp17_;
4410 _valadoc_gtkdoc_token_unref0 (_tmp18_);
4411 result = list;
4412 return result;
4413 }
4414
4415 static ValadocContentParagraph*
valadoc_gtkdoc_parser_parse_docbook_term(ValadocGtkdocParser * self)4416 valadoc_gtkdoc_parser_parse_docbook_term (ValadocGtkdocParser* self)
4417 {
4418 ValadocGtkdocToken* _tmp1_;
4419 ValadocGtkdocToken* _tmp2_;
4420 ValadocContentParagraph* p = NULL;
4421 ValadocContentContentFactory* _tmp3_;
4422 ValadocContentParagraph* _tmp4_;
4423 ValadocContentRun* run = NULL;
4424 ValadocContentRun* _tmp5_;
4425 ValadocContentRun* _tmp6_;
4426 ValadocContentParagraph* _tmp7_;
4427 ValaList* _tmp8_;
4428 ValaList* _tmp9_;
4429 ValadocContentRun* _tmp10_;
4430 ValadocGtkdocToken* _tmp12_;
4431 ValadocGtkdocToken* _tmp13_;
4432 ValadocContentParagraph* result = NULL;
4433 g_return_val_if_fail (self != NULL, NULL);
4434 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "term")) {
4435 ValadocGtkdocToken* _tmp0_;
4436 _tmp0_ = self->priv->current;
4437 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<term>");
4438 result = NULL;
4439 return result;
4440 }
4441 _tmp1_ = valadoc_gtkdoc_parser_next (self);
4442 _tmp2_ = _tmp1_;
4443 _valadoc_gtkdoc_token_unref0 (_tmp2_);
4444 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
4445 _tmp3_ = self->priv->factory;
4446 _tmp4_ = valadoc_content_content_factory_create_paragraph (_tmp3_);
4447 p = _tmp4_;
4448 _tmp5_ = valadoc_gtkdoc_parser_parse_inline_content (self);
4449 run = _tmp5_;
4450 _tmp6_ = run;
4451 valadoc_content_run_set_style (_tmp6_, VALADOC_CONTENT_RUN_STYLE_ITALIC);
4452 _tmp7_ = p;
4453 _tmp8_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp7_);
4454 _tmp9_ = _tmp8_;
4455 _tmp10_ = run;
4456 vala_collection_add ((ValaCollection*) _tmp9_, (ValadocContentInline*) _tmp10_);
4457 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "term")) {
4458 ValadocGtkdocToken* _tmp11_;
4459 _tmp11_ = self->priv->current;
4460 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp11_, "</term>");
4461 result = p;
4462 _g_object_unref0 (run);
4463 return result;
4464 }
4465 _tmp12_ = valadoc_gtkdoc_parser_next (self);
4466 _tmp13_ = _tmp12_;
4467 _valadoc_gtkdoc_token_unref0 (_tmp13_);
4468 result = p;
4469 _g_object_unref0 (run);
4470 return result;
4471 }
4472
4473 static ValadocContentListItem*
valadoc_gtkdoc_parser_parse_docbook_varlistentry(ValadocGtkdocParser * self)4474 valadoc_gtkdoc_parser_parse_docbook_varlistentry (ValadocGtkdocParser* self)
4475 {
4476 ValadocGtkdocToken* _tmp1_;
4477 ValadocGtkdocToken* _tmp2_;
4478 gboolean _tmp3_ = FALSE;
4479 ValadocGtkdocToken* _tmp4_;
4480 ValadocGtkdocTokenType _tmp5_;
4481 ValadocContentParagraph* term = NULL;
4482 ValadocContentParagraph* _tmp8_;
4483 ValadocContentParagraph* _tmp9_;
4484 ValadocContentListItem* desc = NULL;
4485 ValadocContentListItem* _tmp10_;
4486 ValadocContentListItem* _tmp11_;
4487 ValadocContentListItem* listitem = NULL;
4488 ValadocContentContentFactory* _tmp12_;
4489 ValadocContentListItem* _tmp13_;
4490 ValadocContentList* list = NULL;
4491 ValadocContentContentFactory* _tmp14_;
4492 ValadocContentList* _tmp15_;
4493 ValadocContentListItem* _tmp16_;
4494 ValaList* _tmp17_;
4495 ValaList* _tmp18_;
4496 ValadocContentParagraph* _tmp19_;
4497 ValadocContentListItem* _tmp20_;
4498 ValaList* _tmp21_;
4499 ValaList* _tmp22_;
4500 ValadocContentList* _tmp23_;
4501 ValadocContentList* _tmp24_;
4502 ValaList* _tmp25_;
4503 ValaList* _tmp26_;
4504 ValadocContentListItem* _tmp27_;
4505 ValadocGtkdocToken* _tmp29_;
4506 ValadocGtkdocToken* _tmp30_;
4507 ValadocContentListItem* result = NULL;
4508 g_return_val_if_fail (self != NULL, NULL);
4509 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "varlistentry")) {
4510 ValadocGtkdocToken* _tmp0_;
4511 _tmp0_ = self->priv->current;
4512 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<varlistentry>");
4513 result = NULL;
4514 return result;
4515 }
4516 _tmp1_ = valadoc_gtkdoc_parser_next (self);
4517 _tmp2_ = _tmp1_;
4518 _valadoc_gtkdoc_token_unref0 (_tmp2_);
4519 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
4520 _tmp4_ = self->priv->current;
4521 _tmp5_ = _tmp4_->type;
4522 if (_tmp5_ != VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
4523 _tmp3_ = TRUE;
4524 } else {
4525 ValadocGtkdocToken* _tmp6_;
4526 const gchar* _tmp7_;
4527 _tmp6_ = self->priv->current;
4528 _tmp7_ = _tmp6_->content;
4529 _tmp3_ = g_strcmp0 (_tmp7_, "term") != 0;
4530 }
4531 if (_tmp3_) {
4532 result = NULL;
4533 return result;
4534 }
4535 _tmp8_ = valadoc_gtkdoc_parser_parse_docbook_term (self);
4536 term = _tmp8_;
4537 _tmp9_ = term;
4538 if (_tmp9_ == NULL) {
4539 result = NULL;
4540 _g_object_unref0 (term);
4541 return result;
4542 }
4543 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
4544 _tmp10_ = valadoc_gtkdoc_parser_parse_docbook_listitem (self);
4545 desc = _tmp10_;
4546 _tmp11_ = desc;
4547 if (_tmp11_ == NULL) {
4548 result = NULL;
4549 _g_object_unref0 (desc);
4550 _g_object_unref0 (term);
4551 return result;
4552 }
4553 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
4554 _tmp12_ = self->priv->factory;
4555 _tmp13_ = valadoc_content_content_factory_create_list_item (_tmp12_);
4556 listitem = _tmp13_;
4557 _tmp14_ = self->priv->factory;
4558 _tmp15_ = valadoc_content_content_factory_create_list (_tmp14_);
4559 list = _tmp15_;
4560 _tmp16_ = listitem;
4561 _tmp17_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) _tmp16_);
4562 _tmp18_ = _tmp17_;
4563 _tmp19_ = term;
4564 vala_collection_add ((ValaCollection*) _tmp18_, (ValadocContentBlock*) _tmp19_);
4565 _tmp20_ = listitem;
4566 _tmp21_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) _tmp20_);
4567 _tmp22_ = _tmp21_;
4568 _tmp23_ = list;
4569 vala_collection_add ((ValaCollection*) _tmp22_, (ValadocContentBlock*) _tmp23_);
4570 _tmp24_ = list;
4571 _tmp25_ = valadoc_content_list_get_items (_tmp24_);
4572 _tmp26_ = _tmp25_;
4573 _tmp27_ = desc;
4574 vala_collection_add ((ValaCollection*) _tmp26_, _tmp27_);
4575 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "varlistentry")) {
4576 ValadocGtkdocToken* _tmp28_;
4577 _tmp28_ = self->priv->current;
4578 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp28_, "</varlistentry>");
4579 result = listitem;
4580 _g_object_unref0 (list);
4581 _g_object_unref0 (desc);
4582 _g_object_unref0 (term);
4583 return result;
4584 }
4585 _tmp29_ = valadoc_gtkdoc_parser_next (self);
4586 _tmp30_ = _tmp29_;
4587 _valadoc_gtkdoc_token_unref0 (_tmp30_);
4588 result = listitem;
4589 _g_object_unref0 (list);
4590 _g_object_unref0 (desc);
4591 _g_object_unref0 (term);
4592 return result;
4593 }
4594
4595 static ValaCollection*
valadoc_gtkdoc_parser_parse_docbook_variablelist(ValadocGtkdocParser * self)4596 valadoc_gtkdoc_parser_parse_docbook_variablelist (ValadocGtkdocParser* self)
4597 {
4598 ValadocGtkdocToken* _tmp1_;
4599 ValadocGtkdocToken* _tmp2_;
4600 ValaCollection* content = NULL;
4601 GEqualFunc _tmp3_;
4602 ValaArrayList* _tmp4_;
4603 gboolean _tmp5_ = FALSE;
4604 ValadocGtkdocToken* _tmp6_;
4605 ValadocGtkdocTokenType _tmp7_;
4606 ValadocContentList* list = NULL;
4607 ValadocContentContentFactory* _tmp13_;
4608 ValadocContentList* _tmp14_;
4609 ValaCollection* _tmp15_;
4610 ValadocContentList* _tmp16_;
4611 ValadocGtkdocToken* _tmp29_;
4612 ValadocGtkdocToken* _tmp30_;
4613 ValaCollection* result = NULL;
4614 g_return_val_if_fail (self != NULL, NULL);
4615 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "variablelist")) {
4616 ValadocGtkdocToken* _tmp0_;
4617 _tmp0_ = self->priv->current;
4618 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<variablelist>");
4619 result = NULL;
4620 return result;
4621 }
4622 _tmp1_ = valadoc_gtkdoc_parser_next (self);
4623 _tmp2_ = _tmp1_;
4624 _valadoc_gtkdoc_token_unref0 (_tmp2_);
4625 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
4626 _tmp3_ = g_direct_equal;
4627 _tmp4_ = vala_array_list_new (VALADOC_CONTENT_TYPE_BLOCK, (GBoxedCopyFunc) g_object_ref, (GDestroyNotify) g_object_unref, _tmp3_);
4628 content = (ValaCollection*) _tmp4_;
4629 _tmp6_ = self->priv->current;
4630 _tmp7_ = _tmp6_->type;
4631 if (_tmp7_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
4632 ValadocGtkdocToken* _tmp8_;
4633 const gchar* _tmp9_;
4634 _tmp8_ = self->priv->current;
4635 _tmp9_ = _tmp8_->content;
4636 _tmp5_ = g_strcmp0 (_tmp9_, "title") == 0;
4637 } else {
4638 _tmp5_ = FALSE;
4639 }
4640 if (_tmp5_) {
4641 ValaCollection* _tmp10_;
4642 ValadocContentParagraph* _tmp11_;
4643 ValadocContentParagraph* _tmp12_;
4644 _tmp10_ = content;
4645 _tmp11_ = valadoc_gtkdoc_parser_parse_docbook_title (self);
4646 _tmp12_ = _tmp11_;
4647 valadoc_gtkdoc_parser_append_block_content_not_null (self, _tmp10_, (ValadocContentBlock*) _tmp12_);
4648 _g_object_unref0 (_tmp12_);
4649 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
4650 }
4651 _tmp13_ = self->priv->factory;
4652 _tmp14_ = valadoc_content_content_factory_create_list (_tmp13_);
4653 list = _tmp14_;
4654 _tmp15_ = content;
4655 _tmp16_ = list;
4656 vala_collection_add (_tmp15_, (ValadocContentBlock*) _tmp16_);
4657 while (TRUE) {
4658 gboolean _tmp17_ = FALSE;
4659 ValadocGtkdocToken* _tmp18_;
4660 ValadocGtkdocTokenType _tmp19_;
4661 ValadocContentListItem* item = NULL;
4662 ValadocContentListItem* _tmp22_;
4663 ValadocContentListItem* _tmp23_;
4664 ValadocContentList* _tmp24_;
4665 ValaList* _tmp25_;
4666 ValaList* _tmp26_;
4667 ValadocContentListItem* _tmp27_;
4668 _tmp18_ = self->priv->current;
4669 _tmp19_ = _tmp18_->type;
4670 if (_tmp19_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
4671 ValadocGtkdocToken* _tmp20_;
4672 const gchar* _tmp21_;
4673 _tmp20_ = self->priv->current;
4674 _tmp21_ = _tmp20_->content;
4675 _tmp17_ = g_strcmp0 (_tmp21_, "varlistentry") == 0;
4676 } else {
4677 _tmp17_ = FALSE;
4678 }
4679 if (!_tmp17_) {
4680 break;
4681 }
4682 _tmp22_ = valadoc_gtkdoc_parser_parse_docbook_varlistentry (self);
4683 item = _tmp22_;
4684 _tmp23_ = item;
4685 if (_tmp23_ == NULL) {
4686 _g_object_unref0 (item);
4687 break;
4688 }
4689 _tmp24_ = list;
4690 _tmp25_ = valadoc_content_list_get_items (_tmp24_);
4691 _tmp26_ = _tmp25_;
4692 _tmp27_ = item;
4693 vala_collection_add ((ValaCollection*) _tmp26_, _tmp27_);
4694 valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE);
4695 _g_object_unref0 (item);
4696 }
4697 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "variablelist")) {
4698 ValadocGtkdocToken* _tmp28_;
4699 _tmp28_ = self->priv->current;
4700 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp28_, "</variablelist>");
4701 result = content;
4702 _g_object_unref0 (list);
4703 return result;
4704 }
4705 _tmp29_ = valadoc_gtkdoc_parser_next (self);
4706 _tmp30_ = _tmp29_;
4707 _valadoc_gtkdoc_token_unref0 (_tmp30_);
4708 result = content;
4709 _g_object_unref0 (list);
4710 return result;
4711 }
4712
4713 static ValaCollection*
valadoc_gtkdoc_parser_parse_block_content(ValadocGtkdocParser * self)4714 valadoc_gtkdoc_parser_parse_block_content (ValadocGtkdocParser* self)
4715 {
4716 ValaCollection* content = NULL;
4717 GEqualFunc _tmp0_;
4718 ValaArrayList* _tmp1_;
4719 ValaCollection* result = NULL;
4720 g_return_val_if_fail (self != NULL, NULL);
4721 _tmp0_ = g_direct_equal;
4722 _tmp1_ = vala_array_list_new (VALADOC_CONTENT_TYPE_BLOCK, (GBoxedCopyFunc) g_object_ref, (GDestroyNotify) g_object_unref, _tmp0_);
4723 content = (ValaCollection*) _tmp1_;
4724 while (TRUE) {
4725 ValadocGtkdocToken* _tmp2_;
4726 ValadocGtkdocTokenType _tmp3_;
4727 gboolean _tmp4_ = FALSE;
4728 ValadocGtkdocToken* _tmp5_;
4729 ValadocGtkdocTokenType _tmp6_;
4730 _tmp2_ = self->priv->current;
4731 _tmp3_ = _tmp2_->type;
4732 if (!(_tmp3_ != VALADOC_GTKDOC_TOKEN_TYPE_EOF)) {
4733 break;
4734 }
4735 valadoc_gtkdoc_parser_parse_docbook_spaces (self, FALSE);
4736 _tmp5_ = self->priv->current;
4737 _tmp6_ = _tmp5_->type;
4738 if (_tmp6_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
4739 ValadocGtkdocToken* _tmp7_;
4740 const gchar* _tmp8_;
4741 _tmp7_ = self->priv->current;
4742 _tmp8_ = _tmp7_->content;
4743 _tmp4_ = g_strcmp0 (_tmp8_, "itemizedlist") == 0;
4744 } else {
4745 _tmp4_ = FALSE;
4746 }
4747 if (_tmp4_) {
4748 ValaCollection* _tmp9_;
4749 ValaCollection* _tmp10_;
4750 ValaCollection* _tmp11_;
4751 _tmp9_ = content;
4752 _tmp10_ = valadoc_gtkdoc_parser_parse_docbook_itemizedlist (self, "itemizedlist", VALADOC_CONTENT_LIST_BULLET_UNORDERED);
4753 _tmp11_ = _tmp10_;
4754 valadoc_gtkdoc_parser_append_block_content_not_null_all (self, _tmp9_, _tmp11_);
4755 _vala_iterable_unref0 (_tmp11_);
4756 } else {
4757 gboolean _tmp12_ = FALSE;
4758 ValadocGtkdocToken* _tmp13_;
4759 ValadocGtkdocTokenType _tmp14_;
4760 _tmp13_ = self->priv->current;
4761 _tmp14_ = _tmp13_->type;
4762 if (_tmp14_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
4763 ValadocGtkdocToken* _tmp15_;
4764 const gchar* _tmp16_;
4765 _tmp15_ = self->priv->current;
4766 _tmp16_ = _tmp15_->content;
4767 _tmp12_ = g_strcmp0 (_tmp16_, "orderedlist") == 0;
4768 } else {
4769 _tmp12_ = FALSE;
4770 }
4771 if (_tmp12_) {
4772 ValaCollection* _tmp17_;
4773 ValaCollection* _tmp18_;
4774 ValaCollection* _tmp19_;
4775 _tmp17_ = content;
4776 _tmp18_ = valadoc_gtkdoc_parser_parse_docbook_orderedlist (self);
4777 _tmp19_ = _tmp18_;
4778 valadoc_gtkdoc_parser_append_block_content_not_null_all (self, _tmp17_, _tmp19_);
4779 _vala_iterable_unref0 (_tmp19_);
4780 } else {
4781 gboolean _tmp20_ = FALSE;
4782 ValadocGtkdocToken* _tmp21_;
4783 ValadocGtkdocTokenType _tmp22_;
4784 _tmp21_ = self->priv->current;
4785 _tmp22_ = _tmp21_->type;
4786 if (_tmp22_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
4787 ValadocGtkdocToken* _tmp23_;
4788 const gchar* _tmp24_;
4789 _tmp23_ = self->priv->current;
4790 _tmp24_ = _tmp23_->content;
4791 _tmp20_ = g_strcmp0 (_tmp24_, "variablelist") == 0;
4792 } else {
4793 _tmp20_ = FALSE;
4794 }
4795 if (_tmp20_) {
4796 ValaCollection* _tmp25_;
4797 ValaCollection* _tmp26_;
4798 ValaCollection* _tmp27_;
4799 _tmp25_ = content;
4800 _tmp26_ = valadoc_gtkdoc_parser_parse_docbook_variablelist (self);
4801 _tmp27_ = _tmp26_;
4802 valadoc_gtkdoc_parser_append_block_content_not_null_all (self, _tmp25_, _tmp27_);
4803 _vala_iterable_unref0 (_tmp27_);
4804 } else {
4805 gboolean _tmp28_ = FALSE;
4806 ValadocGtkdocToken* _tmp29_;
4807 ValadocGtkdocTokenType _tmp30_;
4808 _tmp29_ = self->priv->current;
4809 _tmp30_ = _tmp29_->type;
4810 if (_tmp30_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
4811 ValadocGtkdocToken* _tmp31_;
4812 const gchar* _tmp32_;
4813 _tmp31_ = self->priv->current;
4814 _tmp32_ = _tmp31_->content;
4815 _tmp28_ = g_strcmp0 (_tmp32_, "simplelist") == 0;
4816 } else {
4817 _tmp28_ = FALSE;
4818 }
4819 if (_tmp28_) {
4820 ValaCollection* _tmp33_;
4821 ValadocContentList* _tmp34_;
4822 ValadocContentList* _tmp35_;
4823 _tmp33_ = content;
4824 _tmp34_ = valadoc_gtkdoc_parser_parse_docbook_simplelist (self);
4825 _tmp35_ = _tmp34_;
4826 valadoc_gtkdoc_parser_append_block_content_not_null (self, _tmp33_, (ValadocContentBlock*) _tmp35_);
4827 _g_object_unref0 (_tmp35_);
4828 } else {
4829 gboolean _tmp36_ = FALSE;
4830 ValadocGtkdocToken* _tmp37_;
4831 ValadocGtkdocTokenType _tmp38_;
4832 _tmp37_ = self->priv->current;
4833 _tmp38_ = _tmp37_->type;
4834 if (_tmp38_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
4835 ValadocGtkdocToken* _tmp39_;
4836 const gchar* _tmp40_;
4837 _tmp39_ = self->priv->current;
4838 _tmp40_ = _tmp39_->content;
4839 _tmp36_ = g_strcmp0 (_tmp40_, "informaltable") == 0;
4840 } else {
4841 _tmp36_ = FALSE;
4842 }
4843 if (_tmp36_) {
4844 ValaCollection* _tmp41_;
4845 ValadocContentTable* _tmp42_;
4846 ValadocContentTable* _tmp43_;
4847 _tmp41_ = content;
4848 _tmp42_ = valadoc_gtkdoc_parser_parse_docbook_informaltable (self);
4849 _tmp43_ = _tmp42_;
4850 valadoc_gtkdoc_parser_append_block_content_not_null (self, _tmp41_, (ValadocContentBlock*) _tmp43_);
4851 _g_object_unref0 (_tmp43_);
4852 } else {
4853 gboolean _tmp44_ = FALSE;
4854 ValadocGtkdocToken* _tmp45_;
4855 ValadocGtkdocTokenType _tmp46_;
4856 _tmp45_ = self->priv->current;
4857 _tmp46_ = _tmp45_->type;
4858 if (_tmp46_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
4859 ValadocGtkdocToken* _tmp47_;
4860 const gchar* _tmp48_;
4861 _tmp47_ = self->priv->current;
4862 _tmp48_ = _tmp47_->content;
4863 _tmp44_ = g_strcmp0 (_tmp48_, "programlisting") == 0;
4864 } else {
4865 _tmp44_ = FALSE;
4866 }
4867 if (_tmp44_) {
4868 ValaCollection* _tmp49_;
4869 ValadocContentParagraph* _tmp50_;
4870 ValadocContentParagraph* _tmp51_;
4871 _tmp49_ = content;
4872 _tmp50_ = valadoc_gtkdoc_parser_parse_docbook_programlisting (self);
4873 _tmp51_ = _tmp50_;
4874 valadoc_gtkdoc_parser_append_block_content_not_null (self, _tmp49_, (ValadocContentBlock*) _tmp51_);
4875 _g_object_unref0 (_tmp51_);
4876 } else {
4877 gboolean _tmp52_ = FALSE;
4878 ValadocGtkdocToken* _tmp53_;
4879 ValadocGtkdocTokenType _tmp54_;
4880 _tmp53_ = self->priv->current;
4881 _tmp54_ = _tmp53_->type;
4882 if (_tmp54_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
4883 ValadocGtkdocToken* _tmp55_;
4884 const gchar* _tmp56_;
4885 _tmp55_ = self->priv->current;
4886 _tmp56_ = _tmp55_->content;
4887 _tmp52_ = g_strcmp0 (_tmp56_, "para") == 0;
4888 } else {
4889 _tmp52_ = FALSE;
4890 }
4891 if (_tmp52_) {
4892 ValaCollection* _tmp57_;
4893 ValaCollection* _tmp58_;
4894 ValaCollection* _tmp59_;
4895 _tmp57_ = content;
4896 _tmp58_ = valadoc_gtkdoc_parser_parse_docbook_para (self, "para");
4897 _tmp59_ = _tmp58_;
4898 valadoc_gtkdoc_parser_append_block_content_not_null_all (self, _tmp57_, _tmp59_);
4899 _vala_iterable_unref0 (_tmp59_);
4900 } else {
4901 gboolean _tmp60_ = FALSE;
4902 ValadocGtkdocToken* _tmp61_;
4903 ValadocGtkdocTokenType _tmp62_;
4904 _tmp61_ = self->priv->current;
4905 _tmp62_ = _tmp61_->type;
4906 if (_tmp62_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
4907 ValadocGtkdocToken* _tmp63_;
4908 const gchar* _tmp64_;
4909 _tmp63_ = self->priv->current;
4910 _tmp64_ = _tmp63_->content;
4911 _tmp60_ = g_strcmp0 (_tmp64_, "simpara") == 0;
4912 } else {
4913 _tmp60_ = FALSE;
4914 }
4915 if (_tmp60_) {
4916 ValaCollection* _tmp65_;
4917 ValaCollection* _tmp66_;
4918 ValaCollection* _tmp67_;
4919 _tmp65_ = content;
4920 _tmp66_ = valadoc_gtkdoc_parser_parse_docbook_simpara (self);
4921 _tmp67_ = _tmp66_;
4922 valadoc_gtkdoc_parser_append_block_content_not_null_all (self, _tmp65_, _tmp67_);
4923 _vala_iterable_unref0 (_tmp67_);
4924 } else {
4925 gboolean _tmp68_ = FALSE;
4926 ValadocGtkdocToken* _tmp69_;
4927 ValadocGtkdocTokenType _tmp70_;
4928 _tmp69_ = self->priv->current;
4929 _tmp70_ = _tmp69_->type;
4930 if (_tmp70_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
4931 ValadocGtkdocToken* _tmp71_;
4932 const gchar* _tmp72_;
4933 _tmp71_ = self->priv->current;
4934 _tmp72_ = _tmp71_->content;
4935 _tmp68_ = g_strcmp0 (_tmp72_, "informalexample") == 0;
4936 } else {
4937 _tmp68_ = FALSE;
4938 }
4939 if (_tmp68_) {
4940 ValaCollection* _tmp73_;
4941 ValaCollection* _tmp74_;
4942 ValaCollection* _tmp75_;
4943 _tmp73_ = content;
4944 _tmp74_ = valadoc_gtkdoc_parser_parse_docbook_informalexample (self);
4945 _tmp75_ = _tmp74_;
4946 valadoc_gtkdoc_parser_append_block_content_not_null_all (self, _tmp73_, _tmp75_);
4947 _vala_iterable_unref0 (_tmp75_);
4948 } else {
4949 gboolean _tmp76_ = FALSE;
4950 ValadocGtkdocToken* _tmp77_;
4951 ValadocGtkdocTokenType _tmp78_;
4952 _tmp77_ = self->priv->current;
4953 _tmp78_ = _tmp77_->type;
4954 if (_tmp78_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
4955 ValadocGtkdocToken* _tmp79_;
4956 const gchar* _tmp80_;
4957 _tmp79_ = self->priv->current;
4958 _tmp80_ = _tmp79_->content;
4959 _tmp76_ = g_strcmp0 (_tmp80_, "example") == 0;
4960 } else {
4961 _tmp76_ = FALSE;
4962 }
4963 if (_tmp76_) {
4964 ValaCollection* _tmp81_;
4965 ValaCollection* _tmp82_;
4966 ValaCollection* _tmp83_;
4967 _tmp81_ = content;
4968 _tmp82_ = valadoc_gtkdoc_parser_parse_docbook_example (self, "example");
4969 _tmp83_ = _tmp82_;
4970 valadoc_gtkdoc_parser_append_block_content_not_null_all (self, _tmp81_, _tmp83_);
4971 _vala_iterable_unref0 (_tmp83_);
4972 } else {
4973 gboolean _tmp84_ = FALSE;
4974 ValadocGtkdocToken* _tmp85_;
4975 ValadocGtkdocTokenType _tmp86_;
4976 _tmp85_ = self->priv->current;
4977 _tmp86_ = _tmp85_->type;
4978 if (_tmp86_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
4979 ValadocGtkdocToken* _tmp87_;
4980 const gchar* _tmp88_;
4981 _tmp87_ = self->priv->current;
4982 _tmp88_ = _tmp87_->content;
4983 _tmp84_ = g_strcmp0 (_tmp88_, "warning") == 0;
4984 } else {
4985 _tmp84_ = FALSE;
4986 }
4987 if (_tmp84_) {
4988 ValaCollection* _tmp89_;
4989 ValadocContentWarning* _tmp90_;
4990 ValadocContentWarning* _tmp91_;
4991 _tmp89_ = content;
4992 _tmp90_ = valadoc_gtkdoc_parser_parse_docbook_warning (self);
4993 _tmp91_ = _tmp90_;
4994 valadoc_gtkdoc_parser_append_block_content_not_null (self, _tmp89_, (ValadocContentBlock*) _tmp91_);
4995 _g_object_unref0 (_tmp91_);
4996 } else {
4997 gboolean _tmp92_ = FALSE;
4998 ValadocGtkdocToken* _tmp93_;
4999 ValadocGtkdocTokenType _tmp94_;
5000 _tmp93_ = self->priv->current;
5001 _tmp94_ = _tmp93_->type;
5002 if (_tmp94_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5003 ValadocGtkdocToken* _tmp95_;
5004 const gchar* _tmp96_;
5005 _tmp95_ = self->priv->current;
5006 _tmp96_ = _tmp95_->content;
5007 _tmp92_ = g_strcmp0 (_tmp96_, "note") == 0;
5008 } else {
5009 _tmp92_ = FALSE;
5010 }
5011 if (_tmp92_) {
5012 ValaCollection* _tmp97_;
5013 ValadocContentNote* _tmp98_;
5014 ValadocContentNote* _tmp99_;
5015 _tmp97_ = content;
5016 _tmp98_ = valadoc_gtkdoc_parser_parse_docbook_note (self);
5017 _tmp99_ = _tmp98_;
5018 valadoc_gtkdoc_parser_append_block_content_not_null (self, _tmp97_, (ValadocContentBlock*) _tmp99_);
5019 _g_object_unref0 (_tmp99_);
5020 } else {
5021 gboolean _tmp100_ = FALSE;
5022 ValadocGtkdocToken* _tmp101_;
5023 ValadocGtkdocTokenType _tmp102_;
5024 _tmp101_ = self->priv->current;
5025 _tmp102_ = _tmp101_->type;
5026 if (_tmp102_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5027 ValadocGtkdocToken* _tmp103_;
5028 const gchar* _tmp104_;
5029 _tmp103_ = self->priv->current;
5030 _tmp104_ = _tmp103_->content;
5031 _tmp100_ = g_strcmp0 (_tmp104_, "important") == 0;
5032 } else {
5033 _tmp100_ = FALSE;
5034 }
5035 if (_tmp100_) {
5036 ValaCollection* _tmp105_;
5037 ValadocContentNote* _tmp106_;
5038 ValadocContentNote* _tmp107_;
5039 _tmp105_ = content;
5040 _tmp106_ = valadoc_gtkdoc_parser_parse_docbook_important (self);
5041 _tmp107_ = _tmp106_;
5042 valadoc_gtkdoc_parser_append_block_content_not_null (self, _tmp105_, (ValadocContentBlock*) _tmp107_);
5043 _g_object_unref0 (_tmp107_);
5044 } else {
5045 gboolean _tmp108_ = FALSE;
5046 ValadocGtkdocToken* _tmp109_;
5047 ValadocGtkdocTokenType _tmp110_;
5048 _tmp109_ = self->priv->current;
5049 _tmp110_ = _tmp109_->type;
5050 if (_tmp110_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5051 ValadocGtkdocToken* _tmp111_;
5052 const gchar* _tmp112_;
5053 _tmp111_ = self->priv->current;
5054 _tmp112_ = _tmp111_->content;
5055 _tmp108_ = g_strcmp0 (_tmp112_, "refsect3") == 0;
5056 } else {
5057 _tmp108_ = FALSE;
5058 }
5059 if (_tmp108_) {
5060 ValaCollection* _tmp113_;
5061 ValaList* _tmp114_;
5062 ValaList* _tmp115_;
5063 _tmp113_ = content;
5064 _tmp114_ = valadoc_gtkdoc_parser_parse_docbook_refsect2 (self, 3);
5065 _tmp115_ = _tmp114_;
5066 valadoc_gtkdoc_parser_append_block_content_not_null_all (self, _tmp113_, (ValaCollection*) _tmp115_);
5067 _vala_iterable_unref0 (_tmp115_);
5068 } else {
5069 gboolean _tmp116_ = FALSE;
5070 ValadocGtkdocToken* _tmp117_;
5071 ValadocGtkdocTokenType _tmp118_;
5072 _tmp117_ = self->priv->current;
5073 _tmp118_ = _tmp117_->type;
5074 if (_tmp118_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5075 ValadocGtkdocToken* _tmp119_;
5076 const gchar* _tmp120_;
5077 _tmp119_ = self->priv->current;
5078 _tmp120_ = _tmp119_->content;
5079 _tmp116_ = g_strcmp0 (_tmp120_, "refsect2") == 0;
5080 } else {
5081 _tmp116_ = FALSE;
5082 }
5083 if (_tmp116_) {
5084 ValaCollection* _tmp121_;
5085 ValaList* _tmp122_;
5086 ValaList* _tmp123_;
5087 _tmp121_ = content;
5088 _tmp122_ = valadoc_gtkdoc_parser_parse_docbook_refsect2 (self, 2);
5089 _tmp123_ = _tmp122_;
5090 valadoc_gtkdoc_parser_append_block_content_not_null_all (self, _tmp121_, (ValaCollection*) _tmp123_);
5091 _vala_iterable_unref0 (_tmp123_);
5092 } else {
5093 gboolean _tmp124_ = FALSE;
5094 ValadocGtkdocToken* _tmp125_;
5095 ValadocGtkdocTokenType _tmp126_;
5096 _tmp125_ = self->priv->current;
5097 _tmp126_ = _tmp125_->type;
5098 if (_tmp126_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5099 ValadocGtkdocToken* _tmp127_;
5100 const gchar* _tmp128_;
5101 _tmp127_ = self->priv->current;
5102 _tmp128_ = _tmp127_->content;
5103 _tmp124_ = g_strcmp0 (_tmp128_, "figure") == 0;
5104 } else {
5105 _tmp124_ = FALSE;
5106 }
5107 if (_tmp124_) {
5108 ValaCollection* _tmp129_;
5109 ValaList* _tmp130_;
5110 ValaList* _tmp131_;
5111 _tmp129_ = content;
5112 _tmp130_ = valadoc_gtkdoc_parser_parse_docbook_figure (self);
5113 _tmp131_ = _tmp130_;
5114 valadoc_gtkdoc_parser_append_block_content_not_null_all (self, _tmp129_, (ValaCollection*) _tmp131_);
5115 _vala_iterable_unref0 (_tmp131_);
5116 } else {
5117 gboolean _tmp132_ = FALSE;
5118 ValadocGtkdocToken* _tmp133_;
5119 ValadocGtkdocTokenType _tmp134_;
5120 _tmp133_ = self->priv->current;
5121 _tmp134_ = _tmp133_->type;
5122 if (_tmp134_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5123 ValadocGtkdocToken* _tmp135_;
5124 const gchar* _tmp136_;
5125 _tmp135_ = self->priv->current;
5126 _tmp136_ = _tmp135_->content;
5127 _tmp132_ = g_strcmp0 (_tmp136_, "title") == 0;
5128 } else {
5129 _tmp132_ = FALSE;
5130 }
5131 if (_tmp132_) {
5132 ValaCollection* _tmp137_;
5133 ValadocContentParagraph* _tmp138_;
5134 ValadocContentParagraph* _tmp139_;
5135 _tmp137_ = content;
5136 _tmp138_ = valadoc_gtkdoc_parser_parse_docbook_title (self);
5137 _tmp139_ = _tmp138_;
5138 valadoc_gtkdoc_parser_append_block_content_not_null (self, _tmp137_, (ValadocContentBlock*) _tmp139_);
5139 _g_object_unref0 (_tmp139_);
5140 } else {
5141 gboolean _tmp140_ = FALSE;
5142 ValadocGtkdocToken* _tmp141_;
5143 ValadocGtkdocTokenType _tmp142_;
5144 _tmp141_ = self->priv->current;
5145 _tmp142_ = _tmp141_->type;
5146 if (_tmp142_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5147 ValadocGtkdocToken* _tmp143_;
5148 const gchar* _tmp144_;
5149 _tmp143_ = self->priv->current;
5150 _tmp144_ = _tmp143_->content;
5151 _tmp140_ = g_strcmp0 (_tmp144_, "section") == 0;
5152 } else {
5153 _tmp140_ = FALSE;
5154 }
5155 if (_tmp140_) {
5156 ValaCollection* _tmp145_;
5157 ValaCollection* _tmp146_;
5158 ValaCollection* _tmp147_;
5159 _tmp145_ = content;
5160 _tmp146_ = valadoc_gtkdoc_parser_parse_docbook_section (self);
5161 _tmp147_ = _tmp146_;
5162 valadoc_gtkdoc_parser_append_block_content_not_null_all (self, _tmp145_, _tmp147_);
5163 _vala_iterable_unref0 (_tmp147_);
5164 } else {
5165 ValadocGtkdocToken* _tmp148_;
5166 ValadocGtkdocTokenType _tmp149_;
5167 _tmp148_ = self->priv->current;
5168 _tmp149_ = _tmp148_->type;
5169 if (_tmp149_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_PARAGRAPH) {
5170 ValaCollection* _tmp150_;
5171 ValadocContentParagraph* _tmp151_;
5172 ValadocContentParagraph* _tmp152_;
5173 _tmp150_ = content;
5174 _tmp151_ = valadoc_gtkdoc_parser_parse_gtkdoc_paragraph (self);
5175 _tmp152_ = _tmp151_;
5176 valadoc_gtkdoc_parser_append_block_content_not_null (self, _tmp150_, (ValadocContentBlock*) _tmp152_);
5177 _g_object_unref0 (_tmp152_);
5178 } else {
5179 ValadocGtkdocToken* _tmp153_;
5180 ValadocGtkdocTokenType _tmp154_;
5181 _tmp153_ = self->priv->current;
5182 _tmp154_ = _tmp153_->type;
5183 if (_tmp154_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_SOURCE_OPEN) {
5184 ValaCollection* _tmp155_;
5185 ValadocContentParagraph* _tmp156_;
5186 ValadocContentParagraph* _tmp157_;
5187 _tmp155_ = content;
5188 _tmp156_ = valadoc_gtkdoc_parser_parse_gtkdoc_source (self);
5189 _tmp157_ = _tmp156_;
5190 valadoc_gtkdoc_parser_append_block_content_not_null (self, _tmp155_, (ValadocContentBlock*) _tmp157_);
5191 _g_object_unref0 (_tmp157_);
5192 } else {
5193 break;
5194 }
5195 }
5196 }
5197 }
5198 }
5199 }
5200 }
5201 }
5202 }
5203 }
5204 }
5205 }
5206 }
5207 }
5208 }
5209 }
5210 }
5211 }
5212 }
5213 }
5214 }
5215 result = content;
5216 return result;
5217 }
5218
5219 static ValadocContentRun*
valadoc_gtkdoc_parser_parse_xml_tag(ValadocGtkdocParser * self)5220 valadoc_gtkdoc_parser_parse_xml_tag (ValadocGtkdocParser* self)
5221 {
5222 gchar* _class = NULL;
5223 ValadocGtkdocToken* _tmp1_;
5224 ValaHashMap* _tmp2_;
5225 gpointer _tmp3_;
5226 ValadocGtkdocToken* _tmp4_;
5227 ValadocGtkdocToken* _tmp5_;
5228 ValadocGtkdocToken* _tmp6_;
5229 ValadocGtkdocTokenType _tmp7_;
5230 ValadocContentRun* run = NULL;
5231 ValadocContentContentFactory* _tmp9_;
5232 ValadocContentRun* _tmp10_;
5233 gboolean _tmp11_ = FALSE;
5234 const gchar* _tmp12_;
5235 ValadocGtkdocToken* _tmp48_;
5236 ValadocGtkdocToken* _tmp49_;
5237 ValadocContentRun* result = NULL;
5238 g_return_val_if_fail (self != NULL, NULL);
5239 if (!valadoc_gtkdoc_parser_check_xml_open_tag (self, "tag")) {
5240 ValadocGtkdocToken* _tmp0_;
5241 _tmp0_ = self->priv->current;
5242 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp0_, "<tag>");
5243 result = NULL;
5244 return result;
5245 }
5246 _tmp1_ = self->priv->current;
5247 _tmp2_ = _tmp1_->attributes;
5248 _tmp3_ = vala_map_get ((ValaMap*) _tmp2_, "class");
5249 _class = (gchar*) _tmp3_;
5250 _tmp4_ = valadoc_gtkdoc_parser_next (self);
5251 _tmp5_ = _tmp4_;
5252 _valadoc_gtkdoc_token_unref0 (_tmp5_);
5253 valadoc_gtkdoc_parser_parse_docbook_spaces (self, FALSE);
5254 _tmp6_ = self->priv->current;
5255 _tmp7_ = _tmp6_->type;
5256 if (_tmp7_ != VALADOC_GTKDOC_TOKEN_TYPE_WORD) {
5257 ValadocGtkdocToken* _tmp8_;
5258 _tmp8_ = self->priv->current;
5259 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp8_, "<WORD>");
5260 result = NULL;
5261 _g_free0 (_class);
5262 return result;
5263 }
5264 _tmp9_ = self->priv->factory;
5265 _tmp10_ = valadoc_content_content_factory_create_run (_tmp9_, VALADOC_CONTENT_RUN_STYLE_MONOSPACED);
5266 run = _tmp10_;
5267 _tmp12_ = _class;
5268 if (_tmp12_ == NULL) {
5269 _tmp11_ = TRUE;
5270 } else {
5271 const gchar* _tmp13_;
5272 _tmp13_ = _class;
5273 _tmp11_ = g_strcmp0 (_tmp13_, "starttag") == 0;
5274 }
5275 if (_tmp11_) {
5276 ValadocContentRun* _tmp14_;
5277 ValaList* _tmp15_;
5278 ValaList* _tmp16_;
5279 ValadocContentContentFactory* _tmp17_;
5280 ValadocGtkdocToken* _tmp18_;
5281 const gchar* _tmp19_;
5282 gchar* _tmp20_;
5283 gchar* _tmp21_;
5284 gchar* _tmp22_;
5285 gchar* _tmp23_;
5286 ValadocContentText* _tmp24_;
5287 ValadocContentText* _tmp25_;
5288 ValadocGtkdocToken* _tmp26_;
5289 ValadocGtkdocToken* _tmp27_;
5290 _tmp14_ = run;
5291 _tmp15_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp14_);
5292 _tmp16_ = _tmp15_;
5293 _tmp17_ = self->priv->factory;
5294 _tmp18_ = self->priv->current;
5295 _tmp19_ = _tmp18_->content;
5296 _tmp20_ = g_strconcat ("<", _tmp19_, NULL);
5297 _tmp21_ = _tmp20_;
5298 _tmp22_ = g_strconcat (_tmp21_, ">", NULL);
5299 _tmp23_ = _tmp22_;
5300 _tmp24_ = valadoc_content_content_factory_create_text (_tmp17_, _tmp23_);
5301 _tmp25_ = _tmp24_;
5302 vala_collection_add ((ValaCollection*) _tmp16_, (ValadocContentInline*) _tmp25_);
5303 _g_object_unref0 (_tmp25_);
5304 _g_free0 (_tmp23_);
5305 _g_free0 (_tmp21_);
5306 _tmp26_ = valadoc_gtkdoc_parser_next (self);
5307 _tmp27_ = _tmp26_;
5308 _valadoc_gtkdoc_token_unref0 (_tmp27_);
5309 } else {
5310 const gchar* _tmp28_;
5311 _tmp28_ = _class;
5312 if (g_strcmp0 (_tmp28_, "endtag") == 0) {
5313 ValadocContentRun* _tmp29_;
5314 ValaList* _tmp30_;
5315 ValaList* _tmp31_;
5316 ValadocContentContentFactory* _tmp32_;
5317 ValadocGtkdocToken* _tmp33_;
5318 const gchar* _tmp34_;
5319 gchar* _tmp35_;
5320 gchar* _tmp36_;
5321 gchar* _tmp37_;
5322 gchar* _tmp38_;
5323 ValadocContentText* _tmp39_;
5324 ValadocContentText* _tmp40_;
5325 ValadocGtkdocToken* _tmp41_;
5326 ValadocGtkdocToken* _tmp42_;
5327 _tmp29_ = run;
5328 _tmp30_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp29_);
5329 _tmp31_ = _tmp30_;
5330 _tmp32_ = self->priv->factory;
5331 _tmp33_ = self->priv->current;
5332 _tmp34_ = _tmp33_->content;
5333 _tmp35_ = g_strconcat ("</", _tmp34_, NULL);
5334 _tmp36_ = _tmp35_;
5335 _tmp37_ = g_strconcat (_tmp36_, ">", NULL);
5336 _tmp38_ = _tmp37_;
5337 _tmp39_ = valadoc_content_content_factory_create_text (_tmp32_, _tmp38_);
5338 _tmp40_ = _tmp39_;
5339 vala_collection_add ((ValaCollection*) _tmp31_, (ValadocContentInline*) _tmp40_);
5340 _g_object_unref0 (_tmp40_);
5341 _g_free0 (_tmp38_);
5342 _g_free0 (_tmp36_);
5343 _tmp41_ = valadoc_gtkdoc_parser_next (self);
5344 _tmp42_ = _tmp41_;
5345 _valadoc_gtkdoc_token_unref0 (_tmp42_);
5346 } else {
5347 ValadocGtkdocToken* _tmp43_;
5348 const gchar* _tmp44_;
5349 gchar* _tmp45_;
5350 gchar* _tmp46_;
5351 _tmp43_ = self->priv->current;
5352 _tmp44_ = _class;
5353 _tmp45_ = g_strdup_printf ("<tag class=\"%s\">", _tmp44_);
5354 _tmp46_ = _tmp45_;
5355 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp43_, _tmp46_);
5356 _g_free0 (_tmp46_);
5357 result = run;
5358 _g_free0 (_class);
5359 return result;
5360 }
5361 }
5362 valadoc_gtkdoc_parser_parse_docbook_spaces (self, FALSE);
5363 if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, "tag")) {
5364 ValadocGtkdocToken* _tmp47_;
5365 _tmp47_ = self->priv->current;
5366 valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp47_, "</tag>");
5367 result = run;
5368 _g_free0 (_class);
5369 return result;
5370 }
5371 _tmp48_ = valadoc_gtkdoc_parser_next (self);
5372 _tmp49_ = _tmp48_;
5373 _valadoc_gtkdoc_token_unref0 (_tmp49_);
5374 result = run;
5375 _g_free0 (_class);
5376 return result;
5377 }
5378
5379 static gchar*
string_chug(const gchar * self)5380 string_chug (const gchar* self)
5381 {
5382 gchar* _result_ = NULL;
5383 gchar* _tmp0_;
5384 gchar* result = NULL;
5385 g_return_val_if_fail (self != NULL, NULL);
5386 _tmp0_ = g_strdup (self);
5387 _result_ = _tmp0_;
5388 g_strchug (_result_);
5389 result = _result_;
5390 return result;
5391 }
5392
5393 static void
valadoc_gtkdoc_parser_append_inline_content_string(ValadocGtkdocParser * self,ValadocContentRun * run,const gchar * current)5394 valadoc_gtkdoc_parser_append_inline_content_string (ValadocGtkdocParser* self,
5395 ValadocContentRun* run,
5396 const gchar* current)
5397 {
5398 ValadocContentText* last_as_text = NULL;
5399 ValaList* _tmp0_;
5400 ValaList* _tmp1_;
5401 gint _tmp2_;
5402 gint _tmp3_;
5403 ValadocContentText* _tmp9_;
5404 g_return_if_fail (self != NULL);
5405 g_return_if_fail (run != NULL);
5406 g_return_if_fail (current != NULL);
5407 last_as_text = NULL;
5408 _tmp0_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) run);
5409 _tmp1_ = _tmp0_;
5410 _tmp2_ = vala_collection_get_size ((ValaCollection*) _tmp1_);
5411 _tmp3_ = _tmp2_;
5412 if (_tmp3_ > 0) {
5413 ValaList* _tmp4_;
5414 ValaList* _tmp5_;
5415 gpointer _tmp6_;
5416 ValadocContentInline* _tmp7_;
5417 ValadocContentText* _tmp8_;
5418 _tmp4_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) run);
5419 _tmp5_ = _tmp4_;
5420 _tmp6_ = vala_list_last (_tmp5_);
5421 _tmp7_ = (ValadocContentInline*) _tmp6_;
5422 _tmp8_ = VALADOC_CONTENT_IS_TEXT (_tmp7_) ? ((ValadocContentText*) _tmp7_) : NULL;
5423 if (_tmp8_ == NULL) {
5424 _g_object_unref0 (_tmp7_);
5425 }
5426 _g_object_unref0 (last_as_text);
5427 last_as_text = _tmp8_;
5428 }
5429 _tmp9_ = last_as_text;
5430 if (_tmp9_ == NULL) {
5431 ValaList* _tmp10_;
5432 ValaList* _tmp11_;
5433 ValadocContentContentFactory* _tmp12_;
5434 ValadocContentText* _tmp13_;
5435 ValadocContentText* _tmp14_;
5436 _tmp10_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) run);
5437 _tmp11_ = _tmp10_;
5438 _tmp12_ = self->priv->factory;
5439 _tmp13_ = valadoc_content_content_factory_create_text (_tmp12_, current);
5440 _tmp14_ = _tmp13_;
5441 vala_collection_add ((ValaCollection*) _tmp11_, (ValadocContentInline*) _tmp14_);
5442 _g_object_unref0 (_tmp14_);
5443 } else {
5444 gboolean _tmp15_ = FALSE;
5445 if (g_str_has_prefix (current, " ")) {
5446 ValadocContentText* _tmp16_;
5447 const gchar* _tmp17_;
5448 const gchar* _tmp18_;
5449 _tmp16_ = last_as_text;
5450 _tmp17_ = valadoc_content_text_get_content (_tmp16_);
5451 _tmp18_ = _tmp17_;
5452 _tmp15_ = g_str_has_suffix (_tmp18_, " ");
5453 } else {
5454 _tmp15_ = FALSE;
5455 }
5456 if (_tmp15_) {
5457 ValadocContentText* _tmp19_;
5458 ValadocContentText* _tmp20_;
5459 const gchar* _tmp21_;
5460 const gchar* _tmp22_;
5461 gchar* _tmp23_;
5462 gchar* _tmp24_;
5463 gchar* _tmp25_;
5464 gchar* _tmp26_;
5465 _tmp19_ = last_as_text;
5466 _tmp20_ = last_as_text;
5467 _tmp21_ = valadoc_content_text_get_content (_tmp20_);
5468 _tmp22_ = _tmp21_;
5469 _tmp23_ = string_chug (current);
5470 _tmp24_ = _tmp23_;
5471 _tmp25_ = g_strconcat (_tmp22_, _tmp24_, NULL);
5472 _tmp26_ = _tmp25_;
5473 valadoc_content_text_set_content (_tmp20_, _tmp26_);
5474 _g_free0 (_tmp26_);
5475 _g_free0 (_tmp24_);
5476 } else {
5477 ValadocContentText* _tmp27_;
5478 ValadocContentText* _tmp28_;
5479 const gchar* _tmp29_;
5480 const gchar* _tmp30_;
5481 gchar* _tmp31_;
5482 gchar* _tmp32_;
5483 _tmp27_ = last_as_text;
5484 _tmp28_ = last_as_text;
5485 _tmp29_ = valadoc_content_text_get_content (_tmp28_);
5486 _tmp30_ = _tmp29_;
5487 _tmp31_ = g_strconcat (_tmp30_, current, NULL);
5488 _tmp32_ = _tmp31_;
5489 valadoc_content_text_set_content (_tmp28_, _tmp32_);
5490 _g_free0 (_tmp32_);
5491 }
5492 }
5493 _g_object_unref0 (last_as_text);
5494 }
5495
5496 static ValadocContentInline*
valadoc_gtkdoc_parser_create_type_link(ValadocGtkdocParser * self,const gchar * name,gboolean c_accept_plural)5497 valadoc_gtkdoc_parser_create_type_link (ValadocGtkdocParser* self,
5498 const gchar* name,
5499 gboolean c_accept_plural)
5500 {
5501 gboolean _tmp0_ = FALSE;
5502 gboolean _tmp1_ = FALSE;
5503 gboolean _tmp2_ = FALSE;
5504 ValadocContentInline* result = NULL;
5505 g_return_val_if_fail (self != NULL, NULL);
5506 g_return_val_if_fail (name != NULL, NULL);
5507 if (g_strcmp0 (name, "TRUE") == 0) {
5508 _tmp2_ = TRUE;
5509 } else {
5510 _tmp2_ = g_strcmp0 (name, "FALSE") == 0;
5511 }
5512 if (_tmp2_) {
5513 _tmp1_ = TRUE;
5514 } else {
5515 _tmp1_ = g_strcmp0 (name, "NULL") == 0;
5516 }
5517 if (_tmp1_) {
5518 _tmp0_ = TRUE;
5519 } else {
5520 _tmp0_ = valadoc_gtkdoc_parser_is_numeric (self, name);
5521 }
5522 if (_tmp0_) {
5523 ValadocContentRun* monospaced = NULL;
5524 ValadocContentContentFactory* _tmp3_;
5525 ValadocContentRun* _tmp4_;
5526 ValadocContentRun* _tmp5_;
5527 ValaList* _tmp6_;
5528 ValaList* _tmp7_;
5529 ValadocContentContentFactory* _tmp8_;
5530 gchar* _tmp9_;
5531 gchar* _tmp10_;
5532 ValadocContentText* _tmp11_;
5533 ValadocContentText* _tmp12_;
5534 _tmp3_ = self->priv->factory;
5535 _tmp4_ = valadoc_content_content_factory_create_run (_tmp3_, VALADOC_CONTENT_RUN_STYLE_MONOSPACED);
5536 monospaced = _tmp4_;
5537 _tmp5_ = monospaced;
5538 _tmp6_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp5_);
5539 _tmp7_ = _tmp6_;
5540 _tmp8_ = self->priv->factory;
5541 _tmp9_ = g_ascii_strdown (name, (gssize) -1);
5542 _tmp10_ = _tmp9_;
5543 _tmp11_ = valadoc_content_content_factory_create_text (_tmp8_, _tmp10_);
5544 _tmp12_ = _tmp11_;
5545 vala_collection_add ((ValaCollection*) _tmp7_, (ValadocContentInline*) _tmp12_);
5546 _g_object_unref0 (_tmp12_);
5547 _g_free0 (_tmp10_);
5548 result = (ValadocContentInline*) monospaced;
5549 return result;
5550 } else {
5551 ValadocTagletsLink* taglet = NULL;
5552 ValadocContentContentFactory* _tmp13_;
5553 ValadocContentTaglet* _tmp14_;
5554 ValadocTagletsLink* _tmp15_;
5555 ValadocTagletsLink* _tmp16_;
5556 ValadocTagletsLink* _tmp17_;
5557 ValadocTagletsLink* _tmp18_;
5558 gchar* _tmp19_;
5559 gchar* _tmp20_;
5560 _tmp13_ = self->priv->factory;
5561 _tmp14_ = valadoc_content_content_factory_create_taglet (_tmp13_, "link");
5562 _tmp15_ = VALADOC_TAGLETS_IS_LINK (_tmp14_) ? ((ValadocTagletsLink*) _tmp14_) : NULL;
5563 if (_tmp15_ == NULL) {
5564 _g_object_unref0 (_tmp14_);
5565 }
5566 taglet = _tmp15_;
5567 _tmp16_ = taglet;
5568 _vala_assert (_tmp16_ != NULL, "taglet != null");
5569 _tmp17_ = taglet;
5570 valadoc_taglets_link_set_c_accept_plural (_tmp17_, c_accept_plural);
5571 _tmp18_ = taglet;
5572 _tmp19_ = g_strconcat ("c::", name, NULL);
5573 _tmp20_ = _tmp19_;
5574 valadoc_taglets_link_set_symbol_name (_tmp18_, _tmp20_);
5575 _g_free0 (_tmp20_);
5576 result = (ValadocContentInline*) taglet;
5577 return result;
5578 }
5579 }
5580
5581 static inline void
valadoc_gtkdoc_parser_append_inline_content_not_null(ValadocGtkdocParser * self,ValadocContentRun * run,ValadocContentInline * element)5582 valadoc_gtkdoc_parser_append_inline_content_not_null (ValadocGtkdocParser* self,
5583 ValadocContentRun* run,
5584 ValadocContentInline* element)
5585 {
5586 g_return_if_fail (self != NULL);
5587 g_return_if_fail (run != NULL);
5588 g_return_if_fail (element != NULL);
5589 if (element != NULL) {
5590 ValaList* _tmp0_;
5591 ValaList* _tmp1_;
5592 _tmp0_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) run);
5593 _tmp1_ = _tmp0_;
5594 vala_collection_add ((ValaCollection*) _tmp1_, element);
5595 }
5596 }
5597
5598 static ValadocContentRun*
valadoc_gtkdoc_parser_parse_inline_content(ValadocGtkdocParser * self)5599 valadoc_gtkdoc_parser_parse_inline_content (ValadocGtkdocParser* self)
5600 {
5601 ValadocContentRun* run = NULL;
5602 ValadocContentContentFactory* _tmp0_;
5603 ValadocContentRun* _tmp1_;
5604 ValadocContentRun* result = NULL;
5605 g_return_val_if_fail (self != NULL, NULL);
5606 _tmp0_ = self->priv->factory;
5607 _tmp1_ = valadoc_content_content_factory_create_run (_tmp0_, VALADOC_CONTENT_RUN_STYLE_NONE);
5608 run = _tmp1_;
5609 while (TRUE) {
5610 ValadocGtkdocToken* _tmp2_;
5611 ValadocGtkdocTokenType _tmp3_;
5612 gboolean _tmp4_ = FALSE;
5613 ValadocGtkdocToken* _tmp5_;
5614 ValadocGtkdocTokenType _tmp6_;
5615 _tmp2_ = self->priv->current;
5616 _tmp3_ = _tmp2_->type;
5617 if (!(_tmp3_ != VALADOC_GTKDOC_TOKEN_TYPE_EOF)) {
5618 break;
5619 }
5620 _tmp5_ = self->priv->current;
5621 _tmp6_ = _tmp5_->type;
5622 if (_tmp6_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5623 ValadocGtkdocToken* _tmp7_;
5624 const gchar* _tmp8_;
5625 _tmp7_ = self->priv->current;
5626 _tmp8_ = _tmp7_->content;
5627 _tmp4_ = g_strcmp0 (_tmp8_, "firstterm") == 0;
5628 } else {
5629 _tmp4_ = FALSE;
5630 }
5631 if (_tmp4_) {
5632 ValadocContentRun* _tmp9_;
5633 ValadocContentRun* _tmp10_;
5634 ValadocContentRun* _tmp11_;
5635 _tmp9_ = run;
5636 _tmp10_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "firstterm", VALADOC_CONTENT_RUN_STYLE_ITALIC);
5637 _tmp11_ = _tmp10_;
5638 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp9_, (ValadocContentInline*) _tmp11_);
5639 _g_object_unref0 (_tmp11_);
5640 } else {
5641 gboolean _tmp12_ = FALSE;
5642 ValadocGtkdocToken* _tmp13_;
5643 ValadocGtkdocTokenType _tmp14_;
5644 _tmp13_ = self->priv->current;
5645 _tmp14_ = _tmp13_->type;
5646 if (_tmp14_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5647 ValadocGtkdocToken* _tmp15_;
5648 const gchar* _tmp16_;
5649 _tmp15_ = self->priv->current;
5650 _tmp16_ = _tmp15_->content;
5651 _tmp12_ = g_strcmp0 (_tmp16_, "abbrev") == 0;
5652 } else {
5653 _tmp12_ = FALSE;
5654 }
5655 if (_tmp12_) {
5656 ValadocContentRun* _tmp17_;
5657 ValadocContentRun* _tmp18_;
5658 ValadocContentRun* _tmp19_;
5659 _tmp17_ = run;
5660 _tmp18_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "abbrev", VALADOC_CONTENT_RUN_STYLE_ITALIC);
5661 _tmp19_ = _tmp18_;
5662 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp17_, (ValadocContentInline*) _tmp19_);
5663 _g_object_unref0 (_tmp19_);
5664 } else {
5665 gboolean _tmp20_ = FALSE;
5666 ValadocGtkdocToken* _tmp21_;
5667 ValadocGtkdocTokenType _tmp22_;
5668 _tmp21_ = self->priv->current;
5669 _tmp22_ = _tmp21_->type;
5670 if (_tmp22_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5671 ValadocGtkdocToken* _tmp23_;
5672 const gchar* _tmp24_;
5673 _tmp23_ = self->priv->current;
5674 _tmp24_ = _tmp23_->content;
5675 _tmp20_ = g_strcmp0 (_tmp24_, "term") == 0;
5676 } else {
5677 _tmp20_ = FALSE;
5678 }
5679 if (_tmp20_) {
5680 ValadocContentRun* _tmp25_;
5681 ValadocContentRun* _tmp26_;
5682 ValadocContentRun* _tmp27_;
5683 _tmp25_ = run;
5684 _tmp26_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "term", VALADOC_CONTENT_RUN_STYLE_ITALIC);
5685 _tmp27_ = _tmp26_;
5686 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp25_, (ValadocContentInline*) _tmp27_);
5687 _g_object_unref0 (_tmp27_);
5688 } else {
5689 gboolean _tmp28_ = FALSE;
5690 ValadocGtkdocToken* _tmp29_;
5691 ValadocGtkdocTokenType _tmp30_;
5692 _tmp29_ = self->priv->current;
5693 _tmp30_ = _tmp29_->type;
5694 if (_tmp30_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5695 ValadocGtkdocToken* _tmp31_;
5696 const gchar* _tmp32_;
5697 _tmp31_ = self->priv->current;
5698 _tmp32_ = _tmp31_->content;
5699 _tmp28_ = g_strcmp0 (_tmp32_, "literal") == 0;
5700 } else {
5701 _tmp28_ = FALSE;
5702 }
5703 if (_tmp28_) {
5704 ValadocContentRun* _tmp33_;
5705 ValadocContentRun* _tmp34_;
5706 ValadocContentRun* _tmp35_;
5707 _tmp33_ = run;
5708 _tmp34_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "literal", VALADOC_CONTENT_RUN_STYLE_ITALIC);
5709 _tmp35_ = _tmp34_;
5710 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp33_, (ValadocContentInline*) _tmp35_);
5711 _g_object_unref0 (_tmp35_);
5712 } else {
5713 gboolean _tmp36_ = FALSE;
5714 ValadocGtkdocToken* _tmp37_;
5715 ValadocGtkdocTokenType _tmp38_;
5716 _tmp37_ = self->priv->current;
5717 _tmp38_ = _tmp37_->type;
5718 if (_tmp38_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5719 ValadocGtkdocToken* _tmp39_;
5720 const gchar* _tmp40_;
5721 _tmp39_ = self->priv->current;
5722 _tmp40_ = _tmp39_->content;
5723 _tmp36_ = g_strcmp0 (_tmp40_, "literallayout") == 0;
5724 } else {
5725 _tmp36_ = FALSE;
5726 }
5727 if (_tmp36_) {
5728 ValadocContentRun* _tmp41_;
5729 ValadocContentRun* _tmp42_;
5730 ValadocContentRun* _tmp43_;
5731 _tmp41_ = run;
5732 _tmp42_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "literallayout", VALADOC_CONTENT_RUN_STYLE_MONOSPACED);
5733 _tmp43_ = _tmp42_;
5734 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp41_, (ValadocContentInline*) _tmp43_);
5735 _g_object_unref0 (_tmp43_);
5736 } else {
5737 gboolean _tmp44_ = FALSE;
5738 ValadocGtkdocToken* _tmp45_;
5739 ValadocGtkdocTokenType _tmp46_;
5740 _tmp45_ = self->priv->current;
5741 _tmp46_ = _tmp45_->type;
5742 if (_tmp46_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5743 ValadocGtkdocToken* _tmp47_;
5744 const gchar* _tmp48_;
5745 _tmp47_ = self->priv->current;
5746 _tmp48_ = _tmp47_->content;
5747 _tmp44_ = g_strcmp0 (_tmp48_, "application") == 0;
5748 } else {
5749 _tmp44_ = FALSE;
5750 }
5751 if (_tmp44_) {
5752 ValadocContentRun* _tmp49_;
5753 ValadocContentRun* _tmp50_;
5754 ValadocContentRun* _tmp51_;
5755 _tmp49_ = run;
5756 _tmp50_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "application", VALADOC_CONTENT_RUN_STYLE_MONOSPACED);
5757 _tmp51_ = _tmp50_;
5758 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp49_, (ValadocContentInline*) _tmp51_);
5759 _g_object_unref0 (_tmp51_);
5760 } else {
5761 gboolean _tmp52_ = FALSE;
5762 ValadocGtkdocToken* _tmp53_;
5763 ValadocGtkdocTokenType _tmp54_;
5764 _tmp53_ = self->priv->current;
5765 _tmp54_ = _tmp53_->type;
5766 if (_tmp54_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5767 ValadocGtkdocToken* _tmp55_;
5768 const gchar* _tmp56_;
5769 _tmp55_ = self->priv->current;
5770 _tmp56_ = _tmp55_->content;
5771 _tmp52_ = g_strcmp0 (_tmp56_, "varname") == 0;
5772 } else {
5773 _tmp52_ = FALSE;
5774 }
5775 if (_tmp52_) {
5776 ValadocContentRun* _tmp57_;
5777 ValadocContentRun* _tmp58_;
5778 ValadocContentRun* _tmp59_;
5779 _tmp57_ = run;
5780 _tmp58_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "varname", VALADOC_CONTENT_RUN_STYLE_MONOSPACED);
5781 _tmp59_ = _tmp58_;
5782 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp57_, (ValadocContentInline*) _tmp59_);
5783 _g_object_unref0 (_tmp59_);
5784 } else {
5785 gboolean _tmp60_ = FALSE;
5786 ValadocGtkdocToken* _tmp61_;
5787 ValadocGtkdocTokenType _tmp62_;
5788 _tmp61_ = self->priv->current;
5789 _tmp62_ = _tmp61_->type;
5790 if (_tmp62_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5791 ValadocGtkdocToken* _tmp63_;
5792 const gchar* _tmp64_;
5793 _tmp63_ = self->priv->current;
5794 _tmp64_ = _tmp63_->content;
5795 _tmp60_ = g_strcmp0 (_tmp64_, "computeroutput") == 0;
5796 } else {
5797 _tmp60_ = FALSE;
5798 }
5799 if (_tmp60_) {
5800 ValadocContentRun* _tmp65_;
5801 ValadocContentRun* _tmp66_;
5802 ValadocContentRun* _tmp67_;
5803 _tmp65_ = run;
5804 _tmp66_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "computeroutput", VALADOC_CONTENT_RUN_STYLE_MONOSPACED);
5805 _tmp67_ = _tmp66_;
5806 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp65_, (ValadocContentInline*) _tmp67_);
5807 _g_object_unref0 (_tmp67_);
5808 } else {
5809 gboolean _tmp68_ = FALSE;
5810 ValadocGtkdocToken* _tmp69_;
5811 ValadocGtkdocTokenType _tmp70_;
5812 _tmp69_ = self->priv->current;
5813 _tmp70_ = _tmp69_->type;
5814 if (_tmp70_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5815 ValadocGtkdocToken* _tmp71_;
5816 const gchar* _tmp72_;
5817 _tmp71_ = self->priv->current;
5818 _tmp72_ = _tmp71_->content;
5819 _tmp68_ = g_strcmp0 (_tmp72_, "emphasis") == 0;
5820 } else {
5821 _tmp68_ = FALSE;
5822 }
5823 if (_tmp68_) {
5824 ValadocContentRun* _tmp73_;
5825 ValadocContentRun* _tmp74_;
5826 ValadocContentRun* _tmp75_;
5827 _tmp73_ = run;
5828 _tmp74_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "emphasis", VALADOC_CONTENT_RUN_STYLE_MONOSPACED);
5829 _tmp75_ = _tmp74_;
5830 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp73_, (ValadocContentInline*) _tmp75_);
5831 _g_object_unref0 (_tmp75_);
5832 } else {
5833 gboolean _tmp76_ = FALSE;
5834 ValadocGtkdocToken* _tmp77_;
5835 ValadocGtkdocTokenType _tmp78_;
5836 _tmp77_ = self->priv->current;
5837 _tmp78_ = _tmp77_->type;
5838 if (_tmp78_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5839 ValadocGtkdocToken* _tmp79_;
5840 const gchar* _tmp80_;
5841 _tmp79_ = self->priv->current;
5842 _tmp80_ = _tmp79_->content;
5843 _tmp76_ = g_strcmp0 (_tmp80_, "pre") == 0;
5844 } else {
5845 _tmp76_ = FALSE;
5846 }
5847 if (_tmp76_) {
5848 ValadocContentRun* _tmp81_;
5849 ValadocContentRun* _tmp82_;
5850 ValadocContentRun* _tmp83_;
5851 _tmp81_ = run;
5852 _tmp82_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "pre", VALADOC_CONTENT_RUN_STYLE_MONOSPACED);
5853 _tmp83_ = _tmp82_;
5854 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp81_, (ValadocContentInline*) _tmp83_);
5855 _g_object_unref0 (_tmp83_);
5856 } else {
5857 gboolean _tmp84_ = FALSE;
5858 ValadocGtkdocToken* _tmp85_;
5859 ValadocGtkdocTokenType _tmp86_;
5860 _tmp85_ = self->priv->current;
5861 _tmp86_ = _tmp85_->type;
5862 if (_tmp86_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5863 ValadocGtkdocToken* _tmp87_;
5864 const gchar* _tmp88_;
5865 _tmp87_ = self->priv->current;
5866 _tmp88_ = _tmp87_->content;
5867 _tmp84_ = g_strcmp0 (_tmp88_, "code") == 0;
5868 } else {
5869 _tmp84_ = FALSE;
5870 }
5871 if (_tmp84_) {
5872 ValadocContentRun* _tmp89_;
5873 ValadocContentRun* _tmp90_;
5874 ValadocContentRun* _tmp91_;
5875 _tmp89_ = run;
5876 _tmp90_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "code", VALADOC_CONTENT_RUN_STYLE_MONOSPACED);
5877 _tmp91_ = _tmp90_;
5878 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp89_, (ValadocContentInline*) _tmp91_);
5879 _g_object_unref0 (_tmp91_);
5880 } else {
5881 gboolean _tmp92_ = FALSE;
5882 ValadocGtkdocToken* _tmp93_;
5883 ValadocGtkdocTokenType _tmp94_;
5884 _tmp93_ = self->priv->current;
5885 _tmp94_ = _tmp93_->type;
5886 if (_tmp94_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5887 ValadocGtkdocToken* _tmp95_;
5888 const gchar* _tmp96_;
5889 _tmp95_ = self->priv->current;
5890 _tmp96_ = _tmp95_->content;
5891 _tmp92_ = g_strcmp0 (_tmp96_, "guimenuitem") == 0;
5892 } else {
5893 _tmp92_ = FALSE;
5894 }
5895 if (_tmp92_) {
5896 ValadocContentRun* _tmp97_;
5897 ValadocContentRun* _tmp98_;
5898 ValadocContentRun* _tmp99_;
5899 _tmp97_ = run;
5900 _tmp98_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "guimenuitem", VALADOC_CONTENT_RUN_STYLE_MONOSPACED);
5901 _tmp99_ = _tmp98_;
5902 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp97_, (ValadocContentInline*) _tmp99_);
5903 _g_object_unref0 (_tmp99_);
5904 } else {
5905 gboolean _tmp100_ = FALSE;
5906 ValadocGtkdocToken* _tmp101_;
5907 ValadocGtkdocTokenType _tmp102_;
5908 _tmp101_ = self->priv->current;
5909 _tmp102_ = _tmp101_->type;
5910 if (_tmp102_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5911 ValadocGtkdocToken* _tmp103_;
5912 const gchar* _tmp104_;
5913 _tmp103_ = self->priv->current;
5914 _tmp104_ = _tmp103_->content;
5915 _tmp100_ = g_strcmp0 (_tmp104_, "command") == 0;
5916 } else {
5917 _tmp100_ = FALSE;
5918 }
5919 if (_tmp100_) {
5920 ValadocContentRun* _tmp105_;
5921 ValadocContentRun* _tmp106_;
5922 ValadocContentRun* _tmp107_;
5923 _tmp105_ = run;
5924 _tmp106_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "command", VALADOC_CONTENT_RUN_STYLE_MONOSPACED);
5925 _tmp107_ = _tmp106_;
5926 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp105_, (ValadocContentInline*) _tmp107_);
5927 _g_object_unref0 (_tmp107_);
5928 } else {
5929 gboolean _tmp108_ = FALSE;
5930 ValadocGtkdocToken* _tmp109_;
5931 ValadocGtkdocTokenType _tmp110_;
5932 _tmp109_ = self->priv->current;
5933 _tmp110_ = _tmp109_->type;
5934 if (_tmp110_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5935 ValadocGtkdocToken* _tmp111_;
5936 const gchar* _tmp112_;
5937 _tmp111_ = self->priv->current;
5938 _tmp112_ = _tmp111_->content;
5939 _tmp108_ = g_strcmp0 (_tmp112_, "option") == 0;
5940 } else {
5941 _tmp108_ = FALSE;
5942 }
5943 if (_tmp108_) {
5944 ValadocContentRun* _tmp113_;
5945 ValadocContentRun* _tmp114_;
5946 ValadocContentRun* _tmp115_;
5947 _tmp113_ = run;
5948 _tmp114_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "option", VALADOC_CONTENT_RUN_STYLE_MONOSPACED);
5949 _tmp115_ = _tmp114_;
5950 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp113_, (ValadocContentInline*) _tmp115_);
5951 _g_object_unref0 (_tmp115_);
5952 } else {
5953 gboolean _tmp116_ = FALSE;
5954 ValadocGtkdocToken* _tmp117_;
5955 ValadocGtkdocTokenType _tmp118_;
5956 _tmp117_ = self->priv->current;
5957 _tmp118_ = _tmp117_->type;
5958 if (_tmp118_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5959 ValadocGtkdocToken* _tmp119_;
5960 const gchar* _tmp120_;
5961 _tmp119_ = self->priv->current;
5962 _tmp120_ = _tmp119_->content;
5963 _tmp116_ = g_strcmp0 (_tmp120_, "keycap") == 0;
5964 } else {
5965 _tmp116_ = FALSE;
5966 }
5967 if (_tmp116_) {
5968 ValadocContentRun* _tmp121_;
5969 ValadocContentRun* _tmp122_;
5970 ValadocContentRun* _tmp123_;
5971 _tmp121_ = run;
5972 _tmp122_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "keycap", VALADOC_CONTENT_RUN_STYLE_MONOSPACED);
5973 _tmp123_ = _tmp122_;
5974 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp121_, (ValadocContentInline*) _tmp123_);
5975 _g_object_unref0 (_tmp123_);
5976 } else {
5977 gboolean _tmp124_ = FALSE;
5978 ValadocGtkdocToken* _tmp125_;
5979 ValadocGtkdocTokenType _tmp126_;
5980 _tmp125_ = self->priv->current;
5981 _tmp126_ = _tmp125_->type;
5982 if (_tmp126_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
5983 ValadocGtkdocToken* _tmp127_;
5984 const gchar* _tmp128_;
5985 _tmp127_ = self->priv->current;
5986 _tmp128_ = _tmp127_->content;
5987 _tmp124_ = g_strcmp0 (_tmp128_, "keycombo") == 0;
5988 } else {
5989 _tmp124_ = FALSE;
5990 }
5991 if (_tmp124_) {
5992 ValadocContentRun* _tmp129_;
5993 ValadocContentRun* _tmp130_;
5994 ValadocContentRun* _tmp131_;
5995 _tmp129_ = run;
5996 _tmp130_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "keycombo", VALADOC_CONTENT_RUN_STYLE_MONOSPACED);
5997 _tmp131_ = _tmp130_;
5998 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp129_, (ValadocContentInline*) _tmp131_);
5999 _g_object_unref0 (_tmp131_);
6000 } else {
6001 gboolean _tmp132_ = FALSE;
6002 ValadocGtkdocToken* _tmp133_;
6003 ValadocGtkdocTokenType _tmp134_;
6004 _tmp133_ = self->priv->current;
6005 _tmp134_ = _tmp133_->type;
6006 if (_tmp134_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
6007 ValadocGtkdocToken* _tmp135_;
6008 const gchar* _tmp136_;
6009 _tmp135_ = self->priv->current;
6010 _tmp136_ = _tmp135_->content;
6011 _tmp132_ = g_strcmp0 (_tmp136_, "envar") == 0;
6012 } else {
6013 _tmp132_ = FALSE;
6014 }
6015 if (_tmp132_) {
6016 ValadocContentRun* _tmp137_;
6017 ValadocContentRun* _tmp138_;
6018 ValadocContentRun* _tmp139_;
6019 _tmp137_ = run;
6020 _tmp138_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "envar", VALADOC_CONTENT_RUN_STYLE_MONOSPACED);
6021 _tmp139_ = _tmp138_;
6022 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp137_, (ValadocContentInline*) _tmp139_);
6023 _g_object_unref0 (_tmp139_);
6024 } else {
6025 gboolean _tmp140_ = FALSE;
6026 ValadocGtkdocToken* _tmp141_;
6027 ValadocGtkdocTokenType _tmp142_;
6028 _tmp141_ = self->priv->current;
6029 _tmp142_ = _tmp141_->type;
6030 if (_tmp142_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
6031 ValadocGtkdocToken* _tmp143_;
6032 const gchar* _tmp144_;
6033 _tmp143_ = self->priv->current;
6034 _tmp144_ = _tmp143_->content;
6035 _tmp140_ = g_strcmp0 (_tmp144_, "filename") == 0;
6036 } else {
6037 _tmp140_ = FALSE;
6038 }
6039 if (_tmp140_) {
6040 ValadocContentRun* _tmp145_;
6041 ValadocContentRun* _tmp146_;
6042 ValadocContentRun* _tmp147_;
6043 _tmp145_ = run;
6044 _tmp146_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "filename", VALADOC_CONTENT_RUN_STYLE_MONOSPACED);
6045 _tmp147_ = _tmp146_;
6046 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp145_, (ValadocContentInline*) _tmp147_);
6047 _g_object_unref0 (_tmp147_);
6048 } else {
6049 gboolean _tmp148_ = FALSE;
6050 ValadocGtkdocToken* _tmp149_;
6051 ValadocGtkdocTokenType _tmp150_;
6052 _tmp149_ = self->priv->current;
6053 _tmp150_ = _tmp149_->type;
6054 if (_tmp150_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
6055 ValadocGtkdocToken* _tmp151_;
6056 const gchar* _tmp152_;
6057 _tmp151_ = self->priv->current;
6058 _tmp152_ = _tmp151_->content;
6059 _tmp148_ = g_strcmp0 (_tmp152_, "parameter") == 0;
6060 } else {
6061 _tmp148_ = FALSE;
6062 }
6063 if (_tmp148_) {
6064 ValadocContentRun* _tmp153_;
6065 ValadocContentRun* _tmp154_;
6066 ValadocContentRun* _tmp155_;
6067 _tmp153_ = run;
6068 _tmp154_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "parameter", VALADOC_CONTENT_RUN_STYLE_MONOSPACED);
6069 _tmp155_ = _tmp154_;
6070 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp153_, (ValadocContentInline*) _tmp155_);
6071 _g_object_unref0 (_tmp155_);
6072 } else {
6073 gboolean _tmp156_ = FALSE;
6074 ValadocGtkdocToken* _tmp157_;
6075 ValadocGtkdocTokenType _tmp158_;
6076 _tmp157_ = self->priv->current;
6077 _tmp158_ = _tmp157_->type;
6078 if (_tmp158_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
6079 ValadocGtkdocToken* _tmp159_;
6080 const gchar* _tmp160_;
6081 _tmp159_ = self->priv->current;
6082 _tmp160_ = _tmp159_->content;
6083 _tmp156_ = g_strcmp0 (_tmp160_, "replaceable") == 0;
6084 } else {
6085 _tmp156_ = FALSE;
6086 }
6087 if (_tmp156_) {
6088 ValadocContentRun* _tmp161_;
6089 ValadocContentRun* _tmp162_;
6090 ValadocContentRun* _tmp163_;
6091 _tmp161_ = run;
6092 _tmp162_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "replaceable", VALADOC_CONTENT_RUN_STYLE_ITALIC);
6093 _tmp163_ = _tmp162_;
6094 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp161_, (ValadocContentInline*) _tmp163_);
6095 _g_object_unref0 (_tmp163_);
6096 } else {
6097 gboolean _tmp164_ = FALSE;
6098 ValadocGtkdocToken* _tmp165_;
6099 ValadocGtkdocTokenType _tmp166_;
6100 _tmp165_ = self->priv->current;
6101 _tmp166_ = _tmp165_->type;
6102 if (_tmp166_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
6103 ValadocGtkdocToken* _tmp167_;
6104 const gchar* _tmp168_;
6105 _tmp167_ = self->priv->current;
6106 _tmp168_ = _tmp167_->content;
6107 _tmp164_ = g_strcmp0 (_tmp168_, "quote") == 0;
6108 } else {
6109 _tmp164_ = FALSE;
6110 }
6111 if (_tmp164_) {
6112 ValadocContentRun* _tmp169_;
6113 ValaList* _tmp170_;
6114 ValaList* _tmp171_;
6115 ValadocContentContentFactory* _tmp172_;
6116 ValadocContentText* _tmp173_;
6117 ValadocContentText* _tmp174_;
6118 ValadocContentRun* _tmp175_;
6119 ValadocContentRun* _tmp176_;
6120 ValadocContentRun* _tmp177_;
6121 ValadocContentRun* _tmp178_;
6122 ValaList* _tmp179_;
6123 ValaList* _tmp180_;
6124 ValadocContentContentFactory* _tmp181_;
6125 ValadocContentText* _tmp182_;
6126 ValadocContentText* _tmp183_;
6127 _tmp169_ = run;
6128 _tmp170_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp169_);
6129 _tmp171_ = _tmp170_;
6130 _tmp172_ = self->priv->factory;
6131 _tmp173_ = valadoc_content_content_factory_create_text (_tmp172_, "“");
6132 _tmp174_ = _tmp173_;
6133 vala_collection_add ((ValaCollection*) _tmp171_, (ValadocContentInline*) _tmp174_);
6134 _g_object_unref0 (_tmp174_);
6135 _tmp175_ = run;
6136 _tmp176_ = valadoc_gtkdoc_parser_parse_highlighted_template (self, "quote", VALADOC_CONTENT_RUN_STYLE_NONE);
6137 _tmp177_ = _tmp176_;
6138 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp175_, (ValadocContentInline*) _tmp177_);
6139 _g_object_unref0 (_tmp177_);
6140 _tmp178_ = run;
6141 _tmp179_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp178_);
6142 _tmp180_ = _tmp179_;
6143 _tmp181_ = self->priv->factory;
6144 _tmp182_ = valadoc_content_content_factory_create_text (_tmp181_, "”");
6145 _tmp183_ = _tmp182_;
6146 vala_collection_add ((ValaCollection*) _tmp180_, (ValadocContentInline*) _tmp183_);
6147 _g_object_unref0 (_tmp183_);
6148 } else {
6149 gboolean _tmp184_ = FALSE;
6150 ValadocGtkdocToken* _tmp185_;
6151 ValadocGtkdocTokenType _tmp186_;
6152 _tmp185_ = self->priv->current;
6153 _tmp186_ = _tmp185_->type;
6154 if (_tmp186_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
6155 ValadocGtkdocToken* _tmp187_;
6156 const gchar* _tmp188_;
6157 _tmp187_ = self->priv->current;
6158 _tmp188_ = _tmp187_->content;
6159 _tmp184_ = g_strcmp0 (_tmp188_, "footnote") == 0;
6160 } else {
6161 _tmp184_ = FALSE;
6162 }
6163 if (_tmp184_) {
6164 ValadocContentRun* _tmp189_;
6165 ValadocContentRun* _tmp190_;
6166 ValadocContentRun* _tmp191_;
6167 _tmp189_ = run;
6168 _tmp190_ = valadoc_gtkdoc_parser_parse_docbook_footnote (self);
6169 _tmp191_ = _tmp190_;
6170 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp189_, (ValadocContentInline*) _tmp191_);
6171 _g_object_unref0 (_tmp191_);
6172 } else {
6173 gboolean _tmp192_ = FALSE;
6174 ValadocGtkdocToken* _tmp193_;
6175 ValadocGtkdocTokenType _tmp194_;
6176 _tmp193_ = self->priv->current;
6177 _tmp194_ = _tmp193_->type;
6178 if (_tmp194_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
6179 ValadocGtkdocToken* _tmp195_;
6180 const gchar* _tmp196_;
6181 _tmp195_ = self->priv->current;
6182 _tmp196_ = _tmp195_->content;
6183 _tmp192_ = g_strcmp0 (_tmp196_, "type") == 0;
6184 } else {
6185 _tmp192_ = FALSE;
6186 }
6187 if (_tmp192_) {
6188 ValadocContentRun* _tmp197_;
6189 ValadocContentInlineTaglet* _tmp198_;
6190 ValadocContentInlineTaglet* _tmp199_;
6191 _tmp197_ = run;
6192 _tmp198_ = valadoc_gtkdoc_parser_parse_symbol_link (self, "type");
6193 _tmp199_ = _tmp198_;
6194 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp197_, (ValadocContentInline*) _tmp199_);
6195 _g_object_unref0 (_tmp199_);
6196 } else {
6197 gboolean _tmp200_ = FALSE;
6198 ValadocGtkdocToken* _tmp201_;
6199 ValadocGtkdocTokenType _tmp202_;
6200 _tmp201_ = self->priv->current;
6201 _tmp202_ = _tmp201_->type;
6202 if (_tmp202_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
6203 ValadocGtkdocToken* _tmp203_;
6204 const gchar* _tmp204_;
6205 _tmp203_ = self->priv->current;
6206 _tmp204_ = _tmp203_->content;
6207 _tmp200_ = g_strcmp0 (_tmp204_, "function") == 0;
6208 } else {
6209 _tmp200_ = FALSE;
6210 }
6211 if (_tmp200_) {
6212 ValadocContentRun* _tmp205_;
6213 ValadocContentInlineTaglet* _tmp206_;
6214 ValadocContentInlineTaglet* _tmp207_;
6215 _tmp205_ = run;
6216 _tmp206_ = valadoc_gtkdoc_parser_parse_symbol_link (self, "function");
6217 _tmp207_ = _tmp206_;
6218 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp205_, (ValadocContentInline*) _tmp207_);
6219 _g_object_unref0 (_tmp207_);
6220 } else {
6221 gboolean _tmp208_ = FALSE;
6222 ValadocGtkdocToken* _tmp209_;
6223 ValadocGtkdocTokenType _tmp210_;
6224 _tmp209_ = self->priv->current;
6225 _tmp210_ = _tmp209_->type;
6226 if (_tmp210_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
6227 ValadocGtkdocToken* _tmp211_;
6228 const gchar* _tmp212_;
6229 _tmp211_ = self->priv->current;
6230 _tmp212_ = _tmp211_->content;
6231 _tmp208_ = g_strcmp0 (_tmp212_, "classname") == 0;
6232 } else {
6233 _tmp208_ = FALSE;
6234 }
6235 if (_tmp208_) {
6236 ValadocContentRun* _tmp213_;
6237 ValadocContentInlineTaglet* _tmp214_;
6238 ValadocContentInlineTaglet* _tmp215_;
6239 _tmp213_ = run;
6240 _tmp214_ = valadoc_gtkdoc_parser_parse_symbol_link (self, "classname");
6241 _tmp215_ = _tmp214_;
6242 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp213_, (ValadocContentInline*) _tmp215_);
6243 _g_object_unref0 (_tmp215_);
6244 } else {
6245 gboolean _tmp216_ = FALSE;
6246 ValadocGtkdocToken* _tmp217_;
6247 ValadocGtkdocTokenType _tmp218_;
6248 _tmp217_ = self->priv->current;
6249 _tmp218_ = _tmp217_->type;
6250 if (_tmp218_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
6251 ValadocGtkdocToken* _tmp219_;
6252 const gchar* _tmp220_;
6253 _tmp219_ = self->priv->current;
6254 _tmp220_ = _tmp219_->content;
6255 _tmp216_ = g_strcmp0 (_tmp220_, "structname") == 0;
6256 } else {
6257 _tmp216_ = FALSE;
6258 }
6259 if (_tmp216_) {
6260 ValadocContentRun* _tmp221_;
6261 ValadocContentInlineTaglet* _tmp222_;
6262 ValadocContentInlineTaglet* _tmp223_;
6263 _tmp221_ = run;
6264 _tmp222_ = valadoc_gtkdoc_parser_parse_symbol_link (self, "structname");
6265 _tmp223_ = _tmp222_;
6266 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp221_, (ValadocContentInline*) _tmp223_);
6267 _g_object_unref0 (_tmp223_);
6268 } else {
6269 gboolean _tmp224_ = FALSE;
6270 ValadocGtkdocToken* _tmp225_;
6271 ValadocGtkdocTokenType _tmp226_;
6272 _tmp225_ = self->priv->current;
6273 _tmp226_ = _tmp225_->type;
6274 if (_tmp226_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
6275 ValadocGtkdocToken* _tmp227_;
6276 const gchar* _tmp228_;
6277 _tmp227_ = self->priv->current;
6278 _tmp228_ = _tmp227_->content;
6279 _tmp224_ = g_strcmp0 (_tmp228_, "structfield") == 0;
6280 } else {
6281 _tmp224_ = FALSE;
6282 }
6283 if (_tmp224_) {
6284 ValadocContentRun* _tmp229_;
6285 ValadocContentInlineTaglet* _tmp230_;
6286 ValadocContentInlineTaglet* _tmp231_;
6287 _tmp229_ = run;
6288 _tmp230_ = valadoc_gtkdoc_parser_parse_symbol_link (self, "structfield");
6289 _tmp231_ = _tmp230_;
6290 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp229_, (ValadocContentInline*) _tmp231_);
6291 _g_object_unref0 (_tmp231_);
6292 } else {
6293 gboolean _tmp232_ = FALSE;
6294 ValadocGtkdocToken* _tmp233_;
6295 ValadocGtkdocTokenType _tmp234_;
6296 _tmp233_ = self->priv->current;
6297 _tmp234_ = _tmp233_->type;
6298 if (_tmp234_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
6299 ValadocGtkdocToken* _tmp235_;
6300 const gchar* _tmp236_;
6301 _tmp235_ = self->priv->current;
6302 _tmp236_ = _tmp235_->content;
6303 _tmp232_ = g_strcmp0 (_tmp236_, "errorcode") == 0;
6304 } else {
6305 _tmp232_ = FALSE;
6306 }
6307 if (_tmp232_) {
6308 ValadocContentRun* _tmp237_;
6309 ValadocContentInlineTaglet* _tmp238_;
6310 ValadocContentInlineTaglet* _tmp239_;
6311 _tmp237_ = run;
6312 _tmp238_ = valadoc_gtkdoc_parser_parse_symbol_link (self, "errorcode");
6313 _tmp239_ = _tmp238_;
6314 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp237_, (ValadocContentInline*) _tmp239_);
6315 _g_object_unref0 (_tmp239_);
6316 } else {
6317 gboolean _tmp240_ = FALSE;
6318 ValadocGtkdocToken* _tmp241_;
6319 ValadocGtkdocTokenType _tmp242_;
6320 _tmp241_ = self->priv->current;
6321 _tmp242_ = _tmp241_->type;
6322 if (_tmp242_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
6323 ValadocGtkdocToken* _tmp243_;
6324 const gchar* _tmp244_;
6325 _tmp243_ = self->priv->current;
6326 _tmp244_ = _tmp243_->content;
6327 _tmp240_ = g_strcmp0 (_tmp244_, "constant") == 0;
6328 } else {
6329 _tmp240_ = FALSE;
6330 }
6331 if (_tmp240_) {
6332 ValadocContentRun* _tmp245_;
6333 ValadocContentInlineTaglet* _tmp246_;
6334 ValadocContentInlineTaglet* _tmp247_;
6335 _tmp245_ = run;
6336 _tmp246_ = valadoc_gtkdoc_parser_parse_symbol_link (self, "constant");
6337 _tmp247_ = _tmp246_;
6338 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp245_, (ValadocContentInline*) _tmp247_);
6339 _g_object_unref0 (_tmp247_);
6340 } else {
6341 gboolean _tmp248_ = FALSE;
6342 ValadocGtkdocToken* _tmp249_;
6343 ValadocGtkdocTokenType _tmp250_;
6344 _tmp249_ = self->priv->current;
6345 _tmp250_ = _tmp249_->type;
6346 if (_tmp250_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
6347 ValadocGtkdocToken* _tmp251_;
6348 const gchar* _tmp252_;
6349 _tmp251_ = self->priv->current;
6350 _tmp252_ = _tmp251_->content;
6351 _tmp248_ = g_strcmp0 (_tmp252_, "inlinegraphic") == 0;
6352 } else {
6353 _tmp248_ = FALSE;
6354 }
6355 if (_tmp248_) {
6356 ValadocContentRun* _tmp253_;
6357 ValadocContentEmbedded* _tmp254_;
6358 ValadocContentEmbedded* _tmp255_;
6359 _tmp253_ = run;
6360 _tmp254_ = valadoc_gtkdoc_parser_parse_docbook_inlinegraphic (self, "inlinegraphic");
6361 _tmp255_ = _tmp254_;
6362 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp253_, (ValadocContentInline*) _tmp255_);
6363 _g_object_unref0 (_tmp255_);
6364 } else {
6365 gboolean _tmp256_ = FALSE;
6366 ValadocGtkdocToken* _tmp257_;
6367 ValadocGtkdocTokenType _tmp258_;
6368 _tmp257_ = self->priv->current;
6369 _tmp258_ = _tmp257_->type;
6370 if (_tmp258_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
6371 ValadocGtkdocToken* _tmp259_;
6372 const gchar* _tmp260_;
6373 _tmp259_ = self->priv->current;
6374 _tmp260_ = _tmp259_->content;
6375 _tmp256_ = g_strcmp0 (_tmp260_, "anchor") == 0;
6376 } else {
6377 _tmp256_ = FALSE;
6378 }
6379 if (_tmp256_) {
6380 valadoc_gtkdoc_parser_parse_anchor (self);
6381 } else {
6382 gboolean _tmp261_ = FALSE;
6383 ValadocGtkdocToken* _tmp262_;
6384 ValadocGtkdocTokenType _tmp263_;
6385 _tmp262_ = self->priv->current;
6386 _tmp263_ = _tmp262_->type;
6387 if (_tmp263_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
6388 ValadocGtkdocToken* _tmp264_;
6389 const gchar* _tmp265_;
6390 _tmp264_ = self->priv->current;
6391 _tmp265_ = _tmp264_->content;
6392 _tmp261_ = g_strcmp0 (_tmp265_, "link") == 0;
6393 } else {
6394 _tmp261_ = FALSE;
6395 }
6396 if (_tmp261_) {
6397 ValadocContentRun* _tmp266_;
6398 ValadocContentInline* _tmp267_;
6399 ValadocContentInline* _tmp268_;
6400 _tmp266_ = run;
6401 _tmp267_ = valadoc_gtkdoc_parser_parse_docbook_link_tempalte (self, "link", TRUE);
6402 _tmp268_ = _tmp267_;
6403 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp266_, _tmp268_);
6404 _g_object_unref0 (_tmp268_);
6405 } else {
6406 gboolean _tmp269_ = FALSE;
6407 ValadocGtkdocToken* _tmp270_;
6408 ValadocGtkdocTokenType _tmp271_;
6409 _tmp270_ = self->priv->current;
6410 _tmp271_ = _tmp270_->type;
6411 if (_tmp271_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
6412 ValadocGtkdocToken* _tmp272_;
6413 const gchar* _tmp273_;
6414 _tmp272_ = self->priv->current;
6415 _tmp273_ = _tmp272_->content;
6416 _tmp269_ = g_strcmp0 (_tmp273_, "ulink") == 0;
6417 } else {
6418 _tmp269_ = FALSE;
6419 }
6420 if (_tmp269_) {
6421 ValadocContentRun* _tmp274_;
6422 ValadocContentInline* _tmp275_;
6423 ValadocContentInline* _tmp276_;
6424 _tmp274_ = run;
6425 _tmp275_ = valadoc_gtkdoc_parser_parse_docbook_link_tempalte (self, "ulink", FALSE);
6426 _tmp276_ = _tmp275_;
6427 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp274_, _tmp276_);
6428 _g_object_unref0 (_tmp276_);
6429 } else {
6430 gboolean _tmp277_ = FALSE;
6431 ValadocGtkdocToken* _tmp278_;
6432 ValadocGtkdocTokenType _tmp279_;
6433 _tmp278_ = self->priv->current;
6434 _tmp279_ = _tmp278_->type;
6435 if (_tmp279_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
6436 ValadocGtkdocToken* _tmp280_;
6437 const gchar* _tmp281_;
6438 _tmp280_ = self->priv->current;
6439 _tmp281_ = _tmp280_->content;
6440 _tmp277_ = g_strcmp0 (_tmp281_, "xref") == 0;
6441 } else {
6442 _tmp277_ = FALSE;
6443 }
6444 if (_tmp277_) {
6445 ValadocContentRun* _tmp282_;
6446 ValadocContentLink* _tmp283_;
6447 ValadocContentLink* _tmp284_;
6448 _tmp282_ = run;
6449 _tmp283_ = valadoc_gtkdoc_parser_parse_xref (self);
6450 _tmp284_ = _tmp283_;
6451 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp282_, (ValadocContentInline*) _tmp284_);
6452 _g_object_unref0 (_tmp284_);
6453 } else {
6454 gboolean _tmp285_ = FALSE;
6455 ValadocGtkdocToken* _tmp286_;
6456 ValadocGtkdocTokenType _tmp287_;
6457 _tmp286_ = self->priv->current;
6458 _tmp287_ = _tmp286_->type;
6459 if (_tmp287_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) {
6460 ValadocGtkdocToken* _tmp288_;
6461 const gchar* _tmp289_;
6462 _tmp288_ = self->priv->current;
6463 _tmp289_ = _tmp288_->content;
6464 _tmp285_ = g_strcmp0 (_tmp289_, "tag") == 0;
6465 } else {
6466 _tmp285_ = FALSE;
6467 }
6468 if (_tmp285_) {
6469 ValadocContentRun* _tmp290_;
6470 ValadocContentRun* _tmp291_;
6471 ValadocContentRun* _tmp292_;
6472 _tmp290_ = run;
6473 _tmp291_ = valadoc_gtkdoc_parser_parse_xml_tag (self);
6474 _tmp292_ = _tmp291_;
6475 valadoc_gtkdoc_parser_append_inline_content_not_null (self, _tmp290_, (ValadocContentInline*) _tmp292_);
6476 _g_object_unref0 (_tmp292_);
6477 } else {
6478 ValadocGtkdocToken* _tmp293_;
6479 ValadocGtkdocTokenType _tmp294_;
6480 _tmp293_ = self->priv->current;
6481 _tmp294_ = _tmp293_->type;
6482 if (_tmp294_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_FUNCTION) {
6483 ValadocContentRun* _tmp295_;
6484 ValaList* _tmp296_;
6485 ValaList* _tmp297_;
6486 ValadocGtkdocToken* _tmp298_;
6487 const gchar* _tmp299_;
6488 ValadocContentInline* _tmp300_;
6489 ValadocContentInline* _tmp301_;
6490 ValadocGtkdocToken* _tmp302_;
6491 ValadocGtkdocToken* _tmp303_;
6492 _tmp295_ = run;
6493 _tmp296_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp295_);
6494 _tmp297_ = _tmp296_;
6495 _tmp298_ = self->priv->current;
6496 _tmp299_ = _tmp298_->content;
6497 _tmp300_ = valadoc_gtkdoc_parser_create_type_link (self, _tmp299_, FALSE);
6498 _tmp301_ = _tmp300_;
6499 vala_collection_add ((ValaCollection*) _tmp297_, _tmp301_);
6500 _g_object_unref0 (_tmp301_);
6501 _tmp302_ = valadoc_gtkdoc_parser_next (self);
6502 _tmp303_ = _tmp302_;
6503 _valadoc_gtkdoc_token_unref0 (_tmp303_);
6504 } else {
6505 ValadocGtkdocToken* _tmp304_;
6506 ValadocGtkdocTokenType _tmp305_;
6507 _tmp304_ = self->priv->current;
6508 _tmp305_ = _tmp304_->type;
6509 if (_tmp305_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_PARAM) {
6510 ValadocGtkdocToken* _tmp306_;
6511 const gchar* _tmp307_;
6512 const gchar* _tmp308_;
6513 ValadocGtkdocToken* _tmp386_;
6514 ValadocGtkdocToken* _tmp387_;
6515 _tmp306_ = self->priv->current;
6516 _tmp307_ = _tmp306_->content;
6517 _tmp308_ = self->priv->instance_param_name;
6518 if (g_strcmp0 (_tmp307_, _tmp308_) == 0) {
6519 ValadocContentRun* keyword_run = NULL;
6520 ValadocContentContentFactory* _tmp309_;
6521 ValadocContentRun* _tmp310_;
6522 ValadocContentText* text = NULL;
6523 ValadocContentContentFactory* _tmp311_;
6524 ValadocContentText* _tmp312_;
6525 ValadocContentRun* _tmp313_;
6526 ValaList* _tmp314_;
6527 ValaList* _tmp315_;
6528 ValadocContentText* _tmp316_;
6529 ValadocContentRun* _tmp317_;
6530 ValaList* _tmp318_;
6531 ValaList* _tmp319_;
6532 ValadocContentRun* _tmp320_;
6533 _tmp309_ = self->priv->factory;
6534 _tmp310_ = valadoc_content_content_factory_create_run (_tmp309_, VALADOC_CONTENT_RUN_STYLE_LANG_KEYWORD);
6535 keyword_run = _tmp310_;
6536 _tmp311_ = self->priv->factory;
6537 _tmp312_ = valadoc_content_content_factory_create_text (_tmp311_, "this");
6538 text = _tmp312_;
6539 _tmp313_ = keyword_run;
6540 _tmp314_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp313_);
6541 _tmp315_ = _tmp314_;
6542 _tmp316_ = text;
6543 vala_collection_add ((ValaCollection*) _tmp315_, (ValadocContentInline*) _tmp316_);
6544 _tmp317_ = run;
6545 _tmp318_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp317_);
6546 _tmp319_ = _tmp318_;
6547 _tmp320_ = keyword_run;
6548 vala_collection_add ((ValaCollection*) _tmp319_, (ValadocContentInline*) _tmp320_);
6549 _g_object_unref0 (text);
6550 _g_object_unref0 (keyword_run);
6551 } else {
6552 gchar* param_array_name = NULL;
6553 gboolean is_return_type_len = FALSE;
6554 gchar* param_name = NULL;
6555 gchar* cname = NULL;
6556 ValadocApiTree* _tmp321_;
6557 ValadocApiNode* _tmp322_;
6558 ValadocGtkdocToken* _tmp323_;
6559 const gchar* _tmp324_;
6560 gchar* _tmp325_ = NULL;
6561 gchar* _tmp326_ = NULL;
6562 gboolean _tmp327_ = FALSE;
6563 gchar* _tmp328_;
6564 ValadocContentRun* current_run = NULL;
6565 ValadocContentContentFactory* _tmp329_;
6566 ValadocContentRun* _tmp330_;
6567 ValadocContentRun* _tmp331_;
6568 ValaList* _tmp332_;
6569 ValaList* _tmp333_;
6570 ValadocContentRun* _tmp334_;
6571 const gchar* _tmp370_;
6572 _tmp321_ = self->priv->tree;
6573 _tmp322_ = self->priv->element;
6574 _tmp323_ = self->priv->current;
6575 _tmp324_ = _tmp323_->content;
6576 _tmp328_ = valadoc_importer_helper_resolve_parameter_ctype (_tmp321_, _tmp322_, _tmp324_, &_tmp325_, &_tmp326_, &_tmp327_);
6577 _g_free0 (param_name);
6578 param_name = _tmp325_;
6579 _g_free0 (param_array_name);
6580 param_array_name = _tmp326_;
6581 is_return_type_len = _tmp327_;
6582 cname = _tmp328_;
6583 _tmp329_ = self->priv->factory;
6584 _tmp330_ = valadoc_content_content_factory_create_run (_tmp329_, VALADOC_CONTENT_RUN_STYLE_MONOSPACED);
6585 current_run = _tmp330_;
6586 _tmp331_ = run;
6587 _tmp332_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp331_);
6588 _tmp333_ = _tmp332_;
6589 _tmp334_ = current_run;
6590 vala_collection_add ((ValaCollection*) _tmp333_, (ValadocContentInline*) _tmp334_);
6591 if (is_return_type_len) {
6592 ValadocContentRun* keyword_run = NULL;
6593 ValadocContentContentFactory* _tmp335_;
6594 ValadocContentRun* _tmp336_;
6595 ValadocContentRun* _tmp337_;
6596 ValaList* _tmp338_;
6597 ValaList* _tmp339_;
6598 ValadocContentContentFactory* _tmp340_;
6599 ValadocContentText* _tmp341_;
6600 ValadocContentText* _tmp342_;
6601 ValadocContentRun* _tmp343_;
6602 ValaList* _tmp344_;
6603 ValaList* _tmp345_;
6604 ValadocContentRun* _tmp346_;
6605 ValadocContentRun* _tmp347_;
6606 ValaList* _tmp348_;
6607 ValaList* _tmp349_;
6608 ValadocContentContentFactory* _tmp350_;
6609 ValadocContentText* _tmp351_;
6610 ValadocContentText* _tmp352_;
6611 _tmp335_ = self->priv->factory;
6612 _tmp336_ = valadoc_content_content_factory_create_run (_tmp335_, VALADOC_CONTENT_RUN_STYLE_LANG_KEYWORD);
6613 keyword_run = _tmp336_;
6614 _tmp337_ = keyword_run;
6615 _tmp338_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp337_);
6616 _tmp339_ = _tmp338_;
6617 _tmp340_ = self->priv->factory;
6618 _tmp341_ = valadoc_content_content_factory_create_text (_tmp340_, "return");
6619 _tmp342_ = _tmp341_;
6620 vala_collection_add ((ValaCollection*) _tmp339_, (ValadocContentInline*) _tmp342_);
6621 _g_object_unref0 (_tmp342_);
6622 _tmp343_ = current_run;
6623 _tmp344_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp343_);
6624 _tmp345_ = _tmp344_;
6625 _tmp346_ = keyword_run;
6626 vala_collection_add ((ValaCollection*) _tmp345_, (ValadocContentInline*) _tmp346_);
6627 _tmp347_ = current_run;
6628 _tmp348_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp347_);
6629 _tmp349_ = _tmp348_;
6630 _tmp350_ = self->priv->factory;
6631 _tmp351_ = valadoc_content_content_factory_create_text (_tmp350_, ".length");
6632 _tmp352_ = _tmp351_;
6633 vala_collection_add ((ValaCollection*) _tmp349_, (ValadocContentInline*) _tmp352_);
6634 _g_object_unref0 (_tmp352_);
6635 _g_object_unref0 (keyword_run);
6636 } else {
6637 const gchar* _tmp353_;
6638 _tmp353_ = param_array_name;
6639 if (_tmp353_ != NULL) {
6640 ValadocContentRun* _tmp354_;
6641 ValaList* _tmp355_;
6642 ValaList* _tmp356_;
6643 ValadocContentContentFactory* _tmp357_;
6644 const gchar* _tmp358_;
6645 gchar* _tmp359_;
6646 gchar* _tmp360_;
6647 ValadocContentText* _tmp361_;
6648 ValadocContentText* _tmp362_;
6649 _tmp354_ = current_run;
6650 _tmp355_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp354_);
6651 _tmp356_ = _tmp355_;
6652 _tmp357_ = self->priv->factory;
6653 _tmp358_ = param_array_name;
6654 _tmp359_ = g_strconcat (_tmp358_, ".length", NULL);
6655 _tmp360_ = _tmp359_;
6656 _tmp361_ = valadoc_content_content_factory_create_text (_tmp357_, _tmp360_);
6657 _tmp362_ = _tmp361_;
6658 vala_collection_add ((ValaCollection*) _tmp356_, (ValadocContentInline*) _tmp362_);
6659 _g_object_unref0 (_tmp362_);
6660 _g_free0 (_tmp360_);
6661 } else {
6662 ValadocContentRun* _tmp363_;
6663 ValaList* _tmp364_;
6664 ValaList* _tmp365_;
6665 ValadocContentContentFactory* _tmp366_;
6666 const gchar* _tmp367_;
6667 ValadocContentText* _tmp368_;
6668 ValadocContentText* _tmp369_;
6669 _tmp363_ = current_run;
6670 _tmp364_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp363_);
6671 _tmp365_ = _tmp364_;
6672 _tmp366_ = self->priv->factory;
6673 _tmp367_ = param_name;
6674 _tmp368_ = valadoc_content_content_factory_create_text (_tmp366_, _tmp367_);
6675 _tmp369_ = _tmp368_;
6676 vala_collection_add ((ValaCollection*) _tmp365_, (ValadocContentInline*) _tmp369_);
6677 _g_object_unref0 (_tmp369_);
6678 }
6679 }
6680 _tmp370_ = cname;
6681 if (_tmp370_ != NULL) {
6682 ValadocContentRun* _tmp371_;
6683 ValaList* _tmp372_;
6684 ValaList* _tmp373_;
6685 ValadocContentContentFactory* _tmp374_;
6686 ValadocContentText* _tmp375_;
6687 ValadocContentText* _tmp376_;
6688 ValadocTagletsLink* link = NULL;
6689 ValadocContentContentFactory* _tmp377_;
6690 ValadocContentTaglet* _tmp378_;
6691 ValadocTagletsLink* _tmp379_;
6692 ValadocTagletsLink* _tmp380_;
6693 const gchar* _tmp381_;
6694 ValadocContentRun* _tmp382_;
6695 ValaList* _tmp383_;
6696 ValaList* _tmp384_;
6697 ValadocTagletsLink* _tmp385_;
6698 _tmp371_ = run;
6699 _tmp372_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp371_);
6700 _tmp373_ = _tmp372_;
6701 _tmp374_ = self->priv->factory;
6702 _tmp375_ = valadoc_content_content_factory_create_text (_tmp374_, ".");
6703 _tmp376_ = _tmp375_;
6704 vala_collection_add ((ValaCollection*) _tmp373_, (ValadocContentInline*) _tmp376_);
6705 _g_object_unref0 (_tmp376_);
6706 _tmp377_ = self->priv->factory;
6707 _tmp378_ = valadoc_content_content_factory_create_taglet (_tmp377_, "link");
6708 _tmp379_ = VALADOC_TAGLETS_IS_LINK (_tmp378_) ? ((ValadocTagletsLink*) _tmp378_) : NULL;
6709 if (_tmp379_ == NULL) {
6710 _g_object_unref0 (_tmp378_);
6711 }
6712 link = _tmp379_;
6713 _tmp380_ = link;
6714 _tmp381_ = cname;
6715 valadoc_taglets_link_set_symbol_name (_tmp380_, _tmp381_);
6716 _tmp382_ = run;
6717 _tmp383_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp382_);
6718 _tmp384_ = _tmp383_;
6719 _tmp385_ = link;
6720 vala_collection_add ((ValaCollection*) _tmp384_, (ValadocContentInline*) _tmp385_);
6721 _g_object_unref0 (link);
6722 }
6723 _g_object_unref0 (current_run);
6724 _g_free0 (cname);
6725 _g_free0 (param_name);
6726 _g_free0 (param_array_name);
6727 }
6728 _tmp386_ = valadoc_gtkdoc_parser_next (self);
6729 _tmp387_ = _tmp386_;
6730 _valadoc_gtkdoc_token_unref0 (_tmp387_);
6731 } else {
6732 ValadocGtkdocToken* _tmp388_;
6733 ValadocGtkdocTokenType _tmp389_;
6734 _tmp388_ = self->priv->current;
6735 _tmp389_ = _tmp388_->type;
6736 if (_tmp389_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_SIGNAL) {
6737 ValadocContentRun* _tmp390_;
6738 ValaList* _tmp391_;
6739 ValaList* _tmp392_;
6740 ValadocGtkdocToken* _tmp393_;
6741 const gchar* _tmp394_;
6742 gchar* _tmp395_;
6743 gchar* _tmp396_;
6744 ValadocContentInline* _tmp397_;
6745 ValadocContentInline* _tmp398_;
6746 ValadocGtkdocToken* _tmp399_;
6747 ValadocGtkdocToken* _tmp400_;
6748 _tmp390_ = run;
6749 _tmp391_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp390_);
6750 _tmp392_ = _tmp391_;
6751 _tmp393_ = self->priv->current;
6752 _tmp394_ = _tmp393_->content;
6753 _tmp395_ = g_strconcat ("::", _tmp394_, NULL);
6754 _tmp396_ = _tmp395_;
6755 _tmp397_ = valadoc_gtkdoc_parser_create_type_link (self, _tmp396_, TRUE);
6756 _tmp398_ = _tmp397_;
6757 vala_collection_add ((ValaCollection*) _tmp392_, _tmp398_);
6758 _g_object_unref0 (_tmp398_);
6759 _g_free0 (_tmp396_);
6760 _tmp399_ = valadoc_gtkdoc_parser_next (self);
6761 _tmp400_ = _tmp399_;
6762 _valadoc_gtkdoc_token_unref0 (_tmp400_);
6763 } else {
6764 ValadocGtkdocToken* _tmp401_;
6765 ValadocGtkdocTokenType _tmp402_;
6766 _tmp401_ = self->priv->current;
6767 _tmp402_ = _tmp401_->type;
6768 if (_tmp402_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_PROPERTY) {
6769 ValadocContentRun* _tmp403_;
6770 ValaList* _tmp404_;
6771 ValaList* _tmp405_;
6772 ValadocGtkdocToken* _tmp406_;
6773 const gchar* _tmp407_;
6774 gchar* _tmp408_;
6775 gchar* _tmp409_;
6776 ValadocContentInline* _tmp410_;
6777 ValadocContentInline* _tmp411_;
6778 ValadocGtkdocToken* _tmp412_;
6779 ValadocGtkdocToken* _tmp413_;
6780 _tmp403_ = run;
6781 _tmp404_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp403_);
6782 _tmp405_ = _tmp404_;
6783 _tmp406_ = self->priv->current;
6784 _tmp407_ = _tmp406_->content;
6785 _tmp408_ = g_strconcat (":", _tmp407_, NULL);
6786 _tmp409_ = _tmp408_;
6787 _tmp410_ = valadoc_gtkdoc_parser_create_type_link (self, _tmp409_, TRUE);
6788 _tmp411_ = _tmp410_;
6789 vala_collection_add ((ValaCollection*) _tmp405_, _tmp411_);
6790 _g_object_unref0 (_tmp411_);
6791 _g_free0 (_tmp409_);
6792 _tmp412_ = valadoc_gtkdoc_parser_next (self);
6793 _tmp413_ = _tmp412_;
6794 _valadoc_gtkdoc_token_unref0 (_tmp413_);
6795 } else {
6796 ValadocGtkdocToken* _tmp414_;
6797 ValadocGtkdocTokenType _tmp415_;
6798 _tmp414_ = self->priv->current;
6799 _tmp415_ = _tmp414_->type;
6800 if (_tmp415_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_CONST) {
6801 ValadocContentRun* _tmp416_;
6802 ValaList* _tmp417_;
6803 ValaList* _tmp418_;
6804 ValadocGtkdocToken* _tmp419_;
6805 const gchar* _tmp420_;
6806 ValadocContentInline* _tmp421_;
6807 ValadocContentInline* _tmp422_;
6808 ValadocGtkdocToken* _tmp423_;
6809 ValadocGtkdocToken* _tmp424_;
6810 _tmp416_ = run;
6811 _tmp417_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp416_);
6812 _tmp418_ = _tmp417_;
6813 _tmp419_ = self->priv->current;
6814 _tmp420_ = _tmp419_->content;
6815 _tmp421_ = valadoc_gtkdoc_parser_create_type_link (self, _tmp420_, TRUE);
6816 _tmp422_ = _tmp421_;
6817 vala_collection_add ((ValaCollection*) _tmp418_, _tmp422_);
6818 _g_object_unref0 (_tmp422_);
6819 _tmp423_ = valadoc_gtkdoc_parser_next (self);
6820 _tmp424_ = _tmp423_;
6821 _valadoc_gtkdoc_token_unref0 (_tmp424_);
6822 } else {
6823 ValadocGtkdocToken* _tmp425_;
6824 ValadocGtkdocTokenType _tmp426_;
6825 _tmp425_ = self->priv->current;
6826 _tmp426_ = _tmp425_->type;
6827 if (_tmp426_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_TYPE) {
6828 ValadocContentRun* _tmp427_;
6829 ValaList* _tmp428_;
6830 ValaList* _tmp429_;
6831 ValadocGtkdocToken* _tmp430_;
6832 const gchar* _tmp431_;
6833 ValadocContentInline* _tmp432_;
6834 ValadocContentInline* _tmp433_;
6835 ValadocGtkdocToken* _tmp434_;
6836 ValadocGtkdocToken* _tmp435_;
6837 _tmp427_ = run;
6838 _tmp428_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp427_);
6839 _tmp429_ = _tmp428_;
6840 _tmp430_ = self->priv->current;
6841 _tmp431_ = _tmp430_->content;
6842 _tmp432_ = valadoc_gtkdoc_parser_create_type_link (self, _tmp431_, TRUE);
6843 _tmp433_ = _tmp432_;
6844 vala_collection_add ((ValaCollection*) _tmp429_, _tmp433_);
6845 _g_object_unref0 (_tmp433_);
6846 _tmp434_ = valadoc_gtkdoc_parser_next (self);
6847 _tmp435_ = _tmp434_;
6848 _valadoc_gtkdoc_token_unref0 (_tmp435_);
6849 } else {
6850 gboolean _tmp436_ = FALSE;
6851 ValadocGtkdocToken* _tmp437_;
6852 ValadocGtkdocTokenType _tmp438_;
6853 _tmp437_ = self->priv->current;
6854 _tmp438_ = _tmp437_->type;
6855 if (_tmp438_ == VALADOC_GTKDOC_TOKEN_TYPE_NEWLINE) {
6856 _tmp436_ = TRUE;
6857 } else {
6858 ValadocGtkdocToken* _tmp439_;
6859 ValadocGtkdocTokenType _tmp440_;
6860 _tmp439_ = self->priv->current;
6861 _tmp440_ = _tmp439_->type;
6862 _tmp436_ = _tmp440_ == VALADOC_GTKDOC_TOKEN_TYPE_SPACE;
6863 }
6864 if (_tmp436_) {
6865 ValadocContentRun* _tmp441_;
6866 ValadocGtkdocToken* _tmp442_;
6867 ValadocGtkdocToken* _tmp443_;
6868 _tmp441_ = run;
6869 valadoc_gtkdoc_parser_append_inline_content_string (self, _tmp441_, " ");
6870 _tmp442_ = valadoc_gtkdoc_parser_next (self);
6871 _tmp443_ = _tmp442_;
6872 _valadoc_gtkdoc_token_unref0 (_tmp443_);
6873 } else {
6874 ValadocGtkdocToken* _tmp444_;
6875 ValadocGtkdocTokenType _tmp445_;
6876 _tmp444_ = self->priv->current;
6877 _tmp445_ = _tmp444_->type;
6878 if (_tmp445_ == VALADOC_GTKDOC_TOKEN_TYPE_WORD) {
6879 ValadocContentRun* _tmp446_;
6880 ValadocGtkdocToken* _tmp447_;
6881 const gchar* _tmp448_;
6882 ValadocGtkdocToken* _tmp449_;
6883 ValadocGtkdocToken* _tmp450_;
6884 _tmp446_ = run;
6885 _tmp447_ = self->priv->current;
6886 _tmp448_ = _tmp447_->content;
6887 valadoc_gtkdoc_parser_append_inline_content_string (self, _tmp446_, _tmp448_);
6888 _tmp449_ = valadoc_gtkdoc_parser_next (self);
6889 _tmp450_ = _tmp449_;
6890 _valadoc_gtkdoc_token_unref0 (_tmp450_);
6891 } else {
6892 gboolean _tmp451_ = FALSE;
6893 ValadocGtkdocToken* _tmp452_;
6894 ValadocGtkdocTokenType _tmp453_;
6895 _tmp452_ = self->priv->current;
6896 _tmp453_ = _tmp452_->type;
6897 if (_tmp453_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE) {
6898 _tmp451_ = valadoc_gtkdoc_parser_ignore_current_xml_close (self);
6899 } else {
6900 _tmp451_ = FALSE;
6901 }
6902 if (_tmp451_) {
6903 ValadocGtkdocToken* _tmp454_;
6904 ValadocGtkdocToken* _tmp455_;
6905 _tmp454_ = valadoc_gtkdoc_parser_next (self);
6906 _tmp455_ = _tmp454_;
6907 _valadoc_gtkdoc_token_unref0 (_tmp455_);
6908 } else {
6909 ValadocGtkdocToken* _tmp456_;
6910 ValadocGtkdocTokenType _tmp457_;
6911 _tmp456_ = self->priv->current;
6912 _tmp457_ = _tmp456_->type;
6913 if (_tmp457_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_COMMENT) {
6914 ValadocGtkdocToken* _tmp458_;
6915 ValadocGtkdocToken* _tmp459_;
6916 _tmp458_ = valadoc_gtkdoc_parser_next (self);
6917 _tmp459_ = _tmp458_;
6918 _valadoc_gtkdoc_token_unref0 (_tmp459_);
6919 } else {
6920 break;
6921 }
6922 }
6923 }
6924 }
6925 }
6926 }
6927 }
6928 }
6929 }
6930 }
6931 }
6932 }
6933 }
6934 }
6935 }
6936 }
6937 }
6938 }
6939 }
6940 }
6941 }
6942 }
6943 }
6944 }
6945 }
6946 }
6947 }
6948 }
6949 }
6950 }
6951 }
6952 }
6953 }
6954 }
6955 }
6956 }
6957 }
6958 }
6959 }
6960 }
6961 }
6962 }
6963 }
6964 }
6965 }
6966 }
6967 result = run;
6968 return result;
6969 }
6970
6971 static gchar*
valadoc_gtkdoc_parser_real_resolve(ValadocResourceLocator * base,const gchar * path)6972 valadoc_gtkdoc_parser_real_resolve (ValadocResourceLocator* base,
6973 const gchar* path)
6974 {
6975 ValadocGtkdocParser * self;
6976 gchar* _tmp0_;
6977 gchar* result = NULL;
6978 self = (ValadocGtkdocParser*) base;
6979 g_return_val_if_fail (path != NULL, NULL);
6980 _tmp0_ = g_strdup (path);
6981 result = _tmp0_;
6982 return result;
6983 }
6984
6985 static void
valadoc_gtkdoc_parser_class_init(ValadocGtkdocParserClass * klass,gpointer klass_data)6986 valadoc_gtkdoc_parser_class_init (ValadocGtkdocParserClass * klass,
6987 gpointer klass_data)
6988 {
6989 valadoc_gtkdoc_parser_parent_class = g_type_class_peek_parent (klass);
6990 g_type_class_adjust_private_offset (klass, &ValadocGtkdocParser_private_offset);
6991 G_OBJECT_CLASS (klass)->finalize = valadoc_gtkdoc_parser_finalize;
6992 }
6993
6994 static void
valadoc_gtkdoc_parser_valadoc_resource_locator_interface_init(ValadocResourceLocatorIface * iface,gpointer iface_data)6995 valadoc_gtkdoc_parser_valadoc_resource_locator_interface_init (ValadocResourceLocatorIface * iface,
6996 gpointer iface_data)
6997 {
6998 valadoc_gtkdoc_parser_valadoc_resource_locator_parent_iface = g_type_interface_peek_parent (iface);
6999 iface->resolve = (gchar* (*) (ValadocResourceLocator*, const gchar*)) valadoc_gtkdoc_parser_real_resolve;
7000 }
7001
7002 static void
valadoc_gtkdoc_parser_instance_init(ValadocGtkdocParser * self,gpointer klass)7003 valadoc_gtkdoc_parser_instance_init (ValadocGtkdocParser * self,
7004 gpointer klass)
7005 {
7006 ValadocGtkdocScanner* _tmp0_;
7007 GEqualFunc _tmp1_;
7008 ValaArrayList* _tmp2_;
7009 GEqualFunc _tmp3_;
7010 ValaArrayList* _tmp4_;
7011 self->priv = valadoc_gtkdoc_parser_get_instance_private (self);
7012 _tmp0_ = valadoc_gtkdoc_scanner_new ();
7013 self->priv->scanner = _tmp0_;
7014 _tmp1_ = g_str_equal;
7015 _tmp2_ = vala_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, _tmp1_);
7016 self->priv->stack = (ValaList*) _tmp2_;
7017 _tmp3_ = g_direct_equal;
7018 _tmp4_ = vala_array_list_new (VALA_TYPE_ARRAY_LIST, (GBoxedCopyFunc) vala_iterable_ref, (GDestroyNotify) vala_iterable_unref, _tmp3_);
7019 self->priv->footnotes = (ValaList*) _tmp4_;
7020 self->priv->is_numeric_regex = NULL;
7021 self->priv->normalize_regex = NULL;
7022 self->priv->regex_source_lang = NULL;
7023 self->priv->id_registrar = NULL;
7024 self->priv->current_metadata = NULL;
7025 }
7026
7027 static void
valadoc_gtkdoc_parser_finalize(GObject * obj)7028 valadoc_gtkdoc_parser_finalize (GObject * obj)
7029 {
7030 ValadocGtkdocParser * self;
7031 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALADOC_GTKDOC_TYPE_PARSER, ValadocGtkdocParser);
7032 _valadoc_gtkdoc_scanner_unref0 (self->priv->scanner);
7033 _valadoc_gtkdoc_token_unref0 (self->priv->current);
7034 _vala_iterable_unref0 (self->priv->stack);
7035 _vala_iterable_unref0 (self->priv->footnotes);
7036 _g_object_unref0 (self->priv->factory);
7037 _g_object_unref0 (self->priv->reporter);
7038 _g_object_unref0 (self->priv->settings);
7039 _valadoc_api_tree_unref0 (self->priv->tree);
7040 _g_object_unref0 (self->priv->element);
7041 _valadoc_api_source_comment_unref0 (self->priv->comment);
7042 self->priv->comment_lines = (_vala_array_free (self->priv->comment_lines, self->priv->comment_lines_length1, (GDestroyNotify) g_free), NULL);
7043 _g_regex_unref0 (self->priv->is_numeric_regex);
7044 _g_regex_unref0 (self->priv->normalize_regex);
7045 _g_regex_unref0 (self->priv->regex_source_lang);
7046 _valadoc_importer_internal_id_registrar_unref0 (self->priv->id_registrar);
7047 _g_object_unref0 (self->priv->current_metadata);
7048 G_OBJECT_CLASS (valadoc_gtkdoc_parser_parent_class)->finalize (obj);
7049 }
7050
7051 static GType
valadoc_gtkdoc_parser_get_type_once(void)7052 valadoc_gtkdoc_parser_get_type_once (void)
7053 {
7054 static const GTypeInfo g_define_type_info = { sizeof (ValadocGtkdocParserClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) valadoc_gtkdoc_parser_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValadocGtkdocParser), 0, (GInstanceInitFunc) valadoc_gtkdoc_parser_instance_init, NULL };
7055 static const GInterfaceInfo valadoc_resource_locator_info = { (GInterfaceInitFunc) valadoc_gtkdoc_parser_valadoc_resource_locator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
7056 GType valadoc_gtkdoc_parser_type_id;
7057 valadoc_gtkdoc_parser_type_id = g_type_register_static (G_TYPE_OBJECT, "ValadocGtkdocParser", &g_define_type_info, 0);
7058 g_type_add_interface_static (valadoc_gtkdoc_parser_type_id, VALADOC_TYPE_RESOURCE_LOCATOR, &valadoc_resource_locator_info);
7059 ValadocGtkdocParser_private_offset = g_type_add_instance_private (valadoc_gtkdoc_parser_type_id, sizeof (ValadocGtkdocParserPrivate));
7060 return valadoc_gtkdoc_parser_type_id;
7061 }
7062
7063 GType
valadoc_gtkdoc_parser_get_type(void)7064 valadoc_gtkdoc_parser_get_type (void)
7065 {
7066 static volatile gsize valadoc_gtkdoc_parser_type_id__volatile = 0;
7067 if (g_once_init_enter (&valadoc_gtkdoc_parser_type_id__volatile)) {
7068 GType valadoc_gtkdoc_parser_type_id;
7069 valadoc_gtkdoc_parser_type_id = valadoc_gtkdoc_parser_get_type_once ();
7070 g_once_init_leave (&valadoc_gtkdoc_parser_type_id__volatile, valadoc_gtkdoc_parser_type_id);
7071 }
7072 return valadoc_gtkdoc_parser_type_id__volatile;
7073 }
7074
7075 static void
_vala_array_destroy(gpointer array,gint array_length,GDestroyNotify destroy_func)7076 _vala_array_destroy (gpointer array,
7077 gint array_length,
7078 GDestroyNotify destroy_func)
7079 {
7080 if ((array != NULL) && (destroy_func != NULL)) {
7081 gint i;
7082 for (i = 0; i < array_length; i = i + 1) {
7083 if (((gpointer*) array)[i] != NULL) {
7084 destroy_func (((gpointer*) array)[i]);
7085 }
7086 }
7087 }
7088 }
7089
7090 static void
_vala_array_free(gpointer array,gint array_length,GDestroyNotify destroy_func)7091 _vala_array_free (gpointer array,
7092 gint array_length,
7093 GDestroyNotify destroy_func)
7094 {
7095 _vala_array_destroy (array, array_length, destroy_func);
7096 g_free (array);
7097 }
7098
7099 static gint
_vala_array_length(gpointer array)7100 _vala_array_length (gpointer array)
7101 {
7102 gint length;
7103 length = 0;
7104 if (array) {
7105 while (((gpointer*) array)[length]) {
7106 length++;
7107 }
7108 }
7109 return length;
7110 }
7111
7112