1 /* valagirparser.c generated by valac, the Vala compiler
2  * generated from valagirparser.vala, do not modify */
3 
4 /* valagirparser.vala
5  *
6  * Copyright (C) 2008-2012  Jürg Billeter
7  * Copyright (C) 2011-2014  Luca Bruno
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13 
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18 
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
22  *
23  * Author:
24  * 	Jürg Billeter <j@bitron.ch>
25  * 	Luca Bruno <lucabru@src.gnome.org>
26  */
27 
28 #include "vala.h"
29 #include <glib-object.h>
30 #include <valagee.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <glib.h>
34 #include <float.h>
35 #include <math.h>
36 #include <glib/gstdio.h>
37 #include <gobject/gvaluecollector.h>
38 #include <errno.h>
39 
40 #define VALA_GIR_PARSER_TYPE_NODE (vala_gir_parser_node_get_type ())
41 #define VALA_GIR_PARSER_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_GIR_PARSER_TYPE_NODE, ValaGirParserNode))
42 #define VALA_GIR_PARSER_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_GIR_PARSER_TYPE_NODE, ValaGirParserNodeClass))
43 #define VALA_GIR_PARSER_IS_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_GIR_PARSER_TYPE_NODE))
44 #define VALA_GIR_PARSER_IS_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_GIR_PARSER_TYPE_NODE))
45 #define VALA_GIR_PARSER_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_GIR_PARSER_TYPE_NODE, ValaGirParserNodeClass))
46 
47 typedef struct _ValaGirParserNode ValaGirParserNode;
48 typedef struct _ValaGirParserNodeClass ValaGirParserNodeClass;
49 
50 #define VALA_GIR_PARSER_TYPE_METADATA (vala_gir_parser_metadata_get_type ())
51 #define VALA_GIR_PARSER_METADATA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_GIR_PARSER_TYPE_METADATA, ValaGirParserMetadata))
52 #define VALA_GIR_PARSER_METADATA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_GIR_PARSER_TYPE_METADATA, ValaGirParserMetadataClass))
53 #define VALA_GIR_PARSER_IS_METADATA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_GIR_PARSER_TYPE_METADATA))
54 #define VALA_GIR_PARSER_IS_METADATA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_GIR_PARSER_TYPE_METADATA))
55 #define VALA_GIR_PARSER_METADATA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_GIR_PARSER_TYPE_METADATA, ValaGirParserMetadataClass))
56 
57 typedef struct _ValaGirParserMetadata ValaGirParserMetadata;
58 typedef struct _ValaGirParserMetadataClass ValaGirParserMetadataClass;
59 typedef enum  {
60 	VALA_GIR_PARSER_ARGUMENT_TYPE_SKIP,
61 	VALA_GIR_PARSER_ARGUMENT_TYPE_HIDDEN,
62 	VALA_GIR_PARSER_ARGUMENT_TYPE_NEW,
63 	VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE,
64 	VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ARGUMENTS,
65 	VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME,
66 	VALA_GIR_PARSER_ARGUMENT_TYPE_NAME,
67 	VALA_GIR_PARSER_ARGUMENT_TYPE_OWNED,
68 	VALA_GIR_PARSER_ARGUMENT_TYPE_UNOWNED,
69 	VALA_GIR_PARSER_ARGUMENT_TYPE_PARENT,
70 	VALA_GIR_PARSER_ARGUMENT_TYPE_NULLABLE,
71 	VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED,
72 	VALA_GIR_PARSER_ARGUMENT_TYPE_REPLACEMENT,
73 	VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED_SINCE,
74 	VALA_GIR_PARSER_ARGUMENT_TYPE_SINCE,
75 	VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY,
76 	VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_IDX,
77 	VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_NULL_TERMINATED,
78 	VALA_GIR_PARSER_ARGUMENT_TYPE_DEFAULT,
79 	VALA_GIR_PARSER_ARGUMENT_TYPE_OUT,
80 	VALA_GIR_PARSER_ARGUMENT_TYPE_REF,
81 	VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME,
82 	VALA_GIR_PARSER_ARGUMENT_TYPE_VIRTUAL,
83 	VALA_GIR_PARSER_ARGUMENT_TYPE_ABSTRACT,
84 	VALA_GIR_PARSER_ARGUMENT_TYPE_COMPACT,
85 	VALA_GIR_PARSER_ARGUMENT_TYPE_SEALED,
86 	VALA_GIR_PARSER_ARGUMENT_TYPE_SCOPE,
87 	VALA_GIR_PARSER_ARGUMENT_TYPE_STRUCT,
88 	VALA_GIR_PARSER_ARGUMENT_TYPE_THROWS,
89 	VALA_GIR_PARSER_ARGUMENT_TYPE_PRINTF_FORMAT,
90 	VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_FIELD,
91 	VALA_GIR_PARSER_ARGUMENT_TYPE_SENTINEL,
92 	VALA_GIR_PARSER_ARGUMENT_TYPE_CLOSURE,
93 	VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROY,
94 	VALA_GIR_PARSER_ARGUMENT_TYPE_CPREFIX,
95 	VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CPREFIX,
96 	VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CSUFFIX,
97 	VALA_GIR_PARSER_ARGUMENT_TYPE_ERRORDOMAIN,
98 	VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROYS_INSTANCE,
99 	VALA_GIR_PARSER_ARGUMENT_TYPE_BASE_TYPE,
100 	VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_NAME,
101 	VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_INSTANCE,
102 	VALA_GIR_PARSER_ARGUMENT_TYPE_SYMBOL_TYPE,
103 	VALA_GIR_PARSER_ARGUMENT_TYPE_INSTANCE_IDX,
104 	VALA_GIR_PARSER_ARGUMENT_TYPE_EXPERIMENTAL,
105 	VALA_GIR_PARSER_ARGUMENT_TYPE_FEATURE_TEST_MACRO,
106 	VALA_GIR_PARSER_ARGUMENT_TYPE_FLOATING,
107 	VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ID,
108 	VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_GET_FUNCTION,
109 	VALA_GIR_PARSER_ARGUMENT_TYPE_RETURN_VOID,
110 	VALA_GIR_PARSER_ARGUMENT_TYPE_RETURNS_MODIFIED_POINTER,
111 	VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET_CNAME,
112 	VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROY_NOTIFY_CNAME,
113 	VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_VFUNC_NAME,
114 	VALA_GIR_PARSER_ARGUMENT_TYPE_NO_ACCESSOR_METHOD,
115 	VALA_GIR_PARSER_ARGUMENT_TYPE_NO_WRAPPER,
116 	VALA_GIR_PARSER_ARGUMENT_TYPE_CNAME,
117 	VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET,
118 	VALA_GIR_PARSER_ARGUMENT_TYPE_CTYPE
119 } ValaGirParserArgumentType;
120 
121 #define VALA_GIR_PARSER_TYPE_ARGUMENT_TYPE (vala_gir_parser_argument_type_get_type ())
122 #define _g_free0(var) (var = (g_free (var), NULL))
123 #define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
124 #define _g_type_class_unref0(var) ((var == NULL) ? NULL : (var = (g_type_class_unref (var), NULL)))
125 #define _vala_markup_reader_unref0(var) ((var == NULL) ? NULL : (var = (vala_markup_reader_unref (var), NULL)))
126 #define _vala_code_context_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_context_unref (var), NULL)))
127 #define _vala_source_file_unref0(var) ((var == NULL) ? NULL : (var = (vala_source_file_unref (var), NULL)))
128 #define _vala_gir_parser_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_gir_parser_node_unref (var), NULL)))
129 #define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
130 #define _vala_gir_parser_metadata_unref0(var) ((var == NULL) ? NULL : (var = (vala_gir_parser_metadata_unref (var), NULL)))
131 #define _vala_map_unref0(var) ((var == NULL) ? NULL : (var = (vala_map_unref (var), NULL)))
132 typedef struct _ValaGirParserNodePrivate ValaGirParserNodePrivate;
133 
134 #define VALA_GIR_PARSER_TYPE_PARAMETER_INFO (vala_gir_parser_parameter_info_get_type ())
135 #define VALA_GIR_PARSER_PARAMETER_INFO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_GIR_PARSER_TYPE_PARAMETER_INFO, ValaGirParserParameterInfo))
136 #define VALA_GIR_PARSER_PARAMETER_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_GIR_PARSER_TYPE_PARAMETER_INFO, ValaGirParserParameterInfoClass))
137 #define VALA_GIR_PARSER_IS_PARAMETER_INFO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_GIR_PARSER_TYPE_PARAMETER_INFO))
138 #define VALA_GIR_PARSER_IS_PARAMETER_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_GIR_PARSER_TYPE_PARAMETER_INFO))
139 #define VALA_GIR_PARSER_PARAMETER_INFO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_GIR_PARSER_TYPE_PARAMETER_INFO, ValaGirParserParameterInfoClass))
140 
141 typedef struct _ValaGirParserParameterInfo ValaGirParserParameterInfo;
142 typedef struct _ValaGirParserParameterInfoClass ValaGirParserParameterInfoClass;
143 #define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
144 #define _vala_source_reference_unref0(var) ((var == NULL) ? NULL : (var = (vala_source_reference_unref (var), NULL)))
145 #define _vala_iterator_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterator_unref (var), NULL)))
146 #define _g_string_free0(var) ((var == NULL) ? NULL : (var = (g_string_free (var, TRUE), NULL)))
147 #define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
148 #define _g_match_info_unref0(var) ((var == NULL) ? NULL : (var = (g_match_info_unref (var), NULL)))
149 typedef struct _ValaGirParserParameterInfoPrivate ValaGirParserParameterInfoPrivate;
150 
151 #define VALA_GIR_PARSER_TYPE_METADATA_PARSER (vala_gir_parser_metadata_parser_get_type ())
152 #define VALA_GIR_PARSER_METADATA_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_GIR_PARSER_TYPE_METADATA_PARSER, ValaGirParserMetadataParser))
153 #define VALA_GIR_PARSER_METADATA_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_GIR_PARSER_TYPE_METADATA_PARSER, ValaGirParserMetadataParserClass))
154 #define VALA_GIR_PARSER_IS_METADATA_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_GIR_PARSER_TYPE_METADATA_PARSER))
155 #define VALA_GIR_PARSER_IS_METADATA_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_GIR_PARSER_TYPE_METADATA_PARSER))
156 #define VALA_GIR_PARSER_METADATA_PARSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_GIR_PARSER_TYPE_METADATA_PARSER, ValaGirParserMetadataParserClass))
157 
158 typedef struct _ValaGirParserMetadataParser ValaGirParserMetadataParser;
159 typedef struct _ValaGirParserMetadataParserClass ValaGirParserMetadataParserClass;
160 #define _vala_gir_parser_metadata_parser_unref0(var) ((var == NULL) ? NULL : (var = (vala_gir_parser_metadata_parser_unref (var), NULL)))
161 #define _vala_comment_unref0(var) ((var == NULL) ? NULL : (var = (vala_comment_unref (var), NULL)))
162 #define _vala_gir_parser_parameter_info_unref0(var) ((var == NULL) ? NULL : (var = (vala_gir_parser_parameter_info_unref (var), NULL)))
163 typedef struct _ValaGirParserMetadataPrivate ValaGirParserMetadataPrivate;
164 
165 #define VALA_GIR_PARSER_TYPE_ARGUMENT (vala_gir_parser_argument_get_type ())
166 #define VALA_GIR_PARSER_ARGUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_GIR_PARSER_TYPE_ARGUMENT, ValaGirParserArgument))
167 #define VALA_GIR_PARSER_ARGUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_GIR_PARSER_TYPE_ARGUMENT, ValaGirParserArgumentClass))
168 #define VALA_GIR_PARSER_IS_ARGUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_GIR_PARSER_TYPE_ARGUMENT))
169 #define VALA_GIR_PARSER_IS_ARGUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_GIR_PARSER_TYPE_ARGUMENT))
170 #define VALA_GIR_PARSER_ARGUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_GIR_PARSER_TYPE_ARGUMENT, ValaGirParserArgumentClass))
171 
172 typedef struct _ValaGirParserArgument ValaGirParserArgument;
173 typedef struct _ValaGirParserArgumentClass ValaGirParserArgumentClass;
174 typedef struct _ValaGirParserArgumentPrivate ValaGirParserArgumentPrivate;
175 #define _vala_gir_parser_argument_unref0(var) ((var == NULL) ? NULL : (var = (vala_gir_parser_argument_unref (var), NULL)))
176 #define _vala_map_iterator_unref0(var) ((var == NULL) ? NULL : (var = (vala_map_iterator_unref (var), NULL)))
177 typedef struct _ValaGirParserParamSpecArgument ValaGirParserParamSpecArgument;
178 
179 #define VALA_GIR_PARSER_TYPE_METADATA_SET (vala_gir_parser_metadata_set_get_type ())
180 #define VALA_GIR_PARSER_METADATA_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_GIR_PARSER_TYPE_METADATA_SET, ValaGirParserMetadataSet))
181 #define VALA_GIR_PARSER_METADATA_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_GIR_PARSER_TYPE_METADATA_SET, ValaGirParserMetadataSetClass))
182 #define VALA_GIR_PARSER_IS_METADATA_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_GIR_PARSER_TYPE_METADATA_SET))
183 #define VALA_GIR_PARSER_IS_METADATA_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_GIR_PARSER_TYPE_METADATA_SET))
184 #define VALA_GIR_PARSER_METADATA_SET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_GIR_PARSER_TYPE_METADATA_SET, ValaGirParserMetadataSetClass))
185 
186 typedef struct _ValaGirParserMetadataSet ValaGirParserMetadataSet;
187 typedef struct _ValaGirParserMetadataSetClass ValaGirParserMetadataSetClass;
188 typedef struct _ValaGirParserMetadataSetPrivate ValaGirParserMetadataSetPrivate;
189 #define _g_pattern_spec_free0(var) ((var == NULL) ? NULL : (var = (g_pattern_spec_free (var), NULL)))
190 typedef struct _ValaGirParserParamSpecMetadata ValaGirParserParamSpecMetadata;
191 typedef struct _ValaGirParserMetadataParserPrivate ValaGirParserMetadataParserPrivate;
192 #define _vala_scanner_unref0(var) ((var == NULL) ? NULL : (var = (vala_scanner_unref (var), NULL)))
193 typedef struct _ValaGirParserParamSpecMetadataParser ValaGirParserParamSpecMetadataParser;
194 typedef struct _ValaGirParserParamSpecNode ValaGirParserParamSpecNode;
195 typedef struct _ValaGirParserParamSpecParameterInfo ValaGirParserParamSpecParameterInfo;
196 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
197 #define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
198 #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; }
199 #define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
200 
201 struct _ValaGirParserPrivate {
202 	ValaMarkupReader* reader;
203 	ValaCodeContext* context;
204 	ValaSourceFile* current_source_file;
205 	ValaGirParserNode* root;
206 	ValaArrayList* metadata_roots;
207 	ValaSourceLocation begin;
208 	ValaSourceLocation end;
209 	ValaMarkupTokenType current_token;
210 	gchar** cheader_filenames;
211 	gint cheader_filenames_length1;
212 	gint _cheader_filenames_size_;
213 	ValaArrayList* metadata_stack;
214 	ValaGirParserMetadata* metadata;
215 	ValaArrayList* tree_stack;
216 	ValaGirParserNode* current;
217 	ValaGirParserNode* old_current;
218 	ValaSet* provided_namespaces;
219 	ValaHashMap* unresolved_symbols_map;
220 	ValaArrayList* unresolved_gir_symbols;
221 	ValaHashMap* unresolved_type_arguments;
222 	ValaArrayList* ifaces_needing_object_prereq;
223 };
224 
225 struct _ValaGirParserNode {
226 	GTypeInstance parent_instance;
227 	volatile int ref_count;
228 	ValaGirParserNode* parent;
229 	gchar* element_type;
230 	gchar* name;
231 	ValaMap* girdata;
232 	ValaGirParserMetadata* metadata;
233 	ValaSourceReference* source_reference;
234 	ValaArrayList* members;
235 	ValaHashMap* scope;
236 	ValaGirComment* comment;
237 	ValaSymbol* symbol;
238 	gboolean new_symbol;
239 	gboolean merged;
240 	gboolean processed;
241 	gint return_array_length_idx;
242 	ValaList* parameters;
243 	ValaArrayList* array_length_parameters;
244 	ValaArrayList* closure_parameters;
245 	ValaArrayList* destroy_parameters;
246 	ValaUnresolvedSymbol* gtype_struct_for;
247 	ValaUnresolvedSymbol* type_struct;
248 	ValaDataType* base_type;
249 	gint array_length_idx;
250 	gboolean deprecated;
251 	guint64 deprecated_version;
252 	gchar* deprecated_since;
253 	gchar* deprecated_replacement;
254 	ValaGirParserNodePrivate * priv;
255 };
256 
257 struct _ValaGirParserNodeClass {
258 	GTypeClass parent_class;
259 	void (*finalize) (ValaGirParserNode *self);
260 };
261 
262 struct _ValaGirParserParameterInfo {
263 	GTypeInstance parent_instance;
264 	volatile int ref_count;
265 	ValaParameter* param;
266 	gfloat vala_idx;
267 	gint array_length_idx;
268 	gint closure_idx;
269 	gint destroy_idx;
270 	gboolean keep;
271 	gboolean is_async;
272 	gboolean is_async_result;
273 	gboolean is_error;
274 	ValaGirParserParameterInfoPrivate * priv;
275 };
276 
277 struct _ValaGirParserParameterInfoClass {
278 	GTypeClass parent_class;
279 	void (*finalize) (ValaGirParserParameterInfo *self);
280 };
281 
282 struct _ValaGirParserMetadata {
283 	GTypeInstance parent_instance;
284 	volatile int ref_count;
285 	GPatternSpec* pattern_spec;
286 	gchar* selector;
287 	ValaSourceReference* source_reference;
288 	gboolean used;
289 	ValaMap* args;
290 	ValaArrayList* children;
291 	ValaGirParserMetadataPrivate * priv;
292 };
293 
294 struct _ValaGirParserMetadataClass {
295 	GTypeClass parent_class;
296 	void (*finalize) (ValaGirParserMetadata *self);
297 };
298 
299 struct _ValaGirParserArgument {
300 	GTypeInstance parent_instance;
301 	volatile int ref_count;
302 	ValaExpression* expression;
303 	ValaSourceReference* source_reference;
304 	gboolean used;
305 	ValaGirParserArgumentPrivate * priv;
306 };
307 
308 struct _ValaGirParserArgumentClass {
309 	GTypeClass parent_class;
310 	void (*finalize) (ValaGirParserArgument *self);
311 };
312 
313 struct _ValaGirParserParamSpecArgument {
314 	GParamSpec parent_instance;
315 };
316 
317 struct _ValaGirParserMetadataSet {
318 	ValaGirParserMetadata parent_instance;
319 	ValaGirParserMetadataSetPrivate * priv;
320 };
321 
322 struct _ValaGirParserMetadataSetClass {
323 	ValaGirParserMetadataClass parent_class;
324 };
325 
326 struct _ValaGirParserParamSpecMetadata {
327 	GParamSpec parent_instance;
328 };
329 
330 struct _ValaGirParserMetadataParser {
331 	GTypeInstance parent_instance;
332 	volatile int ref_count;
333 	ValaGirParserMetadataParserPrivate * priv;
334 };
335 
336 struct _ValaGirParserMetadataParserClass {
337 	GTypeClass parent_class;
338 	void (*finalize) (ValaGirParserMetadataParser *self);
339 };
340 
341 struct _ValaGirParserMetadataParserPrivate {
342 	ValaGirParserMetadata* tree;
343 	ValaScanner* scanner;
344 	ValaSourceLocation begin;
345 	ValaSourceLocation end;
346 	ValaSourceLocation old_end;
347 	ValaTokenType current;
348 	ValaGirParserMetadata* parent_metadata;
349 };
350 
351 struct _ValaGirParserParamSpecMetadataParser {
352 	GParamSpec parent_instance;
353 };
354 
355 struct _ValaGirParserParamSpecNode {
356 	GParamSpec parent_instance;
357 };
358 
359 struct _ValaGirParserParamSpecParameterInfo {
360 	GParamSpec parent_instance;
361 };
362 
363 static gint ValaGirParser_private_offset;
364 static gpointer vala_gir_parser_parent_class = NULL;
365 static GRegex* vala_gir_parser_type_from_string_regex;
366 static GRegex* vala_gir_parser_type_from_string_regex = NULL;
367 static ValaArrayList* vala_gir_parser_node_new_namespaces;
368 static gpointer vala_gir_parser_argument_parent_class = NULL;
369 static gpointer vala_gir_parser_metadata_set_parent_class = NULL;
370 static gpointer vala_gir_parser_metadata_parent_class = NULL;
371 static ValaGirParserMetadata* vala_gir_parser_metadata__empty;
372 static ValaGirParserMetadata* vala_gir_parser_metadata__empty = NULL;
373 static gint ValaGirParserMetadataParser_private_offset;
374 static gpointer vala_gir_parser_metadata_parser_parent_class = NULL;
375 static gpointer vala_gir_parser_node_parent_class = NULL;
376 static ValaArrayList* vala_gir_parser_node_new_namespaces = NULL;
377 static gpointer vala_gir_parser_parameter_info_parent_class = NULL;
378 
379 static gpointer vala_gir_parser_node_ref (gpointer instance);
380 static void vala_gir_parser_node_unref (gpointer instance);
381 static GParamSpec* vala_gir_parser_param_spec_node (const gchar* name,
382                                              const gchar* nick,
383                                              const gchar* blurb,
384                                              GType object_type,
385                                              GParamFlags flags) G_GNUC_UNUSED;
386 static void vala_gir_parser_value_set_node (GValue* value,
387                                      gpointer v_object) G_GNUC_UNUSED;
388 static void vala_gir_parser_value_take_node (GValue* value,
389                                       gpointer v_object) G_GNUC_UNUSED;
390 static gpointer vala_gir_parser_value_get_node (const GValue* value) G_GNUC_UNUSED;
391 static GType vala_gir_parser_node_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
392 static gpointer vala_gir_parser_metadata_ref (gpointer instance);
393 static void vala_gir_parser_metadata_unref (gpointer instance);
394 static GParamSpec* vala_gir_parser_param_spec_metadata (const gchar* name,
395                                                  const gchar* nick,
396                                                  const gchar* blurb,
397                                                  GType object_type,
398                                                  GParamFlags flags) G_GNUC_UNUSED;
399 static void vala_gir_parser_value_set_metadata (GValue* value,
400                                          gpointer v_object) G_GNUC_UNUSED;
401 static void vala_gir_parser_value_take_metadata (GValue* value,
402                                           gpointer v_object) G_GNUC_UNUSED;
403 static gpointer vala_gir_parser_value_get_metadata (const GValue* value) G_GNUC_UNUSED;
404 static GType vala_gir_parser_metadata_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
405 static GType vala_gir_parser_argument_type_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
406 static ValaGirParserArgumentType* vala_gir_parser_argument_type_from_string (const gchar* name);
407 static ValaGirParserArgumentType* _vala_gir_parser_argument_type_dup (ValaGirParserArgumentType* self);
408 #define VALA_GIR_PARSER_GIR_VERSION "1.2"
409 static guint vala_gir_parser_unresolved_symbol_hash (ValaUnresolvedSymbol* sym);
410 static guint _vala_gir_parser_unresolved_symbol_hash_ghash_func (gconstpointer key);
411 static gboolean vala_gir_parser_unresolved_symbol_equal (ValaUnresolvedSymbol* sym1,
412                                                   ValaUnresolvedSymbol* sym2);
413 static gboolean _vala_gir_parser_unresolved_symbol_equal_gequal_func (gconstpointer a,
414                                                                gconstpointer b);
415 static ValaGirParserNode* vala_gir_parser_node_new (const gchar* name);
416 static ValaGirParserNode* vala_gir_parser_node_construct (GType object_type,
417                                                    const gchar* name);
418 static gpointer vala_gir_parser_parameter_info_ref (gpointer instance);
419 static void vala_gir_parser_parameter_info_unref (gpointer instance);
420 static GParamSpec* vala_gir_parser_param_spec_parameter_info (const gchar* name,
421                                                        const gchar* nick,
422                                                        const gchar* blurb,
423                                                        GType object_type,
424                                                        GParamFlags flags) G_GNUC_UNUSED;
425 static void vala_gir_parser_value_set_parameter_info (GValue* value,
426                                                gpointer v_object) G_GNUC_UNUSED;
427 static void vala_gir_parser_value_take_parameter_info (GValue* value,
428                                                 gpointer v_object) G_GNUC_UNUSED;
429 static gpointer vala_gir_parser_value_get_parameter_info (const GValue* value) G_GNUC_UNUSED;
430 static GType vala_gir_parser_parameter_info_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
431 static void vala_gir_parser_map_vala_to_gir (ValaGirParser* self);
432 static void vala_gir_parser_resolve_gir_symbols (ValaGirParser* self);
433 static void vala_gir_parser_create_new_namespaces (ValaGirParser* self);
434 static void vala_gir_parser_resolve_type_arguments (ValaGirParser* self);
435 static void vala_gir_parser_node_process (ValaGirParserNode* self,
436                                    ValaGirParser* parser);
437 static void vala_gir_parser_report_unused_metadata (ValaGirParser* self,
438                                              ValaGirParserMetadata* metadata);
439 static void vala_gir_parser_set_symbol_mapping (ValaGirParser* self,
440                                          ValaUnresolvedSymbol* map_from,
441                                          ValaSymbol* map_to);
442 static void vala_gir_parser_real_visit_source_file (ValaCodeVisitor* base,
443                                              ValaSourceFile* source_file);
444 static ValaGirParserMetadata* vala_gir_parser_metadata_get_empty (void);
445 static void vala_gir_parser_next (ValaGirParser* self);
446 static ValaSourceReference* vala_gir_parser_get_current_src (ValaGirParser* self);
447 static void vala_gir_parser_parse_repository (ValaGirParser* self);
448 static void vala_gir_parser_start_element (ValaGirParser* self,
449                                     const gchar* name);
450 static void vala_gir_parser_end_element (ValaGirParser* self,
451                                   const gchar* name);
452 static void vala_gir_parser_skip_element (ValaGirParser* self);
453 static ValaSourceReference* vala_gir_parser_get_src (ValaGirParser* self,
454                                               ValaSourceLocation* begin,
455                                               ValaSourceLocation* end);
456 static void vala_gir_parser_add_symbol_to_container (ValaSymbol* container,
457                                               ValaSymbol* sym);
458 static gboolean vala_gir_parser_is_container (ValaSymbol* sym);
459 static ValaUnresolvedSymbol* vala_gir_parser_parse_symbol_from_string (ValaGirParser* self,
460                                                                 const gchar* symbol_string,
461                                                                 ValaSourceReference* source_reference);
462 static void vala_gir_parser_assume_parameter_names (ValaGirParser* self,
463                                              ValaSignal* sig,
464                                              ValaSymbol* sym,
465                                              gboolean skip_first);
466 static ValaGirParserNode* vala_gir_parser_find_invoker (ValaGirParser* self,
467                                                  ValaGirParserNode* node);
468 static ValaGirParserMetadata* vala_gir_parser_get_current_metadata (ValaGirParser* self);
469 static ValaGirParserMetadata* vala_gir_parser_metadata_match_child (ValaGirParserMetadata* self,
470                                                              const gchar* name,
471                                                              const gchar* selector);
472 static gboolean vala_gir_parser_push_metadata (ValaGirParser* self);
473 static gboolean vala_gir_parser_metadata_has_argument (ValaGirParserMetadata* self,
474                                                 ValaGirParserArgumentType key);
475 static gboolean vala_gir_parser_metadata_get_bool (ValaGirParserMetadata* self,
476                                             ValaGirParserArgumentType arg,
477                                             gboolean default_value);
478 static void vala_gir_parser_pop_metadata (ValaGirParser* self);
479 static gboolean vala_gir_parser_parse_type_arguments_from_string (ValaGirParser* self,
480                                                            ValaDataType* parent_type,
481                                                            const gchar* type_arguments,
482                                                            ValaSourceReference* source_reference);
483 static ValaDataType* vala_gir_parser_parse_type_from_string (ValaGirParser* self,
484                                                       const gchar* type_string,
485                                                       gboolean owned_by_default,
486                                                       ValaSourceReference* source_reference);
487 static gchar* vala_gir_parser_element_get_string (ValaGirParser* self,
488                                            const gchar* attribute_name,
489                                            ValaGirParserArgumentType arg_type);
490 static gchar* vala_gir_parser_metadata_get_string (ValaGirParserMetadata* self,
491                                             ValaGirParserArgumentType arg);
492 static ValaDataType* vala_gir_parser_element_get_type (ValaGirParser* self,
493                                                 ValaDataType* orig_type,
494                                                 gboolean owned_by_default,
495                                                 gboolean* no_array_length,
496                                                 gboolean* array_null_terminated,
497                                                 gboolean* changed);
498 static ValaSourceReference* vala_gir_parser_metadata_get_source_reference (ValaGirParserMetadata* self,
499                                                                     ValaGirParserArgumentType arg);
500 static gchar* vala_gir_parser_element_get_name (ValaGirParser* self,
501                                          const gchar* gir_name);
502 static gchar* vala_gir_parser_element_get_type_id (ValaGirParser* self);
503 static void vala_gir_parser_set_array_ccode (ValaGirParser* self,
504                                       ValaSymbol* sym,
505                                       ValaGirParserParameterInfo* info);
506 static ValaGirParserNode* vala_gir_parser_node_lookup (ValaGirParserNode* self,
507                                                 const gchar* name,
508                                                 gboolean create_namespace,
509                                                 ValaSourceReference* source_reference);
510 static gchar* vala_gir_parser_node_get_cname (ValaGirParserNode* self);
511 static void vala_gir_parser_set_type_id_ccode (ValaGirParser* self,
512                                         ValaSymbol* sym);
513 static void vala_gir_parser_parse_namespace (ValaGirParser* self);
514 static void vala_gir_parser_parse_include (ValaGirParser* self);
515 static gchar* vala_gir_parser_parse_package (ValaGirParser* self);
516 static void vala_gir_parser_parse_c_include (ValaGirParser* self);
517 static void _vala_array_add1 (gchar** * array,
518                        gint* length,
519                        gint* size,
520                        gchar* value);
521 static ValaGirParserNode* vala_gir_parser_resolve_node (ValaGirParser* self,
522                                                  ValaGirParserNode* parent_scope,
523                                                  ValaUnresolvedSymbol* unresolved_sym,
524                                                  gboolean create_namespace);
525 static ValaSymbol* vala_gir_parser_resolve_symbol (ValaGirParser* self,
526                                             ValaGirParserNode* parent_scope,
527                                             ValaUnresolvedSymbol* unresolved_sym);
528 static void vala_gir_parser_push_node (ValaGirParser* self,
529                                 const gchar* name,
530                                 gboolean merge);
531 static void vala_gir_parser_node_add_member (ValaGirParserNode* self,
532                                       ValaGirParserNode* node);
533 static gchar* vala_gir_parser_node_get_gir_name (ValaGirParserNode* self);
534 static ValaUnresolvedSymbol* vala_gir_parser_node_get_unresolved_symbol (ValaGirParserNode* self);
535 static void vala_gir_parser_pop_node (ValaGirParser* self);
536 static gpointer vala_gir_parser_metadata_parser_ref (gpointer instance);
537 static void vala_gir_parser_metadata_parser_unref (gpointer instance);
538 static GParamSpec* vala_gir_parser_param_spec_metadata_parser (const gchar* name,
539                                                         const gchar* nick,
540                                                         const gchar* blurb,
541                                                         GType object_type,
542                                                         GParamFlags flags) G_GNUC_UNUSED;
543 static void vala_gir_parser_value_set_metadata_parser (GValue* value,
544                                                 gpointer v_object) G_GNUC_UNUSED;
545 static void vala_gir_parser_value_take_metadata_parser (GValue* value,
546                                                  gpointer v_object) G_GNUC_UNUSED;
547 static gpointer vala_gir_parser_value_get_metadata_parser (const GValue* value) G_GNUC_UNUSED;
548 static GType vala_gir_parser_metadata_parser_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
549 static ValaGirParserMetadataParser* vala_gir_parser_metadata_parser_new (void);
550 static ValaGirParserMetadataParser* vala_gir_parser_metadata_parser_construct (GType object_type);
551 static ValaGirParserMetadata* vala_gir_parser_metadata_parser_parse_metadata (ValaGirParserMetadataParser* self,
552                                                                        ValaSourceFile* metadata_file);
553 static void _vala_code_node_unref0_ (gpointer var);
554 static inline void _g_list_free__vala_code_node_unref0_ (GList* self);
555 static void vala_gir_parser_parse_alias (ValaGirParser* self);
556 static void vala_gir_parser_parse_error_domain (ValaGirParser* self);
557 static void vala_gir_parser_parse_enumeration (ValaGirParser* self,
558                                         const gchar* element_name,
559                                         gboolean error_domain);
560 static void vala_gir_parser_parse_bitfield (ValaGirParser* self);
561 static void vala_gir_parser_parse_method (ValaGirParser* self,
562                                    const gchar* element_name);
563 static void vala_gir_parser_parse_callback (ValaGirParser* self);
564 static void vala_gir_parser_parse_record (ValaGirParser* self);
565 static void vala_gir_parser_parse_boxed (ValaGirParser* self,
566                                   const gchar* element_name);
567 static void vala_gir_parser_parse_class (ValaGirParser* self);
568 static void vala_gir_parser_parse_interface (ValaGirParser* self);
569 static void vala_gir_parser_parse_union (ValaGirParser* self);
570 static void vala_gir_parser_parse_constant (ValaGirParser* self);
571 static ValaGirComment* vala_gir_parser_parse_symbol_doc (ValaGirParser* self);
572 static ValaDataType* vala_gir_parser_parse_type (ValaGirParser* self,
573                                           gchar* * ctype,
574                                           gint* array_length_idx,
575                                           gboolean transfer_elements,
576                                           gboolean* no_array_length,
577                                           gboolean* array_null_terminated);
578 static void vala_gir_parser_calculate_common_prefix (ValaGirParser* self,
579                                               gchar* * common_prefix,
580                                               const gchar* cname);
581 static ValaComment* vala_gir_parser_parse_doc (ValaGirParser* self);
582 static void vala_gir_parser_parse_error_member (ValaGirParser* self);
583 static void vala_gir_parser_parse_enumeration_member (ValaGirParser* self);
584 static ValaExpression* vala_gir_parser_metadata_get_expression (ValaGirParserMetadata* self,
585                                                          ValaGirParserArgumentType arg);
586 static ValaDataType* vala_gir_parser_parse_return_value (ValaGirParser* self,
587                                                   gchar* * ctype,
588                                                   gint* array_length_idx,
589                                                   gboolean* no_array_length,
590                                                   gboolean* array_null_terminated,
591                                                   ValaComment* * comment);
592 static ValaParameter* vala_gir_parser_parse_parameter (ValaGirParser* self,
593                                                 gint* array_length_idx,
594                                                 gint* closure_idx,
595                                                 gint* destroy_idx,
596                                                 gchar* * scope,
597                                                 ValaComment* * comment,
598                                                 const gchar* default_name);
599 static gint vala_gir_parser_metadata_get_integer (ValaGirParserMetadata* self,
600                                            ValaGirParserArgumentType arg);
601 static ValaDataType* vala_gir_parser_parse_type_from_gir_name (ValaGirParser* self,
602                                                         const gchar* type_name,
603                                                         gboolean* no_array_length,
604                                                         gboolean* array_null_terminated,
605                                                         const gchar* ctype);
606 static void vala_gir_parser_parse_field (ValaGirParser* self);
607 static void vala_gir_parser_parse_constructor (ValaGirParser* self);
608 static ValaProperty* vala_gir_parser_parse_property (ValaGirParser* self);
609 static void vala_gir_parser_parse_signal (ValaGirParser* self);
610 static void vala_gir_parser_parse_function (ValaGirParser* self,
611                                      const gchar* element_name);
612 G_GNUC_INTERNAL void vala_gir_comment_add_content_for_parameter (ValaGirComment* self,
613                                                  const gchar* name,
614                                                  ValaComment* comment);
615 static ValaGirParserParameterInfo* vala_gir_parser_parameter_info_new (ValaParameter* param,
616                                                                 gint array_length_idx,
617                                                                 gint closure_idx,
618                                                                 gint destroy_idx,
619                                                                 gboolean is_async);
620 static ValaGirParserParameterInfo* vala_gir_parser_parameter_info_construct (GType object_type,
621                                                                       ValaParameter* param,
622                                                                       gint array_length_idx,
623                                                                       gint closure_idx,
624                                                                       gint destroy_idx,
625                                                                       gboolean is_async);
626 static gpointer vala_gir_parser_argument_ref (gpointer instance);
627 static void vala_gir_parser_argument_unref (gpointer instance);
628 static GParamSpec* vala_gir_parser_param_spec_argument (const gchar* name,
629                                                  const gchar* nick,
630                                                  const gchar* blurb,
631                                                  GType object_type,
632                                                  GParamFlags flags) G_GNUC_UNUSED;
633 static void vala_gir_parser_value_set_argument (GValue* value,
634                                          gpointer v_object) G_GNUC_UNUSED;
635 static void vala_gir_parser_value_take_argument (GValue* value,
636                                           gpointer v_object) G_GNUC_UNUSED;
637 static gpointer vala_gir_parser_value_get_argument (const GValue* value) G_GNUC_UNUSED;
638 static GType vala_gir_parser_argument_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
639 static void vala_gir_parser_process_interface (ValaGirParser* self,
640                                         ValaGirParserNode* iface_node);
641 static void vala_gir_parser_process_alias (ValaGirParser* self,
642                                     ValaGirParserNode* alias);
643 static gchar* vala_gir_parser_node_get_full_name (ValaGirParserNode* self);
644 static void vala_gir_parser_process_callable (ValaGirParser* self,
645                                        ValaGirParserNode* node);
646 static void vala_gir_parser_find_parent (ValaGirParser* self,
647                                   const gchar* cname,
648                                   ValaGirParserNode* current,
649                                   ValaGirParserNode* * best,
650                                   gint* match);
651 static gchar* vala_gir_parser_node_get_lower_case_cprefix (ValaGirParserNode* self);
652 static gboolean vala_gir_parser_same_gir (ValaGirParser* self,
653                                    ValaSymbol* gir_component,
654                                    ValaSymbol* sym);
655 static void vala_gir_parser_process_namespace_method (ValaGirParser* self,
656                                                ValaGirParserNode* ns,
657                                                ValaGirParserNode* node);
658 static void vala_gir_parser_node_remove_member (ValaGirParserNode* self,
659                                          ValaGirParserNode* node);
660 static void vala_gir_parser_process_virtual_method_field (ValaGirParser* self,
661                                                    ValaGirParserNode* node,
662                                                    ValaDelegate* d,
663                                                    ValaUnresolvedSymbol* gtype_struct_for);
664 static gchar* vala_gir_parser_node_to_string (ValaGirParserNode* self);
665 static ValaArrayList* vala_gir_parser_node_lookup_all (ValaGirParserNode* self,
666                                                 const gchar* name);
667 static void vala_gir_parser_process_async_method (ValaGirParser* self,
668                                            ValaGirParserNode* node);
669 static gchar* vala_gir_parser_node_get_finish_cname (ValaGirParserNode* self);
670 static ValaGirParserNode* vala_gir_parser_base_interface_property (ValaGirParser* self,
671                                                             ValaGirParserNode* prop_node);
672 static ValaGirParserArgument* vala_gir_parser_argument_new (ValaExpression* expression,
673                                                      ValaSourceReference* source_reference);
674 static ValaGirParserArgument* vala_gir_parser_argument_construct (GType object_type,
675                                                            ValaExpression* expression,
676                                                            ValaSourceReference* source_reference);
677 static void vala_gir_parser_argument_finalize (ValaGirParserArgument * obj);
678 static GType vala_gir_parser_argument_get_type_once (void);
679 static GType vala_gir_parser_metadata_set_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
680 static ValaGirParserMetadataSet* vala_gir_parser_metadata_set_new (const gchar* selector);
681 static ValaGirParserMetadataSet* vala_gir_parser_metadata_set_construct (GType object_type,
682                                                                   const gchar* selector);
683 static ValaGirParserMetadata* vala_gir_parser_metadata_new (const gchar* pattern,
684                                                      const gchar* selector,
685                                                      ValaSourceReference* source_reference);
686 static ValaGirParserMetadata* vala_gir_parser_metadata_construct (GType object_type,
687                                                            const gchar* pattern,
688                                                            const gchar* selector,
689                                                            ValaSourceReference* source_reference);
690 static void vala_gir_parser_metadata_set_add_sibling (ValaGirParserMetadataSet* self,
691                                                ValaGirParserMetadata* metadata);
692 static void vala_gir_parser_metadata_add_child (ValaGirParserMetadata* self,
693                                          ValaGirParserMetadata* metadata);
694 static GType vala_gir_parser_metadata_set_get_type_once (void);
695 static void vala_gir_parser_metadata_add_argument (ValaGirParserMetadata* self,
696                                             ValaGirParserArgumentType key,
697                                             ValaGirParserArgument* value);
698 static void vala_gir_parser_metadata_finalize (ValaGirParserMetadata * obj);
699 static GType vala_gir_parser_metadata_get_type_once (void);
700 static ValaSourceReference* vala_gir_parser_metadata_parser_get_current_src (ValaGirParserMetadataParser* self);
701 static ValaSourceReference* vala_gir_parser_metadata_parser_get_src (ValaGirParserMetadataParser* self,
702                                                               ValaSourceLocation* begin,
703                                                               ValaSourceLocation* end);
704 static ValaTokenType vala_gir_parser_metadata_parser_next (ValaGirParserMetadataParser* self);
705 static gboolean vala_gir_parser_metadata_parser_parse_rule (ValaGirParserMetadataParser* self);
706 static gboolean vala_gir_parser_metadata_parser_has_space (ValaGirParserMetadataParser* self);
707 static gboolean vala_gir_parser_metadata_parser_has_newline (ValaGirParserMetadataParser* self);
708 static gchar* vala_gir_parser_metadata_parser_get_string (ValaGirParserMetadataParser* self,
709                                                    ValaSourceLocation* begin,
710                                                    ValaSourceLocation* end);
711 static gchar* vala_gir_parser_metadata_parser_parse_identifier (ValaGirParserMetadataParser* self,
712                                                          gboolean is_glob);
713 static gchar* vala_gir_parser_metadata_parser_parse_selector (ValaGirParserMetadataParser* self);
714 static ValaGirParserMetadata* vala_gir_parser_metadata_parser_parse_pattern (ValaGirParserMetadataParser* self);
715 static ValaExpression* vala_gir_parser_metadata_parser_parse_expression (ValaGirParserMetadataParser* self);
716 static gboolean vala_gir_parser_metadata_parser_parse_args (ValaGirParserMetadataParser* self,
717                                                      ValaGirParserMetadata* metadata);
718 static void vala_gir_parser_metadata_parser_finalize (ValaGirParserMetadataParser * obj);
719 static GType vala_gir_parser_metadata_parser_get_type_once (void);
720 static gchar* vala_gir_parser_node_get_default_gir_name (ValaGirParserNode* self);
721 static gchar* vala_gir_parser_node_get_default_lower_case_cprefix (ValaGirParserNode* self);
722 static gchar* vala_gir_parser_node_get_lower_case_csuffix (ValaGirParserNode* self);
723 static gchar* vala_gir_parser_node_get_default_lower_case_csuffix (ValaGirParserNode* self);
724 static gchar* vala_gir_parser_node_get_cprefix (ValaGirParserNode* self);
725 static gchar* vala_gir_parser_node_get_default_cname (ValaGirParserNode* self);
726 static gchar* vala_gir_parser_node_get_cheader_filename (ValaGirParserNode* self);
727 static guint64 vala_gir_parser_node_parse_version_string (const gchar* version);
728 static void vala_gir_parser_node_move_class_methods (ValaGirParserNode* target,
729                                               ValaGirParserNode* source);
730 static void vala_gir_parser_node_finalize (ValaGirParserNode * obj);
731 static GType vala_gir_parser_node_get_type_once (void);
732 static void vala_gir_parser_parameter_info_finalize (ValaGirParserParameterInfo * obj);
733 static GType vala_gir_parser_parameter_info_get_type_once (void);
734 static void vala_gir_parser_finalize (ValaCodeVisitor * obj);
735 static GType vala_gir_parser_get_type_once (void);
736 static void _vala_array_destroy (gpointer array,
737                           gint array_length,
738                           GDestroyNotify destroy_func);
739 static void _vala_array_free (gpointer array,
740                        gint array_length,
741                        GDestroyNotify destroy_func);
742 static gint _vala_array_length (gpointer array);
743 
744 static inline gpointer
vala_gir_parser_get_instance_private(ValaGirParser * self)745 vala_gir_parser_get_instance_private (ValaGirParser* self)
746 {
747 	return G_STRUCT_MEMBER_P (self, ValaGirParser_private_offset);
748 }
749 
750 static gchar*
string_replace(const gchar * self,const gchar * old,const gchar * replacement)751 string_replace (const gchar* self,
752                 const gchar* old,
753                 const gchar* replacement)
754 {
755 	gboolean _tmp0_ = FALSE;
756 	gboolean _tmp1_ = FALSE;
757 	GError* _inner_error0_ = NULL;
758 	gchar* result = NULL;
759 	g_return_val_if_fail (self != NULL, NULL);
760 	g_return_val_if_fail (old != NULL, NULL);
761 	g_return_val_if_fail (replacement != NULL, NULL);
762 	if ((*((gchar*) self)) == '\0') {
763 		_tmp1_ = TRUE;
764 	} else {
765 		_tmp1_ = (*((gchar*) old)) == '\0';
766 	}
767 	if (_tmp1_) {
768 		_tmp0_ = TRUE;
769 	} else {
770 		_tmp0_ = g_strcmp0 (old, replacement) == 0;
771 	}
772 	if (_tmp0_) {
773 		gchar* _tmp2_;
774 		_tmp2_ = g_strdup (self);
775 		result = _tmp2_;
776 		return result;
777 	}
778 	{
779 		GRegex* regex = NULL;
780 		gchar* _tmp3_;
781 		gchar* _tmp4_;
782 		GRegex* _tmp5_;
783 		GRegex* _tmp6_;
784 		gchar* _tmp7_ = NULL;
785 		GRegex* _tmp8_;
786 		gchar* _tmp9_;
787 		gchar* _tmp10_;
788 		_tmp3_ = g_regex_escape_string (old, -1);
789 		_tmp4_ = _tmp3_;
790 		_tmp5_ = g_regex_new (_tmp4_, 0, 0, &_inner_error0_);
791 		_tmp6_ = _tmp5_;
792 		_g_free0 (_tmp4_);
793 		regex = _tmp6_;
794 		if (G_UNLIKELY (_inner_error0_ != NULL)) {
795 			_g_free0 (_tmp7_);
796 			_g_regex_unref0 (regex);
797 			if (_inner_error0_->domain == G_REGEX_ERROR) {
798 				goto __catch0_g_regex_error;
799 			}
800 			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);
801 			g_clear_error (&_inner_error0_);
802 			return NULL;
803 		}
804 		_tmp8_ = regex;
805 		_tmp9_ = g_regex_replace_literal (_tmp8_, self, (gssize) -1, 0, replacement, 0, &_inner_error0_);
806 		_tmp7_ = _tmp9_;
807 		if (G_UNLIKELY (_inner_error0_ != NULL)) {
808 			_g_free0 (_tmp7_);
809 			_g_regex_unref0 (regex);
810 			if (_inner_error0_->domain == G_REGEX_ERROR) {
811 				goto __catch0_g_regex_error;
812 			}
813 			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);
814 			g_clear_error (&_inner_error0_);
815 			return NULL;
816 		}
817 		_tmp10_ = _tmp7_;
818 		_tmp7_ = NULL;
819 		result = _tmp10_;
820 		_g_free0 (_tmp7_);
821 		_g_regex_unref0 (regex);
822 		return result;
823 	}
824 	goto __finally0;
825 	__catch0_g_regex_error:
826 	{
827 		g_clear_error (&_inner_error0_);
828 		g_assert_not_reached ();
829 	}
830 	__finally0:
831 	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);
832 	g_clear_error (&_inner_error0_);
833 	return NULL;
834 }
835 
836 static ValaGirParserArgumentType*
_vala_gir_parser_argument_type_dup(ValaGirParserArgumentType * self)837 _vala_gir_parser_argument_type_dup (ValaGirParserArgumentType* self)
838 {
839 	ValaGirParserArgumentType* dup;
840 	dup = g_new0 (ValaGirParserArgumentType, 1);
841 	memcpy (dup, self, sizeof (ValaGirParserArgumentType));
842 	return dup;
843 }
844 
845 static gpointer
__vala_gir_parser_argument_type_dup0(gpointer self)846 __vala_gir_parser_argument_type_dup0 (gpointer self)
847 {
848 	return self ? _vala_gir_parser_argument_type_dup (self) : NULL;
849 }
850 
851 static ValaGirParserArgumentType*
vala_gir_parser_argument_type_from_string(const gchar * name)852 vala_gir_parser_argument_type_from_string (const gchar* name)
853 {
854 	GEnumClass* enum_class = NULL;
855 	GTypeClass* _tmp0_;
856 	gchar* nick = NULL;
857 	gchar* _tmp1_;
858 	GEnumValue* enum_value = NULL;
859 	GEnumClass* _tmp2_;
860 	const gchar* _tmp3_;
861 	GEnumValue* _tmp4_;
862 	ValaGirParserArgumentType* result = NULL;
863 	g_return_val_if_fail (name != NULL, NULL);
864 	_tmp0_ = g_type_class_ref (VALA_GIR_PARSER_TYPE_ARGUMENT_TYPE);
865 	enum_class = (GEnumClass*) _tmp0_;
866 	_tmp1_ = string_replace (name, "_", "-");
867 	nick = _tmp1_;
868 	_tmp2_ = enum_class;
869 	_tmp3_ = nick;
870 	enum_value = g_enum_get_value_by_nick (_tmp2_, _tmp3_);
871 	_tmp4_ = enum_value;
872 	if (_tmp4_ != NULL) {
873 		ValaGirParserArgumentType value = 0;
874 		GEnumValue* _tmp5_;
875 		ValaGirParserArgumentType* _tmp6_;
876 		_tmp5_ = enum_value;
877 		value = (ValaGirParserArgumentType) (*_tmp5_).value;
878 		_tmp6_ = __vala_gir_parser_argument_type_dup0 (&value);
879 		result = _tmp6_;
880 		_g_free0 (nick);
881 		_g_type_class_unref0 (enum_class);
882 		return result;
883 	}
884 	result = NULL;
885 	_g_free0 (nick);
886 	_g_type_class_unref0 (enum_class);
887 	return result;
888 }
889 
890 static GType
vala_gir_parser_argument_type_get_type_once(void)891 vala_gir_parser_argument_type_get_type_once (void)
892 {
893 	static const GEnumValue values[] = {{VALA_GIR_PARSER_ARGUMENT_TYPE_SKIP, "VALA_GIR_PARSER_ARGUMENT_TYPE_SKIP", "skip"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_HIDDEN, "VALA_GIR_PARSER_ARGUMENT_TYPE_HIDDEN", "hidden"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_NEW, "VALA_GIR_PARSER_ARGUMENT_TYPE_NEW", "new"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE", "type"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ARGUMENTS, "VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ARGUMENTS", "type-arguments"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME", "cheader-filename"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_NAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_NAME", "name"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_OWNED, "VALA_GIR_PARSER_ARGUMENT_TYPE_OWNED", "owned"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_UNOWNED, "VALA_GIR_PARSER_ARGUMENT_TYPE_UNOWNED", "unowned"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_PARENT, "VALA_GIR_PARSER_ARGUMENT_TYPE_PARENT", "parent"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_NULLABLE, "VALA_GIR_PARSER_ARGUMENT_TYPE_NULLABLE", "nullable"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED, "VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED", "deprecated"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_REPLACEMENT, "VALA_GIR_PARSER_ARGUMENT_TYPE_REPLACEMENT", "replacement"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED_SINCE, "VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED_SINCE", "deprecated-since"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_SINCE, "VALA_GIR_PARSER_ARGUMENT_TYPE_SINCE", "since"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY, "VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY", "array"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_IDX, "VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_IDX", "array-length-idx"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_NULL_TERMINATED, "VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_NULL_TERMINATED", "array-null-terminated"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DEFAULT, "VALA_GIR_PARSER_ARGUMENT_TYPE_DEFAULT", "default"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_OUT, "VALA_GIR_PARSER_ARGUMENT_TYPE_OUT", "out"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_REF, "VALA_GIR_PARSER_ARGUMENT_TYPE_REF", "ref"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME", "vfunc-name"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_VIRTUAL, "VALA_GIR_PARSER_ARGUMENT_TYPE_VIRTUAL", "virtual"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ABSTRACT, "VALA_GIR_PARSER_ARGUMENT_TYPE_ABSTRACT", "abstract"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_COMPACT, "VALA_GIR_PARSER_ARGUMENT_TYPE_COMPACT", "compact"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_SEALED, "VALA_GIR_PARSER_ARGUMENT_TYPE_SEALED", "sealed"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_SCOPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_SCOPE", "scope"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_STRUCT, "VALA_GIR_PARSER_ARGUMENT_TYPE_STRUCT", "struct"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_THROWS, "VALA_GIR_PARSER_ARGUMENT_TYPE_THROWS", "throws"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_PRINTF_FORMAT, "VALA_GIR_PARSER_ARGUMENT_TYPE_PRINTF_FORMAT", "printf-format"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_FIELD, "VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_FIELD", "array-length-field"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_SENTINEL, "VALA_GIR_PARSER_ARGUMENT_TYPE_SENTINEL", "sentinel"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_CLOSURE, "VALA_GIR_PARSER_ARGUMENT_TYPE_CLOSURE", "closure"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROY, "VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROY", "destroy"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_CPREFIX, "VALA_GIR_PARSER_ARGUMENT_TYPE_CPREFIX", "cprefix"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CPREFIX, "VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CPREFIX", "lower-case-cprefix"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CSUFFIX, "VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CSUFFIX", "lower-case-csuffix"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ERRORDOMAIN, "VALA_GIR_PARSER_ARGUMENT_TYPE_ERRORDOMAIN", "errordomain"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROYS_INSTANCE, "VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROYS_INSTANCE", "destroys-instance"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_BASE_TYPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_BASE_TYPE", "base-type"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_NAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_NAME", "finish-name"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_INSTANCE, "VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_INSTANCE", "finish-instance"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_SYMBOL_TYPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_SYMBOL_TYPE", "symbol-type"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_INSTANCE_IDX, "VALA_GIR_PARSER_ARGUMENT_TYPE_INSTANCE_IDX", "instance-idx"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_EXPERIMENTAL, "VALA_GIR_PARSER_ARGUMENT_TYPE_EXPERIMENTAL", "experimental"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FEATURE_TEST_MACRO, "VALA_GIR_PARSER_ARGUMENT_TYPE_FEATURE_TEST_MACRO", "feature-test-macro"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FLOATING, "VALA_GIR_PARSER_ARGUMENT_TYPE_FLOATING", "floating"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ID, "VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ID", "type-id"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_GET_FUNCTION, "VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_GET_FUNCTION", "type-get-function"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_RETURN_VOID, "VALA_GIR_PARSER_ARGUMENT_TYPE_RETURN_VOID", "return-void"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_RETURNS_MODIFIED_POINTER, "VALA_GIR_PARSER_ARGUMENT_TYPE_RETURNS_MODIFIED_POINTER", "returns-modified-pointer"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET_CNAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET_CNAME", "delegate-target-cname"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROY_NOTIFY_CNAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROY_NOTIFY_CNAME", "destroy-notify-cname"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_VFUNC_NAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_VFUNC_NAME", "finish-vfunc-name"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_NO_ACCESSOR_METHOD, "VALA_GIR_PARSER_ARGUMENT_TYPE_NO_ACCESSOR_METHOD", "no-accessor-method"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_NO_WRAPPER, "VALA_GIR_PARSER_ARGUMENT_TYPE_NO_WRAPPER", "no-wrapper"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_CNAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_CNAME", "cname"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET, "VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET", "delegate-target"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_CTYPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_CTYPE", "ctype"}, {0, NULL, NULL}};
894 	GType vala_gir_parser_argument_type_type_id;
895 	vala_gir_parser_argument_type_type_id = g_enum_register_static ("ValaGirParserArgumentType", values);
896 	return vala_gir_parser_argument_type_type_id;
897 }
898 
899 static GType
vala_gir_parser_argument_type_get_type(void)900 vala_gir_parser_argument_type_get_type (void)
901 {
902 	static volatile gsize vala_gir_parser_argument_type_type_id__volatile = 0;
903 	if (g_once_init_enter (&vala_gir_parser_argument_type_type_id__volatile)) {
904 		GType vala_gir_parser_argument_type_type_id;
905 		vala_gir_parser_argument_type_type_id = vala_gir_parser_argument_type_get_type_once ();
906 		g_once_init_leave (&vala_gir_parser_argument_type_type_id__volatile, vala_gir_parser_argument_type_type_id);
907 	}
908 	return vala_gir_parser_argument_type_type_id__volatile;
909 }
910 
911 static guint
_vala_gir_parser_unresolved_symbol_hash_ghash_func(gconstpointer key)912 _vala_gir_parser_unresolved_symbol_hash_ghash_func (gconstpointer key)
913 {
914 	guint result;
915 	result = vala_gir_parser_unresolved_symbol_hash ((ValaUnresolvedSymbol*) key);
916 	return result;
917 }
918 
919 static gboolean
_vala_gir_parser_unresolved_symbol_equal_gequal_func(gconstpointer a,gconstpointer b)920 _vala_gir_parser_unresolved_symbol_equal_gequal_func (gconstpointer a,
921                                                       gconstpointer b)
922 {
923 	gboolean result;
924 	result = vala_gir_parser_unresolved_symbol_equal ((ValaUnresolvedSymbol*) a, (ValaUnresolvedSymbol*) b);
925 	return result;
926 }
927 
928 /**
929  * Parses all .gir source files in the specified code
930  * context and builds a code tree.
931  *
932  * @param context a code context
933  */
934 static gpointer
_vala_code_context_ref0(gpointer self)935 _vala_code_context_ref0 (gpointer self)
936 {
937 	return self ? vala_code_context_ref (self) : NULL;
938 }
939 
940 static gpointer
_vala_code_node_ref0(gpointer self)941 _vala_code_node_ref0 (gpointer self)
942 {
943 	return self ? vala_code_node_ref (self) : NULL;
944 }
945 
946 static gpointer
_vala_gir_parser_node_ref0(gpointer self)947 _vala_gir_parser_node_ref0 (gpointer self)
948 {
949 	return self ? vala_gir_parser_node_ref (self) : NULL;
950 }
951 
952 static gpointer
_vala_iterable_ref0(gpointer self)953 _vala_iterable_ref0 (gpointer self)
954 {
955 	return self ? vala_iterable_ref (self) : NULL;
956 }
957 
958 void
vala_gir_parser_parse(ValaGirParser * self,ValaCodeContext * context)959 vala_gir_parser_parse (ValaGirParser* self,
960                        ValaCodeContext* context)
961 {
962 	ValaCodeContext* _tmp0_;
963 	ValaGirParserNode* _tmp1_;
964 	ValaGirParserNode* _tmp2_;
965 	ValaNamespace* _tmp3_;
966 	ValaNamespace* _tmp4_;
967 	ValaSymbol* _tmp5_;
968 	GEqualFunc _tmp6_;
969 	ValaArrayList* _tmp7_;
970 	ValaGirParserNode* _tmp8_;
971 	ValaGirParserNode* _tmp9_;
972 	ValaGirParserNode* _tmp10_;
973 	ValaNamespace* glib_ns = NULL;
974 	ValaNamespace* _tmp11_;
975 	ValaNamespace* _tmp12_;
976 	ValaScope* _tmp13_;
977 	ValaScope* _tmp14_;
978 	ValaSymbol* _tmp15_;
979 	ValaNamespace* _tmp16_;
980 	ValaNamespace* _tmp17_;
981 	g_return_if_fail (self != NULL);
982 	g_return_if_fail (context != NULL);
983 	_tmp0_ = _vala_code_context_ref0 (context);
984 	_vala_code_context_unref0 (self->priv->context);
985 	self->priv->context = _tmp0_;
986 	_tmp1_ = vala_gir_parser_node_new (NULL);
987 	_vala_gir_parser_node_unref0 (self->priv->root);
988 	self->priv->root = _tmp1_;
989 	_tmp2_ = self->priv->root;
990 	_tmp3_ = vala_code_context_get_root (context);
991 	_tmp4_ = _tmp3_;
992 	_tmp5_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp4_);
993 	_vala_code_node_unref0 (_tmp2_->symbol);
994 	_tmp2_->symbol = _tmp5_;
995 	_tmp6_ = g_direct_equal;
996 	_tmp7_ = vala_array_list_new (VALA_GIR_PARSER_TYPE_NODE, (GBoxedCopyFunc) vala_gir_parser_node_ref, (GDestroyNotify) vala_gir_parser_node_unref, _tmp6_);
997 	_vala_iterable_unref0 (self->priv->tree_stack);
998 	self->priv->tree_stack = _tmp7_;
999 	_tmp8_ = self->priv->root;
1000 	_tmp9_ = _vala_gir_parser_node_ref0 (_tmp8_);
1001 	_vala_gir_parser_node_unref0 (self->priv->current);
1002 	self->priv->current = _tmp9_;
1003 	vala_gir_parser_map_vala_to_gir (self);
1004 	vala_code_context_accept (context, (ValaCodeVisitor*) self);
1005 	vala_gir_parser_resolve_gir_symbols (self);
1006 	vala_gir_parser_create_new_namespaces (self);
1007 	vala_gir_parser_resolve_type_arguments (self);
1008 	_tmp10_ = self->priv->root;
1009 	vala_gir_parser_node_process (_tmp10_, self);
1010 	_tmp11_ = vala_code_context_get_root (context);
1011 	_tmp12_ = _tmp11_;
1012 	_tmp13_ = vala_symbol_get_scope ((ValaSymbol*) _tmp12_);
1013 	_tmp14_ = _tmp13_;
1014 	_tmp15_ = vala_scope_lookup (_tmp14_, "GLib");
1015 	_tmp16_ = VALA_IS_NAMESPACE (_tmp15_) ? ((ValaNamespace*) _tmp15_) : NULL;
1016 	if (_tmp16_ == NULL) {
1017 		_vala_code_node_unref0 (_tmp15_);
1018 	}
1019 	glib_ns = _tmp16_;
1020 	_tmp17_ = glib_ns;
1021 	if (_tmp17_ != NULL) {
1022 		ValaClass* object_type = NULL;
1023 		ValaNamespace* _tmp18_;
1024 		ValaScope* _tmp19_;
1025 		ValaScope* _tmp20_;
1026 		ValaSymbol* _tmp21_;
1027 		_tmp18_ = glib_ns;
1028 		_tmp19_ = vala_symbol_get_scope ((ValaSymbol*) _tmp18_);
1029 		_tmp20_ = _tmp19_;
1030 		_tmp21_ = vala_scope_lookup (_tmp20_, "Object");
1031 		object_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp21_, VALA_TYPE_CLASS, ValaClass);
1032 		{
1033 			ValaArrayList* _iface_list = NULL;
1034 			ValaArrayList* _tmp22_;
1035 			ValaArrayList* _tmp23_;
1036 			gint _iface_size = 0;
1037 			ValaArrayList* _tmp24_;
1038 			gint _tmp25_;
1039 			gint _tmp26_;
1040 			gint _iface_index = 0;
1041 			_tmp22_ = self->priv->ifaces_needing_object_prereq;
1042 			_tmp23_ = _vala_iterable_ref0 (_tmp22_);
1043 			_iface_list = _tmp23_;
1044 			_tmp24_ = _iface_list;
1045 			_tmp25_ = vala_collection_get_size ((ValaCollection*) _tmp24_);
1046 			_tmp26_ = _tmp25_;
1047 			_iface_size = _tmp26_;
1048 			_iface_index = -1;
1049 			while (TRUE) {
1050 				gint _tmp27_;
1051 				gint _tmp28_;
1052 				ValaInterface* iface = NULL;
1053 				ValaArrayList* _tmp29_;
1054 				gpointer _tmp30_;
1055 				ValaInterface* _tmp31_;
1056 				ValaClass* _tmp32_;
1057 				ValaObjectType* _tmp33_;
1058 				ValaObjectType* _tmp34_;
1059 				_iface_index = _iface_index + 1;
1060 				_tmp27_ = _iface_index;
1061 				_tmp28_ = _iface_size;
1062 				if (!(_tmp27_ < _tmp28_)) {
1063 					break;
1064 				}
1065 				_tmp29_ = _iface_list;
1066 				_tmp30_ = vala_list_get ((ValaList*) _tmp29_, _iface_index);
1067 				iface = (ValaInterface*) _tmp30_;
1068 				_tmp31_ = iface;
1069 				_tmp32_ = object_type;
1070 				_tmp33_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp32_);
1071 				_tmp34_ = _tmp33_;
1072 				vala_interface_add_prerequisite (_tmp31_, (ValaDataType*) _tmp34_);
1073 				_vala_code_node_unref0 (_tmp34_);
1074 				_vala_code_node_unref0 (iface);
1075 			}
1076 			_vala_iterable_unref0 (_iface_list);
1077 		}
1078 		_vala_code_node_unref0 (object_type);
1079 	}
1080 	{
1081 		ValaArrayList* _metadata_list = NULL;
1082 		ValaArrayList* _tmp35_;
1083 		ValaArrayList* _tmp36_;
1084 		gint _metadata_size = 0;
1085 		ValaArrayList* _tmp37_;
1086 		gint _tmp38_;
1087 		gint _tmp39_;
1088 		gint _metadata_index = 0;
1089 		_tmp35_ = self->priv->metadata_roots;
1090 		_tmp36_ = _vala_iterable_ref0 (_tmp35_);
1091 		_metadata_list = _tmp36_;
1092 		_tmp37_ = _metadata_list;
1093 		_tmp38_ = vala_collection_get_size ((ValaCollection*) _tmp37_);
1094 		_tmp39_ = _tmp38_;
1095 		_metadata_size = _tmp39_;
1096 		_metadata_index = -1;
1097 		while (TRUE) {
1098 			gint _tmp40_;
1099 			gint _tmp41_;
1100 			ValaGirParserMetadata* metadata = NULL;
1101 			ValaArrayList* _tmp42_;
1102 			gpointer _tmp43_;
1103 			ValaGirParserMetadata* _tmp44_;
1104 			_metadata_index = _metadata_index + 1;
1105 			_tmp40_ = _metadata_index;
1106 			_tmp41_ = _metadata_size;
1107 			if (!(_tmp40_ < _tmp41_)) {
1108 				break;
1109 			}
1110 			_tmp42_ = _metadata_list;
1111 			_tmp43_ = vala_list_get ((ValaList*) _tmp42_, _metadata_index);
1112 			metadata = (ValaGirParserMetadata*) _tmp43_;
1113 			_tmp44_ = metadata;
1114 			vala_gir_parser_report_unused_metadata (self, _tmp44_);
1115 			_vala_gir_parser_metadata_unref0 (metadata);
1116 		}
1117 		_vala_iterable_unref0 (_metadata_list);
1118 	}
1119 	_vala_code_context_unref0 (self->priv->context);
1120 	self->priv->context = NULL;
1121 	_vala_code_node_unref0 (glib_ns);
1122 }
1123 
1124 static void
vala_gir_parser_map_vala_to_gir(ValaGirParser * self)1125 vala_gir_parser_map_vala_to_gir (ValaGirParser* self)
1126 {
1127 	g_return_if_fail (self != NULL);
1128 	{
1129 		ValaList* _source_file_list = NULL;
1130 		ValaCodeContext* _tmp0_;
1131 		ValaList* _tmp1_;
1132 		ValaList* _tmp2_;
1133 		gint _source_file_size = 0;
1134 		ValaList* _tmp3_;
1135 		gint _tmp4_;
1136 		gint _tmp5_;
1137 		gint _source_file_index = 0;
1138 		_tmp0_ = self->priv->context;
1139 		_tmp1_ = vala_code_context_get_source_files (_tmp0_);
1140 		_tmp2_ = _vala_iterable_ref0 (_tmp1_);
1141 		_source_file_list = _tmp2_;
1142 		_tmp3_ = _source_file_list;
1143 		_tmp4_ = vala_collection_get_size ((ValaCollection*) _tmp3_);
1144 		_tmp5_ = _tmp4_;
1145 		_source_file_size = _tmp5_;
1146 		_source_file_index = -1;
1147 		while (TRUE) {
1148 			gint _tmp6_;
1149 			gint _tmp7_;
1150 			ValaSourceFile* source_file = NULL;
1151 			ValaList* _tmp8_;
1152 			gpointer _tmp9_;
1153 			gchar* gir_namespace = NULL;
1154 			ValaSourceFile* _tmp10_;
1155 			const gchar* _tmp11_;
1156 			const gchar* _tmp12_;
1157 			gchar* _tmp13_;
1158 			gchar* gir_version = NULL;
1159 			ValaSourceFile* _tmp14_;
1160 			const gchar* _tmp15_;
1161 			const gchar* _tmp16_;
1162 			gchar* _tmp17_;
1163 			ValaNamespace* ns = NULL;
1164 			const gchar* _tmp18_;
1165 			const gchar* _tmp37_;
1166 			ValaSet* _tmp38_;
1167 			const gchar* _tmp39_;
1168 			const gchar* _tmp40_;
1169 			gchar* _tmp41_;
1170 			gchar* _tmp42_;
1171 			ValaUnresolvedSymbol* gir_symbol = NULL;
1172 			const gchar* _tmp43_;
1173 			ValaUnresolvedSymbol* _tmp44_;
1174 			const gchar* _tmp45_;
1175 			ValaNamespace* _tmp46_;
1176 			const gchar* _tmp47_;
1177 			const gchar* _tmp48_;
1178 			_source_file_index = _source_file_index + 1;
1179 			_tmp6_ = _source_file_index;
1180 			_tmp7_ = _source_file_size;
1181 			if (!(_tmp6_ < _tmp7_)) {
1182 				break;
1183 			}
1184 			_tmp8_ = _source_file_list;
1185 			_tmp9_ = vala_list_get (_tmp8_, _source_file_index);
1186 			source_file = (ValaSourceFile*) _tmp9_;
1187 			_tmp10_ = source_file;
1188 			_tmp11_ = vala_source_file_get_gir_namespace (_tmp10_);
1189 			_tmp12_ = _tmp11_;
1190 			_tmp13_ = g_strdup (_tmp12_);
1191 			gir_namespace = _tmp13_;
1192 			_tmp14_ = source_file;
1193 			_tmp15_ = vala_source_file_get_gir_version (_tmp14_);
1194 			_tmp16_ = _tmp15_;
1195 			_tmp17_ = g_strdup (_tmp16_);
1196 			gir_version = _tmp17_;
1197 			ns = NULL;
1198 			_tmp18_ = gir_namespace;
1199 			if (_tmp18_ == NULL) {
1200 				{
1201 					ValaList* _node_list = NULL;
1202 					ValaSourceFile* _tmp19_;
1203 					ValaList* _tmp20_;
1204 					ValaList* _tmp21_;
1205 					gint _node_size = 0;
1206 					ValaList* _tmp22_;
1207 					gint _tmp23_;
1208 					gint _tmp24_;
1209 					gint _node_index = 0;
1210 					_tmp19_ = source_file;
1211 					_tmp20_ = vala_source_file_get_nodes (_tmp19_);
1212 					_tmp21_ = _vala_iterable_ref0 (_tmp20_);
1213 					_node_list = _tmp21_;
1214 					_tmp22_ = _node_list;
1215 					_tmp23_ = vala_collection_get_size ((ValaCollection*) _tmp22_);
1216 					_tmp24_ = _tmp23_;
1217 					_node_size = _tmp24_;
1218 					_node_index = -1;
1219 					while (TRUE) {
1220 						gint _tmp25_;
1221 						gint _tmp26_;
1222 						ValaCodeNode* node = NULL;
1223 						ValaList* _tmp27_;
1224 						gpointer _tmp28_;
1225 						ValaCodeNode* _tmp29_;
1226 						_node_index = _node_index + 1;
1227 						_tmp25_ = _node_index;
1228 						_tmp26_ = _node_size;
1229 						if (!(_tmp25_ < _tmp26_)) {
1230 							break;
1231 						}
1232 						_tmp27_ = _node_list;
1233 						_tmp28_ = vala_list_get (_tmp27_, _node_index);
1234 						node = (ValaCodeNode*) _tmp28_;
1235 						_tmp29_ = node;
1236 						if (VALA_IS_NAMESPACE (_tmp29_)) {
1237 							ValaCodeNode* _tmp30_;
1238 							ValaNamespace* _tmp31_;
1239 							ValaNamespace* _tmp32_;
1240 							gchar* _tmp33_;
1241 							const gchar* _tmp34_;
1242 							_tmp30_ = node;
1243 							_tmp31_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp30_, VALA_TYPE_NAMESPACE, ValaNamespace));
1244 							_vala_code_node_unref0 (ns);
1245 							ns = _tmp31_;
1246 							_tmp32_ = ns;
1247 							_tmp33_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp32_, "CCode", "gir_namespace", NULL);
1248 							_g_free0 (gir_namespace);
1249 							gir_namespace = _tmp33_;
1250 							_tmp34_ = gir_namespace;
1251 							if (_tmp34_ != NULL) {
1252 								ValaNamespace* _tmp35_;
1253 								gchar* _tmp36_;
1254 								_tmp35_ = ns;
1255 								_tmp36_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp35_, "CCode", "gir_version", NULL);
1256 								_g_free0 (gir_version);
1257 								gir_version = _tmp36_;
1258 								_vala_code_node_unref0 (node);
1259 								break;
1260 							}
1261 						}
1262 						_vala_code_node_unref0 (node);
1263 					}
1264 					_vala_iterable_unref0 (_node_list);
1265 				}
1266 			}
1267 			_tmp37_ = gir_namespace;
1268 			if (_tmp37_ == NULL) {
1269 				_vala_code_node_unref0 (ns);
1270 				_g_free0 (gir_version);
1271 				_g_free0 (gir_namespace);
1272 				_vala_source_file_unref0 (source_file);
1273 				continue;
1274 			}
1275 			_tmp38_ = self->priv->provided_namespaces;
1276 			_tmp39_ = gir_namespace;
1277 			_tmp40_ = gir_version;
1278 			_tmp41_ = g_strdup_printf ("%s-%s", _tmp39_, _tmp40_);
1279 			_tmp42_ = _tmp41_;
1280 			vala_collection_add ((ValaCollection*) _tmp38_, _tmp42_);
1281 			_g_free0 (_tmp42_);
1282 			_tmp43_ = gir_namespace;
1283 			_tmp44_ = vala_unresolved_symbol_new (NULL, _tmp43_, NULL);
1284 			gir_symbol = _tmp44_;
1285 			_tmp45_ = gir_namespace;
1286 			_tmp46_ = ns;
1287 			_tmp47_ = vala_symbol_get_name ((ValaSymbol*) _tmp46_);
1288 			_tmp48_ = _tmp47_;
1289 			if (g_strcmp0 (_tmp45_, _tmp48_) != 0) {
1290 				ValaUnresolvedSymbol* _tmp49_;
1291 				ValaNamespace* _tmp50_;
1292 				_tmp49_ = gir_symbol;
1293 				_tmp50_ = ns;
1294 				vala_gir_parser_set_symbol_mapping (self, _tmp49_, (ValaSymbol*) _tmp50_);
1295 			}
1296 			{
1297 				ValaList* _node_list = NULL;
1298 				ValaSourceFile* _tmp51_;
1299 				ValaList* _tmp52_;
1300 				ValaList* _tmp53_;
1301 				gint _node_size = 0;
1302 				ValaList* _tmp54_;
1303 				gint _tmp55_;
1304 				gint _tmp56_;
1305 				gint _node_index = 0;
1306 				_tmp51_ = source_file;
1307 				_tmp52_ = vala_source_file_get_nodes (_tmp51_);
1308 				_tmp53_ = _vala_iterable_ref0 (_tmp52_);
1309 				_node_list = _tmp53_;
1310 				_tmp54_ = _node_list;
1311 				_tmp55_ = vala_collection_get_size ((ValaCollection*) _tmp54_);
1312 				_tmp56_ = _tmp55_;
1313 				_node_size = _tmp56_;
1314 				_node_index = -1;
1315 				while (TRUE) {
1316 					gint _tmp57_;
1317 					gint _tmp58_;
1318 					ValaCodeNode* node = NULL;
1319 					ValaList* _tmp59_;
1320 					gpointer _tmp60_;
1321 					ValaCodeNode* _tmp61_;
1322 					_node_index = _node_index + 1;
1323 					_tmp57_ = _node_index;
1324 					_tmp58_ = _node_size;
1325 					if (!(_tmp57_ < _tmp58_)) {
1326 						break;
1327 					}
1328 					_tmp59_ = _node_list;
1329 					_tmp60_ = vala_list_get (_tmp59_, _node_index);
1330 					node = (ValaCodeNode*) _tmp60_;
1331 					_tmp61_ = node;
1332 					if (vala_code_node_has_attribute_argument (_tmp61_, "GIR", "name")) {
1333 						ValaUnresolvedSymbol* map_from = NULL;
1334 						ValaUnresolvedSymbol* _tmp62_;
1335 						ValaCodeNode* _tmp63_;
1336 						gchar* _tmp64_;
1337 						gchar* _tmp65_;
1338 						ValaUnresolvedSymbol* _tmp66_;
1339 						ValaUnresolvedSymbol* _tmp67_;
1340 						ValaUnresolvedSymbol* _tmp68_;
1341 						ValaCodeNode* _tmp69_;
1342 						_tmp62_ = gir_symbol;
1343 						_tmp63_ = node;
1344 						_tmp64_ = vala_code_node_get_attribute_string (_tmp63_, "GIR", "name", NULL);
1345 						_tmp65_ = _tmp64_;
1346 						_tmp66_ = vala_unresolved_symbol_new (_tmp62_, _tmp65_, NULL);
1347 						_tmp67_ = _tmp66_;
1348 						_g_free0 (_tmp65_);
1349 						map_from = _tmp67_;
1350 						_tmp68_ = map_from;
1351 						_tmp69_ = node;
1352 						vala_gir_parser_set_symbol_mapping (self, _tmp68_, G_TYPE_CHECK_INSTANCE_CAST (_tmp69_, VALA_TYPE_SYMBOL, ValaSymbol));
1353 						_vala_code_node_unref0 (map_from);
1354 					}
1355 					_vala_code_node_unref0 (node);
1356 				}
1357 				_vala_iterable_unref0 (_node_list);
1358 			}
1359 			_vala_code_node_unref0 (gir_symbol);
1360 			_vala_code_node_unref0 (ns);
1361 			_g_free0 (gir_version);
1362 			_g_free0 (gir_namespace);
1363 			_vala_source_file_unref0 (source_file);
1364 		}
1365 		_vala_iterable_unref0 (_source_file_list);
1366 	}
1367 }
1368 
1369 static void
vala_gir_parser_real_visit_source_file(ValaCodeVisitor * base,ValaSourceFile * source_file)1370 vala_gir_parser_real_visit_source_file (ValaCodeVisitor* base,
1371                                         ValaSourceFile* source_file)
1372 {
1373 	ValaGirParser * self;
1374 	const gchar* _tmp0_;
1375 	const gchar* _tmp1_;
1376 	self = (ValaGirParser*) base;
1377 	g_return_if_fail (source_file != NULL);
1378 	_tmp0_ = vala_source_file_get_filename (source_file);
1379 	_tmp1_ = _tmp0_;
1380 	if (g_str_has_suffix (_tmp1_, ".gir")) {
1381 		vala_gir_parser_parse_file (self, source_file);
1382 	}
1383 }
1384 
1385 static gpointer
_vala_gir_parser_metadata_ref0(gpointer self)1386 _vala_gir_parser_metadata_ref0 (gpointer self)
1387 {
1388 	return self ? vala_gir_parser_metadata_ref (self) : NULL;
1389 }
1390 
1391 static gpointer
_vala_source_file_ref0(gpointer self)1392 _vala_source_file_ref0 (gpointer self)
1393 {
1394 	return self ? vala_source_file_ref (self) : NULL;
1395 }
1396 
1397 void
vala_gir_parser_parse_file(ValaGirParser * self,ValaSourceFile * source_file)1398 vala_gir_parser_parse_file (ValaGirParser* self,
1399                             ValaSourceFile* source_file)
1400 {
1401 	gboolean has_global_context = FALSE;
1402 	ValaCodeContext* _tmp0_;
1403 	GEqualFunc _tmp4_;
1404 	ValaArrayList* _tmp5_;
1405 	ValaGirParserMetadata* _tmp6_;
1406 	ValaGirParserMetadata* _tmp7_;
1407 	ValaGirParserMetadata* _tmp8_;
1408 	ValaSourceFile* _tmp9_;
1409 	const gchar* _tmp10_;
1410 	const gchar* _tmp11_;
1411 	ValaMarkupReader* _tmp12_;
1412 	g_return_if_fail (self != NULL);
1413 	g_return_if_fail (source_file != NULL);
1414 	_tmp0_ = self->priv->context;
1415 	has_global_context = _tmp0_ != NULL;
1416 	if (!has_global_context) {
1417 		ValaCodeContext* _tmp1_;
1418 		ValaCodeContext* _tmp2_;
1419 		ValaCodeContext* _tmp3_;
1420 		_tmp1_ = vala_source_file_get_context (source_file);
1421 		_tmp2_ = _tmp1_;
1422 		_tmp3_ = _vala_code_context_ref0 (_tmp2_);
1423 		_vala_code_context_unref0 (self->priv->context);
1424 		self->priv->context = _tmp3_;
1425 	}
1426 	_tmp4_ = g_direct_equal;
1427 	_tmp5_ = vala_array_list_new (VALA_GIR_PARSER_TYPE_METADATA, (GBoxedCopyFunc) vala_gir_parser_metadata_ref, (GDestroyNotify) vala_gir_parser_metadata_unref, _tmp4_);
1428 	_vala_iterable_unref0 (self->priv->metadata_stack);
1429 	self->priv->metadata_stack = _tmp5_;
1430 	_tmp6_ = vala_gir_parser_metadata_get_empty ();
1431 	_tmp7_ = _tmp6_;
1432 	_tmp8_ = _vala_gir_parser_metadata_ref0 (_tmp7_);
1433 	_vala_gir_parser_metadata_unref0 (self->priv->metadata);
1434 	self->priv->metadata = _tmp8_;
1435 	self->priv->cheader_filenames = (_vala_array_free (self->priv->cheader_filenames, self->priv->cheader_filenames_length1, (GDestroyNotify) g_free), NULL);
1436 	self->priv->cheader_filenames = NULL;
1437 	self->priv->cheader_filenames_length1 = 0;
1438 	self->priv->_cheader_filenames_size_ = self->priv->cheader_filenames_length1;
1439 	_tmp9_ = _vala_source_file_ref0 (source_file);
1440 	_vala_source_file_unref0 (self->priv->current_source_file);
1441 	self->priv->current_source_file = _tmp9_;
1442 	_tmp10_ = vala_source_file_get_filename (source_file);
1443 	_tmp11_ = _tmp10_;
1444 	_tmp12_ = vala_markup_reader_new (_tmp11_);
1445 	_vala_markup_reader_unref0 (self->priv->reader);
1446 	self->priv->reader = _tmp12_;
1447 	{
1448 		gboolean _tmp13_ = FALSE;
1449 		_tmp13_ = TRUE;
1450 		while (TRUE) {
1451 			ValaMarkupTokenType _tmp19_;
1452 			if (!_tmp13_) {
1453 				gboolean _tmp14_ = FALSE;
1454 				ValaMarkupTokenType _tmp15_;
1455 				_tmp15_ = self->priv->current_token;
1456 				if (_tmp15_ != VALA_MARKUP_TOKEN_TYPE_START_ELEMENT) {
1457 					ValaMarkupReader* _tmp16_;
1458 					const gchar* _tmp17_;
1459 					const gchar* _tmp18_;
1460 					_tmp16_ = self->priv->reader;
1461 					_tmp17_ = vala_markup_reader_get_name (_tmp16_);
1462 					_tmp18_ = _tmp17_;
1463 					_tmp14_ = g_strcmp0 (_tmp18_, "repository") != 0;
1464 				} else {
1465 					_tmp14_ = FALSE;
1466 				}
1467 				if (!_tmp14_) {
1468 					break;
1469 				}
1470 			}
1471 			_tmp13_ = FALSE;
1472 			vala_gir_parser_next (self);
1473 			_tmp19_ = self->priv->current_token;
1474 			if (_tmp19_ == VALA_MARKUP_TOKEN_TYPE_EOF) {
1475 				ValaSourceReference* _tmp20_;
1476 				ValaSourceReference* _tmp21_;
1477 				_tmp20_ = vala_gir_parser_get_current_src (self);
1478 				_tmp21_ = _tmp20_;
1479 				vala_report_error (_tmp21_, "unexpected end of file");
1480 				_vala_source_reference_unref0 (_tmp21_);
1481 				return;
1482 			}
1483 		}
1484 	}
1485 	vala_gir_parser_parse_repository (self);
1486 	_vala_markup_reader_unref0 (self->priv->reader);
1487 	self->priv->reader = NULL;
1488 	_vala_source_file_unref0 (self->priv->current_source_file);
1489 	self->priv->current_source_file = NULL;
1490 	if (!has_global_context) {
1491 		_vala_code_context_unref0 (self->priv->context);
1492 		self->priv->context = NULL;
1493 	}
1494 }
1495 
1496 static void
vala_gir_parser_next(ValaGirParser * self)1497 vala_gir_parser_next (ValaGirParser* self)
1498 {
1499 	ValaMarkupReader* _tmp0_;
1500 	ValaSourceLocation _tmp1_ = {0};
1501 	ValaSourceLocation _tmp2_ = {0};
1502 	ValaMarkupTokenType _tmp3_;
1503 	g_return_if_fail (self != NULL);
1504 	_tmp0_ = self->priv->reader;
1505 	_tmp3_ = vala_markup_reader_read_token (_tmp0_, &_tmp1_, &_tmp2_);
1506 	self->priv->begin = _tmp1_;
1507 	self->priv->end = _tmp2_;
1508 	self->priv->current_token = _tmp3_;
1509 }
1510 
1511 static void
vala_gir_parser_start_element(ValaGirParser * self,const gchar * name)1512 vala_gir_parser_start_element (ValaGirParser* self,
1513                                const gchar* name)
1514 {
1515 	gboolean _tmp0_ = FALSE;
1516 	ValaMarkupTokenType _tmp1_;
1517 	g_return_if_fail (self != NULL);
1518 	g_return_if_fail (name != NULL);
1519 	_tmp1_ = self->priv->current_token;
1520 	if (_tmp1_ != VALA_MARKUP_TOKEN_TYPE_START_ELEMENT) {
1521 		_tmp0_ = TRUE;
1522 	} else {
1523 		ValaMarkupReader* _tmp2_;
1524 		const gchar* _tmp3_;
1525 		const gchar* _tmp4_;
1526 		_tmp2_ = self->priv->reader;
1527 		_tmp3_ = vala_markup_reader_get_name (_tmp2_);
1528 		_tmp4_ = _tmp3_;
1529 		_tmp0_ = g_strcmp0 (_tmp4_, name) != 0;
1530 	}
1531 	if (_tmp0_) {
1532 		ValaSourceReference* _tmp5_;
1533 		ValaSourceReference* _tmp6_;
1534 		gchar* _tmp7_;
1535 		gchar* _tmp8_;
1536 		_tmp5_ = vala_gir_parser_get_current_src (self);
1537 		_tmp6_ = _tmp5_;
1538 		_tmp7_ = g_strdup_printf ("expected start element of `%s'", name);
1539 		_tmp8_ = _tmp7_;
1540 		vala_report_error (_tmp6_, _tmp8_);
1541 		_g_free0 (_tmp8_);
1542 		_vala_source_reference_unref0 (_tmp6_);
1543 	}
1544 }
1545 
1546 static void
vala_gir_parser_end_element(ValaGirParser * self,const gchar * name)1547 vala_gir_parser_end_element (ValaGirParser* self,
1548                              const gchar* name)
1549 {
1550 	g_return_if_fail (self != NULL);
1551 	g_return_if_fail (name != NULL);
1552 	while (TRUE) {
1553 		gboolean _tmp0_ = FALSE;
1554 		ValaMarkupTokenType _tmp1_;
1555 		ValaSourceReference* _tmp5_;
1556 		ValaSourceReference* _tmp6_;
1557 		gchar* _tmp7_;
1558 		gchar* _tmp8_;
1559 		_tmp1_ = self->priv->current_token;
1560 		if (_tmp1_ != VALA_MARKUP_TOKEN_TYPE_END_ELEMENT) {
1561 			_tmp0_ = TRUE;
1562 		} else {
1563 			ValaMarkupReader* _tmp2_;
1564 			const gchar* _tmp3_;
1565 			const gchar* _tmp4_;
1566 			_tmp2_ = self->priv->reader;
1567 			_tmp3_ = vala_markup_reader_get_name (_tmp2_);
1568 			_tmp4_ = _tmp3_;
1569 			_tmp0_ = g_strcmp0 (_tmp4_, name) != 0;
1570 		}
1571 		if (!_tmp0_) {
1572 			break;
1573 		}
1574 		_tmp5_ = vala_gir_parser_get_current_src (self);
1575 		_tmp6_ = _tmp5_;
1576 		_tmp7_ = g_strdup_printf ("expected end element of `%s'", name);
1577 		_tmp8_ = _tmp7_;
1578 		vala_report_warning (_tmp6_, _tmp8_);
1579 		_g_free0 (_tmp8_);
1580 		_vala_source_reference_unref0 (_tmp6_);
1581 		vala_gir_parser_skip_element (self);
1582 	}
1583 	vala_gir_parser_next (self);
1584 }
1585 
1586 static ValaSourceReference*
vala_gir_parser_get_current_src(ValaGirParser * self)1587 vala_gir_parser_get_current_src (ValaGirParser* self)
1588 {
1589 	ValaSourceFile* _tmp0_;
1590 	ValaSourceLocation _tmp1_;
1591 	ValaSourceLocation _tmp2_;
1592 	ValaSourceReference* _tmp3_;
1593 	ValaSourceReference* result = NULL;
1594 	g_return_val_if_fail (self != NULL, NULL);
1595 	_tmp0_ = self->priv->current_source_file;
1596 	_tmp1_ = self->priv->begin;
1597 	_tmp2_ = self->priv->end;
1598 	_tmp3_ = vala_source_reference_new (_tmp0_, &_tmp1_, &_tmp2_);
1599 	result = _tmp3_;
1600 	return result;
1601 }
1602 
1603 static ValaSourceReference*
vala_gir_parser_get_src(ValaGirParser * self,ValaSourceLocation * begin,ValaSourceLocation * end)1604 vala_gir_parser_get_src (ValaGirParser* self,
1605                          ValaSourceLocation* begin,
1606                          ValaSourceLocation* end)
1607 {
1608 	ValaSourceLocation e = {0};
1609 	ValaSourceLocation _tmp0_;
1610 	ValaSourceFile* _tmp1_;
1611 	ValaSourceLocation _tmp2_;
1612 	ValaSourceLocation _tmp3_;
1613 	ValaSourceReference* _tmp4_;
1614 	ValaSourceReference* result = NULL;
1615 	g_return_val_if_fail (self != NULL, NULL);
1616 	g_return_val_if_fail (begin != NULL, NULL);
1617 	_tmp0_ = self->priv->end;
1618 	e = _tmp0_;
1619 	if (end != NULL) {
1620 		e = *end;
1621 	}
1622 	_tmp1_ = self->priv->current_source_file;
1623 	_tmp2_ = *begin;
1624 	_tmp3_ = e;
1625 	_tmp4_ = vala_source_reference_new (_tmp1_, &_tmp2_, &_tmp3_);
1626 	result = _tmp4_;
1627 	return result;
1628 }
1629 
1630 static void
vala_gir_parser_add_symbol_to_container(ValaSymbol * container,ValaSymbol * sym)1631 vala_gir_parser_add_symbol_to_container (ValaSymbol* container,
1632                                          ValaSymbol* sym)
1633 {
1634 	g_return_if_fail (container != NULL);
1635 	g_return_if_fail (sym != NULL);
1636 	if (VALA_IS_CLASS (container)) {
1637 		ValaClass* cl = NULL;
1638 		cl = G_TYPE_CHECK_INSTANCE_CAST (container, VALA_TYPE_CLASS, ValaClass);
1639 		if (VALA_IS_CLASS (sym)) {
1640 			ValaClass* _tmp0_;
1641 			_tmp0_ = cl;
1642 			vala_symbol_add_class ((ValaSymbol*) _tmp0_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_CLASS, ValaClass));
1643 		} else {
1644 			if (VALA_IS_CONSTANT (sym)) {
1645 				ValaClass* _tmp1_;
1646 				_tmp1_ = cl;
1647 				vala_symbol_add_constant ((ValaSymbol*) _tmp1_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_CONSTANT, ValaConstant));
1648 			} else {
1649 				if (VALA_IS_ENUM (sym)) {
1650 					ValaClass* _tmp2_;
1651 					_tmp2_ = cl;
1652 					vala_symbol_add_enum ((ValaSymbol*) _tmp2_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_ENUM, ValaEnum));
1653 				} else {
1654 					if (VALA_IS_FIELD (sym)) {
1655 						ValaClass* _tmp3_;
1656 						_tmp3_ = cl;
1657 						vala_symbol_add_field ((ValaSymbol*) _tmp3_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_FIELD, ValaField));
1658 					} else {
1659 						if (VALA_IS_METHOD (sym)) {
1660 							ValaClass* _tmp4_;
1661 							_tmp4_ = cl;
1662 							vala_symbol_add_method ((ValaSymbol*) _tmp4_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_METHOD, ValaMethod));
1663 						} else {
1664 							if (VALA_IS_PROPERTY (sym)) {
1665 								ValaClass* _tmp5_;
1666 								_tmp5_ = cl;
1667 								vala_symbol_add_property ((ValaSymbol*) _tmp5_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_PROPERTY, ValaProperty));
1668 							} else {
1669 								if (VALA_IS_SIGNAL (sym)) {
1670 									ValaClass* _tmp6_;
1671 									_tmp6_ = cl;
1672 									vala_symbol_add_signal ((ValaSymbol*) _tmp6_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_SIGNAL, ValaSignal));
1673 								} else {
1674 									if (VALA_IS_STRUCT (sym)) {
1675 										ValaClass* _tmp7_;
1676 										_tmp7_ = cl;
1677 										vala_symbol_add_struct ((ValaSymbol*) _tmp7_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_STRUCT, ValaStruct));
1678 									}
1679 								}
1680 							}
1681 						}
1682 					}
1683 				}
1684 			}
1685 		}
1686 	} else {
1687 		if (VALA_IS_ENUM (container)) {
1688 			ValaEnum* en = NULL;
1689 			en = G_TYPE_CHECK_INSTANCE_CAST (container, VALA_TYPE_ENUM, ValaEnum);
1690 			if (VALA_IS_ENUM_VALUE (sym)) {
1691 				ValaEnum* _tmp8_;
1692 				_tmp8_ = en;
1693 				vala_enum_add_value (_tmp8_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_ENUM_VALUE, ValaEnumValue));
1694 			} else {
1695 				if (VALA_IS_CONSTANT (sym)) {
1696 					ValaEnum* _tmp9_;
1697 					_tmp9_ = en;
1698 					vala_symbol_add_constant ((ValaSymbol*) _tmp9_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_CONSTANT, ValaConstant));
1699 				} else {
1700 					if (VALA_IS_METHOD (sym)) {
1701 						ValaEnum* _tmp10_;
1702 						_tmp10_ = en;
1703 						vala_symbol_add_method ((ValaSymbol*) _tmp10_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_METHOD, ValaMethod));
1704 					}
1705 				}
1706 			}
1707 		} else {
1708 			if (VALA_IS_INTERFACE (container)) {
1709 				ValaInterface* iface = NULL;
1710 				iface = G_TYPE_CHECK_INSTANCE_CAST (container, VALA_TYPE_INTERFACE, ValaInterface);
1711 				if (VALA_IS_CLASS (sym)) {
1712 					ValaInterface* _tmp11_;
1713 					_tmp11_ = iface;
1714 					vala_symbol_add_class ((ValaSymbol*) _tmp11_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_CLASS, ValaClass));
1715 				} else {
1716 					if (VALA_IS_CONSTANT (sym)) {
1717 						ValaInterface* _tmp12_;
1718 						_tmp12_ = iface;
1719 						vala_symbol_add_constant ((ValaSymbol*) _tmp12_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_CONSTANT, ValaConstant));
1720 					} else {
1721 						if (VALA_IS_ENUM (sym)) {
1722 							ValaInterface* _tmp13_;
1723 							_tmp13_ = iface;
1724 							vala_symbol_add_enum ((ValaSymbol*) _tmp13_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_ENUM, ValaEnum));
1725 						} else {
1726 							if (VALA_IS_FIELD (sym)) {
1727 								ValaInterface* _tmp14_;
1728 								_tmp14_ = iface;
1729 								vala_symbol_add_field ((ValaSymbol*) _tmp14_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_FIELD, ValaField));
1730 							} else {
1731 								if (VALA_IS_METHOD (sym)) {
1732 									ValaInterface* _tmp15_;
1733 									_tmp15_ = iface;
1734 									vala_symbol_add_method ((ValaSymbol*) _tmp15_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_METHOD, ValaMethod));
1735 								} else {
1736 									if (VALA_IS_PROPERTY (sym)) {
1737 										ValaInterface* _tmp16_;
1738 										_tmp16_ = iface;
1739 										vala_symbol_add_property ((ValaSymbol*) _tmp16_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_PROPERTY, ValaProperty));
1740 									} else {
1741 										if (VALA_IS_SIGNAL (sym)) {
1742 											ValaInterface* _tmp17_;
1743 											_tmp17_ = iface;
1744 											vala_symbol_add_signal ((ValaSymbol*) _tmp17_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_SIGNAL, ValaSignal));
1745 										} else {
1746 											if (VALA_IS_STRUCT (sym)) {
1747 												ValaInterface* _tmp18_;
1748 												_tmp18_ = iface;
1749 												vala_symbol_add_struct ((ValaSymbol*) _tmp18_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_STRUCT, ValaStruct));
1750 											}
1751 										}
1752 									}
1753 								}
1754 							}
1755 						}
1756 					}
1757 				}
1758 			} else {
1759 				if (VALA_IS_NAMESPACE (container)) {
1760 					ValaNamespace* ns = NULL;
1761 					ns = G_TYPE_CHECK_INSTANCE_CAST (container, VALA_TYPE_NAMESPACE, ValaNamespace);
1762 					if (VALA_IS_NAMESPACE (sym)) {
1763 						ValaNamespace* _tmp19_;
1764 						_tmp19_ = ns;
1765 						vala_symbol_add_namespace ((ValaSymbol*) _tmp19_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_NAMESPACE, ValaNamespace));
1766 					} else {
1767 						if (VALA_IS_CLASS (sym)) {
1768 							ValaNamespace* _tmp20_;
1769 							_tmp20_ = ns;
1770 							vala_symbol_add_class ((ValaSymbol*) _tmp20_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_CLASS, ValaClass));
1771 						} else {
1772 							if (VALA_IS_CONSTANT (sym)) {
1773 								ValaNamespace* _tmp21_;
1774 								_tmp21_ = ns;
1775 								vala_symbol_add_constant ((ValaSymbol*) _tmp21_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_CONSTANT, ValaConstant));
1776 							} else {
1777 								if (VALA_IS_DELEGATE (sym)) {
1778 									ValaNamespace* _tmp22_;
1779 									_tmp22_ = ns;
1780 									vala_symbol_add_delegate ((ValaSymbol*) _tmp22_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_DELEGATE, ValaDelegate));
1781 								} else {
1782 									if (VALA_IS_ENUM (sym)) {
1783 										ValaNamespace* _tmp23_;
1784 										_tmp23_ = ns;
1785 										vala_symbol_add_enum ((ValaSymbol*) _tmp23_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_ENUM, ValaEnum));
1786 									} else {
1787 										if (VALA_IS_ERROR_DOMAIN (sym)) {
1788 											ValaNamespace* _tmp24_;
1789 											_tmp24_ = ns;
1790 											vala_symbol_add_error_domain ((ValaSymbol*) _tmp24_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_ERROR_DOMAIN, ValaErrorDomain));
1791 										} else {
1792 											if (VALA_IS_FIELD (sym)) {
1793 												ValaField* field = NULL;
1794 												ValaField* _tmp25_;
1795 												ValaMemberBinding _tmp26_;
1796 												ValaMemberBinding _tmp27_;
1797 												ValaNamespace* _tmp29_;
1798 												ValaField* _tmp30_;
1799 												field = G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_FIELD, ValaField);
1800 												_tmp25_ = field;
1801 												_tmp26_ = vala_field_get_binding (_tmp25_);
1802 												_tmp27_ = _tmp26_;
1803 												if (_tmp27_ == VALA_MEMBER_BINDING_INSTANCE) {
1804 													ValaField* _tmp28_;
1805 													_tmp28_ = field;
1806 													vala_field_set_binding (_tmp28_, VALA_MEMBER_BINDING_STATIC);
1807 												}
1808 												_tmp29_ = ns;
1809 												_tmp30_ = field;
1810 												vala_symbol_add_field ((ValaSymbol*) _tmp29_, _tmp30_);
1811 											} else {
1812 												if (VALA_IS_INTERFACE (sym)) {
1813 													ValaNamespace* _tmp31_;
1814 													_tmp31_ = ns;
1815 													vala_symbol_add_interface ((ValaSymbol*) _tmp31_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_INTERFACE, ValaInterface));
1816 												} else {
1817 													if (VALA_IS_METHOD (sym)) {
1818 														ValaMethod* method = NULL;
1819 														ValaMethod* _tmp32_;
1820 														ValaMemberBinding _tmp33_;
1821 														ValaMemberBinding _tmp34_;
1822 														ValaNamespace* _tmp36_;
1823 														ValaMethod* _tmp37_;
1824 														method = G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_METHOD, ValaMethod);
1825 														_tmp32_ = method;
1826 														_tmp33_ = vala_method_get_binding (_tmp32_);
1827 														_tmp34_ = _tmp33_;
1828 														if (_tmp34_ == VALA_MEMBER_BINDING_INSTANCE) {
1829 															ValaMethod* _tmp35_;
1830 															_tmp35_ = method;
1831 															vala_method_set_binding (_tmp35_, VALA_MEMBER_BINDING_STATIC);
1832 														}
1833 														_tmp36_ = ns;
1834 														_tmp37_ = method;
1835 														vala_symbol_add_method ((ValaSymbol*) _tmp36_, _tmp37_);
1836 													} else {
1837 														if (VALA_IS_STRUCT (sym)) {
1838 															ValaNamespace* _tmp38_;
1839 															_tmp38_ = ns;
1840 															vala_symbol_add_struct ((ValaSymbol*) _tmp38_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_STRUCT, ValaStruct));
1841 														}
1842 													}
1843 												}
1844 											}
1845 										}
1846 									}
1847 								}
1848 							}
1849 						}
1850 					}
1851 				} else {
1852 					if (VALA_IS_STRUCT (container)) {
1853 						ValaStruct* st = NULL;
1854 						st = G_TYPE_CHECK_INSTANCE_CAST (container, VALA_TYPE_STRUCT, ValaStruct);
1855 						if (VALA_IS_CONSTANT (sym)) {
1856 							ValaStruct* _tmp39_;
1857 							_tmp39_ = st;
1858 							vala_symbol_add_constant ((ValaSymbol*) _tmp39_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_CONSTANT, ValaConstant));
1859 						} else {
1860 							if (VALA_IS_FIELD (sym)) {
1861 								ValaStruct* _tmp40_;
1862 								_tmp40_ = st;
1863 								vala_symbol_add_field ((ValaSymbol*) _tmp40_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_FIELD, ValaField));
1864 							} else {
1865 								if (VALA_IS_METHOD (sym)) {
1866 									ValaStruct* _tmp41_;
1867 									_tmp41_ = st;
1868 									vala_symbol_add_method ((ValaSymbol*) _tmp41_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_METHOD, ValaMethod));
1869 								} else {
1870 									if (VALA_IS_PROPERTY (sym)) {
1871 										ValaStruct* _tmp42_;
1872 										_tmp42_ = st;
1873 										vala_symbol_add_property ((ValaSymbol*) _tmp42_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_PROPERTY, ValaProperty));
1874 									}
1875 								}
1876 							}
1877 						}
1878 					} else {
1879 						if (VALA_IS_ERROR_DOMAIN (container)) {
1880 							ValaErrorDomain* ed = NULL;
1881 							ed = G_TYPE_CHECK_INSTANCE_CAST (container, VALA_TYPE_ERROR_DOMAIN, ValaErrorDomain);
1882 							if (VALA_IS_ERROR_CODE (sym)) {
1883 								ValaErrorDomain* _tmp43_;
1884 								_tmp43_ = ed;
1885 								vala_error_domain_add_code (_tmp43_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_ERROR_CODE, ValaErrorCode));
1886 							} else {
1887 								if (VALA_IS_METHOD (sym)) {
1888 									ValaErrorDomain* _tmp44_;
1889 									_tmp44_ = ed;
1890 									vala_symbol_add_method ((ValaSymbol*) _tmp44_, G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_METHOD, ValaMethod));
1891 								}
1892 							}
1893 						} else {
1894 							ValaSourceReference* _tmp45_;
1895 							ValaSourceReference* _tmp46_;
1896 							const gchar* _tmp47_;
1897 							const gchar* _tmp48_;
1898 							const gchar* _tmp49_;
1899 							const gchar* _tmp50_;
1900 							gchar* _tmp51_;
1901 							gchar* _tmp52_;
1902 							_tmp45_ = vala_code_node_get_source_reference ((ValaCodeNode*) sym);
1903 							_tmp46_ = _tmp45_;
1904 							_tmp47_ = vala_symbol_get_name (sym);
1905 							_tmp48_ = _tmp47_;
1906 							_tmp49_ = vala_symbol_get_name (container);
1907 							_tmp50_ = _tmp49_;
1908 							_tmp51_ = g_strdup_printf ("impossible to add `%s' to container `%s'", _tmp48_, _tmp50_);
1909 							_tmp52_ = _tmp51_;
1910 							vala_report_error (_tmp46_, _tmp52_);
1911 							_g_free0 (_tmp52_);
1912 						}
1913 					}
1914 				}
1915 			}
1916 		}
1917 	}
1918 }
1919 
1920 static gboolean
vala_gir_parser_is_container(ValaSymbol * sym)1921 vala_gir_parser_is_container (ValaSymbol* sym)
1922 {
1923 	gboolean _tmp0_ = FALSE;
1924 	gboolean _tmp1_ = FALSE;
1925 	gboolean _tmp2_ = FALSE;
1926 	gboolean _tmp3_ = FALSE;
1927 	gboolean result = FALSE;
1928 	g_return_val_if_fail (sym != NULL, FALSE);
1929 	if (VALA_IS_OBJECT_TYPE_SYMBOL (sym)) {
1930 		_tmp3_ = TRUE;
1931 	} else {
1932 		_tmp3_ = VALA_IS_STRUCT (sym);
1933 	}
1934 	if (_tmp3_) {
1935 		_tmp2_ = TRUE;
1936 	} else {
1937 		_tmp2_ = VALA_IS_NAMESPACE (sym);
1938 	}
1939 	if (_tmp2_) {
1940 		_tmp1_ = TRUE;
1941 	} else {
1942 		_tmp1_ = VALA_IS_ERROR_DOMAIN (sym);
1943 	}
1944 	if (_tmp1_) {
1945 		_tmp0_ = TRUE;
1946 	} else {
1947 		_tmp0_ = VALA_IS_ENUM (sym);
1948 	}
1949 	result = _tmp0_;
1950 	return result;
1951 }
1952 
1953 static ValaUnresolvedSymbol*
vala_gir_parser_parse_symbol_from_string(ValaGirParser * self,const gchar * symbol_string,ValaSourceReference * source_reference)1954 vala_gir_parser_parse_symbol_from_string (ValaGirParser* self,
1955                                           const gchar* symbol_string,
1956                                           ValaSourceReference* source_reference)
1957 {
1958 	ValaUnresolvedSymbol* sym = NULL;
1959 	gchar** _tmp0_;
1960 	gchar** _tmp1_;
1961 	ValaUnresolvedSymbol* _tmp5_;
1962 	ValaUnresolvedSymbol* result = NULL;
1963 	g_return_val_if_fail (self != NULL, NULL);
1964 	g_return_val_if_fail (symbol_string != NULL, NULL);
1965 	sym = NULL;
1966 	_tmp1_ = _tmp0_ = g_strsplit (symbol_string, ".", 0);
1967 	{
1968 		gchar** s_collection = NULL;
1969 		gint s_collection_length1 = 0;
1970 		gint _s_collection_size_ = 0;
1971 		gint s_it = 0;
1972 		s_collection = _tmp1_;
1973 		s_collection_length1 = _vala_array_length (_tmp0_);
1974 		for (s_it = 0; s_it < s_collection_length1; s_it = s_it + 1) {
1975 			const gchar* s = NULL;
1976 			s = s_collection[s_it];
1977 			{
1978 				ValaUnresolvedSymbol* _tmp2_;
1979 				const gchar* _tmp3_;
1980 				ValaUnresolvedSymbol* _tmp4_;
1981 				_tmp2_ = sym;
1982 				_tmp3_ = s;
1983 				_tmp4_ = vala_unresolved_symbol_new (_tmp2_, _tmp3_, source_reference);
1984 				_vala_code_node_unref0 (sym);
1985 				sym = _tmp4_;
1986 			}
1987 		}
1988 		s_collection = (_vala_array_free (s_collection, s_collection_length1, (GDestroyNotify) g_free), NULL);
1989 	}
1990 	_tmp5_ = sym;
1991 	if (_tmp5_ == NULL) {
1992 		vala_report_error (source_reference, "a symbol must be specified");
1993 	}
1994 	result = sym;
1995 	return result;
1996 }
1997 
1998 static void
vala_gir_parser_set_symbol_mapping(ValaGirParser * self,ValaUnresolvedSymbol * map_from,ValaSymbol * map_to)1999 vala_gir_parser_set_symbol_mapping (ValaGirParser* self,
2000                                     ValaUnresolvedSymbol* map_from,
2001                                     ValaSymbol* map_to)
2002 {
2003 	g_return_if_fail (self != NULL);
2004 	g_return_if_fail (map_from != NULL);
2005 	g_return_if_fail (map_to != NULL);
2006 	if (VALA_IS_UNRESOLVED_SYMBOL (map_from)) {
2007 		ValaHashMap* _tmp0_;
2008 		_tmp0_ = self->priv->unresolved_symbols_map;
2009 		vala_map_set ((ValaMap*) _tmp0_, G_TYPE_CHECK_INSTANCE_CAST (map_from, VALA_TYPE_UNRESOLVED_SYMBOL, ValaUnresolvedSymbol), map_to);
2010 	}
2011 }
2012 
2013 static void
vala_gir_parser_assume_parameter_names(ValaGirParser * self,ValaSignal * sig,ValaSymbol * sym,gboolean skip_first)2014 vala_gir_parser_assume_parameter_names (ValaGirParser* self,
2015                                         ValaSignal* sig,
2016                                         ValaSymbol* sym,
2017                                         gboolean skip_first)
2018 {
2019 	ValaIterator* iter = NULL;
2020 	ValaList* _tmp0_;
2021 	ValaIterator* _tmp1_;
2022 	gboolean first = FALSE;
2023 	g_return_if_fail (self != NULL);
2024 	g_return_if_fail (sig != NULL);
2025 	g_return_if_fail (sym != NULL);
2026 	_tmp0_ = vala_callable_get_parameters (G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_CALLABLE, ValaCallable));
2027 	_tmp1_ = vala_iterable_iterator ((ValaIterable*) _tmp0_);
2028 	iter = _tmp1_;
2029 	first = TRUE;
2030 	{
2031 		ValaList* _param_list = NULL;
2032 		ValaList* _tmp2_;
2033 		ValaList* _tmp3_;
2034 		gint _param_size = 0;
2035 		ValaList* _tmp4_;
2036 		gint _tmp5_;
2037 		gint _tmp6_;
2038 		gint _param_index = 0;
2039 		_tmp2_ = vala_callable_get_parameters ((ValaCallable*) sig);
2040 		_tmp3_ = _vala_iterable_ref0 (_tmp2_);
2041 		_param_list = _tmp3_;
2042 		_tmp4_ = _param_list;
2043 		_tmp5_ = vala_collection_get_size ((ValaCollection*) _tmp4_);
2044 		_tmp6_ = _tmp5_;
2045 		_param_size = _tmp6_;
2046 		_param_index = -1;
2047 		while (TRUE) {
2048 			gint _tmp7_;
2049 			gint _tmp8_;
2050 			ValaParameter* param = NULL;
2051 			ValaList* _tmp9_;
2052 			gpointer _tmp10_;
2053 			ValaIterator* _tmp11_;
2054 			gboolean _tmp12_ = FALSE;
2055 			ValaParameter* _tmp14_;
2056 			ValaIterator* _tmp15_;
2057 			gpointer _tmp16_;
2058 			ValaParameter* _tmp17_;
2059 			const gchar* _tmp18_;
2060 			const gchar* _tmp19_;
2061 			_param_index = _param_index + 1;
2062 			_tmp7_ = _param_index;
2063 			_tmp8_ = _param_size;
2064 			if (!(_tmp7_ < _tmp8_)) {
2065 				break;
2066 			}
2067 			_tmp9_ = _param_list;
2068 			_tmp10_ = vala_list_get (_tmp9_, _param_index);
2069 			param = (ValaParameter*) _tmp10_;
2070 			_tmp11_ = iter;
2071 			if (!vala_iterator_next (_tmp11_)) {
2072 				_vala_code_node_unref0 (param);
2073 				break;
2074 			}
2075 			if (skip_first) {
2076 				_tmp12_ = first;
2077 			} else {
2078 				_tmp12_ = FALSE;
2079 			}
2080 			if (_tmp12_) {
2081 				ValaIterator* _tmp13_;
2082 				_tmp13_ = iter;
2083 				if (!vala_iterator_next (_tmp13_)) {
2084 					_vala_code_node_unref0 (param);
2085 					break;
2086 				}
2087 				first = FALSE;
2088 			}
2089 			_tmp14_ = param;
2090 			_tmp15_ = iter;
2091 			_tmp16_ = vala_iterator_get (_tmp15_);
2092 			_tmp17_ = (ValaParameter*) _tmp16_;
2093 			_tmp18_ = vala_symbol_get_name ((ValaSymbol*) _tmp17_);
2094 			_tmp19_ = _tmp18_;
2095 			vala_symbol_set_name ((ValaSymbol*) _tmp14_, _tmp19_);
2096 			_vala_code_node_unref0 (_tmp17_);
2097 			_vala_code_node_unref0 (param);
2098 		}
2099 		_vala_iterable_unref0 (_param_list);
2100 	}
2101 	_vala_iterator_unref0 (iter);
2102 }
2103 
2104 static ValaGirParserNode*
vala_gir_parser_find_invoker(ValaGirParser * self,ValaGirParserNode * node)2105 vala_gir_parser_find_invoker (ValaGirParser* self,
2106                               ValaGirParserNode* node)
2107 {
2108 	ValaMethod* m = NULL;
2109 	ValaSymbol* _tmp0_;
2110 	ValaMethod* _tmp1_;
2111 	gchar* prefix = NULL;
2112 	ValaMethod* _tmp2_;
2113 	const gchar* _tmp3_;
2114 	const gchar* _tmp4_;
2115 	gchar* _tmp5_;
2116 	ValaGirParserNode* result = NULL;
2117 	g_return_val_if_fail (self != NULL, NULL);
2118 	g_return_val_if_fail (node != NULL, NULL);
2119 	_tmp0_ = node->symbol;
2120 	_tmp1_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALA_TYPE_METHOD, ValaMethod));
2121 	m = _tmp1_;
2122 	_tmp2_ = m;
2123 	_tmp3_ = vala_symbol_get_name ((ValaSymbol*) _tmp2_);
2124 	_tmp4_ = _tmp3_;
2125 	_tmp5_ = g_strdup_printf ("%s_", _tmp4_);
2126 	prefix = _tmp5_;
2127 	{
2128 		ValaArrayList* _n_list = NULL;
2129 		ValaGirParserNode* _tmp6_;
2130 		ValaArrayList* _tmp7_;
2131 		ValaArrayList* _tmp8_;
2132 		gint _n_size = 0;
2133 		ValaArrayList* _tmp9_;
2134 		gint _tmp10_;
2135 		gint _tmp11_;
2136 		gint _n_index = 0;
2137 		_tmp6_ = node->parent;
2138 		_tmp7_ = _tmp6_->members;
2139 		_tmp8_ = _vala_iterable_ref0 (_tmp7_);
2140 		_n_list = _tmp8_;
2141 		_tmp9_ = _n_list;
2142 		_tmp10_ = vala_collection_get_size ((ValaCollection*) _tmp9_);
2143 		_tmp11_ = _tmp10_;
2144 		_n_size = _tmp11_;
2145 		_n_index = -1;
2146 		while (TRUE) {
2147 			gint _tmp12_;
2148 			gint _tmp13_;
2149 			ValaGirParserNode* n = NULL;
2150 			ValaArrayList* _tmp14_;
2151 			gpointer _tmp15_;
2152 			ValaGirParserNode* _tmp16_;
2153 			const gchar* _tmp17_;
2154 			const gchar* _tmp18_;
2155 			ValaMethod* invoker = NULL;
2156 			ValaGirParserNode* _tmp19_;
2157 			ValaSymbol* _tmp20_;
2158 			ValaMethod* _tmp21_;
2159 			gboolean _tmp22_ = FALSE;
2160 			ValaMethod* _tmp23_;
2161 			ValaIterator* iter = NULL;
2162 			ValaMethod* _tmp32_;
2163 			ValaList* _tmp33_;
2164 			ValaIterator* _tmp34_;
2165 			ValaMethod* _tmp55_;
2166 			_n_index = _n_index + 1;
2167 			_tmp12_ = _n_index;
2168 			_tmp13_ = _n_size;
2169 			if (!(_tmp12_ < _tmp13_)) {
2170 				break;
2171 			}
2172 			_tmp14_ = _n_list;
2173 			_tmp15_ = vala_list_get ((ValaList*) _tmp14_, _n_index);
2174 			n = (ValaGirParserNode*) _tmp15_;
2175 			_tmp16_ = n;
2176 			_tmp17_ = _tmp16_->name;
2177 			_tmp18_ = prefix;
2178 			if (!g_str_has_prefix (_tmp17_, _tmp18_)) {
2179 				_vala_gir_parser_node_unref0 (n);
2180 				continue;
2181 			}
2182 			_tmp19_ = n;
2183 			_tmp20_ = _tmp19_->symbol;
2184 			_tmp21_ = _vala_code_node_ref0 (VALA_IS_METHOD (_tmp20_) ? ((ValaMethod*) _tmp20_) : NULL);
2185 			invoker = _tmp21_;
2186 			_tmp23_ = invoker;
2187 			if (_tmp23_ == NULL) {
2188 				_tmp22_ = TRUE;
2189 			} else {
2190 				ValaMethod* _tmp24_;
2191 				ValaList* _tmp25_;
2192 				gint _tmp26_;
2193 				gint _tmp27_;
2194 				ValaMethod* _tmp28_;
2195 				ValaList* _tmp29_;
2196 				gint _tmp30_;
2197 				gint _tmp31_;
2198 				_tmp24_ = m;
2199 				_tmp25_ = vala_callable_get_parameters ((ValaCallable*) _tmp24_);
2200 				_tmp26_ = vala_collection_get_size ((ValaCollection*) _tmp25_);
2201 				_tmp27_ = _tmp26_;
2202 				_tmp28_ = invoker;
2203 				_tmp29_ = vala_callable_get_parameters ((ValaCallable*) _tmp28_);
2204 				_tmp30_ = vala_collection_get_size ((ValaCollection*) _tmp29_);
2205 				_tmp31_ = _tmp30_;
2206 				_tmp22_ = _tmp27_ != _tmp31_;
2207 			}
2208 			if (_tmp22_) {
2209 				_vala_code_node_unref0 (invoker);
2210 				_vala_gir_parser_node_unref0 (n);
2211 				continue;
2212 			}
2213 			_tmp32_ = invoker;
2214 			_tmp33_ = vala_callable_get_parameters ((ValaCallable*) _tmp32_);
2215 			_tmp34_ = vala_iterable_iterator ((ValaIterable*) _tmp33_);
2216 			iter = _tmp34_;
2217 			{
2218 				ValaList* _param_list = NULL;
2219 				ValaMethod* _tmp35_;
2220 				ValaList* _tmp36_;
2221 				ValaList* _tmp37_;
2222 				gint _param_size = 0;
2223 				ValaList* _tmp38_;
2224 				gint _tmp39_;
2225 				gint _tmp40_;
2226 				gint _param_index = 0;
2227 				_tmp35_ = m;
2228 				_tmp36_ = vala_callable_get_parameters ((ValaCallable*) _tmp35_);
2229 				_tmp37_ = _vala_iterable_ref0 (_tmp36_);
2230 				_param_list = _tmp37_;
2231 				_tmp38_ = _param_list;
2232 				_tmp39_ = vala_collection_get_size ((ValaCollection*) _tmp38_);
2233 				_tmp40_ = _tmp39_;
2234 				_param_size = _tmp40_;
2235 				_param_index = -1;
2236 				while (TRUE) {
2237 					gint _tmp41_;
2238 					gint _tmp42_;
2239 					ValaParameter* param = NULL;
2240 					ValaList* _tmp43_;
2241 					gpointer _tmp44_;
2242 					ValaIterator* _tmp45_;
2243 					ValaParameter* _tmp46_;
2244 					const gchar* _tmp47_;
2245 					const gchar* _tmp48_;
2246 					ValaIterator* _tmp49_;
2247 					gpointer _tmp50_;
2248 					ValaParameter* _tmp51_;
2249 					const gchar* _tmp52_;
2250 					const gchar* _tmp53_;
2251 					gboolean _tmp54_;
2252 					_param_index = _param_index + 1;
2253 					_tmp41_ = _param_index;
2254 					_tmp42_ = _param_size;
2255 					if (!(_tmp41_ < _tmp42_)) {
2256 						break;
2257 					}
2258 					_tmp43_ = _param_list;
2259 					_tmp44_ = vala_list_get (_tmp43_, _param_index);
2260 					param = (ValaParameter*) _tmp44_;
2261 					_tmp45_ = iter;
2262 					_vala_assert (vala_iterator_next (_tmp45_), "iter.next ()");
2263 					_tmp46_ = param;
2264 					_tmp47_ = vala_symbol_get_name ((ValaSymbol*) _tmp46_);
2265 					_tmp48_ = _tmp47_;
2266 					_tmp49_ = iter;
2267 					_tmp50_ = vala_iterator_get (_tmp49_);
2268 					_tmp51_ = (ValaParameter*) _tmp50_;
2269 					_tmp52_ = vala_symbol_get_name ((ValaSymbol*) _tmp51_);
2270 					_tmp53_ = _tmp52_;
2271 					_tmp54_ = g_strcmp0 (_tmp48_, _tmp53_) != 0;
2272 					_vala_code_node_unref0 (_tmp51_);
2273 					if (_tmp54_) {
2274 						_vala_code_node_unref0 (invoker);
2275 						invoker = NULL;
2276 						_vala_code_node_unref0 (param);
2277 						break;
2278 					}
2279 					_vala_code_node_unref0 (param);
2280 				}
2281 				_vala_iterable_unref0 (_param_list);
2282 			}
2283 			_tmp55_ = invoker;
2284 			if (_tmp55_ != NULL) {
2285 				result = n;
2286 				_vala_iterator_unref0 (iter);
2287 				_vala_code_node_unref0 (invoker);
2288 				_vala_iterable_unref0 (_n_list);
2289 				_g_free0 (prefix);
2290 				_vala_code_node_unref0 (m);
2291 				return result;
2292 			}
2293 			_vala_iterator_unref0 (iter);
2294 			_vala_code_node_unref0 (invoker);
2295 			_vala_gir_parser_node_unref0 (n);
2296 		}
2297 		_vala_iterable_unref0 (_n_list);
2298 	}
2299 	result = NULL;
2300 	_g_free0 (prefix);
2301 	_vala_code_node_unref0 (m);
2302 	return result;
2303 }
2304 
2305 static glong
string_strnlen(gchar * str,glong maxlen)2306 string_strnlen (gchar* str,
2307                 glong maxlen)
2308 {
2309 	gchar* end = NULL;
2310 	gchar* _tmp0_;
2311 	gchar* _tmp1_;
2312 	glong result = 0L;
2313 	_tmp0_ = memchr (str, 0, (gsize) maxlen);
2314 	end = _tmp0_;
2315 	_tmp1_ = end;
2316 	if (_tmp1_ == NULL) {
2317 		result = maxlen;
2318 		return result;
2319 	} else {
2320 		gchar* _tmp2_;
2321 		_tmp2_ = end;
2322 		result = (glong) (_tmp2_ - str);
2323 		return result;
2324 	}
2325 }
2326 
2327 static gchar*
string_substring(const gchar * self,glong offset,glong len)2328 string_substring (const gchar* self,
2329                   glong offset,
2330                   glong len)
2331 {
2332 	glong string_length = 0L;
2333 	gboolean _tmp0_ = FALSE;
2334 	gchar* _tmp3_;
2335 	gchar* result = NULL;
2336 	g_return_val_if_fail (self != NULL, NULL);
2337 	if (offset >= ((glong) 0)) {
2338 		_tmp0_ = len >= ((glong) 0);
2339 	} else {
2340 		_tmp0_ = FALSE;
2341 	}
2342 	if (_tmp0_) {
2343 		string_length = string_strnlen ((gchar*) self, offset + len);
2344 	} else {
2345 		gint _tmp1_;
2346 		gint _tmp2_;
2347 		_tmp1_ = strlen (self);
2348 		_tmp2_ = _tmp1_;
2349 		string_length = (glong) _tmp2_;
2350 	}
2351 	if (offset < ((glong) 0)) {
2352 		offset = string_length + offset;
2353 		g_return_val_if_fail (offset >= ((glong) 0), NULL);
2354 	} else {
2355 		g_return_val_if_fail (offset <= string_length, NULL);
2356 	}
2357 	if (len < ((glong) 0)) {
2358 		len = string_length - offset;
2359 	}
2360 	g_return_val_if_fail ((offset + len) <= string_length, NULL);
2361 	_tmp3_ = g_strndup (((gchar*) self) + offset, (gsize) len);
2362 	result = _tmp3_;
2363 	return result;
2364 }
2365 
2366 static ValaGirParserMetadata*
vala_gir_parser_get_current_metadata(ValaGirParser * self)2367 vala_gir_parser_get_current_metadata (ValaGirParser* self)
2368 {
2369 	gchar* selector = NULL;
2370 	ValaMarkupReader* _tmp0_;
2371 	const gchar* _tmp1_;
2372 	const gchar* _tmp2_;
2373 	gchar* _tmp3_;
2374 	gchar* child_name = NULL;
2375 	ValaMarkupReader* _tmp4_;
2376 	gchar* _tmp5_;
2377 	const gchar* _tmp6_;
2378 	gboolean _tmp9_ = FALSE;
2379 	const gchar* _tmp10_;
2380 	const gchar* _tmp13_;
2381 	const gchar* _tmp17_;
2382 	gchar* _tmp18_;
2383 	const gchar* _tmp19_;
2384 	gchar* _tmp20_;
2385 	const gchar* _tmp21_;
2386 	ValaGirParserMetadata* _tmp26_;
2387 	const gchar* _tmp27_;
2388 	const gchar* _tmp28_;
2389 	ValaGirParserMetadata* _tmp29_;
2390 	ValaGirParserMetadata* result = NULL;
2391 	g_return_val_if_fail (self != NULL, NULL);
2392 	_tmp0_ = self->priv->reader;
2393 	_tmp1_ = vala_markup_reader_get_name (_tmp0_);
2394 	_tmp2_ = _tmp1_;
2395 	_tmp3_ = g_strdup (_tmp2_);
2396 	selector = _tmp3_;
2397 	_tmp4_ = self->priv->reader;
2398 	_tmp5_ = vala_markup_reader_get_attribute (_tmp4_, "name");
2399 	child_name = _tmp5_;
2400 	_tmp6_ = child_name;
2401 	if (_tmp6_ == NULL) {
2402 		ValaMarkupReader* _tmp7_;
2403 		gchar* _tmp8_;
2404 		_tmp7_ = self->priv->reader;
2405 		_tmp8_ = vala_markup_reader_get_attribute (_tmp7_, "glib:name");
2406 		_g_free0 (child_name);
2407 		child_name = _tmp8_;
2408 	}
2409 	_tmp10_ = selector;
2410 	if (g_strcmp0 (_tmp10_, "union") == 0) {
2411 		const gchar* _tmp11_;
2412 		_tmp11_ = child_name;
2413 		_tmp9_ = _tmp11_ == NULL;
2414 	} else {
2415 		_tmp9_ = FALSE;
2416 	}
2417 	if (_tmp9_) {
2418 		gchar* _tmp12_;
2419 		_tmp12_ = g_strdup ("union");
2420 		_g_free0 (child_name);
2421 		child_name = _tmp12_;
2422 	}
2423 	_tmp13_ = child_name;
2424 	if (_tmp13_ == NULL) {
2425 		ValaGirParserMetadata* _tmp14_;
2426 		ValaGirParserMetadata* _tmp15_;
2427 		ValaGirParserMetadata* _tmp16_;
2428 		_tmp14_ = vala_gir_parser_metadata_get_empty ();
2429 		_tmp15_ = _tmp14_;
2430 		_tmp16_ = _vala_gir_parser_metadata_ref0 (_tmp15_);
2431 		result = _tmp16_;
2432 		_g_free0 (child_name);
2433 		_g_free0 (selector);
2434 		return result;
2435 	}
2436 	_tmp17_ = selector;
2437 	_tmp18_ = string_replace (_tmp17_, "-", "_");
2438 	_g_free0 (selector);
2439 	selector = _tmp18_;
2440 	_tmp19_ = child_name;
2441 	_tmp20_ = string_replace (_tmp19_, "-", "_");
2442 	_g_free0 (child_name);
2443 	child_name = _tmp20_;
2444 	_tmp21_ = selector;
2445 	if (g_str_has_prefix (_tmp21_, "glib:")) {
2446 		const gchar* _tmp22_;
2447 		gint _tmp23_;
2448 		gint _tmp24_;
2449 		gchar* _tmp25_;
2450 		_tmp22_ = selector;
2451 		_tmp23_ = strlen ("glib:");
2452 		_tmp24_ = _tmp23_;
2453 		_tmp25_ = string_substring (_tmp22_, (glong) _tmp24_, (glong) -1);
2454 		_g_free0 (selector);
2455 		selector = _tmp25_;
2456 	}
2457 	_tmp26_ = self->priv->metadata;
2458 	_tmp27_ = child_name;
2459 	_tmp28_ = selector;
2460 	_tmp29_ = vala_gir_parser_metadata_match_child (_tmp26_, _tmp27_, _tmp28_);
2461 	result = _tmp29_;
2462 	_g_free0 (child_name);
2463 	_g_free0 (selector);
2464 	return result;
2465 }
2466 
2467 static gboolean
vala_gir_parser_push_metadata(ValaGirParser * self)2468 vala_gir_parser_push_metadata (ValaGirParser* self)
2469 {
2470 	ValaGirParserMetadata* new_metadata = NULL;
2471 	ValaGirParserMetadata* _tmp0_;
2472 	ValaGirParserMetadata* _tmp1_;
2473 	ValaArrayList* _tmp11_;
2474 	ValaGirParserMetadata* _tmp12_;
2475 	ValaGirParserMetadata* _tmp13_;
2476 	ValaGirParserMetadata* _tmp14_;
2477 	gboolean result = FALSE;
2478 	g_return_val_if_fail (self != NULL, FALSE);
2479 	_tmp0_ = vala_gir_parser_get_current_metadata (self);
2480 	new_metadata = _tmp0_;
2481 	_tmp1_ = new_metadata;
2482 	if (vala_gir_parser_metadata_has_argument (_tmp1_, VALA_GIR_PARSER_ARGUMENT_TYPE_SKIP)) {
2483 		ValaGirParserMetadata* _tmp2_;
2484 		_tmp2_ = new_metadata;
2485 		if (vala_gir_parser_metadata_get_bool (_tmp2_, VALA_GIR_PARSER_ARGUMENT_TYPE_SKIP, FALSE)) {
2486 			result = FALSE;
2487 			_vala_gir_parser_metadata_unref0 (new_metadata);
2488 			return result;
2489 		}
2490 	} else {
2491 		gboolean _tmp3_ = FALSE;
2492 		ValaMarkupReader* _tmp4_;
2493 		gchar* _tmp5_;
2494 		gchar* _tmp6_;
2495 		gboolean _tmp7_;
2496 		_tmp4_ = self->priv->reader;
2497 		_tmp5_ = vala_markup_reader_get_attribute (_tmp4_, "introspectable");
2498 		_tmp6_ = _tmp5_;
2499 		_tmp7_ = g_strcmp0 (_tmp6_, "0") == 0;
2500 		_g_free0 (_tmp6_);
2501 		if (_tmp7_) {
2502 			_tmp3_ = TRUE;
2503 		} else {
2504 			ValaMarkupReader* _tmp8_;
2505 			gchar* _tmp9_;
2506 			gchar* _tmp10_;
2507 			_tmp8_ = self->priv->reader;
2508 			_tmp9_ = vala_markup_reader_get_attribute (_tmp8_, "private");
2509 			_tmp10_ = _tmp9_;
2510 			_tmp3_ = g_strcmp0 (_tmp10_, "1") == 0;
2511 			_g_free0 (_tmp10_);
2512 		}
2513 		if (_tmp3_) {
2514 			result = FALSE;
2515 			_vala_gir_parser_metadata_unref0 (new_metadata);
2516 			return result;
2517 		}
2518 	}
2519 	_tmp11_ = self->priv->metadata_stack;
2520 	_tmp12_ = self->priv->metadata;
2521 	vala_collection_add ((ValaCollection*) _tmp11_, _tmp12_);
2522 	_tmp13_ = new_metadata;
2523 	_tmp14_ = _vala_gir_parser_metadata_ref0 (_tmp13_);
2524 	_vala_gir_parser_metadata_unref0 (self->priv->metadata);
2525 	self->priv->metadata = _tmp14_;
2526 	result = TRUE;
2527 	_vala_gir_parser_metadata_unref0 (new_metadata);
2528 	return result;
2529 }
2530 
2531 static void
vala_gir_parser_pop_metadata(ValaGirParser * self)2532 vala_gir_parser_pop_metadata (ValaGirParser* self)
2533 {
2534 	ValaArrayList* _tmp0_;
2535 	ValaArrayList* _tmp1_;
2536 	gint _tmp2_;
2537 	gint _tmp3_;
2538 	gpointer _tmp4_;
2539 	g_return_if_fail (self != NULL);
2540 	_tmp0_ = self->priv->metadata_stack;
2541 	_tmp1_ = self->priv->metadata_stack;
2542 	_tmp2_ = vala_collection_get_size ((ValaCollection*) _tmp1_);
2543 	_tmp3_ = _tmp2_;
2544 	_tmp4_ = vala_list_remove_at ((ValaList*) _tmp0_, _tmp3_ - 1);
2545 	_vala_gir_parser_metadata_unref0 (self->priv->metadata);
2546 	self->priv->metadata = (ValaGirParserMetadata*) _tmp4_;
2547 }
2548 
2549 static gchar
string_get(const gchar * self,glong index)2550 string_get (const gchar* self,
2551             glong index)
2552 {
2553 	gchar _tmp0_;
2554 	gchar result = '\0';
2555 	g_return_val_if_fail (self != NULL, '\0');
2556 	_tmp0_ = ((gchar*) self)[index];
2557 	result = _tmp0_;
2558 	return result;
2559 }
2560 
2561 static gboolean
vala_gir_parser_parse_type_arguments_from_string(ValaGirParser * self,ValaDataType * parent_type,const gchar * type_arguments,ValaSourceReference * source_reference)2562 vala_gir_parser_parse_type_arguments_from_string (ValaGirParser* self,
2563                                                   ValaDataType* parent_type,
2564                                                   const gchar* type_arguments,
2565                                                   ValaSourceReference* source_reference)
2566 {
2567 	gint type_arguments_length = 0;
2568 	gint _tmp0_;
2569 	gint _tmp1_;
2570 	GString* current = NULL;
2571 	GString* _tmp2_;
2572 	gint depth = 0;
2573 	ValaDataType* dt = NULL;
2574 	GString* _tmp19_;
2575 	const gchar* _tmp20_;
2576 	ValaDataType* _tmp21_;
2577 	ValaDataType* _tmp22_;
2578 	ValaDataType* _tmp23_;
2579 	gboolean result = FALSE;
2580 	g_return_val_if_fail (self != NULL, FALSE);
2581 	g_return_val_if_fail (parent_type != NULL, FALSE);
2582 	g_return_val_if_fail (type_arguments != NULL, FALSE);
2583 	_tmp0_ = strlen (type_arguments);
2584 	_tmp1_ = _tmp0_;
2585 	type_arguments_length = (gint) _tmp1_;
2586 	_tmp2_ = g_string_sized_new ((gsize) type_arguments_length);
2587 	current = _tmp2_;
2588 	depth = 0;
2589 	{
2590 		gint c = 0;
2591 		c = 0;
2592 		{
2593 			gboolean _tmp3_ = FALSE;
2594 			_tmp3_ = TRUE;
2595 			while (TRUE) {
2596 				gboolean _tmp5_ = FALSE;
2597 				if (!_tmp3_) {
2598 					gint _tmp4_;
2599 					_tmp4_ = c;
2600 					c = _tmp4_ + 1;
2601 				}
2602 				_tmp3_ = FALSE;
2603 				if (!(c < type_arguments_length)) {
2604 					break;
2605 				}
2606 				if (string_get (type_arguments, (glong) c) == '<') {
2607 					_tmp5_ = TRUE;
2608 				} else {
2609 					_tmp5_ = string_get (type_arguments, (glong) c) == '[';
2610 				}
2611 				if (_tmp5_) {
2612 					gint _tmp6_;
2613 					GString* _tmp7_;
2614 					_tmp6_ = depth;
2615 					depth = _tmp6_ + 1;
2616 					_tmp7_ = current;
2617 					g_string_append_unichar (_tmp7_, (gunichar) string_get (type_arguments, (glong) c));
2618 				} else {
2619 					gboolean _tmp8_ = FALSE;
2620 					if (string_get (type_arguments, (glong) c) == '>') {
2621 						_tmp8_ = TRUE;
2622 					} else {
2623 						_tmp8_ = string_get (type_arguments, (glong) c) == ']';
2624 					}
2625 					if (_tmp8_) {
2626 						gint _tmp9_;
2627 						GString* _tmp10_;
2628 						_tmp9_ = depth;
2629 						depth = _tmp9_ - 1;
2630 						_tmp10_ = current;
2631 						g_string_append_unichar (_tmp10_, (gunichar) string_get (type_arguments, (glong) c));
2632 					} else {
2633 						if (string_get (type_arguments, (glong) c) == ',') {
2634 							if (depth == 0) {
2635 								ValaDataType* dt = NULL;
2636 								GString* _tmp11_;
2637 								const gchar* _tmp12_;
2638 								ValaDataType* _tmp13_;
2639 								ValaDataType* _tmp14_;
2640 								ValaDataType* _tmp15_;
2641 								GString* _tmp16_;
2642 								_tmp11_ = current;
2643 								_tmp12_ = _tmp11_->str;
2644 								_tmp13_ = vala_gir_parser_parse_type_from_string (self, _tmp12_, TRUE, source_reference);
2645 								dt = _tmp13_;
2646 								_tmp14_ = dt;
2647 								if (_tmp14_ == NULL) {
2648 									result = FALSE;
2649 									_vala_code_node_unref0 (dt);
2650 									_g_string_free0 (current);
2651 									return result;
2652 								}
2653 								_tmp15_ = dt;
2654 								vala_data_type_add_type_argument (parent_type, _tmp15_);
2655 								_tmp16_ = current;
2656 								g_string_truncate (_tmp16_, (gsize) 0);
2657 								_vala_code_node_unref0 (dt);
2658 							} else {
2659 								GString* _tmp17_;
2660 								_tmp17_ = current;
2661 								g_string_append_unichar (_tmp17_, (gunichar) string_get (type_arguments, (glong) c));
2662 							}
2663 						} else {
2664 							GString* _tmp18_;
2665 							_tmp18_ = current;
2666 							g_string_append_unichar (_tmp18_, (gunichar) string_get (type_arguments, (glong) c));
2667 						}
2668 					}
2669 				}
2670 			}
2671 		}
2672 	}
2673 	_tmp19_ = current;
2674 	_tmp20_ = _tmp19_->str;
2675 	_tmp21_ = vala_gir_parser_parse_type_from_string (self, _tmp20_, TRUE, source_reference);
2676 	dt = _tmp21_;
2677 	_tmp22_ = dt;
2678 	if (_tmp22_ == NULL) {
2679 		result = FALSE;
2680 		_vala_code_node_unref0 (dt);
2681 		_g_string_free0 (current);
2682 		return result;
2683 	}
2684 	_tmp23_ = dt;
2685 	vala_data_type_add_type_argument (parent_type, _tmp23_);
2686 	result = TRUE;
2687 	_vala_code_node_unref0 (dt);
2688 	_g_string_free0 (current);
2689 	return result;
2690 }
2691 
2692 static ValaDataType*
vala_gir_parser_parse_type_from_string(ValaGirParser * self,const gchar * type_string,gboolean owned_by_default,ValaSourceReference * source_reference)2693 vala_gir_parser_parse_type_from_string (ValaGirParser* self,
2694                                         const gchar* type_string,
2695                                         gboolean owned_by_default,
2696                                         ValaSourceReference* source_reference)
2697 {
2698 	GRegex* _tmp0_;
2699 	GMatchInfo* match = NULL;
2700 	GRegex* _tmp5_;
2701 	GMatchInfo* _tmp6_ = NULL;
2702 	gboolean _tmp7_;
2703 	ValaDataType* type = NULL;
2704 	gchar* ownership_data = NULL;
2705 	GMatchInfo* _tmp8_;
2706 	gchar* _tmp9_;
2707 	gchar* type_name = NULL;
2708 	GMatchInfo* _tmp10_;
2709 	gchar* _tmp11_;
2710 	gchar* type_arguments_data = NULL;
2711 	GMatchInfo* _tmp12_;
2712 	gchar* _tmp13_;
2713 	gchar* pointers_data = NULL;
2714 	GMatchInfo* _tmp14_;
2715 	gchar* _tmp15_;
2716 	gchar* array_data = NULL;
2717 	GMatchInfo* _tmp16_;
2718 	gchar* _tmp17_;
2719 	gchar* nullable_data = NULL;
2720 	GMatchInfo* _tmp18_;
2721 	gchar* _tmp19_;
2722 	gboolean _tmp20_ = FALSE;
2723 	const gchar* _tmp21_;
2724 	gboolean nullable = FALSE;
2725 	gboolean _tmp25_ = FALSE;
2726 	const gchar* _tmp26_;
2727 	gboolean value_owned = FALSE;
2728 	const gchar* _tmp39_;
2729 	ValaUnresolvedSymbol* sym = NULL;
2730 	const gchar* _tmp41_;
2731 	ValaUnresolvedSymbol* _tmp42_;
2732 	ValaUnresolvedSymbol* _tmp43_;
2733 	ValaUnresolvedSymbol* _tmp44_;
2734 	ValaUnresolvedType* _tmp45_;
2735 	gboolean _tmp46_ = FALSE;
2736 	const gchar* _tmp47_;
2737 	const gchar* _tmp53_;
2738 	gboolean _tmp61_ = FALSE;
2739 	const gchar* _tmp62_;
2740 	ValaDataType* _tmp72_;
2741 	ValaDataType* _tmp73_;
2742 	GError* _inner_error0_ = NULL;
2743 	ValaDataType* result = NULL;
2744 	g_return_val_if_fail (self != NULL, NULL);
2745 	g_return_val_if_fail (type_string != NULL, NULL);
2746 	_tmp0_ = vala_gir_parser_type_from_string_regex;
2747 	if (_tmp0_ == NULL) {
2748 		{
2749 			GRegex* _tmp1_ = NULL;
2750 			GRegex* _tmp2_;
2751 			GRegex* _tmp3_;
2752 			_tmp2_ = g_regex_new ("^(?:(owned|unowned|weak) +)?([0-9a-zA-Z_\\.]+)(?:<(.+)>)?(\\*+)?(\\[,*" \
2753 "\\])?(\\?)?$", (G_REGEX_ANCHORED | G_REGEX_DOLLAR_ENDONLY) | G_REGEX_OPTIMIZE, 0, &_inner_error0_);
2754 			_tmp1_ = _tmp2_;
2755 			if (G_UNLIKELY (_inner_error0_ != NULL)) {
2756 				if (_inner_error0_->domain == G_REGEX_ERROR) {
2757 					goto __catch0_g_regex_error;
2758 				}
2759 				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);
2760 				g_clear_error (&_inner_error0_);
2761 				return NULL;
2762 			}
2763 			_tmp3_ = _tmp1_;
2764 			_tmp1_ = NULL;
2765 			_g_regex_unref0 (vala_gir_parser_type_from_string_regex);
2766 			vala_gir_parser_type_from_string_regex = _tmp3_;
2767 			_g_regex_unref0 (_tmp1_);
2768 		}
2769 		goto __finally0;
2770 		__catch0_g_regex_error:
2771 		{
2772 			GError* e = NULL;
2773 			const gchar* _tmp4_;
2774 			e = _inner_error0_;
2775 			_inner_error0_ = NULL;
2776 			_tmp4_ = e->message;
2777 			g_error ("valagirparser.vala:1785: Unable to compile regex: %s", _tmp4_);
2778 			_g_error_free0 (e);
2779 		}
2780 		__finally0:
2781 		if (G_UNLIKELY (_inner_error0_ != NULL)) {
2782 			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);
2783 			g_clear_error (&_inner_error0_);
2784 			return NULL;
2785 		}
2786 	}
2787 	_tmp5_ = vala_gir_parser_type_from_string_regex;
2788 	_tmp7_ = g_regex_match (_tmp5_, type_string, 0, &_tmp6_);
2789 	_g_match_info_unref0 (match);
2790 	match = _tmp6_;
2791 	if (!_tmp7_) {
2792 		vala_report_error (source_reference, "unable to parse type");
2793 		result = NULL;
2794 		_g_match_info_unref0 (match);
2795 		return result;
2796 	}
2797 	type = NULL;
2798 	_tmp8_ = match;
2799 	_tmp9_ = g_match_info_fetch (_tmp8_, 1);
2800 	ownership_data = _tmp9_;
2801 	_tmp10_ = match;
2802 	_tmp11_ = g_match_info_fetch (_tmp10_, 2);
2803 	type_name = _tmp11_;
2804 	_tmp12_ = match;
2805 	_tmp13_ = g_match_info_fetch (_tmp12_, 3);
2806 	type_arguments_data = _tmp13_;
2807 	_tmp14_ = match;
2808 	_tmp15_ = g_match_info_fetch (_tmp14_, 4);
2809 	pointers_data = _tmp15_;
2810 	_tmp16_ = match;
2811 	_tmp17_ = g_match_info_fetch (_tmp16_, 5);
2812 	array_data = _tmp17_;
2813 	_tmp18_ = match;
2814 	_tmp19_ = g_match_info_fetch (_tmp18_, 6);
2815 	nullable_data = _tmp19_;
2816 	_tmp21_ = nullable_data;
2817 	if (_tmp21_ != NULL) {
2818 		const gchar* _tmp22_;
2819 		gint _tmp23_;
2820 		gint _tmp24_;
2821 		_tmp22_ = nullable_data;
2822 		_tmp23_ = strlen (_tmp22_);
2823 		_tmp24_ = _tmp23_;
2824 		_tmp20_ = _tmp24_ > 0;
2825 	} else {
2826 		_tmp20_ = FALSE;
2827 	}
2828 	nullable = _tmp20_;
2829 	_tmp26_ = ownership_data;
2830 	if (_tmp26_ == NULL) {
2831 		const gchar* _tmp27_;
2832 		_tmp27_ = type_name;
2833 		_tmp25_ = g_strcmp0 (_tmp27_, "void") == 0;
2834 	} else {
2835 		_tmp25_ = FALSE;
2836 	}
2837 	if (_tmp25_) {
2838 		gboolean _tmp28_ = FALSE;
2839 		const gchar* _tmp29_;
2840 		_tmp29_ = array_data;
2841 		if (_tmp29_ == NULL) {
2842 			_tmp28_ = !nullable;
2843 		} else {
2844 			_tmp28_ = FALSE;
2845 		}
2846 		if (_tmp28_) {
2847 			ValaVoidType* _tmp30_;
2848 			const gchar* _tmp31_;
2849 			_tmp30_ = vala_void_type_new (source_reference);
2850 			_vala_code_node_unref0 (type);
2851 			type = (ValaDataType*) _tmp30_;
2852 			_tmp31_ = pointers_data;
2853 			if (_tmp31_ != NULL) {
2854 				{
2855 					gint i = 0;
2856 					i = 0;
2857 					{
2858 						gboolean _tmp32_ = FALSE;
2859 						_tmp32_ = TRUE;
2860 						while (TRUE) {
2861 							const gchar* _tmp34_;
2862 							gint _tmp35_;
2863 							gint _tmp36_;
2864 							ValaDataType* _tmp37_;
2865 							ValaPointerType* _tmp38_;
2866 							if (!_tmp32_) {
2867 								gint _tmp33_;
2868 								_tmp33_ = i;
2869 								i = _tmp33_ + 1;
2870 							}
2871 							_tmp32_ = FALSE;
2872 							_tmp34_ = pointers_data;
2873 							_tmp35_ = strlen (_tmp34_);
2874 							_tmp36_ = _tmp35_;
2875 							if (!(i < _tmp36_)) {
2876 								break;
2877 							}
2878 							_tmp37_ = type;
2879 							_tmp38_ = vala_pointer_type_new (_tmp37_, NULL);
2880 							_vala_code_node_unref0 (type);
2881 							type = (ValaDataType*) _tmp38_;
2882 						}
2883 					}
2884 				}
2885 			}
2886 			result = type;
2887 			_g_free0 (nullable_data);
2888 			_g_free0 (array_data);
2889 			_g_free0 (pointers_data);
2890 			_g_free0 (type_arguments_data);
2891 			_g_free0 (type_name);
2892 			_g_free0 (ownership_data);
2893 			_g_match_info_unref0 (match);
2894 			return result;
2895 		} else {
2896 			vala_report_error (source_reference, "invalid void type");
2897 			result = NULL;
2898 			_g_free0 (nullable_data);
2899 			_g_free0 (array_data);
2900 			_g_free0 (pointers_data);
2901 			_g_free0 (type_arguments_data);
2902 			_g_free0 (type_name);
2903 			_g_free0 (ownership_data);
2904 			_vala_code_node_unref0 (type);
2905 			_g_match_info_unref0 (match);
2906 			return result;
2907 		}
2908 	}
2909 	value_owned = owned_by_default;
2910 	_tmp39_ = ownership_data;
2911 	if (g_strcmp0 (_tmp39_, "owned") == 0) {
2912 		if (owned_by_default) {
2913 			vala_report_error (source_reference, "unexpected `owned' keyword");
2914 		} else {
2915 			value_owned = TRUE;
2916 		}
2917 	} else {
2918 		const gchar* _tmp40_;
2919 		_tmp40_ = ownership_data;
2920 		if (g_strcmp0 (_tmp40_, "unowned") == 0) {
2921 			if (owned_by_default) {
2922 				value_owned = FALSE;
2923 			} else {
2924 				vala_report_error (source_reference, "unexpected `unowned' keyword");
2925 				result = NULL;
2926 				_g_free0 (nullable_data);
2927 				_g_free0 (array_data);
2928 				_g_free0 (pointers_data);
2929 				_g_free0 (type_arguments_data);
2930 				_g_free0 (type_name);
2931 				_g_free0 (ownership_data);
2932 				_vala_code_node_unref0 (type);
2933 				_g_match_info_unref0 (match);
2934 				return result;
2935 			}
2936 		}
2937 	}
2938 	_tmp41_ = type_name;
2939 	_tmp42_ = vala_gir_parser_parse_symbol_from_string (self, _tmp41_, source_reference);
2940 	sym = _tmp42_;
2941 	_tmp43_ = sym;
2942 	if (_tmp43_ == NULL) {
2943 		result = NULL;
2944 		_vala_code_node_unref0 (sym);
2945 		_g_free0 (nullable_data);
2946 		_g_free0 (array_data);
2947 		_g_free0 (pointers_data);
2948 		_g_free0 (type_arguments_data);
2949 		_g_free0 (type_name);
2950 		_g_free0 (ownership_data);
2951 		_vala_code_node_unref0 (type);
2952 		_g_match_info_unref0 (match);
2953 		return result;
2954 	}
2955 	_tmp44_ = sym;
2956 	_tmp45_ = vala_unresolved_type_new_from_symbol (_tmp44_, source_reference);
2957 	_vala_code_node_unref0 (type);
2958 	type = (ValaDataType*) _tmp45_;
2959 	_tmp47_ = type_arguments_data;
2960 	if (_tmp47_ != NULL) {
2961 		const gchar* _tmp48_;
2962 		gint _tmp49_;
2963 		gint _tmp50_;
2964 		_tmp48_ = type_arguments_data;
2965 		_tmp49_ = strlen (_tmp48_);
2966 		_tmp50_ = _tmp49_;
2967 		_tmp46_ = _tmp50_ > 0;
2968 	} else {
2969 		_tmp46_ = FALSE;
2970 	}
2971 	if (_tmp46_) {
2972 		ValaDataType* _tmp51_;
2973 		const gchar* _tmp52_;
2974 		_tmp51_ = type;
2975 		_tmp52_ = type_arguments_data;
2976 		if (!vala_gir_parser_parse_type_arguments_from_string (self, _tmp51_, _tmp52_, source_reference)) {
2977 			result = NULL;
2978 			_vala_code_node_unref0 (sym);
2979 			_g_free0 (nullable_data);
2980 			_g_free0 (array_data);
2981 			_g_free0 (pointers_data);
2982 			_g_free0 (type_arguments_data);
2983 			_g_free0 (type_name);
2984 			_g_free0 (ownership_data);
2985 			_vala_code_node_unref0 (type);
2986 			_g_match_info_unref0 (match);
2987 			return result;
2988 		}
2989 	}
2990 	_tmp53_ = pointers_data;
2991 	if (_tmp53_ != NULL) {
2992 		{
2993 			gint i = 0;
2994 			i = 0;
2995 			{
2996 				gboolean _tmp54_ = FALSE;
2997 				_tmp54_ = TRUE;
2998 				while (TRUE) {
2999 					const gchar* _tmp56_;
3000 					gint _tmp57_;
3001 					gint _tmp58_;
3002 					ValaDataType* _tmp59_;
3003 					ValaPointerType* _tmp60_;
3004 					if (!_tmp54_) {
3005 						gint _tmp55_;
3006 						_tmp55_ = i;
3007 						i = _tmp55_ + 1;
3008 					}
3009 					_tmp54_ = FALSE;
3010 					_tmp56_ = pointers_data;
3011 					_tmp57_ = strlen (_tmp56_);
3012 					_tmp58_ = _tmp57_;
3013 					if (!(i < _tmp58_)) {
3014 						break;
3015 					}
3016 					_tmp59_ = type;
3017 					_tmp60_ = vala_pointer_type_new (_tmp59_, NULL);
3018 					_vala_code_node_unref0 (type);
3019 					type = (ValaDataType*) _tmp60_;
3020 				}
3021 			}
3022 		}
3023 	}
3024 	_tmp62_ = array_data;
3025 	if (_tmp62_ != NULL) {
3026 		const gchar* _tmp63_;
3027 		gint _tmp64_;
3028 		gint _tmp65_;
3029 		_tmp63_ = array_data;
3030 		_tmp64_ = strlen (_tmp63_);
3031 		_tmp65_ = _tmp64_;
3032 		_tmp61_ = _tmp65_ != 0;
3033 	} else {
3034 		_tmp61_ = FALSE;
3035 	}
3036 	if (_tmp61_) {
3037 		ValaDataType* _tmp66_;
3038 		ValaDataType* _tmp67_;
3039 		const gchar* _tmp68_;
3040 		gint _tmp69_;
3041 		gint _tmp70_;
3042 		ValaArrayType* _tmp71_;
3043 		_tmp66_ = type;
3044 		vala_data_type_set_value_owned (_tmp66_, TRUE);
3045 		_tmp67_ = type;
3046 		_tmp68_ = array_data;
3047 		_tmp69_ = strlen (_tmp68_);
3048 		_tmp70_ = _tmp69_;
3049 		_tmp71_ = vala_array_type_new (_tmp67_, ((gint) _tmp70_) - 1, source_reference);
3050 		_vala_code_node_unref0 (type);
3051 		type = (ValaDataType*) _tmp71_;
3052 	}
3053 	_tmp72_ = type;
3054 	vala_data_type_set_nullable (_tmp72_, nullable);
3055 	_tmp73_ = type;
3056 	vala_data_type_set_value_owned (_tmp73_, value_owned);
3057 	result = type;
3058 	_vala_code_node_unref0 (sym);
3059 	_g_free0 (nullable_data);
3060 	_g_free0 (array_data);
3061 	_g_free0 (pointers_data);
3062 	_g_free0 (type_arguments_data);
3063 	_g_free0 (type_name);
3064 	_g_free0 (ownership_data);
3065 	_g_match_info_unref0 (match);
3066 	return result;
3067 }
3068 
3069 static gchar*
vala_gir_parser_element_get_string(ValaGirParser * self,const gchar * attribute_name,ValaGirParserArgumentType arg_type)3070 vala_gir_parser_element_get_string (ValaGirParser* self,
3071                                     const gchar* attribute_name,
3072                                     ValaGirParserArgumentType arg_type)
3073 {
3074 	ValaGirParserMetadata* _tmp0_;
3075 	gchar* result = NULL;
3076 	g_return_val_if_fail (self != NULL, NULL);
3077 	g_return_val_if_fail (attribute_name != NULL, NULL);
3078 	_tmp0_ = self->priv->metadata;
3079 	if (vala_gir_parser_metadata_has_argument (_tmp0_, arg_type)) {
3080 		ValaGirParserMetadata* _tmp1_;
3081 		gchar* _tmp2_;
3082 		_tmp1_ = self->priv->metadata;
3083 		_tmp2_ = vala_gir_parser_metadata_get_string (_tmp1_, arg_type);
3084 		result = _tmp2_;
3085 		return result;
3086 	} else {
3087 		ValaMarkupReader* _tmp3_;
3088 		gchar* _tmp4_;
3089 		_tmp3_ = self->priv->reader;
3090 		_tmp4_ = vala_markup_reader_get_attribute (_tmp3_, attribute_name);
3091 		result = _tmp4_;
3092 		return result;
3093 	}
3094 }
3095 
3096 static ValaDataType*
vala_gir_parser_element_get_type(ValaGirParser * self,ValaDataType * orig_type,gboolean owned_by_default,gboolean * no_array_length,gboolean * array_null_terminated,gboolean * changed)3097 vala_gir_parser_element_get_type (ValaGirParser* self,
3098                                   ValaDataType* orig_type,
3099                                   gboolean owned_by_default,
3100                                   gboolean* no_array_length,
3101                                   gboolean* array_null_terminated,
3102                                   gboolean* changed)
3103 {
3104 	gboolean _vala_changed = FALSE;
3105 	ValaDataType* type = NULL;
3106 	ValaDataType* _tmp0_;
3107 	ValaGirParserMetadata* _tmp1_;
3108 	ValaDataType* _tmp43_;
3109 	ValaDataType* result = NULL;
3110 	g_return_val_if_fail (self != NULL, NULL);
3111 	g_return_val_if_fail (orig_type != NULL, NULL);
3112 	_vala_changed = FALSE;
3113 	_tmp0_ = _vala_code_node_ref0 (orig_type);
3114 	type = _tmp0_;
3115 	_tmp1_ = self->priv->metadata;
3116 	if (vala_gir_parser_metadata_has_argument (_tmp1_, VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE)) {
3117 		ValaGirParserMetadata* _tmp2_;
3118 		gchar* _tmp3_;
3119 		gchar* _tmp4_;
3120 		ValaGirParserMetadata* _tmp5_;
3121 		ValaSourceReference* _tmp6_;
3122 		ValaSourceReference* _tmp7_;
3123 		ValaDataType* _tmp8_;
3124 		_tmp2_ = self->priv->metadata;
3125 		_tmp3_ = vala_gir_parser_metadata_get_string (_tmp2_, VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE);
3126 		_tmp4_ = _tmp3_;
3127 		_tmp5_ = self->priv->metadata;
3128 		_tmp6_ = vala_gir_parser_metadata_get_source_reference (_tmp5_, VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE);
3129 		_tmp7_ = _tmp6_;
3130 		_tmp8_ = vala_gir_parser_parse_type_from_string (self, _tmp4_, owned_by_default, _tmp7_);
3131 		_vala_code_node_unref0 (type);
3132 		type = _tmp8_;
3133 		_vala_source_reference_unref0 (_tmp7_);
3134 		_g_free0 (_tmp4_);
3135 		_vala_changed = TRUE;
3136 	} else {
3137 		ValaDataType* _tmp9_;
3138 		_tmp9_ = type;
3139 		if (!VALA_IS_VOID_TYPE (_tmp9_)) {
3140 			ValaGirParserMetadata* _tmp10_;
3141 			gboolean _tmp19_ = FALSE;
3142 			ValaDataType* _tmp20_;
3143 			ValaDataType* _tmp38_;
3144 			ValaGirParserMetadata* _tmp39_;
3145 			ValaDataType* _tmp40_;
3146 			gboolean _tmp41_;
3147 			gboolean _tmp42_;
3148 			_tmp10_ = self->priv->metadata;
3149 			if (vala_gir_parser_metadata_has_argument (_tmp10_, VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ARGUMENTS)) {
3150 				ValaDataType* _tmp11_;
3151 				ValaDataType* _tmp12_;
3152 				ValaGirParserMetadata* _tmp13_;
3153 				gchar* _tmp14_;
3154 				gchar* _tmp15_;
3155 				ValaGirParserMetadata* _tmp16_;
3156 				ValaSourceReference* _tmp17_;
3157 				ValaSourceReference* _tmp18_;
3158 				_tmp11_ = type;
3159 				vala_data_type_remove_all_type_arguments (_tmp11_);
3160 				_tmp12_ = type;
3161 				_tmp13_ = self->priv->metadata;
3162 				_tmp14_ = vala_gir_parser_metadata_get_string (_tmp13_, VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ARGUMENTS);
3163 				_tmp15_ = _tmp14_;
3164 				_tmp16_ = self->priv->metadata;
3165 				_tmp17_ = vala_gir_parser_metadata_get_source_reference (_tmp16_, VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ARGUMENTS);
3166 				_tmp18_ = _tmp17_;
3167 				vala_gir_parser_parse_type_arguments_from_string (self, _tmp12_, _tmp15_, _tmp18_);
3168 				_vala_source_reference_unref0 (_tmp18_);
3169 				_g_free0 (_tmp15_);
3170 			}
3171 			_tmp20_ = type;
3172 			if (!VALA_IS_ARRAY_TYPE (_tmp20_)) {
3173 				ValaGirParserMetadata* _tmp21_;
3174 				_tmp21_ = self->priv->metadata;
3175 				_tmp19_ = vala_gir_parser_metadata_get_bool (_tmp21_, VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY, FALSE);
3176 			} else {
3177 				_tmp19_ = FALSE;
3178 			}
3179 			if (_tmp19_) {
3180 				ValaDataType* _tmp22_;
3181 				ValaDataType* _tmp23_;
3182 				ValaDataType* _tmp24_;
3183 				ValaSourceReference* _tmp25_;
3184 				ValaSourceReference* _tmp26_;
3185 				ValaArrayType* _tmp27_;
3186 				_tmp22_ = type;
3187 				vala_data_type_set_value_owned (_tmp22_, TRUE);
3188 				_tmp23_ = type;
3189 				_tmp24_ = type;
3190 				_tmp25_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp24_);
3191 				_tmp26_ = _tmp25_;
3192 				_tmp27_ = vala_array_type_new (_tmp23_, 1, _tmp26_);
3193 				_vala_code_node_unref0 (type);
3194 				type = (ValaDataType*) _tmp27_;
3195 				_vala_changed = TRUE;
3196 			}
3197 			if (owned_by_default) {
3198 				ValaDataType* _tmp28_;
3199 				ValaGirParserMetadata* _tmp29_;
3200 				ValaDataType* _tmp30_;
3201 				gboolean _tmp31_;
3202 				gboolean _tmp32_;
3203 				_tmp28_ = type;
3204 				_tmp29_ = self->priv->metadata;
3205 				_tmp30_ = type;
3206 				_tmp31_ = vala_data_type_get_value_owned (_tmp30_);
3207 				_tmp32_ = _tmp31_;
3208 				vala_data_type_set_value_owned (_tmp28_, !vala_gir_parser_metadata_get_bool (_tmp29_, VALA_GIR_PARSER_ARGUMENT_TYPE_UNOWNED, !_tmp32_));
3209 			} else {
3210 				ValaDataType* _tmp33_;
3211 				ValaGirParserMetadata* _tmp34_;
3212 				ValaDataType* _tmp35_;
3213 				gboolean _tmp36_;
3214 				gboolean _tmp37_;
3215 				_tmp33_ = type;
3216 				_tmp34_ = self->priv->metadata;
3217 				_tmp35_ = type;
3218 				_tmp36_ = vala_data_type_get_value_owned (_tmp35_);
3219 				_tmp37_ = _tmp36_;
3220 				vala_data_type_set_value_owned (_tmp33_, vala_gir_parser_metadata_get_bool (_tmp34_, VALA_GIR_PARSER_ARGUMENT_TYPE_OWNED, _tmp37_));
3221 			}
3222 			_tmp38_ = type;
3223 			_tmp39_ = self->priv->metadata;
3224 			_tmp40_ = type;
3225 			_tmp41_ = vala_data_type_get_nullable (_tmp40_);
3226 			_tmp42_ = _tmp41_;
3227 			vala_data_type_set_nullable (_tmp38_, vala_gir_parser_metadata_get_bool (_tmp39_, VALA_GIR_PARSER_ARGUMENT_TYPE_NULLABLE, _tmp42_));
3228 		}
3229 	}
3230 	_tmp43_ = type;
3231 	if (VALA_IS_ARRAY_TYPE (_tmp43_)) {
3232 		ValaGirParserMetadata* _tmp44_;
3233 		if (!VALA_IS_ARRAY_TYPE (orig_type)) {
3234 			*no_array_length = TRUE;
3235 		}
3236 		_tmp44_ = self->priv->metadata;
3237 		*array_null_terminated = vala_gir_parser_metadata_get_bool (_tmp44_, VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_NULL_TERMINATED, *array_null_terminated);
3238 	}
3239 	result = type;
3240 	if (changed) {
3241 		*changed = _vala_changed;
3242 	}
3243 	return result;
3244 }
3245 
3246 static gint
string_index_of_char(const gchar * self,gunichar c,gint start_index)3247 string_index_of_char (const gchar* self,
3248                       gunichar c,
3249                       gint start_index)
3250 {
3251 	gchar* _result_ = NULL;
3252 	gchar* _tmp0_;
3253 	gchar* _tmp1_;
3254 	gint result = 0;
3255 	g_return_val_if_fail (self != NULL, 0);
3256 	_tmp0_ = g_utf8_strchr (((gchar*) self) + start_index, (gssize) -1, c);
3257 	_result_ = _tmp0_;
3258 	_tmp1_ = _result_;
3259 	if (_tmp1_ != NULL) {
3260 		gchar* _tmp2_;
3261 		_tmp2_ = _result_;
3262 		result = (gint) (_tmp2_ - ((gchar*) self));
3263 		return result;
3264 	} else {
3265 		result = -1;
3266 		return result;
3267 	}
3268 }
3269 
3270 static gchar*
vala_gir_parser_element_get_name(ValaGirParser * self,const gchar * gir_name)3271 vala_gir_parser_element_get_name (ValaGirParser* self,
3272                                   const gchar* gir_name)
3273 {
3274 	gchar* name = NULL;
3275 	gchar* _tmp0_;
3276 	const gchar* _tmp1_;
3277 	gchar* pattern = NULL;
3278 	ValaGirParserMetadata* _tmp4_;
3279 	gchar* _tmp5_;
3280 	const gchar* _tmp6_;
3281 	GError* _inner_error0_ = NULL;
3282 	gchar* result = NULL;
3283 	g_return_val_if_fail (self != NULL, NULL);
3284 	_tmp0_ = g_strdup (gir_name);
3285 	name = _tmp0_;
3286 	_tmp1_ = name;
3287 	if (_tmp1_ == NULL) {
3288 		ValaMarkupReader* _tmp2_;
3289 		gchar* _tmp3_;
3290 		_tmp2_ = self->priv->reader;
3291 		_tmp3_ = vala_markup_reader_get_attribute (_tmp2_, "name");
3292 		_g_free0 (name);
3293 		name = _tmp3_;
3294 	}
3295 	_tmp4_ = self->priv->metadata;
3296 	_tmp5_ = vala_gir_parser_metadata_get_string (_tmp4_, VALA_GIR_PARSER_ARGUMENT_TYPE_NAME);
3297 	pattern = _tmp5_;
3298 	_tmp6_ = pattern;
3299 	if (_tmp6_ != NULL) {
3300 		const gchar* _tmp7_;
3301 		_tmp7_ = pattern;
3302 		if (string_index_of_char (_tmp7_, (gunichar) '(', 0) < 0) {
3303 			const gchar* _tmp8_;
3304 			gchar* _tmp9_;
3305 			_tmp8_ = pattern;
3306 			_tmp9_ = g_strdup (_tmp8_);
3307 			_g_free0 (name);
3308 			name = _tmp9_;
3309 		} else {
3310 			{
3311 				gchar* replacement = NULL;
3312 				gchar* _tmp10_;
3313 				gchar** split = NULL;
3314 				const gchar* _tmp11_;
3315 				gchar** _tmp12_;
3316 				gchar** _tmp13_;
3317 				gint split_length1;
3318 				gint _split_size_;
3319 				gchar** _tmp14_;
3320 				gint _tmp14__length1;
3321 				GRegex* regex = NULL;
3322 				const gchar* _tmp21_;
3323 				GRegex* _tmp22_;
3324 				gchar* _tmp23_ = NULL;
3325 				GRegex* _tmp24_;
3326 				const gchar* _tmp25_;
3327 				const gchar* _tmp26_;
3328 				gchar* _tmp27_;
3329 				gchar* _tmp28_;
3330 				_tmp10_ = g_strdup ("\\1");
3331 				replacement = _tmp10_;
3332 				_tmp11_ = pattern;
3333 				_tmp13_ = _tmp12_ = g_strsplit (_tmp11_, "/", 0);
3334 				split = _tmp13_;
3335 				split_length1 = _vala_array_length (_tmp12_);
3336 				_split_size_ = split_length1;
3337 				_tmp14_ = split;
3338 				_tmp14__length1 = split_length1;
3339 				if (_tmp14__length1 > 1) {
3340 					gchar** _tmp15_;
3341 					gint _tmp15__length1;
3342 					const gchar* _tmp16_;
3343 					gchar* _tmp17_;
3344 					gchar** _tmp18_;
3345 					gint _tmp18__length1;
3346 					const gchar* _tmp19_;
3347 					gchar* _tmp20_;
3348 					_tmp15_ = split;
3349 					_tmp15__length1 = split_length1;
3350 					_tmp16_ = _tmp15_[0];
3351 					_tmp17_ = g_strdup (_tmp16_);
3352 					_g_free0 (pattern);
3353 					pattern = _tmp17_;
3354 					_tmp18_ = split;
3355 					_tmp18__length1 = split_length1;
3356 					_tmp19_ = _tmp18_[1];
3357 					_tmp20_ = g_strdup (_tmp19_);
3358 					_g_free0 (replacement);
3359 					replacement = _tmp20_;
3360 				}
3361 				_tmp21_ = pattern;
3362 				_tmp22_ = g_regex_new (_tmp21_, G_REGEX_ANCHORED, G_REGEX_MATCH_ANCHORED, &_inner_error0_);
3363 				regex = _tmp22_;
3364 				if (G_UNLIKELY (_inner_error0_ != NULL)) {
3365 					split = (_vala_array_free (split, split_length1, (GDestroyNotify) g_free), NULL);
3366 					_g_free0 (replacement);
3367 					goto __catch0_g_error;
3368 				}
3369 				_tmp24_ = regex;
3370 				_tmp25_ = name;
3371 				_tmp26_ = replacement;
3372 				_tmp27_ = g_regex_replace (_tmp24_, _tmp25_, (gssize) -1, 0, _tmp26_, 0, &_inner_error0_);
3373 				_tmp23_ = _tmp27_;
3374 				if (G_UNLIKELY (_inner_error0_ != NULL)) {
3375 					_g_regex_unref0 (regex);
3376 					split = (_vala_array_free (split, split_length1, (GDestroyNotify) g_free), NULL);
3377 					_g_free0 (replacement);
3378 					goto __catch0_g_error;
3379 				}
3380 				_tmp28_ = _tmp23_;
3381 				_tmp23_ = NULL;
3382 				_g_free0 (name);
3383 				name = _tmp28_;
3384 				_g_free0 (_tmp23_);
3385 				_g_regex_unref0 (regex);
3386 				split = (_vala_array_free (split, split_length1, (GDestroyNotify) g_free), NULL);
3387 				_g_free0 (replacement);
3388 			}
3389 			goto __finally0;
3390 			__catch0_g_error:
3391 			{
3392 				const gchar* _tmp29_;
3393 				gchar* _tmp30_;
3394 				g_clear_error (&_inner_error0_);
3395 				_tmp29_ = pattern;
3396 				_tmp30_ = g_strdup (_tmp29_);
3397 				_g_free0 (name);
3398 				name = _tmp30_;
3399 			}
3400 			__finally0:
3401 			if (G_UNLIKELY (_inner_error0_ != NULL)) {
3402 				_g_free0 (pattern);
3403 				_g_free0 (name);
3404 				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);
3405 				g_clear_error (&_inner_error0_);
3406 				return NULL;
3407 			}
3408 		}
3409 	} else {
3410 		gboolean _tmp31_ = FALSE;
3411 		const gchar* _tmp32_;
3412 		_tmp32_ = name;
3413 		if (_tmp32_ != NULL) {
3414 			const gchar* _tmp33_;
3415 			_tmp33_ = name;
3416 			_tmp31_ = g_str_has_suffix (_tmp33_, "Enum");
3417 		} else {
3418 			_tmp31_ = FALSE;
3419 		}
3420 		if (_tmp31_) {
3421 			const gchar* _tmp34_;
3422 			const gchar* _tmp35_;
3423 			gint _tmp36_;
3424 			gint _tmp37_;
3425 			gint _tmp38_;
3426 			gint _tmp39_;
3427 			gchar* _tmp40_;
3428 			_tmp34_ = name;
3429 			_tmp35_ = name;
3430 			_tmp36_ = strlen (_tmp35_);
3431 			_tmp37_ = _tmp36_;
3432 			_tmp38_ = strlen ("Enum");
3433 			_tmp39_ = _tmp38_;
3434 			_tmp40_ = string_substring (_tmp34_, (glong) 0, (glong) (_tmp37_ - _tmp39_));
3435 			_g_free0 (name);
3436 			name = _tmp40_;
3437 		}
3438 	}
3439 	result = name;
3440 	_g_free0 (pattern);
3441 	return result;
3442 }
3443 
3444 static gchar*
vala_gir_parser_element_get_type_id(ValaGirParser * self)3445 vala_gir_parser_element_get_type_id (ValaGirParser* self)
3446 {
3447 	gchar* type_id = NULL;
3448 	ValaGirParserMetadata* _tmp0_;
3449 	gchar* _tmp1_;
3450 	const gchar* _tmp2_;
3451 	ValaMarkupReader* _tmp3_;
3452 	gchar* _tmp4_;
3453 	const gchar* _tmp5_;
3454 	gchar* result = NULL;
3455 	g_return_val_if_fail (self != NULL, NULL);
3456 	_tmp0_ = self->priv->metadata;
3457 	_tmp1_ = vala_gir_parser_metadata_get_string (_tmp0_, VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ID);
3458 	type_id = _tmp1_;
3459 	_tmp2_ = type_id;
3460 	if (_tmp2_ != NULL) {
3461 		result = type_id;
3462 		return result;
3463 	}
3464 	_tmp3_ = self->priv->reader;
3465 	_tmp4_ = vala_markup_reader_get_attribute (_tmp3_, "glib:get-type");
3466 	_g_free0 (type_id);
3467 	type_id = _tmp4_;
3468 	_tmp5_ = type_id;
3469 	if (_tmp5_ != NULL) {
3470 		const gchar* _tmp6_;
3471 		gchar* _tmp7_;
3472 		_tmp6_ = type_id;
3473 		_tmp7_ = g_strconcat (_tmp6_, " ()", NULL);
3474 		_g_free0 (type_id);
3475 		type_id = _tmp7_;
3476 	}
3477 	result = type_id;
3478 	return result;
3479 }
3480 
3481 static void
vala_gir_parser_set_array_ccode(ValaGirParser * self,ValaSymbol * sym,ValaGirParserParameterInfo * info)3482 vala_gir_parser_set_array_ccode (ValaGirParser* self,
3483                                  ValaSymbol* sym,
3484                                  ValaGirParserParameterInfo* info)
3485 {
3486 	gchar* type_name = NULL;
3487 	ValaParameter* _tmp3_;
3488 	ValaDataType* _tmp4_;
3489 	ValaDataType* _tmp5_;
3490 	gchar* _tmp6_;
3491 	const gchar* _tmp7_;
3492 	g_return_if_fail (self != NULL);
3493 	g_return_if_fail (sym != NULL);
3494 	g_return_if_fail (info != NULL);
3495 	vala_code_node_set_attribute_double ((ValaCodeNode*) sym, "CCode", "array_length_pos", (gdouble) info->vala_idx, NULL);
3496 	if (VALA_IS_PARAMETER (sym)) {
3497 		ValaParameter* _tmp0_;
3498 		const gchar* _tmp1_;
3499 		const gchar* _tmp2_;
3500 		_tmp0_ = info->param;
3501 		_tmp1_ = vala_symbol_get_name ((ValaSymbol*) _tmp0_);
3502 		_tmp2_ = _tmp1_;
3503 		vala_code_node_set_attribute_string ((ValaCodeNode*) sym, "CCode", "array_length_cname", _tmp2_, NULL);
3504 	}
3505 	_tmp3_ = info->param;
3506 	_tmp4_ = vala_variable_get_variable_type ((ValaVariable*) _tmp3_);
3507 	_tmp5_ = _tmp4_;
3508 	_tmp6_ = vala_data_type_to_qualified_string (_tmp5_, NULL);
3509 	type_name = _tmp6_;
3510 	_tmp7_ = type_name;
3511 	if (g_strcmp0 (_tmp7_, "int") != 0) {
3512 		ValaGirParserNode* st = NULL;
3513 		ValaGirParserNode* _tmp8_;
3514 		const gchar* _tmp9_;
3515 		ValaGirParserNode* _tmp10_;
3516 		ValaGirParserNode* _tmp11_;
3517 		_tmp8_ = self->priv->root;
3518 		_tmp9_ = type_name;
3519 		_tmp10_ = vala_gir_parser_node_lookup (_tmp8_, _tmp9_, FALSE, NULL);
3520 		st = _tmp10_;
3521 		_tmp11_ = st;
3522 		if (_tmp11_ != NULL) {
3523 			gboolean _tmp12_ = FALSE;
3524 			if (VALA_IS_CALLABLE (sym)) {
3525 				_tmp12_ = TRUE;
3526 			} else {
3527 				_tmp12_ = VALA_IS_PARAMETER (sym);
3528 			}
3529 			if (_tmp12_) {
3530 				ValaGirParserNode* _tmp13_;
3531 				gchar* _tmp14_;
3532 				gchar* _tmp15_;
3533 				_tmp13_ = st;
3534 				_tmp14_ = vala_gir_parser_node_get_cname (_tmp13_);
3535 				_tmp15_ = _tmp14_;
3536 				vala_code_node_set_attribute_string ((ValaCodeNode*) sym, "CCode", "array_length_type", _tmp15_, NULL);
3537 				_g_free0 (_tmp15_);
3538 			}
3539 		}
3540 		_vala_gir_parser_node_unref0 (st);
3541 	}
3542 	_g_free0 (type_name);
3543 }
3544 
3545 static void
vala_gir_parser_set_type_id_ccode(ValaGirParser * self,ValaSymbol * sym)3546 vala_gir_parser_set_type_id_ccode (ValaGirParser* self,
3547                                    ValaSymbol* sym)
3548 {
3549 	gboolean _tmp0_ = FALSE;
3550 	gchar* type_id = NULL;
3551 	gchar* _tmp1_;
3552 	const gchar* _tmp2_;
3553 	g_return_if_fail (self != NULL);
3554 	g_return_if_fail (sym != NULL);
3555 	if (vala_code_node_has_attribute_argument ((ValaCodeNode*) sym, "CCode", "has_type_id")) {
3556 		_tmp0_ = TRUE;
3557 	} else {
3558 		_tmp0_ = vala_code_node_has_attribute_argument ((ValaCodeNode*) sym, "CCode", "type_id");
3559 	}
3560 	if (_tmp0_) {
3561 		return;
3562 	}
3563 	_tmp1_ = vala_gir_parser_element_get_type_id (self);
3564 	type_id = _tmp1_;
3565 	_tmp2_ = type_id;
3566 	if (_tmp2_ == NULL) {
3567 		vala_code_node_set_attribute_bool ((ValaCodeNode*) sym, "CCode", "has_type_id", FALSE, NULL);
3568 	} else {
3569 		const gchar* _tmp3_;
3570 		_tmp3_ = type_id;
3571 		vala_code_node_set_attribute_string ((ValaCodeNode*) sym, "CCode", "type_id", _tmp3_, NULL);
3572 	}
3573 	_g_free0 (type_id);
3574 }
3575 
3576 static void
vala_gir_parser_parse_repository(ValaGirParser * self)3577 vala_gir_parser_parse_repository (ValaGirParser* self)
3578 {
3579 	ValaMarkupReader* _tmp0_;
3580 	gchar* _tmp1_;
3581 	gchar* _tmp2_;
3582 	gboolean _tmp3_;
3583 	g_return_if_fail (self != NULL);
3584 	vala_gir_parser_start_element (self, "repository");
3585 	_tmp0_ = self->priv->reader;
3586 	_tmp1_ = vala_markup_reader_get_attribute (_tmp0_, "version");
3587 	_tmp2_ = _tmp1_;
3588 	_tmp3_ = g_strcmp0 (_tmp2_, VALA_GIR_PARSER_GIR_VERSION) != 0;
3589 	_g_free0 (_tmp2_);
3590 	if (_tmp3_) {
3591 		ValaSourceReference* _tmp4_;
3592 		ValaSourceReference* _tmp5_;
3593 		ValaMarkupReader* _tmp6_;
3594 		gchar* _tmp7_;
3595 		gchar* _tmp8_;
3596 		gchar* _tmp9_;
3597 		gchar* _tmp10_;
3598 		_tmp4_ = vala_gir_parser_get_current_src (self);
3599 		_tmp5_ = _tmp4_;
3600 		_tmp6_ = self->priv->reader;
3601 		_tmp7_ = vala_markup_reader_get_attribute (_tmp6_, "version");
3602 		_tmp8_ = _tmp7_;
3603 		_tmp9_ = g_strdup_printf ("unsupported GIR version %s (supported: %s)", _tmp8_, VALA_GIR_PARSER_GIR_VERSION);
3604 		_tmp10_ = _tmp9_;
3605 		vala_report_error (_tmp5_, _tmp10_);
3606 		_g_free0 (_tmp10_);
3607 		_g_free0 (_tmp8_);
3608 		_vala_source_reference_unref0 (_tmp5_);
3609 		return;
3610 	}
3611 	vala_gir_parser_next (self);
3612 	while (TRUE) {
3613 		ValaMarkupTokenType _tmp11_;
3614 		ValaMarkupReader* _tmp12_;
3615 		const gchar* _tmp13_;
3616 		const gchar* _tmp14_;
3617 		_tmp11_ = self->priv->current_token;
3618 		if (!(_tmp11_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT)) {
3619 			break;
3620 		}
3621 		_tmp12_ = self->priv->reader;
3622 		_tmp13_ = vala_markup_reader_get_name (_tmp12_);
3623 		_tmp14_ = _tmp13_;
3624 		if (g_strcmp0 (_tmp14_, "namespace") == 0) {
3625 			vala_gir_parser_parse_namespace (self);
3626 		} else {
3627 			ValaMarkupReader* _tmp15_;
3628 			const gchar* _tmp16_;
3629 			const gchar* _tmp17_;
3630 			_tmp15_ = self->priv->reader;
3631 			_tmp16_ = vala_markup_reader_get_name (_tmp15_);
3632 			_tmp17_ = _tmp16_;
3633 			if (g_strcmp0 (_tmp17_, "include") == 0) {
3634 				vala_gir_parser_parse_include (self);
3635 			} else {
3636 				ValaMarkupReader* _tmp18_;
3637 				const gchar* _tmp19_;
3638 				const gchar* _tmp20_;
3639 				_tmp18_ = self->priv->reader;
3640 				_tmp19_ = vala_markup_reader_get_name (_tmp18_);
3641 				_tmp20_ = _tmp19_;
3642 				if (g_strcmp0 (_tmp20_, "package") == 0) {
3643 					gchar* pkg = NULL;
3644 					gchar* _tmp21_;
3645 					ValaSourceFile* _tmp22_;
3646 					const gchar* _tmp23_;
3647 					ValaCodeContext* _tmp24_;
3648 					const gchar* _tmp25_;
3649 					_tmp21_ = vala_gir_parser_parse_package (self);
3650 					pkg = _tmp21_;
3651 					_tmp22_ = self->priv->current_source_file;
3652 					_tmp23_ = pkg;
3653 					vala_source_file_set_package_name (_tmp22_, _tmp23_);
3654 					_tmp24_ = self->priv->context;
3655 					_tmp25_ = pkg;
3656 					if (vala_code_context_has_package (_tmp24_, _tmp25_)) {
3657 						ValaSourceFile* _tmp26_;
3658 						gboolean _tmp27_;
3659 						gboolean _tmp28_;
3660 						_tmp26_ = self->priv->current_source_file;
3661 						_tmp27_ = vala_source_file_get_from_commandline (_tmp26_);
3662 						_tmp28_ = _tmp27_;
3663 						if (!_tmp28_) {
3664 							_g_free0 (pkg);
3665 							return;
3666 						}
3667 					} else {
3668 						ValaCodeContext* _tmp29_;
3669 						const gchar* _tmp30_;
3670 						_tmp29_ = self->priv->context;
3671 						_tmp30_ = pkg;
3672 						vala_code_context_add_package (_tmp29_, _tmp30_);
3673 					}
3674 					_g_free0 (pkg);
3675 				} else {
3676 					ValaMarkupReader* _tmp31_;
3677 					const gchar* _tmp32_;
3678 					const gchar* _tmp33_;
3679 					_tmp31_ = self->priv->reader;
3680 					_tmp32_ = vala_markup_reader_get_name (_tmp31_);
3681 					_tmp33_ = _tmp32_;
3682 					if (g_strcmp0 (_tmp33_, "c:include") == 0) {
3683 						vala_gir_parser_parse_c_include (self);
3684 					} else {
3685 						ValaSourceReference* _tmp34_;
3686 						ValaSourceReference* _tmp35_;
3687 						ValaMarkupReader* _tmp36_;
3688 						const gchar* _tmp37_;
3689 						const gchar* _tmp38_;
3690 						gchar* _tmp39_;
3691 						gchar* _tmp40_;
3692 						_tmp34_ = vala_gir_parser_get_current_src (self);
3693 						_tmp35_ = _tmp34_;
3694 						_tmp36_ = self->priv->reader;
3695 						_tmp37_ = vala_markup_reader_get_name (_tmp36_);
3696 						_tmp38_ = _tmp37_;
3697 						_tmp39_ = g_strdup_printf ("unknown child element `%s' in `repository'", _tmp38_);
3698 						_tmp40_ = _tmp39_;
3699 						vala_report_error (_tmp35_, _tmp40_);
3700 						_g_free0 (_tmp40_);
3701 						_vala_source_reference_unref0 (_tmp35_);
3702 						vala_gir_parser_skip_element (self);
3703 					}
3704 				}
3705 			}
3706 		}
3707 	}
3708 	vala_gir_parser_end_element (self, "repository");
3709 }
3710 
3711 static void
vala_gir_parser_parse_include(ValaGirParser * self)3712 vala_gir_parser_parse_include (ValaGirParser* self)
3713 {
3714 	gchar* pkg = NULL;
3715 	ValaMarkupReader* _tmp0_;
3716 	gchar* _tmp1_;
3717 	gchar* version = NULL;
3718 	ValaMarkupReader* _tmp2_;
3719 	gchar* _tmp3_;
3720 	const gchar* _tmp4_;
3721 	ValaCodeContext* _tmp8_;
3722 	const gchar* _tmp9_;
3723 	g_return_if_fail (self != NULL);
3724 	vala_gir_parser_start_element (self, "include");
3725 	_tmp0_ = self->priv->reader;
3726 	_tmp1_ = vala_markup_reader_get_attribute (_tmp0_, "name");
3727 	pkg = _tmp1_;
3728 	_tmp2_ = self->priv->reader;
3729 	_tmp3_ = vala_markup_reader_get_attribute (_tmp2_, "version");
3730 	version = _tmp3_;
3731 	_tmp4_ = version;
3732 	if (_tmp4_ != NULL) {
3733 		const gchar* _tmp5_;
3734 		const gchar* _tmp6_;
3735 		gchar* _tmp7_;
3736 		_tmp5_ = pkg;
3737 		_tmp6_ = version;
3738 		_tmp7_ = g_strdup_printf ("%s-%s", _tmp5_, _tmp6_);
3739 		_g_free0 (pkg);
3740 		pkg = _tmp7_;
3741 	}
3742 	_tmp8_ = self->priv->context;
3743 	_tmp9_ = pkg;
3744 	vala_code_context_add_external_package (_tmp8_, _tmp9_);
3745 	vala_gir_parser_next (self);
3746 	vala_gir_parser_end_element (self, "include");
3747 	_g_free0 (version);
3748 	_g_free0 (pkg);
3749 }
3750 
3751 static gchar*
vala_gir_parser_parse_package(ValaGirParser * self)3752 vala_gir_parser_parse_package (ValaGirParser* self)
3753 {
3754 	gchar* pkg = NULL;
3755 	ValaMarkupReader* _tmp0_;
3756 	gchar* _tmp1_;
3757 	gchar* result = NULL;
3758 	g_return_val_if_fail (self != NULL, NULL);
3759 	vala_gir_parser_start_element (self, "package");
3760 	_tmp0_ = self->priv->reader;
3761 	_tmp1_ = vala_markup_reader_get_attribute (_tmp0_, "name");
3762 	pkg = _tmp1_;
3763 	vala_gir_parser_next (self);
3764 	vala_gir_parser_end_element (self, "package");
3765 	result = pkg;
3766 	return result;
3767 }
3768 
3769 static void
_vala_array_add1(gchar *** array,gint * length,gint * size,gchar * value)3770 _vala_array_add1 (gchar** * array,
3771                   gint* length,
3772                   gint* size,
3773                   gchar* value)
3774 {
3775 	if ((*length) == (*size)) {
3776 		*size = (*size) ? (2 * (*size)) : 4;
3777 		*array = g_renew (gchar*, *array, (*size) + 1);
3778 	}
3779 	(*array)[(*length)++] = value;
3780 	(*array)[*length] = NULL;
3781 }
3782 
3783 static void
vala_gir_parser_parse_c_include(ValaGirParser * self)3784 vala_gir_parser_parse_c_include (ValaGirParser* self)
3785 {
3786 	ValaMarkupReader* _tmp0_;
3787 	gchar* _tmp1_;
3788 	g_return_if_fail (self != NULL);
3789 	vala_gir_parser_start_element (self, "c:include");
3790 	_tmp0_ = self->priv->reader;
3791 	_tmp1_ = vala_markup_reader_get_attribute (_tmp0_, "name");
3792 	_vala_array_add1 (&self->priv->cheader_filenames, &self->priv->cheader_filenames_length1, &self->priv->_cheader_filenames_size_, _tmp1_);
3793 	vala_gir_parser_next (self);
3794 	vala_gir_parser_end_element (self, "c:include");
3795 }
3796 
3797 static void
vala_gir_parser_skip_element(ValaGirParser * self)3798 vala_gir_parser_skip_element (ValaGirParser* self)
3799 {
3800 	gint level = 0;
3801 	g_return_if_fail (self != NULL);
3802 	vala_gir_parser_next (self);
3803 	level = 1;
3804 	while (TRUE) {
3805 		ValaMarkupTokenType _tmp0_;
3806 		if (!(level > 0)) {
3807 			break;
3808 		}
3809 		_tmp0_ = self->priv->current_token;
3810 		if (_tmp0_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT) {
3811 			gint _tmp1_;
3812 			_tmp1_ = level;
3813 			level = _tmp1_ + 1;
3814 		} else {
3815 			ValaMarkupTokenType _tmp2_;
3816 			_tmp2_ = self->priv->current_token;
3817 			if (_tmp2_ == VALA_MARKUP_TOKEN_TYPE_END_ELEMENT) {
3818 				gint _tmp3_;
3819 				_tmp3_ = level;
3820 				level = _tmp3_ - 1;
3821 			} else {
3822 				ValaMarkupTokenType _tmp4_;
3823 				_tmp4_ = self->priv->current_token;
3824 				if (_tmp4_ == VALA_MARKUP_TOKEN_TYPE_EOF) {
3825 					ValaSourceReference* _tmp5_;
3826 					ValaSourceReference* _tmp6_;
3827 					_tmp5_ = vala_gir_parser_get_current_src (self);
3828 					_tmp6_ = _tmp5_;
3829 					vala_report_error (_tmp6_, "unexpected end of file");
3830 					_vala_source_reference_unref0 (_tmp6_);
3831 					break;
3832 				}
3833 			}
3834 		}
3835 		vala_gir_parser_next (self);
3836 	}
3837 }
3838 
3839 static ValaGirParserNode*
vala_gir_parser_resolve_node(ValaGirParser * self,ValaGirParserNode * parent_scope,ValaUnresolvedSymbol * unresolved_sym,gboolean create_namespace)3840 vala_gir_parser_resolve_node (ValaGirParser* self,
3841                               ValaGirParserNode* parent_scope,
3842                               ValaUnresolvedSymbol* unresolved_sym,
3843                               gboolean create_namespace)
3844 {
3845 	ValaUnresolvedSymbol* _tmp0_;
3846 	ValaUnresolvedSymbol* _tmp1_;
3847 	ValaGirParserNode* result = NULL;
3848 	g_return_val_if_fail (self != NULL, NULL);
3849 	g_return_val_if_fail (parent_scope != NULL, NULL);
3850 	g_return_val_if_fail (unresolved_sym != NULL, NULL);
3851 	_tmp0_ = vala_unresolved_symbol_get_inner (unresolved_sym);
3852 	_tmp1_ = _tmp0_;
3853 	if (_tmp1_ == NULL) {
3854 		ValaGirParserNode* scope = NULL;
3855 		ValaGirParserNode* _tmp2_;
3856 		_tmp2_ = _vala_gir_parser_node_ref0 (parent_scope);
3857 		scope = _tmp2_;
3858 		while (TRUE) {
3859 			ValaGirParserNode* _tmp3_;
3860 			ValaGirParserNode* node = NULL;
3861 			ValaGirParserNode* _tmp4_;
3862 			const gchar* _tmp5_;
3863 			const gchar* _tmp6_;
3864 			ValaSourceReference* _tmp7_;
3865 			ValaSourceReference* _tmp8_;
3866 			ValaGirParserNode* _tmp9_;
3867 			ValaGirParserNode* _tmp10_;
3868 			ValaGirParserNode* _tmp11_;
3869 			ValaGirParserNode* _tmp12_;
3870 			ValaGirParserNode* _tmp13_;
3871 			_tmp3_ = scope;
3872 			if (!(_tmp3_ != NULL)) {
3873 				break;
3874 			}
3875 			_tmp4_ = scope;
3876 			_tmp5_ = vala_symbol_get_name ((ValaSymbol*) unresolved_sym);
3877 			_tmp6_ = _tmp5_;
3878 			_tmp7_ = vala_code_node_get_source_reference ((ValaCodeNode*) unresolved_sym);
3879 			_tmp8_ = _tmp7_;
3880 			_tmp9_ = vala_gir_parser_node_lookup (_tmp4_, _tmp6_, create_namespace, _tmp8_);
3881 			node = _tmp9_;
3882 			_tmp10_ = node;
3883 			if (_tmp10_ != NULL) {
3884 				result = node;
3885 				_vala_gir_parser_node_unref0 (scope);
3886 				return result;
3887 			}
3888 			_tmp11_ = scope;
3889 			_tmp12_ = _tmp11_->parent;
3890 			_tmp13_ = _vala_gir_parser_node_ref0 (_tmp12_);
3891 			_vala_gir_parser_node_unref0 (scope);
3892 			scope = _tmp13_;
3893 			_vala_gir_parser_node_unref0 (node);
3894 		}
3895 		_vala_gir_parser_node_unref0 (scope);
3896 	} else {
3897 		ValaGirParserNode* inner = NULL;
3898 		ValaUnresolvedSymbol* _tmp14_;
3899 		ValaUnresolvedSymbol* _tmp15_;
3900 		ValaGirParserNode* _tmp16_;
3901 		ValaGirParserNode* _tmp17_;
3902 		_tmp14_ = vala_unresolved_symbol_get_inner (unresolved_sym);
3903 		_tmp15_ = _tmp14_;
3904 		_tmp16_ = vala_gir_parser_resolve_node (self, parent_scope, _tmp15_, create_namespace);
3905 		inner = _tmp16_;
3906 		_tmp17_ = inner;
3907 		if (_tmp17_ != NULL) {
3908 			ValaGirParserNode* _tmp18_;
3909 			const gchar* _tmp19_;
3910 			const gchar* _tmp20_;
3911 			ValaSourceReference* _tmp21_;
3912 			ValaSourceReference* _tmp22_;
3913 			ValaGirParserNode* _tmp23_;
3914 			_tmp18_ = inner;
3915 			_tmp19_ = vala_symbol_get_name ((ValaSymbol*) unresolved_sym);
3916 			_tmp20_ = _tmp19_;
3917 			_tmp21_ = vala_code_node_get_source_reference ((ValaCodeNode*) unresolved_sym);
3918 			_tmp22_ = _tmp21_;
3919 			_tmp23_ = vala_gir_parser_node_lookup (_tmp18_, _tmp20_, create_namespace, _tmp22_);
3920 			result = _tmp23_;
3921 			_vala_gir_parser_node_unref0 (inner);
3922 			return result;
3923 		}
3924 		_vala_gir_parser_node_unref0 (inner);
3925 	}
3926 	result = NULL;
3927 	return result;
3928 }
3929 
3930 static ValaSymbol*
vala_gir_parser_resolve_symbol(ValaGirParser * self,ValaGirParserNode * parent_scope,ValaUnresolvedSymbol * unresolved_sym)3931 vala_gir_parser_resolve_symbol (ValaGirParser* self,
3932                                 ValaGirParserNode* parent_scope,
3933                                 ValaUnresolvedSymbol* unresolved_sym)
3934 {
3935 	ValaGirParserNode* node = NULL;
3936 	ValaGirParserNode* _tmp0_;
3937 	ValaGirParserNode* _tmp1_;
3938 	ValaSymbol* result = NULL;
3939 	g_return_val_if_fail (self != NULL, NULL);
3940 	g_return_val_if_fail (parent_scope != NULL, NULL);
3941 	g_return_val_if_fail (unresolved_sym != NULL, NULL);
3942 	_tmp0_ = vala_gir_parser_resolve_node (self, parent_scope, unresolved_sym, FALSE);
3943 	node = _tmp0_;
3944 	_tmp1_ = node;
3945 	if (_tmp1_ != NULL) {
3946 		ValaGirParserNode* _tmp2_;
3947 		ValaSymbol* _tmp3_;
3948 		ValaSymbol* _tmp4_;
3949 		_tmp2_ = node;
3950 		_tmp3_ = _tmp2_->symbol;
3951 		_tmp4_ = _vala_code_node_ref0 (_tmp3_);
3952 		result = _tmp4_;
3953 		_vala_gir_parser_node_unref0 (node);
3954 		return result;
3955 	}
3956 	result = NULL;
3957 	_vala_gir_parser_node_unref0 (node);
3958 	return result;
3959 }
3960 
3961 static void
vala_gir_parser_push_node(ValaGirParser * self,const gchar * name,gboolean merge)3962 vala_gir_parser_push_node (ValaGirParser* self,
3963                            const gchar* name,
3964                            gboolean merge)
3965 {
3966 	ValaGirParserNode* parent = NULL;
3967 	ValaGirParserNode* _tmp0_;
3968 	ValaGirParserNode* _tmp1_;
3969 	ValaGirParserMetadata* _tmp2_;
3970 	ValaGirParserNode* node = NULL;
3971 	ValaGirParserNode* _tmp14_;
3972 	ValaGirParserNode* _tmp15_;
3973 	gboolean _tmp16_ = FALSE;
3974 	ValaGirParserNode* _tmp17_;
3975 	ValaGirParserNode* _tmp27_;
3976 	ValaMarkupReader* _tmp28_;
3977 	const gchar* _tmp29_;
3978 	const gchar* _tmp30_;
3979 	gchar* _tmp31_;
3980 	ValaGirParserNode* _tmp32_;
3981 	ValaMarkupReader* _tmp33_;
3982 	ValaMap* _tmp34_;
3983 	ValaGirParserNode* _tmp35_;
3984 	ValaGirParserMetadata* _tmp36_;
3985 	ValaGirParserMetadata* _tmp37_;
3986 	ValaGirParserNode* _tmp38_;
3987 	ValaSourceReference* _tmp39_;
3988 	gchar* gir_name = NULL;
3989 	ValaGirParserNode* _tmp40_;
3990 	gchar* _tmp41_;
3991 	gboolean _tmp42_ = FALSE;
3992 	ValaGirParserNode* _tmp43_;
3993 	ValaGirParserNode* _tmp44_;
3994 	ValaArrayList* _tmp52_;
3995 	ValaGirParserNode* _tmp53_;
3996 	ValaGirParserNode* _tmp54_;
3997 	ValaGirParserNode* _tmp55_;
3998 	g_return_if_fail (self != NULL);
3999 	g_return_if_fail (name != NULL);
4000 	_tmp0_ = self->priv->current;
4001 	_tmp1_ = _vala_gir_parser_node_ref0 (_tmp0_);
4002 	parent = _tmp1_;
4003 	_tmp2_ = self->priv->metadata;
4004 	if (vala_gir_parser_metadata_has_argument (_tmp2_, VALA_GIR_PARSER_ARGUMENT_TYPE_PARENT)) {
4005 		ValaUnresolvedSymbol* target = NULL;
4006 		ValaGirParserMetadata* _tmp3_;
4007 		gchar* _tmp4_;
4008 		gchar* _tmp5_;
4009 		ValaGirParserMetadata* _tmp6_;
4010 		ValaSourceReference* _tmp7_;
4011 		ValaSourceReference* _tmp8_;
4012 		ValaUnresolvedSymbol* _tmp9_;
4013 		ValaUnresolvedSymbol* _tmp10_;
4014 		ValaGirParserNode* _tmp11_;
4015 		ValaUnresolvedSymbol* _tmp12_;
4016 		ValaGirParserNode* _tmp13_;
4017 		_tmp3_ = self->priv->metadata;
4018 		_tmp4_ = vala_gir_parser_metadata_get_string (_tmp3_, VALA_GIR_PARSER_ARGUMENT_TYPE_PARENT);
4019 		_tmp5_ = _tmp4_;
4020 		_tmp6_ = self->priv->metadata;
4021 		_tmp7_ = vala_gir_parser_metadata_get_source_reference (_tmp6_, VALA_GIR_PARSER_ARGUMENT_TYPE_PARENT);
4022 		_tmp8_ = _tmp7_;
4023 		_tmp9_ = vala_gir_parser_parse_symbol_from_string (self, _tmp5_, _tmp8_);
4024 		_tmp10_ = _tmp9_;
4025 		_vala_source_reference_unref0 (_tmp8_);
4026 		_g_free0 (_tmp5_);
4027 		target = _tmp10_;
4028 		_tmp11_ = self->priv->root;
4029 		_tmp12_ = target;
4030 		_tmp13_ = vala_gir_parser_resolve_node (self, _tmp11_, _tmp12_, TRUE);
4031 		_vala_gir_parser_node_unref0 (parent);
4032 		parent = _tmp13_;
4033 		_vala_code_node_unref0 (target);
4034 	}
4035 	_tmp14_ = parent;
4036 	_tmp15_ = vala_gir_parser_node_lookup (_tmp14_, name, FALSE, NULL);
4037 	node = _tmp15_;
4038 	_tmp17_ = node;
4039 	if (_tmp17_ == NULL) {
4040 		_tmp16_ = TRUE;
4041 	} else {
4042 		gboolean _tmp18_ = FALSE;
4043 		ValaGirParserNode* _tmp19_;
4044 		ValaSymbol* _tmp20_;
4045 		_tmp19_ = node;
4046 		_tmp20_ = _tmp19_->symbol;
4047 		if (_tmp20_ != NULL) {
4048 			_tmp18_ = !merge;
4049 		} else {
4050 			_tmp18_ = FALSE;
4051 		}
4052 		_tmp16_ = _tmp18_;
4053 	}
4054 	if (_tmp16_) {
4055 		ValaGirParserNode* _tmp21_;
4056 		ValaGirParserNode* _tmp22_;
4057 		ValaGirParserNode* _tmp23_;
4058 		ValaGirParserNode* _tmp24_;
4059 		_tmp21_ = vala_gir_parser_node_new (name);
4060 		_vala_gir_parser_node_unref0 (node);
4061 		node = _tmp21_;
4062 		_tmp22_ = node;
4063 		_tmp22_->new_symbol = TRUE;
4064 		_tmp23_ = parent;
4065 		_tmp24_ = node;
4066 		vala_gir_parser_node_add_member (_tmp23_, _tmp24_);
4067 	} else {
4068 		ValaArrayList* _tmp25_;
4069 		ValaGirParserNode* _tmp26_;
4070 		_tmp25_ = vala_gir_parser_node_new_namespaces;
4071 		_tmp26_ = node;
4072 		vala_collection_remove ((ValaCollection*) _tmp25_, _tmp26_);
4073 	}
4074 	_tmp27_ = node;
4075 	_tmp28_ = self->priv->reader;
4076 	_tmp29_ = vala_markup_reader_get_name (_tmp28_);
4077 	_tmp30_ = _tmp29_;
4078 	_tmp31_ = g_strdup (_tmp30_);
4079 	_g_free0 (_tmp27_->element_type);
4080 	_tmp27_->element_type = _tmp31_;
4081 	_tmp32_ = node;
4082 	_tmp33_ = self->priv->reader;
4083 	_tmp34_ = vala_markup_reader_get_attributes (_tmp33_);
4084 	_vala_map_unref0 (_tmp32_->girdata);
4085 	_tmp32_->girdata = _tmp34_;
4086 	_tmp35_ = node;
4087 	_tmp36_ = self->priv->metadata;
4088 	_tmp37_ = _vala_gir_parser_metadata_ref0 (_tmp36_);
4089 	_vala_gir_parser_metadata_unref0 (_tmp35_->metadata);
4090 	_tmp35_->metadata = _tmp37_;
4091 	_tmp38_ = node;
4092 	_tmp39_ = vala_gir_parser_get_current_src (self);
4093 	_vala_source_reference_unref0 (_tmp38_->source_reference);
4094 	_tmp38_->source_reference = _tmp39_;
4095 	_tmp40_ = node;
4096 	_tmp41_ = vala_gir_parser_node_get_gir_name (_tmp40_);
4097 	gir_name = _tmp41_;
4098 	_tmp43_ = parent;
4099 	_tmp44_ = self->priv->current;
4100 	if (_tmp43_ != _tmp44_) {
4101 		_tmp42_ = TRUE;
4102 	} else {
4103 		const gchar* _tmp45_;
4104 		_tmp45_ = gir_name;
4105 		_tmp42_ = g_strcmp0 (_tmp45_, name) != 0;
4106 	}
4107 	if (_tmp42_) {
4108 		const gchar* _tmp46_;
4109 		ValaUnresolvedSymbol* _tmp47_;
4110 		ValaUnresolvedSymbol* _tmp48_;
4111 		ValaGirParserNode* _tmp49_;
4112 		ValaUnresolvedSymbol* _tmp50_;
4113 		ValaUnresolvedSymbol* _tmp51_;
4114 		_tmp46_ = gir_name;
4115 		_tmp47_ = vala_unresolved_symbol_new (NULL, _tmp46_, NULL);
4116 		_tmp48_ = _tmp47_;
4117 		_tmp49_ = node;
4118 		_tmp50_ = vala_gir_parser_node_get_unresolved_symbol (_tmp49_);
4119 		_tmp51_ = _tmp50_;
4120 		vala_gir_parser_set_symbol_mapping (self, _tmp48_, (ValaSymbol*) _tmp51_);
4121 		_vala_code_node_unref0 (_tmp51_);
4122 		_vala_code_node_unref0 (_tmp48_);
4123 	}
4124 	_tmp52_ = self->priv->tree_stack;
4125 	_tmp53_ = self->priv->current;
4126 	vala_collection_add ((ValaCollection*) _tmp52_, _tmp53_);
4127 	_tmp54_ = node;
4128 	_tmp55_ = _vala_gir_parser_node_ref0 (_tmp54_);
4129 	_vala_gir_parser_node_unref0 (self->priv->current);
4130 	self->priv->current = _tmp55_;
4131 	_g_free0 (gir_name);
4132 	_vala_gir_parser_node_unref0 (node);
4133 	_vala_gir_parser_node_unref0 (parent);
4134 }
4135 
4136 static void
vala_gir_parser_pop_node(ValaGirParser * self)4137 vala_gir_parser_pop_node (ValaGirParser* self)
4138 {
4139 	ValaGirParserNode* _tmp0_;
4140 	ValaGirParserNode* _tmp1_;
4141 	ValaArrayList* _tmp2_;
4142 	ValaArrayList* _tmp3_;
4143 	gint _tmp4_;
4144 	gint _tmp5_;
4145 	gpointer _tmp6_;
4146 	g_return_if_fail (self != NULL);
4147 	_tmp0_ = self->priv->current;
4148 	_tmp1_ = _vala_gir_parser_node_ref0 (_tmp0_);
4149 	_vala_gir_parser_node_unref0 (self->priv->old_current);
4150 	self->priv->old_current = _tmp1_;
4151 	_tmp2_ = self->priv->tree_stack;
4152 	_tmp3_ = self->priv->tree_stack;
4153 	_tmp4_ = vala_collection_get_size ((ValaCollection*) _tmp3_);
4154 	_tmp5_ = _tmp4_;
4155 	_tmp6_ = vala_list_remove_at ((ValaList*) _tmp2_, _tmp5_ - 1);
4156 	_vala_gir_parser_node_unref0 (self->priv->current);
4157 	self->priv->current = (ValaGirParserNode*) _tmp6_;
4158 }
4159 
4160 static gint
string_index_of(const gchar * self,const gchar * needle,gint start_index)4161 string_index_of (const gchar* self,
4162                  const gchar* needle,
4163                  gint start_index)
4164 {
4165 	gchar* _result_ = NULL;
4166 	gchar* _tmp0_;
4167 	gchar* _tmp1_;
4168 	gint result = 0;
4169 	g_return_val_if_fail (self != NULL, 0);
4170 	g_return_val_if_fail (needle != NULL, 0);
4171 	_tmp0_ = strstr (((gchar*) self) + start_index, (gchar*) needle);
4172 	_result_ = _tmp0_;
4173 	_tmp1_ = _result_;
4174 	if (_tmp1_ != NULL) {
4175 		gchar* _tmp2_;
4176 		_tmp2_ = _result_;
4177 		result = (gint) (_tmp2_ - ((gchar*) self));
4178 		return result;
4179 	} else {
4180 		result = -1;
4181 		return result;
4182 	}
4183 }
4184 
4185 static void
_vala_code_node_unref0_(gpointer var)4186 _vala_code_node_unref0_ (gpointer var)
4187 {
4188 	(var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL));
4189 }
4190 
4191 static inline void
_g_list_free__vala_code_node_unref0_(GList * self)4192 _g_list_free__vala_code_node_unref0_ (GList* self)
4193 {
4194 	g_list_free_full (self, (GDestroyNotify) _vala_code_node_unref0_);
4195 }
4196 
4197 static gchar*
_vala_g_strjoinv(const gchar * separator,gchar ** str_array,gint str_array_length1)4198 _vala_g_strjoinv (const gchar* separator,
4199                   gchar** str_array,
4200                   gint str_array_length1)
4201 {
4202 	gboolean _tmp0_ = FALSE;
4203 	gchar* result = NULL;
4204 	if (separator == NULL) {
4205 		separator = "";
4206 	}
4207 	if (str_array != NULL) {
4208 		gboolean _tmp1_ = FALSE;
4209 		if (str_array_length1 > 0) {
4210 			_tmp1_ = TRUE;
4211 		} else {
4212 			gboolean _tmp2_ = FALSE;
4213 			if (str_array_length1 == -1) {
4214 				const gchar* _tmp3_;
4215 				_tmp3_ = str_array[0];
4216 				_tmp2_ = _tmp3_ != NULL;
4217 			} else {
4218 				_tmp2_ = FALSE;
4219 			}
4220 			_tmp1_ = _tmp2_;
4221 		}
4222 		_tmp0_ = _tmp1_;
4223 	} else {
4224 		_tmp0_ = FALSE;
4225 	}
4226 	if (_tmp0_) {
4227 		gint i = 0;
4228 		gsize len = 0UL;
4229 		gint _tmp16_;
4230 		gint _tmp17_;
4231 		const gchar* res = NULL;
4232 		void* _tmp18_;
4233 		void* ptr = NULL;
4234 		const gchar* _tmp19_;
4235 		const gchar* _tmp20_;
4236 		void* _tmp21_;
4237 		const gchar* _tmp31_;
4238 		len = (gsize) 1;
4239 		{
4240 			gboolean _tmp4_ = FALSE;
4241 			i = 0;
4242 			_tmp4_ = TRUE;
4243 			while (TRUE) {
4244 				gboolean _tmp6_ = FALSE;
4245 				gboolean _tmp7_ = FALSE;
4246 				gint _tmp10_ = 0;
4247 				const gchar* _tmp11_;
4248 				if (!_tmp4_) {
4249 					gint _tmp5_;
4250 					_tmp5_ = i;
4251 					i = _tmp5_ + 1;
4252 				}
4253 				_tmp4_ = FALSE;
4254 				if (str_array_length1 != -1) {
4255 					_tmp7_ = i < str_array_length1;
4256 				} else {
4257 					_tmp7_ = FALSE;
4258 				}
4259 				if (_tmp7_) {
4260 					_tmp6_ = TRUE;
4261 				} else {
4262 					gboolean _tmp8_ = FALSE;
4263 					if (str_array_length1 == -1) {
4264 						const gchar* _tmp9_;
4265 						_tmp9_ = str_array[i];
4266 						_tmp8_ = _tmp9_ != NULL;
4267 					} else {
4268 						_tmp8_ = FALSE;
4269 					}
4270 					_tmp6_ = _tmp8_;
4271 				}
4272 				if (!_tmp6_) {
4273 					break;
4274 				}
4275 				_tmp11_ = str_array[i];
4276 				if (_tmp11_ != NULL) {
4277 					const gchar* _tmp12_;
4278 					gint _tmp13_;
4279 					gint _tmp14_;
4280 					_tmp12_ = str_array[i];
4281 					_tmp13_ = strlen ((const gchar*) _tmp12_);
4282 					_tmp14_ = _tmp13_;
4283 					_tmp10_ = _tmp14_;
4284 				} else {
4285 					_tmp10_ = 0;
4286 				}
4287 				len += (gsize) _tmp10_;
4288 			}
4289 		}
4290 		if (i == 0) {
4291 			gchar* _tmp15_;
4292 			_tmp15_ = g_strdup ("");
4293 			result = _tmp15_;
4294 			return result;
4295 		}
4296 		str_array_length1 = i;
4297 		_tmp16_ = strlen ((const gchar*) separator);
4298 		_tmp17_ = _tmp16_;
4299 		len += (gsize) (_tmp17_ * (i - 1));
4300 		_tmp18_ = g_malloc (len);
4301 		res = _tmp18_;
4302 		_tmp19_ = res;
4303 		_tmp20_ = str_array[0];
4304 		_tmp21_ = g_stpcpy ((void*) _tmp19_, (const gchar*) _tmp20_);
4305 		ptr = _tmp21_;
4306 		{
4307 			gboolean _tmp22_ = FALSE;
4308 			i = 1;
4309 			_tmp22_ = TRUE;
4310 			while (TRUE) {
4311 				void* _tmp24_;
4312 				void* _tmp25_;
4313 				const gchar* _tmp26_ = NULL;
4314 				const gchar* _tmp27_;
4315 				void* _tmp29_;
4316 				void* _tmp30_;
4317 				if (!_tmp22_) {
4318 					gint _tmp23_;
4319 					_tmp23_ = i;
4320 					i = _tmp23_ + 1;
4321 				}
4322 				_tmp22_ = FALSE;
4323 				if (!(i < str_array_length1)) {
4324 					break;
4325 				}
4326 				_tmp24_ = ptr;
4327 				_tmp25_ = g_stpcpy (_tmp24_, (const gchar*) separator);
4328 				ptr = _tmp25_;
4329 				_tmp27_ = str_array[i];
4330 				if (_tmp27_ != NULL) {
4331 					const gchar* _tmp28_;
4332 					_tmp28_ = str_array[i];
4333 					_tmp26_ = (const gchar*) _tmp28_;
4334 				} else {
4335 					_tmp26_ = "";
4336 				}
4337 				_tmp29_ = ptr;
4338 				_tmp30_ = g_stpcpy (_tmp29_, _tmp26_);
4339 				ptr = _tmp30_;
4340 			}
4341 		}
4342 		_tmp31_ = res;
4343 		res = NULL;
4344 		result = (gchar*) _tmp31_;
4345 		return result;
4346 	} else {
4347 		gchar* _tmp32_;
4348 		_tmp32_ = g_strdup ("");
4349 		result = _tmp32_;
4350 		return result;
4351 	}
4352 }
4353 
4354 static void
vala_gir_parser_parse_namespace(ValaGirParser * self)4355 vala_gir_parser_parse_namespace (ValaGirParser* self)
4356 {
4357 	gchar* cprefix = NULL;
4358 	ValaMarkupReader* _tmp0_;
4359 	gchar* _tmp1_;
4360 	const gchar* _tmp2_;
4361 	gchar* lower_case_cprefix = NULL;
4362 	ValaMarkupReader* _tmp6_;
4363 	gchar* _tmp7_;
4364 	gchar* vala_namespace = NULL;
4365 	const gchar* _tmp8_;
4366 	gchar* _tmp9_;
4367 	gchar* gir_namespace = NULL;
4368 	ValaMarkupReader* _tmp10_;
4369 	gchar* _tmp11_;
4370 	gchar* gir_version = NULL;
4371 	ValaMarkupReader* _tmp12_;
4372 	gchar* _tmp13_;
4373 	const gchar* _tmp14_;
4374 	ValaSet* _tmp18_;
4375 	const gchar* _tmp19_;
4376 	const gchar* _tmp20_;
4377 	gchar* _tmp21_;
4378 	gchar* _tmp22_;
4379 	gboolean _tmp23_;
4380 	gchar* metadata_filename = NULL;
4381 	ValaCodeContext* _tmp24_;
4382 	ValaSourceFile* _tmp25_;
4383 	const gchar* _tmp26_;
4384 	const gchar* _tmp27_;
4385 	gchar* _tmp28_;
4386 	gboolean _tmp29_ = FALSE;
4387 	const gchar* _tmp30_;
4388 	ValaGirParserMetadata* ns_metadata = NULL;
4389 	ValaGirParserMetadata* _tmp46_;
4390 	const gchar* _tmp47_;
4391 	ValaGirParserMetadata* _tmp48_;
4392 	ValaGirParserMetadata* _tmp49_;
4393 	const gchar* _tmp52_;
4394 	ValaSourceFile* _tmp55_;
4395 	const gchar* _tmp56_;
4396 	ValaSourceFile* _tmp57_;
4397 	const gchar* _tmp58_;
4398 	ValaNamespace* ns = NULL;
4399 	const gchar* _tmp59_;
4400 	ValaGirParserNode* _tmp60_;
4401 	ValaGirParserNode* _tmp75_;
4402 	ValaGirParserMetadata* _tmp76_;
4403 	ValaGirParserMetadata* _tmp77_;
4404 	ValaGirParserMetadata* _tmp78_;
4405 	ValaGirParserMetadata* _tmp81_;
4406 	ValaNamespace* _tmp87_;
4407 	const gchar* _tmp88_;
4408 	ValaNamespace* _tmp89_;
4409 	const gchar* _tmp90_;
4410 	const gchar* _tmp91_;
4411 	const gchar* _tmp101_;
4412 	gchar** _tmp104_;
4413 	gint _tmp104__length1;
4414 	g_return_if_fail (self != NULL);
4415 	vala_gir_parser_start_element (self, "namespace");
4416 	_tmp0_ = self->priv->reader;
4417 	_tmp1_ = vala_markup_reader_get_attribute (_tmp0_, "c:identifier-prefixes");
4418 	cprefix = _tmp1_;
4419 	_tmp2_ = cprefix;
4420 	if (_tmp2_ != NULL) {
4421 		gint idx = 0;
4422 		const gchar* _tmp3_;
4423 		_tmp3_ = cprefix;
4424 		idx = string_index_of (_tmp3_, ",", 0);
4425 		if (idx != -1) {
4426 			const gchar* _tmp4_;
4427 			gchar* _tmp5_;
4428 			_tmp4_ = cprefix;
4429 			_tmp5_ = string_substring (_tmp4_, (glong) 0, (glong) idx);
4430 			_g_free0 (cprefix);
4431 			cprefix = _tmp5_;
4432 		}
4433 	}
4434 	_tmp6_ = self->priv->reader;
4435 	_tmp7_ = vala_markup_reader_get_attribute (_tmp6_, "c:symbol-prefixes");
4436 	lower_case_cprefix = _tmp7_;
4437 	_tmp8_ = cprefix;
4438 	_tmp9_ = g_strdup (_tmp8_);
4439 	vala_namespace = _tmp9_;
4440 	_tmp10_ = self->priv->reader;
4441 	_tmp11_ = vala_markup_reader_get_attribute (_tmp10_, "name");
4442 	gir_namespace = _tmp11_;
4443 	_tmp12_ = self->priv->reader;
4444 	_tmp13_ = vala_markup_reader_get_attribute (_tmp12_, "version");
4445 	gir_version = _tmp13_;
4446 	_tmp14_ = lower_case_cprefix;
4447 	if (_tmp14_ != NULL) {
4448 		gint idx = 0;
4449 		const gchar* _tmp15_;
4450 		_tmp15_ = lower_case_cprefix;
4451 		idx = string_index_of (_tmp15_, ",", 0);
4452 		if (idx != -1) {
4453 			const gchar* _tmp16_;
4454 			gchar* _tmp17_;
4455 			_tmp16_ = lower_case_cprefix;
4456 			_tmp17_ = string_substring (_tmp16_, (glong) 0, (glong) idx);
4457 			_g_free0 (lower_case_cprefix);
4458 			lower_case_cprefix = _tmp17_;
4459 		}
4460 	}
4461 	_tmp18_ = self->priv->provided_namespaces;
4462 	_tmp19_ = gir_namespace;
4463 	_tmp20_ = gir_version;
4464 	_tmp21_ = g_strdup_printf ("%s-%s", _tmp19_, _tmp20_);
4465 	_tmp22_ = _tmp21_;
4466 	_tmp23_ = vala_collection_contains ((ValaCollection*) _tmp18_, _tmp22_);
4467 	_g_free0 (_tmp22_);
4468 	if (_tmp23_) {
4469 		vala_gir_parser_skip_element (self);
4470 		_g_free0 (gir_version);
4471 		_g_free0 (gir_namespace);
4472 		_g_free0 (vala_namespace);
4473 		_g_free0 (lower_case_cprefix);
4474 		_g_free0 (cprefix);
4475 		return;
4476 	}
4477 	_tmp24_ = self->priv->context;
4478 	_tmp25_ = self->priv->current_source_file;
4479 	_tmp26_ = vala_source_file_get_filename (_tmp25_);
4480 	_tmp27_ = _tmp26_;
4481 	_tmp28_ = vala_code_context_get_metadata_path (_tmp24_, _tmp27_);
4482 	metadata_filename = _tmp28_;
4483 	_tmp30_ = metadata_filename;
4484 	if (_tmp30_ != NULL) {
4485 		const gchar* _tmp31_;
4486 		_tmp31_ = metadata_filename;
4487 		_tmp29_ = g_file_test (_tmp31_, G_FILE_TEST_EXISTS);
4488 	} else {
4489 		_tmp29_ = FALSE;
4490 	}
4491 	if (_tmp29_) {
4492 		ValaGirParserMetadataParser* metadata_parser = NULL;
4493 		ValaGirParserMetadataParser* _tmp32_;
4494 		ValaSourceFile* metadata_file = NULL;
4495 		ValaCodeContext* _tmp33_;
4496 		ValaSourceFile* _tmp34_;
4497 		ValaSourceFileType _tmp35_;
4498 		ValaSourceFileType _tmp36_;
4499 		const gchar* _tmp37_;
4500 		ValaSourceFile* _tmp38_;
4501 		ValaCodeContext* _tmp39_;
4502 		ValaSourceFile* _tmp40_;
4503 		ValaGirParserMetadataParser* _tmp41_;
4504 		ValaSourceFile* _tmp42_;
4505 		ValaGirParserMetadata* _tmp43_;
4506 		ValaArrayList* _tmp44_;
4507 		ValaGirParserMetadata* _tmp45_;
4508 		_tmp32_ = vala_gir_parser_metadata_parser_new ();
4509 		metadata_parser = _tmp32_;
4510 		_tmp33_ = self->priv->context;
4511 		_tmp34_ = self->priv->current_source_file;
4512 		_tmp35_ = vala_source_file_get_file_type (_tmp34_);
4513 		_tmp36_ = _tmp35_;
4514 		_tmp37_ = metadata_filename;
4515 		_tmp38_ = vala_source_file_new (_tmp33_, _tmp36_, _tmp37_, NULL, FALSE);
4516 		metadata_file = _tmp38_;
4517 		_tmp39_ = self->priv->context;
4518 		_tmp40_ = metadata_file;
4519 		vala_code_context_add_source_file (_tmp39_, _tmp40_);
4520 		_tmp41_ = metadata_parser;
4521 		_tmp42_ = metadata_file;
4522 		_tmp43_ = vala_gir_parser_metadata_parser_parse_metadata (_tmp41_, _tmp42_);
4523 		_vala_gir_parser_metadata_unref0 (self->priv->metadata);
4524 		self->priv->metadata = _tmp43_;
4525 		_tmp44_ = self->priv->metadata_roots;
4526 		_tmp45_ = self->priv->metadata;
4527 		vala_collection_add ((ValaCollection*) _tmp44_, _tmp45_);
4528 		_vala_source_file_unref0 (metadata_file);
4529 		_vala_gir_parser_metadata_parser_unref0 (metadata_parser);
4530 	}
4531 	_tmp46_ = self->priv->metadata;
4532 	_tmp47_ = gir_namespace;
4533 	_tmp48_ = vala_gir_parser_metadata_match_child (_tmp46_, _tmp47_, NULL);
4534 	ns_metadata = _tmp48_;
4535 	_tmp49_ = ns_metadata;
4536 	if (vala_gir_parser_metadata_has_argument (_tmp49_, VALA_GIR_PARSER_ARGUMENT_TYPE_NAME)) {
4537 		ValaGirParserMetadata* _tmp50_;
4538 		gchar* _tmp51_;
4539 		_tmp50_ = ns_metadata;
4540 		_tmp51_ = vala_gir_parser_metadata_get_string (_tmp50_, VALA_GIR_PARSER_ARGUMENT_TYPE_NAME);
4541 		_g_free0 (vala_namespace);
4542 		vala_namespace = _tmp51_;
4543 	}
4544 	_tmp52_ = vala_namespace;
4545 	if (_tmp52_ == NULL) {
4546 		const gchar* _tmp53_;
4547 		gchar* _tmp54_;
4548 		_tmp53_ = gir_namespace;
4549 		_tmp54_ = g_strdup (_tmp53_);
4550 		_g_free0 (vala_namespace);
4551 		vala_namespace = _tmp54_;
4552 	}
4553 	_tmp55_ = self->priv->current_source_file;
4554 	_tmp56_ = gir_namespace;
4555 	vala_source_file_set_gir_namespace (_tmp55_, _tmp56_);
4556 	_tmp57_ = self->priv->current_source_file;
4557 	_tmp58_ = gir_version;
4558 	vala_source_file_set_gir_version (_tmp57_, _tmp58_);
4559 	_tmp59_ = vala_namespace;
4560 	vala_gir_parser_push_node (self, _tmp59_, TRUE);
4561 	_tmp60_ = self->priv->current;
4562 	if (_tmp60_->new_symbol) {
4563 		const gchar* _tmp61_;
4564 		ValaGirParserNode* _tmp62_;
4565 		ValaSourceReference* _tmp63_;
4566 		ValaNamespace* _tmp64_;
4567 		ValaGirParserNode* _tmp65_;
4568 		ValaNamespace* _tmp66_;
4569 		ValaSymbol* _tmp67_;
4570 		_tmp61_ = vala_namespace;
4571 		_tmp62_ = self->priv->current;
4572 		_tmp63_ = _tmp62_->source_reference;
4573 		_tmp64_ = vala_namespace_new (_tmp61_, _tmp63_);
4574 		_vala_code_node_unref0 (ns);
4575 		ns = _tmp64_;
4576 		_tmp65_ = self->priv->current;
4577 		_tmp66_ = ns;
4578 		_tmp67_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp66_);
4579 		_vala_code_node_unref0 (_tmp65_->symbol);
4580 		_tmp65_->symbol = _tmp67_;
4581 	} else {
4582 		ValaGirParserNode* _tmp68_;
4583 		ValaSymbol* _tmp69_;
4584 		ValaNamespace* _tmp70_;
4585 		ValaNamespace* _tmp71_;
4586 		ValaNamespace* _tmp72_;
4587 		ValaGirParserNode* _tmp73_;
4588 		ValaSourceReference* _tmp74_;
4589 		_tmp68_ = self->priv->current;
4590 		_tmp69_ = _tmp68_->symbol;
4591 		_tmp70_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp69_, VALA_TYPE_NAMESPACE, ValaNamespace));
4592 		_vala_code_node_unref0 (ns);
4593 		ns = _tmp70_;
4594 		_tmp71_ = ns;
4595 		(((ValaCodeNode*) _tmp71_)->attributes == NULL) ? NULL : (((ValaCodeNode*) _tmp71_)->attributes = (_g_list_free__vala_code_node_unref0_ (((ValaCodeNode*) _tmp71_)->attributes), NULL));
4596 		((ValaCodeNode*) _tmp71_)->attributes = NULL;
4597 		_tmp72_ = ns;
4598 		_tmp73_ = self->priv->current;
4599 		_tmp74_ = _tmp73_->source_reference;
4600 		vala_code_node_set_source_reference ((ValaCodeNode*) _tmp72_, _tmp74_);
4601 	}
4602 	_tmp75_ = self->priv->current;
4603 	_tmp76_ = ns_metadata;
4604 	_tmp77_ = _vala_gir_parser_metadata_ref0 (_tmp76_);
4605 	_vala_gir_parser_metadata_unref0 (_tmp75_->metadata);
4606 	_tmp75_->metadata = _tmp77_;
4607 	_tmp78_ = ns_metadata;
4608 	if (vala_gir_parser_metadata_has_argument (_tmp78_, VALA_GIR_PARSER_ARGUMENT_TYPE_CPREFIX)) {
4609 		ValaGirParserMetadata* _tmp79_;
4610 		gchar* _tmp80_;
4611 		_tmp79_ = ns_metadata;
4612 		_tmp80_ = vala_gir_parser_metadata_get_string (_tmp79_, VALA_GIR_PARSER_ARGUMENT_TYPE_CPREFIX);
4613 		_g_free0 (cprefix);
4614 		cprefix = _tmp80_;
4615 	}
4616 	_tmp81_ = ns_metadata;
4617 	if (vala_gir_parser_metadata_has_argument (_tmp81_, VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CPREFIX)) {
4618 		ValaGirParserMetadata* _tmp82_;
4619 		gchar* _tmp83_;
4620 		_tmp82_ = ns_metadata;
4621 		_tmp83_ = vala_gir_parser_metadata_get_string (_tmp82_, VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CPREFIX);
4622 		_g_free0 (lower_case_cprefix);
4623 		lower_case_cprefix = _tmp83_;
4624 	} else {
4625 		const gchar* _tmp84_;
4626 		_tmp84_ = lower_case_cprefix;
4627 		if (_tmp84_ != NULL) {
4628 			const gchar* _tmp85_;
4629 			gchar* _tmp86_;
4630 			_tmp85_ = lower_case_cprefix;
4631 			_tmp86_ = g_strconcat (_tmp85_, "_", NULL);
4632 			_g_free0 (lower_case_cprefix);
4633 			lower_case_cprefix = _tmp86_;
4634 		}
4635 	}
4636 	_tmp87_ = ns;
4637 	_tmp88_ = gir_namespace;
4638 	vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp87_, "CCode", "gir_namespace", _tmp88_, NULL);
4639 	_tmp89_ = ns;
4640 	_tmp90_ = gir_version;
4641 	vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp89_, "CCode", "gir_version", _tmp90_, NULL);
4642 	_tmp91_ = cprefix;
4643 	if (_tmp91_ != NULL) {
4644 		ValaNamespace* _tmp92_;
4645 		const gchar* _tmp93_;
4646 		const gchar* _tmp94_;
4647 		_tmp92_ = ns;
4648 		_tmp93_ = cprefix;
4649 		vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp92_, "CCode", "cprefix", _tmp93_, NULL);
4650 		_tmp94_ = lower_case_cprefix;
4651 		if (_tmp94_ == NULL) {
4652 			ValaNamespace* _tmp95_;
4653 			const gchar* _tmp96_;
4654 			gchar* _tmp97_;
4655 			gchar* _tmp98_;
4656 			gchar* _tmp99_;
4657 			gchar* _tmp100_;
4658 			_tmp95_ = ns;
4659 			_tmp96_ = cprefix;
4660 			_tmp97_ = vala_symbol_camel_case_to_lower_case (_tmp96_);
4661 			_tmp98_ = _tmp97_;
4662 			_tmp99_ = g_strconcat (_tmp98_, "_", NULL);
4663 			_tmp100_ = _tmp99_;
4664 			vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp95_, "CCode", "lower_case_cprefix", _tmp100_, NULL);
4665 			_g_free0 (_tmp100_);
4666 			_g_free0 (_tmp98_);
4667 		}
4668 	}
4669 	_tmp101_ = lower_case_cprefix;
4670 	if (_tmp101_ != NULL) {
4671 		ValaNamespace* _tmp102_;
4672 		const gchar* _tmp103_;
4673 		_tmp102_ = ns;
4674 		_tmp103_ = lower_case_cprefix;
4675 		vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp102_, "CCode", "lower_case_cprefix", _tmp103_, NULL);
4676 	}
4677 	_tmp104_ = self->priv->cheader_filenames;
4678 	_tmp104__length1 = self->priv->cheader_filenames_length1;
4679 	if (_tmp104_ != NULL) {
4680 		ValaNamespace* _tmp105_;
4681 		gchar** _tmp106_;
4682 		gint _tmp106__length1;
4683 		gchar* _tmp107_;
4684 		gchar* _tmp108_;
4685 		_tmp105_ = ns;
4686 		_tmp106_ = self->priv->cheader_filenames;
4687 		_tmp106__length1 = self->priv->cheader_filenames_length1;
4688 		_tmp107_ = _vala_g_strjoinv (",", _tmp106_, (gint) _tmp106__length1);
4689 		_tmp108_ = _tmp107_;
4690 		vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp105_, "CCode", "cheader_filename", _tmp108_, NULL);
4691 		_g_free0 (_tmp108_);
4692 	}
4693 	vala_gir_parser_next (self);
4694 	while (TRUE) {
4695 		ValaMarkupTokenType _tmp109_;
4696 		ValaMarkupReader* _tmp110_;
4697 		const gchar* _tmp111_;
4698 		const gchar* _tmp112_;
4699 		_tmp109_ = self->priv->current_token;
4700 		if (!(_tmp109_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT)) {
4701 			break;
4702 		}
4703 		if (!vala_gir_parser_push_metadata (self)) {
4704 			vala_gir_parser_skip_element (self);
4705 			continue;
4706 		}
4707 		_tmp110_ = self->priv->reader;
4708 		_tmp111_ = vala_markup_reader_get_name (_tmp110_);
4709 		_tmp112_ = _tmp111_;
4710 		if (g_strcmp0 (_tmp112_, "alias") == 0) {
4711 			vala_gir_parser_parse_alias (self);
4712 		} else {
4713 			ValaMarkupReader* _tmp113_;
4714 			const gchar* _tmp114_;
4715 			const gchar* _tmp115_;
4716 			_tmp113_ = self->priv->reader;
4717 			_tmp114_ = vala_markup_reader_get_name (_tmp113_);
4718 			_tmp115_ = _tmp114_;
4719 			if (g_strcmp0 (_tmp115_, "enumeration") == 0) {
4720 				ValaGirParserMetadata* _tmp116_;
4721 				_tmp116_ = self->priv->metadata;
4722 				if (vala_gir_parser_metadata_has_argument (_tmp116_, VALA_GIR_PARSER_ARGUMENT_TYPE_ERRORDOMAIN)) {
4723 					ValaGirParserMetadata* _tmp117_;
4724 					_tmp117_ = self->priv->metadata;
4725 					if (vala_gir_parser_metadata_get_bool (_tmp117_, VALA_GIR_PARSER_ARGUMENT_TYPE_ERRORDOMAIN, FALSE)) {
4726 						vala_gir_parser_parse_error_domain (self);
4727 					} else {
4728 						vala_gir_parser_parse_enumeration (self, "enumeration", FALSE);
4729 					}
4730 				} else {
4731 					gboolean _tmp118_ = FALSE;
4732 					ValaMarkupReader* _tmp119_;
4733 					gchar* _tmp120_;
4734 					gchar* _tmp121_;
4735 					gboolean _tmp122_;
4736 					_tmp119_ = self->priv->reader;
4737 					_tmp120_ = vala_markup_reader_get_attribute (_tmp119_, "glib:error-quark");
4738 					_tmp121_ = _tmp120_;
4739 					_tmp122_ = _tmp121_ != NULL;
4740 					_g_free0 (_tmp121_);
4741 					if (_tmp122_) {
4742 						_tmp118_ = TRUE;
4743 					} else {
4744 						ValaMarkupReader* _tmp123_;
4745 						gchar* _tmp124_;
4746 						gchar* _tmp125_;
4747 						_tmp123_ = self->priv->reader;
4748 						_tmp124_ = vala_markup_reader_get_attribute (_tmp123_, "glib:error-domain");
4749 						_tmp125_ = _tmp124_;
4750 						_tmp118_ = _tmp125_ != NULL;
4751 						_g_free0 (_tmp125_);
4752 					}
4753 					if (_tmp118_) {
4754 						vala_gir_parser_parse_error_domain (self);
4755 					} else {
4756 						vala_gir_parser_parse_enumeration (self, "enumeration", FALSE);
4757 					}
4758 				}
4759 			} else {
4760 				ValaMarkupReader* _tmp126_;
4761 				const gchar* _tmp127_;
4762 				const gchar* _tmp128_;
4763 				_tmp126_ = self->priv->reader;
4764 				_tmp127_ = vala_markup_reader_get_name (_tmp126_);
4765 				_tmp128_ = _tmp127_;
4766 				if (g_strcmp0 (_tmp128_, "bitfield") == 0) {
4767 					vala_gir_parser_parse_bitfield (self);
4768 				} else {
4769 					ValaMarkupReader* _tmp129_;
4770 					const gchar* _tmp130_;
4771 					const gchar* _tmp131_;
4772 					_tmp129_ = self->priv->reader;
4773 					_tmp130_ = vala_markup_reader_get_name (_tmp129_);
4774 					_tmp131_ = _tmp130_;
4775 					if (g_strcmp0 (_tmp131_, "function") == 0) {
4776 						vala_gir_parser_parse_method (self, "function");
4777 					} else {
4778 						ValaMarkupReader* _tmp132_;
4779 						const gchar* _tmp133_;
4780 						const gchar* _tmp134_;
4781 						_tmp132_ = self->priv->reader;
4782 						_tmp133_ = vala_markup_reader_get_name (_tmp132_);
4783 						_tmp134_ = _tmp133_;
4784 						if (g_strcmp0 (_tmp134_, "function-macro") == 0) {
4785 							vala_gir_parser_skip_element (self);
4786 						} else {
4787 							ValaMarkupReader* _tmp135_;
4788 							const gchar* _tmp136_;
4789 							const gchar* _tmp137_;
4790 							_tmp135_ = self->priv->reader;
4791 							_tmp136_ = vala_markup_reader_get_name (_tmp135_);
4792 							_tmp137_ = _tmp136_;
4793 							if (g_strcmp0 (_tmp137_, "callback") == 0) {
4794 								vala_gir_parser_parse_callback (self);
4795 							} else {
4796 								ValaMarkupReader* _tmp138_;
4797 								const gchar* _tmp139_;
4798 								const gchar* _tmp140_;
4799 								_tmp138_ = self->priv->reader;
4800 								_tmp139_ = vala_markup_reader_get_name (_tmp138_);
4801 								_tmp140_ = _tmp139_;
4802 								if (g_strcmp0 (_tmp140_, "record") == 0) {
4803 									ValaGirParserMetadata* _tmp141_;
4804 									_tmp141_ = self->priv->metadata;
4805 									if (vala_gir_parser_metadata_has_argument (_tmp141_, VALA_GIR_PARSER_ARGUMENT_TYPE_STRUCT)) {
4806 										ValaGirParserMetadata* _tmp142_;
4807 										_tmp142_ = self->priv->metadata;
4808 										if (vala_gir_parser_metadata_get_bool (_tmp142_, VALA_GIR_PARSER_ARGUMENT_TYPE_STRUCT, FALSE)) {
4809 											vala_gir_parser_parse_record (self);
4810 										} else {
4811 											vala_gir_parser_parse_boxed (self, "record");
4812 										}
4813 									} else {
4814 										gchar* _tmp143_;
4815 										gchar* _tmp144_;
4816 										gboolean _tmp145_;
4817 										_tmp143_ = vala_gir_parser_element_get_type_id (self);
4818 										_tmp144_ = _tmp143_;
4819 										_tmp145_ = _tmp144_ != NULL;
4820 										_g_free0 (_tmp144_);
4821 										if (_tmp145_) {
4822 											vala_gir_parser_parse_boxed (self, "record");
4823 										} else {
4824 											ValaMarkupReader* _tmp146_;
4825 											gchar* _tmp147_;
4826 											gchar* _tmp148_;
4827 											gboolean _tmp149_;
4828 											_tmp146_ = self->priv->reader;
4829 											_tmp147_ = vala_markup_reader_get_attribute (_tmp146_, "name");
4830 											_tmp148_ = _tmp147_;
4831 											_tmp149_ = !g_str_has_suffix (_tmp148_, "Private");
4832 											_g_free0 (_tmp148_);
4833 											if (_tmp149_) {
4834 												gboolean _tmp150_ = FALSE;
4835 												ValaMarkupReader* _tmp151_;
4836 												gchar* _tmp152_;
4837 												gchar* _tmp153_;
4838 												gboolean _tmp154_;
4839 												_tmp151_ = self->priv->reader;
4840 												_tmp152_ = vala_markup_reader_get_attribute (_tmp151_, "glib:is-gtype-struct-for");
4841 												_tmp153_ = _tmp152_;
4842 												_tmp154_ = _tmp153_ == NULL;
4843 												_g_free0 (_tmp153_);
4844 												if (_tmp154_) {
4845 													ValaMarkupReader* _tmp155_;
4846 													gchar* _tmp156_;
4847 													gchar* _tmp157_;
4848 													_tmp155_ = self->priv->reader;
4849 													_tmp156_ = vala_markup_reader_get_attribute (_tmp155_, "disguised");
4850 													_tmp157_ = _tmp156_;
4851 													_tmp150_ = g_strcmp0 (_tmp157_, "1") == 0;
4852 													_g_free0 (_tmp157_);
4853 												} else {
4854 													_tmp150_ = FALSE;
4855 												}
4856 												if (_tmp150_) {
4857 													vala_gir_parser_parse_boxed (self, "record");
4858 												} else {
4859 													vala_gir_parser_parse_record (self);
4860 												}
4861 											} else {
4862 												vala_gir_parser_skip_element (self);
4863 											}
4864 										}
4865 									}
4866 								} else {
4867 									ValaMarkupReader* _tmp158_;
4868 									const gchar* _tmp159_;
4869 									const gchar* _tmp160_;
4870 									_tmp158_ = self->priv->reader;
4871 									_tmp159_ = vala_markup_reader_get_name (_tmp158_);
4872 									_tmp160_ = _tmp159_;
4873 									if (g_strcmp0 (_tmp160_, "class") == 0) {
4874 										vala_gir_parser_parse_class (self);
4875 									} else {
4876 										ValaMarkupReader* _tmp161_;
4877 										const gchar* _tmp162_;
4878 										const gchar* _tmp163_;
4879 										_tmp161_ = self->priv->reader;
4880 										_tmp162_ = vala_markup_reader_get_name (_tmp161_);
4881 										_tmp163_ = _tmp162_;
4882 										if (g_strcmp0 (_tmp163_, "interface") == 0) {
4883 											vala_gir_parser_parse_interface (self);
4884 										} else {
4885 											ValaMarkupReader* _tmp164_;
4886 											const gchar* _tmp165_;
4887 											const gchar* _tmp166_;
4888 											_tmp164_ = self->priv->reader;
4889 											_tmp165_ = vala_markup_reader_get_name (_tmp164_);
4890 											_tmp166_ = _tmp165_;
4891 											if (g_strcmp0 (_tmp166_, "glib:boxed") == 0) {
4892 												vala_gir_parser_parse_boxed (self, "glib:boxed");
4893 											} else {
4894 												ValaMarkupReader* _tmp167_;
4895 												const gchar* _tmp168_;
4896 												const gchar* _tmp169_;
4897 												_tmp167_ = self->priv->reader;
4898 												_tmp168_ = vala_markup_reader_get_name (_tmp167_);
4899 												_tmp169_ = _tmp168_;
4900 												if (g_strcmp0 (_tmp169_, "union") == 0) {
4901 													gboolean _tmp170_ = FALSE;
4902 													gchar* _tmp171_;
4903 													gchar* _tmp172_;
4904 													gboolean _tmp173_;
4905 													_tmp171_ = vala_gir_parser_element_get_type_id (self);
4906 													_tmp172_ = _tmp171_;
4907 													_tmp173_ = _tmp172_ != NULL;
4908 													_g_free0 (_tmp172_);
4909 													if (_tmp173_) {
4910 														ValaGirParserMetadata* _tmp174_;
4911 														_tmp174_ = self->priv->metadata;
4912 														_tmp170_ = !vala_gir_parser_metadata_get_bool (_tmp174_, VALA_GIR_PARSER_ARGUMENT_TYPE_STRUCT, FALSE);
4913 													} else {
4914 														_tmp170_ = FALSE;
4915 													}
4916 													if (_tmp170_) {
4917 														vala_gir_parser_parse_boxed (self, "union");
4918 													} else {
4919 														vala_gir_parser_parse_union (self);
4920 													}
4921 												} else {
4922 													ValaMarkupReader* _tmp175_;
4923 													const gchar* _tmp176_;
4924 													const gchar* _tmp177_;
4925 													_tmp175_ = self->priv->reader;
4926 													_tmp176_ = vala_markup_reader_get_name (_tmp175_);
4927 													_tmp177_ = _tmp176_;
4928 													if (g_strcmp0 (_tmp177_, "constant") == 0) {
4929 														vala_gir_parser_parse_constant (self);
4930 													} else {
4931 														ValaMarkupReader* _tmp178_;
4932 														const gchar* _tmp179_;
4933 														const gchar* _tmp180_;
4934 														_tmp178_ = self->priv->reader;
4935 														_tmp179_ = vala_markup_reader_get_name (_tmp178_);
4936 														_tmp180_ = _tmp179_;
4937 														if (g_strcmp0 (_tmp180_, "docsection") == 0) {
4938 															vala_gir_parser_skip_element (self);
4939 														} else {
4940 															ValaSourceReference* _tmp181_;
4941 															ValaSourceReference* _tmp182_;
4942 															ValaMarkupReader* _tmp183_;
4943 															const gchar* _tmp184_;
4944 															const gchar* _tmp185_;
4945 															gchar* _tmp186_;
4946 															gchar* _tmp187_;
4947 															_tmp181_ = vala_gir_parser_get_current_src (self);
4948 															_tmp182_ = _tmp181_;
4949 															_tmp183_ = self->priv->reader;
4950 															_tmp184_ = vala_markup_reader_get_name (_tmp183_);
4951 															_tmp185_ = _tmp184_;
4952 															_tmp186_ = g_strdup_printf ("unknown child element `%s' in `namespace'", _tmp185_);
4953 															_tmp187_ = _tmp186_;
4954 															vala_report_error (_tmp182_, _tmp187_);
4955 															_g_free0 (_tmp187_);
4956 															_vala_source_reference_unref0 (_tmp182_);
4957 															vala_gir_parser_skip_element (self);
4958 														}
4959 													}
4960 												}
4961 											}
4962 										}
4963 									}
4964 								}
4965 							}
4966 						}
4967 					}
4968 				}
4969 			}
4970 		}
4971 		vala_gir_parser_pop_metadata (self);
4972 	}
4973 	vala_gir_parser_pop_node (self);
4974 	vala_gir_parser_end_element (self, "namespace");
4975 	_vala_code_node_unref0 (ns);
4976 	_vala_gir_parser_metadata_unref0 (ns_metadata);
4977 	_g_free0 (metadata_filename);
4978 	_g_free0 (gir_version);
4979 	_g_free0 (gir_namespace);
4980 	_g_free0 (vala_namespace);
4981 	_g_free0 (lower_case_cprefix);
4982 	_g_free0 (cprefix);
4983 }
4984 
4985 static void
vala_gir_parser_parse_alias(ValaGirParser * self)4986 vala_gir_parser_parse_alias (ValaGirParser* self)
4987 {
4988 	gchar* _tmp0_;
4989 	gchar* _tmp1_;
4990 	ValaGirParserNode* _tmp2_;
4991 	ValaGirComment* _tmp3_;
4992 	gboolean no_array_length = FALSE;
4993 	gboolean array_null_terminated = FALSE;
4994 	ValaGirParserNode* _tmp8_;
4995 	ValaDataType* _tmp9_;
4996 	ValaDataType* _tmp10_;
4997 	ValaDataType* _tmp11_;
4998 	ValaGirParserMetadata* _tmp12_;
4999 	g_return_if_fail (self != NULL);
5000 	vala_gir_parser_start_element (self, "alias");
5001 	_tmp0_ = vala_gir_parser_element_get_name (self, NULL);
5002 	_tmp1_ = _tmp0_;
5003 	vala_gir_parser_push_node (self, _tmp1_, TRUE);
5004 	_g_free0 (_tmp1_);
5005 	vala_gir_parser_next (self);
5006 	_tmp2_ = self->priv->current;
5007 	_tmp3_ = _tmp2_->comment;
5008 	if (_tmp3_ == NULL) {
5009 		ValaGirParserNode* _tmp4_;
5010 		ValaGirComment* _tmp5_;
5011 		_tmp4_ = self->priv->current;
5012 		_tmp5_ = vala_gir_parser_parse_symbol_doc (self);
5013 		_vala_comment_unref0 (_tmp4_->comment);
5014 		_tmp4_->comment = _tmp5_;
5015 	} else {
5016 		ValaGirComment* _tmp6_;
5017 		ValaGirComment* _tmp7_;
5018 		_tmp6_ = vala_gir_parser_parse_symbol_doc (self);
5019 		_tmp7_ = _tmp6_;
5020 		_vala_comment_unref0 (_tmp7_);
5021 	}
5022 	no_array_length = FALSE;
5023 	array_null_terminated = FALSE;
5024 	_tmp8_ = self->priv->current;
5025 	_tmp9_ = vala_gir_parser_parse_type (self, NULL, NULL, TRUE, NULL, NULL);
5026 	_tmp10_ = _tmp9_;
5027 	_tmp11_ = vala_gir_parser_element_get_type (self, _tmp10_, TRUE, &no_array_length, &array_null_terminated, NULL);
5028 	_vala_code_node_unref0 (_tmp8_->base_type);
5029 	_tmp8_->base_type = _tmp11_;
5030 	_vala_code_node_unref0 (_tmp10_);
5031 	_tmp12_ = self->priv->metadata;
5032 	if (vala_gir_parser_metadata_has_argument (_tmp12_, VALA_GIR_PARSER_ARGUMENT_TYPE_BASE_TYPE)) {
5033 		ValaGirParserNode* _tmp13_;
5034 		ValaGirParserMetadata* _tmp14_;
5035 		gchar* _tmp15_;
5036 		gchar* _tmp16_;
5037 		ValaGirParserMetadata* _tmp17_;
5038 		ValaSourceReference* _tmp18_;
5039 		ValaSourceReference* _tmp19_;
5040 		ValaDataType* _tmp20_;
5041 		_tmp13_ = self->priv->current;
5042 		_tmp14_ = self->priv->metadata;
5043 		_tmp15_ = vala_gir_parser_metadata_get_string (_tmp14_, VALA_GIR_PARSER_ARGUMENT_TYPE_BASE_TYPE);
5044 		_tmp16_ = _tmp15_;
5045 		_tmp17_ = self->priv->metadata;
5046 		_tmp18_ = vala_gir_parser_metadata_get_source_reference (_tmp17_, VALA_GIR_PARSER_ARGUMENT_TYPE_BASE_TYPE);
5047 		_tmp19_ = _tmp18_;
5048 		_tmp20_ = vala_gir_parser_parse_type_from_string (self, _tmp16_, TRUE, _tmp19_);
5049 		_vala_code_node_unref0 (_tmp13_->base_type);
5050 		_tmp13_->base_type = _tmp20_;
5051 		_vala_source_reference_unref0 (_tmp19_);
5052 		_g_free0 (_tmp16_);
5053 	}
5054 	vala_gir_parser_pop_node (self);
5055 	vala_gir_parser_end_element (self, "alias");
5056 }
5057 
5058 static gunichar
string_get_char(const gchar * self,glong index)5059 string_get_char (const gchar* self,
5060                  glong index)
5061 {
5062 	gunichar result = 0U;
5063 	g_return_val_if_fail (self != NULL, 0U);
5064 	result = g_utf8_get_char (((gchar*) self) + index);
5065 	return result;
5066 }
5067 
5068 static void
vala_gir_parser_calculate_common_prefix(ValaGirParser * self,gchar ** common_prefix,const gchar * cname)5069 vala_gir_parser_calculate_common_prefix (ValaGirParser* self,
5070                                          gchar* * common_prefix,
5071                                          const gchar* cname)
5072 {
5073 	g_return_if_fail (self != NULL);
5074 	g_return_if_fail (cname != NULL);
5075 	if ((*common_prefix) == NULL) {
5076 		gchar* _tmp0_;
5077 		_tmp0_ = g_strdup (cname);
5078 		_g_free0 (*common_prefix);
5079 		*common_prefix = _tmp0_;
5080 		while (TRUE) {
5081 			gboolean _tmp1_ = FALSE;
5082 			gint _tmp2_;
5083 			gint _tmp3_;
5084 			gint _tmp4_;
5085 			gint _tmp5_;
5086 			gchar* _tmp6_;
5087 			_tmp2_ = strlen (*common_prefix);
5088 			_tmp3_ = _tmp2_;
5089 			if (_tmp3_ > 0) {
5090 				_tmp1_ = !g_str_has_suffix (*common_prefix, "_");
5091 			} else {
5092 				_tmp1_ = FALSE;
5093 			}
5094 			if (!_tmp1_) {
5095 				break;
5096 			}
5097 			_tmp4_ = strlen (*common_prefix);
5098 			_tmp5_ = _tmp4_;
5099 			_tmp6_ = string_substring (*common_prefix, (glong) 0, (glong) (_tmp5_ - 1));
5100 			_g_free0 (*common_prefix);
5101 			*common_prefix = _tmp6_;
5102 		}
5103 	} else {
5104 		while (TRUE) {
5105 			gint _tmp7_;
5106 			gint _tmp8_;
5107 			gchar* _tmp9_;
5108 			if (!(!g_str_has_prefix (cname, *common_prefix))) {
5109 				break;
5110 			}
5111 			_tmp7_ = strlen (*common_prefix);
5112 			_tmp8_ = _tmp7_;
5113 			_tmp9_ = string_substring (*common_prefix, (glong) 0, (glong) (_tmp8_ - 1));
5114 			_g_free0 (*common_prefix);
5115 			*common_prefix = _tmp9_;
5116 		}
5117 	}
5118 	while (TRUE) {
5119 		gboolean _tmp10_ = FALSE;
5120 		gint _tmp11_;
5121 		gint _tmp12_;
5122 		gint _tmp21_;
5123 		gint _tmp22_;
5124 		gchar* _tmp23_;
5125 		_tmp11_ = strlen (*common_prefix);
5126 		_tmp12_ = _tmp11_;
5127 		if (_tmp12_ > 0) {
5128 			gboolean _tmp13_ = FALSE;
5129 			if (!g_str_has_suffix (*common_prefix, "_")) {
5130 				_tmp13_ = TRUE;
5131 			} else {
5132 				gboolean _tmp14_ = FALSE;
5133 				gint _tmp15_;
5134 				gint _tmp16_;
5135 				_tmp15_ = strlen (*common_prefix);
5136 				_tmp16_ = _tmp15_;
5137 				if (g_unichar_isdigit (string_get_char (cname, (glong) _tmp16_))) {
5138 					gint _tmp17_;
5139 					gint _tmp18_;
5140 					gint _tmp19_;
5141 					gint _tmp20_;
5142 					_tmp17_ = strlen (cname);
5143 					_tmp18_ = _tmp17_;
5144 					_tmp19_ = strlen (*common_prefix);
5145 					_tmp20_ = _tmp19_;
5146 					_tmp14_ = (_tmp18_ - _tmp20_) <= 1;
5147 				} else {
5148 					_tmp14_ = FALSE;
5149 				}
5150 				_tmp13_ = _tmp14_;
5151 			}
5152 			_tmp10_ = _tmp13_;
5153 		} else {
5154 			_tmp10_ = FALSE;
5155 		}
5156 		if (!_tmp10_) {
5157 			break;
5158 		}
5159 		_tmp21_ = strlen (*common_prefix);
5160 		_tmp22_ = _tmp21_;
5161 		_tmp23_ = string_substring (*common_prefix, (glong) 0, (glong) (_tmp22_ - 1));
5162 		_g_free0 (*common_prefix);
5163 		*common_prefix = _tmp23_;
5164 	}
5165 }
5166 
5167 static ValaGirComment*
vala_gir_parser_parse_symbol_doc(ValaGirParser * self)5168 vala_gir_parser_parse_symbol_doc (ValaGirParser* self)
5169 {
5170 	ValaGirComment* comment = NULL;
5171 	ValaGirComment* result = NULL;
5172 	g_return_val_if_fail (self != NULL, NULL);
5173 	comment = NULL;
5174 	while (TRUE) {
5175 		ValaMarkupTokenType _tmp0_;
5176 		const gchar* reader_name = NULL;
5177 		ValaMarkupReader* _tmp1_;
5178 		const gchar* _tmp2_;
5179 		const gchar* _tmp3_;
5180 		const gchar* _tmp4_;
5181 		_tmp0_ = self->priv->current_token;
5182 		if (!(_tmp0_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT)) {
5183 			break;
5184 		}
5185 		_tmp1_ = self->priv->reader;
5186 		_tmp2_ = vala_markup_reader_get_name (_tmp1_);
5187 		_tmp3_ = _tmp2_;
5188 		reader_name = _tmp3_;
5189 		_tmp4_ = reader_name;
5190 		if (g_strcmp0 (_tmp4_, "doc") == 0) {
5191 			ValaMarkupTokenType _tmp5_;
5192 			vala_gir_parser_start_element (self, "doc");
5193 			vala_gir_parser_next (self);
5194 			_tmp5_ = self->priv->current_token;
5195 			if (_tmp5_ == VALA_MARKUP_TOKEN_TYPE_TEXT) {
5196 				ValaMarkupReader* _tmp6_;
5197 				const gchar* _tmp7_;
5198 				const gchar* _tmp8_;
5199 				ValaGirParserNode* _tmp9_;
5200 				ValaSourceReference* _tmp10_;
5201 				ValaGirComment* _tmp11_;
5202 				_tmp6_ = self->priv->reader;
5203 				_tmp7_ = vala_markup_reader_get_content (_tmp6_);
5204 				_tmp8_ = _tmp7_;
5205 				_tmp9_ = self->priv->current;
5206 				_tmp10_ = _tmp9_->source_reference;
5207 				_tmp11_ = vala_gir_comment_new (_tmp8_, _tmp10_);
5208 				_vala_comment_unref0 (comment);
5209 				comment = _tmp11_;
5210 				vala_gir_parser_next (self);
5211 			}
5212 			vala_gir_parser_end_element (self, "doc");
5213 		} else {
5214 			gboolean _tmp12_ = FALSE;
5215 			gboolean _tmp13_ = FALSE;
5216 			const gchar* _tmp14_;
5217 			_tmp14_ = reader_name;
5218 			if (g_strcmp0 (_tmp14_, "doc-version") == 0) {
5219 				_tmp13_ = TRUE;
5220 			} else {
5221 				const gchar* _tmp15_;
5222 				_tmp15_ = reader_name;
5223 				_tmp13_ = g_strcmp0 (_tmp15_, "doc-deprecated") == 0;
5224 			}
5225 			if (_tmp13_) {
5226 				_tmp12_ = TRUE;
5227 			} else {
5228 				const gchar* _tmp16_;
5229 				_tmp16_ = reader_name;
5230 				_tmp12_ = g_strcmp0 (_tmp16_, "doc-stability") == 0;
5231 			}
5232 			if (_tmp12_) {
5233 				vala_gir_parser_skip_element (self);
5234 			} else {
5235 				const gchar* _tmp17_;
5236 				_tmp17_ = reader_name;
5237 				if (g_strcmp0 (_tmp17_, "source-position") == 0) {
5238 					vala_gir_parser_skip_element (self);
5239 				} else {
5240 					const gchar* _tmp18_;
5241 					_tmp18_ = reader_name;
5242 					if (g_strcmp0 (_tmp18_, "attribute") == 0) {
5243 						vala_gir_parser_skip_element (self);
5244 					} else {
5245 						break;
5246 					}
5247 				}
5248 			}
5249 		}
5250 	}
5251 	result = comment;
5252 	return result;
5253 }
5254 
5255 static ValaComment*
vala_gir_parser_parse_doc(ValaGirParser * self)5256 vala_gir_parser_parse_doc (ValaGirParser* self)
5257 {
5258 	ValaComment* comment = NULL;
5259 	ValaComment* result = NULL;
5260 	g_return_val_if_fail (self != NULL, NULL);
5261 	comment = NULL;
5262 	while (TRUE) {
5263 		ValaMarkupTokenType _tmp0_;
5264 		const gchar* reader_name = NULL;
5265 		ValaMarkupReader* _tmp1_;
5266 		const gchar* _tmp2_;
5267 		const gchar* _tmp3_;
5268 		const gchar* _tmp4_;
5269 		_tmp0_ = self->priv->current_token;
5270 		if (!(_tmp0_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT)) {
5271 			break;
5272 		}
5273 		_tmp1_ = self->priv->reader;
5274 		_tmp2_ = vala_markup_reader_get_name (_tmp1_);
5275 		_tmp3_ = _tmp2_;
5276 		reader_name = _tmp3_;
5277 		_tmp4_ = reader_name;
5278 		if (g_strcmp0 (_tmp4_, "doc") == 0) {
5279 			ValaMarkupTokenType _tmp5_;
5280 			vala_gir_parser_start_element (self, "doc");
5281 			vala_gir_parser_next (self);
5282 			_tmp5_ = self->priv->current_token;
5283 			if (_tmp5_ == VALA_MARKUP_TOKEN_TYPE_TEXT) {
5284 				ValaMarkupReader* _tmp6_;
5285 				const gchar* _tmp7_;
5286 				const gchar* _tmp8_;
5287 				ValaGirParserNode* _tmp9_;
5288 				ValaSourceReference* _tmp10_;
5289 				ValaComment* _tmp11_;
5290 				_tmp6_ = self->priv->reader;
5291 				_tmp7_ = vala_markup_reader_get_content (_tmp6_);
5292 				_tmp8_ = _tmp7_;
5293 				_tmp9_ = self->priv->current;
5294 				_tmp10_ = _tmp9_->source_reference;
5295 				_tmp11_ = vala_comment_new (_tmp8_, _tmp10_);
5296 				_vala_comment_unref0 (comment);
5297 				comment = _tmp11_;
5298 				vala_gir_parser_next (self);
5299 			}
5300 			vala_gir_parser_end_element (self, "doc");
5301 		} else {
5302 			gboolean _tmp12_ = FALSE;
5303 			gboolean _tmp13_ = FALSE;
5304 			const gchar* _tmp14_;
5305 			_tmp14_ = reader_name;
5306 			if (g_strcmp0 (_tmp14_, "doc-version") == 0) {
5307 				_tmp13_ = TRUE;
5308 			} else {
5309 				const gchar* _tmp15_;
5310 				_tmp15_ = reader_name;
5311 				_tmp13_ = g_strcmp0 (_tmp15_, "doc-deprecated") == 0;
5312 			}
5313 			if (_tmp13_) {
5314 				_tmp12_ = TRUE;
5315 			} else {
5316 				const gchar* _tmp16_;
5317 				_tmp16_ = reader_name;
5318 				_tmp12_ = g_strcmp0 (_tmp16_, "doc-stability") == 0;
5319 			}
5320 			if (_tmp12_) {
5321 				vala_gir_parser_skip_element (self);
5322 			} else {
5323 				const gchar* _tmp17_;
5324 				_tmp17_ = reader_name;
5325 				if (g_strcmp0 (_tmp17_, "source-position") == 0) {
5326 					vala_gir_parser_skip_element (self);
5327 				} else {
5328 					const gchar* _tmp18_;
5329 					_tmp18_ = reader_name;
5330 					if (g_strcmp0 (_tmp18_, "attribute") == 0) {
5331 						vala_gir_parser_skip_element (self);
5332 					} else {
5333 						break;
5334 					}
5335 				}
5336 			}
5337 		}
5338 	}
5339 	result = comment;
5340 	return result;
5341 }
5342 
5343 static void
vala_gir_parser_parse_enumeration(ValaGirParser * self,const gchar * element_name,gboolean error_domain)5344 vala_gir_parser_parse_enumeration (ValaGirParser* self,
5345                                    const gchar* element_name,
5346                                    gboolean error_domain)
5347 {
5348 	gchar* _tmp0_;
5349 	gchar* _tmp1_;
5350 	ValaSymbol* sym = NULL;
5351 	ValaGirParserNode* _tmp2_;
5352 	ValaSymbol* _tmp23_;
5353 	gchar* common_prefix = NULL;
5354 	gboolean explicit_prefix = FALSE;
5355 	ValaGirParserMetadata* _tmp24_;
5356 	gboolean has_member = FALSE;
5357 	ValaSymbol* _tmp29_;
5358 	ValaGirComment* _tmp30_;
5359 	ValaGirComment* _tmp31_;
5360 	const gchar* _tmp58_;
5361 	g_return_if_fail (self != NULL);
5362 	g_return_if_fail (element_name != NULL);
5363 	vala_gir_parser_start_element (self, element_name);
5364 	_tmp0_ = vala_gir_parser_element_get_name (self, NULL);
5365 	_tmp1_ = _tmp0_;
5366 	vala_gir_parser_push_node (self, _tmp1_, TRUE);
5367 	_g_free0 (_tmp1_);
5368 	_tmp2_ = self->priv->current;
5369 	if (_tmp2_->new_symbol) {
5370 		ValaGirParserNode* _tmp16_;
5371 		ValaSymbol* _tmp17_;
5372 		ValaSymbol* _tmp18_;
5373 		if (error_domain) {
5374 			ValaGirParserNode* _tmp3_;
5375 			const gchar* _tmp4_;
5376 			ValaGirParserNode* _tmp5_;
5377 			ValaSourceReference* _tmp6_;
5378 			ValaErrorDomain* _tmp7_;
5379 			_tmp3_ = self->priv->current;
5380 			_tmp4_ = _tmp3_->name;
5381 			_tmp5_ = self->priv->current;
5382 			_tmp6_ = _tmp5_->source_reference;
5383 			_tmp7_ = vala_error_domain_new (_tmp4_, _tmp6_, NULL);
5384 			_vala_code_node_unref0 (sym);
5385 			sym = (ValaSymbol*) _tmp7_;
5386 		} else {
5387 			ValaEnum* en = NULL;
5388 			ValaGirParserNode* _tmp8_;
5389 			const gchar* _tmp9_;
5390 			ValaGirParserNode* _tmp10_;
5391 			ValaSourceReference* _tmp11_;
5392 			ValaEnum* _tmp12_;
5393 			ValaEnum* _tmp14_;
5394 			ValaSymbol* _tmp15_;
5395 			_tmp8_ = self->priv->current;
5396 			_tmp9_ = _tmp8_->name;
5397 			_tmp10_ = self->priv->current;
5398 			_tmp11_ = _tmp10_->source_reference;
5399 			_tmp12_ = vala_enum_new (_tmp9_, _tmp11_, NULL);
5400 			en = _tmp12_;
5401 			if (g_strcmp0 (element_name, "bitfield") == 0) {
5402 				ValaEnum* _tmp13_;
5403 				_tmp13_ = en;
5404 				vala_code_node_set_attribute ((ValaCodeNode*) _tmp13_, "Flags", TRUE, NULL);
5405 			}
5406 			_tmp14_ = en;
5407 			_tmp15_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp14_);
5408 			_vala_code_node_unref0 (sym);
5409 			sym = _tmp15_;
5410 			_vala_code_node_unref0 (en);
5411 		}
5412 		_tmp16_ = self->priv->current;
5413 		_tmp17_ = sym;
5414 		_tmp18_ = _vala_code_node_ref0 (_tmp17_);
5415 		_vala_code_node_unref0 (_tmp16_->symbol);
5416 		_tmp16_->symbol = _tmp18_;
5417 	} else {
5418 		ValaGirParserNode* _tmp19_;
5419 		ValaSymbol* _tmp20_;
5420 		ValaSymbol* _tmp21_;
5421 		_tmp19_ = self->priv->current;
5422 		_tmp20_ = _tmp19_->symbol;
5423 		_tmp21_ = _vala_code_node_ref0 (_tmp20_);
5424 		_vala_code_node_unref0 (sym);
5425 		sym = _tmp21_;
5426 	}
5427 	if (!error_domain) {
5428 		ValaSymbol* _tmp22_;
5429 		_tmp22_ = sym;
5430 		vala_gir_parser_set_type_id_ccode (self, _tmp22_);
5431 	}
5432 	_tmp23_ = sym;
5433 	vala_symbol_set_access (_tmp23_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
5434 	common_prefix = NULL;
5435 	explicit_prefix = FALSE;
5436 	_tmp24_ = self->priv->metadata;
5437 	if (vala_gir_parser_metadata_has_argument (_tmp24_, VALA_GIR_PARSER_ARGUMENT_TYPE_CPREFIX)) {
5438 		ValaSymbol* _tmp25_;
5439 		ValaGirParserMetadata* _tmp26_;
5440 		gchar* _tmp27_;
5441 		gchar* _tmp28_;
5442 		_tmp25_ = sym;
5443 		_tmp26_ = self->priv->metadata;
5444 		_tmp27_ = vala_gir_parser_metadata_get_string (_tmp26_, VALA_GIR_PARSER_ARGUMENT_TYPE_CPREFIX);
5445 		_tmp28_ = _tmp27_;
5446 		vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp25_, "CCode", "cprefix", _tmp28_, NULL);
5447 		_g_free0 (_tmp28_);
5448 		explicit_prefix = TRUE;
5449 	}
5450 	has_member = FALSE;
5451 	vala_gir_parser_next (self);
5452 	_tmp29_ = sym;
5453 	_tmp30_ = vala_gir_parser_parse_symbol_doc (self);
5454 	_tmp31_ = _tmp30_;
5455 	vala_symbol_set_comment (_tmp29_, (ValaComment*) _tmp31_);
5456 	_vala_comment_unref0 (_tmp31_);
5457 	while (TRUE) {
5458 		ValaMarkupTokenType _tmp32_;
5459 		ValaMarkupReader* _tmp33_;
5460 		const gchar* _tmp34_;
5461 		const gchar* _tmp35_;
5462 		_tmp32_ = self->priv->current_token;
5463 		if (!(_tmp32_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT)) {
5464 			break;
5465 		}
5466 		if (!vala_gir_parser_push_metadata (self)) {
5467 			vala_gir_parser_skip_element (self);
5468 			continue;
5469 		}
5470 		_tmp33_ = self->priv->reader;
5471 		_tmp34_ = vala_markup_reader_get_name (_tmp33_);
5472 		_tmp35_ = _tmp34_;
5473 		if (g_strcmp0 (_tmp35_, "member") == 0) {
5474 			has_member = TRUE;
5475 			if (error_domain) {
5476 				vala_gir_parser_parse_error_member (self);
5477 			} else {
5478 				vala_gir_parser_parse_enumeration_member (self);
5479 			}
5480 			if (!explicit_prefix) {
5481 				ValaGirParserNode* _tmp36_;
5482 				gchar* _tmp37_;
5483 				gchar* _tmp38_;
5484 				_tmp36_ = self->priv->old_current;
5485 				_tmp37_ = vala_gir_parser_node_get_cname (_tmp36_);
5486 				_tmp38_ = _tmp37_;
5487 				vala_gir_parser_calculate_common_prefix (self, &common_prefix, _tmp38_);
5488 				_g_free0 (_tmp38_);
5489 			}
5490 		} else {
5491 			ValaMarkupReader* _tmp39_;
5492 			const gchar* _tmp40_;
5493 			const gchar* _tmp41_;
5494 			_tmp39_ = self->priv->reader;
5495 			_tmp40_ = vala_markup_reader_get_name (_tmp39_);
5496 			_tmp41_ = _tmp40_;
5497 			if (g_strcmp0 (_tmp41_, "function") == 0) {
5498 				vala_gir_parser_skip_element (self);
5499 			} else {
5500 				ValaMarkupReader* _tmp42_;
5501 				const gchar* _tmp43_;
5502 				const gchar* _tmp44_;
5503 				_tmp42_ = self->priv->reader;
5504 				_tmp43_ = vala_markup_reader_get_name (_tmp42_);
5505 				_tmp44_ = _tmp43_;
5506 				if (g_strcmp0 (_tmp44_, "function-macro") == 0) {
5507 					vala_gir_parser_skip_element (self);
5508 				} else {
5509 					ValaSourceReference* _tmp45_;
5510 					ValaSourceReference* _tmp46_;
5511 					ValaMarkupReader* _tmp47_;
5512 					const gchar* _tmp48_;
5513 					const gchar* _tmp49_;
5514 					gchar* _tmp50_;
5515 					gchar* _tmp51_;
5516 					_tmp45_ = vala_gir_parser_get_current_src (self);
5517 					_tmp46_ = _tmp45_;
5518 					_tmp47_ = self->priv->reader;
5519 					_tmp48_ = vala_markup_reader_get_name (_tmp47_);
5520 					_tmp49_ = _tmp48_;
5521 					_tmp50_ = g_strdup_printf ("unknown child element `%s' in `%s'", _tmp49_, element_name);
5522 					_tmp51_ = _tmp50_;
5523 					vala_report_error (_tmp46_, _tmp51_);
5524 					_g_free0 (_tmp51_);
5525 					_vala_source_reference_unref0 (_tmp46_);
5526 					vala_gir_parser_skip_element (self);
5527 				}
5528 			}
5529 		}
5530 		vala_gir_parser_pop_metadata (self);
5531 	}
5532 	if (!has_member) {
5533 		ValaSourceReference* _tmp52_;
5534 		ValaSourceReference* _tmp53_;
5535 		ValaGirParserNode* _tmp54_;
5536 		const gchar* _tmp55_;
5537 		gchar* _tmp56_;
5538 		gchar* _tmp57_;
5539 		_tmp52_ = vala_gir_parser_get_current_src (self);
5540 		_tmp53_ = _tmp52_;
5541 		_tmp54_ = self->priv->current;
5542 		_tmp55_ = _tmp54_->name;
5543 		_tmp56_ = g_strdup_printf ("%s `%s' has no members", element_name, _tmp55_);
5544 		_tmp57_ = _tmp56_;
5545 		vala_report_error (_tmp53_, _tmp57_);
5546 		_g_free0 (_tmp57_);
5547 		_vala_source_reference_unref0 (_tmp53_);
5548 	}
5549 	_tmp58_ = common_prefix;
5550 	if (_tmp58_ != NULL) {
5551 		ValaSymbol* _tmp59_;
5552 		const gchar* _tmp60_;
5553 		_tmp59_ = sym;
5554 		_tmp60_ = common_prefix;
5555 		vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp59_, "CCode", "cprefix", _tmp60_, NULL);
5556 	}
5557 	vala_gir_parser_pop_node (self);
5558 	vala_gir_parser_end_element (self, element_name);
5559 	_g_free0 (common_prefix);
5560 	_vala_code_node_unref0 (sym);
5561 }
5562 
5563 static void
vala_gir_parser_parse_error_domain(ValaGirParser * self)5564 vala_gir_parser_parse_error_domain (ValaGirParser* self)
5565 {
5566 	g_return_if_fail (self != NULL);
5567 	vala_gir_parser_parse_enumeration (self, "enumeration", TRUE);
5568 }
5569 
5570 static void
vala_gir_parser_parse_bitfield(ValaGirParser * self)5571 vala_gir_parser_parse_bitfield (ValaGirParser* self)
5572 {
5573 	g_return_if_fail (self != NULL);
5574 	vala_gir_parser_parse_enumeration (self, "bitfield", FALSE);
5575 }
5576 
5577 static void
vala_gir_parser_parse_enumeration_member(ValaGirParser * self)5578 vala_gir_parser_parse_enumeration_member (ValaGirParser* self)
5579 {
5580 	gchar* _tmp0_;
5581 	gchar* _tmp1_;
5582 	gchar* _tmp2_;
5583 	gchar* _tmp3_;
5584 	gchar* _tmp4_;
5585 	gchar* _tmp5_;
5586 	ValaEnumValue* ev = NULL;
5587 	ValaGirParserNode* _tmp6_;
5588 	const gchar* _tmp7_;
5589 	ValaGirParserMetadata* _tmp8_;
5590 	ValaExpression* _tmp9_;
5591 	ValaExpression* _tmp10_;
5592 	ValaGirParserNode* _tmp11_;
5593 	ValaSourceReference* _tmp12_;
5594 	ValaEnumValue* _tmp13_;
5595 	ValaEnumValue* _tmp14_;
5596 	ValaGirParserNode* _tmp15_;
5597 	ValaSymbol* _tmp16_;
5598 	ValaGirComment* _tmp17_;
5599 	ValaGirComment* _tmp18_;
5600 	g_return_if_fail (self != NULL);
5601 	vala_gir_parser_start_element (self, "member");
5602 	_tmp0_ = vala_gir_parser_element_get_name (self, NULL);
5603 	_tmp1_ = _tmp0_;
5604 	_tmp2_ = g_ascii_strup (_tmp1_, (gssize) -1);
5605 	_tmp3_ = _tmp2_;
5606 	_tmp4_ = string_replace (_tmp3_, "-", "_");
5607 	_tmp5_ = _tmp4_;
5608 	vala_gir_parser_push_node (self, _tmp5_, FALSE);
5609 	_g_free0 (_tmp5_);
5610 	_g_free0 (_tmp3_);
5611 	_g_free0 (_tmp1_);
5612 	_tmp6_ = self->priv->current;
5613 	_tmp7_ = _tmp6_->name;
5614 	_tmp8_ = self->priv->metadata;
5615 	_tmp9_ = vala_gir_parser_metadata_get_expression (_tmp8_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEFAULT);
5616 	_tmp10_ = _tmp9_;
5617 	_tmp11_ = self->priv->current;
5618 	_tmp12_ = _tmp11_->source_reference;
5619 	_tmp13_ = vala_enum_value_new (_tmp7_, _tmp10_, _tmp12_, NULL);
5620 	_tmp14_ = _tmp13_;
5621 	_vala_code_node_unref0 (_tmp10_);
5622 	ev = _tmp14_;
5623 	_tmp15_ = self->priv->current;
5624 	_tmp16_ = _vala_code_node_ref0 ((ValaSymbol*) ev);
5625 	_vala_code_node_unref0 (_tmp15_->symbol);
5626 	_tmp15_->symbol = _tmp16_;
5627 	vala_gir_parser_next (self);
5628 	_tmp17_ = vala_gir_parser_parse_symbol_doc (self);
5629 	_tmp18_ = _tmp17_;
5630 	vala_symbol_set_comment ((ValaSymbol*) ev, (ValaComment*) _tmp18_);
5631 	_vala_comment_unref0 (_tmp18_);
5632 	vala_gir_parser_pop_node (self);
5633 	vala_gir_parser_end_element (self, "member");
5634 	_vala_code_node_unref0 (ev);
5635 }
5636 
5637 static void
vala_gir_parser_parse_error_member(ValaGirParser * self)5638 vala_gir_parser_parse_error_member (ValaGirParser* self)
5639 {
5640 	gchar* _tmp0_;
5641 	gchar* _tmp1_;
5642 	gchar* _tmp2_;
5643 	gchar* _tmp3_;
5644 	gchar* _tmp4_;
5645 	gchar* _tmp5_;
5646 	ValaErrorCode* ec = NULL;
5647 	gchar* value = NULL;
5648 	ValaMarkupReader* _tmp6_;
5649 	gchar* _tmp7_;
5650 	const gchar* _tmp8_;
5651 	ValaGirParserNode* _tmp18_;
5652 	ValaErrorCode* _tmp19_;
5653 	ValaSymbol* _tmp20_;
5654 	ValaErrorCode* _tmp21_;
5655 	ValaGirComment* _tmp22_;
5656 	ValaGirComment* _tmp23_;
5657 	g_return_if_fail (self != NULL);
5658 	vala_gir_parser_start_element (self, "member");
5659 	_tmp0_ = vala_gir_parser_element_get_name (self, NULL);
5660 	_tmp1_ = _tmp0_;
5661 	_tmp2_ = g_ascii_strup (_tmp1_, (gssize) -1);
5662 	_tmp3_ = _tmp2_;
5663 	_tmp4_ = string_replace (_tmp3_, "-", "_");
5664 	_tmp5_ = _tmp4_;
5665 	vala_gir_parser_push_node (self, _tmp5_, FALSE);
5666 	_g_free0 (_tmp5_);
5667 	_g_free0 (_tmp3_);
5668 	_g_free0 (_tmp1_);
5669 	_tmp6_ = self->priv->reader;
5670 	_tmp7_ = vala_markup_reader_get_attribute (_tmp6_, "value");
5671 	value = _tmp7_;
5672 	_tmp8_ = value;
5673 	if (_tmp8_ != NULL) {
5674 		ValaGirParserNode* _tmp9_;
5675 		const gchar* _tmp10_;
5676 		const gchar* _tmp11_;
5677 		ValaIntegerLiteral* _tmp12_;
5678 		ValaIntegerLiteral* _tmp13_;
5679 		ValaErrorCode* _tmp14_;
5680 		_tmp9_ = self->priv->current;
5681 		_tmp10_ = _tmp9_->name;
5682 		_tmp11_ = value;
5683 		_tmp12_ = vala_integer_literal_new (_tmp11_, NULL);
5684 		_tmp13_ = _tmp12_;
5685 		_tmp14_ = vala_error_code_new_with_value (_tmp10_, (ValaExpression*) _tmp13_, NULL);
5686 		_vala_code_node_unref0 (ec);
5687 		ec = _tmp14_;
5688 		_vala_code_node_unref0 (_tmp13_);
5689 	} else {
5690 		ValaGirParserNode* _tmp15_;
5691 		const gchar* _tmp16_;
5692 		ValaErrorCode* _tmp17_;
5693 		_tmp15_ = self->priv->current;
5694 		_tmp16_ = _tmp15_->name;
5695 		_tmp17_ = vala_error_code_new (_tmp16_, NULL, NULL);
5696 		_vala_code_node_unref0 (ec);
5697 		ec = _tmp17_;
5698 	}
5699 	_tmp18_ = self->priv->current;
5700 	_tmp19_ = ec;
5701 	_tmp20_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp19_);
5702 	_vala_code_node_unref0 (_tmp18_->symbol);
5703 	_tmp18_->symbol = _tmp20_;
5704 	vala_gir_parser_next (self);
5705 	_tmp21_ = ec;
5706 	_tmp22_ = vala_gir_parser_parse_symbol_doc (self);
5707 	_tmp23_ = _tmp22_;
5708 	vala_symbol_set_comment ((ValaSymbol*) _tmp21_, (ValaComment*) _tmp23_);
5709 	_vala_comment_unref0 (_tmp23_);
5710 	vala_gir_parser_pop_node (self);
5711 	vala_gir_parser_end_element (self, "member");
5712 	_g_free0 (value);
5713 	_vala_code_node_unref0 (ec);
5714 }
5715 
5716 static ValaDataType*
vala_gir_parser_parse_return_value(ValaGirParser * self,gchar ** ctype,gint * array_length_idx,gboolean * no_array_length,gboolean * array_null_terminated,ValaComment ** comment)5717 vala_gir_parser_parse_return_value (ValaGirParser* self,
5718                                     gchar* * ctype,
5719                                     gint* array_length_idx,
5720                                     gboolean* no_array_length,
5721                                     gboolean* array_null_terminated,
5722                                     ValaComment* * comment)
5723 {
5724 	gchar* _vala_ctype = NULL;
5725 	gint _vala_array_length_idx = 0;
5726 	gboolean _vala_no_array_length = FALSE;
5727 	gboolean _vala_array_null_terminated = FALSE;
5728 	ValaComment* _vala_comment = NULL;
5729 	gchar* transfer = NULL;
5730 	ValaMarkupReader* _tmp0_;
5731 	gchar* _tmp1_;
5732 	gchar* nullable = NULL;
5733 	ValaMarkupReader* _tmp2_;
5734 	gchar* _tmp3_;
5735 	gchar* allow_none = NULL;
5736 	ValaMarkupReader* _tmp4_;
5737 	gchar* _tmp5_;
5738 	ValaComment* _tmp6_;
5739 	gboolean transfer_elements = FALSE;
5740 	const gchar* _tmp7_;
5741 	ValaDataType* type = NULL;
5742 	gchar* _tmp8_ = NULL;
5743 	gint _tmp9_ = 0;
5744 	gboolean _tmp10_ = FALSE;
5745 	gboolean _tmp11_ = FALSE;
5746 	ValaDataType* _tmp12_;
5747 	gboolean _tmp13_ = FALSE;
5748 	const gchar* _tmp14_;
5749 	gboolean _tmp17_ = FALSE;
5750 	const gchar* _tmp18_;
5751 	ValaDataType* _tmp21_;
5752 	ValaDataType* _tmp22_;
5753 	ValaDataType* result = NULL;
5754 	g_return_val_if_fail (self != NULL, NULL);
5755 	vala_gir_parser_start_element (self, "return-value");
5756 	_tmp0_ = self->priv->reader;
5757 	_tmp1_ = vala_markup_reader_get_attribute (_tmp0_, "transfer-ownership");
5758 	transfer = _tmp1_;
5759 	_tmp2_ = self->priv->reader;
5760 	_tmp3_ = vala_markup_reader_get_attribute (_tmp2_, "nullable");
5761 	nullable = _tmp3_;
5762 	_tmp4_ = self->priv->reader;
5763 	_tmp5_ = vala_markup_reader_get_attribute (_tmp4_, "allow-none");
5764 	allow_none = _tmp5_;
5765 	vala_gir_parser_next (self);
5766 	_tmp6_ = vala_gir_parser_parse_doc (self);
5767 	_vala_comment_unref0 (_vala_comment);
5768 	_vala_comment = _tmp6_;
5769 	_tmp7_ = transfer;
5770 	transfer_elements = g_strcmp0 (_tmp7_, "container") != 0;
5771 	_tmp12_ = vala_gir_parser_parse_type (self, &_tmp8_, &_tmp9_, transfer_elements, &_tmp10_, &_tmp11_);
5772 	_g_free0 (_vala_ctype);
5773 	_vala_ctype = _tmp8_;
5774 	_vala_array_length_idx = _tmp9_;
5775 	_vala_no_array_length = _tmp10_;
5776 	_vala_array_null_terminated = _tmp11_;
5777 	type = _tmp12_;
5778 	_tmp14_ = transfer;
5779 	if (g_strcmp0 (_tmp14_, "full") == 0) {
5780 		_tmp13_ = TRUE;
5781 	} else {
5782 		const gchar* _tmp15_;
5783 		_tmp15_ = transfer;
5784 		_tmp13_ = g_strcmp0 (_tmp15_, "container") == 0;
5785 	}
5786 	if (_tmp13_) {
5787 		ValaDataType* _tmp16_;
5788 		_tmp16_ = type;
5789 		vala_data_type_set_value_owned (_tmp16_, TRUE);
5790 	}
5791 	_tmp18_ = nullable;
5792 	if (g_strcmp0 (_tmp18_, "1") == 0) {
5793 		_tmp17_ = TRUE;
5794 	} else {
5795 		const gchar* _tmp19_;
5796 		_tmp19_ = allow_none;
5797 		_tmp17_ = g_strcmp0 (_tmp19_, "1") == 0;
5798 	}
5799 	if (_tmp17_) {
5800 		ValaDataType* _tmp20_;
5801 		_tmp20_ = type;
5802 		vala_data_type_set_nullable (_tmp20_, TRUE);
5803 	}
5804 	_tmp21_ = type;
5805 	_tmp22_ = vala_gir_parser_element_get_type (self, _tmp21_, TRUE, &_vala_no_array_length, &_vala_array_null_terminated, NULL);
5806 	_vala_code_node_unref0 (type);
5807 	type = _tmp22_;
5808 	vala_gir_parser_end_element (self, "return-value");
5809 	result = type;
5810 	_g_free0 (allow_none);
5811 	_g_free0 (nullable);
5812 	_g_free0 (transfer);
5813 	if (ctype) {
5814 		*ctype = _vala_ctype;
5815 	} else {
5816 		_g_free0 (_vala_ctype);
5817 	}
5818 	if (array_length_idx) {
5819 		*array_length_idx = _vala_array_length_idx;
5820 	}
5821 	if (no_array_length) {
5822 		*no_array_length = _vala_no_array_length;
5823 	}
5824 	if (array_null_terminated) {
5825 		*array_null_terminated = _vala_array_null_terminated;
5826 	}
5827 	if (comment) {
5828 		*comment = _vala_comment;
5829 	} else {
5830 		_vala_comment_unref0 (_vala_comment);
5831 	}
5832 	return result;
5833 }
5834 
5835 static gboolean
string_contains(const gchar * self,const gchar * needle)5836 string_contains (const gchar* self,
5837                  const gchar* needle)
5838 {
5839 	gchar* _tmp0_;
5840 	gboolean result = FALSE;
5841 	g_return_val_if_fail (self != NULL, FALSE);
5842 	g_return_val_if_fail (needle != NULL, FALSE);
5843 	_tmp0_ = strstr ((gchar*) self, (gchar*) needle);
5844 	result = _tmp0_ != NULL;
5845 	return result;
5846 }
5847 
5848 static ValaParameter*
vala_gir_parser_parse_parameter(ValaGirParser * self,gint * array_length_idx,gint * closure_idx,gint * destroy_idx,gchar ** scope,ValaComment ** comment,const gchar * default_name)5849 vala_gir_parser_parse_parameter (ValaGirParser* self,
5850                                  gint* array_length_idx,
5851                                  gint* closure_idx,
5852                                  gint* destroy_idx,
5853                                  gchar* * scope,
5854                                  ValaComment* * comment,
5855                                  const gchar* default_name)
5856 {
5857 	gint _vala_array_length_idx = 0;
5858 	gint _vala_closure_idx = 0;
5859 	gint _vala_destroy_idx = 0;
5860 	gchar* _vala_scope = NULL;
5861 	ValaComment* _vala_comment = NULL;
5862 	ValaSourceLocation begin = {0};
5863 	ValaSourceLocation _tmp0_;
5864 	ValaParameter* param = NULL;
5865 	gchar* element_type = NULL;
5866 	ValaMarkupReader* _tmp1_;
5867 	const gchar* _tmp2_;
5868 	const gchar* _tmp3_;
5869 	gchar* _tmp4_;
5870 	gboolean _tmp5_ = FALSE;
5871 	ValaMarkupTokenType _tmp6_;
5872 	const gchar* _tmp12_;
5873 	gchar* name = NULL;
5874 	ValaGirParserMetadata* _tmp13_;
5875 	gchar* _tmp14_;
5876 	const gchar* _tmp15_;
5877 	const gchar* _tmp18_;
5878 	gchar* direction = NULL;
5879 	ValaGirParserMetadata* _tmp25_;
5880 	gchar* transfer = NULL;
5881 	ValaMarkupReader* _tmp33_;
5882 	gchar* _tmp34_;
5883 	gchar* nullable = NULL;
5884 	ValaMarkupReader* _tmp35_;
5885 	gchar* _tmp36_;
5886 	gchar* allow_none = NULL;
5887 	ValaMarkupReader* _tmp37_;
5888 	gchar* _tmp38_;
5889 	gchar* _tmp39_;
5890 	gchar* closure = NULL;
5891 	ValaMarkupReader* _tmp40_;
5892 	gchar* _tmp41_;
5893 	gchar* destroy = NULL;
5894 	ValaMarkupReader* _tmp42_;
5895 	gchar* _tmp43_;
5896 	gboolean _tmp44_ = FALSE;
5897 	const gchar* _tmp45_;
5898 	gboolean _tmp47_ = FALSE;
5899 	const gchar* _tmp48_;
5900 	ValaGirParserMetadata* _tmp50_;
5901 	ValaGirParserMetadata* _tmp52_;
5902 	ValaComment* _tmp54_;
5903 	ValaMarkupReader* _tmp55_;
5904 	const gchar* _tmp56_;
5905 	const gchar* _tmp57_;
5906 	const gchar* _tmp118_;
5907 	ValaParameter* result = NULL;
5908 	g_return_val_if_fail (self != NULL, NULL);
5909 	_tmp0_ = self->priv->begin;
5910 	begin = _tmp0_;
5911 	_vala_array_length_idx = -1;
5912 	_vala_closure_idx = -1;
5913 	_vala_destroy_idx = -1;
5914 	_tmp1_ = self->priv->reader;
5915 	_tmp2_ = vala_markup_reader_get_name (_tmp1_);
5916 	_tmp3_ = _tmp2_;
5917 	_tmp4_ = g_strdup (_tmp3_);
5918 	element_type = _tmp4_;
5919 	_tmp6_ = self->priv->current_token;
5920 	if (_tmp6_ != VALA_MARKUP_TOKEN_TYPE_START_ELEMENT) {
5921 		_tmp5_ = TRUE;
5922 	} else {
5923 		gboolean _tmp7_ = FALSE;
5924 		const gchar* _tmp8_;
5925 		_tmp8_ = element_type;
5926 		if (g_strcmp0 (_tmp8_, "parameter") != 0) {
5927 			const gchar* _tmp9_;
5928 			_tmp9_ = element_type;
5929 			_tmp7_ = g_strcmp0 (_tmp9_, "instance-parameter") != 0;
5930 		} else {
5931 			_tmp7_ = FALSE;
5932 		}
5933 		_tmp5_ = _tmp7_;
5934 	}
5935 	if (_tmp5_) {
5936 		ValaSourceReference* _tmp10_;
5937 		ValaSourceReference* _tmp11_;
5938 		_tmp10_ = vala_gir_parser_get_current_src (self);
5939 		_tmp11_ = _tmp10_;
5940 		vala_report_error (_tmp11_, "expected start element of `parameter' or `instance-parameter'");
5941 		_vala_source_reference_unref0 (_tmp11_);
5942 	}
5943 	_tmp12_ = element_type;
5944 	vala_gir_parser_start_element (self, _tmp12_);
5945 	_tmp13_ = self->priv->metadata;
5946 	_tmp14_ = vala_gir_parser_metadata_get_string (_tmp13_, VALA_GIR_PARSER_ARGUMENT_TYPE_NAME);
5947 	name = _tmp14_;
5948 	_tmp15_ = name;
5949 	if (_tmp15_ == NULL) {
5950 		ValaMarkupReader* _tmp16_;
5951 		gchar* _tmp17_;
5952 		_tmp16_ = self->priv->reader;
5953 		_tmp17_ = vala_markup_reader_get_attribute (_tmp16_, "name");
5954 		_g_free0 (name);
5955 		name = _tmp17_;
5956 	}
5957 	_tmp18_ = name;
5958 	if (_tmp18_ == NULL) {
5959 		gchar* _tmp19_;
5960 		_tmp19_ = g_strdup (default_name);
5961 		_g_free0 (name);
5962 		name = _tmp19_;
5963 	} else {
5964 		const gchar* _tmp20_;
5965 		_tmp20_ = name;
5966 		if (string_contains (_tmp20_, "-")) {
5967 			ValaSourceReference* _tmp21_;
5968 			ValaSourceReference* _tmp22_;
5969 			const gchar* _tmp23_;
5970 			gchar* _tmp24_;
5971 			_tmp21_ = vala_gir_parser_get_current_src (self);
5972 			_tmp22_ = _tmp21_;
5973 			vala_report_warning (_tmp22_, "parameter name contains hyphen");
5974 			_vala_source_reference_unref0 (_tmp22_);
5975 			_tmp23_ = name;
5976 			_tmp24_ = string_replace (_tmp23_, "-", "_");
5977 			_g_free0 (name);
5978 			name = _tmp24_;
5979 		}
5980 	}
5981 	direction = NULL;
5982 	_tmp25_ = self->priv->metadata;
5983 	if (vala_gir_parser_metadata_has_argument (_tmp25_, VALA_GIR_PARSER_ARGUMENT_TYPE_OUT)) {
5984 		ValaGirParserMetadata* _tmp26_;
5985 		_tmp26_ = self->priv->metadata;
5986 		if (vala_gir_parser_metadata_get_bool (_tmp26_, VALA_GIR_PARSER_ARGUMENT_TYPE_OUT, FALSE)) {
5987 			gchar* _tmp27_;
5988 			_tmp27_ = g_strdup ("out");
5989 			_g_free0 (direction);
5990 			direction = _tmp27_;
5991 		}
5992 	} else {
5993 		ValaGirParserMetadata* _tmp28_;
5994 		_tmp28_ = self->priv->metadata;
5995 		if (vala_gir_parser_metadata_has_argument (_tmp28_, VALA_GIR_PARSER_ARGUMENT_TYPE_REF)) {
5996 			ValaGirParserMetadata* _tmp29_;
5997 			_tmp29_ = self->priv->metadata;
5998 			if (vala_gir_parser_metadata_get_bool (_tmp29_, VALA_GIR_PARSER_ARGUMENT_TYPE_REF, FALSE)) {
5999 				gchar* _tmp30_;
6000 				_tmp30_ = g_strdup ("inout");
6001 				_g_free0 (direction);
6002 				direction = _tmp30_;
6003 			}
6004 		} else {
6005 			ValaMarkupReader* _tmp31_;
6006 			gchar* _tmp32_;
6007 			_tmp31_ = self->priv->reader;
6008 			_tmp32_ = vala_markup_reader_get_attribute (_tmp31_, "direction");
6009 			_g_free0 (direction);
6010 			direction = _tmp32_;
6011 		}
6012 	}
6013 	_tmp33_ = self->priv->reader;
6014 	_tmp34_ = vala_markup_reader_get_attribute (_tmp33_, "transfer-ownership");
6015 	transfer = _tmp34_;
6016 	_tmp35_ = self->priv->reader;
6017 	_tmp36_ = vala_markup_reader_get_attribute (_tmp35_, "nullable");
6018 	nullable = _tmp36_;
6019 	_tmp37_ = self->priv->reader;
6020 	_tmp38_ = vala_markup_reader_get_attribute (_tmp37_, "allow-none");
6021 	allow_none = _tmp38_;
6022 	_tmp39_ = vala_gir_parser_element_get_string (self, "scope", VALA_GIR_PARSER_ARGUMENT_TYPE_SCOPE);
6023 	_g_free0 (_vala_scope);
6024 	_vala_scope = _tmp39_;
6025 	_tmp40_ = self->priv->reader;
6026 	_tmp41_ = vala_markup_reader_get_attribute (_tmp40_, "closure");
6027 	closure = _tmp41_;
6028 	_tmp42_ = self->priv->reader;
6029 	_tmp43_ = vala_markup_reader_get_attribute (_tmp42_, "destroy");
6030 	destroy = _tmp43_;
6031 	_tmp45_ = closure;
6032 	if (_tmp45_ != NULL) {
6033 		_tmp44_ = (&_vala_closure_idx) != NULL;
6034 	} else {
6035 		_tmp44_ = FALSE;
6036 	}
6037 	if (_tmp44_) {
6038 		const gchar* _tmp46_;
6039 		_tmp46_ = closure;
6040 		_vala_closure_idx = atoi (_tmp46_);
6041 	}
6042 	_tmp48_ = destroy;
6043 	if (_tmp48_ != NULL) {
6044 		_tmp47_ = (&_vala_destroy_idx) != NULL;
6045 	} else {
6046 		_tmp47_ = FALSE;
6047 	}
6048 	if (_tmp47_) {
6049 		const gchar* _tmp49_;
6050 		_tmp49_ = destroy;
6051 		_vala_destroy_idx = atoi (_tmp49_);
6052 	}
6053 	_tmp50_ = self->priv->metadata;
6054 	if (vala_gir_parser_metadata_has_argument (_tmp50_, VALA_GIR_PARSER_ARGUMENT_TYPE_CLOSURE)) {
6055 		ValaGirParserMetadata* _tmp51_;
6056 		_tmp51_ = self->priv->metadata;
6057 		_vala_closure_idx = vala_gir_parser_metadata_get_integer (_tmp51_, VALA_GIR_PARSER_ARGUMENT_TYPE_CLOSURE);
6058 	}
6059 	_tmp52_ = self->priv->metadata;
6060 	if (vala_gir_parser_metadata_has_argument (_tmp52_, VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROY)) {
6061 		ValaGirParserMetadata* _tmp53_;
6062 		_tmp53_ = self->priv->metadata;
6063 		_vala_destroy_idx = vala_gir_parser_metadata_get_integer (_tmp53_, VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROY);
6064 	}
6065 	vala_gir_parser_next (self);
6066 	_tmp54_ = vala_gir_parser_parse_doc (self);
6067 	_vala_comment_unref0 (_vala_comment);
6068 	_vala_comment = _tmp54_;
6069 	_tmp55_ = self->priv->reader;
6070 	_tmp56_ = vala_markup_reader_get_name (_tmp55_);
6071 	_tmp57_ = _tmp56_;
6072 	if (g_strcmp0 (_tmp57_, "varargs") == 0) {
6073 		ValaSourceLocation _tmp58_;
6074 		ValaSourceReference* _tmp59_;
6075 		ValaSourceReference* _tmp60_;
6076 		ValaParameter* _tmp61_;
6077 		vala_gir_parser_start_element (self, "varargs");
6078 		vala_gir_parser_next (self);
6079 		_tmp58_ = begin;
6080 		_tmp59_ = vala_gir_parser_get_src (self, &_tmp58_, NULL);
6081 		_tmp60_ = _tmp59_;
6082 		_tmp61_ = vala_parameter_new_with_ellipsis (_tmp60_);
6083 		_vala_code_node_unref0 (param);
6084 		param = _tmp61_;
6085 		_vala_source_reference_unref0 (_tmp60_);
6086 		vala_gir_parser_end_element (self, "varargs");
6087 	} else {
6088 		gchar* ctype = NULL;
6089 		gboolean no_array_length = FALSE;
6090 		gboolean array_null_terminated = FALSE;
6091 		ValaDataType* type = NULL;
6092 		const gchar* _tmp62_;
6093 		gchar* _tmp63_ = NULL;
6094 		gint _tmp64_ = 0;
6095 		gboolean _tmp65_ = FALSE;
6096 		gboolean _tmp66_ = FALSE;
6097 		ValaDataType* _tmp67_;
6098 		gboolean _tmp68_ = FALSE;
6099 		gboolean _tmp69_ = FALSE;
6100 		const gchar* _tmp70_;
6101 		gboolean _tmp74_ = FALSE;
6102 		const gchar* _tmp75_;
6103 		gboolean changed = FALSE;
6104 		gboolean _tmp80_ = FALSE;
6105 		const gchar* _tmp81_;
6106 		ValaDataType* _tmp83_;
6107 		gboolean _tmp84_ = FALSE;
6108 		ValaDataType* _tmp85_;
6109 		const gchar* _tmp86_;
6110 		ValaDataType* _tmp87_;
6111 		ValaSourceLocation _tmp88_;
6112 		ValaSourceReference* _tmp89_;
6113 		ValaSourceReference* _tmp90_;
6114 		ValaParameter* _tmp91_;
6115 		const gchar* _tmp92_;
6116 		const gchar* _tmp95_;
6117 		gboolean _tmp99_ = FALSE;
6118 		ValaDataType* _tmp100_;
6119 		ValaDataType* _tmp104_;
6120 		ValaParameter* _tmp110_;
6121 		ValaGirParserMetadata* _tmp111_;
6122 		ValaExpression* _tmp112_;
6123 		ValaExpression* _tmp113_;
6124 		ValaParameter* _tmp114_;
6125 		ValaExpression* _tmp115_;
6126 		ValaExpression* _tmp116_;
6127 		_tmp62_ = transfer;
6128 		_tmp67_ = vala_gir_parser_parse_type (self, &_tmp63_, &_tmp64_, g_strcmp0 (_tmp62_, "container") != 0, &_tmp65_, &_tmp66_);
6129 		_g_free0 (ctype);
6130 		ctype = _tmp63_;
6131 		_vala_array_length_idx = _tmp64_;
6132 		no_array_length = _tmp65_;
6133 		array_null_terminated = _tmp66_;
6134 		type = _tmp67_;
6135 		_tmp70_ = transfer;
6136 		if (g_strcmp0 (_tmp70_, "full") == 0) {
6137 			_tmp69_ = TRUE;
6138 		} else {
6139 			const gchar* _tmp71_;
6140 			_tmp71_ = transfer;
6141 			_tmp69_ = g_strcmp0 (_tmp71_, "container") == 0;
6142 		}
6143 		if (_tmp69_) {
6144 			_tmp68_ = TRUE;
6145 		} else {
6146 			const gchar* _tmp72_;
6147 			_tmp72_ = destroy;
6148 			_tmp68_ = _tmp72_ != NULL;
6149 		}
6150 		if (_tmp68_) {
6151 			ValaDataType* _tmp73_;
6152 			_tmp73_ = type;
6153 			vala_data_type_set_value_owned (_tmp73_, TRUE);
6154 		}
6155 		_tmp75_ = nullable;
6156 		if (g_strcmp0 (_tmp75_, "1") == 0) {
6157 			_tmp74_ = TRUE;
6158 		} else {
6159 			gboolean _tmp76_ = FALSE;
6160 			const gchar* _tmp77_;
6161 			_tmp77_ = allow_none;
6162 			if (g_strcmp0 (_tmp77_, "1") == 0) {
6163 				const gchar* _tmp78_;
6164 				_tmp78_ = direction;
6165 				_tmp76_ = g_strcmp0 (_tmp78_, "out") != 0;
6166 			} else {
6167 				_tmp76_ = FALSE;
6168 			}
6169 			_tmp74_ = _tmp76_;
6170 		}
6171 		if (_tmp74_) {
6172 			ValaDataType* _tmp79_;
6173 			_tmp79_ = type;
6174 			vala_data_type_set_nullable (_tmp79_, TRUE);
6175 		}
6176 		_tmp81_ = direction;
6177 		if (g_strcmp0 (_tmp81_, "out") == 0) {
6178 			_tmp80_ = TRUE;
6179 		} else {
6180 			const gchar* _tmp82_;
6181 			_tmp82_ = direction;
6182 			_tmp80_ = g_strcmp0 (_tmp82_, "inout") == 0;
6183 		}
6184 		_tmp83_ = type;
6185 		_tmp85_ = vala_gir_parser_element_get_type (self, _tmp83_, _tmp80_, &no_array_length, &array_null_terminated, &_tmp84_);
6186 		changed = _tmp84_;
6187 		_vala_code_node_unref0 (type);
6188 		type = _tmp85_;
6189 		if (!changed) {
6190 			_g_free0 (ctype);
6191 			ctype = NULL;
6192 		}
6193 		_tmp86_ = name;
6194 		_tmp87_ = type;
6195 		_tmp88_ = begin;
6196 		_tmp89_ = vala_gir_parser_get_src (self, &_tmp88_, NULL);
6197 		_tmp90_ = _tmp89_;
6198 		_tmp91_ = vala_parameter_new (_tmp86_, _tmp87_, _tmp90_);
6199 		_vala_code_node_unref0 (param);
6200 		param = _tmp91_;
6201 		_vala_source_reference_unref0 (_tmp90_);
6202 		_tmp92_ = ctype;
6203 		if (_tmp92_ != NULL) {
6204 			ValaParameter* _tmp93_;
6205 			const gchar* _tmp94_;
6206 			_tmp93_ = param;
6207 			_tmp94_ = ctype;
6208 			vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp93_, "CCode", "type", _tmp94_, NULL);
6209 		}
6210 		_tmp95_ = direction;
6211 		if (g_strcmp0 (_tmp95_, "out") == 0) {
6212 			ValaParameter* _tmp96_;
6213 			_tmp96_ = param;
6214 			vala_parameter_set_direction (_tmp96_, VALA_PARAMETER_DIRECTION_OUT);
6215 		} else {
6216 			const gchar* _tmp97_;
6217 			_tmp97_ = direction;
6218 			if (g_strcmp0 (_tmp97_, "inout") == 0) {
6219 				ValaParameter* _tmp98_;
6220 				_tmp98_ = param;
6221 				vala_parameter_set_direction (_tmp98_, VALA_PARAMETER_DIRECTION_REF);
6222 			}
6223 		}
6224 		_tmp100_ = type;
6225 		if (VALA_IS_DELEGATE_TYPE (_tmp100_)) {
6226 			ValaGirParserMetadata* _tmp101_;
6227 			_tmp101_ = self->priv->metadata;
6228 			_tmp99_ = vala_gir_parser_metadata_has_argument (_tmp101_, VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET);
6229 		} else {
6230 			_tmp99_ = FALSE;
6231 		}
6232 		if (_tmp99_) {
6233 			ValaParameter* _tmp102_;
6234 			ValaGirParserMetadata* _tmp103_;
6235 			_tmp102_ = param;
6236 			_tmp103_ = self->priv->metadata;
6237 			vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp102_, "CCode", "delegate_target", vala_gir_parser_metadata_get_bool (_tmp103_, VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET, FALSE), NULL);
6238 		}
6239 		_tmp104_ = type;
6240 		if (VALA_IS_ARRAY_TYPE (_tmp104_)) {
6241 			ValaGirParserMetadata* _tmp105_;
6242 			_tmp105_ = self->priv->metadata;
6243 			if (vala_gir_parser_metadata_has_argument (_tmp105_, VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_IDX)) {
6244 				ValaGirParserMetadata* _tmp106_;
6245 				_tmp106_ = self->priv->metadata;
6246 				_vala_array_length_idx = vala_gir_parser_metadata_get_integer (_tmp106_, VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_IDX);
6247 			} else {
6248 				gboolean _tmp107_ = FALSE;
6249 				if (no_array_length) {
6250 					_tmp107_ = TRUE;
6251 				} else {
6252 					_tmp107_ = array_null_terminated;
6253 				}
6254 				if (_tmp107_) {
6255 					ValaParameter* _tmp108_;
6256 					_tmp108_ = param;
6257 					vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp108_, "CCode", "array_length", !no_array_length, NULL);
6258 				}
6259 				if (array_null_terminated) {
6260 					ValaParameter* _tmp109_;
6261 					_tmp109_ = param;
6262 					vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp109_, "CCode", "array_null_terminated", array_null_terminated, NULL);
6263 				}
6264 			}
6265 		}
6266 		_tmp110_ = param;
6267 		_tmp111_ = self->priv->metadata;
6268 		_tmp112_ = vala_gir_parser_metadata_get_expression (_tmp111_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEFAULT);
6269 		_tmp113_ = _tmp112_;
6270 		vala_variable_set_initializer ((ValaVariable*) _tmp110_, _tmp113_);
6271 		_vala_code_node_unref0 (_tmp113_);
6272 		_tmp114_ = param;
6273 		_tmp115_ = vala_variable_get_initializer ((ValaVariable*) _tmp114_);
6274 		_tmp116_ = _tmp115_;
6275 		if (VALA_IS_TUPLE (_tmp116_)) {
6276 			ValaParameter* _tmp117_;
6277 			_tmp117_ = param;
6278 			vala_variable_set_initializer ((ValaVariable*) _tmp117_, NULL);
6279 		}
6280 		_vala_code_node_unref0 (type);
6281 		_g_free0 (ctype);
6282 	}
6283 	_tmp118_ = element_type;
6284 	vala_gir_parser_end_element (self, _tmp118_);
6285 	result = param;
6286 	_g_free0 (destroy);
6287 	_g_free0 (closure);
6288 	_g_free0 (allow_none);
6289 	_g_free0 (nullable);
6290 	_g_free0 (transfer);
6291 	_g_free0 (direction);
6292 	_g_free0 (name);
6293 	_g_free0 (element_type);
6294 	if (array_length_idx) {
6295 		*array_length_idx = _vala_array_length_idx;
6296 	}
6297 	if (closure_idx) {
6298 		*closure_idx = _vala_closure_idx;
6299 	}
6300 	if (destroy_idx) {
6301 		*destroy_idx = _vala_destroy_idx;
6302 	}
6303 	if (scope) {
6304 		*scope = _vala_scope;
6305 	} else {
6306 		_g_free0 (_vala_scope);
6307 	}
6308 	if (comment) {
6309 		*comment = _vala_comment;
6310 	} else {
6311 		_vala_comment_unref0 (_vala_comment);
6312 	}
6313 	return result;
6314 }
6315 
6316 static ValaDataType*
vala_gir_parser_parse_type(ValaGirParser * self,gchar ** ctype,gint * array_length_idx,gboolean transfer_elements,gboolean * no_array_length,gboolean * array_null_terminated)6317 vala_gir_parser_parse_type (ValaGirParser* self,
6318                             gchar* * ctype,
6319                             gint* array_length_idx,
6320                             gboolean transfer_elements,
6321                             gboolean* no_array_length,
6322                             gboolean* array_null_terminated)
6323 {
6324 	gchar* _vala_ctype = NULL;
6325 	gint _vala_array_length_idx = 0;
6326 	gboolean _vala_no_array_length = FALSE;
6327 	gboolean _vala_array_null_terminated = FALSE;
6328 	gboolean is_array = FALSE;
6329 	gchar* type_name = NULL;
6330 	ValaMarkupReader* _tmp0_;
6331 	gchar* _tmp1_;
6332 	gint fixed_length = 0;
6333 	ValaMarkupReader* _tmp2_;
6334 	const gchar* _tmp3_;
6335 	const gchar* _tmp4_;
6336 	ValaGirParserMetadata* _tmp49_;
6337 	const gchar* _tmp54_;
6338 	ValaDataType* type = NULL;
6339 	const gchar* _tmp57_;
6340 	const gchar* _tmp92_ = NULL;
6341 	ValaDataType* result = NULL;
6342 	g_return_val_if_fail (self != NULL, NULL);
6343 	is_array = FALSE;
6344 	_tmp0_ = self->priv->reader;
6345 	_tmp1_ = vala_markup_reader_get_attribute (_tmp0_, "name");
6346 	type_name = _tmp1_;
6347 	_g_free0 (_vala_ctype);
6348 	_vala_ctype = NULL;
6349 	fixed_length = -1;
6350 	_vala_array_length_idx = -1;
6351 	_vala_no_array_length = TRUE;
6352 	_vala_array_null_terminated = TRUE;
6353 	_tmp2_ = self->priv->reader;
6354 	_tmp3_ = vala_markup_reader_get_name (_tmp2_);
6355 	_tmp4_ = _tmp3_;
6356 	if (g_strcmp0 (_tmp4_, "array") == 0) {
6357 		ValaSourceReference* src = NULL;
6358 		ValaSourceReference* _tmp5_;
6359 		const gchar* _tmp6_;
6360 		is_array = TRUE;
6361 		vala_gir_parser_start_element (self, "array");
6362 		_tmp5_ = vala_gir_parser_get_current_src (self);
6363 		src = _tmp5_;
6364 		_tmp6_ = type_name;
6365 		if (_tmp6_ == NULL) {
6366 			ValaMarkupReader* _tmp7_;
6367 			gchar* _tmp8_;
6368 			gchar* _tmp9_;
6369 			gboolean _tmp10_;
6370 			ValaMarkupReader* _tmp14_;
6371 			gchar* _tmp15_;
6372 			gchar* _tmp16_;
6373 			gboolean _tmp17_;
6374 			ValaMarkupReader* _tmp21_;
6375 			gchar* _tmp22_;
6376 			gchar* _tmp23_;
6377 			gboolean _tmp24_;
6378 			ValaMarkupReader* _tmp25_;
6379 			gchar* _tmp26_;
6380 			gchar* _tmp27_;
6381 			gboolean _tmp28_;
6382 			ValaDataType* element_type = NULL;
6383 			ValaDataType* _tmp32_;
6384 			ValaDataType* _tmp33_;
6385 			ValaArrayType* array_type = NULL;
6386 			ValaDataType* _tmp34_;
6387 			ValaSourceReference* _tmp35_;
6388 			ValaArrayType* _tmp36_;
6389 			_tmp7_ = self->priv->reader;
6390 			_tmp8_ = vala_markup_reader_get_attribute (_tmp7_, "length");
6391 			_tmp9_ = _tmp8_;
6392 			_tmp10_ = _tmp9_ != NULL;
6393 			_g_free0 (_tmp9_);
6394 			if (_tmp10_) {
6395 				ValaMarkupReader* _tmp11_;
6396 				gchar* _tmp12_;
6397 				gchar* _tmp13_;
6398 				_tmp11_ = self->priv->reader;
6399 				_tmp12_ = vala_markup_reader_get_attribute (_tmp11_, "length");
6400 				_tmp13_ = _tmp12_;
6401 				_vala_array_length_idx = atoi (_tmp13_);
6402 				_g_free0 (_tmp13_);
6403 				_vala_no_array_length = FALSE;
6404 				_vala_array_null_terminated = FALSE;
6405 			}
6406 			_tmp14_ = self->priv->reader;
6407 			_tmp15_ = vala_markup_reader_get_attribute (_tmp14_, "fixed-size");
6408 			_tmp16_ = _tmp15_;
6409 			_tmp17_ = _tmp16_ != NULL;
6410 			_g_free0 (_tmp16_);
6411 			if (_tmp17_) {
6412 				ValaMarkupReader* _tmp18_;
6413 				gchar* _tmp19_;
6414 				gchar* _tmp20_;
6415 				_tmp18_ = self->priv->reader;
6416 				_tmp19_ = vala_markup_reader_get_attribute (_tmp18_, "fixed-size");
6417 				_tmp20_ = _tmp19_;
6418 				fixed_length = atoi (_tmp20_);
6419 				_g_free0 (_tmp20_);
6420 				_vala_array_null_terminated = FALSE;
6421 			}
6422 			_tmp21_ = self->priv->reader;
6423 			_tmp22_ = vala_markup_reader_get_attribute (_tmp21_, "c:type");
6424 			_tmp23_ = _tmp22_;
6425 			_tmp24_ = g_strcmp0 (_tmp23_, "GStrv") == 0;
6426 			_g_free0 (_tmp23_);
6427 			if (_tmp24_) {
6428 				_vala_no_array_length = TRUE;
6429 				_vala_array_null_terminated = TRUE;
6430 			}
6431 			_tmp25_ = self->priv->reader;
6432 			_tmp26_ = vala_markup_reader_get_attribute (_tmp25_, "zero-terminated");
6433 			_tmp27_ = _tmp26_;
6434 			_tmp28_ = _tmp27_ != NULL;
6435 			_g_free0 (_tmp27_);
6436 			if (_tmp28_) {
6437 				ValaMarkupReader* _tmp29_;
6438 				gchar* _tmp30_;
6439 				gchar* _tmp31_;
6440 				_tmp29_ = self->priv->reader;
6441 				_tmp30_ = vala_markup_reader_get_attribute (_tmp29_, "zero-terminated");
6442 				_tmp31_ = _tmp30_;
6443 				_vala_array_null_terminated = atoi (_tmp31_) != 0;
6444 				_g_free0 (_tmp31_);
6445 			}
6446 			vala_gir_parser_next (self);
6447 			_tmp32_ = vala_gir_parser_parse_type (self, NULL, NULL, TRUE, NULL, NULL);
6448 			element_type = _tmp32_;
6449 			_tmp33_ = element_type;
6450 			vala_data_type_set_value_owned (_tmp33_, transfer_elements);
6451 			vala_gir_parser_end_element (self, "array");
6452 			_tmp34_ = element_type;
6453 			_tmp35_ = src;
6454 			_tmp36_ = vala_array_type_new (_tmp34_, 1, _tmp35_);
6455 			array_type = _tmp36_;
6456 			if (fixed_length > 0) {
6457 				ValaArrayType* _tmp37_;
6458 				ValaArrayType* _tmp38_;
6459 				gchar* _tmp39_;
6460 				gchar* _tmp40_;
6461 				ValaIntegerLiteral* _tmp41_;
6462 				ValaIntegerLiteral* _tmp42_;
6463 				_tmp37_ = array_type;
6464 				vala_array_type_set_fixed_length (_tmp37_, TRUE);
6465 				_tmp38_ = array_type;
6466 				_tmp39_ = g_strdup_printf ("%i", fixed_length);
6467 				_tmp40_ = _tmp39_;
6468 				_tmp41_ = vala_integer_literal_new (_tmp40_, NULL);
6469 				_tmp42_ = _tmp41_;
6470 				vala_array_type_set_length (_tmp38_, (ValaExpression*) _tmp42_);
6471 				_vala_code_node_unref0 (_tmp42_);
6472 				_g_free0 (_tmp40_);
6473 			}
6474 			result = (ValaDataType*) array_type;
6475 			_vala_code_node_unref0 (element_type);
6476 			_vala_source_reference_unref0 (src);
6477 			_g_free0 (type_name);
6478 			if (ctype) {
6479 				*ctype = _vala_ctype;
6480 			} else {
6481 				_g_free0 (_vala_ctype);
6482 			}
6483 			if (array_length_idx) {
6484 				*array_length_idx = _vala_array_length_idx;
6485 			}
6486 			if (no_array_length) {
6487 				*no_array_length = _vala_no_array_length;
6488 			}
6489 			if (array_null_terminated) {
6490 				*array_null_terminated = _vala_array_null_terminated;
6491 			}
6492 			return result;
6493 		}
6494 		_vala_source_reference_unref0 (src);
6495 	} else {
6496 		ValaMarkupReader* _tmp43_;
6497 		const gchar* _tmp44_;
6498 		const gchar* _tmp45_;
6499 		_tmp43_ = self->priv->reader;
6500 		_tmp44_ = vala_markup_reader_get_name (_tmp43_);
6501 		_tmp45_ = _tmp44_;
6502 		if (g_strcmp0 (_tmp45_, "callback") == 0) {
6503 			ValaGirParserNode* _tmp46_;
6504 			ValaSymbol* _tmp47_;
6505 			ValaDelegateType* _tmp48_;
6506 			vala_gir_parser_parse_callback (self);
6507 			_tmp46_ = self->priv->old_current;
6508 			_tmp47_ = _tmp46_->symbol;
6509 			_tmp48_ = vala_delegate_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp47_, VALA_TYPE_DELEGATE, ValaDelegate));
6510 			result = (ValaDataType*) _tmp48_;
6511 			_g_free0 (type_name);
6512 			if (ctype) {
6513 				*ctype = _vala_ctype;
6514 			} else {
6515 				_g_free0 (_vala_ctype);
6516 			}
6517 			if (array_length_idx) {
6518 				*array_length_idx = _vala_array_length_idx;
6519 			}
6520 			if (no_array_length) {
6521 				*no_array_length = _vala_no_array_length;
6522 			}
6523 			if (array_null_terminated) {
6524 				*array_null_terminated = _vala_array_null_terminated;
6525 			}
6526 			return result;
6527 		} else {
6528 			vala_gir_parser_start_element (self, "type");
6529 		}
6530 	}
6531 	_tmp49_ = self->priv->metadata;
6532 	if (vala_gir_parser_metadata_has_argument (_tmp49_, VALA_GIR_PARSER_ARGUMENT_TYPE_CTYPE)) {
6533 		ValaGirParserMetadata* _tmp50_;
6534 		gchar* _tmp51_;
6535 		_tmp50_ = self->priv->metadata;
6536 		_tmp51_ = vala_gir_parser_metadata_get_string (_tmp50_, VALA_GIR_PARSER_ARGUMENT_TYPE_CTYPE);
6537 		_g_free0 (_vala_ctype);
6538 		_vala_ctype = _tmp51_;
6539 	} else {
6540 		ValaMarkupReader* _tmp52_;
6541 		gchar* _tmp53_;
6542 		_tmp52_ = self->priv->reader;
6543 		_tmp53_ = vala_markup_reader_get_attribute (_tmp52_, "c:type");
6544 		_g_free0 (_vala_ctype);
6545 		_vala_ctype = _tmp53_;
6546 	}
6547 	vala_gir_parser_next (self);
6548 	_tmp54_ = type_name;
6549 	if (_tmp54_ == NULL) {
6550 		const gchar* _tmp55_;
6551 		gchar* _tmp56_;
6552 		_tmp55_ = _vala_ctype;
6553 		_tmp56_ = g_strdup (_tmp55_);
6554 		_g_free0 (type_name);
6555 		type_name = _tmp56_;
6556 	}
6557 	_tmp57_ = type_name;
6558 	if (_tmp57_ != NULL) {
6559 		const gchar* _tmp58_;
6560 		const gchar* _tmp59_;
6561 		gboolean _tmp60_ = FALSE;
6562 		gboolean _tmp61_ = FALSE;
6563 		ValaDataType* _tmp62_;
6564 		_tmp58_ = type_name;
6565 		_tmp59_ = _vala_ctype;
6566 		_tmp62_ = vala_gir_parser_parse_type_from_gir_name (self, _tmp58_, &_tmp60_, &_tmp61_, _tmp59_);
6567 		_vala_no_array_length = _tmp60_;
6568 		_vala_array_null_terminated = _tmp61_;
6569 		_vala_code_node_unref0 (type);
6570 		type = _tmp62_;
6571 	} else {
6572 		ValaInvalidType* _tmp63_;
6573 		ValaSourceReference* _tmp64_;
6574 		ValaSourceReference* _tmp65_;
6575 		_vala_no_array_length = FALSE;
6576 		_vala_array_null_terminated = FALSE;
6577 		_tmp63_ = vala_invalid_type_new ();
6578 		_vala_code_node_unref0 (type);
6579 		type = (ValaDataType*) _tmp63_;
6580 		_tmp64_ = vala_gir_parser_get_current_src (self);
6581 		_tmp65_ = _tmp64_;
6582 		vala_report_error (_tmp65_, "empty type element");
6583 		_vala_source_reference_unref0 (_tmp65_);
6584 	}
6585 	while (TRUE) {
6586 		ValaMarkupTokenType _tmp66_;
6587 		const gchar* _tmp67_;
6588 		ValaDataType* element_type = NULL;
6589 		ValaDataType* _tmp68_;
6590 		ValaDataType* _tmp69_;
6591 		ValaDataType* _tmp70_;
6592 		ValaDataType* _tmp71_;
6593 		ValaDataType* _tmp72_;
6594 		_tmp66_ = self->priv->current_token;
6595 		if (!(_tmp66_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT)) {
6596 			break;
6597 		}
6598 		_tmp67_ = type_name;
6599 		if (g_strcmp0 (_tmp67_, "GLib.ByteArray") == 0) {
6600 			vala_gir_parser_skip_element (self);
6601 			continue;
6602 		}
6603 		_tmp68_ = vala_gir_parser_parse_type (self, NULL, NULL, TRUE, NULL, NULL);
6604 		element_type = _tmp68_;
6605 		_tmp69_ = element_type;
6606 		vala_data_type_set_value_owned (_tmp69_, transfer_elements);
6607 		_tmp70_ = type;
6608 		_tmp71_ = element_type;
6609 		vala_data_type_add_type_argument (_tmp70_, _tmp71_);
6610 		_tmp72_ = element_type;
6611 		if (VALA_IS_UNRESOLVED_TYPE (_tmp72_)) {
6612 			ValaGirParserNode* _tmp73_ = NULL;
6613 			ValaGirParserNode* _tmp74_;
6614 			ValaGirParserNode* parent = NULL;
6615 			ValaGirParserNode* _tmp76_;
6616 			ValaHashMap* _tmp89_;
6617 			ValaDataType* _tmp90_;
6618 			ValaGirParserNode* _tmp91_;
6619 			_tmp74_ = self->priv->current;
6620 			_tmp73_ = _tmp74_;
6621 			if (_tmp73_ == NULL) {
6622 				ValaGirParserNode* _tmp75_;
6623 				_tmp75_ = self->priv->root;
6624 				_tmp73_ = _tmp75_;
6625 			}
6626 			_tmp76_ = _vala_gir_parser_node_ref0 (_tmp73_);
6627 			parent = _tmp76_;
6628 			while (TRUE) {
6629 				gboolean _tmp77_ = FALSE;
6630 				gboolean _tmp78_ = FALSE;
6631 				ValaGirParserNode* _tmp79_;
6632 				ValaGirParserNode* _tmp80_;
6633 				ValaGirParserNode* _tmp86_;
6634 				ValaGirParserNode* _tmp87_;
6635 				ValaGirParserNode* _tmp88_;
6636 				_tmp79_ = parent;
6637 				_tmp80_ = self->priv->root;
6638 				if (_tmp79_ != _tmp80_) {
6639 					ValaGirParserNode* _tmp81_;
6640 					ValaGirParserNode* _tmp82_;
6641 					_tmp81_ = parent;
6642 					_tmp82_ = _tmp81_->parent;
6643 					_tmp78_ = _tmp82_ != NULL;
6644 				} else {
6645 					_tmp78_ = FALSE;
6646 				}
6647 				if (_tmp78_) {
6648 					ValaGirParserNode* _tmp83_;
6649 					ValaGirParserNode* _tmp84_;
6650 					ValaGirParserNode* _tmp85_;
6651 					_tmp83_ = parent;
6652 					_tmp84_ = _tmp83_->parent;
6653 					_tmp85_ = self->priv->root;
6654 					_tmp77_ = _tmp84_ != _tmp85_;
6655 				} else {
6656 					_tmp77_ = FALSE;
6657 				}
6658 				if (!_tmp77_) {
6659 					break;
6660 				}
6661 				_tmp86_ = parent;
6662 				_tmp87_ = _tmp86_->parent;
6663 				_tmp88_ = _vala_gir_parser_node_ref0 (_tmp87_);
6664 				_vala_gir_parser_node_unref0 (parent);
6665 				parent = _tmp88_;
6666 			}
6667 			_tmp89_ = self->priv->unresolved_type_arguments;
6668 			_tmp90_ = element_type;
6669 			_tmp91_ = parent;
6670 			vala_map_set ((ValaMap*) _tmp89_, G_TYPE_CHECK_INSTANCE_CAST (_tmp90_, VALA_TYPE_UNRESOLVED_TYPE, ValaUnresolvedType), _tmp91_);
6671 			_vala_gir_parser_node_unref0 (parent);
6672 		}
6673 		_vala_code_node_unref0 (element_type);
6674 	}
6675 	if (is_array) {
6676 		_tmp92_ = "array";
6677 	} else {
6678 		_tmp92_ = "type";
6679 	}
6680 	vala_gir_parser_end_element (self, _tmp92_);
6681 	result = type;
6682 	_g_free0 (type_name);
6683 	if (ctype) {
6684 		*ctype = _vala_ctype;
6685 	} else {
6686 		_g_free0 (_vala_ctype);
6687 	}
6688 	if (array_length_idx) {
6689 		*array_length_idx = _vala_array_length_idx;
6690 	}
6691 	if (no_array_length) {
6692 		*no_array_length = _vala_no_array_length;
6693 	}
6694 	if (array_null_terminated) {
6695 		*array_null_terminated = _vala_array_null_terminated;
6696 	}
6697 	return result;
6698 }
6699 
6700 static ValaDataType*
vala_gir_parser_parse_type_from_gir_name(ValaGirParser * self,const gchar * type_name,gboolean * no_array_length,gboolean * array_null_terminated,const gchar * ctype)6701 vala_gir_parser_parse_type_from_gir_name (ValaGirParser* self,
6702                                           const gchar* type_name,
6703                                           gboolean* no_array_length,
6704                                           gboolean* array_null_terminated,
6705                                           const gchar* ctype)
6706 {
6707 	gboolean _vala_no_array_length = FALSE;
6708 	gboolean _vala_array_null_terminated = FALSE;
6709 	ValaDataType* type = NULL;
6710 	ValaDataType* result = NULL;
6711 	g_return_val_if_fail (self != NULL, NULL);
6712 	g_return_val_if_fail (type_name != NULL, NULL);
6713 	_vala_no_array_length = FALSE;
6714 	_vala_array_null_terminated = FALSE;
6715 	type = NULL;
6716 	if (g_strcmp0 (type_name, "none") == 0) {
6717 		ValaSourceReference* _tmp0_;
6718 		ValaSourceReference* _tmp1_;
6719 		ValaVoidType* _tmp2_;
6720 		_tmp0_ = vala_gir_parser_get_current_src (self);
6721 		_tmp1_ = _tmp0_;
6722 		_tmp2_ = vala_void_type_new (_tmp1_);
6723 		_vala_code_node_unref0 (type);
6724 		type = (ValaDataType*) _tmp2_;
6725 		_vala_source_reference_unref0 (_tmp1_);
6726 	} else {
6727 		if (g_strcmp0 (type_name, "gpointer") == 0) {
6728 			ValaSourceReference* _tmp3_;
6729 			ValaSourceReference* _tmp4_;
6730 			ValaVoidType* _tmp5_;
6731 			ValaVoidType* _tmp6_;
6732 			ValaSourceReference* _tmp7_;
6733 			ValaSourceReference* _tmp8_;
6734 			ValaPointerType* _tmp9_;
6735 			_tmp3_ = vala_gir_parser_get_current_src (self);
6736 			_tmp4_ = _tmp3_;
6737 			_tmp5_ = vala_void_type_new (_tmp4_);
6738 			_tmp6_ = _tmp5_;
6739 			_tmp7_ = vala_gir_parser_get_current_src (self);
6740 			_tmp8_ = _tmp7_;
6741 			_tmp9_ = vala_pointer_type_new ((ValaDataType*) _tmp6_, _tmp8_);
6742 			_vala_code_node_unref0 (type);
6743 			type = (ValaDataType*) _tmp9_;
6744 			_vala_source_reference_unref0 (_tmp8_);
6745 			_vala_code_node_unref0 (_tmp6_);
6746 			_vala_source_reference_unref0 (_tmp4_);
6747 		} else {
6748 			if (g_strcmp0 (type_name, "GObject.Strv") == 0) {
6749 				ValaUnresolvedType* element_type = NULL;
6750 				ValaUnresolvedSymbol* _tmp10_;
6751 				ValaUnresolvedSymbol* _tmp11_;
6752 				ValaUnresolvedType* _tmp12_;
6753 				ValaUnresolvedType* _tmp13_;
6754 				ValaUnresolvedType* _tmp14_;
6755 				ValaUnresolvedType* _tmp15_;
6756 				ValaSourceReference* _tmp16_;
6757 				ValaSourceReference* _tmp17_;
6758 				ValaArrayType* _tmp18_;
6759 				_tmp10_ = vala_unresolved_symbol_new (NULL, "string", NULL);
6760 				_tmp11_ = _tmp10_;
6761 				_tmp12_ = vala_unresolved_type_new_from_symbol (_tmp11_, NULL);
6762 				_tmp13_ = _tmp12_;
6763 				_vala_code_node_unref0 (_tmp11_);
6764 				element_type = _tmp13_;
6765 				_tmp14_ = element_type;
6766 				vala_data_type_set_value_owned ((ValaDataType*) _tmp14_, TRUE);
6767 				_tmp15_ = element_type;
6768 				_tmp16_ = vala_gir_parser_get_current_src (self);
6769 				_tmp17_ = _tmp16_;
6770 				_tmp18_ = vala_array_type_new ((ValaDataType*) _tmp15_, 1, _tmp17_);
6771 				_vala_code_node_unref0 (type);
6772 				type = (ValaDataType*) _tmp18_;
6773 				_vala_source_reference_unref0 (_tmp17_);
6774 				_vala_no_array_length = TRUE;
6775 				_vala_array_null_terminated = TRUE;
6776 				_vala_code_node_unref0 (element_type);
6777 			} else {
6778 				gboolean known_type = FALSE;
6779 				ValaDataType* _tmp31_;
6780 				known_type = TRUE;
6781 				if (g_strcmp0 (type_name, "utf8") == 0) {
6782 					type_name = "string";
6783 				} else {
6784 					if (g_strcmp0 (type_name, "gboolean") == 0) {
6785 						ValaCodeContext* _tmp19_;
6786 						ValaNamespace* _tmp20_;
6787 						ValaNamespace* _tmp21_;
6788 						ValaScope* _tmp22_;
6789 						ValaScope* _tmp23_;
6790 						ValaSymbol* _tmp24_;
6791 						ValaStruct* _tmp25_;
6792 						ValaBooleanType* _tmp26_;
6793 						_tmp19_ = self->priv->context;
6794 						_tmp20_ = vala_code_context_get_root (_tmp19_);
6795 						_tmp21_ = _tmp20_;
6796 						_tmp22_ = vala_symbol_get_scope ((ValaSymbol*) _tmp21_);
6797 						_tmp23_ = _tmp22_;
6798 						_tmp24_ = vala_scope_lookup (_tmp23_, "bool");
6799 						_tmp25_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp24_, VALA_TYPE_STRUCT, ValaStruct);
6800 						_tmp26_ = vala_boolean_type_new (_tmp25_);
6801 						_vala_code_node_unref0 (type);
6802 						type = (ValaDataType*) _tmp26_;
6803 						_vala_code_node_unref0 (_tmp25_);
6804 					} else {
6805 						if (g_strcmp0 (type_name, "gchar") == 0) {
6806 							type_name = "char";
6807 						} else {
6808 							if (g_strcmp0 (type_name, "gshort") == 0) {
6809 								type_name = "short";
6810 							} else {
6811 								if (g_strcmp0 (type_name, "gushort") == 0) {
6812 									type_name = "ushort";
6813 								} else {
6814 									if (g_strcmp0 (type_name, "gint") == 0) {
6815 										type_name = "int";
6816 									} else {
6817 										if (g_strcmp0 (type_name, "guint") == 0) {
6818 											type_name = "uint";
6819 										} else {
6820 											if (g_strcmp0 (type_name, "glong") == 0) {
6821 												gboolean _tmp27_ = FALSE;
6822 												if (ctype != NULL) {
6823 													_tmp27_ = g_str_has_prefix (ctype, "gssize");
6824 												} else {
6825 													_tmp27_ = FALSE;
6826 												}
6827 												if (_tmp27_) {
6828 													type_name = "ssize_t";
6829 												} else {
6830 													gboolean _tmp28_ = FALSE;
6831 													if (ctype != NULL) {
6832 														_tmp28_ = g_str_has_prefix (ctype, "gintptr");
6833 													} else {
6834 														_tmp28_ = FALSE;
6835 													}
6836 													if (_tmp28_) {
6837 														type_name = "intptr";
6838 													} else {
6839 														type_name = "long";
6840 													}
6841 												}
6842 											} else {
6843 												if (g_strcmp0 (type_name, "gulong") == 0) {
6844 													gboolean _tmp29_ = FALSE;
6845 													if (ctype != NULL) {
6846 														_tmp29_ = g_str_has_prefix (ctype, "gsize");
6847 													} else {
6848 														_tmp29_ = FALSE;
6849 													}
6850 													if (_tmp29_) {
6851 														type_name = "size_t";
6852 													} else {
6853 														gboolean _tmp30_ = FALSE;
6854 														if (ctype != NULL) {
6855 															_tmp30_ = g_str_has_prefix (ctype, "guintptr");
6856 														} else {
6857 															_tmp30_ = FALSE;
6858 														}
6859 														if (_tmp30_) {
6860 															type_name = "uintptr";
6861 														} else {
6862 															type_name = "ulong";
6863 														}
6864 													}
6865 												} else {
6866 													if (g_strcmp0 (type_name, "gint8") == 0) {
6867 														type_name = "int8";
6868 													} else {
6869 														if (g_strcmp0 (type_name, "guint8") == 0) {
6870 															type_name = "uint8";
6871 														} else {
6872 															if (g_strcmp0 (type_name, "gint16") == 0) {
6873 																type_name = "int16";
6874 															} else {
6875 																if (g_strcmp0 (type_name, "guint16") == 0) {
6876 																	type_name = "uint16";
6877 																} else {
6878 																	if (g_strcmp0 (type_name, "gint32") == 0) {
6879 																		type_name = "int32";
6880 																	} else {
6881 																		if (g_strcmp0 (type_name, "guint32") == 0) {
6882 																			type_name = "uint32";
6883 																		} else {
6884 																			if (g_strcmp0 (type_name, "gint64") == 0) {
6885 																				type_name = "int64";
6886 																			} else {
6887 																				if (g_strcmp0 (type_name, "guint64") == 0) {
6888 																					type_name = "uint64";
6889 																				} else {
6890 																					if (g_strcmp0 (type_name, "gfloat") == 0) {
6891 																						type_name = "float";
6892 																					} else {
6893 																						if (g_strcmp0 (type_name, "gdouble") == 0) {
6894 																							type_name = "double";
6895 																						} else {
6896 																							if (g_strcmp0 (type_name, "filename") == 0) {
6897 																								type_name = "string";
6898 																							} else {
6899 																								if (g_strcmp0 (type_name, "GLib.offset") == 0) {
6900 																									type_name = "int64";
6901 																								} else {
6902 																									if (g_strcmp0 (type_name, "gsize") == 0) {
6903 																										type_name = "size_t";
6904 																									} else {
6905 																										if (g_strcmp0 (type_name, "gssize") == 0) {
6906 																											type_name = "ssize_t";
6907 																										} else {
6908 																											if (g_strcmp0 (type_name, "guintptr") == 0) {
6909 																												type_name = "uintptr";
6910 																											} else {
6911 																												if (g_strcmp0 (type_name, "gintptr") == 0) {
6912 																													type_name = "intptr";
6913 																												} else {
6914 																													if (g_strcmp0 (type_name, "GType") == 0) {
6915 																														type_name = "GLib.Type";
6916 																													} else {
6917 																														if (g_strcmp0 (type_name, "GObject.Class") == 0) {
6918 																															type_name = "GLib.ObjectClass";
6919 																														} else {
6920 																															if (g_strcmp0 (type_name, "gunichar") == 0) {
6921 																																type_name = "unichar";
6922 																															} else {
6923 																																if (g_strcmp0 (type_name, "Atk.ImplementorIface") == 0) {
6924 																																	type_name = "Atk.Implementor";
6925 																																} else {
6926 																																	known_type = FALSE;
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 				_tmp31_ = type;
6957 				if (_tmp31_ == NULL) {
6958 					ValaUnresolvedSymbol* sym = NULL;
6959 					ValaSourceReference* _tmp32_;
6960 					ValaSourceReference* _tmp33_;
6961 					ValaUnresolvedSymbol* _tmp34_;
6962 					ValaUnresolvedSymbol* _tmp35_;
6963 					ValaUnresolvedSymbol* _tmp36_;
6964 					ValaSourceReference* _tmp37_;
6965 					ValaSourceReference* _tmp38_;
6966 					ValaUnresolvedType* _tmp39_;
6967 					_tmp32_ = vala_gir_parser_get_current_src (self);
6968 					_tmp33_ = _tmp32_;
6969 					_tmp34_ = vala_gir_parser_parse_symbol_from_string (self, type_name, _tmp33_);
6970 					_tmp35_ = _tmp34_;
6971 					_vala_source_reference_unref0 (_tmp33_);
6972 					sym = _tmp35_;
6973 					_tmp36_ = sym;
6974 					_tmp37_ = vala_gir_parser_get_current_src (self);
6975 					_tmp38_ = _tmp37_;
6976 					_tmp39_ = vala_unresolved_type_new_from_symbol (_tmp36_, _tmp38_);
6977 					_vala_code_node_unref0 (type);
6978 					type = (ValaDataType*) _tmp39_;
6979 					_vala_source_reference_unref0 (_tmp38_);
6980 					if (!known_type) {
6981 						ValaArrayList* _tmp40_;
6982 						ValaUnresolvedSymbol* _tmp41_;
6983 						_tmp40_ = self->priv->unresolved_gir_symbols;
6984 						_tmp41_ = sym;
6985 						vala_collection_add ((ValaCollection*) _tmp40_, _tmp41_);
6986 					}
6987 					_vala_code_node_unref0 (sym);
6988 				}
6989 			}
6990 		}
6991 	}
6992 	result = type;
6993 	if (no_array_length) {
6994 		*no_array_length = _vala_no_array_length;
6995 	}
6996 	if (array_null_terminated) {
6997 		*array_null_terminated = _vala_array_null_terminated;
6998 	}
6999 	return result;
7000 }
7001 
7002 static void
vala_gir_parser_parse_record(ValaGirParser * self)7003 vala_gir_parser_parse_record (ValaGirParser* self)
7004 {
7005 	gchar* _tmp0_;
7006 	gchar* _tmp1_;
7007 	ValaStruct* st = NULL;
7008 	gboolean require_copy_free = FALSE;
7009 	ValaGirParserNode* _tmp2_;
7010 	ValaStruct* _tmp14_;
7011 	ValaStruct* _tmp15_;
7012 	ValaStruct* _tmp16_;
7013 	gchar* gtype_struct_for = NULL;
7014 	ValaMarkupReader* _tmp17_;
7015 	gchar* _tmp18_;
7016 	const gchar* _tmp19_;
7017 	gboolean first_field = FALSE;
7018 	ValaStruct* _tmp28_;
7019 	ValaGirComment* _tmp29_;
7020 	ValaGirComment* _tmp30_;
7021 	g_return_if_fail (self != NULL);
7022 	vala_gir_parser_start_element (self, "record");
7023 	_tmp0_ = vala_gir_parser_element_get_name (self, NULL);
7024 	_tmp1_ = _tmp0_;
7025 	vala_gir_parser_push_node (self, _tmp1_, TRUE);
7026 	_g_free0 (_tmp1_);
7027 	require_copy_free = FALSE;
7028 	_tmp2_ = self->priv->current;
7029 	if (_tmp2_->new_symbol) {
7030 		gchar* _tmp3_;
7031 		gchar* _tmp4_;
7032 		ValaGirParserNode* _tmp5_;
7033 		ValaSourceReference* _tmp6_;
7034 		ValaStruct* _tmp7_;
7035 		ValaGirParserNode* _tmp8_;
7036 		ValaStruct* _tmp9_;
7037 		ValaSymbol* _tmp10_;
7038 		_tmp3_ = vala_gir_parser_element_get_name (self, NULL);
7039 		_tmp4_ = _tmp3_;
7040 		_tmp5_ = self->priv->current;
7041 		_tmp6_ = _tmp5_->source_reference;
7042 		_tmp7_ = vala_struct_new (_tmp4_, _tmp6_, NULL);
7043 		_vala_code_node_unref0 (st);
7044 		st = _tmp7_;
7045 		_g_free0 (_tmp4_);
7046 		_tmp8_ = self->priv->current;
7047 		_tmp9_ = st;
7048 		_tmp10_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp9_);
7049 		_vala_code_node_unref0 (_tmp8_->symbol);
7050 		_tmp8_->symbol = _tmp10_;
7051 	} else {
7052 		ValaGirParserNode* _tmp11_;
7053 		ValaSymbol* _tmp12_;
7054 		ValaStruct* _tmp13_;
7055 		_tmp11_ = self->priv->current;
7056 		_tmp12_ = _tmp11_->symbol;
7057 		_tmp13_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp12_, VALA_TYPE_STRUCT, ValaStruct));
7058 		_vala_code_node_unref0 (st);
7059 		st = _tmp13_;
7060 	}
7061 	_tmp14_ = st;
7062 	vala_gir_parser_set_type_id_ccode (self, (ValaSymbol*) _tmp14_);
7063 	_tmp15_ = st;
7064 	require_copy_free = vala_code_node_has_attribute_argument ((ValaCodeNode*) _tmp15_, "CCode", "type_id");
7065 	_tmp16_ = st;
7066 	vala_symbol_set_access ((ValaSymbol*) _tmp16_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
7067 	_tmp17_ = self->priv->reader;
7068 	_tmp18_ = vala_markup_reader_get_attribute (_tmp17_, "glib:is-gtype-struct-for");
7069 	gtype_struct_for = _tmp18_;
7070 	_tmp19_ = gtype_struct_for;
7071 	if (_tmp19_ != NULL) {
7072 		ValaGirParserNode* _tmp20_;
7073 		const gchar* _tmp21_;
7074 		ValaGirParserNode* _tmp22_;
7075 		ValaSourceReference* _tmp23_;
7076 		ValaUnresolvedSymbol* _tmp24_;
7077 		ValaArrayList* _tmp25_;
7078 		ValaGirParserNode* _tmp26_;
7079 		ValaUnresolvedSymbol* _tmp27_;
7080 		_tmp20_ = self->priv->current;
7081 		_tmp21_ = gtype_struct_for;
7082 		_tmp22_ = self->priv->current;
7083 		_tmp23_ = _tmp22_->source_reference;
7084 		_tmp24_ = vala_gir_parser_parse_symbol_from_string (self, _tmp21_, _tmp23_);
7085 		_vala_code_node_unref0 (_tmp20_->gtype_struct_for);
7086 		_tmp20_->gtype_struct_for = _tmp24_;
7087 		_tmp25_ = self->priv->unresolved_gir_symbols;
7088 		_tmp26_ = self->priv->current;
7089 		_tmp27_ = _tmp26_->gtype_struct_for;
7090 		vala_collection_add ((ValaCollection*) _tmp25_, _tmp27_);
7091 	}
7092 	first_field = TRUE;
7093 	vala_gir_parser_next (self);
7094 	_tmp28_ = st;
7095 	_tmp29_ = vala_gir_parser_parse_symbol_doc (self);
7096 	_tmp30_ = _tmp29_;
7097 	vala_symbol_set_comment ((ValaSymbol*) _tmp28_, (ValaComment*) _tmp30_);
7098 	_vala_comment_unref0 (_tmp30_);
7099 	while (TRUE) {
7100 		ValaMarkupTokenType _tmp31_;
7101 		ValaMarkupReader* _tmp36_;
7102 		const gchar* _tmp37_;
7103 		const gchar* _tmp38_;
7104 		_tmp31_ = self->priv->current_token;
7105 		if (!(_tmp31_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT)) {
7106 			break;
7107 		}
7108 		if (!vala_gir_parser_push_metadata (self)) {
7109 			gboolean _tmp32_ = FALSE;
7110 			if (first_field) {
7111 				ValaMarkupReader* _tmp33_;
7112 				const gchar* _tmp34_;
7113 				const gchar* _tmp35_;
7114 				_tmp33_ = self->priv->reader;
7115 				_tmp34_ = vala_markup_reader_get_name (_tmp33_);
7116 				_tmp35_ = _tmp34_;
7117 				_tmp32_ = g_strcmp0 (_tmp35_, "field") == 0;
7118 			} else {
7119 				_tmp32_ = FALSE;
7120 			}
7121 			if (_tmp32_) {
7122 				first_field = FALSE;
7123 			}
7124 			vala_gir_parser_skip_element (self);
7125 			continue;
7126 		}
7127 		_tmp36_ = self->priv->reader;
7128 		_tmp37_ = vala_markup_reader_get_name (_tmp36_);
7129 		_tmp38_ = _tmp37_;
7130 		if (g_strcmp0 (_tmp38_, "field") == 0) {
7131 			gboolean _tmp39_ = FALSE;
7132 			ValaMarkupReader* _tmp40_;
7133 			gchar* _tmp41_;
7134 			gchar* _tmp42_;
7135 			gboolean _tmp43_;
7136 			_tmp40_ = self->priv->reader;
7137 			_tmp41_ = vala_markup_reader_get_attribute (_tmp40_, "name");
7138 			_tmp42_ = _tmp41_;
7139 			_tmp43_ = g_strcmp0 (_tmp42_, "priv") != 0;
7140 			_g_free0 (_tmp42_);
7141 			if (_tmp43_) {
7142 				gboolean _tmp44_ = FALSE;
7143 				if (first_field) {
7144 					const gchar* _tmp45_;
7145 					_tmp45_ = gtype_struct_for;
7146 					_tmp44_ = _tmp45_ != NULL;
7147 				} else {
7148 					_tmp44_ = FALSE;
7149 				}
7150 				_tmp39_ = !_tmp44_;
7151 			} else {
7152 				_tmp39_ = FALSE;
7153 			}
7154 			if (_tmp39_) {
7155 				vala_gir_parser_parse_field (self);
7156 			} else {
7157 				vala_gir_parser_skip_element (self);
7158 			}
7159 			first_field = FALSE;
7160 		} else {
7161 			ValaMarkupReader* _tmp46_;
7162 			const gchar* _tmp47_;
7163 			const gchar* _tmp48_;
7164 			_tmp46_ = self->priv->reader;
7165 			_tmp47_ = vala_markup_reader_get_name (_tmp46_);
7166 			_tmp48_ = _tmp47_;
7167 			if (g_strcmp0 (_tmp48_, "constructor") == 0) {
7168 				vala_gir_parser_parse_constructor (self);
7169 			} else {
7170 				ValaMarkupReader* _tmp49_;
7171 				const gchar* _tmp50_;
7172 				const gchar* _tmp51_;
7173 				_tmp49_ = self->priv->reader;
7174 				_tmp50_ = vala_markup_reader_get_name (_tmp49_);
7175 				_tmp51_ = _tmp50_;
7176 				if (g_strcmp0 (_tmp51_, "method") == 0) {
7177 					vala_gir_parser_parse_method (self, "method");
7178 				} else {
7179 					ValaMarkupReader* _tmp52_;
7180 					const gchar* _tmp53_;
7181 					const gchar* _tmp54_;
7182 					_tmp52_ = self->priv->reader;
7183 					_tmp53_ = vala_markup_reader_get_name (_tmp52_);
7184 					_tmp54_ = _tmp53_;
7185 					if (g_strcmp0 (_tmp54_, "function") == 0) {
7186 						vala_gir_parser_skip_element (self);
7187 					} else {
7188 						ValaMarkupReader* _tmp55_;
7189 						const gchar* _tmp56_;
7190 						const gchar* _tmp57_;
7191 						_tmp55_ = self->priv->reader;
7192 						_tmp56_ = vala_markup_reader_get_name (_tmp55_);
7193 						_tmp57_ = _tmp56_;
7194 						if (g_strcmp0 (_tmp57_, "function-macro") == 0) {
7195 							vala_gir_parser_skip_element (self);
7196 						} else {
7197 							ValaMarkupReader* _tmp58_;
7198 							const gchar* _tmp59_;
7199 							const gchar* _tmp60_;
7200 							_tmp58_ = self->priv->reader;
7201 							_tmp59_ = vala_markup_reader_get_name (_tmp58_);
7202 							_tmp60_ = _tmp59_;
7203 							if (g_strcmp0 (_tmp60_, "union") == 0) {
7204 								vala_gir_parser_parse_union (self);
7205 							} else {
7206 								ValaSourceReference* _tmp61_;
7207 								ValaSourceReference* _tmp62_;
7208 								ValaMarkupReader* _tmp63_;
7209 								const gchar* _tmp64_;
7210 								const gchar* _tmp65_;
7211 								gchar* _tmp66_;
7212 								gchar* _tmp67_;
7213 								_tmp61_ = vala_gir_parser_get_current_src (self);
7214 								_tmp62_ = _tmp61_;
7215 								_tmp63_ = self->priv->reader;
7216 								_tmp64_ = vala_markup_reader_get_name (_tmp63_);
7217 								_tmp65_ = _tmp64_;
7218 								_tmp66_ = g_strdup_printf ("unknown child element `%s' in `record'", _tmp65_);
7219 								_tmp67_ = _tmp66_;
7220 								vala_report_error (_tmp62_, _tmp67_);
7221 								_g_free0 (_tmp67_);
7222 								_vala_source_reference_unref0 (_tmp62_);
7223 								vala_gir_parser_skip_element (self);
7224 							}
7225 						}
7226 					}
7227 				}
7228 			}
7229 		}
7230 		vala_gir_parser_pop_metadata (self);
7231 	}
7232 	if (require_copy_free) {
7233 		ValaStruct* _tmp68_;
7234 		ValaStruct* _tmp69_;
7235 		_tmp68_ = st;
7236 		vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp68_, "CCode", "copy_function", "g_boxed_copy", NULL);
7237 		_tmp69_ = st;
7238 		vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp69_, "CCode", "free_function", "g_boxed_free", NULL);
7239 	}
7240 	vala_gir_parser_pop_node (self);
7241 	vala_gir_parser_end_element (self, "record");
7242 	_g_free0 (gtype_struct_for);
7243 	_vala_code_node_unref0 (st);
7244 }
7245 
7246 static void
vala_gir_parser_parse_class(ValaGirParser * self)7247 vala_gir_parser_parse_class (ValaGirParser* self)
7248 {
7249 	gchar* _tmp0_;
7250 	gchar* _tmp1_;
7251 	ValaClass* cl = NULL;
7252 	gchar* parent = NULL;
7253 	ValaMarkupReader* _tmp2_;
7254 	gchar* _tmp3_;
7255 	ValaGirParserNode* _tmp4_;
7256 	ValaClass* _tmp44_;
7257 	ValaClass* _tmp45_;
7258 	ValaClass* _tmp46_;
7259 	ValaGirComment* _tmp47_;
7260 	ValaGirComment* _tmp48_;
7261 	gboolean first_field = FALSE;
7262 	g_return_if_fail (self != NULL);
7263 	vala_gir_parser_start_element (self, "class");
7264 	_tmp0_ = vala_gir_parser_element_get_name (self, NULL);
7265 	_tmp1_ = _tmp0_;
7266 	vala_gir_parser_push_node (self, _tmp1_, TRUE);
7267 	_g_free0 (_tmp1_);
7268 	_tmp2_ = self->priv->reader;
7269 	_tmp3_ = vala_markup_reader_get_attribute (_tmp2_, "parent");
7270 	parent = _tmp3_;
7271 	_tmp4_ = self->priv->current;
7272 	if (_tmp4_->new_symbol) {
7273 		ValaGirParserNode* _tmp5_;
7274 		const gchar* _tmp6_;
7275 		ValaGirParserNode* _tmp7_;
7276 		ValaSourceReference* _tmp8_;
7277 		ValaClass* _tmp9_;
7278 		ValaClass* _tmp10_;
7279 		ValaGirParserMetadata* _tmp11_;
7280 		ValaMarkupReader* _tmp12_;
7281 		gchar* _tmp13_;
7282 		gchar* _tmp14_;
7283 		ValaClass* _tmp15_;
7284 		ValaGirParserMetadata* _tmp16_;
7285 		ValaGirParserMetadata* _tmp17_;
7286 		const gchar* _tmp22_;
7287 		gchar* type_struct = NULL;
7288 		ValaMarkupReader* _tmp27_;
7289 		gchar* _tmp28_;
7290 		const gchar* _tmp29_;
7291 		ValaGirParserNode* _tmp38_;
7292 		ValaClass* _tmp39_;
7293 		ValaSymbol* _tmp40_;
7294 		_tmp5_ = self->priv->current;
7295 		_tmp6_ = _tmp5_->name;
7296 		_tmp7_ = self->priv->current;
7297 		_tmp8_ = _tmp7_->source_reference;
7298 		_tmp9_ = vala_class_new (_tmp6_, _tmp8_, NULL);
7299 		_vala_code_node_unref0 (cl);
7300 		cl = _tmp9_;
7301 		_tmp10_ = cl;
7302 		_tmp11_ = self->priv->metadata;
7303 		_tmp12_ = self->priv->reader;
7304 		_tmp13_ = vala_markup_reader_get_attribute (_tmp12_, "abstract");
7305 		_tmp14_ = _tmp13_;
7306 		vala_class_set_is_abstract (_tmp10_, vala_gir_parser_metadata_get_bool (_tmp11_, VALA_GIR_PARSER_ARGUMENT_TYPE_ABSTRACT, g_strcmp0 (_tmp14_, "1") == 0));
7307 		_g_free0 (_tmp14_);
7308 		_tmp15_ = cl;
7309 		_tmp16_ = self->priv->metadata;
7310 		vala_class_set_is_sealed (_tmp15_, vala_gir_parser_metadata_get_bool (_tmp16_, VALA_GIR_PARSER_ARGUMENT_TYPE_SEALED, FALSE));
7311 		_tmp17_ = self->priv->metadata;
7312 		if (vala_gir_parser_metadata_has_argument (_tmp17_, VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_GET_FUNCTION)) {
7313 			ValaClass* _tmp18_;
7314 			ValaGirParserMetadata* _tmp19_;
7315 			gchar* _tmp20_;
7316 			gchar* _tmp21_;
7317 			_tmp18_ = cl;
7318 			_tmp19_ = self->priv->metadata;
7319 			_tmp20_ = vala_gir_parser_metadata_get_string (_tmp19_, VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_GET_FUNCTION);
7320 			_tmp21_ = _tmp20_;
7321 			vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp18_, "CCode", "type_get_function", _tmp21_, NULL);
7322 			_g_free0 (_tmp21_);
7323 		}
7324 		_tmp22_ = parent;
7325 		if (_tmp22_ != NULL) {
7326 			ValaClass* _tmp23_;
7327 			const gchar* _tmp24_;
7328 			ValaDataType* _tmp25_;
7329 			ValaDataType* _tmp26_;
7330 			_tmp23_ = cl;
7331 			_tmp24_ = parent;
7332 			_tmp25_ = vala_gir_parser_parse_type_from_gir_name (self, _tmp24_, NULL, NULL, NULL);
7333 			_tmp26_ = _tmp25_;
7334 			vala_class_add_base_type (_tmp23_, _tmp26_);
7335 			_vala_code_node_unref0 (_tmp26_);
7336 		}
7337 		_tmp27_ = self->priv->reader;
7338 		_tmp28_ = vala_markup_reader_get_attribute (_tmp27_, "glib:type-struct");
7339 		type_struct = _tmp28_;
7340 		_tmp29_ = type_struct;
7341 		if (_tmp29_ != NULL) {
7342 			ValaGirParserNode* _tmp30_;
7343 			const gchar* _tmp31_;
7344 			ValaGirParserNode* _tmp32_;
7345 			ValaSourceReference* _tmp33_;
7346 			ValaUnresolvedSymbol* _tmp34_;
7347 			ValaArrayList* _tmp35_;
7348 			ValaGirParserNode* _tmp36_;
7349 			ValaUnresolvedSymbol* _tmp37_;
7350 			_tmp30_ = self->priv->current;
7351 			_tmp31_ = type_struct;
7352 			_tmp32_ = self->priv->current;
7353 			_tmp33_ = _tmp32_->source_reference;
7354 			_tmp34_ = vala_gir_parser_parse_symbol_from_string (self, _tmp31_, _tmp33_);
7355 			_vala_code_node_unref0 (_tmp30_->type_struct);
7356 			_tmp30_->type_struct = _tmp34_;
7357 			_tmp35_ = self->priv->unresolved_gir_symbols;
7358 			_tmp36_ = self->priv->current;
7359 			_tmp37_ = _tmp36_->type_struct;
7360 			vala_collection_add ((ValaCollection*) _tmp35_, _tmp37_);
7361 		}
7362 		_tmp38_ = self->priv->current;
7363 		_tmp39_ = cl;
7364 		_tmp40_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp39_);
7365 		_vala_code_node_unref0 (_tmp38_->symbol);
7366 		_tmp38_->symbol = _tmp40_;
7367 		_g_free0 (type_struct);
7368 	} else {
7369 		ValaGirParserNode* _tmp41_;
7370 		ValaSymbol* _tmp42_;
7371 		ValaClass* _tmp43_;
7372 		_tmp41_ = self->priv->current;
7373 		_tmp42_ = _tmp41_->symbol;
7374 		_tmp43_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp42_, VALA_TYPE_CLASS, ValaClass));
7375 		_vala_code_node_unref0 (cl);
7376 		cl = _tmp43_;
7377 	}
7378 	_tmp44_ = cl;
7379 	vala_gir_parser_set_type_id_ccode (self, (ValaSymbol*) _tmp44_);
7380 	_tmp45_ = cl;
7381 	vala_symbol_set_access ((ValaSymbol*) _tmp45_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
7382 	vala_gir_parser_next (self);
7383 	_tmp46_ = cl;
7384 	_tmp47_ = vala_gir_parser_parse_symbol_doc (self);
7385 	_tmp48_ = _tmp47_;
7386 	vala_symbol_set_comment ((ValaSymbol*) _tmp46_, (ValaComment*) _tmp48_);
7387 	_vala_comment_unref0 (_tmp48_);
7388 	first_field = TRUE;
7389 	while (TRUE) {
7390 		ValaMarkupTokenType _tmp49_;
7391 		ValaMarkupReader* _tmp54_;
7392 		const gchar* _tmp55_;
7393 		const gchar* _tmp56_;
7394 		_tmp49_ = self->priv->current_token;
7395 		if (!(_tmp49_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT)) {
7396 			break;
7397 		}
7398 		if (!vala_gir_parser_push_metadata (self)) {
7399 			gboolean _tmp50_ = FALSE;
7400 			if (first_field) {
7401 				ValaMarkupReader* _tmp51_;
7402 				const gchar* _tmp52_;
7403 				const gchar* _tmp53_;
7404 				_tmp51_ = self->priv->reader;
7405 				_tmp52_ = vala_markup_reader_get_name (_tmp51_);
7406 				_tmp53_ = _tmp52_;
7407 				_tmp50_ = g_strcmp0 (_tmp53_, "field") == 0;
7408 			} else {
7409 				_tmp50_ = FALSE;
7410 			}
7411 			if (_tmp50_) {
7412 				first_field = FALSE;
7413 			}
7414 			vala_gir_parser_skip_element (self);
7415 			continue;
7416 		}
7417 		_tmp54_ = self->priv->reader;
7418 		_tmp55_ = vala_markup_reader_get_name (_tmp54_);
7419 		_tmp56_ = _tmp55_;
7420 		if (g_strcmp0 (_tmp56_, "implements") == 0) {
7421 			ValaClass* _tmp57_;
7422 			ValaMarkupReader* _tmp58_;
7423 			gchar* _tmp59_;
7424 			gchar* _tmp60_;
7425 			ValaDataType* _tmp61_;
7426 			ValaDataType* _tmp62_;
7427 			vala_gir_parser_start_element (self, "implements");
7428 			_tmp57_ = cl;
7429 			_tmp58_ = self->priv->reader;
7430 			_tmp59_ = vala_markup_reader_get_attribute (_tmp58_, "name");
7431 			_tmp60_ = _tmp59_;
7432 			_tmp61_ = vala_gir_parser_parse_type_from_gir_name (self, _tmp60_, NULL, NULL, NULL);
7433 			_tmp62_ = _tmp61_;
7434 			vala_class_add_base_type (_tmp57_, _tmp62_);
7435 			_vala_code_node_unref0 (_tmp62_);
7436 			_g_free0 (_tmp60_);
7437 			vala_gir_parser_next (self);
7438 			vala_gir_parser_end_element (self, "implements");
7439 		} else {
7440 			ValaMarkupReader* _tmp63_;
7441 			const gchar* _tmp64_;
7442 			const gchar* _tmp65_;
7443 			_tmp63_ = self->priv->reader;
7444 			_tmp64_ = vala_markup_reader_get_name (_tmp63_);
7445 			_tmp65_ = _tmp64_;
7446 			if (g_strcmp0 (_tmp65_, "constant") == 0) {
7447 				vala_gir_parser_parse_constant (self);
7448 			} else {
7449 				ValaMarkupReader* _tmp66_;
7450 				const gchar* _tmp67_;
7451 				const gchar* _tmp68_;
7452 				_tmp66_ = self->priv->reader;
7453 				_tmp67_ = vala_markup_reader_get_name (_tmp66_);
7454 				_tmp68_ = _tmp67_;
7455 				if (g_strcmp0 (_tmp68_, "field") == 0) {
7456 					gboolean _tmp69_ = FALSE;
7457 					if (first_field) {
7458 						const gchar* _tmp70_;
7459 						_tmp70_ = parent;
7460 						_tmp69_ = _tmp70_ != NULL;
7461 					} else {
7462 						_tmp69_ = FALSE;
7463 					}
7464 					if (_tmp69_) {
7465 						vala_gir_parser_skip_element (self);
7466 					} else {
7467 						ValaMarkupReader* _tmp71_;
7468 						gchar* _tmp72_;
7469 						gchar* _tmp73_;
7470 						gboolean _tmp74_;
7471 						_tmp71_ = self->priv->reader;
7472 						_tmp72_ = vala_markup_reader_get_attribute (_tmp71_, "name");
7473 						_tmp73_ = _tmp72_;
7474 						_tmp74_ = g_strcmp0 (_tmp73_, "priv") != 0;
7475 						_g_free0 (_tmp73_);
7476 						if (_tmp74_) {
7477 							vala_gir_parser_parse_field (self);
7478 						} else {
7479 							vala_gir_parser_skip_element (self);
7480 						}
7481 					}
7482 					first_field = FALSE;
7483 				} else {
7484 					ValaMarkupReader* _tmp75_;
7485 					const gchar* _tmp76_;
7486 					const gchar* _tmp77_;
7487 					_tmp75_ = self->priv->reader;
7488 					_tmp76_ = vala_markup_reader_get_name (_tmp75_);
7489 					_tmp77_ = _tmp76_;
7490 					if (g_strcmp0 (_tmp77_, "property") == 0) {
7491 						ValaProperty* _tmp78_;
7492 						ValaProperty* _tmp79_;
7493 						_tmp78_ = vala_gir_parser_parse_property (self);
7494 						_tmp79_ = _tmp78_;
7495 						_vala_code_node_unref0 (_tmp79_);
7496 					} else {
7497 						ValaMarkupReader* _tmp80_;
7498 						const gchar* _tmp81_;
7499 						const gchar* _tmp82_;
7500 						_tmp80_ = self->priv->reader;
7501 						_tmp81_ = vala_markup_reader_get_name (_tmp80_);
7502 						_tmp82_ = _tmp81_;
7503 						if (g_strcmp0 (_tmp82_, "constructor") == 0) {
7504 							vala_gir_parser_parse_constructor (self);
7505 						} else {
7506 							ValaMarkupReader* _tmp83_;
7507 							const gchar* _tmp84_;
7508 							const gchar* _tmp85_;
7509 							_tmp83_ = self->priv->reader;
7510 							_tmp84_ = vala_markup_reader_get_name (_tmp83_);
7511 							_tmp85_ = _tmp84_;
7512 							if (g_strcmp0 (_tmp85_, "function") == 0) {
7513 								vala_gir_parser_parse_method (self, "function");
7514 							} else {
7515 								ValaMarkupReader* _tmp86_;
7516 								const gchar* _tmp87_;
7517 								const gchar* _tmp88_;
7518 								_tmp86_ = self->priv->reader;
7519 								_tmp87_ = vala_markup_reader_get_name (_tmp86_);
7520 								_tmp88_ = _tmp87_;
7521 								if (g_strcmp0 (_tmp88_, "function-macro") == 0) {
7522 									vala_gir_parser_skip_element (self);
7523 								} else {
7524 									ValaMarkupReader* _tmp89_;
7525 									const gchar* _tmp90_;
7526 									const gchar* _tmp91_;
7527 									_tmp89_ = self->priv->reader;
7528 									_tmp90_ = vala_markup_reader_get_name (_tmp89_);
7529 									_tmp91_ = _tmp90_;
7530 									if (g_strcmp0 (_tmp91_, "method") == 0) {
7531 										vala_gir_parser_parse_method (self, "method");
7532 									} else {
7533 										ValaMarkupReader* _tmp92_;
7534 										const gchar* _tmp93_;
7535 										const gchar* _tmp94_;
7536 										_tmp92_ = self->priv->reader;
7537 										_tmp93_ = vala_markup_reader_get_name (_tmp92_);
7538 										_tmp94_ = _tmp93_;
7539 										if (g_strcmp0 (_tmp94_, "virtual-method") == 0) {
7540 											vala_gir_parser_parse_method (self, "virtual-method");
7541 										} else {
7542 											ValaMarkupReader* _tmp95_;
7543 											const gchar* _tmp96_;
7544 											const gchar* _tmp97_;
7545 											_tmp95_ = self->priv->reader;
7546 											_tmp96_ = vala_markup_reader_get_name (_tmp95_);
7547 											_tmp97_ = _tmp96_;
7548 											if (g_strcmp0 (_tmp97_, "union") == 0) {
7549 												vala_gir_parser_parse_union (self);
7550 											} else {
7551 												ValaMarkupReader* _tmp98_;
7552 												const gchar* _tmp99_;
7553 												const gchar* _tmp100_;
7554 												_tmp98_ = self->priv->reader;
7555 												_tmp99_ = vala_markup_reader_get_name (_tmp98_);
7556 												_tmp100_ = _tmp99_;
7557 												if (g_strcmp0 (_tmp100_, "glib:signal") == 0) {
7558 													vala_gir_parser_parse_signal (self);
7559 												} else {
7560 													ValaSourceReference* _tmp101_;
7561 													ValaSourceReference* _tmp102_;
7562 													ValaMarkupReader* _tmp103_;
7563 													const gchar* _tmp104_;
7564 													const gchar* _tmp105_;
7565 													gchar* _tmp106_;
7566 													gchar* _tmp107_;
7567 													_tmp101_ = vala_gir_parser_get_current_src (self);
7568 													_tmp102_ = _tmp101_;
7569 													_tmp103_ = self->priv->reader;
7570 													_tmp104_ = vala_markup_reader_get_name (_tmp103_);
7571 													_tmp105_ = _tmp104_;
7572 													_tmp106_ = g_strdup_printf ("unknown child element `%s' in `class'", _tmp105_);
7573 													_tmp107_ = _tmp106_;
7574 													vala_report_error (_tmp102_, _tmp107_);
7575 													_g_free0 (_tmp107_);
7576 													_vala_source_reference_unref0 (_tmp102_);
7577 													vala_gir_parser_skip_element (self);
7578 												}
7579 											}
7580 										}
7581 									}
7582 								}
7583 							}
7584 						}
7585 					}
7586 				}
7587 			}
7588 		}
7589 		vala_gir_parser_pop_metadata (self);
7590 	}
7591 	vala_gir_parser_pop_node (self);
7592 	vala_gir_parser_end_element (self, "class");
7593 	_g_free0 (parent);
7594 	_vala_code_node_unref0 (cl);
7595 }
7596 
7597 static void
vala_gir_parser_parse_interface(ValaGirParser * self)7598 vala_gir_parser_parse_interface (ValaGirParser* self)
7599 {
7600 	gchar* _tmp0_;
7601 	gchar* _tmp1_;
7602 	ValaInterface* iface = NULL;
7603 	ValaGirParserNode* _tmp2_;
7604 	ValaInterface* _tmp19_;
7605 	ValaInterface* _tmp20_;
7606 	ValaInterface* _tmp21_;
7607 	ValaGirComment* _tmp22_;
7608 	ValaGirComment* _tmp23_;
7609 	g_return_if_fail (self != NULL);
7610 	vala_gir_parser_start_element (self, "interface");
7611 	_tmp0_ = vala_gir_parser_element_get_name (self, NULL);
7612 	_tmp1_ = _tmp0_;
7613 	vala_gir_parser_push_node (self, _tmp1_, TRUE);
7614 	_g_free0 (_tmp1_);
7615 	_tmp2_ = self->priv->current;
7616 	if (_tmp2_->new_symbol) {
7617 		ValaGirParserNode* _tmp3_;
7618 		const gchar* _tmp4_;
7619 		ValaGirParserNode* _tmp5_;
7620 		ValaSourceReference* _tmp6_;
7621 		ValaInterface* _tmp7_;
7622 		ValaGirParserMetadata* _tmp8_;
7623 		ValaGirParserNode* _tmp13_;
7624 		ValaInterface* _tmp14_;
7625 		ValaSymbol* _tmp15_;
7626 		_tmp3_ = self->priv->current;
7627 		_tmp4_ = _tmp3_->name;
7628 		_tmp5_ = self->priv->current;
7629 		_tmp6_ = _tmp5_->source_reference;
7630 		_tmp7_ = vala_interface_new (_tmp4_, _tmp6_, NULL);
7631 		_vala_code_node_unref0 (iface);
7632 		iface = _tmp7_;
7633 		_tmp8_ = self->priv->metadata;
7634 		if (vala_gir_parser_metadata_has_argument (_tmp8_, VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_GET_FUNCTION)) {
7635 			ValaInterface* _tmp9_;
7636 			ValaGirParserMetadata* _tmp10_;
7637 			gchar* _tmp11_;
7638 			gchar* _tmp12_;
7639 			_tmp9_ = iface;
7640 			_tmp10_ = self->priv->metadata;
7641 			_tmp11_ = vala_gir_parser_metadata_get_string (_tmp10_, VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_GET_FUNCTION);
7642 			_tmp12_ = _tmp11_;
7643 			vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp9_, "CCode", "type_get_function", _tmp12_, NULL);
7644 			_g_free0 (_tmp12_);
7645 		}
7646 		_tmp13_ = self->priv->current;
7647 		_tmp14_ = iface;
7648 		_tmp15_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp14_);
7649 		_vala_code_node_unref0 (_tmp13_->symbol);
7650 		_tmp13_->symbol = _tmp15_;
7651 	} else {
7652 		ValaGirParserNode* _tmp16_;
7653 		ValaSymbol* _tmp17_;
7654 		ValaInterface* _tmp18_;
7655 		_tmp16_ = self->priv->current;
7656 		_tmp17_ = _tmp16_->symbol;
7657 		_tmp18_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp17_, VALA_TYPE_INTERFACE, ValaInterface));
7658 		_vala_code_node_unref0 (iface);
7659 		iface = _tmp18_;
7660 	}
7661 	_tmp19_ = iface;
7662 	vala_gir_parser_set_type_id_ccode (self, (ValaSymbol*) _tmp19_);
7663 	_tmp20_ = iface;
7664 	vala_symbol_set_access ((ValaSymbol*) _tmp20_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
7665 	vala_gir_parser_next (self);
7666 	_tmp21_ = iface;
7667 	_tmp22_ = vala_gir_parser_parse_symbol_doc (self);
7668 	_tmp23_ = _tmp22_;
7669 	vala_symbol_set_comment ((ValaSymbol*) _tmp21_, (ValaComment*) _tmp23_);
7670 	_vala_comment_unref0 (_tmp23_);
7671 	while (TRUE) {
7672 		ValaMarkupTokenType _tmp24_;
7673 		ValaMarkupReader* _tmp25_;
7674 		const gchar* _tmp26_;
7675 		const gchar* _tmp27_;
7676 		_tmp24_ = self->priv->current_token;
7677 		if (!(_tmp24_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT)) {
7678 			break;
7679 		}
7680 		if (!vala_gir_parser_push_metadata (self)) {
7681 			vala_gir_parser_skip_element (self);
7682 			continue;
7683 		}
7684 		_tmp25_ = self->priv->reader;
7685 		_tmp26_ = vala_markup_reader_get_name (_tmp25_);
7686 		_tmp27_ = _tmp26_;
7687 		if (g_strcmp0 (_tmp27_, "prerequisite") == 0) {
7688 			ValaInterface* _tmp28_;
7689 			ValaMarkupReader* _tmp29_;
7690 			gchar* _tmp30_;
7691 			gchar* _tmp31_;
7692 			ValaDataType* _tmp32_;
7693 			ValaDataType* _tmp33_;
7694 			vala_gir_parser_start_element (self, "prerequisite");
7695 			_tmp28_ = iface;
7696 			_tmp29_ = self->priv->reader;
7697 			_tmp30_ = vala_markup_reader_get_attribute (_tmp29_, "name");
7698 			_tmp31_ = _tmp30_;
7699 			_tmp32_ = vala_gir_parser_parse_type_from_gir_name (self, _tmp31_, NULL, NULL, NULL);
7700 			_tmp33_ = _tmp32_;
7701 			vala_interface_add_prerequisite (_tmp28_, _tmp33_);
7702 			_vala_code_node_unref0 (_tmp33_);
7703 			_g_free0 (_tmp31_);
7704 			vala_gir_parser_next (self);
7705 			vala_gir_parser_end_element (self, "prerequisite");
7706 		} else {
7707 			ValaMarkupReader* _tmp34_;
7708 			const gchar* _tmp35_;
7709 			const gchar* _tmp36_;
7710 			_tmp34_ = self->priv->reader;
7711 			_tmp35_ = vala_markup_reader_get_name (_tmp34_);
7712 			_tmp36_ = _tmp35_;
7713 			if (g_strcmp0 (_tmp36_, "field") == 0) {
7714 				vala_gir_parser_parse_field (self);
7715 			} else {
7716 				ValaMarkupReader* _tmp37_;
7717 				const gchar* _tmp38_;
7718 				const gchar* _tmp39_;
7719 				_tmp37_ = self->priv->reader;
7720 				_tmp38_ = vala_markup_reader_get_name (_tmp37_);
7721 				_tmp39_ = _tmp38_;
7722 				if (g_strcmp0 (_tmp39_, "property") == 0) {
7723 					ValaProperty* _tmp40_;
7724 					ValaProperty* _tmp41_;
7725 					_tmp40_ = vala_gir_parser_parse_property (self);
7726 					_tmp41_ = _tmp40_;
7727 					_vala_code_node_unref0 (_tmp41_);
7728 				} else {
7729 					ValaMarkupReader* _tmp42_;
7730 					const gchar* _tmp43_;
7731 					const gchar* _tmp44_;
7732 					_tmp42_ = self->priv->reader;
7733 					_tmp43_ = vala_markup_reader_get_name (_tmp42_);
7734 					_tmp44_ = _tmp43_;
7735 					if (g_strcmp0 (_tmp44_, "virtual-method") == 0) {
7736 						vala_gir_parser_parse_method (self, "virtual-method");
7737 					} else {
7738 						ValaMarkupReader* _tmp45_;
7739 						const gchar* _tmp46_;
7740 						const gchar* _tmp47_;
7741 						_tmp45_ = self->priv->reader;
7742 						_tmp46_ = vala_markup_reader_get_name (_tmp45_);
7743 						_tmp47_ = _tmp46_;
7744 						if (g_strcmp0 (_tmp47_, "function") == 0) {
7745 							vala_gir_parser_parse_method (self, "function");
7746 						} else {
7747 							ValaMarkupReader* _tmp48_;
7748 							const gchar* _tmp49_;
7749 							const gchar* _tmp50_;
7750 							_tmp48_ = self->priv->reader;
7751 							_tmp49_ = vala_markup_reader_get_name (_tmp48_);
7752 							_tmp50_ = _tmp49_;
7753 							if (g_strcmp0 (_tmp50_, "function-macro") == 0) {
7754 								vala_gir_parser_skip_element (self);
7755 							} else {
7756 								ValaMarkupReader* _tmp51_;
7757 								const gchar* _tmp52_;
7758 								const gchar* _tmp53_;
7759 								_tmp51_ = self->priv->reader;
7760 								_tmp52_ = vala_markup_reader_get_name (_tmp51_);
7761 								_tmp53_ = _tmp52_;
7762 								if (g_strcmp0 (_tmp53_, "method") == 0) {
7763 									vala_gir_parser_parse_method (self, "method");
7764 								} else {
7765 									ValaMarkupReader* _tmp54_;
7766 									const gchar* _tmp55_;
7767 									const gchar* _tmp56_;
7768 									_tmp54_ = self->priv->reader;
7769 									_tmp55_ = vala_markup_reader_get_name (_tmp54_);
7770 									_tmp56_ = _tmp55_;
7771 									if (g_strcmp0 (_tmp56_, "glib:signal") == 0) {
7772 										vala_gir_parser_parse_signal (self);
7773 									} else {
7774 										ValaSourceReference* _tmp57_;
7775 										ValaSourceReference* _tmp58_;
7776 										ValaMarkupReader* _tmp59_;
7777 										const gchar* _tmp60_;
7778 										const gchar* _tmp61_;
7779 										gchar* _tmp62_;
7780 										gchar* _tmp63_;
7781 										_tmp57_ = vala_gir_parser_get_current_src (self);
7782 										_tmp58_ = _tmp57_;
7783 										_tmp59_ = self->priv->reader;
7784 										_tmp60_ = vala_markup_reader_get_name (_tmp59_);
7785 										_tmp61_ = _tmp60_;
7786 										_tmp62_ = g_strdup_printf ("unknown child element `%s' in `interface'", _tmp61_);
7787 										_tmp63_ = _tmp62_;
7788 										vala_report_error (_tmp58_, _tmp63_);
7789 										_g_free0 (_tmp63_);
7790 										_vala_source_reference_unref0 (_tmp58_);
7791 										vala_gir_parser_skip_element (self);
7792 									}
7793 								}
7794 							}
7795 						}
7796 					}
7797 				}
7798 			}
7799 		}
7800 		vala_gir_parser_pop_metadata (self);
7801 	}
7802 	vala_gir_parser_pop_node (self);
7803 	vala_gir_parser_end_element (self, "interface");
7804 	_vala_code_node_unref0 (iface);
7805 }
7806 
7807 static void
vala_gir_parser_parse_field(ValaGirParser * self)7808 vala_gir_parser_parse_field (ValaGirParser* self)
7809 {
7810 	gchar* _tmp0_;
7811 	gchar* _tmp1_;
7812 	gchar* nullable = NULL;
7813 	ValaMarkupReader* _tmp2_;
7814 	gchar* _tmp3_;
7815 	gchar* allow_none = NULL;
7816 	ValaMarkupReader* _tmp4_;
7817 	gchar* _tmp5_;
7818 	ValaGirComment* comment = NULL;
7819 	ValaGirComment* _tmp6_;
7820 	gboolean no_array_length = FALSE;
7821 	gboolean array_null_terminated = FALSE;
7822 	gint array_length_idx = 0;
7823 	ValaDataType* type = NULL;
7824 	gint _tmp7_ = 0;
7825 	gboolean _tmp8_ = FALSE;
7826 	gboolean _tmp9_ = FALSE;
7827 	ValaDataType* _tmp10_;
7828 	ValaDataType* _tmp11_;
7829 	ValaDataType* _tmp12_;
7830 	gchar* name = NULL;
7831 	ValaGirParserNode* _tmp13_;
7832 	const gchar* _tmp14_;
7833 	gchar* _tmp15_;
7834 	gchar* cname = NULL;
7835 	ValaGirParserNode* _tmp16_;
7836 	ValaMap* _tmp17_;
7837 	gpointer _tmp18_;
7838 	ValaField* field = NULL;
7839 	const gchar* _tmp19_;
7840 	ValaDataType* _tmp20_;
7841 	ValaGirParserNode* _tmp21_;
7842 	ValaSourceReference* _tmp22_;
7843 	ValaField* _tmp23_;
7844 	ValaField* _tmp24_;
7845 	ValaField* _tmp25_;
7846 	ValaGirComment* _tmp26_;
7847 	const gchar* _tmp27_;
7848 	const gchar* _tmp28_;
7849 	ValaDataType* _tmp31_;
7850 	gboolean _tmp37_ = FALSE;
7851 	const gchar* _tmp38_;
7852 	ValaGirParserNode* _tmp41_;
7853 	ValaField* _tmp42_;
7854 	ValaSymbol* _tmp43_;
7855 	g_return_if_fail (self != NULL);
7856 	vala_gir_parser_start_element (self, "field");
7857 	_tmp0_ = vala_gir_parser_element_get_name (self, NULL);
7858 	_tmp1_ = _tmp0_;
7859 	vala_gir_parser_push_node (self, _tmp1_, FALSE);
7860 	_g_free0 (_tmp1_);
7861 	_tmp2_ = self->priv->reader;
7862 	_tmp3_ = vala_markup_reader_get_attribute (_tmp2_, "nullable");
7863 	nullable = _tmp3_;
7864 	_tmp4_ = self->priv->reader;
7865 	_tmp5_ = vala_markup_reader_get_attribute (_tmp4_, "allow-none");
7866 	allow_none = _tmp5_;
7867 	vala_gir_parser_next (self);
7868 	_tmp6_ = vala_gir_parser_parse_symbol_doc (self);
7869 	comment = _tmp6_;
7870 	_tmp10_ = vala_gir_parser_parse_type (self, NULL, &_tmp7_, TRUE, &_tmp8_, &_tmp9_);
7871 	array_length_idx = _tmp7_;
7872 	no_array_length = _tmp8_;
7873 	array_null_terminated = _tmp9_;
7874 	type = _tmp10_;
7875 	_tmp11_ = type;
7876 	_tmp12_ = vala_gir_parser_element_get_type (self, _tmp11_, TRUE, &no_array_length, &array_null_terminated, NULL);
7877 	_vala_code_node_unref0 (type);
7878 	type = _tmp12_;
7879 	_tmp13_ = self->priv->current;
7880 	_tmp14_ = _tmp13_->name;
7881 	_tmp15_ = g_strdup (_tmp14_);
7882 	name = _tmp15_;
7883 	_tmp16_ = self->priv->current;
7884 	_tmp17_ = _tmp16_->girdata;
7885 	_tmp18_ = vala_map_get (_tmp17_, "name");
7886 	cname = (gchar*) _tmp18_;
7887 	_tmp19_ = name;
7888 	_tmp20_ = type;
7889 	_tmp21_ = self->priv->current;
7890 	_tmp22_ = _tmp21_->source_reference;
7891 	_tmp23_ = vala_field_new (_tmp19_, _tmp20_, NULL, _tmp22_, NULL);
7892 	field = _tmp23_;
7893 	_tmp24_ = field;
7894 	vala_symbol_set_access ((ValaSymbol*) _tmp24_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
7895 	_tmp25_ = field;
7896 	_tmp26_ = comment;
7897 	vala_symbol_set_comment ((ValaSymbol*) _tmp25_, (ValaComment*) _tmp26_);
7898 	_tmp27_ = name;
7899 	_tmp28_ = cname;
7900 	if (g_strcmp0 (_tmp27_, _tmp28_) != 0) {
7901 		ValaField* _tmp29_;
7902 		const gchar* _tmp30_;
7903 		_tmp29_ = field;
7904 		_tmp30_ = cname;
7905 		vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp29_, "CCode", "cname", _tmp30_, NULL);
7906 	}
7907 	_tmp31_ = type;
7908 	if (VALA_IS_ARRAY_TYPE (_tmp31_)) {
7909 		gboolean _tmp32_ = FALSE;
7910 		gboolean _tmp34_ = FALSE;
7911 		if (!no_array_length) {
7912 			_tmp32_ = array_length_idx > -1;
7913 		} else {
7914 			_tmp32_ = FALSE;
7915 		}
7916 		if (_tmp32_) {
7917 			ValaGirParserNode* _tmp33_;
7918 			_tmp33_ = self->priv->current;
7919 			_tmp33_->array_length_idx = array_length_idx;
7920 		}
7921 		if (no_array_length) {
7922 			_tmp34_ = TRUE;
7923 		} else {
7924 			_tmp34_ = array_null_terminated;
7925 		}
7926 		if (_tmp34_) {
7927 			ValaField* _tmp35_;
7928 			_tmp35_ = field;
7929 			vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp35_, "CCode", "array_length", !no_array_length, NULL);
7930 		}
7931 		if (array_null_terminated) {
7932 			ValaField* _tmp36_;
7933 			_tmp36_ = field;
7934 			vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp36_, "CCode", "array_null_terminated", TRUE, NULL);
7935 		}
7936 	}
7937 	_tmp38_ = nullable;
7938 	if (g_strcmp0 (_tmp38_, "1") == 0) {
7939 		_tmp37_ = TRUE;
7940 	} else {
7941 		const gchar* _tmp39_;
7942 		_tmp39_ = allow_none;
7943 		_tmp37_ = g_strcmp0 (_tmp39_, "1") == 0;
7944 	}
7945 	if (_tmp37_) {
7946 		ValaDataType* _tmp40_;
7947 		_tmp40_ = type;
7948 		vala_data_type_set_nullable (_tmp40_, TRUE);
7949 	}
7950 	_tmp41_ = self->priv->current;
7951 	_tmp42_ = field;
7952 	_tmp43_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp42_);
7953 	_vala_code_node_unref0 (_tmp41_->symbol);
7954 	_tmp41_->symbol = _tmp43_;
7955 	vala_gir_parser_pop_node (self);
7956 	vala_gir_parser_end_element (self, "field");
7957 	_vala_code_node_unref0 (field);
7958 	_g_free0 (cname);
7959 	_g_free0 (name);
7960 	_vala_code_node_unref0 (type);
7961 	_vala_comment_unref0 (comment);
7962 	_g_free0 (allow_none);
7963 	_g_free0 (nullable);
7964 }
7965 
7966 static ValaProperty*
vala_gir_parser_parse_property(ValaGirParser * self)7967 vala_gir_parser_parse_property (ValaGirParser* self)
7968 {
7969 	gchar* _tmp0_;
7970 	gchar* _tmp1_;
7971 	gchar* _tmp2_;
7972 	gchar* _tmp3_;
7973 	gboolean is_abstract = FALSE;
7974 	ValaGirParserMetadata* _tmp4_;
7975 	ValaGirParserNode* _tmp5_;
7976 	ValaGirParserNode* _tmp6_;
7977 	ValaSymbol* _tmp7_;
7978 	gchar* transfer = NULL;
7979 	ValaMarkupReader* _tmp8_;
7980 	gchar* _tmp9_;
7981 	ValaGirComment* comment = NULL;
7982 	ValaGirComment* _tmp10_;
7983 	gboolean no_array_length = FALSE;
7984 	gboolean array_null_terminated = FALSE;
7985 	ValaDataType* type = NULL;
7986 	const gchar* _tmp11_;
7987 	gboolean _tmp12_ = FALSE;
7988 	gboolean _tmp13_ = FALSE;
7989 	ValaDataType* _tmp14_;
7990 	ValaDataType* _tmp15_;
7991 	ValaDataType* _tmp16_;
7992 	ValaProperty* prop = NULL;
7993 	ValaGirParserNode* _tmp17_;
7994 	const gchar* _tmp18_;
7995 	ValaDataType* _tmp19_;
7996 	ValaGirParserNode* _tmp20_;
7997 	ValaSourceReference* _tmp21_;
7998 	ValaProperty* _tmp22_;
7999 	ValaProperty* _tmp23_;
8000 	ValaGirComment* _tmp24_;
8001 	ValaProperty* _tmp25_;
8002 	ValaProperty* _tmp26_;
8003 	gboolean _tmp27_ = FALSE;
8004 	ValaGirParserNode* _tmp30_;
8005 	ValaProperty* _tmp31_;
8006 	ValaSymbol* _tmp32_;
8007 	ValaProperty* result = NULL;
8008 	g_return_val_if_fail (self != NULL, NULL);
8009 	vala_gir_parser_start_element (self, "property");
8010 	_tmp0_ = vala_gir_parser_element_get_name (self, NULL);
8011 	_tmp1_ = _tmp0_;
8012 	_tmp2_ = string_replace (_tmp1_, "-", "_");
8013 	_tmp3_ = _tmp2_;
8014 	vala_gir_parser_push_node (self, _tmp3_, FALSE);
8015 	_g_free0 (_tmp3_);
8016 	_g_free0 (_tmp1_);
8017 	_tmp4_ = self->priv->metadata;
8018 	_tmp5_ = self->priv->current;
8019 	_tmp6_ = _tmp5_->parent;
8020 	_tmp7_ = _tmp6_->symbol;
8021 	is_abstract = vala_gir_parser_metadata_get_bool (_tmp4_, VALA_GIR_PARSER_ARGUMENT_TYPE_ABSTRACT, VALA_IS_INTERFACE (_tmp7_));
8022 	_tmp8_ = self->priv->reader;
8023 	_tmp9_ = vala_markup_reader_get_attribute (_tmp8_, "transfer-ownership");
8024 	transfer = _tmp9_;
8025 	vala_gir_parser_next (self);
8026 	_tmp10_ = vala_gir_parser_parse_symbol_doc (self);
8027 	comment = _tmp10_;
8028 	_tmp11_ = transfer;
8029 	_tmp14_ = vala_gir_parser_parse_type (self, NULL, NULL, g_strcmp0 (_tmp11_, "container") != 0, &_tmp12_, &_tmp13_);
8030 	no_array_length = _tmp12_;
8031 	array_null_terminated = _tmp13_;
8032 	type = _tmp14_;
8033 	_tmp15_ = type;
8034 	_tmp16_ = vala_gir_parser_element_get_type (self, _tmp15_, TRUE, &no_array_length, &array_null_terminated, NULL);
8035 	_vala_code_node_unref0 (type);
8036 	type = _tmp16_;
8037 	_tmp17_ = self->priv->current;
8038 	_tmp18_ = _tmp17_->name;
8039 	_tmp19_ = type;
8040 	_tmp20_ = self->priv->current;
8041 	_tmp21_ = _tmp20_->source_reference;
8042 	_tmp22_ = vala_property_new (_tmp18_, _tmp19_, NULL, NULL, _tmp21_, NULL);
8043 	prop = _tmp22_;
8044 	_tmp23_ = prop;
8045 	_tmp24_ = comment;
8046 	vala_symbol_set_comment ((ValaSymbol*) _tmp23_, (ValaComment*) _tmp24_);
8047 	_tmp25_ = prop;
8048 	vala_symbol_set_access ((ValaSymbol*) _tmp25_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
8049 	_tmp26_ = prop;
8050 	vala_property_set_is_abstract (_tmp26_, is_abstract);
8051 	if (no_array_length) {
8052 		_tmp27_ = TRUE;
8053 	} else {
8054 		_tmp27_ = array_null_terminated;
8055 	}
8056 	if (_tmp27_) {
8057 		ValaProperty* _tmp28_;
8058 		_tmp28_ = prop;
8059 		vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp28_, "CCode", "array_length", !no_array_length, NULL);
8060 	}
8061 	if (array_null_terminated) {
8062 		ValaProperty* _tmp29_;
8063 		_tmp29_ = prop;
8064 		vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp29_, "CCode", "array_null_terminated", TRUE, NULL);
8065 	}
8066 	_tmp30_ = self->priv->current;
8067 	_tmp31_ = prop;
8068 	_tmp32_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp31_);
8069 	_vala_code_node_unref0 (_tmp30_->symbol);
8070 	_tmp30_->symbol = _tmp32_;
8071 	vala_gir_parser_pop_node (self);
8072 	vala_gir_parser_end_element (self, "property");
8073 	result = prop;
8074 	_vala_code_node_unref0 (type);
8075 	_vala_comment_unref0 (comment);
8076 	_g_free0 (transfer);
8077 	return result;
8078 }
8079 
8080 static void
vala_gir_parser_parse_callback(ValaGirParser * self)8081 vala_gir_parser_parse_callback (ValaGirParser* self)
8082 {
8083 	g_return_if_fail (self != NULL);
8084 	vala_gir_parser_parse_function (self, "callback");
8085 }
8086 
8087 static void
vala_gir_parser_parse_constructor(ValaGirParser * self)8088 vala_gir_parser_parse_constructor (ValaGirParser* self)
8089 {
8090 	g_return_if_fail (self != NULL);
8091 	vala_gir_parser_parse_function (self, "constructor");
8092 }
8093 
8094 static void
vala_gir_parser_parse_function(ValaGirParser * self,const gchar * element_name)8095 vala_gir_parser_parse_function (ValaGirParser* self,
8096                                 const gchar* element_name)
8097 {
8098 	ValaMarkupReader* _tmp0_;
8099 	gchar* _tmp1_;
8100 	gchar* _tmp2_;
8101 	gchar* _tmp3_;
8102 	gchar* _tmp4_;
8103 	gchar* _tmp5_;
8104 	gchar* _tmp6_;
8105 	gchar* symbol_type = NULL;
8106 	ValaGirParserMetadata* _tmp7_;
8107 	gchar* ctype = NULL;
8108 	ValaGirParserMetadata* _tmp11_;
8109 	gchar* name = NULL;
8110 	ValaGirParserNode* _tmp14_;
8111 	const gchar* _tmp15_;
8112 	gchar* _tmp16_;
8113 	gchar* throws_string = NULL;
8114 	ValaMarkupReader* _tmp17_;
8115 	gchar* _tmp18_;
8116 	gchar* invoker = NULL;
8117 	ValaMarkupReader* _tmp19_;
8118 	gchar* _tmp20_;
8119 	ValaGirComment* comment = NULL;
8120 	ValaGirComment* _tmp21_;
8121 	ValaDataType* return_type = NULL;
8122 	gchar* return_ctype = NULL;
8123 	gint return_array_length_idx = 0;
8124 	gboolean return_no_array_length = FALSE;
8125 	gboolean return_array_null_terminated = FALSE;
8126 	gboolean _tmp22_ = FALSE;
8127 	ValaMarkupTokenType _tmp23_;
8128 	ValaSymbol* s = NULL;
8129 	const gchar* _tmp41_;
8130 	ValaSymbol* _tmp98_;
8131 	ValaSymbol* _tmp99_;
8132 	ValaGirComment* _tmp100_;
8133 	ValaArrayType* array_type = NULL;
8134 	ValaDataType* _tmp101_;
8135 	ValaArrayType* _tmp102_;
8136 	gboolean _tmp103_ = FALSE;
8137 	ValaArrayType* _tmp104_;
8138 	ValaSymbol* _tmp116_;
8139 	ValaSymbol* _tmp130_;
8140 	gboolean _tmp176_ = FALSE;
8141 	ValaSymbol* _tmp177_;
8142 	ValaGirParserMetadata* _tmp201_;
8143 	ValaExpression* _tmp202_;
8144 	ValaExpression* _tmp203_;
8145 	gboolean _tmp204_;
8146 	ValaSymbol* _tmp233_;
8147 	gboolean _tmp243_ = FALSE;
8148 	ValaDataType* _tmp244_;
8149 	ValaGirParserNode* _tmp250_;
8150 	const gchar* _tmp251_;
8151 	ValaGirParserNode* _tmp254_;
8152 	ValaSymbol* _tmp255_;
8153 	ValaSymbol* _tmp256_;
8154 	ValaGirParserMetadata* _tmp257_;
8155 	ValaGirParserMetadata* _tmp262_;
8156 	gint instance_idx = 0;
8157 	gboolean _tmp265_ = FALSE;
8158 	ValaArrayList* parameters = NULL;
8159 	GEqualFunc _tmp272_;
8160 	ValaArrayList* _tmp273_;
8161 	ValaGirParserNode* _tmp274_;
8162 	GEqualFunc _tmp275_;
8163 	ValaArrayList* _tmp276_;
8164 	ValaGirParserNode* _tmp277_;
8165 	GEqualFunc _tmp278_;
8166 	ValaArrayList* _tmp279_;
8167 	ValaGirParserNode* _tmp280_;
8168 	GEqualFunc _tmp281_;
8169 	ValaArrayList* _tmp282_;
8170 	gboolean _tmp283_ = FALSE;
8171 	ValaMarkupTokenType _tmp284_;
8172 	ValaGirParserNode* _tmp359_;
8173 	ValaArrayList* _tmp360_;
8174 	ValaList* _tmp361_;
8175 	g_return_if_fail (self != NULL);
8176 	g_return_if_fail (element_name != NULL);
8177 	vala_gir_parser_start_element (self, element_name);
8178 	_tmp0_ = self->priv->reader;
8179 	_tmp1_ = vala_markup_reader_get_attribute (_tmp0_, "invoker");
8180 	_tmp2_ = _tmp1_;
8181 	_tmp3_ = vala_gir_parser_element_get_name (self, _tmp2_);
8182 	_tmp4_ = _tmp3_;
8183 	_tmp5_ = string_replace (_tmp4_, "-", "_");
8184 	_tmp6_ = _tmp5_;
8185 	vala_gir_parser_push_node (self, _tmp6_, FALSE);
8186 	_g_free0 (_tmp6_);
8187 	_g_free0 (_tmp4_);
8188 	_g_free0 (_tmp2_);
8189 	_tmp7_ = self->priv->metadata;
8190 	if (vala_gir_parser_metadata_has_argument (_tmp7_, VALA_GIR_PARSER_ARGUMENT_TYPE_SYMBOL_TYPE)) {
8191 		ValaGirParserMetadata* _tmp8_;
8192 		gchar* _tmp9_;
8193 		_tmp8_ = self->priv->metadata;
8194 		_tmp9_ = vala_gir_parser_metadata_get_string (_tmp8_, VALA_GIR_PARSER_ARGUMENT_TYPE_SYMBOL_TYPE);
8195 		_g_free0 (symbol_type);
8196 		symbol_type = _tmp9_;
8197 	} else {
8198 		gchar* _tmp10_;
8199 		_tmp10_ = g_strdup (element_name);
8200 		_g_free0 (symbol_type);
8201 		symbol_type = _tmp10_;
8202 	}
8203 	ctype = NULL;
8204 	_tmp11_ = self->priv->metadata;
8205 	if (vala_gir_parser_metadata_has_argument (_tmp11_, VALA_GIR_PARSER_ARGUMENT_TYPE_CTYPE)) {
8206 		ValaGirParserMetadata* _tmp12_;
8207 		gchar* _tmp13_;
8208 		_tmp12_ = self->priv->metadata;
8209 		_tmp13_ = vala_gir_parser_metadata_get_string (_tmp12_, VALA_GIR_PARSER_ARGUMENT_TYPE_CTYPE);
8210 		_g_free0 (ctype);
8211 		ctype = _tmp13_;
8212 	}
8213 	_tmp14_ = self->priv->current;
8214 	_tmp15_ = _tmp14_->name;
8215 	_tmp16_ = g_strdup (_tmp15_);
8216 	name = _tmp16_;
8217 	_tmp17_ = self->priv->reader;
8218 	_tmp18_ = vala_markup_reader_get_attribute (_tmp17_, "throws");
8219 	throws_string = _tmp18_;
8220 	_tmp19_ = self->priv->reader;
8221 	_tmp20_ = vala_markup_reader_get_attribute (_tmp19_, "invoker");
8222 	invoker = _tmp20_;
8223 	vala_gir_parser_next (self);
8224 	_tmp21_ = vala_gir_parser_parse_symbol_doc (self);
8225 	comment = _tmp21_;
8226 	return_ctype = NULL;
8227 	return_array_length_idx = -1;
8228 	return_no_array_length = FALSE;
8229 	return_array_null_terminated = FALSE;
8230 	_tmp23_ = self->priv->current_token;
8231 	if (_tmp23_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT) {
8232 		ValaMarkupReader* _tmp24_;
8233 		const gchar* _tmp25_;
8234 		const gchar* _tmp26_;
8235 		_tmp24_ = self->priv->reader;
8236 		_tmp25_ = vala_markup_reader_get_name (_tmp24_);
8237 		_tmp26_ = _tmp25_;
8238 		_tmp22_ = g_strcmp0 (_tmp26_, "return-value") == 0;
8239 	} else {
8240 		_tmp22_ = FALSE;
8241 	}
8242 	if (_tmp22_) {
8243 		ValaComment* return_comment = NULL;
8244 		gchar* _tmp27_ = NULL;
8245 		gint _tmp28_ = 0;
8246 		gboolean _tmp29_ = FALSE;
8247 		gboolean _tmp30_ = FALSE;
8248 		ValaComment* _tmp31_ = NULL;
8249 		ValaDataType* _tmp32_;
8250 		ValaComment* _tmp33_;
8251 		_tmp32_ = vala_gir_parser_parse_return_value (self, &_tmp27_, &_tmp28_, &_tmp29_, &_tmp30_, &_tmp31_);
8252 		_g_free0 (return_ctype);
8253 		return_ctype = _tmp27_;
8254 		return_array_length_idx = _tmp28_;
8255 		return_no_array_length = _tmp29_;
8256 		return_array_null_terminated = _tmp30_;
8257 		_vala_comment_unref0 (return_comment);
8258 		return_comment = _tmp31_;
8259 		_vala_code_node_unref0 (return_type);
8260 		return_type = _tmp32_;
8261 		_tmp33_ = return_comment;
8262 		if (_tmp33_ != NULL) {
8263 			ValaGirComment* _tmp34_;
8264 			ValaGirComment* _tmp38_;
8265 			ValaComment* _tmp39_;
8266 			_tmp34_ = comment;
8267 			if (_tmp34_ == NULL) {
8268 				ValaGirParserNode* _tmp35_;
8269 				ValaSourceReference* _tmp36_;
8270 				ValaGirComment* _tmp37_;
8271 				_tmp35_ = self->priv->current;
8272 				_tmp36_ = _tmp35_->source_reference;
8273 				_tmp37_ = vala_gir_comment_new (NULL, _tmp36_);
8274 				_vala_comment_unref0 (comment);
8275 				comment = _tmp37_;
8276 			}
8277 			_tmp38_ = comment;
8278 			_tmp39_ = return_comment;
8279 			vala_gir_comment_set_return_content (_tmp38_, _tmp39_);
8280 		}
8281 		_vala_comment_unref0 (return_comment);
8282 	} else {
8283 		ValaVoidType* _tmp40_;
8284 		_tmp40_ = vala_void_type_new (NULL);
8285 		_vala_code_node_unref0 (return_type);
8286 		return_type = (ValaDataType*) _tmp40_;
8287 	}
8288 	_tmp41_ = symbol_type;
8289 	if (g_strcmp0 (_tmp41_, "callback") == 0) {
8290 		const gchar* _tmp42_;
8291 		ValaDataType* _tmp43_;
8292 		ValaGirParserNode* _tmp44_;
8293 		ValaSourceReference* _tmp45_;
8294 		ValaDelegate* _tmp46_;
8295 		ValaSymbol* _tmp47_;
8296 		_tmp42_ = name;
8297 		_tmp43_ = return_type;
8298 		_tmp44_ = self->priv->current;
8299 		_tmp45_ = _tmp44_->source_reference;
8300 		_tmp46_ = vala_delegate_new (_tmp42_, _tmp43_, _tmp45_, NULL);
8301 		_vala_code_node_unref0 (s);
8302 		s = (ValaSymbol*) _tmp46_;
8303 		_tmp47_ = s;
8304 		vala_delegate_set_has_target (G_TYPE_CHECK_INSTANCE_CAST (_tmp47_, VALA_TYPE_DELEGATE, ValaDelegate), FALSE);
8305 	} else {
8306 		const gchar* _tmp48_;
8307 		_tmp48_ = symbol_type;
8308 		if (g_strcmp0 (_tmp48_, "constructor") == 0) {
8309 			const gchar* _tmp49_;
8310 			ValaCreationMethod* m = NULL;
8311 			const gchar* _tmp55_;
8312 			ValaGirParserNode* _tmp56_;
8313 			ValaSourceReference* _tmp57_;
8314 			ValaCreationMethod* _tmp58_;
8315 			ValaCreationMethod* _tmp59_;
8316 			gboolean _tmp60_ = FALSE;
8317 			const gchar* _tmp61_;
8318 			gchar* parent_ctype = NULL;
8319 			ValaGirParserNode* _tmp69_;
8320 			ValaGirParserNode* _tmp70_;
8321 			ValaSymbol* _tmp71_;
8322 			gboolean _tmp75_ = FALSE;
8323 			const gchar* _tmp76_;
8324 			ValaCreationMethod* _tmp85_;
8325 			ValaSymbol* _tmp86_;
8326 			_tmp49_ = name;
8327 			if (g_strcmp0 (_tmp49_, "new") == 0) {
8328 				_g_free0 (name);
8329 				name = NULL;
8330 			} else {
8331 				const gchar* _tmp50_;
8332 				_tmp50_ = name;
8333 				if (g_str_has_prefix (_tmp50_, "new_")) {
8334 					const gchar* _tmp51_;
8335 					gint _tmp52_;
8336 					gint _tmp53_;
8337 					gchar* _tmp54_;
8338 					_tmp51_ = name;
8339 					_tmp52_ = strlen ("new_");
8340 					_tmp53_ = _tmp52_;
8341 					_tmp54_ = string_substring (_tmp51_, (glong) _tmp53_, (glong) -1);
8342 					_g_free0 (name);
8343 					name = _tmp54_;
8344 				}
8345 			}
8346 			_tmp55_ = name;
8347 			_tmp56_ = self->priv->current;
8348 			_tmp57_ = _tmp56_->source_reference;
8349 			_tmp58_ = vala_creation_method_new (NULL, _tmp55_, _tmp57_, NULL);
8350 			m = _tmp58_;
8351 			_tmp59_ = m;
8352 			vala_method_set_has_construct_function ((ValaMethod*) _tmp59_, FALSE);
8353 			_tmp61_ = name;
8354 			if (_tmp61_ != NULL) {
8355 				ValaGirParserNode* _tmp62_;
8356 				const gchar* _tmp63_;
8357 				_tmp62_ = self->priv->current;
8358 				_tmp63_ = _tmp62_->name;
8359 				_tmp60_ = !g_str_has_prefix (_tmp63_, "new_");
8360 			} else {
8361 				_tmp60_ = FALSE;
8362 			}
8363 			if (_tmp60_) {
8364 				ValaCreationMethod* _tmp64_;
8365 				ValaGirParserNode* _tmp65_;
8366 				ValaMap* _tmp66_;
8367 				gpointer _tmp67_;
8368 				gchar* _tmp68_;
8369 				_tmp64_ = m;
8370 				_tmp65_ = self->priv->current;
8371 				_tmp66_ = _tmp65_->girdata;
8372 				_tmp67_ = vala_map_get (_tmp66_, "c:identifier");
8373 				_tmp68_ = (gchar*) _tmp67_;
8374 				vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp64_, "CCode", "cname", _tmp68_, NULL);
8375 				_g_free0 (_tmp68_);
8376 			}
8377 			parent_ctype = NULL;
8378 			_tmp69_ = self->priv->current;
8379 			_tmp70_ = _tmp69_->parent;
8380 			_tmp71_ = _tmp70_->symbol;
8381 			if (VALA_IS_CLASS (_tmp71_)) {
8382 				ValaGirParserNode* _tmp72_;
8383 				ValaGirParserNode* _tmp73_;
8384 				gchar* _tmp74_;
8385 				_tmp72_ = self->priv->current;
8386 				_tmp73_ = _tmp72_->parent;
8387 				_tmp74_ = vala_gir_parser_node_get_cname (_tmp73_);
8388 				_g_free0 (parent_ctype);
8389 				parent_ctype = _tmp74_;
8390 			}
8391 			_tmp76_ = return_ctype;
8392 			if (_tmp76_ != NULL) {
8393 				gboolean _tmp77_ = FALSE;
8394 				const gchar* _tmp78_;
8395 				_tmp78_ = parent_ctype;
8396 				if (_tmp78_ == NULL) {
8397 					_tmp77_ = TRUE;
8398 				} else {
8399 					const gchar* _tmp79_;
8400 					const gchar* _tmp80_;
8401 					gchar* _tmp81_;
8402 					gchar* _tmp82_;
8403 					_tmp79_ = return_ctype;
8404 					_tmp80_ = parent_ctype;
8405 					_tmp81_ = g_strconcat (_tmp80_, "*", NULL);
8406 					_tmp82_ = _tmp81_;
8407 					_tmp77_ = g_strcmp0 (_tmp79_, _tmp82_) != 0;
8408 					_g_free0 (_tmp82_);
8409 				}
8410 				_tmp75_ = _tmp77_;
8411 			} else {
8412 				_tmp75_ = FALSE;
8413 			}
8414 			if (_tmp75_) {
8415 				ValaCreationMethod* _tmp83_;
8416 				const gchar* _tmp84_;
8417 				_tmp83_ = m;
8418 				_tmp84_ = return_ctype;
8419 				vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp83_, "CCode", "type", _tmp84_, NULL);
8420 			}
8421 			_tmp85_ = m;
8422 			_tmp86_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp85_);
8423 			_vala_code_node_unref0 (s);
8424 			s = _tmp86_;
8425 			_g_free0 (parent_ctype);
8426 			_vala_code_node_unref0 (m);
8427 		} else {
8428 			const gchar* _tmp87_;
8429 			_tmp87_ = symbol_type;
8430 			if (g_strcmp0 (_tmp87_, "glib:signal") == 0) {
8431 				const gchar* _tmp88_;
8432 				ValaDataType* _tmp89_;
8433 				ValaGirParserNode* _tmp90_;
8434 				ValaSourceReference* _tmp91_;
8435 				ValaSignal* _tmp92_;
8436 				_tmp88_ = name;
8437 				_tmp89_ = return_type;
8438 				_tmp90_ = self->priv->current;
8439 				_tmp91_ = _tmp90_->source_reference;
8440 				_tmp92_ = vala_signal_new (_tmp88_, _tmp89_, _tmp91_, NULL);
8441 				_vala_code_node_unref0 (s);
8442 				s = (ValaSymbol*) _tmp92_;
8443 			} else {
8444 				const gchar* _tmp93_;
8445 				ValaDataType* _tmp94_;
8446 				ValaGirParserNode* _tmp95_;
8447 				ValaSourceReference* _tmp96_;
8448 				ValaMethod* _tmp97_;
8449 				_tmp93_ = name;
8450 				_tmp94_ = return_type;
8451 				_tmp95_ = self->priv->current;
8452 				_tmp96_ = _tmp95_->source_reference;
8453 				_tmp97_ = vala_method_new (_tmp93_, _tmp94_, _tmp96_, NULL);
8454 				_vala_code_node_unref0 (s);
8455 				s = (ValaSymbol*) _tmp97_;
8456 			}
8457 		}
8458 	}
8459 	_tmp98_ = s;
8460 	vala_symbol_set_access (_tmp98_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
8461 	_tmp99_ = s;
8462 	_tmp100_ = comment;
8463 	vala_symbol_set_comment (_tmp99_, (ValaComment*) _tmp100_);
8464 	_tmp101_ = return_type;
8465 	_tmp102_ = _vala_code_node_ref0 (VALA_IS_ARRAY_TYPE (_tmp101_) ? ((ValaArrayType*) _tmp101_) : NULL);
8466 	array_type = _tmp102_;
8467 	_tmp104_ = array_type;
8468 	if (_tmp104_ != NULL) {
8469 		ValaArrayType* _tmp105_;
8470 		gboolean _tmp106_;
8471 		gboolean _tmp107_;
8472 		_tmp105_ = array_type;
8473 		_tmp106_ = vala_array_type_get_fixed_length (_tmp105_);
8474 		_tmp107_ = _tmp106_;
8475 		_tmp103_ = _tmp107_;
8476 	} else {
8477 		_tmp103_ = FALSE;
8478 	}
8479 	if (_tmp103_) {
8480 		ValaSymbol* _tmp108_;
8481 		ValaArrayType* _tmp109_;
8482 		ValaExpression* _tmp110_;
8483 		ValaExpression* _tmp111_;
8484 		const gchar* _tmp112_;
8485 		const gchar* _tmp113_;
8486 		ValaArrayType* _tmp114_;
8487 		ValaArrayType* _tmp115_;
8488 		_tmp108_ = s;
8489 		_tmp109_ = array_type;
8490 		_tmp110_ = vala_array_type_get_length (_tmp109_);
8491 		_tmp111_ = _tmp110_;
8492 		_tmp112_ = vala_integer_literal_get_value (G_TYPE_CHECK_INSTANCE_CAST (_tmp111_, VALA_TYPE_INTEGER_LITERAL, ValaIntegerLiteral));
8493 		_tmp113_ = _tmp112_;
8494 		vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp108_, "CCode", "array_length_cexpr", _tmp113_, NULL);
8495 		_tmp114_ = array_type;
8496 		vala_array_type_set_fixed_length (_tmp114_, FALSE);
8497 		_tmp115_ = array_type;
8498 		vala_array_type_set_length (_tmp115_, NULL);
8499 	}
8500 	_tmp116_ = s;
8501 	if (VALA_IS_SIGNAL (_tmp116_)) {
8502 		ValaGirParserNode* _tmp117_;
8503 		ValaMap* _tmp118_;
8504 		gpointer _tmp119_;
8505 		gchar* _tmp120_;
8506 		const gchar* _tmp121_;
8507 		gchar* _tmp122_;
8508 		gchar* _tmp123_;
8509 		gboolean _tmp124_;
8510 		_tmp117_ = self->priv->current;
8511 		_tmp118_ = _tmp117_->girdata;
8512 		_tmp119_ = vala_map_get (_tmp118_, "name");
8513 		_tmp120_ = (gchar*) _tmp119_;
8514 		_tmp121_ = name;
8515 		_tmp122_ = string_replace (_tmp121_, "_", "-");
8516 		_tmp123_ = _tmp122_;
8517 		_tmp124_ = g_strcmp0 (_tmp120_, _tmp123_) != 0;
8518 		_g_free0 (_tmp123_);
8519 		_g_free0 (_tmp120_);
8520 		if (_tmp124_) {
8521 			ValaSymbol* _tmp125_;
8522 			ValaGirParserNode* _tmp126_;
8523 			ValaMap* _tmp127_;
8524 			gpointer _tmp128_;
8525 			gchar* _tmp129_;
8526 			_tmp125_ = s;
8527 			_tmp126_ = self->priv->current;
8528 			_tmp127_ = _tmp126_->girdata;
8529 			_tmp128_ = vala_map_get (_tmp127_, "name");
8530 			_tmp129_ = (gchar*) _tmp128_;
8531 			vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp125_, "CCode", "cname", _tmp129_, NULL);
8532 			_g_free0 (_tmp129_);
8533 		}
8534 	}
8535 	_tmp130_ = s;
8536 	if (VALA_IS_METHOD (_tmp130_)) {
8537 		ValaMethod* m = NULL;
8538 		ValaSymbol* _tmp131_;
8539 		ValaMethod* _tmp132_;
8540 		gboolean _tmp133_ = FALSE;
8541 		const gchar* _tmp134_;
8542 		ValaGirParserMetadata* _tmp167_;
8543 		ValaGirParserMetadata* _tmp173_;
8544 		_tmp131_ = s;
8545 		_tmp132_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp131_, VALA_TYPE_METHOD, ValaMethod));
8546 		m = _tmp132_;
8547 		_tmp134_ = symbol_type;
8548 		if (g_strcmp0 (_tmp134_, "virtual-method") == 0) {
8549 			_tmp133_ = TRUE;
8550 		} else {
8551 			const gchar* _tmp135_;
8552 			_tmp135_ = symbol_type;
8553 			_tmp133_ = g_strcmp0 (_tmp135_, "callback") == 0;
8554 		}
8555 		if (_tmp133_) {
8556 			ValaGirParserNode* _tmp136_;
8557 			ValaGirParserNode* _tmp137_;
8558 			ValaSymbol* _tmp138_;
8559 			ValaGirParserMetadata* _tmp141_;
8560 			ValaGirParserNode* _tmp154_;
8561 			ValaMap* _tmp155_;
8562 			gpointer _tmp156_;
8563 			gchar* _tmp157_;
8564 			const gchar* _tmp158_;
8565 			gboolean _tmp159_;
8566 			_tmp136_ = self->priv->current;
8567 			_tmp137_ = _tmp136_->parent;
8568 			_tmp138_ = _tmp137_->symbol;
8569 			if (VALA_IS_INTERFACE (_tmp138_)) {
8570 				ValaMethod* _tmp139_;
8571 				_tmp139_ = m;
8572 				vala_method_set_is_abstract (_tmp139_, TRUE);
8573 			} else {
8574 				ValaMethod* _tmp140_;
8575 				_tmp140_ = m;
8576 				vala_method_set_is_virtual (_tmp140_, TRUE);
8577 			}
8578 			_tmp141_ = self->priv->metadata;
8579 			if (vala_gir_parser_metadata_has_argument (_tmp141_, VALA_GIR_PARSER_ARGUMENT_TYPE_NO_WRAPPER)) {
8580 				ValaSymbol* _tmp142_;
8581 				ValaGirParserMetadata* _tmp143_;
8582 				ValaSymbol* _tmp144_;
8583 				ValaSourceReference* _tmp145_;
8584 				ValaSourceReference* _tmp146_;
8585 				_tmp142_ = s;
8586 				_tmp143_ = self->priv->metadata;
8587 				_tmp144_ = s;
8588 				_tmp145_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp144_);
8589 				_tmp146_ = _tmp145_;
8590 				vala_code_node_set_attribute ((ValaCodeNode*) _tmp142_, "NoWrapper", vala_gir_parser_metadata_get_bool (_tmp143_, VALA_GIR_PARSER_ARGUMENT_TYPE_NO_WRAPPER, FALSE), _tmp146_);
8591 			} else {
8592 				gboolean _tmp147_ = FALSE;
8593 				const gchar* _tmp148_;
8594 				_tmp148_ = invoker;
8595 				if (_tmp148_ == NULL) {
8596 					ValaGirParserMetadata* _tmp149_;
8597 					_tmp149_ = self->priv->metadata;
8598 					_tmp147_ = !vala_gir_parser_metadata_has_argument (_tmp149_, VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME);
8599 				} else {
8600 					_tmp147_ = FALSE;
8601 				}
8602 				if (_tmp147_) {
8603 					ValaSymbol* _tmp150_;
8604 					ValaSymbol* _tmp151_;
8605 					ValaSourceReference* _tmp152_;
8606 					ValaSourceReference* _tmp153_;
8607 					_tmp150_ = s;
8608 					_tmp151_ = s;
8609 					_tmp152_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp151_);
8610 					_tmp153_ = _tmp152_;
8611 					vala_code_node_set_attribute ((ValaCodeNode*) _tmp150_, "NoWrapper", TRUE, _tmp153_);
8612 				}
8613 			}
8614 			_tmp154_ = self->priv->current;
8615 			_tmp155_ = _tmp154_->girdata;
8616 			_tmp156_ = vala_map_get (_tmp155_, "name");
8617 			_tmp157_ = (gchar*) _tmp156_;
8618 			_tmp158_ = name;
8619 			_tmp159_ = g_strcmp0 (_tmp157_, _tmp158_) != 0;
8620 			_g_free0 (_tmp157_);
8621 			if (_tmp159_) {
8622 				ValaMethod* _tmp160_;
8623 				ValaGirParserNode* _tmp161_;
8624 				ValaMap* _tmp162_;
8625 				gpointer _tmp163_;
8626 				gchar* _tmp164_;
8627 				_tmp160_ = m;
8628 				_tmp161_ = self->priv->current;
8629 				_tmp162_ = _tmp161_->girdata;
8630 				_tmp163_ = vala_map_get (_tmp162_, "name");
8631 				_tmp164_ = (gchar*) _tmp163_;
8632 				vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp160_, "CCode", "vfunc_name", _tmp164_, NULL);
8633 				_g_free0 (_tmp164_);
8634 			}
8635 		} else {
8636 			const gchar* _tmp165_;
8637 			_tmp165_ = symbol_type;
8638 			if (g_strcmp0 (_tmp165_, "function") == 0) {
8639 				ValaMethod* _tmp166_;
8640 				_tmp166_ = m;
8641 				vala_method_set_binding (_tmp166_, VALA_MEMBER_BINDING_STATIC);
8642 			}
8643 		}
8644 		_tmp167_ = self->priv->metadata;
8645 		if (vala_gir_parser_metadata_has_argument (_tmp167_, VALA_GIR_PARSER_ARGUMENT_TYPE_FLOATING)) {
8646 			ValaMethod* _tmp168_;
8647 			ValaGirParserMetadata* _tmp169_;
8648 			ValaMethod* _tmp170_;
8649 			ValaDataType* _tmp171_;
8650 			ValaDataType* _tmp172_;
8651 			_tmp168_ = m;
8652 			_tmp169_ = self->priv->metadata;
8653 			vala_method_set_returns_floating_reference (_tmp168_, vala_gir_parser_metadata_get_bool (_tmp169_, VALA_GIR_PARSER_ARGUMENT_TYPE_FLOATING, FALSE));
8654 			_tmp170_ = m;
8655 			_tmp171_ = vala_callable_get_return_type ((ValaCallable*) _tmp170_);
8656 			_tmp172_ = _tmp171_;
8657 			vala_data_type_set_value_owned (_tmp172_, TRUE);
8658 		}
8659 		_tmp173_ = self->priv->metadata;
8660 		if (vala_gir_parser_metadata_has_argument (_tmp173_, VALA_GIR_PARSER_ARGUMENT_TYPE_NEW)) {
8661 			ValaMethod* _tmp174_;
8662 			ValaGirParserMetadata* _tmp175_;
8663 			_tmp174_ = m;
8664 			_tmp175_ = self->priv->metadata;
8665 			vala_symbol_set_hides ((ValaSymbol*) _tmp174_, vala_gir_parser_metadata_get_bool (_tmp175_, VALA_GIR_PARSER_ARGUMENT_TYPE_NEW, FALSE));
8666 		}
8667 		_vala_code_node_unref0 (m);
8668 	}
8669 	_tmp177_ = s;
8670 	if (VALA_IS_METHOD (_tmp177_)) {
8671 		ValaSymbol* _tmp178_;
8672 		_tmp178_ = s;
8673 		_tmp176_ = !VALA_IS_CREATION_METHOD (_tmp178_);
8674 	} else {
8675 		_tmp176_ = FALSE;
8676 	}
8677 	if (_tmp176_) {
8678 		ValaMethod* method = NULL;
8679 		ValaSymbol* _tmp179_;
8680 		ValaMethod* _tmp180_;
8681 		ValaGirParserMetadata* _tmp181_;
8682 		ValaGirParserMetadata* _tmp189_;
8683 		ValaGirParserMetadata* _tmp195_;
8684 		_tmp179_ = s;
8685 		_tmp180_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp179_, VALA_TYPE_METHOD, ValaMethod));
8686 		method = _tmp180_;
8687 		_tmp181_ = self->priv->metadata;
8688 		if (vala_gir_parser_metadata_has_argument (_tmp181_, VALA_GIR_PARSER_ARGUMENT_TYPE_VIRTUAL)) {
8689 			ValaMethod* _tmp182_;
8690 			ValaGirParserMetadata* _tmp183_;
8691 			ValaMethod* _tmp184_;
8692 			_tmp182_ = method;
8693 			_tmp183_ = self->priv->metadata;
8694 			vala_method_set_is_virtual (_tmp182_, vala_gir_parser_metadata_get_bool (_tmp183_, VALA_GIR_PARSER_ARGUMENT_TYPE_VIRTUAL, FALSE));
8695 			_tmp184_ = method;
8696 			vala_method_set_is_abstract (_tmp184_, FALSE);
8697 		} else {
8698 			ValaGirParserMetadata* _tmp185_;
8699 			_tmp185_ = self->priv->metadata;
8700 			if (vala_gir_parser_metadata_has_argument (_tmp185_, VALA_GIR_PARSER_ARGUMENT_TYPE_ABSTRACT)) {
8701 				ValaMethod* _tmp186_;
8702 				ValaGirParserMetadata* _tmp187_;
8703 				ValaMethod* _tmp188_;
8704 				_tmp186_ = method;
8705 				_tmp187_ = self->priv->metadata;
8706 				vala_method_set_is_abstract (_tmp186_, vala_gir_parser_metadata_get_bool (_tmp187_, VALA_GIR_PARSER_ARGUMENT_TYPE_ABSTRACT, FALSE));
8707 				_tmp188_ = method;
8708 				vala_method_set_is_virtual (_tmp188_, FALSE);
8709 			}
8710 		}
8711 		_tmp189_ = self->priv->metadata;
8712 		if (vala_gir_parser_metadata_has_argument (_tmp189_, VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME)) {
8713 			ValaMethod* _tmp190_;
8714 			ValaGirParserMetadata* _tmp191_;
8715 			gchar* _tmp192_;
8716 			gchar* _tmp193_;
8717 			ValaMethod* _tmp194_;
8718 			_tmp190_ = method;
8719 			_tmp191_ = self->priv->metadata;
8720 			_tmp192_ = vala_gir_parser_metadata_get_string (_tmp191_, VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME);
8721 			_tmp193_ = _tmp192_;
8722 			vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp190_, "CCode", "vfunc_name", _tmp193_, NULL);
8723 			_g_free0 (_tmp193_);
8724 			_tmp194_ = method;
8725 			vala_method_set_is_virtual (_tmp194_, TRUE);
8726 		}
8727 		_tmp195_ = self->priv->metadata;
8728 		if (vala_gir_parser_metadata_has_argument (_tmp195_, VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_VFUNC_NAME)) {
8729 			ValaMethod* _tmp196_;
8730 			ValaGirParserMetadata* _tmp197_;
8731 			gchar* _tmp198_;
8732 			gchar* _tmp199_;
8733 			ValaMethod* _tmp200_;
8734 			_tmp196_ = method;
8735 			_tmp197_ = self->priv->metadata;
8736 			_tmp198_ = vala_gir_parser_metadata_get_string (_tmp197_, VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_VFUNC_NAME);
8737 			_tmp199_ = _tmp198_;
8738 			vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp196_, "CCode", "finish_vfunc_name", _tmp199_, NULL);
8739 			_g_free0 (_tmp199_);
8740 			_tmp200_ = method;
8741 			vala_method_set_is_virtual (_tmp200_, TRUE);
8742 		}
8743 		_vala_code_node_unref0 (method);
8744 	}
8745 	_tmp201_ = self->priv->metadata;
8746 	_tmp202_ = vala_gir_parser_metadata_get_expression (_tmp201_, VALA_GIR_PARSER_ARGUMENT_TYPE_THROWS);
8747 	_tmp203_ = _tmp202_;
8748 	_tmp204_ = !VALA_IS_NULL_LITERAL (_tmp203_);
8749 	_vala_code_node_unref0 (_tmp203_);
8750 	if (_tmp204_) {
8751 		ValaGirParserMetadata* _tmp205_;
8752 		_tmp205_ = self->priv->metadata;
8753 		if (vala_gir_parser_metadata_has_argument (_tmp205_, VALA_GIR_PARSER_ARGUMENT_TYPE_THROWS)) {
8754 			gchar** error_types = NULL;
8755 			ValaGirParserMetadata* _tmp206_;
8756 			gchar* _tmp207_;
8757 			gchar* _tmp208_;
8758 			gchar** _tmp209_;
8759 			gchar** _tmp210_;
8760 			gchar** _tmp211_;
8761 			gint _tmp211__length1;
8762 			gint error_types_length1;
8763 			gint _error_types_size_;
8764 			gchar** _tmp212_;
8765 			gint _tmp212__length1;
8766 			_tmp206_ = self->priv->metadata;
8767 			_tmp207_ = vala_gir_parser_metadata_get_string (_tmp206_, VALA_GIR_PARSER_ARGUMENT_TYPE_THROWS);
8768 			_tmp208_ = _tmp207_;
8769 			_tmp210_ = _tmp209_ = g_strsplit (_tmp208_, ",", 0);
8770 			_tmp211_ = _tmp210_;
8771 			_tmp211__length1 = _vala_array_length (_tmp209_);
8772 			_g_free0 (_tmp208_);
8773 			error_types = _tmp211_;
8774 			error_types_length1 = _tmp211__length1;
8775 			_error_types_size_ = error_types_length1;
8776 			_tmp212_ = error_types;
8777 			_tmp212__length1 = error_types_length1;
8778 			{
8779 				gchar** error_type_name_collection = NULL;
8780 				gint error_type_name_collection_length1 = 0;
8781 				gint _error_type_name_collection_size_ = 0;
8782 				gint error_type_name_it = 0;
8783 				error_type_name_collection = _tmp212_;
8784 				error_type_name_collection_length1 = _tmp212__length1;
8785 				for (error_type_name_it = 0; error_type_name_it < error_type_name_collection_length1; error_type_name_it = error_type_name_it + 1) {
8786 					gchar* _tmp213_;
8787 					gchar* error_type_name = NULL;
8788 					_tmp213_ = g_strdup (error_type_name_collection[error_type_name_it]);
8789 					error_type_name = _tmp213_;
8790 					{
8791 						ValaDataType* error_type = NULL;
8792 						const gchar* _tmp214_;
8793 						ValaGirParserMetadata* _tmp215_;
8794 						ValaSourceReference* _tmp216_;
8795 						ValaSourceReference* _tmp217_;
8796 						ValaDataType* _tmp218_;
8797 						ValaDataType* _tmp219_;
8798 						ValaSymbol* _tmp220_;
8799 						_tmp214_ = error_type_name;
8800 						_tmp215_ = self->priv->metadata;
8801 						_tmp216_ = vala_gir_parser_metadata_get_source_reference (_tmp215_, VALA_GIR_PARSER_ARGUMENT_TYPE_THROWS);
8802 						_tmp217_ = _tmp216_;
8803 						_tmp218_ = vala_gir_parser_parse_type_from_string (self, _tmp214_, TRUE, _tmp217_);
8804 						_tmp219_ = _tmp218_;
8805 						_vala_source_reference_unref0 (_tmp217_);
8806 						error_type = _tmp219_;
8807 						_tmp220_ = s;
8808 						if (VALA_IS_METHOD (_tmp220_)) {
8809 							ValaSymbol* _tmp221_;
8810 							ValaDataType* _tmp222_;
8811 							_tmp221_ = s;
8812 							_tmp222_ = error_type;
8813 							vala_method_add_error_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp221_, VALA_TYPE_METHOD, ValaMethod), _tmp222_);
8814 						} else {
8815 							ValaSymbol* _tmp223_;
8816 							ValaDataType* _tmp224_;
8817 							_tmp223_ = s;
8818 							_tmp224_ = error_type;
8819 							vala_delegate_add_error_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp223_, VALA_TYPE_DELEGATE, ValaDelegate), _tmp224_);
8820 						}
8821 						_vala_code_node_unref0 (error_type);
8822 						_g_free0 (error_type_name);
8823 					}
8824 				}
8825 			}
8826 			error_types = (_vala_array_free (error_types, error_types_length1, (GDestroyNotify) g_free), NULL);
8827 		} else {
8828 			const gchar* _tmp225_;
8829 			_tmp225_ = throws_string;
8830 			if (g_strcmp0 (_tmp225_, "1") == 0) {
8831 				ValaSymbol* _tmp226_;
8832 				_tmp226_ = s;
8833 				if (VALA_IS_METHOD (_tmp226_)) {
8834 					ValaSymbol* _tmp227_;
8835 					ValaErrorType* _tmp228_;
8836 					ValaErrorType* _tmp229_;
8837 					_tmp227_ = s;
8838 					_tmp228_ = vala_error_type_new (NULL, NULL, NULL);
8839 					_tmp229_ = _tmp228_;
8840 					vala_method_add_error_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp227_, VALA_TYPE_METHOD, ValaMethod), (ValaDataType*) _tmp229_);
8841 					_vala_code_node_unref0 (_tmp229_);
8842 				} else {
8843 					ValaSymbol* _tmp230_;
8844 					ValaErrorType* _tmp231_;
8845 					ValaErrorType* _tmp232_;
8846 					_tmp230_ = s;
8847 					_tmp231_ = vala_error_type_new (NULL, NULL, NULL);
8848 					_tmp232_ = _tmp231_;
8849 					vala_delegate_add_error_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp230_, VALA_TYPE_DELEGATE, ValaDelegate), (ValaDataType*) _tmp232_);
8850 					_vala_code_node_unref0 (_tmp232_);
8851 				}
8852 			}
8853 		}
8854 	}
8855 	_tmp233_ = s;
8856 	if (VALA_IS_METHOD (_tmp233_)) {
8857 		ValaMethod* m = NULL;
8858 		ValaSymbol* _tmp234_;
8859 		ValaMethod* _tmp235_;
8860 		ValaMethod* _tmp236_;
8861 		ValaGirParserMetadata* _tmp237_;
8862 		ValaGirParserMetadata* _tmp238_;
8863 		_tmp234_ = s;
8864 		_tmp235_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp234_, VALA_TYPE_METHOD, ValaMethod));
8865 		m = _tmp235_;
8866 		_tmp236_ = m;
8867 		_tmp237_ = self->priv->metadata;
8868 		vala_code_node_set_attribute ((ValaCodeNode*) _tmp236_, "PrintfFormat", vala_gir_parser_metadata_get_bool (_tmp237_, VALA_GIR_PARSER_ARGUMENT_TYPE_PRINTF_FORMAT, FALSE), NULL);
8869 		_tmp238_ = self->priv->metadata;
8870 		if (vala_gir_parser_metadata_has_argument (_tmp238_, VALA_GIR_PARSER_ARGUMENT_TYPE_SENTINEL)) {
8871 			ValaMethod* _tmp239_;
8872 			ValaGirParserMetadata* _tmp240_;
8873 			gchar* _tmp241_;
8874 			gchar* _tmp242_;
8875 			_tmp239_ = m;
8876 			_tmp240_ = self->priv->metadata;
8877 			_tmp241_ = vala_gir_parser_metadata_get_string (_tmp240_, VALA_GIR_PARSER_ARGUMENT_TYPE_SENTINEL);
8878 			_tmp242_ = _tmp241_;
8879 			vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp239_, "CCode", "sentinel", _tmp242_, NULL);
8880 			_g_free0 (_tmp242_);
8881 		}
8882 		_vala_code_node_unref0 (m);
8883 	}
8884 	_tmp244_ = return_type;
8885 	if (VALA_IS_ARRAY_TYPE (_tmp244_)) {
8886 		ValaGirParserMetadata* _tmp245_;
8887 		_tmp245_ = self->priv->metadata;
8888 		_tmp243_ = vala_gir_parser_metadata_has_argument (_tmp245_, VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_IDX);
8889 	} else {
8890 		_tmp243_ = FALSE;
8891 	}
8892 	if (_tmp243_) {
8893 		ValaGirParserMetadata* _tmp246_;
8894 		_tmp246_ = self->priv->metadata;
8895 		return_array_length_idx = vala_gir_parser_metadata_get_integer (_tmp246_, VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_IDX);
8896 	} else {
8897 		gboolean _tmp247_ = FALSE;
8898 		if (return_no_array_length) {
8899 			_tmp247_ = TRUE;
8900 		} else {
8901 			_tmp247_ = return_array_null_terminated;
8902 		}
8903 		if (_tmp247_) {
8904 			ValaSymbol* _tmp248_;
8905 			_tmp248_ = s;
8906 			vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp248_, "CCode", "array_length", !return_no_array_length, NULL);
8907 		}
8908 		if (return_array_null_terminated) {
8909 			ValaSymbol* _tmp249_;
8910 			_tmp249_ = s;
8911 			vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp249_, "CCode", "array_null_terminated", TRUE, NULL);
8912 		}
8913 	}
8914 	_tmp250_ = self->priv->current;
8915 	_tmp250_->return_array_length_idx = return_array_length_idx;
8916 	_tmp251_ = ctype;
8917 	if (_tmp251_ != NULL) {
8918 		ValaSymbol* _tmp252_;
8919 		const gchar* _tmp253_;
8920 		_tmp252_ = s;
8921 		_tmp253_ = ctype;
8922 		vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp252_, "CCode", "type", _tmp253_, NULL);
8923 	}
8924 	_tmp254_ = self->priv->current;
8925 	_tmp255_ = s;
8926 	_tmp256_ = _vala_code_node_ref0 (_tmp255_);
8927 	_vala_code_node_unref0 (_tmp254_->symbol);
8928 	_tmp254_->symbol = _tmp256_;
8929 	_tmp257_ = self->priv->metadata;
8930 	if (vala_gir_parser_metadata_has_argument (_tmp257_, VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_NAME)) {
8931 		ValaSymbol* _tmp258_;
8932 		ValaGirParserMetadata* _tmp259_;
8933 		gchar* _tmp260_;
8934 		gchar* _tmp261_;
8935 		_tmp258_ = s;
8936 		_tmp259_ = self->priv->metadata;
8937 		_tmp260_ = vala_gir_parser_metadata_get_string (_tmp259_, VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_NAME);
8938 		_tmp261_ = _tmp260_;
8939 		vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp258_, "CCode", "finish_name", _tmp261_, NULL);
8940 		_g_free0 (_tmp261_);
8941 	}
8942 	_tmp262_ = self->priv->metadata;
8943 	if (vala_gir_parser_metadata_has_argument (_tmp262_, VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_INSTANCE)) {
8944 		ValaSymbol* _tmp263_;
8945 		ValaGirParserMetadata* _tmp264_;
8946 		_tmp263_ = s;
8947 		_tmp264_ = self->priv->metadata;
8948 		vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp263_, "CCode", "finish_instance", vala_gir_parser_metadata_get_bool (_tmp264_, VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_INSTANCE, FALSE), NULL);
8949 	}
8950 	instance_idx = -2;
8951 	if (g_strcmp0 (element_name, "function") == 0) {
8952 		const gchar* _tmp266_;
8953 		_tmp266_ = symbol_type;
8954 		_tmp265_ = g_strcmp0 (_tmp266_, "method") == 0;
8955 	} else {
8956 		_tmp265_ = FALSE;
8957 	}
8958 	if (_tmp265_) {
8959 		ValaGirParserMetadata* _tmp267_;
8960 		_tmp267_ = self->priv->metadata;
8961 		if (vala_gir_parser_metadata_has_argument (_tmp267_, VALA_GIR_PARSER_ARGUMENT_TYPE_INSTANCE_IDX)) {
8962 			ValaGirParserMetadata* _tmp268_;
8963 			_tmp268_ = self->priv->metadata;
8964 			instance_idx = vala_gir_parser_metadata_get_integer (_tmp268_, VALA_GIR_PARSER_ARGUMENT_TYPE_INSTANCE_IDX);
8965 			if (instance_idx != 0) {
8966 				ValaSymbol* _tmp269_;
8967 				_tmp269_ = s;
8968 				vala_code_node_set_attribute_double ((ValaCodeNode*) _tmp269_, "CCode", "instance_pos", instance_idx + 0.5, NULL);
8969 			}
8970 		} else {
8971 			ValaSourceReference* _tmp270_;
8972 			ValaSourceReference* _tmp271_;
8973 			_tmp270_ = vala_gir_parser_get_current_src (self);
8974 			_tmp271_ = _tmp270_;
8975 			vala_report_error (_tmp271_, "instance_idx required when converting function to method");
8976 			_vala_source_reference_unref0 (_tmp271_);
8977 		}
8978 	}
8979 	_tmp272_ = g_direct_equal;
8980 	_tmp273_ = vala_array_list_new (VALA_GIR_PARSER_TYPE_PARAMETER_INFO, (GBoxedCopyFunc) vala_gir_parser_parameter_info_ref, (GDestroyNotify) vala_gir_parser_parameter_info_unref, _tmp272_);
8981 	parameters = _tmp273_;
8982 	_tmp274_ = self->priv->current;
8983 	_tmp275_ = g_direct_equal;
8984 	_tmp276_ = vala_array_list_new (G_TYPE_INT, NULL, NULL, _tmp275_);
8985 	_vala_iterable_unref0 (_tmp274_->array_length_parameters);
8986 	_tmp274_->array_length_parameters = _tmp276_;
8987 	_tmp277_ = self->priv->current;
8988 	_tmp278_ = g_direct_equal;
8989 	_tmp279_ = vala_array_list_new (G_TYPE_INT, NULL, NULL, _tmp278_);
8990 	_vala_iterable_unref0 (_tmp277_->closure_parameters);
8991 	_tmp277_->closure_parameters = _tmp279_;
8992 	_tmp280_ = self->priv->current;
8993 	_tmp281_ = g_direct_equal;
8994 	_tmp282_ = vala_array_list_new (G_TYPE_INT, NULL, NULL, _tmp281_);
8995 	_vala_iterable_unref0 (_tmp280_->destroy_parameters);
8996 	_tmp280_->destroy_parameters = _tmp282_;
8997 	_tmp284_ = self->priv->current_token;
8998 	if (_tmp284_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT) {
8999 		ValaMarkupReader* _tmp285_;
9000 		const gchar* _tmp286_;
9001 		const gchar* _tmp287_;
9002 		_tmp285_ = self->priv->reader;
9003 		_tmp286_ = vala_markup_reader_get_name (_tmp285_);
9004 		_tmp287_ = _tmp286_;
9005 		_tmp283_ = g_strcmp0 (_tmp287_, "parameters") == 0;
9006 	} else {
9007 		_tmp283_ = FALSE;
9008 	}
9009 	if (_tmp283_) {
9010 		gint current_parameter_idx = 0;
9011 		vala_gir_parser_start_element (self, "parameters");
9012 		vala_gir_parser_next (self);
9013 		current_parameter_idx = -1;
9014 		while (TRUE) {
9015 			ValaMarkupTokenType _tmp288_;
9016 			gint _tmp289_;
9017 			gboolean _tmp290_ = FALSE;
9018 			ValaMarkupReader* _tmp291_;
9019 			const gchar* _tmp292_;
9020 			const gchar* _tmp293_;
9021 			gboolean is_instance_parameter = FALSE;
9022 			gboolean _tmp297_ = FALSE;
9023 			gint array_length_idx = 0;
9024 			gint closure_idx = 0;
9025 			gint destroy_idx = 0;
9026 			gchar* scope = NULL;
9027 			gchar* default_param_name = NULL;
9028 			ValaComment* param_comment = NULL;
9029 			ValaArrayList* _tmp298_;
9030 			gint _tmp299_;
9031 			gint _tmp300_;
9032 			gchar* _tmp301_;
9033 			ValaParameter* param = NULL;
9034 			const gchar* _tmp302_;
9035 			gint _tmp303_ = 0;
9036 			gint _tmp304_ = 0;
9037 			gint _tmp305_ = 0;
9038 			gchar* _tmp306_ = NULL;
9039 			ValaComment* _tmp307_ = NULL;
9040 			ValaParameter* _tmp308_;
9041 			ValaComment* _tmp337_;
9042 			ValaGirParserParameterInfo* info = NULL;
9043 			ValaParameter* _tmp354_;
9044 			const gchar* _tmp355_;
9045 			ValaGirParserParameterInfo* _tmp356_;
9046 			ValaArrayList* _tmp357_;
9047 			ValaGirParserParameterInfo* _tmp358_;
9048 			_tmp288_ = self->priv->current_token;
9049 			if (!(_tmp288_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT)) {
9050 				break;
9051 			}
9052 			_tmp289_ = current_parameter_idx;
9053 			current_parameter_idx = _tmp289_ + 1;
9054 			_tmp291_ = self->priv->reader;
9055 			_tmp292_ = vala_markup_reader_get_name (_tmp291_);
9056 			_tmp293_ = _tmp292_;
9057 			if (g_strcmp0 (_tmp293_, "instance-parameter") == 0) {
9058 				gboolean _tmp294_ = FALSE;
9059 				const gchar* _tmp295_;
9060 				_tmp295_ = symbol_type;
9061 				if (g_strcmp0 (_tmp295_, "function") == 0) {
9062 					_tmp294_ = TRUE;
9063 				} else {
9064 					const gchar* _tmp296_;
9065 					_tmp296_ = symbol_type;
9066 					_tmp294_ = g_strcmp0 (_tmp296_, "constructor") == 0;
9067 				}
9068 				_tmp290_ = !_tmp294_;
9069 			} else {
9070 				_tmp290_ = FALSE;
9071 			}
9072 			is_instance_parameter = _tmp290_;
9073 			if (instance_idx > -2) {
9074 				_tmp297_ = instance_idx == current_parameter_idx;
9075 			} else {
9076 				_tmp297_ = FALSE;
9077 			}
9078 			if (_tmp297_) {
9079 				vala_gir_parser_skip_element (self);
9080 				continue;
9081 			}
9082 			if (!vala_gir_parser_push_metadata (self)) {
9083 				vala_gir_parser_skip_element (self);
9084 				continue;
9085 			}
9086 			default_param_name = NULL;
9087 			_tmp298_ = parameters;
9088 			_tmp299_ = vala_collection_get_size ((ValaCollection*) _tmp298_);
9089 			_tmp300_ = _tmp299_;
9090 			_tmp301_ = g_strdup_printf ("arg%d", _tmp300_);
9091 			_g_free0 (default_param_name);
9092 			default_param_name = _tmp301_;
9093 			_tmp302_ = default_param_name;
9094 			_tmp308_ = vala_gir_parser_parse_parameter (self, &_tmp303_, &_tmp304_, &_tmp305_, &_tmp306_, &_tmp307_, _tmp302_);
9095 			array_length_idx = _tmp303_;
9096 			closure_idx = _tmp304_;
9097 			destroy_idx = _tmp305_;
9098 			_g_free0 (scope);
9099 			scope = _tmp306_;
9100 			_vala_comment_unref0 (param_comment);
9101 			param_comment = _tmp307_;
9102 			param = _tmp308_;
9103 			if (is_instance_parameter) {
9104 				ValaMethod* m = NULL;
9105 				ValaSymbol* _tmp309_;
9106 				ValaMethod* _tmp310_;
9107 				_tmp309_ = s;
9108 				m = VALA_IS_METHOD (_tmp309_) ? ((ValaMethod*) _tmp309_) : NULL;
9109 				_tmp310_ = m;
9110 				if (_tmp310_ != NULL) {
9111 					ValaParameter* _tmp311_;
9112 					ValaParameterDirection _tmp312_;
9113 					ValaParameterDirection _tmp313_;
9114 					_tmp311_ = param;
9115 					_tmp312_ = vala_parameter_get_direction (_tmp311_);
9116 					_tmp313_ = _tmp312_;
9117 					if (_tmp313_ == VALA_PARAMETER_DIRECTION_IN) {
9118 						ValaParameter* _tmp314_;
9119 						ValaDataType* _tmp315_;
9120 						ValaDataType* _tmp316_;
9121 						gboolean _tmp317_;
9122 						gboolean _tmp318_;
9123 						_tmp314_ = param;
9124 						_tmp315_ = vala_variable_get_variable_type ((ValaVariable*) _tmp314_);
9125 						_tmp316_ = _tmp315_;
9126 						_tmp317_ = vala_data_type_get_value_owned (_tmp316_);
9127 						_tmp318_ = _tmp317_;
9128 						if (_tmp318_) {
9129 							ValaMethod* _tmp319_;
9130 							_tmp319_ = m;
9131 							vala_code_node_set_attribute ((ValaCodeNode*) _tmp319_, "DestroysInstance", TRUE, NULL);
9132 						}
9133 						vala_gir_parser_pop_metadata (self);
9134 						_vala_code_node_unref0 (param);
9135 						_vala_comment_unref0 (param_comment);
9136 						_g_free0 (default_param_name);
9137 						_g_free0 (scope);
9138 						continue;
9139 					} else {
9140 						ValaMethod* _tmp320_;
9141 						_tmp320_ = m;
9142 						vala_method_set_binding (_tmp320_, VALA_MEMBER_BINDING_STATIC);
9143 					}
9144 				}
9145 			}
9146 			if (array_length_idx != -1) {
9147 				gboolean _tmp321_ = FALSE;
9148 				ValaGirParserNode* _tmp323_;
9149 				ValaArrayList* _tmp324_;
9150 				if (instance_idx > -2) {
9151 					_tmp321_ = instance_idx < array_length_idx;
9152 				} else {
9153 					_tmp321_ = FALSE;
9154 				}
9155 				if (_tmp321_) {
9156 					gint _tmp322_;
9157 					_tmp322_ = array_length_idx;
9158 					array_length_idx = _tmp322_ - 1;
9159 				}
9160 				_tmp323_ = self->priv->current;
9161 				_tmp324_ = _tmp323_->array_length_parameters;
9162 				vala_collection_add ((ValaCollection*) _tmp324_, (gpointer) ((gintptr) array_length_idx));
9163 			}
9164 			if (closure_idx != -1) {
9165 				gboolean _tmp325_ = FALSE;
9166 				ValaGirParserNode* _tmp327_;
9167 				ValaArrayList* _tmp328_;
9168 				if (instance_idx > -2) {
9169 					_tmp325_ = instance_idx < closure_idx;
9170 				} else {
9171 					_tmp325_ = FALSE;
9172 				}
9173 				if (_tmp325_) {
9174 					gint _tmp326_;
9175 					_tmp326_ = closure_idx;
9176 					closure_idx = _tmp326_ - 1;
9177 				}
9178 				_tmp327_ = self->priv->current;
9179 				_tmp328_ = _tmp327_->closure_parameters;
9180 				if (vala_list_index_of ((ValaList*) _tmp328_, (gpointer) ((gintptr) current_parameter_idx)) < 0) {
9181 					ValaGirParserNode* _tmp329_;
9182 					ValaArrayList* _tmp330_;
9183 					_tmp329_ = self->priv->current;
9184 					_tmp330_ = _tmp329_->closure_parameters;
9185 					vala_collection_add ((ValaCollection*) _tmp330_, (gpointer) ((gintptr) closure_idx));
9186 				}
9187 			}
9188 			if (destroy_idx != -1) {
9189 				gboolean _tmp331_ = FALSE;
9190 				ValaGirParserNode* _tmp333_;
9191 				ValaArrayList* _tmp334_;
9192 				if (instance_idx > -2) {
9193 					_tmp331_ = instance_idx < destroy_idx;
9194 				} else {
9195 					_tmp331_ = FALSE;
9196 				}
9197 				if (_tmp331_) {
9198 					gint _tmp332_;
9199 					_tmp332_ = destroy_idx;
9200 					destroy_idx = _tmp332_ - 1;
9201 				}
9202 				_tmp333_ = self->priv->current;
9203 				_tmp334_ = _tmp333_->destroy_parameters;
9204 				if (vala_list_index_of ((ValaList*) _tmp334_, (gpointer) ((gintptr) current_parameter_idx)) < 0) {
9205 					ValaGirParserNode* _tmp335_;
9206 					ValaArrayList* _tmp336_;
9207 					_tmp335_ = self->priv->current;
9208 					_tmp336_ = _tmp335_->destroy_parameters;
9209 					vala_collection_add ((ValaCollection*) _tmp336_, (gpointer) ((gintptr) destroy_idx));
9210 				}
9211 			}
9212 			_tmp337_ = param_comment;
9213 			if (_tmp337_ != NULL) {
9214 				ValaGirComment* _tmp338_;
9215 				const gchar* _tmp345_ = NULL;
9216 				ValaParameter* _tmp346_;
9217 				gboolean _tmp347_;
9218 				gboolean _tmp348_;
9219 				ValaGirComment* _tmp352_;
9220 				ValaComment* _tmp353_;
9221 				_tmp338_ = comment;
9222 				if (_tmp338_ == NULL) {
9223 					ValaSymbol* _tmp339_;
9224 					ValaSourceReference* _tmp340_;
9225 					ValaSourceReference* _tmp341_;
9226 					ValaGirComment* _tmp342_;
9227 					ValaSymbol* _tmp343_;
9228 					ValaGirComment* _tmp344_;
9229 					_tmp339_ = s;
9230 					_tmp340_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp339_);
9231 					_tmp341_ = _tmp340_;
9232 					_tmp342_ = vala_gir_comment_new (NULL, _tmp341_);
9233 					_vala_comment_unref0 (comment);
9234 					comment = _tmp342_;
9235 					_tmp343_ = s;
9236 					_tmp344_ = comment;
9237 					vala_symbol_set_comment (_tmp343_, (ValaComment*) _tmp344_);
9238 				}
9239 				_tmp346_ = param;
9240 				_tmp347_ = vala_parameter_get_ellipsis (_tmp346_);
9241 				_tmp348_ = _tmp347_;
9242 				if (_tmp348_) {
9243 					_tmp345_ = "...";
9244 				} else {
9245 					ValaParameter* _tmp349_;
9246 					const gchar* _tmp350_;
9247 					const gchar* _tmp351_;
9248 					_tmp349_ = param;
9249 					_tmp350_ = vala_symbol_get_name ((ValaSymbol*) _tmp349_);
9250 					_tmp351_ = _tmp350_;
9251 					_tmp345_ = _tmp351_;
9252 				}
9253 				_tmp352_ = comment;
9254 				_tmp353_ = param_comment;
9255 				vala_gir_comment_add_content_for_parameter (_tmp352_, _tmp345_, _tmp353_);
9256 			}
9257 			_tmp354_ = param;
9258 			_tmp355_ = scope;
9259 			_tmp356_ = vala_gir_parser_parameter_info_new (_tmp354_, array_length_idx, closure_idx, destroy_idx, g_strcmp0 (_tmp355_, "async") == 0);
9260 			info = _tmp356_;
9261 			_tmp357_ = parameters;
9262 			_tmp358_ = info;
9263 			vala_collection_add ((ValaCollection*) _tmp357_, _tmp358_);
9264 			vala_gir_parser_pop_metadata (self);
9265 			_vala_gir_parser_parameter_info_unref0 (info);
9266 			_vala_code_node_unref0 (param);
9267 			_vala_comment_unref0 (param_comment);
9268 			_g_free0 (default_param_name);
9269 			_g_free0 (scope);
9270 		}
9271 		vala_gir_parser_end_element (self, "parameters");
9272 	}
9273 	_tmp359_ = self->priv->current;
9274 	_tmp360_ = parameters;
9275 	_tmp361_ = _vala_iterable_ref0 ((ValaList*) _tmp360_);
9276 	_vala_iterable_unref0 (_tmp359_->parameters);
9277 	_tmp359_->parameters = _tmp361_;
9278 	vala_gir_parser_pop_node (self);
9279 	vala_gir_parser_end_element (self, element_name);
9280 	_vala_iterable_unref0 (parameters);
9281 	_vala_code_node_unref0 (array_type);
9282 	_vala_code_node_unref0 (s);
9283 	_g_free0 (return_ctype);
9284 	_vala_code_node_unref0 (return_type);
9285 	_vala_comment_unref0 (comment);
9286 	_g_free0 (invoker);
9287 	_g_free0 (throws_string);
9288 	_g_free0 (name);
9289 	_g_free0 (ctype);
9290 	_g_free0 (symbol_type);
9291 }
9292 
9293 static void
vala_gir_parser_parse_method(ValaGirParser * self,const gchar * element_name)9294 vala_gir_parser_parse_method (ValaGirParser* self,
9295                               const gchar* element_name)
9296 {
9297 	g_return_if_fail (self != NULL);
9298 	g_return_if_fail (element_name != NULL);
9299 	vala_gir_parser_parse_function (self, element_name);
9300 }
9301 
9302 static void
vala_gir_parser_parse_signal(ValaGirParser * self)9303 vala_gir_parser_parse_signal (ValaGirParser* self)
9304 {
9305 	g_return_if_fail (self != NULL);
9306 	vala_gir_parser_parse_function (self, "glib:signal");
9307 }
9308 
9309 static void
vala_gir_parser_parse_boxed(ValaGirParser * self,const gchar * element_name)9310 vala_gir_parser_parse_boxed (ValaGirParser* self,
9311                              const gchar* element_name)
9312 {
9313 	gchar* name = NULL;
9314 	ValaMarkupReader* _tmp0_;
9315 	gchar* _tmp1_;
9316 	const gchar* _tmp2_;
9317 	const gchar* _tmp5_;
9318 	gchar* _tmp6_;
9319 	gchar* _tmp7_;
9320 	ValaClass* cl = NULL;
9321 	gboolean require_copy_free = FALSE;
9322 	ValaGirParserNode* _tmp8_;
9323 	ValaClass* _tmp24_;
9324 	ValaClass* _tmp25_;
9325 	ValaClass* _tmp26_;
9326 	ValaGirParserMetadata* _tmp27_;
9327 	ValaClass* _tmp37_;
9328 	ValaGirComment* _tmp38_;
9329 	ValaGirComment* _tmp39_;
9330 	ValaGirParserNode* ref_method = NULL;
9331 	ValaGirParserNode* unref_method = NULL;
9332 	gboolean _tmp84_ = FALSE;
9333 	gboolean _tmp85_ = FALSE;
9334 	gboolean _tmp86_ = FALSE;
9335 	ValaClass* _tmp87_;
9336 	g_return_if_fail (self != NULL);
9337 	g_return_if_fail (element_name != NULL);
9338 	vala_gir_parser_start_element (self, element_name);
9339 	_tmp0_ = self->priv->reader;
9340 	_tmp1_ = vala_markup_reader_get_attribute (_tmp0_, "name");
9341 	name = _tmp1_;
9342 	_tmp2_ = name;
9343 	if (_tmp2_ == NULL) {
9344 		ValaMarkupReader* _tmp3_;
9345 		gchar* _tmp4_;
9346 		_tmp3_ = self->priv->reader;
9347 		_tmp4_ = vala_markup_reader_get_attribute (_tmp3_, "glib:name");
9348 		_g_free0 (name);
9349 		name = _tmp4_;
9350 	}
9351 	_tmp5_ = name;
9352 	_tmp6_ = vala_gir_parser_element_get_name (self, _tmp5_);
9353 	_tmp7_ = _tmp6_;
9354 	vala_gir_parser_push_node (self, _tmp7_, TRUE);
9355 	_g_free0 (_tmp7_);
9356 	require_copy_free = FALSE;
9357 	_tmp8_ = self->priv->current;
9358 	if (_tmp8_->new_symbol) {
9359 		ValaGirParserNode* _tmp9_;
9360 		const gchar* _tmp10_;
9361 		ValaGirParserNode* _tmp11_;
9362 		ValaSourceReference* _tmp12_;
9363 		ValaClass* _tmp13_;
9364 		ValaGirParserMetadata* _tmp14_;
9365 		ValaGirParserNode* _tmp18_;
9366 		ValaClass* _tmp19_;
9367 		ValaSymbol* _tmp20_;
9368 		_tmp9_ = self->priv->current;
9369 		_tmp10_ = _tmp9_->name;
9370 		_tmp11_ = self->priv->current;
9371 		_tmp12_ = _tmp11_->source_reference;
9372 		_tmp13_ = vala_class_new (_tmp10_, _tmp12_, NULL);
9373 		_vala_code_node_unref0 (cl);
9374 		cl = _tmp13_;
9375 		_tmp14_ = self->priv->metadata;
9376 		if (vala_gir_parser_metadata_has_argument (_tmp14_, VALA_GIR_PARSER_ARGUMENT_TYPE_COMPACT)) {
9377 			ValaClass* _tmp15_;
9378 			ValaGirParserMetadata* _tmp16_;
9379 			_tmp15_ = cl;
9380 			_tmp16_ = self->priv->metadata;
9381 			vala_class_set_is_compact (_tmp15_, vala_gir_parser_metadata_get_bool (_tmp16_, VALA_GIR_PARSER_ARGUMENT_TYPE_COMPACT, FALSE));
9382 		} else {
9383 			ValaClass* _tmp17_;
9384 			_tmp17_ = cl;
9385 			vala_class_set_is_compact (_tmp17_, TRUE);
9386 		}
9387 		_tmp18_ = self->priv->current;
9388 		_tmp19_ = cl;
9389 		_tmp20_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp19_);
9390 		_vala_code_node_unref0 (_tmp18_->symbol);
9391 		_tmp18_->symbol = _tmp20_;
9392 	} else {
9393 		ValaGirParserNode* _tmp21_;
9394 		ValaSymbol* _tmp22_;
9395 		ValaClass* _tmp23_;
9396 		_tmp21_ = self->priv->current;
9397 		_tmp22_ = _tmp21_->symbol;
9398 		_tmp23_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp22_, VALA_TYPE_CLASS, ValaClass));
9399 		_vala_code_node_unref0 (cl);
9400 		cl = _tmp23_;
9401 	}
9402 	_tmp24_ = cl;
9403 	vala_gir_parser_set_type_id_ccode (self, (ValaSymbol*) _tmp24_);
9404 	_tmp25_ = cl;
9405 	require_copy_free = vala_code_node_has_attribute_argument ((ValaCodeNode*) _tmp25_, "CCode", "type_id");
9406 	_tmp26_ = cl;
9407 	vala_symbol_set_access ((ValaSymbol*) _tmp26_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
9408 	_tmp27_ = self->priv->metadata;
9409 	if (vala_gir_parser_metadata_has_argument (_tmp27_, VALA_GIR_PARSER_ARGUMENT_TYPE_BASE_TYPE)) {
9410 		ValaClass* _tmp28_;
9411 		ValaGirParserMetadata* _tmp29_;
9412 		gchar* _tmp30_;
9413 		gchar* _tmp31_;
9414 		ValaGirParserMetadata* _tmp32_;
9415 		ValaSourceReference* _tmp33_;
9416 		ValaSourceReference* _tmp34_;
9417 		ValaDataType* _tmp35_;
9418 		ValaDataType* _tmp36_;
9419 		_tmp28_ = cl;
9420 		_tmp29_ = self->priv->metadata;
9421 		_tmp30_ = vala_gir_parser_metadata_get_string (_tmp29_, VALA_GIR_PARSER_ARGUMENT_TYPE_BASE_TYPE);
9422 		_tmp31_ = _tmp30_;
9423 		_tmp32_ = self->priv->metadata;
9424 		_tmp33_ = vala_gir_parser_metadata_get_source_reference (_tmp32_, VALA_GIR_PARSER_ARGUMENT_TYPE_BASE_TYPE);
9425 		_tmp34_ = _tmp33_;
9426 		_tmp35_ = vala_gir_parser_parse_type_from_string (self, _tmp31_, TRUE, _tmp34_);
9427 		_tmp36_ = _tmp35_;
9428 		vala_class_add_base_type (_tmp28_, _tmp36_);
9429 		_vala_code_node_unref0 (_tmp36_);
9430 		_vala_source_reference_unref0 (_tmp34_);
9431 		_g_free0 (_tmp31_);
9432 	}
9433 	vala_gir_parser_next (self);
9434 	_tmp37_ = cl;
9435 	_tmp38_ = vala_gir_parser_parse_symbol_doc (self);
9436 	_tmp39_ = _tmp38_;
9437 	vala_symbol_set_comment ((ValaSymbol*) _tmp37_, (ValaComment*) _tmp39_);
9438 	_vala_comment_unref0 (_tmp39_);
9439 	ref_method = NULL;
9440 	unref_method = NULL;
9441 	while (TRUE) {
9442 		ValaMarkupTokenType _tmp40_;
9443 		ValaMarkupReader* _tmp41_;
9444 		const gchar* _tmp42_;
9445 		const gchar* _tmp43_;
9446 		_tmp40_ = self->priv->current_token;
9447 		if (!(_tmp40_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT)) {
9448 			break;
9449 		}
9450 		if (!vala_gir_parser_push_metadata (self)) {
9451 			vala_gir_parser_skip_element (self);
9452 			continue;
9453 		}
9454 		_tmp41_ = self->priv->reader;
9455 		_tmp42_ = vala_markup_reader_get_name (_tmp41_);
9456 		_tmp43_ = _tmp42_;
9457 		if (g_strcmp0 (_tmp43_, "field") == 0) {
9458 			vala_gir_parser_parse_field (self);
9459 		} else {
9460 			ValaMarkupReader* _tmp44_;
9461 			const gchar* _tmp45_;
9462 			const gchar* _tmp46_;
9463 			_tmp44_ = self->priv->reader;
9464 			_tmp45_ = vala_markup_reader_get_name (_tmp44_);
9465 			_tmp46_ = _tmp45_;
9466 			if (g_strcmp0 (_tmp46_, "constructor") == 0) {
9467 				vala_gir_parser_parse_constructor (self);
9468 			} else {
9469 				ValaMarkupReader* _tmp47_;
9470 				const gchar* _tmp48_;
9471 				const gchar* _tmp49_;
9472 				_tmp47_ = self->priv->reader;
9473 				_tmp48_ = vala_markup_reader_get_name (_tmp47_);
9474 				_tmp49_ = _tmp48_;
9475 				if (g_strcmp0 (_tmp49_, "method") == 0) {
9476 					gchar* cname = NULL;
9477 					ValaGirParserNode* _tmp50_;
9478 					gchar* _tmp51_;
9479 					gboolean _tmp52_ = FALSE;
9480 					const gchar* _tmp53_;
9481 					vala_gir_parser_parse_method (self, "method");
9482 					_tmp50_ = self->priv->old_current;
9483 					_tmp51_ = vala_gir_parser_node_get_cname (_tmp50_);
9484 					cname = _tmp51_;
9485 					_tmp53_ = cname;
9486 					if (g_str_has_suffix (_tmp53_, "_ref")) {
9487 						gboolean _tmp54_ = FALSE;
9488 						ValaGirParserNode* _tmp55_;
9489 						_tmp55_ = ref_method;
9490 						if (_tmp55_ == NULL) {
9491 							_tmp54_ = TRUE;
9492 						} else {
9493 							ValaGirParserNode* _tmp56_;
9494 							const gchar* _tmp57_;
9495 							_tmp56_ = self->priv->old_current;
9496 							_tmp57_ = _tmp56_->name;
9497 							_tmp54_ = g_strcmp0 (_tmp57_, "ref") == 0;
9498 						}
9499 						_tmp52_ = _tmp54_;
9500 					} else {
9501 						_tmp52_ = FALSE;
9502 					}
9503 					if (_tmp52_) {
9504 						ValaGirParserNode* _tmp58_;
9505 						ValaGirParserNode* _tmp59_;
9506 						_tmp58_ = self->priv->old_current;
9507 						_tmp59_ = _vala_gir_parser_node_ref0 (_tmp58_);
9508 						_vala_gir_parser_node_unref0 (ref_method);
9509 						ref_method = _tmp59_;
9510 					} else {
9511 						gboolean _tmp60_ = FALSE;
9512 						const gchar* _tmp61_;
9513 						_tmp61_ = cname;
9514 						if (g_str_has_suffix (_tmp61_, "_unref")) {
9515 							gboolean _tmp62_ = FALSE;
9516 							ValaGirParserNode* _tmp63_;
9517 							_tmp63_ = unref_method;
9518 							if (_tmp63_ == NULL) {
9519 								_tmp62_ = TRUE;
9520 							} else {
9521 								ValaGirParserNode* _tmp64_;
9522 								const gchar* _tmp65_;
9523 								_tmp64_ = self->priv->old_current;
9524 								_tmp65_ = _tmp64_->name;
9525 								_tmp62_ = g_strcmp0 (_tmp65_, "unref") == 0;
9526 							}
9527 							_tmp60_ = _tmp62_;
9528 						} else {
9529 							_tmp60_ = FALSE;
9530 						}
9531 						if (_tmp60_) {
9532 							ValaGirParserNode* _tmp66_;
9533 							ValaGirParserNode* _tmp67_;
9534 							_tmp66_ = self->priv->old_current;
9535 							_tmp67_ = _vala_gir_parser_node_ref0 (_tmp66_);
9536 							_vala_gir_parser_node_unref0 (unref_method);
9537 							unref_method = _tmp67_;
9538 						}
9539 					}
9540 					_g_free0 (cname);
9541 				} else {
9542 					ValaMarkupReader* _tmp68_;
9543 					const gchar* _tmp69_;
9544 					const gchar* _tmp70_;
9545 					_tmp68_ = self->priv->reader;
9546 					_tmp69_ = vala_markup_reader_get_name (_tmp68_);
9547 					_tmp70_ = _tmp69_;
9548 					if (g_strcmp0 (_tmp70_, "function") == 0) {
9549 						vala_gir_parser_skip_element (self);
9550 					} else {
9551 						ValaMarkupReader* _tmp71_;
9552 						const gchar* _tmp72_;
9553 						const gchar* _tmp73_;
9554 						_tmp71_ = self->priv->reader;
9555 						_tmp72_ = vala_markup_reader_get_name (_tmp71_);
9556 						_tmp73_ = _tmp72_;
9557 						if (g_strcmp0 (_tmp73_, "function-macro") == 0) {
9558 							vala_gir_parser_skip_element (self);
9559 						} else {
9560 							ValaMarkupReader* _tmp74_;
9561 							const gchar* _tmp75_;
9562 							const gchar* _tmp76_;
9563 							_tmp74_ = self->priv->reader;
9564 							_tmp75_ = vala_markup_reader_get_name (_tmp74_);
9565 							_tmp76_ = _tmp75_;
9566 							if (g_strcmp0 (_tmp76_, "union") == 0) {
9567 								vala_gir_parser_parse_union (self);
9568 							} else {
9569 								ValaSourceReference* _tmp77_;
9570 								ValaSourceReference* _tmp78_;
9571 								ValaMarkupReader* _tmp79_;
9572 								const gchar* _tmp80_;
9573 								const gchar* _tmp81_;
9574 								gchar* _tmp82_;
9575 								gchar* _tmp83_;
9576 								_tmp77_ = vala_gir_parser_get_current_src (self);
9577 								_tmp78_ = _tmp77_;
9578 								_tmp79_ = self->priv->reader;
9579 								_tmp80_ = vala_markup_reader_get_name (_tmp79_);
9580 								_tmp81_ = _tmp80_;
9581 								_tmp82_ = g_strdup_printf ("unknown child element `%s' in `class'", _tmp81_);
9582 								_tmp83_ = _tmp82_;
9583 								vala_report_error (_tmp78_, _tmp83_);
9584 								_g_free0 (_tmp83_);
9585 								_vala_source_reference_unref0 (_tmp78_);
9586 								vala_gir_parser_skip_element (self);
9587 							}
9588 						}
9589 					}
9590 				}
9591 			}
9592 		}
9593 		vala_gir_parser_pop_metadata (self);
9594 	}
9595 	_tmp87_ = cl;
9596 	if (vala_code_node_has_attribute_argument ((ValaCodeNode*) _tmp87_, "CCode", "ref_function")) {
9597 		_tmp86_ = TRUE;
9598 	} else {
9599 		ValaClass* _tmp88_;
9600 		_tmp88_ = cl;
9601 		_tmp86_ = vala_code_node_has_attribute_argument ((ValaCodeNode*) _tmp88_, "CCode", "unref_function");
9602 	}
9603 	if (_tmp86_) {
9604 		_tmp85_ = TRUE;
9605 	} else {
9606 		ValaClass* _tmp89_;
9607 		_tmp89_ = cl;
9608 		_tmp85_ = vala_code_node_has_attribute_argument ((ValaCodeNode*) _tmp89_, "CCode", "copy_function");
9609 	}
9610 	if (_tmp85_) {
9611 		_tmp84_ = TRUE;
9612 	} else {
9613 		ValaClass* _tmp90_;
9614 		_tmp90_ = cl;
9615 		_tmp84_ = vala_code_node_has_attribute_argument ((ValaCodeNode*) _tmp90_, "CCode", "free_function");
9616 	}
9617 	if (_tmp84_) {
9618 	} else {
9619 		gboolean _tmp91_ = FALSE;
9620 		ValaGirParserNode* _tmp92_;
9621 		_tmp92_ = ref_method;
9622 		if (_tmp92_ != NULL) {
9623 			ValaGirParserNode* _tmp93_;
9624 			_tmp93_ = unref_method;
9625 			_tmp91_ = _tmp93_ != NULL;
9626 		} else {
9627 			_tmp91_ = FALSE;
9628 		}
9629 		if (_tmp91_) {
9630 			ValaClass* _tmp94_;
9631 			ValaGirParserNode* _tmp95_;
9632 			gchar* _tmp96_;
9633 			gchar* _tmp97_;
9634 			ValaClass* _tmp98_;
9635 			ValaGirParserNode* _tmp99_;
9636 			gchar* _tmp100_;
9637 			gchar* _tmp101_;
9638 			_tmp94_ = cl;
9639 			_tmp95_ = ref_method;
9640 			_tmp96_ = vala_gir_parser_node_get_cname (_tmp95_);
9641 			_tmp97_ = _tmp96_;
9642 			vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp94_, "CCode", "ref_function", _tmp97_, NULL);
9643 			_g_free0 (_tmp97_);
9644 			_tmp98_ = cl;
9645 			_tmp99_ = unref_method;
9646 			_tmp100_ = vala_gir_parser_node_get_cname (_tmp99_);
9647 			_tmp101_ = _tmp100_;
9648 			vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp98_, "CCode", "unref_function", _tmp101_, NULL);
9649 			_g_free0 (_tmp101_);
9650 		} else {
9651 			if (require_copy_free) {
9652 				ValaClass* _tmp102_;
9653 				ValaClass* _tmp103_;
9654 				_tmp102_ = cl;
9655 				vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp102_, "CCode", "copy_function", "g_boxed_copy", NULL);
9656 				_tmp103_ = cl;
9657 				vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp103_, "CCode", "free_function", "g_boxed_free", NULL);
9658 			}
9659 		}
9660 	}
9661 	vala_gir_parser_pop_node (self);
9662 	vala_gir_parser_end_element (self, element_name);
9663 	_vala_gir_parser_node_unref0 (unref_method);
9664 	_vala_gir_parser_node_unref0 (ref_method);
9665 	_vala_code_node_unref0 (cl);
9666 	_g_free0 (name);
9667 }
9668 
9669 static void
vala_gir_parser_parse_union(ValaGirParser * self)9670 vala_gir_parser_parse_union (ValaGirParser* self)
9671 {
9672 	gchar* element_name = NULL;
9673 	gchar* _tmp0_;
9674 	const gchar* _tmp1_;
9675 	const gchar* _tmp15_;
9676 	ValaStruct* st = NULL;
9677 	ValaGirParserNode* _tmp16_;
9678 	ValaStruct* _tmp29_;
9679 	ValaStruct* _tmp30_;
9680 	ValaGirComment* _tmp31_;
9681 	ValaGirComment* _tmp32_;
9682 	g_return_if_fail (self != NULL);
9683 	vala_gir_parser_start_element (self, "union");
9684 	_tmp0_ = vala_gir_parser_element_get_name (self, NULL);
9685 	element_name = _tmp0_;
9686 	_tmp1_ = element_name;
9687 	if (_tmp1_ == NULL) {
9688 		ValaGirComment* _tmp2_;
9689 		ValaGirComment* _tmp3_;
9690 		vala_gir_parser_next (self);
9691 		_tmp2_ = vala_gir_parser_parse_symbol_doc (self);
9692 		_tmp3_ = _tmp2_;
9693 		_vala_comment_unref0 (_tmp3_);
9694 		while (TRUE) {
9695 			ValaMarkupTokenType _tmp4_;
9696 			ValaMarkupReader* _tmp5_;
9697 			const gchar* _tmp6_;
9698 			const gchar* _tmp7_;
9699 			_tmp4_ = self->priv->current_token;
9700 			if (!(_tmp4_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT)) {
9701 				break;
9702 			}
9703 			if (!vala_gir_parser_push_metadata (self)) {
9704 				vala_gir_parser_skip_element (self);
9705 				continue;
9706 			}
9707 			_tmp5_ = self->priv->reader;
9708 			_tmp6_ = vala_markup_reader_get_name (_tmp5_);
9709 			_tmp7_ = _tmp6_;
9710 			if (g_strcmp0 (_tmp7_, "field") == 0) {
9711 				vala_gir_parser_parse_field (self);
9712 			} else {
9713 				ValaSourceReference* _tmp8_;
9714 				ValaSourceReference* _tmp9_;
9715 				ValaMarkupReader* _tmp10_;
9716 				const gchar* _tmp11_;
9717 				const gchar* _tmp12_;
9718 				gchar* _tmp13_;
9719 				gchar* _tmp14_;
9720 				_tmp8_ = vala_gir_parser_get_current_src (self);
9721 				_tmp9_ = _tmp8_;
9722 				_tmp10_ = self->priv->reader;
9723 				_tmp11_ = vala_markup_reader_get_name (_tmp10_);
9724 				_tmp12_ = _tmp11_;
9725 				_tmp13_ = g_strdup_printf ("unknown child element `%s' in `transparent union'", _tmp12_);
9726 				_tmp14_ = _tmp13_;
9727 				vala_report_error (_tmp9_, _tmp14_);
9728 				_g_free0 (_tmp14_);
9729 				_vala_source_reference_unref0 (_tmp9_);
9730 				vala_gir_parser_skip_element (self);
9731 			}
9732 			vala_gir_parser_pop_metadata (self);
9733 		}
9734 		vala_gir_parser_end_element (self, "union");
9735 		_g_free0 (element_name);
9736 		return;
9737 	}
9738 	_tmp15_ = element_name;
9739 	vala_gir_parser_push_node (self, _tmp15_, TRUE);
9740 	_tmp16_ = self->priv->current;
9741 	if (_tmp16_->new_symbol) {
9742 		ValaMarkupReader* _tmp17_;
9743 		gchar* _tmp18_;
9744 		gchar* _tmp19_;
9745 		ValaGirParserNode* _tmp20_;
9746 		ValaSourceReference* _tmp21_;
9747 		ValaStruct* _tmp22_;
9748 		ValaGirParserNode* _tmp23_;
9749 		ValaStruct* _tmp24_;
9750 		ValaSymbol* _tmp25_;
9751 		_tmp17_ = self->priv->reader;
9752 		_tmp18_ = vala_markup_reader_get_attribute (_tmp17_, "name");
9753 		_tmp19_ = _tmp18_;
9754 		_tmp20_ = self->priv->current;
9755 		_tmp21_ = _tmp20_->source_reference;
9756 		_tmp22_ = vala_struct_new (_tmp19_, _tmp21_, NULL);
9757 		_vala_code_node_unref0 (st);
9758 		st = _tmp22_;
9759 		_g_free0 (_tmp19_);
9760 		_tmp23_ = self->priv->current;
9761 		_tmp24_ = st;
9762 		_tmp25_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp24_);
9763 		_vala_code_node_unref0 (_tmp23_->symbol);
9764 		_tmp23_->symbol = _tmp25_;
9765 	} else {
9766 		ValaGirParserNode* _tmp26_;
9767 		ValaSymbol* _tmp27_;
9768 		ValaStruct* _tmp28_;
9769 		_tmp26_ = self->priv->current;
9770 		_tmp27_ = _tmp26_->symbol;
9771 		_tmp28_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp27_, VALA_TYPE_STRUCT, ValaStruct));
9772 		_vala_code_node_unref0 (st);
9773 		st = _tmp28_;
9774 	}
9775 	_tmp29_ = st;
9776 	vala_symbol_set_access ((ValaSymbol*) _tmp29_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
9777 	vala_gir_parser_next (self);
9778 	_tmp30_ = st;
9779 	_tmp31_ = vala_gir_parser_parse_symbol_doc (self);
9780 	_tmp32_ = _tmp31_;
9781 	vala_symbol_set_comment ((ValaSymbol*) _tmp30_, (ValaComment*) _tmp32_);
9782 	_vala_comment_unref0 (_tmp32_);
9783 	while (TRUE) {
9784 		ValaMarkupTokenType _tmp33_;
9785 		ValaMarkupReader* _tmp34_;
9786 		const gchar* _tmp35_;
9787 		const gchar* _tmp36_;
9788 		_tmp33_ = self->priv->current_token;
9789 		if (!(_tmp33_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT)) {
9790 			break;
9791 		}
9792 		if (!vala_gir_parser_push_metadata (self)) {
9793 			vala_gir_parser_skip_element (self);
9794 			continue;
9795 		}
9796 		_tmp34_ = self->priv->reader;
9797 		_tmp35_ = vala_markup_reader_get_name (_tmp34_);
9798 		_tmp36_ = _tmp35_;
9799 		if (g_strcmp0 (_tmp36_, "field") == 0) {
9800 			vala_gir_parser_parse_field (self);
9801 		} else {
9802 			ValaMarkupReader* _tmp37_;
9803 			const gchar* _tmp38_;
9804 			const gchar* _tmp39_;
9805 			_tmp37_ = self->priv->reader;
9806 			_tmp38_ = vala_markup_reader_get_name (_tmp37_);
9807 			_tmp39_ = _tmp38_;
9808 			if (g_strcmp0 (_tmp39_, "constructor") == 0) {
9809 				vala_gir_parser_parse_constructor (self);
9810 			} else {
9811 				ValaMarkupReader* _tmp40_;
9812 				const gchar* _tmp41_;
9813 				const gchar* _tmp42_;
9814 				_tmp40_ = self->priv->reader;
9815 				_tmp41_ = vala_markup_reader_get_name (_tmp40_);
9816 				_tmp42_ = _tmp41_;
9817 				if (g_strcmp0 (_tmp42_, "method") == 0) {
9818 					vala_gir_parser_parse_method (self, "method");
9819 				} else {
9820 					ValaMarkupReader* _tmp43_;
9821 					const gchar* _tmp44_;
9822 					const gchar* _tmp45_;
9823 					_tmp43_ = self->priv->reader;
9824 					_tmp44_ = vala_markup_reader_get_name (_tmp43_);
9825 					_tmp45_ = _tmp44_;
9826 					if (g_strcmp0 (_tmp45_, "function") == 0) {
9827 						vala_gir_parser_skip_element (self);
9828 					} else {
9829 						ValaMarkupReader* _tmp46_;
9830 						const gchar* _tmp47_;
9831 						const gchar* _tmp48_;
9832 						_tmp46_ = self->priv->reader;
9833 						_tmp47_ = vala_markup_reader_get_name (_tmp46_);
9834 						_tmp48_ = _tmp47_;
9835 						if (g_strcmp0 (_tmp48_, "function-macro") == 0) {
9836 							vala_gir_parser_skip_element (self);
9837 						} else {
9838 							ValaMarkupReader* _tmp49_;
9839 							const gchar* _tmp50_;
9840 							const gchar* _tmp51_;
9841 							_tmp49_ = self->priv->reader;
9842 							_tmp50_ = vala_markup_reader_get_name (_tmp49_);
9843 							_tmp51_ = _tmp50_;
9844 							if (g_strcmp0 (_tmp51_, "record") == 0) {
9845 								vala_gir_parser_parse_record (self);
9846 							} else {
9847 								ValaSourceReference* _tmp52_;
9848 								ValaSourceReference* _tmp53_;
9849 								ValaMarkupReader* _tmp54_;
9850 								const gchar* _tmp55_;
9851 								const gchar* _tmp56_;
9852 								gchar* _tmp57_;
9853 								gchar* _tmp58_;
9854 								_tmp52_ = vala_gir_parser_get_current_src (self);
9855 								_tmp53_ = _tmp52_;
9856 								_tmp54_ = self->priv->reader;
9857 								_tmp55_ = vala_markup_reader_get_name (_tmp54_);
9858 								_tmp56_ = _tmp55_;
9859 								_tmp57_ = g_strdup_printf ("unknown child element `%s' in `union'", _tmp56_);
9860 								_tmp58_ = _tmp57_;
9861 								vala_report_error (_tmp53_, _tmp58_);
9862 								_g_free0 (_tmp58_);
9863 								_vala_source_reference_unref0 (_tmp53_);
9864 								vala_gir_parser_skip_element (self);
9865 							}
9866 						}
9867 					}
9868 				}
9869 			}
9870 		}
9871 		vala_gir_parser_pop_metadata (self);
9872 	}
9873 	vala_gir_parser_pop_node (self);
9874 	vala_gir_parser_end_element (self, "union");
9875 	_vala_code_node_unref0 (st);
9876 	_g_free0 (element_name);
9877 }
9878 
9879 static void
vala_gir_parser_parse_constant(ValaGirParser * self)9880 vala_gir_parser_parse_constant (ValaGirParser* self)
9881 {
9882 	gchar* _tmp0_;
9883 	gchar* _tmp1_;
9884 	ValaGirComment* comment = NULL;
9885 	ValaGirComment* _tmp2_;
9886 	gboolean no_array_length = FALSE;
9887 	gboolean array_null_terminated = FALSE;
9888 	gint array_length_idx = 0;
9889 	ValaDataType* type = NULL;
9890 	gint _tmp3_ = 0;
9891 	gboolean _tmp4_ = FALSE;
9892 	gboolean _tmp5_ = FALSE;
9893 	ValaDataType* _tmp6_;
9894 	ValaDataType* _tmp7_;
9895 	ValaDataType* _tmp8_;
9896 	ValaConstant* c = NULL;
9897 	ValaGirParserNode* _tmp9_;
9898 	const gchar* _tmp10_;
9899 	ValaDataType* _tmp11_;
9900 	ValaGirParserNode* _tmp12_;
9901 	ValaSourceReference* _tmp13_;
9902 	ValaConstant* _tmp14_;
9903 	ValaGirParserNode* _tmp15_;
9904 	ValaConstant* _tmp16_;
9905 	ValaSymbol* _tmp17_;
9906 	ValaConstant* _tmp18_;
9907 	ValaConstant* _tmp19_;
9908 	ValaGirComment* _tmp20_;
9909 	gboolean _tmp21_ = FALSE;
9910 	g_return_if_fail (self != NULL);
9911 	vala_gir_parser_start_element (self, "constant");
9912 	_tmp0_ = vala_gir_parser_element_get_name (self, NULL);
9913 	_tmp1_ = _tmp0_;
9914 	vala_gir_parser_push_node (self, _tmp1_, FALSE);
9915 	_g_free0 (_tmp1_);
9916 	vala_gir_parser_next (self);
9917 	_tmp2_ = vala_gir_parser_parse_symbol_doc (self);
9918 	comment = _tmp2_;
9919 	_tmp6_ = vala_gir_parser_parse_type (self, NULL, &_tmp3_, TRUE, &_tmp4_, &_tmp5_);
9920 	array_length_idx = _tmp3_;
9921 	no_array_length = _tmp4_;
9922 	array_null_terminated = _tmp5_;
9923 	type = _tmp6_;
9924 	_tmp7_ = type;
9925 	_tmp8_ = vala_gir_parser_element_get_type (self, _tmp7_, TRUE, &no_array_length, &array_null_terminated, NULL);
9926 	_vala_code_node_unref0 (type);
9927 	type = _tmp8_;
9928 	_tmp9_ = self->priv->current;
9929 	_tmp10_ = _tmp9_->name;
9930 	_tmp11_ = type;
9931 	_tmp12_ = self->priv->current;
9932 	_tmp13_ = _tmp12_->source_reference;
9933 	_tmp14_ = vala_constant_new (_tmp10_, _tmp11_, NULL, _tmp13_, NULL);
9934 	c = _tmp14_;
9935 	_tmp15_ = self->priv->current;
9936 	_tmp16_ = c;
9937 	_tmp17_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp16_);
9938 	_vala_code_node_unref0 (_tmp15_->symbol);
9939 	_tmp15_->symbol = _tmp17_;
9940 	_tmp18_ = c;
9941 	vala_symbol_set_access ((ValaSymbol*) _tmp18_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
9942 	_tmp19_ = c;
9943 	_tmp20_ = comment;
9944 	vala_symbol_set_comment ((ValaSymbol*) _tmp19_, (ValaComment*) _tmp20_);
9945 	if (no_array_length) {
9946 		_tmp21_ = TRUE;
9947 	} else {
9948 		_tmp21_ = array_null_terminated;
9949 	}
9950 	if (_tmp21_) {
9951 		ValaConstant* _tmp22_;
9952 		_tmp22_ = c;
9953 		vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp22_, "CCode", "array_length", !no_array_length, NULL);
9954 	}
9955 	if (array_null_terminated) {
9956 		ValaConstant* _tmp23_;
9957 		_tmp23_ = c;
9958 		vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp23_, "CCode", "array_null_terminated", TRUE, NULL);
9959 	}
9960 	vala_gir_parser_pop_node (self);
9961 	vala_gir_parser_end_element (self, "constant");
9962 	_vala_code_node_unref0 (c);
9963 	_vala_code_node_unref0 (type);
9964 	_vala_comment_unref0 (comment);
9965 }
9966 
9967 static void
vala_gir_parser_report_unused_metadata(ValaGirParser * self,ValaGirParserMetadata * metadata)9968 vala_gir_parser_report_unused_metadata (ValaGirParser* self,
9969                                         ValaGirParserMetadata* metadata)
9970 {
9971 	ValaGirParserMetadata* _tmp0_;
9972 	ValaGirParserMetadata* _tmp1_;
9973 	gboolean _tmp2_ = FALSE;
9974 	ValaMap* _tmp3_;
9975 	gint _tmp4_;
9976 	gint _tmp5_;
9977 	g_return_if_fail (self != NULL);
9978 	g_return_if_fail (metadata != NULL);
9979 	_tmp0_ = vala_gir_parser_metadata_get_empty ();
9980 	_tmp1_ = _tmp0_;
9981 	if (metadata == _tmp1_) {
9982 		return;
9983 	}
9984 	_tmp3_ = metadata->args;
9985 	_tmp4_ = vala_map_get_size (_tmp3_);
9986 	_tmp5_ = _tmp4_;
9987 	if (_tmp5_ == 0) {
9988 		ValaArrayList* _tmp6_;
9989 		gint _tmp7_;
9990 		gint _tmp8_;
9991 		_tmp6_ = metadata->children;
9992 		_tmp7_ = vala_collection_get_size ((ValaCollection*) _tmp6_);
9993 		_tmp8_ = _tmp7_;
9994 		_tmp2_ = _tmp8_ == 0;
9995 	} else {
9996 		_tmp2_ = FALSE;
9997 	}
9998 	if (_tmp2_) {
9999 		ValaSourceReference* _tmp9_;
10000 		_tmp9_ = metadata->source_reference;
10001 		vala_report_warning (_tmp9_, "empty metadata");
10002 		return;
10003 	}
10004 	{
10005 		ValaIterator* _arg_type_it = NULL;
10006 		ValaMap* _tmp10_;
10007 		ValaSet* _tmp11_;
10008 		ValaSet* _tmp12_;
10009 		ValaIterator* _tmp13_;
10010 		ValaIterator* _tmp14_;
10011 		_tmp10_ = metadata->args;
10012 		_tmp11_ = vala_map_get_keys (_tmp10_);
10013 		_tmp12_ = _tmp11_;
10014 		_tmp13_ = vala_iterable_iterator ((ValaIterable*) _tmp12_);
10015 		_tmp14_ = _tmp13_;
10016 		_vala_iterable_unref0 (_tmp12_);
10017 		_arg_type_it = _tmp14_;
10018 		while (TRUE) {
10019 			ValaIterator* _tmp15_;
10020 			ValaGirParserArgumentType arg_type = 0;
10021 			ValaIterator* _tmp16_;
10022 			gpointer _tmp17_;
10023 			ValaGirParserArgument* arg = NULL;
10024 			ValaMap* _tmp18_;
10025 			ValaGirParserArgumentType _tmp19_;
10026 			gpointer _tmp20_;
10027 			ValaGirParserArgument* _tmp21_;
10028 			_tmp15_ = _arg_type_it;
10029 			if (!vala_iterator_next (_tmp15_)) {
10030 				break;
10031 			}
10032 			_tmp16_ = _arg_type_it;
10033 			_tmp17_ = vala_iterator_get (_tmp16_);
10034 			arg_type = (ValaGirParserArgumentType) ((gintptr) _tmp17_);
10035 			_tmp18_ = metadata->args;
10036 			_tmp19_ = arg_type;
10037 			_tmp20_ = vala_map_get (_tmp18_, (gpointer) ((gintptr) _tmp19_));
10038 			arg = (ValaGirParserArgument*) _tmp20_;
10039 			_tmp21_ = arg;
10040 			if (!_tmp21_->used) {
10041 				ValaGirParserArgument* _tmp22_;
10042 				ValaSourceReference* _tmp23_;
10043 				_tmp22_ = arg;
10044 				_tmp23_ = _tmp22_->source_reference;
10045 				vala_report_warning (_tmp23_, "argument never used");
10046 			}
10047 			_vala_gir_parser_argument_unref0 (arg);
10048 		}
10049 		_vala_iterator_unref0 (_arg_type_it);
10050 	}
10051 	{
10052 		ValaArrayList* _child_list = NULL;
10053 		ValaArrayList* _tmp24_;
10054 		ValaArrayList* _tmp25_;
10055 		gint _child_size = 0;
10056 		ValaArrayList* _tmp26_;
10057 		gint _tmp27_;
10058 		gint _tmp28_;
10059 		gint _child_index = 0;
10060 		_tmp24_ = metadata->children;
10061 		_tmp25_ = _vala_iterable_ref0 (_tmp24_);
10062 		_child_list = _tmp25_;
10063 		_tmp26_ = _child_list;
10064 		_tmp27_ = vala_collection_get_size ((ValaCollection*) _tmp26_);
10065 		_tmp28_ = _tmp27_;
10066 		_child_size = _tmp28_;
10067 		_child_index = -1;
10068 		while (TRUE) {
10069 			gint _tmp29_;
10070 			gint _tmp30_;
10071 			ValaGirParserMetadata* child = NULL;
10072 			ValaArrayList* _tmp31_;
10073 			gpointer _tmp32_;
10074 			ValaGirParserMetadata* _tmp33_;
10075 			_child_index = _child_index + 1;
10076 			_tmp29_ = _child_index;
10077 			_tmp30_ = _child_size;
10078 			if (!(_tmp29_ < _tmp30_)) {
10079 				break;
10080 			}
10081 			_tmp31_ = _child_list;
10082 			_tmp32_ = vala_list_get ((ValaList*) _tmp31_, _child_index);
10083 			child = (ValaGirParserMetadata*) _tmp32_;
10084 			_tmp33_ = child;
10085 			if (!_tmp33_->used) {
10086 				ValaGirParserMetadata* _tmp34_;
10087 				ValaSourceReference* _tmp35_;
10088 				_tmp34_ = child;
10089 				_tmp35_ = _tmp34_->source_reference;
10090 				vala_report_warning (_tmp35_, "metadata never used");
10091 			} else {
10092 				ValaGirParserMetadata* _tmp36_;
10093 				_tmp36_ = child;
10094 				vala_gir_parser_report_unused_metadata (self, _tmp36_);
10095 			}
10096 			_vala_gir_parser_metadata_unref0 (child);
10097 		}
10098 		_vala_iterable_unref0 (_child_list);
10099 	}
10100 }
10101 
10102 static void
vala_gir_parser_resolve_gir_symbols(ValaGirParser * self)10103 vala_gir_parser_resolve_gir_symbols (ValaGirParser* self)
10104 {
10105 	g_return_if_fail (self != NULL);
10106 	{
10107 		ValaArrayList* _map_from_list = NULL;
10108 		ValaArrayList* _tmp0_;
10109 		ValaArrayList* _tmp1_;
10110 		gint _map_from_size = 0;
10111 		ValaArrayList* _tmp2_;
10112 		gint _tmp3_;
10113 		gint _tmp4_;
10114 		gint _map_from_index = 0;
10115 		_tmp0_ = self->priv->unresolved_gir_symbols;
10116 		_tmp1_ = _vala_iterable_ref0 (_tmp0_);
10117 		_map_from_list = _tmp1_;
10118 		_tmp2_ = _map_from_list;
10119 		_tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
10120 		_tmp4_ = _tmp3_;
10121 		_map_from_size = _tmp4_;
10122 		_map_from_index = -1;
10123 		while (TRUE) {
10124 			gint _tmp5_;
10125 			gint _tmp6_;
10126 			ValaUnresolvedSymbol* map_from = NULL;
10127 			ValaArrayList* _tmp7_;
10128 			gpointer _tmp8_;
10129 			_map_from_index = _map_from_index + 1;
10130 			_tmp5_ = _map_from_index;
10131 			_tmp6_ = _map_from_size;
10132 			if (!(_tmp5_ < _tmp6_)) {
10133 				break;
10134 			}
10135 			_tmp7_ = _map_from_list;
10136 			_tmp8_ = vala_list_get ((ValaList*) _tmp7_, _map_from_index);
10137 			map_from = (ValaUnresolvedSymbol*) _tmp8_;
10138 			while (TRUE) {
10139 				ValaUnresolvedSymbol* _tmp9_;
10140 				ValaSymbol* map_to = NULL;
10141 				ValaHashMap* _tmp10_;
10142 				ValaUnresolvedSymbol* _tmp11_;
10143 				gpointer _tmp12_;
10144 				ValaSymbol* _tmp13_;
10145 				ValaUnresolvedSymbol* _tmp63_;
10146 				ValaUnresolvedSymbol* _tmp64_;
10147 				ValaUnresolvedSymbol* _tmp65_;
10148 				ValaUnresolvedSymbol* _tmp66_;
10149 				_tmp9_ = map_from;
10150 				if (!(_tmp9_ != NULL)) {
10151 					break;
10152 				}
10153 				_tmp10_ = self->priv->unresolved_symbols_map;
10154 				_tmp11_ = map_from;
10155 				_tmp12_ = vala_map_get ((ValaMap*) _tmp10_, _tmp11_);
10156 				map_to = (ValaSymbol*) _tmp12_;
10157 				_tmp13_ = map_to;
10158 				if (_tmp13_ != NULL) {
10159 					ValaUnresolvedSymbol* _tmp14_;
10160 					ValaUnresolvedSymbol* _tmp15_;
10161 					ValaSymbol* _tmp16_;
10162 					const gchar* _tmp17_;
10163 					const gchar* _tmp18_;
10164 					ValaSymbol* _tmp19_;
10165 					_tmp14_ = map_from;
10166 					vala_unresolved_symbol_set_inner (_tmp14_, NULL);
10167 					_tmp15_ = map_from;
10168 					_tmp16_ = map_to;
10169 					_tmp17_ = vala_symbol_get_name (_tmp16_);
10170 					_tmp18_ = _tmp17_;
10171 					vala_symbol_set_name ((ValaSymbol*) _tmp15_, _tmp18_);
10172 					_tmp19_ = map_to;
10173 					if (VALA_IS_UNRESOLVED_SYMBOL (_tmp19_)) {
10174 						ValaUnresolvedSymbol* umap_to = NULL;
10175 						ValaSymbol* _tmp20_;
10176 						ValaUnresolvedSymbol* _tmp21_;
10177 						_tmp20_ = map_to;
10178 						_tmp21_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp20_, VALA_TYPE_UNRESOLVED_SYMBOL, ValaUnresolvedSymbol));
10179 						umap_to = _tmp21_;
10180 						while (TRUE) {
10181 							ValaUnresolvedSymbol* _tmp22_;
10182 							ValaUnresolvedSymbol* _tmp23_;
10183 							ValaUnresolvedSymbol* _tmp24_;
10184 							ValaUnresolvedSymbol* _tmp25_;
10185 							ValaUnresolvedSymbol* _tmp26_;
10186 							ValaUnresolvedSymbol* _tmp27_;
10187 							ValaUnresolvedSymbol* _tmp28_;
10188 							ValaUnresolvedSymbol* _tmp29_;
10189 							ValaUnresolvedSymbol* _tmp30_;
10190 							const gchar* _tmp31_;
10191 							const gchar* _tmp32_;
10192 							ValaUnresolvedSymbol* _tmp33_;
10193 							ValaUnresolvedSymbol* _tmp34_;
10194 							ValaUnresolvedSymbol* _tmp35_;
10195 							ValaUnresolvedSymbol* _tmp36_;
10196 							ValaUnresolvedSymbol* _tmp37_;
10197 							ValaUnresolvedSymbol* _tmp38_;
10198 							_tmp22_ = umap_to;
10199 							_tmp23_ = vala_unresolved_symbol_get_inner (_tmp22_);
10200 							_tmp24_ = _tmp23_;
10201 							if (!(_tmp24_ != NULL)) {
10202 								break;
10203 							}
10204 							_tmp25_ = umap_to;
10205 							_tmp26_ = vala_unresolved_symbol_get_inner (_tmp25_);
10206 							_tmp27_ = _tmp26_;
10207 							_tmp28_ = _vala_code_node_ref0 (_tmp27_);
10208 							_vala_code_node_unref0 (umap_to);
10209 							umap_to = _tmp28_;
10210 							_tmp29_ = map_from;
10211 							_tmp30_ = umap_to;
10212 							_tmp31_ = vala_symbol_get_name ((ValaSymbol*) _tmp30_);
10213 							_tmp32_ = _tmp31_;
10214 							_tmp33_ = vala_unresolved_symbol_new (NULL, _tmp32_, NULL);
10215 							_tmp34_ = _tmp33_;
10216 							vala_unresolved_symbol_set_inner (_tmp29_, _tmp34_);
10217 							_vala_code_node_unref0 (_tmp34_);
10218 							_tmp35_ = map_from;
10219 							_tmp36_ = vala_unresolved_symbol_get_inner (_tmp35_);
10220 							_tmp37_ = _tmp36_;
10221 							_tmp38_ = _vala_code_node_ref0 (_tmp37_);
10222 							_vala_code_node_unref0 (map_from);
10223 							map_from = _tmp38_;
10224 						}
10225 						_vala_code_node_unref0 (umap_to);
10226 					} else {
10227 						while (TRUE) {
10228 							gboolean _tmp39_ = FALSE;
10229 							ValaSymbol* _tmp40_;
10230 							ValaSymbol* _tmp41_;
10231 							ValaSymbol* _tmp42_;
10232 							ValaSymbol* _tmp49_;
10233 							ValaSymbol* _tmp50_;
10234 							ValaSymbol* _tmp51_;
10235 							ValaSymbol* _tmp52_;
10236 							ValaUnresolvedSymbol* _tmp53_;
10237 							ValaSymbol* _tmp54_;
10238 							const gchar* _tmp55_;
10239 							const gchar* _tmp56_;
10240 							ValaUnresolvedSymbol* _tmp57_;
10241 							ValaUnresolvedSymbol* _tmp58_;
10242 							ValaUnresolvedSymbol* _tmp59_;
10243 							ValaUnresolvedSymbol* _tmp60_;
10244 							ValaUnresolvedSymbol* _tmp61_;
10245 							ValaUnresolvedSymbol* _tmp62_;
10246 							_tmp40_ = map_to;
10247 							_tmp41_ = vala_symbol_get_parent_symbol (_tmp40_);
10248 							_tmp42_ = _tmp41_;
10249 							if (_tmp42_ != NULL) {
10250 								ValaSymbol* _tmp43_;
10251 								ValaSymbol* _tmp44_;
10252 								ValaSymbol* _tmp45_;
10253 								ValaCodeContext* _tmp46_;
10254 								ValaNamespace* _tmp47_;
10255 								ValaNamespace* _tmp48_;
10256 								_tmp43_ = map_to;
10257 								_tmp44_ = vala_symbol_get_parent_symbol (_tmp43_);
10258 								_tmp45_ = _tmp44_;
10259 								_tmp46_ = self->priv->context;
10260 								_tmp47_ = vala_code_context_get_root (_tmp46_);
10261 								_tmp48_ = _tmp47_;
10262 								_tmp39_ = _tmp45_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp48_, VALA_TYPE_SYMBOL, ValaSymbol);
10263 							} else {
10264 								_tmp39_ = FALSE;
10265 							}
10266 							if (!_tmp39_) {
10267 								break;
10268 							}
10269 							_tmp49_ = map_to;
10270 							_tmp50_ = vala_symbol_get_parent_symbol (_tmp49_);
10271 							_tmp51_ = _tmp50_;
10272 							_tmp52_ = _vala_code_node_ref0 (_tmp51_);
10273 							_vala_code_node_unref0 (map_to);
10274 							map_to = _tmp52_;
10275 							_tmp53_ = map_from;
10276 							_tmp54_ = map_to;
10277 							_tmp55_ = vala_symbol_get_name (_tmp54_);
10278 							_tmp56_ = _tmp55_;
10279 							_tmp57_ = vala_unresolved_symbol_new (NULL, _tmp56_, NULL);
10280 							_tmp58_ = _tmp57_;
10281 							vala_unresolved_symbol_set_inner (_tmp53_, _tmp58_);
10282 							_vala_code_node_unref0 (_tmp58_);
10283 							_tmp59_ = map_from;
10284 							_tmp60_ = vala_unresolved_symbol_get_inner (_tmp59_);
10285 							_tmp61_ = _tmp60_;
10286 							_tmp62_ = _vala_code_node_ref0 (_tmp61_);
10287 							_vala_code_node_unref0 (map_from);
10288 							map_from = _tmp62_;
10289 						}
10290 					}
10291 					_vala_code_node_unref0 (map_to);
10292 					break;
10293 				}
10294 				_tmp63_ = map_from;
10295 				_tmp64_ = vala_unresolved_symbol_get_inner (_tmp63_);
10296 				_tmp65_ = _tmp64_;
10297 				_tmp66_ = _vala_code_node_ref0 (_tmp65_);
10298 				_vala_code_node_unref0 (map_from);
10299 				map_from = _tmp66_;
10300 				_vala_code_node_unref0 (map_to);
10301 			}
10302 			_vala_code_node_unref0 (map_from);
10303 		}
10304 		_vala_iterable_unref0 (_map_from_list);
10305 	}
10306 }
10307 
10308 static void
vala_gir_parser_create_new_namespaces(ValaGirParser * self)10309 vala_gir_parser_create_new_namespaces (ValaGirParser* self)
10310 {
10311 	g_return_if_fail (self != NULL);
10312 	{
10313 		ValaArrayList* _node_list = NULL;
10314 		ValaArrayList* _tmp0_;
10315 		ValaArrayList* _tmp1_;
10316 		gint _node_size = 0;
10317 		ValaArrayList* _tmp2_;
10318 		gint _tmp3_;
10319 		gint _tmp4_;
10320 		gint _node_index = 0;
10321 		_tmp0_ = vala_gir_parser_node_new_namespaces;
10322 		_tmp1_ = _vala_iterable_ref0 (_tmp0_);
10323 		_node_list = _tmp1_;
10324 		_tmp2_ = _node_list;
10325 		_tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
10326 		_tmp4_ = _tmp3_;
10327 		_node_size = _tmp4_;
10328 		_node_index = -1;
10329 		while (TRUE) {
10330 			gint _tmp5_;
10331 			gint _tmp6_;
10332 			ValaGirParserNode* node = NULL;
10333 			ValaArrayList* _tmp7_;
10334 			gpointer _tmp8_;
10335 			ValaGirParserNode* _tmp9_;
10336 			ValaSymbol* _tmp10_;
10337 			_node_index = _node_index + 1;
10338 			_tmp5_ = _node_index;
10339 			_tmp6_ = _node_size;
10340 			if (!(_tmp5_ < _tmp6_)) {
10341 				break;
10342 			}
10343 			_tmp7_ = _node_list;
10344 			_tmp8_ = vala_list_get ((ValaList*) _tmp7_, _node_index);
10345 			node = (ValaGirParserNode*) _tmp8_;
10346 			_tmp9_ = node;
10347 			_tmp10_ = _tmp9_->symbol;
10348 			if (_tmp10_ == NULL) {
10349 				ValaGirParserNode* _tmp11_;
10350 				ValaGirParserNode* _tmp12_;
10351 				const gchar* _tmp13_;
10352 				ValaGirParserNode* _tmp14_;
10353 				ValaSourceReference* _tmp15_;
10354 				ValaNamespace* _tmp16_;
10355 				_tmp11_ = node;
10356 				_tmp12_ = node;
10357 				_tmp13_ = _tmp12_->name;
10358 				_tmp14_ = node;
10359 				_tmp15_ = _tmp14_->source_reference;
10360 				_tmp16_ = vala_namespace_new (_tmp13_, _tmp15_);
10361 				_vala_code_node_unref0 (_tmp11_->symbol);
10362 				_tmp11_->symbol = (ValaSymbol*) _tmp16_;
10363 			}
10364 			_vala_gir_parser_node_unref0 (node);
10365 		}
10366 		_vala_iterable_unref0 (_node_list);
10367 	}
10368 }
10369 
10370 static void
vala_gir_parser_resolve_type_arguments(ValaGirParser * self)10371 vala_gir_parser_resolve_type_arguments (ValaGirParser* self)
10372 {
10373 	ValaMapIterator* it = NULL;
10374 	ValaHashMap* _tmp0_;
10375 	ValaMapIterator* _tmp1_;
10376 	g_return_if_fail (self != NULL);
10377 	_tmp0_ = self->priv->unresolved_type_arguments;
10378 	_tmp1_ = vala_map_map_iterator ((ValaMap*) _tmp0_);
10379 	it = _tmp1_;
10380 	while (TRUE) {
10381 		ValaMapIterator* _tmp2_;
10382 		ValaUnresolvedType* element_type = NULL;
10383 		ValaMapIterator* _tmp3_;
10384 		gpointer _tmp4_;
10385 		ValaGirParserNode* parent = NULL;
10386 		ValaMapIterator* _tmp5_;
10387 		gpointer _tmp6_;
10388 		ValaTypeSymbol* sym = NULL;
10389 		ValaGirParserNode* _tmp7_;
10390 		ValaUnresolvedType* _tmp8_;
10391 		ValaUnresolvedSymbol* _tmp9_;
10392 		ValaUnresolvedSymbol* _tmp10_;
10393 		ValaSymbol* _tmp11_;
10394 		ValaStruct* st = NULL;
10395 		ValaTypeSymbol* _tmp12_;
10396 		ValaStruct* _tmp13_;
10397 		gboolean _tmp14_ = FALSE;
10398 		gboolean _tmp15_ = FALSE;
10399 		ValaStruct* _tmp16_;
10400 		_tmp2_ = it;
10401 		if (!vala_map_iterator_next (_tmp2_)) {
10402 			break;
10403 		}
10404 		_tmp3_ = it;
10405 		_tmp4_ = vala_map_iterator_get_key (_tmp3_);
10406 		element_type = (ValaUnresolvedType*) _tmp4_;
10407 		_tmp5_ = it;
10408 		_tmp6_ = vala_map_iterator_get_value (_tmp5_);
10409 		parent = (ValaGirParserNode*) _tmp6_;
10410 		_tmp7_ = parent;
10411 		_tmp8_ = element_type;
10412 		_tmp9_ = vala_unresolved_type_get_unresolved_symbol (_tmp8_);
10413 		_tmp10_ = _tmp9_;
10414 		_tmp11_ = vala_gir_parser_resolve_symbol (self, _tmp7_, _tmp10_);
10415 		sym = G_TYPE_CHECK_INSTANCE_CAST (_tmp11_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
10416 		_tmp12_ = sym;
10417 		_tmp13_ = _vala_code_node_ref0 (VALA_IS_STRUCT (_tmp12_) ? ((ValaStruct*) _tmp12_) : NULL);
10418 		st = _tmp13_;
10419 		_tmp16_ = st;
10420 		if (_tmp16_ != NULL) {
10421 			ValaStruct* _tmp17_;
10422 			_tmp17_ = st;
10423 			_tmp15_ = !vala_struct_is_integer_type (_tmp17_);
10424 		} else {
10425 			_tmp15_ = FALSE;
10426 		}
10427 		if (_tmp15_) {
10428 			ValaStruct* _tmp18_;
10429 			_tmp18_ = st;
10430 			_tmp14_ = !vala_struct_is_floating_type (_tmp18_);
10431 		} else {
10432 			_tmp14_ = FALSE;
10433 		}
10434 		if (_tmp14_) {
10435 			ValaUnresolvedType* _tmp19_;
10436 			_tmp19_ = element_type;
10437 			vala_data_type_set_nullable ((ValaDataType*) _tmp19_, TRUE);
10438 		}
10439 		_vala_code_node_unref0 (st);
10440 		_vala_code_node_unref0 (sym);
10441 		_vala_gir_parser_node_unref0 (parent);
10442 		_vala_code_node_unref0 (element_type);
10443 	}
10444 	_vala_map_iterator_unref0 (it);
10445 }
10446 
10447 static void
vala_gir_parser_process_interface(ValaGirParser * self,ValaGirParserNode * iface_node)10448 vala_gir_parser_process_interface (ValaGirParser* self,
10449                                    ValaGirParserNode* iface_node)
10450 {
10451 	ValaInterface* iface = NULL;
10452 	ValaSymbol* _tmp0_;
10453 	ValaInterface* _tmp1_;
10454 	gboolean has_instantiable_prereq = FALSE;
10455 	g_return_if_fail (self != NULL);
10456 	g_return_if_fail (iface_node != NULL);
10457 	_tmp0_ = iface_node->symbol;
10458 	_tmp1_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALA_TYPE_INTERFACE, ValaInterface));
10459 	iface = _tmp1_;
10460 	has_instantiable_prereq = FALSE;
10461 	{
10462 		ValaList* _prereq_list = NULL;
10463 		ValaInterface* _tmp2_;
10464 		ValaList* _tmp3_;
10465 		ValaList* _tmp4_;
10466 		gint _prereq_size = 0;
10467 		ValaList* _tmp5_;
10468 		gint _tmp6_;
10469 		gint _tmp7_;
10470 		gint _prereq_index = 0;
10471 		_tmp2_ = iface;
10472 		_tmp3_ = vala_interface_get_prerequisites (_tmp2_);
10473 		_tmp4_ = _vala_iterable_ref0 (_tmp3_);
10474 		_prereq_list = _tmp4_;
10475 		_tmp5_ = _prereq_list;
10476 		_tmp6_ = vala_collection_get_size ((ValaCollection*) _tmp5_);
10477 		_tmp7_ = _tmp6_;
10478 		_prereq_size = _tmp7_;
10479 		_prereq_index = -1;
10480 		while (TRUE) {
10481 			gint _tmp8_;
10482 			gint _tmp9_;
10483 			ValaDataType* prereq = NULL;
10484 			ValaList* _tmp10_;
10485 			gpointer _tmp11_;
10486 			ValaSymbol* sym = NULL;
10487 			ValaDataType* _tmp12_;
10488 			ValaSymbol* _tmp24_;
10489 			_prereq_index = _prereq_index + 1;
10490 			_tmp8_ = _prereq_index;
10491 			_tmp9_ = _prereq_size;
10492 			if (!(_tmp8_ < _tmp9_)) {
10493 				break;
10494 			}
10495 			_tmp10_ = _prereq_list;
10496 			_tmp11_ = vala_list_get (_tmp10_, _prereq_index);
10497 			prereq = (ValaDataType*) _tmp11_;
10498 			sym = NULL;
10499 			_tmp12_ = prereq;
10500 			if (VALA_IS_UNRESOLVED_TYPE (_tmp12_)) {
10501 				ValaUnresolvedSymbol* unresolved_symbol = NULL;
10502 				ValaDataType* _tmp13_;
10503 				ValaUnresolvedSymbol* _tmp14_;
10504 				ValaUnresolvedSymbol* _tmp15_;
10505 				ValaUnresolvedSymbol* _tmp16_;
10506 				ValaGirParserNode* _tmp17_;
10507 				ValaUnresolvedSymbol* _tmp18_;
10508 				ValaSymbol* _tmp19_;
10509 				_tmp13_ = prereq;
10510 				_tmp14_ = vala_unresolved_type_get_unresolved_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp13_, VALA_TYPE_UNRESOLVED_TYPE, ValaUnresolvedType));
10511 				_tmp15_ = _tmp14_;
10512 				_tmp16_ = _vala_code_node_ref0 (_tmp15_);
10513 				unresolved_symbol = _tmp16_;
10514 				_tmp17_ = iface_node->parent;
10515 				_tmp18_ = unresolved_symbol;
10516 				_tmp19_ = vala_gir_parser_resolve_symbol (self, _tmp17_, _tmp18_);
10517 				_vala_code_node_unref0 (sym);
10518 				sym = _tmp19_;
10519 				_vala_code_node_unref0 (unresolved_symbol);
10520 			} else {
10521 				ValaDataType* _tmp20_;
10522 				ValaTypeSymbol* _tmp21_;
10523 				ValaTypeSymbol* _tmp22_;
10524 				ValaSymbol* _tmp23_;
10525 				_tmp20_ = prereq;
10526 				_tmp21_ = vala_data_type_get_type_symbol (_tmp20_);
10527 				_tmp22_ = _tmp21_;
10528 				_tmp23_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp22_);
10529 				_vala_code_node_unref0 (sym);
10530 				sym = _tmp23_;
10531 			}
10532 			_tmp24_ = sym;
10533 			if (VALA_IS_CLASS (_tmp24_)) {
10534 				has_instantiable_prereq = TRUE;
10535 				_vala_code_node_unref0 (sym);
10536 				_vala_code_node_unref0 (prereq);
10537 				break;
10538 			}
10539 			_vala_code_node_unref0 (sym);
10540 			_vala_code_node_unref0 (prereq);
10541 		}
10542 		_vala_iterable_unref0 (_prereq_list);
10543 	}
10544 	if (!has_instantiable_prereq) {
10545 		ValaArrayList* _tmp25_;
10546 		ValaInterface* _tmp26_;
10547 		_tmp25_ = self->priv->ifaces_needing_object_prereq;
10548 		_tmp26_ = iface;
10549 		vala_collection_add ((ValaCollection*) _tmp25_, _tmp26_);
10550 	}
10551 	_vala_code_node_unref0 (iface);
10552 }
10553 
10554 static void
vala_gir_parser_process_alias(ValaGirParser * self,ValaGirParserNode * alias)10555 vala_gir_parser_process_alias (ValaGirParser* self,
10556                                ValaGirParserNode* alias)
10557 {
10558 	ValaDataType* base_type = NULL;
10559 	ValaSymbol* type_sym = NULL;
10560 	ValaGirParserNode* base_node = NULL;
10561 	gboolean simple_type = FALSE;
10562 	ValaDataType* _tmp0_;
10563 	gboolean _tmp32_ = FALSE;
10564 	ValaSymbol* _tmp33_;
10565 	gboolean _tmp35_ = FALSE;
10566 	gboolean _tmp36_ = FALSE;
10567 	ValaDataType* _tmp37_;
10568 	gboolean _tmp152_ = FALSE;
10569 	ValaSymbol* _tmp153_;
10570 	g_return_if_fail (self != NULL);
10571 	g_return_if_fail (alias != NULL);
10572 	base_type = NULL;
10573 	type_sym = NULL;
10574 	base_node = NULL;
10575 	simple_type = FALSE;
10576 	_tmp0_ = alias->base_type;
10577 	if (VALA_IS_UNRESOLVED_TYPE (_tmp0_)) {
10578 		ValaDataType* _tmp1_;
10579 		ValaDataType* _tmp2_;
10580 		ValaGirParserNode* _tmp3_;
10581 		ValaDataType* _tmp4_;
10582 		ValaUnresolvedSymbol* _tmp5_;
10583 		ValaUnresolvedSymbol* _tmp6_;
10584 		ValaGirParserNode* _tmp7_;
10585 		ValaGirParserNode* _tmp8_;
10586 		_tmp1_ = alias->base_type;
10587 		_tmp2_ = _vala_code_node_ref0 (_tmp1_);
10588 		_vala_code_node_unref0 (base_type);
10589 		base_type = _tmp2_;
10590 		_tmp3_ = alias->parent;
10591 		_tmp4_ = base_type;
10592 		_tmp5_ = vala_unresolved_type_get_unresolved_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp4_, VALA_TYPE_UNRESOLVED_TYPE, ValaUnresolvedType));
10593 		_tmp6_ = _tmp5_;
10594 		_tmp7_ = vala_gir_parser_resolve_node (self, _tmp3_, _tmp6_, FALSE);
10595 		_vala_gir_parser_node_unref0 (base_node);
10596 		base_node = _tmp7_;
10597 		_tmp8_ = base_node;
10598 		if (_tmp8_ != NULL) {
10599 			ValaGirParserNode* _tmp9_;
10600 			ValaSymbol* _tmp10_;
10601 			ValaSymbol* _tmp11_;
10602 			_tmp9_ = base_node;
10603 			_tmp10_ = _tmp9_->symbol;
10604 			_tmp11_ = _vala_code_node_ref0 (_tmp10_);
10605 			_vala_code_node_unref0 (type_sym);
10606 			type_sym = _tmp11_;
10607 		}
10608 	} else {
10609 		gboolean _tmp12_ = FALSE;
10610 		ValaDataType* _tmp13_;
10611 		_tmp13_ = alias->base_type;
10612 		if (VALA_IS_POINTER_TYPE (_tmp13_)) {
10613 			ValaDataType* _tmp14_;
10614 			ValaDataType* _tmp15_;
10615 			ValaDataType* _tmp16_;
10616 			_tmp14_ = alias->base_type;
10617 			_tmp15_ = vala_pointer_type_get_base_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp14_, VALA_TYPE_POINTER_TYPE, ValaPointerType));
10618 			_tmp16_ = _tmp15_;
10619 			_tmp12_ = VALA_IS_VOID_TYPE (_tmp16_);
10620 		} else {
10621 			_tmp12_ = FALSE;
10622 		}
10623 		if (_tmp12_) {
10624 			simple_type = TRUE;
10625 		} else {
10626 			ValaDataType* _tmp17_;
10627 			ValaDataType* _tmp18_;
10628 			ValaDataType* _tmp19_;
10629 			ValaTypeSymbol* _tmp20_;
10630 			ValaTypeSymbol* _tmp21_;
10631 			ValaSymbol* _tmp22_;
10632 			ValaSymbol* _tmp23_;
10633 			_tmp17_ = alias->base_type;
10634 			_tmp18_ = _vala_code_node_ref0 (_tmp17_);
10635 			_vala_code_node_unref0 (base_type);
10636 			base_type = _tmp18_;
10637 			_tmp19_ = base_type;
10638 			_tmp20_ = vala_data_type_get_type_symbol (_tmp19_);
10639 			_tmp21_ = _tmp20_;
10640 			_tmp22_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp21_);
10641 			_vala_code_node_unref0 (type_sym);
10642 			type_sym = _tmp22_;
10643 			_tmp23_ = type_sym;
10644 			if (_tmp23_ != NULL) {
10645 				ValaGirParserNode* _tmp24_;
10646 				ValaSymbol* _tmp25_;
10647 				gchar* _tmp26_;
10648 				gchar* _tmp27_;
10649 				ValaSourceReference* _tmp28_;
10650 				ValaUnresolvedSymbol* _tmp29_;
10651 				ValaUnresolvedSymbol* _tmp30_;
10652 				ValaGirParserNode* _tmp31_;
10653 				_tmp24_ = alias->parent;
10654 				_tmp25_ = type_sym;
10655 				_tmp26_ = vala_symbol_get_full_name (_tmp25_);
10656 				_tmp27_ = _tmp26_;
10657 				_tmp28_ = alias->source_reference;
10658 				_tmp29_ = vala_gir_parser_parse_symbol_from_string (self, _tmp27_, _tmp28_);
10659 				_tmp30_ = _tmp29_;
10660 				_tmp31_ = vala_gir_parser_resolve_node (self, _tmp24_, _tmp30_, FALSE);
10661 				_vala_gir_parser_node_unref0 (base_node);
10662 				base_node = _tmp31_;
10663 				_vala_code_node_unref0 (_tmp30_);
10664 				_g_free0 (_tmp27_);
10665 			}
10666 		}
10667 	}
10668 	_tmp33_ = type_sym;
10669 	if (VALA_IS_STRUCT (_tmp33_)) {
10670 		ValaSymbol* _tmp34_;
10671 		_tmp34_ = type_sym;
10672 		_tmp32_ = vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp34_, VALA_TYPE_STRUCT, ValaStruct));
10673 	} else {
10674 		_tmp32_ = FALSE;
10675 	}
10676 	if (_tmp32_) {
10677 		simple_type = TRUE;
10678 	}
10679 	_tmp37_ = base_type;
10680 	if (_tmp37_ == NULL) {
10681 		_tmp36_ = TRUE;
10682 	} else {
10683 		ValaSymbol* _tmp38_;
10684 		_tmp38_ = type_sym;
10685 		_tmp36_ = _tmp38_ == NULL;
10686 	}
10687 	if (_tmp36_) {
10688 		_tmp35_ = TRUE;
10689 	} else {
10690 		ValaSymbol* _tmp39_;
10691 		_tmp39_ = type_sym;
10692 		_tmp35_ = VALA_IS_STRUCT (_tmp39_);
10693 	}
10694 	if (_tmp35_) {
10695 		ValaStruct* st = NULL;
10696 		const gchar* _tmp40_;
10697 		ValaSourceReference* _tmp41_;
10698 		ValaStruct* _tmp42_;
10699 		ValaStruct* _tmp43_;
10700 		ValaDataType* _tmp44_;
10701 		ValaStruct* _tmp47_;
10702 		ValaGirComment* _tmp48_;
10703 		ValaStruct* _tmp49_;
10704 		ValaStruct* _tmp50_;
10705 		ValaSymbol* _tmp51_;
10706 		_tmp40_ = alias->name;
10707 		_tmp41_ = alias->source_reference;
10708 		_tmp42_ = vala_struct_new (_tmp40_, _tmp41_, NULL);
10709 		st = _tmp42_;
10710 		_tmp43_ = st;
10711 		vala_symbol_set_access ((ValaSymbol*) _tmp43_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
10712 		_tmp44_ = base_type;
10713 		if (_tmp44_ != NULL) {
10714 			ValaStruct* _tmp45_;
10715 			ValaDataType* _tmp46_;
10716 			_tmp45_ = st;
10717 			_tmp46_ = base_type;
10718 			vala_struct_set_base_type (_tmp45_, _tmp46_);
10719 		}
10720 		_tmp47_ = st;
10721 		_tmp48_ = alias->comment;
10722 		vala_symbol_set_comment ((ValaSymbol*) _tmp47_, (ValaComment*) _tmp48_);
10723 		_tmp49_ = st;
10724 		vala_struct_set_simple_type (_tmp49_, simple_type);
10725 		_tmp50_ = st;
10726 		_tmp51_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp50_);
10727 		_vala_code_node_unref0 (alias->symbol);
10728 		alias->symbol = _tmp51_;
10729 		_vala_code_node_unref0 (st);
10730 	} else {
10731 		ValaSymbol* _tmp52_;
10732 		_tmp52_ = type_sym;
10733 		if (VALA_IS_CLASS (_tmp52_)) {
10734 			ValaClass* cl = NULL;
10735 			const gchar* _tmp53_;
10736 			ValaSourceReference* _tmp54_;
10737 			ValaClass* _tmp55_;
10738 			ValaClass* _tmp56_;
10739 			ValaDataType* _tmp57_;
10740 			ValaClass* _tmp60_;
10741 			ValaGirComment* _tmp61_;
10742 			ValaClass* _tmp62_;
10743 			ValaSymbol* _tmp63_;
10744 			gboolean _tmp64_;
10745 			gboolean _tmp65_;
10746 			ValaClass* _tmp66_;
10747 			ValaSymbol* _tmp67_;
10748 			_tmp53_ = alias->name;
10749 			_tmp54_ = alias->source_reference;
10750 			_tmp55_ = vala_class_new (_tmp53_, _tmp54_, NULL);
10751 			cl = _tmp55_;
10752 			_tmp56_ = cl;
10753 			vala_symbol_set_access ((ValaSymbol*) _tmp56_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
10754 			_tmp57_ = base_type;
10755 			if (_tmp57_ != NULL) {
10756 				ValaClass* _tmp58_;
10757 				ValaDataType* _tmp59_;
10758 				_tmp58_ = cl;
10759 				_tmp59_ = base_type;
10760 				vala_class_add_base_type (_tmp58_, _tmp59_);
10761 			}
10762 			_tmp60_ = cl;
10763 			_tmp61_ = alias->comment;
10764 			vala_symbol_set_comment ((ValaSymbol*) _tmp60_, (ValaComment*) _tmp61_);
10765 			_tmp62_ = cl;
10766 			_tmp63_ = type_sym;
10767 			_tmp64_ = vala_class_get_is_compact (G_TYPE_CHECK_INSTANCE_CAST (_tmp63_, VALA_TYPE_CLASS, ValaClass));
10768 			_tmp65_ = _tmp64_;
10769 			vala_class_set_is_compact (_tmp62_, _tmp65_);
10770 			_tmp66_ = cl;
10771 			_tmp67_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp66_);
10772 			_vala_code_node_unref0 (alias->symbol);
10773 			alias->symbol = _tmp67_;
10774 			_vala_code_node_unref0 (cl);
10775 		} else {
10776 			ValaSymbol* _tmp68_;
10777 			_tmp68_ = type_sym;
10778 			if (VALA_IS_INTERFACE (_tmp68_)) {
10779 				ValaInterface* iface = NULL;
10780 				const gchar* _tmp69_;
10781 				ValaSourceReference* _tmp70_;
10782 				ValaInterface* _tmp71_;
10783 				ValaInterface* _tmp72_;
10784 				ValaDataType* _tmp73_;
10785 				ValaInterface* _tmp76_;
10786 				ValaGirComment* _tmp77_;
10787 				ValaInterface* _tmp78_;
10788 				ValaSymbol* _tmp79_;
10789 				_tmp69_ = alias->name;
10790 				_tmp70_ = alias->source_reference;
10791 				_tmp71_ = vala_interface_new (_tmp69_, _tmp70_, NULL);
10792 				iface = _tmp71_;
10793 				_tmp72_ = iface;
10794 				vala_symbol_set_access ((ValaSymbol*) _tmp72_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
10795 				_tmp73_ = base_type;
10796 				if (_tmp73_ != NULL) {
10797 					ValaInterface* _tmp74_;
10798 					ValaDataType* _tmp75_;
10799 					_tmp74_ = iface;
10800 					_tmp75_ = base_type;
10801 					vala_interface_add_prerequisite (_tmp74_, _tmp75_);
10802 				}
10803 				_tmp76_ = iface;
10804 				_tmp77_ = alias->comment;
10805 				vala_symbol_set_comment ((ValaSymbol*) _tmp76_, (ValaComment*) _tmp77_);
10806 				_tmp78_ = iface;
10807 				_tmp79_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp78_);
10808 				_vala_code_node_unref0 (alias->symbol);
10809 				alias->symbol = _tmp79_;
10810 				_vala_code_node_unref0 (iface);
10811 			} else {
10812 				ValaSymbol* _tmp80_;
10813 				_tmp80_ = type_sym;
10814 				if (VALA_IS_DELEGATE (_tmp80_)) {
10815 					ValaDelegate* orig = NULL;
10816 					ValaSymbol* _tmp81_;
10817 					ValaDelegate* _tmp82_;
10818 					ValaGirParserNode* _tmp83_;
10819 					ValaDelegate* deleg = NULL;
10820 					const gchar* _tmp88_;
10821 					ValaDelegate* _tmp89_;
10822 					ValaDataType* _tmp90_;
10823 					ValaDataType* _tmp91_;
10824 					ValaDataType* _tmp92_;
10825 					ValaDataType* _tmp93_;
10826 					ValaSourceReference* _tmp94_;
10827 					ValaDelegate* _tmp95_;
10828 					ValaDelegate* _tmp96_;
10829 					ValaDelegate* _tmp97_;
10830 					ValaDelegate* _tmp98_;
10831 					ValaSymbolAccessibility _tmp99_;
10832 					ValaSymbolAccessibility _tmp100_;
10833 					ValaArrayList* error_types = NULL;
10834 					GEqualFunc _tmp115_;
10835 					ValaArrayList* _tmp116_;
10836 					ValaDelegate* _tmp117_;
10837 					ValaArrayList* _tmp118_;
10838 					ValaSourceReference* _tmp119_;
10839 					ValaDelegate* _tmp133_;
10840 					GList* _tmp134_;
10841 					ValaDelegate* _tmp139_;
10842 					ValaSymbol* _tmp140_;
10843 					_tmp81_ = type_sym;
10844 					_tmp82_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp81_, VALA_TYPE_DELEGATE, ValaDelegate));
10845 					orig = _tmp82_;
10846 					_tmp83_ = base_node;
10847 					if (_tmp83_ != NULL) {
10848 						ValaGirParserNode* _tmp84_;
10849 						ValaGirParserNode* _tmp85_;
10850 						ValaSymbol* _tmp86_;
10851 						ValaDelegate* _tmp87_;
10852 						_tmp84_ = base_node;
10853 						vala_gir_parser_node_process (_tmp84_, self);
10854 						_tmp85_ = base_node;
10855 						_tmp86_ = _tmp85_->symbol;
10856 						_tmp87_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp86_, VALA_TYPE_DELEGATE, ValaDelegate));
10857 						_vala_code_node_unref0 (orig);
10858 						orig = _tmp87_;
10859 					}
10860 					_tmp88_ = alias->name;
10861 					_tmp89_ = orig;
10862 					_tmp90_ = vala_callable_get_return_type ((ValaCallable*) _tmp89_);
10863 					_tmp91_ = _tmp90_;
10864 					_tmp92_ = vala_data_type_copy (_tmp91_);
10865 					_tmp93_ = _tmp92_;
10866 					_tmp94_ = alias->source_reference;
10867 					_tmp95_ = vala_delegate_new (_tmp88_, _tmp93_, _tmp94_, NULL);
10868 					_tmp96_ = _tmp95_;
10869 					_vala_code_node_unref0 (_tmp93_);
10870 					deleg = _tmp96_;
10871 					_tmp97_ = deleg;
10872 					_tmp98_ = orig;
10873 					_tmp99_ = vala_symbol_get_access ((ValaSymbol*) _tmp98_);
10874 					_tmp100_ = _tmp99_;
10875 					vala_symbol_set_access ((ValaSymbol*) _tmp97_, _tmp100_);
10876 					{
10877 						ValaList* _param_list = NULL;
10878 						ValaDelegate* _tmp101_;
10879 						ValaList* _tmp102_;
10880 						ValaList* _tmp103_;
10881 						gint _param_size = 0;
10882 						ValaList* _tmp104_;
10883 						gint _tmp105_;
10884 						gint _tmp106_;
10885 						gint _param_index = 0;
10886 						_tmp101_ = orig;
10887 						_tmp102_ = vala_callable_get_parameters ((ValaCallable*) _tmp101_);
10888 						_tmp103_ = _vala_iterable_ref0 (_tmp102_);
10889 						_param_list = _tmp103_;
10890 						_tmp104_ = _param_list;
10891 						_tmp105_ = vala_collection_get_size ((ValaCollection*) _tmp104_);
10892 						_tmp106_ = _tmp105_;
10893 						_param_size = _tmp106_;
10894 						_param_index = -1;
10895 						while (TRUE) {
10896 							gint _tmp107_;
10897 							gint _tmp108_;
10898 							ValaParameter* param = NULL;
10899 							ValaList* _tmp109_;
10900 							gpointer _tmp110_;
10901 							ValaDelegate* _tmp111_;
10902 							ValaParameter* _tmp112_;
10903 							ValaParameter* _tmp113_;
10904 							ValaParameter* _tmp114_;
10905 							_param_index = _param_index + 1;
10906 							_tmp107_ = _param_index;
10907 							_tmp108_ = _param_size;
10908 							if (!(_tmp107_ < _tmp108_)) {
10909 								break;
10910 							}
10911 							_tmp109_ = _param_list;
10912 							_tmp110_ = vala_list_get (_tmp109_, _param_index);
10913 							param = (ValaParameter*) _tmp110_;
10914 							_tmp111_ = deleg;
10915 							_tmp112_ = param;
10916 							_tmp113_ = vala_parameter_copy (_tmp112_);
10917 							_tmp114_ = _tmp113_;
10918 							vala_callable_add_parameter ((ValaCallable*) _tmp111_, _tmp114_);
10919 							_vala_code_node_unref0 (_tmp114_);
10920 							_vala_code_node_unref0 (param);
10921 						}
10922 						_vala_iterable_unref0 (_param_list);
10923 					}
10924 					_tmp115_ = g_direct_equal;
10925 					_tmp116_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp115_);
10926 					error_types = _tmp116_;
10927 					_tmp117_ = orig;
10928 					_tmp118_ = error_types;
10929 					_tmp119_ = alias->source_reference;
10930 					vala_code_node_get_error_types ((ValaCodeNode*) _tmp117_, (ValaCollection*) _tmp118_, _tmp119_);
10931 					{
10932 						ValaArrayList* _error_type_list = NULL;
10933 						ValaArrayList* _tmp120_;
10934 						ValaArrayList* _tmp121_;
10935 						gint _error_type_size = 0;
10936 						ValaArrayList* _tmp122_;
10937 						gint _tmp123_;
10938 						gint _tmp124_;
10939 						gint _error_type_index = 0;
10940 						_tmp120_ = error_types;
10941 						_tmp121_ = _vala_iterable_ref0 (_tmp120_);
10942 						_error_type_list = _tmp121_;
10943 						_tmp122_ = _error_type_list;
10944 						_tmp123_ = vala_collection_get_size ((ValaCollection*) _tmp122_);
10945 						_tmp124_ = _tmp123_;
10946 						_error_type_size = _tmp124_;
10947 						_error_type_index = -1;
10948 						while (TRUE) {
10949 							gint _tmp125_;
10950 							gint _tmp126_;
10951 							ValaDataType* error_type = NULL;
10952 							ValaArrayList* _tmp127_;
10953 							gpointer _tmp128_;
10954 							ValaDelegate* _tmp129_;
10955 							ValaDataType* _tmp130_;
10956 							ValaDataType* _tmp131_;
10957 							ValaDataType* _tmp132_;
10958 							_error_type_index = _error_type_index + 1;
10959 							_tmp125_ = _error_type_index;
10960 							_tmp126_ = _error_type_size;
10961 							if (!(_tmp125_ < _tmp126_)) {
10962 								break;
10963 							}
10964 							_tmp127_ = _error_type_list;
10965 							_tmp128_ = vala_list_get ((ValaList*) _tmp127_, _error_type_index);
10966 							error_type = (ValaDataType*) _tmp128_;
10967 							_tmp129_ = deleg;
10968 							_tmp130_ = error_type;
10969 							_tmp131_ = vala_data_type_copy (_tmp130_);
10970 							_tmp132_ = _tmp131_;
10971 							vala_delegate_add_error_type (_tmp129_, _tmp132_);
10972 							_vala_code_node_unref0 (_tmp132_);
10973 							_vala_code_node_unref0 (error_type);
10974 						}
10975 						_vala_iterable_unref0 (_error_type_list);
10976 					}
10977 					_tmp133_ = orig;
10978 					_tmp134_ = ((ValaCodeNode*) _tmp133_)->attributes;
10979 					{
10980 						GList* attribute_collection = NULL;
10981 						GList* attribute_it = NULL;
10982 						attribute_collection = _tmp134_;
10983 						for (attribute_it = attribute_collection; attribute_it != NULL; attribute_it = attribute_it->next) {
10984 							ValaAttribute* _tmp135_;
10985 							ValaAttribute* attribute = NULL;
10986 							_tmp135_ = _vala_code_node_ref0 ((ValaAttribute*) attribute_it->data);
10987 							attribute = _tmp135_;
10988 							{
10989 								ValaDelegate* _tmp136_;
10990 								ValaAttribute* _tmp137_;
10991 								ValaAttribute* _tmp138_;
10992 								_tmp136_ = deleg;
10993 								_tmp137_ = attribute;
10994 								_tmp138_ = _vala_code_node_ref0 (_tmp137_);
10995 								((ValaCodeNode*) _tmp136_)->attributes = g_list_append (((ValaCodeNode*) _tmp136_)->attributes, _tmp138_);
10996 								_vala_code_node_unref0 (attribute);
10997 							}
10998 						}
10999 					}
11000 					_tmp139_ = deleg;
11001 					_tmp140_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp139_);
11002 					_vala_code_node_unref0 (alias->symbol);
11003 					alias->symbol = _tmp140_;
11004 					_vala_iterable_unref0 (error_types);
11005 					_vala_code_node_unref0 (deleg);
11006 					_vala_code_node_unref0 (orig);
11007 				} else {
11008 					ValaSymbol* _tmp141_;
11009 					_tmp141_ = type_sym;
11010 					if (_tmp141_ != NULL) {
11011 						ValaSourceReference* _tmp142_;
11012 						gchar* _tmp143_;
11013 						gchar* _tmp144_;
11014 						ValaSymbol* _tmp145_;
11015 						gchar* _tmp146_;
11016 						gchar* _tmp147_;
11017 						gchar* _tmp148_;
11018 						gchar* _tmp149_;
11019 						ValaSymbol* _tmp150_;
11020 						ValaSymbol* _tmp151_;
11021 						_tmp142_ = alias->source_reference;
11022 						_tmp143_ = vala_gir_parser_node_get_full_name (alias);
11023 						_tmp144_ = _tmp143_;
11024 						_tmp145_ = type_sym;
11025 						_tmp146_ = vala_symbol_get_full_name (_tmp145_);
11026 						_tmp147_ = _tmp146_;
11027 						_tmp148_ = g_strdup_printf ("alias `%s' for `%s' is not supported", _tmp144_, _tmp147_);
11028 						_tmp149_ = _tmp148_;
11029 						vala_report_warning (_tmp142_, _tmp149_);
11030 						_g_free0 (_tmp149_);
11031 						_g_free0 (_tmp147_);
11032 						_g_free0 (_tmp144_);
11033 						_tmp150_ = type_sym;
11034 						_tmp151_ = _vala_code_node_ref0 (_tmp150_);
11035 						_vala_code_node_unref0 (alias->symbol);
11036 						alias->symbol = _tmp151_;
11037 						alias->merged = TRUE;
11038 					}
11039 				}
11040 			}
11041 		}
11042 	}
11043 	_tmp153_ = type_sym;
11044 	if (VALA_IS_CLASS (_tmp153_)) {
11045 		_tmp152_ = TRUE;
11046 	} else {
11047 		gboolean _tmp154_ = FALSE;
11048 		ValaSymbol* _tmp155_;
11049 		_tmp155_ = type_sym;
11050 		if (VALA_IS_STRUCT (_tmp155_)) {
11051 			_tmp154_ = !simple_type;
11052 		} else {
11053 			_tmp154_ = FALSE;
11054 		}
11055 		_tmp152_ = _tmp154_;
11056 	}
11057 	if (_tmp152_) {
11058 		ValaSymbol* _tmp156_;
11059 		_tmp156_ = type_sym;
11060 		if (vala_code_node_has_attribute_argument ((ValaCodeNode*) _tmp156_, "CCode", "has_type_id")) {
11061 			ValaSymbol* _tmp157_;
11062 			ValaSymbol* _tmp158_;
11063 			_tmp157_ = alias->symbol;
11064 			_tmp158_ = type_sym;
11065 			vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp157_, "CCode", "has_type_id", vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp158_, "CCode", "has_type_id", FALSE), NULL);
11066 		} else {
11067 			ValaSymbol* _tmp159_;
11068 			_tmp159_ = type_sym;
11069 			if (vala_code_node_has_attribute_argument ((ValaCodeNode*) _tmp159_, "CCode", "type_id")) {
11070 				ValaSymbol* _tmp160_;
11071 				ValaSymbol* _tmp161_;
11072 				gchar* _tmp162_;
11073 				gchar* _tmp163_;
11074 				_tmp160_ = alias->symbol;
11075 				_tmp161_ = type_sym;
11076 				_tmp162_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp161_, "CCode", "type_id", NULL);
11077 				_tmp163_ = _tmp162_;
11078 				vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp160_, "CCode", "type_id", _tmp163_, NULL);
11079 				_g_free0 (_tmp163_);
11080 			}
11081 		}
11082 	}
11083 	_vala_gir_parser_node_unref0 (base_node);
11084 	_vala_code_node_unref0 (type_sym);
11085 	_vala_code_node_unref0 (base_type);
11086 }
11087 
11088 static void
vala_gir_parser_process_callable(ValaGirParser * self,ValaGirParserNode * node)11089 vala_gir_parser_process_callable (ValaGirParser* self,
11090                                   ValaGirParserNode* node)
11091 {
11092 	gboolean _tmp0_ = FALSE;
11093 	const gchar* _tmp1_;
11094 	ValaSymbol* s = NULL;
11095 	ValaSymbol* _tmp3_;
11096 	ValaSymbol* _tmp4_;
11097 	ValaList* parameters = NULL;
11098 	ValaList* _tmp5_;
11099 	ValaList* _tmp6_;
11100 	ValaDataType* return_type = NULL;
11101 	ValaSymbol* _tmp7_;
11102 	gboolean _tmp12_ = FALSE;
11103 	ValaDataType* _tmp13_;
11104 	ValaList* _tmp240_;
11105 	gint _tmp241_;
11106 	gint _tmp242_;
11107 	gint i = 0;
11108 	gint j = 0;
11109 	gint first_out = 0;
11110 	gint last = 0;
11111 	gboolean _tmp449_ = FALSE;
11112 	ValaDataType* _tmp450_;
11113 	ValaSymbol* _tmp455_;
11114 	g_return_if_fail (self != NULL);
11115 	g_return_if_fail (node != NULL);
11116 	_tmp1_ = node->element_type;
11117 	if (g_strcmp0 (_tmp1_, "alias") == 0) {
11118 		ValaSymbol* _tmp2_;
11119 		_tmp2_ = node->symbol;
11120 		_tmp0_ = VALA_IS_DELEGATE (_tmp2_);
11121 	} else {
11122 		_tmp0_ = FALSE;
11123 	}
11124 	if (_tmp0_) {
11125 		return;
11126 	}
11127 	_tmp3_ = node->symbol;
11128 	_tmp4_ = _vala_code_node_ref0 (_tmp3_);
11129 	s = _tmp4_;
11130 	_tmp5_ = node->parameters;
11131 	_tmp6_ = _vala_iterable_ref0 (_tmp5_);
11132 	parameters = _tmp6_;
11133 	return_type = NULL;
11134 	_tmp7_ = s;
11135 	if (VALA_IS_CALLABLE (_tmp7_)) {
11136 		ValaSymbol* _tmp8_;
11137 		ValaDataType* _tmp9_;
11138 		ValaDataType* _tmp10_;
11139 		ValaDataType* _tmp11_;
11140 		_tmp8_ = s;
11141 		_tmp9_ = vala_callable_get_return_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp8_, VALA_TYPE_CALLABLE, ValaCallable));
11142 		_tmp10_ = _tmp9_;
11143 		_tmp11_ = _vala_code_node_ref0 (_tmp10_);
11144 		_vala_code_node_unref0 (return_type);
11145 		return_type = _tmp11_;
11146 	}
11147 	_tmp13_ = return_type;
11148 	if (VALA_IS_ARRAY_TYPE (_tmp13_)) {
11149 		_tmp12_ = node->return_array_length_idx >= 0;
11150 	} else {
11151 		_tmp12_ = FALSE;
11152 	}
11153 	if (_tmp12_) {
11154 		ValaList* _tmp14_;
11155 		gint _tmp15_;
11156 		gint _tmp16_;
11157 		_tmp14_ = parameters;
11158 		_tmp15_ = vala_collection_get_size ((ValaCollection*) _tmp14_);
11159 		_tmp16_ = _tmp15_;
11160 		if (node->return_array_length_idx >= _tmp16_) {
11161 			ValaDataType* _tmp17_;
11162 			ValaSourceReference* _tmp18_;
11163 			ValaSourceReference* _tmp19_;
11164 			_tmp17_ = return_type;
11165 			_tmp18_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp17_);
11166 			_tmp19_ = _tmp18_;
11167 			vala_report_error (_tmp19_, "invalid array length index");
11168 		} else {
11169 			ValaList* _tmp20_;
11170 			gpointer _tmp21_;
11171 			ValaGirParserParameterInfo* _tmp22_;
11172 			ValaArrayList* _tmp23_;
11173 			_tmp20_ = parameters;
11174 			_tmp21_ = vala_list_get (_tmp20_, node->return_array_length_idx);
11175 			_tmp22_ = (ValaGirParserParameterInfo*) _tmp21_;
11176 			_tmp22_->keep = FALSE;
11177 			_vala_gir_parser_parameter_info_unref0 (_tmp22_);
11178 			_tmp23_ = node->array_length_parameters;
11179 			vala_collection_add ((ValaCollection*) _tmp23_, (gpointer) ((gintptr) node->return_array_length_idx));
11180 		}
11181 	} else {
11182 		gboolean _tmp24_ = FALSE;
11183 		ValaDataType* _tmp25_;
11184 		_tmp25_ = return_type;
11185 		if (VALA_IS_VOID_TYPE (_tmp25_)) {
11186 			ValaList* _tmp26_;
11187 			gint _tmp27_;
11188 			gint _tmp28_;
11189 			_tmp26_ = parameters;
11190 			_tmp27_ = vala_collection_get_size ((ValaCollection*) _tmp26_);
11191 			_tmp28_ = _tmp27_;
11192 			_tmp24_ = _tmp28_ > 0;
11193 		} else {
11194 			_tmp24_ = FALSE;
11195 		}
11196 		if (_tmp24_) {
11197 			gint n_out_parameters = 0;
11198 			n_out_parameters = 0;
11199 			{
11200 				ValaList* _info_list = NULL;
11201 				ValaList* _tmp29_;
11202 				ValaList* _tmp30_;
11203 				gint _info_size = 0;
11204 				ValaList* _tmp31_;
11205 				gint _tmp32_;
11206 				gint _tmp33_;
11207 				gint _info_index = 0;
11208 				_tmp29_ = parameters;
11209 				_tmp30_ = _vala_iterable_ref0 (_tmp29_);
11210 				_info_list = _tmp30_;
11211 				_tmp31_ = _info_list;
11212 				_tmp32_ = vala_collection_get_size ((ValaCollection*) _tmp31_);
11213 				_tmp33_ = _tmp32_;
11214 				_info_size = _tmp33_;
11215 				_info_index = -1;
11216 				while (TRUE) {
11217 					gint _tmp34_;
11218 					gint _tmp35_;
11219 					ValaGirParserParameterInfo* info = NULL;
11220 					ValaList* _tmp36_;
11221 					gpointer _tmp37_;
11222 					ValaGirParserParameterInfo* _tmp38_;
11223 					ValaParameter* _tmp39_;
11224 					ValaParameterDirection _tmp40_;
11225 					ValaParameterDirection _tmp41_;
11226 					_info_index = _info_index + 1;
11227 					_tmp34_ = _info_index;
11228 					_tmp35_ = _info_size;
11229 					if (!(_tmp34_ < _tmp35_)) {
11230 						break;
11231 					}
11232 					_tmp36_ = _info_list;
11233 					_tmp37_ = vala_list_get (_tmp36_, _info_index);
11234 					info = (ValaGirParserParameterInfo*) _tmp37_;
11235 					_tmp38_ = info;
11236 					_tmp39_ = _tmp38_->param;
11237 					_tmp40_ = vala_parameter_get_direction (_tmp39_);
11238 					_tmp41_ = _tmp40_;
11239 					if (_tmp41_ == VALA_PARAMETER_DIRECTION_OUT) {
11240 						gint _tmp42_;
11241 						_tmp42_ = n_out_parameters;
11242 						n_out_parameters = _tmp42_ + 1;
11243 					}
11244 					_vala_gir_parser_parameter_info_unref0 (info);
11245 				}
11246 				_vala_iterable_unref0 (_info_list);
11247 			}
11248 			if (n_out_parameters == 1) {
11249 				ValaGirParserParameterInfo* last_param = NULL;
11250 				ValaList* _tmp43_;
11251 				ValaList* _tmp44_;
11252 				gint _tmp45_;
11253 				gint _tmp46_;
11254 				gpointer _tmp47_;
11255 				ValaGirParserParameterInfo* _tmp48_;
11256 				ValaParameter* _tmp49_;
11257 				ValaParameterDirection _tmp50_;
11258 				ValaParameterDirection _tmp51_;
11259 				_tmp43_ = parameters;
11260 				_tmp44_ = parameters;
11261 				_tmp45_ = vala_collection_get_size ((ValaCollection*) _tmp44_);
11262 				_tmp46_ = _tmp45_;
11263 				_tmp47_ = vala_list_get (_tmp43_, _tmp46_ - 1);
11264 				last_param = (ValaGirParserParameterInfo*) _tmp47_;
11265 				_tmp48_ = last_param;
11266 				_tmp49_ = _tmp48_->param;
11267 				_tmp50_ = vala_parameter_get_direction (_tmp49_);
11268 				_tmp51_ = _tmp50_;
11269 				if (_tmp51_ == VALA_PARAMETER_DIRECTION_OUT) {
11270 					ValaGirParserParameterInfo* _tmp52_;
11271 					ValaParameter* _tmp53_;
11272 					ValaDataType* _tmp54_;
11273 					ValaDataType* _tmp55_;
11274 					_tmp52_ = last_param;
11275 					_tmp53_ = _tmp52_->param;
11276 					_tmp54_ = vala_variable_get_variable_type ((ValaVariable*) _tmp53_);
11277 					_tmp55_ = _tmp54_;
11278 					if (VALA_IS_UNRESOLVED_TYPE (_tmp55_)) {
11279 						ValaStruct* st = NULL;
11280 						ValaGirParserNode* _tmp56_;
11281 						ValaGirParserParameterInfo* _tmp57_;
11282 						ValaParameter* _tmp58_;
11283 						ValaDataType* _tmp59_;
11284 						ValaDataType* _tmp60_;
11285 						ValaUnresolvedSymbol* _tmp61_;
11286 						ValaUnresolvedSymbol* _tmp62_;
11287 						ValaSymbol* _tmp63_;
11288 						ValaStruct* _tmp64_;
11289 						gboolean _tmp65_ = FALSE;
11290 						gboolean _tmp66_ = FALSE;
11291 						ValaStruct* _tmp67_;
11292 						_tmp56_ = node->parent;
11293 						_tmp57_ = last_param;
11294 						_tmp58_ = _tmp57_->param;
11295 						_tmp59_ = vala_variable_get_variable_type ((ValaVariable*) _tmp58_);
11296 						_tmp60_ = _tmp59_;
11297 						_tmp61_ = vala_unresolved_type_get_unresolved_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp60_, VALA_TYPE_UNRESOLVED_TYPE, ValaUnresolvedType));
11298 						_tmp62_ = _tmp61_;
11299 						_tmp63_ = vala_gir_parser_resolve_symbol (self, _tmp56_, _tmp62_);
11300 						_tmp64_ = VALA_IS_STRUCT (_tmp63_) ? ((ValaStruct*) _tmp63_) : NULL;
11301 						if (_tmp64_ == NULL) {
11302 							_vala_code_node_unref0 (_tmp63_);
11303 						}
11304 						st = _tmp64_;
11305 						_tmp67_ = st;
11306 						if (_tmp67_ != NULL) {
11307 							ValaStruct* _tmp68_;
11308 							_tmp68_ = st;
11309 							_tmp66_ = !vala_struct_is_simple_type (_tmp68_);
11310 						} else {
11311 							_tmp66_ = FALSE;
11312 						}
11313 						if (_tmp66_) {
11314 							ValaGirParserParameterInfo* _tmp69_;
11315 							ValaParameter* _tmp70_;
11316 							ValaDataType* _tmp71_;
11317 							ValaDataType* _tmp72_;
11318 							gboolean _tmp73_;
11319 							gboolean _tmp74_;
11320 							_tmp69_ = last_param;
11321 							_tmp70_ = _tmp69_->param;
11322 							_tmp71_ = vala_variable_get_variable_type ((ValaVariable*) _tmp70_);
11323 							_tmp72_ = _tmp71_;
11324 							_tmp73_ = vala_data_type_get_nullable (_tmp72_);
11325 							_tmp74_ = _tmp73_;
11326 							_tmp65_ = !_tmp74_;
11327 						} else {
11328 							_tmp65_ = FALSE;
11329 						}
11330 						if (_tmp65_) {
11331 							ValaGirParserMetadata* _tmp75_;
11332 							_tmp75_ = node->metadata;
11333 							if (!vala_gir_parser_metadata_get_bool (_tmp75_, VALA_GIR_PARSER_ARGUMENT_TYPE_RETURN_VOID, FALSE)) {
11334 								ValaGirParserParameterInfo* _tmp76_;
11335 								ValaGirParserParameterInfo* _tmp77_;
11336 								ValaParameter* _tmp78_;
11337 								ValaDataType* _tmp79_;
11338 								ValaDataType* _tmp80_;
11339 								ValaDataType* _tmp81_;
11340 								_tmp76_ = last_param;
11341 								_tmp76_->keep = FALSE;
11342 								_tmp77_ = last_param;
11343 								_tmp78_ = _tmp77_->param;
11344 								_tmp79_ = vala_variable_get_variable_type ((ValaVariable*) _tmp78_);
11345 								_tmp80_ = _tmp79_;
11346 								_tmp81_ = vala_data_type_copy (_tmp80_);
11347 								_vala_code_node_unref0 (return_type);
11348 								return_type = _tmp81_;
11349 							}
11350 						}
11351 						_vala_code_node_unref0 (st);
11352 					}
11353 				}
11354 				_vala_gir_parser_parameter_info_unref0 (last_param);
11355 			}
11356 		} else {
11357 			gboolean _tmp82_ = FALSE;
11358 			ValaDataType* _tmp83_;
11359 			_tmp83_ = return_type;
11360 			if (VALA_IS_UNRESOLVED_TYPE (_tmp83_)) {
11361 				ValaDataType* _tmp84_;
11362 				gboolean _tmp85_;
11363 				gboolean _tmp86_;
11364 				_tmp84_ = return_type;
11365 				_tmp85_ = vala_data_type_get_nullable (_tmp84_);
11366 				_tmp86_ = _tmp85_;
11367 				_tmp82_ = !_tmp86_;
11368 			} else {
11369 				_tmp82_ = FALSE;
11370 			}
11371 			if (_tmp82_) {
11372 				ValaStruct* st = NULL;
11373 				ValaGirParserNode* _tmp87_;
11374 				ValaDataType* _tmp88_;
11375 				ValaUnresolvedSymbol* _tmp89_;
11376 				ValaUnresolvedSymbol* _tmp90_;
11377 				ValaSymbol* _tmp91_;
11378 				ValaStruct* _tmp92_;
11379 				ValaStruct* _tmp93_;
11380 				_tmp87_ = node->parent;
11381 				_tmp88_ = return_type;
11382 				_tmp89_ = vala_unresolved_type_get_unresolved_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp88_, VALA_TYPE_UNRESOLVED_TYPE, ValaUnresolvedType));
11383 				_tmp90_ = _tmp89_;
11384 				_tmp91_ = vala_gir_parser_resolve_symbol (self, _tmp87_, _tmp90_);
11385 				_tmp92_ = VALA_IS_STRUCT (_tmp91_) ? ((ValaStruct*) _tmp91_) : NULL;
11386 				if (_tmp92_ == NULL) {
11387 					_vala_code_node_unref0 (_tmp91_);
11388 				}
11389 				st = _tmp92_;
11390 				_tmp93_ = st;
11391 				if (_tmp93_ != NULL) {
11392 					gboolean is_simple_type = FALSE;
11393 					ValaStruct* base_st = NULL;
11394 					ValaStruct* _tmp94_;
11395 					ValaStruct* _tmp95_;
11396 					is_simple_type = FALSE;
11397 					_tmp94_ = st;
11398 					_tmp95_ = _vala_code_node_ref0 (_tmp94_);
11399 					base_st = _tmp95_;
11400 					while (TRUE) {
11401 						ValaStruct* _tmp96_;
11402 						ValaStruct* _tmp97_;
11403 						ValaStruct* _tmp98_;
11404 						ValaDataType* _tmp99_;
11405 						ValaDataType* _tmp100_;
11406 						_tmp96_ = base_st;
11407 						if (!(_tmp96_ != NULL)) {
11408 							break;
11409 						}
11410 						_tmp97_ = base_st;
11411 						if (vala_struct_is_simple_type (_tmp97_)) {
11412 							is_simple_type = TRUE;
11413 							break;
11414 						}
11415 						_tmp98_ = base_st;
11416 						_tmp99_ = vala_struct_get_base_type (_tmp98_);
11417 						_tmp100_ = _tmp99_;
11418 						if (VALA_IS_UNRESOLVED_TYPE (_tmp100_)) {
11419 							ValaGirParserNode* _tmp101_;
11420 							ValaStruct* _tmp102_;
11421 							ValaDataType* _tmp103_;
11422 							ValaDataType* _tmp104_;
11423 							ValaUnresolvedSymbol* _tmp105_;
11424 							ValaUnresolvedSymbol* _tmp106_;
11425 							ValaSymbol* _tmp107_;
11426 							ValaStruct* _tmp108_;
11427 							_tmp101_ = node->parent;
11428 							_tmp102_ = base_st;
11429 							_tmp103_ = vala_struct_get_base_type (_tmp102_);
11430 							_tmp104_ = _tmp103_;
11431 							_tmp105_ = vala_unresolved_type_get_unresolved_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp104_, VALA_TYPE_UNRESOLVED_TYPE, ValaUnresolvedType));
11432 							_tmp106_ = _tmp105_;
11433 							_tmp107_ = vala_gir_parser_resolve_symbol (self, _tmp101_, _tmp106_);
11434 							_tmp108_ = VALA_IS_STRUCT (_tmp107_) ? ((ValaStruct*) _tmp107_) : NULL;
11435 							if (_tmp108_ == NULL) {
11436 								_vala_code_node_unref0 (_tmp107_);
11437 							}
11438 							_vala_code_node_unref0 (base_st);
11439 							base_st = _tmp108_;
11440 						} else {
11441 							ValaStruct* _tmp109_;
11442 							ValaStruct* _tmp110_;
11443 							ValaStruct* _tmp111_;
11444 							ValaStruct* _tmp112_;
11445 							_tmp109_ = base_st;
11446 							_tmp110_ = vala_struct_get_base_struct (_tmp109_);
11447 							_tmp111_ = _tmp110_;
11448 							_tmp112_ = _vala_code_node_ref0 (_tmp111_);
11449 							_vala_code_node_unref0 (base_st);
11450 							base_st = _tmp112_;
11451 						}
11452 					}
11453 					if (!is_simple_type) {
11454 						ValaDataType* _tmp113_;
11455 						_tmp113_ = return_type;
11456 						vala_data_type_set_nullable (_tmp113_, TRUE);
11457 					}
11458 					_vala_code_node_unref0 (base_st);
11459 				}
11460 				_vala_code_node_unref0 (st);
11461 			}
11462 		}
11463 	}
11464 	{
11465 		ValaList* _info_list = NULL;
11466 		ValaList* _tmp114_;
11467 		ValaList* _tmp115_;
11468 		gint _info_size = 0;
11469 		ValaList* _tmp116_;
11470 		gint _tmp117_;
11471 		gint _tmp118_;
11472 		gint _info_index = 0;
11473 		_tmp114_ = parameters;
11474 		_tmp115_ = _vala_iterable_ref0 (_tmp114_);
11475 		_info_list = _tmp115_;
11476 		_tmp116_ = _info_list;
11477 		_tmp117_ = vala_collection_get_size ((ValaCollection*) _tmp116_);
11478 		_tmp118_ = _tmp117_;
11479 		_info_size = _tmp118_;
11480 		_info_index = -1;
11481 		while (TRUE) {
11482 			gint _tmp119_;
11483 			gint _tmp120_;
11484 			ValaGirParserParameterInfo* info = NULL;
11485 			ValaList* _tmp121_;
11486 			gpointer _tmp122_;
11487 			ValaDataType* type = NULL;
11488 			ValaGirParserParameterInfo* _tmp123_;
11489 			ValaParameter* _tmp124_;
11490 			ValaDataType* _tmp125_;
11491 			ValaDataType* _tmp126_;
11492 			gboolean _tmp127_ = FALSE;
11493 			ValaGirParserParameterInfo* _tmp128_;
11494 			ValaParameter* _tmp129_;
11495 			ValaParameterDirection _tmp130_;
11496 			ValaParameterDirection _tmp131_;
11497 			ValaSymbol* _tmp151_;
11498 			gboolean _tmp189_ = FALSE;
11499 			gboolean _tmp190_ = FALSE;
11500 			ValaGirParserParameterInfo* _tmp191_;
11501 			ValaParameter* _tmp192_;
11502 			ValaParameterDirection _tmp193_;
11503 			ValaParameterDirection _tmp194_;
11504 			_info_index = _info_index + 1;
11505 			_tmp119_ = _info_index;
11506 			_tmp120_ = _info_size;
11507 			if (!(_tmp119_ < _tmp120_)) {
11508 				break;
11509 			}
11510 			_tmp121_ = _info_list;
11511 			_tmp122_ = vala_list_get (_tmp121_, _info_index);
11512 			info = (ValaGirParserParameterInfo*) _tmp122_;
11513 			_tmp123_ = info;
11514 			_tmp124_ = _tmp123_->param;
11515 			_tmp125_ = vala_variable_get_variable_type ((ValaVariable*) _tmp124_);
11516 			_tmp126_ = _tmp125_;
11517 			type = _tmp126_;
11518 			_tmp128_ = info;
11519 			_tmp129_ = _tmp128_->param;
11520 			_tmp130_ = vala_parameter_get_direction (_tmp129_);
11521 			_tmp131_ = _tmp130_;
11522 			if (_tmp131_ == VALA_PARAMETER_DIRECTION_OUT) {
11523 				ValaDataType* _tmp132_;
11524 				gboolean _tmp133_;
11525 				gboolean _tmp134_;
11526 				_tmp132_ = type;
11527 				_tmp133_ = vala_data_type_get_nullable (_tmp132_);
11528 				_tmp134_ = _tmp133_;
11529 				_tmp127_ = _tmp134_;
11530 			} else {
11531 				_tmp127_ = FALSE;
11532 			}
11533 			if (_tmp127_) {
11534 				ValaStruct* st = NULL;
11535 				ValaDataType* _tmp135_;
11536 				gboolean _tmp147_ = FALSE;
11537 				ValaStruct* _tmp148_;
11538 				st = NULL;
11539 				_tmp135_ = type;
11540 				if (VALA_IS_UNRESOLVED_TYPE (_tmp135_)) {
11541 					ValaGirParserNode* _tmp136_;
11542 					ValaDataType* _tmp137_;
11543 					ValaUnresolvedSymbol* _tmp138_;
11544 					ValaUnresolvedSymbol* _tmp139_;
11545 					ValaSymbol* _tmp140_;
11546 					ValaStruct* _tmp141_;
11547 					_tmp136_ = node->parent;
11548 					_tmp137_ = type;
11549 					_tmp138_ = vala_unresolved_type_get_unresolved_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp137_, VALA_TYPE_UNRESOLVED_TYPE, ValaUnresolvedType));
11550 					_tmp139_ = _tmp138_;
11551 					_tmp140_ = vala_gir_parser_resolve_symbol (self, _tmp136_, _tmp139_);
11552 					_tmp141_ = VALA_IS_STRUCT (_tmp140_) ? ((ValaStruct*) _tmp140_) : NULL;
11553 					if (_tmp141_ == NULL) {
11554 						_vala_code_node_unref0 (_tmp140_);
11555 					}
11556 					_vala_code_node_unref0 (st);
11557 					st = _tmp141_;
11558 				} else {
11559 					ValaDataType* _tmp142_;
11560 					_tmp142_ = type;
11561 					if (VALA_IS_VALUE_TYPE (_tmp142_)) {
11562 						ValaDataType* _tmp143_;
11563 						ValaTypeSymbol* _tmp144_;
11564 						ValaTypeSymbol* _tmp145_;
11565 						ValaStruct* _tmp146_;
11566 						_tmp143_ = type;
11567 						_tmp144_ = vala_data_type_get_type_symbol (_tmp143_);
11568 						_tmp145_ = _tmp144_;
11569 						_tmp146_ = _vala_code_node_ref0 (VALA_IS_STRUCT (_tmp145_) ? ((ValaStruct*) _tmp145_) : NULL);
11570 						_vala_code_node_unref0 (st);
11571 						st = _tmp146_;
11572 					}
11573 				}
11574 				_tmp148_ = st;
11575 				if (_tmp148_ != NULL) {
11576 					ValaStruct* _tmp149_;
11577 					_tmp149_ = st;
11578 					_tmp147_ = vala_struct_is_simple_type (_tmp149_);
11579 				} else {
11580 					_tmp147_ = FALSE;
11581 				}
11582 				if (_tmp147_) {
11583 					ValaDataType* _tmp150_;
11584 					_tmp150_ = type;
11585 					vala_data_type_set_nullable (_tmp150_, FALSE);
11586 				}
11587 				_vala_code_node_unref0 (st);
11588 			}
11589 			_tmp151_ = s;
11590 			if (VALA_IS_METHOD (_tmp151_)) {
11591 				gchar* type_name = NULL;
11592 				ValaUnresolvedType* unresolved_type = NULL;
11593 				ValaDataType* _tmp152_;
11594 				ValaUnresolvedType* _tmp153_;
11595 				ValaGirParserParameterInfo* _tmp163_;
11596 				gboolean _tmp177_ = FALSE;
11597 				gboolean _tmp178_ = FALSE;
11598 				gboolean _tmp179_ = FALSE;
11599 				gboolean _tmp180_ = FALSE;
11600 				gboolean _tmp181_ = FALSE;
11601 				ValaUnresolvedType* _tmp182_;
11602 				type_name = NULL;
11603 				_tmp152_ = type;
11604 				unresolved_type = VALA_IS_UNRESOLVED_TYPE (_tmp152_) ? ((ValaUnresolvedType*) _tmp152_) : NULL;
11605 				_tmp153_ = unresolved_type;
11606 				if (_tmp153_ != NULL) {
11607 					ValaUnresolvedType* _tmp154_;
11608 					ValaUnresolvedSymbol* _tmp155_;
11609 					ValaUnresolvedSymbol* _tmp156_;
11610 					const gchar* _tmp157_;
11611 					const gchar* _tmp158_;
11612 					gchar* _tmp159_;
11613 					_tmp154_ = unresolved_type;
11614 					_tmp155_ = vala_unresolved_type_get_unresolved_symbol (_tmp154_);
11615 					_tmp156_ = _tmp155_;
11616 					_tmp157_ = vala_symbol_get_name ((ValaSymbol*) _tmp156_);
11617 					_tmp158_ = _tmp157_;
11618 					_tmp159_ = g_strdup (_tmp158_);
11619 					_g_free0 (type_name);
11620 					type_name = _tmp159_;
11621 				} else {
11622 					ValaDataType* _tmp160_;
11623 					_tmp160_ = type;
11624 					if (_tmp160_ != NULL) {
11625 						ValaDataType* _tmp161_;
11626 						gchar* _tmp162_;
11627 						_tmp161_ = type;
11628 						_tmp162_ = vala_code_node_to_string ((ValaCodeNode*) _tmp161_);
11629 						_g_free0 (type_name);
11630 						type_name = _tmp162_;
11631 					}
11632 				}
11633 				_tmp163_ = info;
11634 				if (_tmp163_->is_async) {
11635 					gboolean _tmp164_ = FALSE;
11636 					gboolean _tmp165_ = FALSE;
11637 					gboolean _tmp166_ = FALSE;
11638 					gboolean _tmp167_ = FALSE;
11639 					gboolean _tmp168_ = FALSE;
11640 					ValaUnresolvedType* _tmp169_;
11641 					_tmp169_ = unresolved_type;
11642 					if (_tmp169_ != NULL) {
11643 						const gchar* _tmp170_;
11644 						_tmp170_ = type_name;
11645 						_tmp168_ = g_strcmp0 (_tmp170_, "AsyncReadyCallback") == 0;
11646 					} else {
11647 						_tmp168_ = FALSE;
11648 					}
11649 					if (_tmp168_) {
11650 						_tmp167_ = TRUE;
11651 					} else {
11652 						const gchar* _tmp171_;
11653 						_tmp171_ = type_name;
11654 						_tmp167_ = g_strcmp0 (_tmp171_, "GLib.AsyncReadyCallback") == 0;
11655 					}
11656 					if (_tmp167_) {
11657 						_tmp166_ = TRUE;
11658 					} else {
11659 						const gchar* _tmp172_;
11660 						_tmp172_ = type_name;
11661 						_tmp166_ = g_strcmp0 (_tmp172_, "Gio.AsyncReadyCallback") == 0;
11662 					}
11663 					if (_tmp166_) {
11664 						_tmp165_ = TRUE;
11665 					} else {
11666 						const gchar* _tmp173_;
11667 						_tmp173_ = type_name;
11668 						_tmp165_ = g_strcmp0 (_tmp173_, "GLib.AsyncReadyCallback?") == 0;
11669 					}
11670 					if (_tmp165_) {
11671 						_tmp164_ = TRUE;
11672 					} else {
11673 						const gchar* _tmp174_;
11674 						_tmp174_ = type_name;
11675 						_tmp164_ = g_strcmp0 (_tmp174_, "Gio.AsyncReadyCallback?") == 0;
11676 					}
11677 					if (_tmp164_) {
11678 						ValaSymbol* _tmp175_;
11679 						ValaGirParserParameterInfo* _tmp176_;
11680 						_tmp175_ = s;
11681 						vala_method_set_coroutine (G_TYPE_CHECK_INSTANCE_CAST (_tmp175_, VALA_TYPE_METHOD, ValaMethod), TRUE);
11682 						_tmp176_ = info;
11683 						_tmp176_->keep = FALSE;
11684 					}
11685 				}
11686 				_tmp182_ = unresolved_type;
11687 				if (_tmp182_ != NULL) {
11688 					const gchar* _tmp183_;
11689 					_tmp183_ = type_name;
11690 					_tmp181_ = g_strcmp0 (_tmp183_, "AsyncResult") == 0;
11691 				} else {
11692 					_tmp181_ = FALSE;
11693 				}
11694 				if (_tmp181_) {
11695 					_tmp180_ = TRUE;
11696 				} else {
11697 					const gchar* _tmp184_;
11698 					_tmp184_ = type_name;
11699 					_tmp180_ = g_strcmp0 (_tmp184_, "GLib.AsyncResult") == 0;
11700 				}
11701 				if (_tmp180_) {
11702 					_tmp179_ = TRUE;
11703 				} else {
11704 					const gchar* _tmp185_;
11705 					_tmp185_ = type_name;
11706 					_tmp179_ = g_strcmp0 (_tmp185_, "Gio.AsyncResult") == 0;
11707 				}
11708 				if (_tmp179_) {
11709 					_tmp178_ = TRUE;
11710 				} else {
11711 					const gchar* _tmp186_;
11712 					_tmp186_ = type_name;
11713 					_tmp178_ = g_strcmp0 (_tmp186_, "GLib.AsyncResult?") == 0;
11714 				}
11715 				if (_tmp178_) {
11716 					_tmp177_ = TRUE;
11717 				} else {
11718 					const gchar* _tmp187_;
11719 					_tmp187_ = type_name;
11720 					_tmp177_ = g_strcmp0 (_tmp187_, "Gio.AsyncResult?") == 0;
11721 				}
11722 				if (_tmp177_) {
11723 					ValaGirParserParameterInfo* _tmp188_;
11724 					_tmp188_ = info;
11725 					_tmp188_->is_async_result = TRUE;
11726 				}
11727 				_g_free0 (type_name);
11728 			}
11729 			_tmp191_ = info;
11730 			_tmp192_ = _tmp191_->param;
11731 			_tmp193_ = vala_parameter_get_direction (_tmp192_);
11732 			_tmp194_ = _tmp193_;
11733 			if (_tmp194_ == VALA_PARAMETER_DIRECTION_OUT) {
11734 				ValaSymbol* _tmp195_;
11735 				_tmp195_ = s;
11736 				_tmp190_ = VALA_IS_DELEGATE (_tmp195_);
11737 			} else {
11738 				_tmp190_ = FALSE;
11739 			}
11740 			if (_tmp190_) {
11741 				ValaSymbol* _tmp196_;
11742 				gboolean _tmp197_;
11743 				gboolean _tmp198_;
11744 				_tmp196_ = s;
11745 				_tmp197_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp196_);
11746 				_tmp198_ = _tmp197_;
11747 				_tmp189_ = !_tmp198_;
11748 			} else {
11749 				_tmp189_ = FALSE;
11750 			}
11751 			if (_tmp189_) {
11752 				ValaUnresolvedType* unresolved_type = NULL;
11753 				ValaDataType* _tmp199_;
11754 				gboolean _tmp200_ = FALSE;
11755 				ValaUnresolvedType* _tmp201_;
11756 				_tmp199_ = type;
11757 				unresolved_type = VALA_IS_UNRESOLVED_TYPE (_tmp199_) ? ((ValaUnresolvedType*) _tmp199_) : NULL;
11758 				_tmp201_ = unresolved_type;
11759 				if (_tmp201_ != NULL) {
11760 					ValaUnresolvedType* _tmp202_;
11761 					ValaUnresolvedSymbol* _tmp203_;
11762 					ValaUnresolvedSymbol* _tmp204_;
11763 					gchar* _tmp205_;
11764 					gchar* _tmp206_;
11765 					_tmp202_ = unresolved_type;
11766 					_tmp203_ = vala_unresolved_type_get_unresolved_symbol (_tmp202_);
11767 					_tmp204_ = _tmp203_;
11768 					_tmp205_ = vala_code_node_to_string ((ValaCodeNode*) _tmp204_);
11769 					_tmp206_ = _tmp205_;
11770 					_tmp200_ = g_strcmp0 (_tmp206_, "GLib.Error") == 0;
11771 					_g_free0 (_tmp206_);
11772 				} else {
11773 					_tmp200_ = FALSE;
11774 				}
11775 				if (_tmp200_) {
11776 					ValaSymbol* _tmp207_;
11777 					ValaErrorType* _tmp208_;
11778 					ValaErrorType* _tmp209_;
11779 					ValaGirParserParameterInfo* _tmp210_;
11780 					ValaGirParserParameterInfo* _tmp211_;
11781 					_tmp207_ = s;
11782 					_tmp208_ = vala_error_type_new (NULL, NULL, NULL);
11783 					_tmp209_ = _tmp208_;
11784 					vala_delegate_add_error_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp207_, VALA_TYPE_DELEGATE, ValaDelegate), (ValaDataType*) _tmp209_);
11785 					_vala_code_node_unref0 (_tmp209_);
11786 					_tmp210_ = info;
11787 					_tmp210_->is_error = TRUE;
11788 					_tmp211_ = info;
11789 					_tmp211_->keep = FALSE;
11790 				}
11791 			}
11792 			_vala_gir_parser_parameter_info_unref0 (info);
11793 		}
11794 		_vala_iterable_unref0 (_info_list);
11795 	}
11796 	{
11797 		gint param_n = 0;
11798 		ValaList* _tmp212_;
11799 		gint _tmp213_;
11800 		gint _tmp214_;
11801 		_tmp212_ = parameters;
11802 		_tmp213_ = vala_collection_get_size ((ValaCollection*) _tmp212_);
11803 		_tmp214_ = _tmp213_;
11804 		param_n = _tmp214_ - 1;
11805 		{
11806 			gboolean _tmp215_ = FALSE;
11807 			_tmp215_ = TRUE;
11808 			while (TRUE) {
11809 				ValaGirParserParameterInfo* info = NULL;
11810 				ValaList* _tmp217_;
11811 				gpointer _tmp218_;
11812 				gboolean _tmp219_ = FALSE;
11813 				ValaGirParserParameterInfo* _tmp220_;
11814 				ValaParameter* _tmp221_;
11815 				gboolean _tmp222_;
11816 				gboolean _tmp223_;
11817 				if (!_tmp215_) {
11818 					gint _tmp216_;
11819 					_tmp216_ = param_n;
11820 					param_n = _tmp216_ - 1;
11821 				}
11822 				_tmp215_ = FALSE;
11823 				if (!(param_n >= 0)) {
11824 					break;
11825 				}
11826 				_tmp217_ = parameters;
11827 				_tmp218_ = vala_list_get (_tmp217_, param_n);
11828 				info = (ValaGirParserParameterInfo*) _tmp218_;
11829 				_tmp220_ = info;
11830 				_tmp221_ = _tmp220_->param;
11831 				_tmp222_ = vala_parameter_get_ellipsis (_tmp221_);
11832 				_tmp223_ = _tmp222_;
11833 				if (!_tmp223_) {
11834 					ValaGirParserParameterInfo* _tmp224_;
11835 					ValaParameter* _tmp225_;
11836 					ValaExpression* _tmp226_;
11837 					ValaExpression* _tmp227_;
11838 					_tmp224_ = info;
11839 					_tmp225_ = _tmp224_->param;
11840 					_tmp226_ = vala_variable_get_initializer ((ValaVariable*) _tmp225_);
11841 					_tmp227_ = _tmp226_;
11842 					_tmp219_ = _tmp227_ == NULL;
11843 				} else {
11844 					_tmp219_ = FALSE;
11845 				}
11846 				if (_tmp219_) {
11847 					gchar* type_string = NULL;
11848 					ValaGirParserParameterInfo* _tmp228_;
11849 					ValaParameter* _tmp229_;
11850 					ValaDataType* _tmp230_;
11851 					ValaDataType* _tmp231_;
11852 					gchar* _tmp232_;
11853 					gboolean _tmp233_ = FALSE;
11854 					const gchar* _tmp234_;
11855 					_tmp228_ = info;
11856 					_tmp229_ = _tmp228_->param;
11857 					_tmp230_ = vala_variable_get_variable_type ((ValaVariable*) _tmp229_);
11858 					_tmp231_ = _tmp230_;
11859 					_tmp232_ = vala_code_node_to_string ((ValaCodeNode*) _tmp231_);
11860 					type_string = _tmp232_;
11861 					_tmp234_ = type_string;
11862 					if (g_strcmp0 (_tmp234_, "GLib.Cancellable?") == 0) {
11863 						_tmp233_ = TRUE;
11864 					} else {
11865 						const gchar* _tmp235_;
11866 						_tmp235_ = type_string;
11867 						_tmp233_ = g_strcmp0 (_tmp235_, "Gio.Cancellable?") == 0;
11868 					}
11869 					if (_tmp233_) {
11870 						ValaGirParserParameterInfo* _tmp236_;
11871 						ValaParameter* _tmp237_;
11872 						ValaNullLiteral* _tmp238_;
11873 						ValaNullLiteral* _tmp239_;
11874 						_tmp236_ = info;
11875 						_tmp237_ = _tmp236_->param;
11876 						_tmp238_ = vala_null_literal_new (NULL);
11877 						_tmp239_ = _tmp238_;
11878 						vala_variable_set_initializer ((ValaVariable*) _tmp237_, (ValaExpression*) _tmp239_);
11879 						_vala_code_node_unref0 (_tmp239_);
11880 					} else {
11881 						_g_free0 (type_string);
11882 						_vala_gir_parser_parameter_info_unref0 (info);
11883 						break;
11884 					}
11885 					_g_free0 (type_string);
11886 				}
11887 				_vala_gir_parser_parameter_info_unref0 (info);
11888 			}
11889 		}
11890 	}
11891 	_tmp240_ = parameters;
11892 	_tmp241_ = vala_collection_get_size ((ValaCollection*) _tmp240_);
11893 	_tmp242_ = _tmp241_;
11894 	if (_tmp242_ > 1) {
11895 		ValaGirParserParameterInfo* last_param = NULL;
11896 		ValaList* _tmp243_;
11897 		ValaList* _tmp244_;
11898 		gint _tmp245_;
11899 		gint _tmp246_;
11900 		gpointer _tmp247_;
11901 		ValaGirParserParameterInfo* _tmp248_;
11902 		ValaParameter* _tmp249_;
11903 		gboolean _tmp250_;
11904 		gboolean _tmp251_;
11905 		_tmp243_ = parameters;
11906 		_tmp244_ = parameters;
11907 		_tmp245_ = vala_collection_get_size ((ValaCollection*) _tmp244_);
11908 		_tmp246_ = _tmp245_;
11909 		_tmp247_ = vala_list_get (_tmp243_, _tmp246_ - 1);
11910 		last_param = (ValaGirParserParameterInfo*) _tmp247_;
11911 		_tmp248_ = last_param;
11912 		_tmp249_ = _tmp248_->param;
11913 		_tmp250_ = vala_parameter_get_ellipsis (_tmp249_);
11914 		_tmp251_ = _tmp250_;
11915 		if (_tmp251_) {
11916 			ValaGirParserParameterInfo* first_vararg_param = NULL;
11917 			ValaList* _tmp252_;
11918 			ValaList* _tmp253_;
11919 			gint _tmp254_;
11920 			gint _tmp255_;
11921 			gpointer _tmp256_;
11922 			ValaGirParserParameterInfo* _tmp257_;
11923 			ValaParameter* _tmp258_;
11924 			const gchar* _tmp259_;
11925 			const gchar* _tmp260_;
11926 			_tmp252_ = parameters;
11927 			_tmp253_ = parameters;
11928 			_tmp254_ = vala_collection_get_size ((ValaCollection*) _tmp253_);
11929 			_tmp255_ = _tmp254_;
11930 			_tmp256_ = vala_list_get (_tmp252_, _tmp255_ - 2);
11931 			first_vararg_param = (ValaGirParserParameterInfo*) _tmp256_;
11932 			_tmp257_ = first_vararg_param;
11933 			_tmp258_ = _tmp257_->param;
11934 			_tmp259_ = vala_symbol_get_name ((ValaSymbol*) _tmp258_);
11935 			_tmp260_ = _tmp259_;
11936 			if (g_str_has_prefix (_tmp260_, "first_")) {
11937 				ValaGirParserParameterInfo* _tmp261_;
11938 				_tmp261_ = first_vararg_param;
11939 				_tmp261_->keep = FALSE;
11940 			}
11941 			_vala_gir_parser_parameter_info_unref0 (first_vararg_param);
11942 		}
11943 		_vala_gir_parser_parameter_info_unref0 (last_param);
11944 	}
11945 	i = 0;
11946 	j = 1;
11947 	first_out = -1;
11948 	last = -1;
11949 	{
11950 		ValaList* _info_list = NULL;
11951 		ValaList* _tmp262_;
11952 		ValaList* _tmp263_;
11953 		gint _info_size = 0;
11954 		ValaList* _tmp264_;
11955 		gint _tmp265_;
11956 		gint _tmp266_;
11957 		gint _info_index = 0;
11958 		_tmp262_ = parameters;
11959 		_tmp263_ = _vala_iterable_ref0 (_tmp262_);
11960 		_info_list = _tmp263_;
11961 		_tmp264_ = _info_list;
11962 		_tmp265_ = vala_collection_get_size ((ValaCollection*) _tmp264_);
11963 		_tmp266_ = _tmp265_;
11964 		_info_size = _tmp266_;
11965 		_info_index = -1;
11966 		while (TRUE) {
11967 			gint _tmp267_;
11968 			gint _tmp268_;
11969 			ValaGirParserParameterInfo* info = NULL;
11970 			ValaList* _tmp269_;
11971 			gpointer _tmp270_;
11972 			gboolean _tmp271_ = FALSE;
11973 			ValaSymbol* _tmp272_;
11974 			gboolean _tmp299_ = FALSE;
11975 			gboolean _tmp304_ = FALSE;
11976 			gboolean _tmp305_ = FALSE;
11977 			gboolean _tmp313_ = FALSE;
11978 			ValaSymbol* _tmp314_;
11979 			gint _tmp318_;
11980 			_info_index = _info_index + 1;
11981 			_tmp267_ = _info_index;
11982 			_tmp268_ = _info_size;
11983 			if (!(_tmp267_ < _tmp268_)) {
11984 				break;
11985 			}
11986 			_tmp269_ = _info_list;
11987 			_tmp270_ = vala_list_get (_tmp269_, _info_index);
11988 			info = (ValaGirParserParameterInfo*) _tmp270_;
11989 			_tmp272_ = s;
11990 			if (VALA_IS_DELEGATE (_tmp272_)) {
11991 				ValaGirParserParameterInfo* _tmp273_;
11992 				_tmp273_ = info;
11993 				_tmp271_ = _tmp273_->closure_idx == i;
11994 			} else {
11995 				_tmp271_ = FALSE;
11996 			}
11997 			if (_tmp271_) {
11998 				ValaDelegate* d = NULL;
11999 				ValaSymbol* _tmp274_;
12000 				ValaDelegate* _tmp275_;
12001 				ValaDelegate* _tmp276_;
12002 				ValaDelegate* _tmp277_;
12003 				ValaGirParserParameterInfo* _tmp278_;
12004 				_tmp274_ = s;
12005 				_tmp275_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp274_, VALA_TYPE_DELEGATE, ValaDelegate));
12006 				d = _tmp275_;
12007 				_tmp276_ = d;
12008 				vala_delegate_set_has_target (_tmp276_, TRUE);
12009 				_tmp277_ = d;
12010 				vala_code_node_set_attribute_double ((ValaCodeNode*) _tmp277_, "CCode", "instance_pos", j - 0.1, NULL);
12011 				_tmp278_ = info;
12012 				_tmp278_->keep = FALSE;
12013 				_vala_code_node_unref0 (d);
12014 			} else {
12015 				gboolean _tmp279_ = FALSE;
12016 				gboolean _tmp280_ = FALSE;
12017 				gboolean _tmp281_ = FALSE;
12018 				ValaGirParserParameterInfo* _tmp282_;
12019 				_tmp282_ = info;
12020 				if (_tmp282_->keep) {
12021 					ValaArrayList* _tmp283_;
12022 					_tmp283_ = node->array_length_parameters;
12023 					_tmp281_ = !vala_collection_contains ((ValaCollection*) _tmp283_, (gpointer) ((gintptr) i));
12024 				} else {
12025 					_tmp281_ = FALSE;
12026 				}
12027 				if (_tmp281_) {
12028 					ValaArrayList* _tmp284_;
12029 					_tmp284_ = node->closure_parameters;
12030 					_tmp280_ = !vala_collection_contains ((ValaCollection*) _tmp284_, (gpointer) ((gintptr) i));
12031 				} else {
12032 					_tmp280_ = FALSE;
12033 				}
12034 				if (_tmp280_) {
12035 					ValaArrayList* _tmp285_;
12036 					_tmp285_ = node->destroy_parameters;
12037 					_tmp279_ = !vala_collection_contains ((ValaCollection*) _tmp285_, (gpointer) ((gintptr) i));
12038 				} else {
12039 					_tmp279_ = FALSE;
12040 				}
12041 				if (_tmp279_) {
12042 					ValaGirParserParameterInfo* _tmp286_;
12043 					ValaGirParserParameterInfo* _tmp287_;
12044 					gfloat last_idx = 0.0F;
12045 					gint _tmp296_;
12046 					_tmp286_ = info;
12047 					_tmp286_->vala_idx = (gfloat) j;
12048 					_tmp287_ = info;
12049 					_tmp287_->keep = TRUE;
12050 					last_idx = 0.0F;
12051 					if (last != -1) {
12052 						ValaList* _tmp288_;
12053 						gpointer _tmp289_;
12054 						ValaGirParserParameterInfo* _tmp290_;
12055 						_tmp288_ = parameters;
12056 						_tmp289_ = vala_list_get (_tmp288_, last);
12057 						_tmp290_ = (ValaGirParserParameterInfo*) _tmp289_;
12058 						last_idx = _tmp290_->vala_idx;
12059 						_vala_gir_parser_parameter_info_unref0 (_tmp290_);
12060 					}
12061 					{
12062 						gint k = 0;
12063 						k = last + 1;
12064 						{
12065 							gboolean _tmp291_ = FALSE;
12066 							_tmp291_ = TRUE;
12067 							while (TRUE) {
12068 								ValaList* _tmp293_;
12069 								gpointer _tmp294_;
12070 								ValaGirParserParameterInfo* _tmp295_;
12071 								if (!_tmp291_) {
12072 									gint _tmp292_;
12073 									_tmp292_ = k;
12074 									k = _tmp292_ + 1;
12075 								}
12076 								_tmp291_ = FALSE;
12077 								if (!(k < i)) {
12078 									break;
12079 								}
12080 								_tmp293_ = parameters;
12081 								_tmp294_ = vala_list_get (_tmp293_, k);
12082 								_tmp295_ = (ValaGirParserParameterInfo*) _tmp294_;
12083 								_tmp295_->vala_idx = last_idx + (((j - last_idx) / (i - last)) * (k - last));
12084 								_vala_gir_parser_parameter_info_unref0 (_tmp295_);
12085 							}
12086 						}
12087 					}
12088 					last = i;
12089 					_tmp296_ = j;
12090 					j = _tmp296_ + 1;
12091 				} else {
12092 					ValaGirParserParameterInfo* _tmp297_;
12093 					ValaGirParserParameterInfo* _tmp298_;
12094 					_tmp297_ = info;
12095 					_tmp297_->keep = FALSE;
12096 					_tmp298_ = info;
12097 					_tmp298_->vala_idx = (j - 1) + ((i - last) * 0.1F);
12098 				}
12099 			}
12100 			if (first_out < 0) {
12101 				ValaGirParserParameterInfo* _tmp300_;
12102 				ValaParameter* _tmp301_;
12103 				ValaParameterDirection _tmp302_;
12104 				ValaParameterDirection _tmp303_;
12105 				_tmp300_ = info;
12106 				_tmp301_ = _tmp300_->param;
12107 				_tmp302_ = vala_parameter_get_direction (_tmp301_);
12108 				_tmp303_ = _tmp302_;
12109 				_tmp299_ = _tmp303_ == VALA_PARAMETER_DIRECTION_OUT;
12110 			} else {
12111 				_tmp299_ = FALSE;
12112 			}
12113 			if (_tmp299_) {
12114 				first_out = i;
12115 			}
12116 			if (first_out >= 0) {
12117 				ValaGirParserParameterInfo* _tmp306_;
12118 				_tmp306_ = info;
12119 				_tmp305_ = _tmp306_->is_async_result;
12120 			} else {
12121 				_tmp305_ = FALSE;
12122 			}
12123 			if (_tmp305_) {
12124 				ValaSymbol* _tmp307_;
12125 				_tmp307_ = s;
12126 				_tmp304_ = VALA_IS_METHOD (_tmp307_);
12127 			} else {
12128 				_tmp304_ = FALSE;
12129 			}
12130 			if (_tmp304_) {
12131 				gdouble _tmp308_ = 0.0;
12132 				ValaSymbol* _tmp309_;
12133 				ValaMemberBinding _tmp310_;
12134 				ValaMemberBinding _tmp311_;
12135 				gdouble shift = 0.0;
12136 				ValaSymbol* _tmp312_;
12137 				_tmp309_ = s;
12138 				_tmp310_ = vala_method_get_binding (G_TYPE_CHECK_INSTANCE_CAST (_tmp309_, VALA_TYPE_METHOD, ValaMethod));
12139 				_tmp311_ = _tmp310_;
12140 				if (_tmp311_ == VALA_MEMBER_BINDING_INSTANCE) {
12141 					_tmp308_ = 1.1;
12142 				} else {
12143 					_tmp308_ = 0.1;
12144 				}
12145 				shift = _tmp308_;
12146 				_tmp312_ = s;
12147 				vala_code_node_set_attribute_double ((ValaCodeNode*) _tmp312_, "CCode", "async_result_pos", i + shift, NULL);
12148 			}
12149 			_tmp314_ = s;
12150 			if (VALA_IS_DELEGATE (_tmp314_)) {
12151 				ValaGirParserParameterInfo* _tmp315_;
12152 				_tmp315_ = info;
12153 				_tmp313_ = _tmp315_->is_error;
12154 			} else {
12155 				_tmp313_ = FALSE;
12156 			}
12157 			if (_tmp313_) {
12158 				ValaSymbol* _tmp316_;
12159 				_tmp316_ = s;
12160 				if (!vala_code_node_has_attribute_argument ((ValaCodeNode*) _tmp316_, "CCode", "instance_pos")) {
12161 					ValaSymbol* _tmp317_;
12162 					_tmp317_ = s;
12163 					vala_code_node_set_attribute_double ((ValaCodeNode*) _tmp317_, "CCode", "error_pos", j - 0.2, NULL);
12164 				}
12165 			}
12166 			_tmp318_ = i;
12167 			i = _tmp318_ + 1;
12168 			_vala_gir_parser_parameter_info_unref0 (info);
12169 		}
12170 		_vala_iterable_unref0 (_info_list);
12171 	}
12172 	{
12173 		ValaList* _info_list = NULL;
12174 		ValaList* _tmp319_;
12175 		ValaList* _tmp320_;
12176 		gint _info_size = 0;
12177 		ValaList* _tmp321_;
12178 		gint _tmp322_;
12179 		gint _tmp323_;
12180 		gint _info_index = 0;
12181 		_tmp319_ = parameters;
12182 		_tmp320_ = _vala_iterable_ref0 (_tmp319_);
12183 		_info_list = _tmp320_;
12184 		_tmp321_ = _info_list;
12185 		_tmp322_ = vala_collection_get_size ((ValaCollection*) _tmp321_);
12186 		_tmp323_ = _tmp322_;
12187 		_info_size = _tmp323_;
12188 		_info_index = -1;
12189 		while (TRUE) {
12190 			gint _tmp324_;
12191 			gint _tmp325_;
12192 			ValaGirParserParameterInfo* info = NULL;
12193 			ValaList* _tmp326_;
12194 			gpointer _tmp327_;
12195 			ValaGirParserParameterInfo* _tmp328_;
12196 			ValaSymbol* _tmp329_;
12197 			ValaGirParserParameterInfo* _tmp333_;
12198 			ValaGirParserParameterInfo* _tmp348_;
12199 			ValaGirParserParameterInfo* _tmp373_;
12200 			ValaGirParserParameterInfo* _tmp398_;
12201 			_info_index = _info_index + 1;
12202 			_tmp324_ = _info_index;
12203 			_tmp325_ = _info_size;
12204 			if (!(_tmp324_ < _tmp325_)) {
12205 				break;
12206 			}
12207 			_tmp326_ = _info_list;
12208 			_tmp327_ = vala_list_get (_tmp326_, _info_index);
12209 			info = (ValaGirParserParameterInfo*) _tmp327_;
12210 			_tmp328_ = info;
12211 			if (!_tmp328_->keep) {
12212 				_vala_gir_parser_parameter_info_unref0 (info);
12213 				continue;
12214 			}
12215 			_tmp329_ = s;
12216 			if (VALA_IS_CALLABLE (_tmp329_)) {
12217 				ValaSymbol* _tmp330_;
12218 				ValaGirParserParameterInfo* _tmp331_;
12219 				ValaParameter* _tmp332_;
12220 				_tmp330_ = s;
12221 				_tmp331_ = info;
12222 				_tmp332_ = _tmp331_->param;
12223 				vala_callable_add_parameter (G_TYPE_CHECK_INSTANCE_CAST (_tmp330_, VALA_TYPE_CALLABLE, ValaCallable), _tmp332_);
12224 			}
12225 			_tmp333_ = info;
12226 			if (_tmp333_->array_length_idx != -1) {
12227 				ValaGirParserParameterInfo* _tmp334_;
12228 				ValaList* _tmp335_;
12229 				gint _tmp336_;
12230 				gint _tmp337_;
12231 				ValaGirParserParameterInfo* _tmp342_;
12232 				ValaParameter* _tmp343_;
12233 				ValaList* _tmp344_;
12234 				ValaGirParserParameterInfo* _tmp345_;
12235 				gpointer _tmp346_;
12236 				ValaGirParserParameterInfo* _tmp347_;
12237 				_tmp334_ = info;
12238 				_tmp335_ = parameters;
12239 				_tmp336_ = vala_collection_get_size ((ValaCollection*) _tmp335_);
12240 				_tmp337_ = _tmp336_;
12241 				if (_tmp334_->array_length_idx >= _tmp337_) {
12242 					ValaGirParserParameterInfo* _tmp338_;
12243 					ValaParameter* _tmp339_;
12244 					ValaSourceReference* _tmp340_;
12245 					ValaSourceReference* _tmp341_;
12246 					_tmp338_ = info;
12247 					_tmp339_ = _tmp338_->param;
12248 					_tmp340_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp339_);
12249 					_tmp341_ = _tmp340_;
12250 					vala_report_error (_tmp341_, "invalid array_length index");
12251 					_vala_gir_parser_parameter_info_unref0 (info);
12252 					continue;
12253 				}
12254 				_tmp342_ = info;
12255 				_tmp343_ = _tmp342_->param;
12256 				_tmp344_ = parameters;
12257 				_tmp345_ = info;
12258 				_tmp346_ = vala_list_get (_tmp344_, _tmp345_->array_length_idx);
12259 				_tmp347_ = (ValaGirParserParameterInfo*) _tmp346_;
12260 				vala_gir_parser_set_array_ccode (self, (ValaSymbol*) _tmp343_, _tmp347_);
12261 				_vala_gir_parser_parameter_info_unref0 (_tmp347_);
12262 			}
12263 			_tmp348_ = info;
12264 			if (_tmp348_->closure_idx != -1) {
12265 				ValaGirParserParameterInfo* _tmp349_;
12266 				ValaList* _tmp350_;
12267 				gint _tmp351_;
12268 				gint _tmp352_;
12269 				ValaList* _tmp357_;
12270 				ValaGirParserParameterInfo* _tmp358_;
12271 				gpointer _tmp359_;
12272 				ValaGirParserParameterInfo* _tmp360_;
12273 				gchar* _tmp361_;
12274 				gchar* _tmp362_;
12275 				ValaGirParserParameterInfo* _tmp363_;
12276 				gchar* _tmp364_;
12277 				gchar* _tmp365_;
12278 				gboolean _tmp366_;
12279 				_tmp349_ = info;
12280 				_tmp350_ = parameters;
12281 				_tmp351_ = vala_collection_get_size ((ValaCollection*) _tmp350_);
12282 				_tmp352_ = _tmp351_;
12283 				if (_tmp349_->closure_idx >= _tmp352_) {
12284 					ValaGirParserParameterInfo* _tmp353_;
12285 					ValaParameter* _tmp354_;
12286 					ValaSourceReference* _tmp355_;
12287 					ValaSourceReference* _tmp356_;
12288 					_tmp353_ = info;
12289 					_tmp354_ = _tmp353_->param;
12290 					_tmp355_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp354_);
12291 					_tmp356_ = _tmp355_;
12292 					vala_report_error (_tmp356_, "invalid closure index");
12293 					_vala_gir_parser_parameter_info_unref0 (info);
12294 					continue;
12295 				}
12296 				_tmp357_ = parameters;
12297 				_tmp358_ = info;
12298 				_tmp359_ = vala_list_get (_tmp357_, _tmp358_->closure_idx);
12299 				_tmp360_ = (ValaGirParserParameterInfo*) _tmp359_;
12300 				_tmp361_ = g_strdup_printf ("%g", (gdouble) _tmp360_->vala_idx);
12301 				_tmp362_ = _tmp361_;
12302 				_tmp363_ = info;
12303 				_tmp364_ = g_strdup_printf ("%g", _tmp363_->vala_idx + 0.1);
12304 				_tmp365_ = _tmp364_;
12305 				_tmp366_ = g_strcmp0 (_tmp362_, _tmp365_) != 0;
12306 				_g_free0 (_tmp365_);
12307 				_g_free0 (_tmp362_);
12308 				_vala_gir_parser_parameter_info_unref0 (_tmp360_);
12309 				if (_tmp366_) {
12310 					ValaGirParserParameterInfo* _tmp367_;
12311 					ValaParameter* _tmp368_;
12312 					ValaList* _tmp369_;
12313 					ValaGirParserParameterInfo* _tmp370_;
12314 					gpointer _tmp371_;
12315 					ValaGirParserParameterInfo* _tmp372_;
12316 					_tmp367_ = info;
12317 					_tmp368_ = _tmp367_->param;
12318 					_tmp369_ = parameters;
12319 					_tmp370_ = info;
12320 					_tmp371_ = vala_list_get (_tmp369_, _tmp370_->closure_idx);
12321 					_tmp372_ = (ValaGirParserParameterInfo*) _tmp371_;
12322 					vala_code_node_set_attribute_double ((ValaCodeNode*) _tmp368_, "CCode", "delegate_target_pos", (gdouble) _tmp372_->vala_idx, NULL);
12323 					_vala_gir_parser_parameter_info_unref0 (_tmp372_);
12324 				}
12325 			}
12326 			_tmp373_ = info;
12327 			if (_tmp373_->destroy_idx != -1) {
12328 				ValaGirParserParameterInfo* _tmp374_;
12329 				ValaList* _tmp375_;
12330 				gint _tmp376_;
12331 				gint _tmp377_;
12332 				ValaList* _tmp382_;
12333 				ValaGirParserParameterInfo* _tmp383_;
12334 				gpointer _tmp384_;
12335 				ValaGirParserParameterInfo* _tmp385_;
12336 				gchar* _tmp386_;
12337 				gchar* _tmp387_;
12338 				ValaGirParserParameterInfo* _tmp388_;
12339 				gchar* _tmp389_;
12340 				gchar* _tmp390_;
12341 				gboolean _tmp391_;
12342 				_tmp374_ = info;
12343 				_tmp375_ = parameters;
12344 				_tmp376_ = vala_collection_get_size ((ValaCollection*) _tmp375_);
12345 				_tmp377_ = _tmp376_;
12346 				if (_tmp374_->destroy_idx >= _tmp377_) {
12347 					ValaGirParserParameterInfo* _tmp378_;
12348 					ValaParameter* _tmp379_;
12349 					ValaSourceReference* _tmp380_;
12350 					ValaSourceReference* _tmp381_;
12351 					_tmp378_ = info;
12352 					_tmp379_ = _tmp378_->param;
12353 					_tmp380_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp379_);
12354 					_tmp381_ = _tmp380_;
12355 					vala_report_error (_tmp381_, "invalid destroy index");
12356 					_vala_gir_parser_parameter_info_unref0 (info);
12357 					continue;
12358 				}
12359 				_tmp382_ = parameters;
12360 				_tmp383_ = info;
12361 				_tmp384_ = vala_list_get (_tmp382_, _tmp383_->destroy_idx);
12362 				_tmp385_ = (ValaGirParserParameterInfo*) _tmp384_;
12363 				_tmp386_ = g_strdup_printf ("%g", (gdouble) _tmp385_->vala_idx);
12364 				_tmp387_ = _tmp386_;
12365 				_tmp388_ = info;
12366 				_tmp389_ = g_strdup_printf ("%g", _tmp388_->vala_idx + 0.2);
12367 				_tmp390_ = _tmp389_;
12368 				_tmp391_ = g_strcmp0 (_tmp387_, _tmp390_) != 0;
12369 				_g_free0 (_tmp390_);
12370 				_g_free0 (_tmp387_);
12371 				_vala_gir_parser_parameter_info_unref0 (_tmp385_);
12372 				if (_tmp391_) {
12373 					ValaGirParserParameterInfo* _tmp392_;
12374 					ValaParameter* _tmp393_;
12375 					ValaList* _tmp394_;
12376 					ValaGirParserParameterInfo* _tmp395_;
12377 					gpointer _tmp396_;
12378 					ValaGirParserParameterInfo* _tmp397_;
12379 					_tmp392_ = info;
12380 					_tmp393_ = _tmp392_->param;
12381 					_tmp394_ = parameters;
12382 					_tmp395_ = info;
12383 					_tmp396_ = vala_list_get (_tmp394_, _tmp395_->destroy_idx);
12384 					_tmp397_ = (ValaGirParserParameterInfo*) _tmp396_;
12385 					vala_code_node_set_attribute_double ((ValaCodeNode*) _tmp393_, "CCode", "destroy_notify_pos", (gdouble) _tmp397_->vala_idx, NULL);
12386 					_vala_gir_parser_parameter_info_unref0 (_tmp397_);
12387 				}
12388 			}
12389 			_tmp398_ = info;
12390 			if (_tmp398_->is_async) {
12391 				ValaDataType* resolved_type = NULL;
12392 				ValaGirParserParameterInfo* _tmp399_;
12393 				ValaParameter* _tmp400_;
12394 				ValaDataType* _tmp401_;
12395 				ValaDataType* _tmp402_;
12396 				ValaDataType* _tmp403_;
12397 				ValaDataType* _tmp404_;
12398 				ValaDataType* _tmp413_;
12399 				_tmp399_ = info;
12400 				_tmp400_ = _tmp399_->param;
12401 				_tmp401_ = vala_variable_get_variable_type ((ValaVariable*) _tmp400_);
12402 				_tmp402_ = _tmp401_;
12403 				_tmp403_ = _vala_code_node_ref0 (_tmp402_);
12404 				resolved_type = _tmp403_;
12405 				_tmp404_ = resolved_type;
12406 				if (VALA_IS_UNRESOLVED_TYPE (_tmp404_)) {
12407 					ValaSymbol* resolved_symbol = NULL;
12408 					ValaGirParserNode* _tmp405_;
12409 					ValaDataType* _tmp406_;
12410 					ValaUnresolvedSymbol* _tmp407_;
12411 					ValaUnresolvedSymbol* _tmp408_;
12412 					ValaSymbol* _tmp409_;
12413 					ValaSymbol* _tmp410_;
12414 					_tmp405_ = node->parent;
12415 					_tmp406_ = resolved_type;
12416 					_tmp407_ = vala_unresolved_type_get_unresolved_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp406_, VALA_TYPE_UNRESOLVED_TYPE, ValaUnresolvedType));
12417 					_tmp408_ = _tmp407_;
12418 					_tmp409_ = vala_gir_parser_resolve_symbol (self, _tmp405_, _tmp408_);
12419 					resolved_symbol = _tmp409_;
12420 					_tmp410_ = resolved_symbol;
12421 					if (VALA_IS_DELEGATE (_tmp410_)) {
12422 						ValaSymbol* _tmp411_;
12423 						ValaDelegateType* _tmp412_;
12424 						_tmp411_ = resolved_symbol;
12425 						_tmp412_ = vala_delegate_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp411_, VALA_TYPE_DELEGATE, ValaDelegate));
12426 						_vala_code_node_unref0 (resolved_type);
12427 						resolved_type = (ValaDataType*) _tmp412_;
12428 					}
12429 					_vala_code_node_unref0 (resolved_symbol);
12430 				}
12431 				_tmp413_ = resolved_type;
12432 				if (VALA_IS_DELEGATE_TYPE (_tmp413_)) {
12433 					ValaDelegate* d = NULL;
12434 					ValaDataType* _tmp414_;
12435 					ValaDelegate* _tmp415_;
12436 					ValaDelegate* _tmp416_;
12437 					ValaDelegate* _tmp417_;
12438 					gboolean _tmp418_ = FALSE;
12439 					ValaDelegate* _tmp419_;
12440 					const gchar* _tmp420_;
12441 					const gchar* _tmp421_;
12442 					_tmp414_ = resolved_type;
12443 					_tmp415_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp414_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
12444 					_tmp416_ = _tmp415_;
12445 					_tmp417_ = _vala_code_node_ref0 (_tmp416_);
12446 					d = _tmp417_;
12447 					_tmp419_ = d;
12448 					_tmp420_ = vala_symbol_get_name ((ValaSymbol*) _tmp419_);
12449 					_tmp421_ = _tmp420_;
12450 					if (g_strcmp0 (_tmp421_, "DestroyNotify") == 0) {
12451 						ValaDelegate* _tmp422_;
12452 						ValaSymbol* _tmp423_;
12453 						ValaSymbol* _tmp424_;
12454 						const gchar* _tmp425_;
12455 						const gchar* _tmp426_;
12456 						_tmp422_ = d;
12457 						_tmp423_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp422_);
12458 						_tmp424_ = _tmp423_;
12459 						_tmp425_ = vala_symbol_get_name (_tmp424_);
12460 						_tmp426_ = _tmp425_;
12461 						_tmp418_ = g_strcmp0 (_tmp426_, "GLib") == 0;
12462 					} else {
12463 						_tmp418_ = FALSE;
12464 					}
12465 					if (!_tmp418_) {
12466 						ValaGirParserParameterInfo* _tmp427_;
12467 						ValaParameter* _tmp428_;
12468 						gboolean _tmp429_ = FALSE;
12469 						ValaGirParserParameterInfo* _tmp430_;
12470 						ValaGirParserParameterInfo* _tmp432_;
12471 						ValaParameter* _tmp433_;
12472 						ValaDataType* _tmp434_;
12473 						ValaDataType* _tmp435_;
12474 						_tmp427_ = info;
12475 						_tmp428_ = _tmp427_->param;
12476 						vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp428_, "CCode", "scope", "async", NULL);
12477 						_tmp430_ = info;
12478 						if (_tmp430_->closure_idx != -1) {
12479 							ValaGirParserParameterInfo* _tmp431_;
12480 							_tmp431_ = info;
12481 							_tmp429_ = _tmp431_->destroy_idx != -1;
12482 						} else {
12483 							_tmp429_ = FALSE;
12484 						}
12485 						_tmp432_ = info;
12486 						_tmp433_ = _tmp432_->param;
12487 						_tmp434_ = vala_variable_get_variable_type ((ValaVariable*) _tmp433_);
12488 						_tmp435_ = _tmp434_;
12489 						vala_data_type_set_value_owned (_tmp435_, _tmp429_);
12490 					}
12491 					_vala_code_node_unref0 (d);
12492 				}
12493 				_vala_code_node_unref0 (resolved_type);
12494 			} else {
12495 				ValaDataType* resolved_type = NULL;
12496 				ValaGirParserParameterInfo* _tmp436_;
12497 				ValaParameter* _tmp437_;
12498 				ValaDataType* _tmp438_;
12499 				ValaDataType* _tmp439_;
12500 				ValaDataType* _tmp440_;
12501 				ValaDataType* _tmp441_;
12502 				_tmp436_ = info;
12503 				_tmp437_ = _tmp436_->param;
12504 				_tmp438_ = vala_variable_get_variable_type ((ValaVariable*) _tmp437_);
12505 				_tmp439_ = _tmp438_;
12506 				_tmp440_ = _vala_code_node_ref0 (_tmp439_);
12507 				resolved_type = _tmp440_;
12508 				_tmp441_ = resolved_type;
12509 				if (VALA_IS_DELEGATE_TYPE (_tmp441_)) {
12510 					gboolean _tmp442_ = FALSE;
12511 					ValaGirParserParameterInfo* _tmp443_;
12512 					ValaGirParserParameterInfo* _tmp445_;
12513 					ValaParameter* _tmp446_;
12514 					ValaDataType* _tmp447_;
12515 					ValaDataType* _tmp448_;
12516 					_tmp443_ = info;
12517 					if (_tmp443_->closure_idx != -1) {
12518 						ValaGirParserParameterInfo* _tmp444_;
12519 						_tmp444_ = info;
12520 						_tmp442_ = _tmp444_->destroy_idx != -1;
12521 					} else {
12522 						_tmp442_ = FALSE;
12523 					}
12524 					_tmp445_ = info;
12525 					_tmp446_ = _tmp445_->param;
12526 					_tmp447_ = vala_variable_get_variable_type ((ValaVariable*) _tmp446_);
12527 					_tmp448_ = _tmp447_;
12528 					vala_data_type_set_value_owned (_tmp448_, _tmp442_);
12529 				}
12530 				_vala_code_node_unref0 (resolved_type);
12531 			}
12532 			_vala_gir_parser_parameter_info_unref0 (info);
12533 		}
12534 		_vala_iterable_unref0 (_info_list);
12535 	}
12536 	_tmp450_ = return_type;
12537 	if (VALA_IS_ARRAY_TYPE (_tmp450_)) {
12538 		_tmp449_ = node->return_array_length_idx >= 0;
12539 	} else {
12540 		_tmp449_ = FALSE;
12541 	}
12542 	if (_tmp449_) {
12543 		ValaSymbol* _tmp451_;
12544 		ValaList* _tmp452_;
12545 		gpointer _tmp453_;
12546 		ValaGirParserParameterInfo* _tmp454_;
12547 		_tmp451_ = s;
12548 		_tmp452_ = parameters;
12549 		_tmp453_ = vala_list_get (_tmp452_, node->return_array_length_idx);
12550 		_tmp454_ = (ValaGirParserParameterInfo*) _tmp453_;
12551 		vala_gir_parser_set_array_ccode (self, _tmp451_, _tmp454_);
12552 		_vala_gir_parser_parameter_info_unref0 (_tmp454_);
12553 	}
12554 	_tmp455_ = s;
12555 	if (VALA_IS_CALLABLE (_tmp455_)) {
12556 		ValaSymbol* _tmp456_;
12557 		ValaDataType* _tmp457_;
12558 		_tmp456_ = s;
12559 		_tmp457_ = return_type;
12560 		vala_callable_set_return_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp456_, VALA_TYPE_CALLABLE, ValaCallable), _tmp457_);
12561 	}
12562 	_vala_code_node_unref0 (return_type);
12563 	_vala_iterable_unref0 (parameters);
12564 	_vala_code_node_unref0 (s);
12565 }
12566 
12567 static void
vala_gir_parser_find_parent(ValaGirParser * self,const gchar * cname,ValaGirParserNode * current,ValaGirParserNode ** best,gint * match)12568 vala_gir_parser_find_parent (ValaGirParser* self,
12569                              const gchar* cname,
12570                              ValaGirParserNode* current,
12571                              ValaGirParserNode* * best,
12572                              gint* match)
12573 {
12574 	ValaGirParserNode* old_best = NULL;
12575 	ValaGirParserNode* _tmp0_;
12576 	ValaSymbol* _tmp1_;
12577 	ValaGirParserNode* _tmp21_;
12578 	gint current_match = 0;
12579 	gchar* _tmp22_;
12580 	gchar* _tmp23_;
12581 	gint _tmp24_;
12582 	gint _tmp25_;
12583 	gint _tmp26_;
12584 	g_return_if_fail (self != NULL);
12585 	g_return_if_fail (cname != NULL);
12586 	g_return_if_fail (current != NULL);
12587 	g_return_if_fail (*best != NULL);
12588 	_tmp0_ = _vala_gir_parser_node_ref0 (*best);
12589 	old_best = _tmp0_;
12590 	_tmp1_ = current->symbol;
12591 	if (VALA_IS_NAMESPACE (_tmp1_)) {
12592 		{
12593 			ValaArrayList* _child_list = NULL;
12594 			ValaArrayList* _tmp2_;
12595 			ValaArrayList* _tmp3_;
12596 			gint _child_size = 0;
12597 			ValaArrayList* _tmp4_;
12598 			gint _tmp5_;
12599 			gint _tmp6_;
12600 			gint _child_index = 0;
12601 			_tmp2_ = current->members;
12602 			_tmp3_ = _vala_iterable_ref0 (_tmp2_);
12603 			_child_list = _tmp3_;
12604 			_tmp4_ = _child_list;
12605 			_tmp5_ = vala_collection_get_size ((ValaCollection*) _tmp4_);
12606 			_tmp6_ = _tmp5_;
12607 			_child_size = _tmp6_;
12608 			_child_index = -1;
12609 			while (TRUE) {
12610 				gint _tmp7_;
12611 				gint _tmp8_;
12612 				ValaGirParserNode* child = NULL;
12613 				ValaArrayList* _tmp9_;
12614 				gpointer _tmp10_;
12615 				gboolean _tmp11_ = FALSE;
12616 				gboolean _tmp12_ = FALSE;
12617 				ValaGirParserNode* _tmp13_;
12618 				ValaSymbol* _tmp14_;
12619 				_child_index = _child_index + 1;
12620 				_tmp7_ = _child_index;
12621 				_tmp8_ = _child_size;
12622 				if (!(_tmp7_ < _tmp8_)) {
12623 					break;
12624 				}
12625 				_tmp9_ = _child_list;
12626 				_tmp10_ = vala_list_get ((ValaList*) _tmp9_, _child_index);
12627 				child = (ValaGirParserNode*) _tmp10_;
12628 				_tmp13_ = child;
12629 				_tmp14_ = _tmp13_->symbol;
12630 				if (_tmp14_ == NULL) {
12631 					_tmp12_ = TRUE;
12632 				} else {
12633 					ValaGirParserNode* _tmp15_;
12634 					ValaSymbol* _tmp16_;
12635 					_tmp15_ = child;
12636 					_tmp16_ = _tmp15_->symbol;
12637 					_tmp12_ = vala_gir_parser_is_container (_tmp16_);
12638 				}
12639 				if (_tmp12_) {
12640 					ValaGirParserNode* _tmp17_;
12641 					gchar* _tmp18_;
12642 					gchar* _tmp19_;
12643 					_tmp17_ = child;
12644 					_tmp18_ = vala_gir_parser_node_get_lower_case_cprefix (_tmp17_);
12645 					_tmp19_ = _tmp18_;
12646 					_tmp11_ = g_str_has_prefix (cname, _tmp19_);
12647 					_g_free0 (_tmp19_);
12648 				} else {
12649 					_tmp11_ = FALSE;
12650 				}
12651 				if (_tmp11_) {
12652 					ValaGirParserNode* _tmp20_;
12653 					_tmp20_ = child;
12654 					vala_gir_parser_find_parent (self, cname, _tmp20_, best, match);
12655 				}
12656 				_vala_gir_parser_node_unref0 (child);
12657 			}
12658 			_vala_iterable_unref0 (_child_list);
12659 		}
12660 	}
12661 	_tmp21_ = old_best;
12662 	if ((*best) != _tmp21_) {
12663 		_vala_gir_parser_node_unref0 (old_best);
12664 		return;
12665 	}
12666 	_tmp22_ = vala_gir_parser_node_get_lower_case_cprefix (current);
12667 	_tmp23_ = _tmp22_;
12668 	_tmp24_ = strlen (_tmp23_);
12669 	_tmp25_ = _tmp24_;
12670 	_tmp26_ = _tmp25_;
12671 	_g_free0 (_tmp23_);
12672 	current_match = _tmp26_;
12673 	if (current_match > (*match)) {
12674 		ValaGirParserNode* _tmp27_;
12675 		*match = current_match;
12676 		_tmp27_ = _vala_gir_parser_node_ref0 (current);
12677 		_vala_gir_parser_node_unref0 (*best);
12678 		*best = _tmp27_;
12679 	}
12680 	_vala_gir_parser_node_unref0 (old_best);
12681 }
12682 
12683 static gboolean
vala_gir_parser_same_gir(ValaGirParser * self,ValaSymbol * gir_component,ValaSymbol * sym)12684 vala_gir_parser_same_gir (ValaGirParser* self,
12685                           ValaSymbol* gir_component,
12686                           ValaSymbol* sym)
12687 {
12688 	gchar* gir_name = NULL;
12689 	ValaSourceReference* _tmp0_;
12690 	ValaSourceReference* _tmp1_;
12691 	ValaSourceFile* _tmp2_;
12692 	ValaSourceFile* _tmp3_;
12693 	const gchar* _tmp4_;
12694 	const gchar* _tmp5_;
12695 	gchar* _tmp6_;
12696 	gchar* gir_version = NULL;
12697 	ValaSourceReference* _tmp7_;
12698 	ValaSourceReference* _tmp8_;
12699 	ValaSourceFile* _tmp9_;
12700 	ValaSourceFile* _tmp10_;
12701 	const gchar* _tmp11_;
12702 	const gchar* _tmp12_;
12703 	gchar* _tmp13_;
12704 	ValaSourceReference* _tmp14_;
12705 	ValaSourceReference* _tmp15_;
12706 	ValaSourceFile* _tmp16_;
12707 	ValaSourceFile* _tmp17_;
12708 	const gchar* _tmp18_;
12709 	const gchar* _tmp19_;
12710 	gchar* _tmp20_;
12711 	gchar* _tmp21_;
12712 	gboolean _tmp22_;
12713 	gboolean result = FALSE;
12714 	g_return_val_if_fail (self != NULL, FALSE);
12715 	g_return_val_if_fail (gir_component != NULL, FALSE);
12716 	g_return_val_if_fail (sym != NULL, FALSE);
12717 	_tmp0_ = vala_code_node_get_source_reference ((ValaCodeNode*) gir_component);
12718 	_tmp1_ = _tmp0_;
12719 	_tmp2_ = vala_source_reference_get_file (_tmp1_);
12720 	_tmp3_ = _tmp2_;
12721 	_tmp4_ = vala_source_file_get_gir_namespace (_tmp3_);
12722 	_tmp5_ = _tmp4_;
12723 	_tmp6_ = g_strdup (_tmp5_);
12724 	gir_name = _tmp6_;
12725 	_tmp7_ = vala_code_node_get_source_reference ((ValaCodeNode*) gir_component);
12726 	_tmp8_ = _tmp7_;
12727 	_tmp9_ = vala_source_reference_get_file (_tmp8_);
12728 	_tmp10_ = _tmp9_;
12729 	_tmp11_ = vala_source_file_get_gir_version (_tmp10_);
12730 	_tmp12_ = _tmp11_;
12731 	_tmp13_ = g_strdup (_tmp12_);
12732 	gir_version = _tmp13_;
12733 	_tmp14_ = vala_code_node_get_source_reference ((ValaCodeNode*) sym);
12734 	_tmp15_ = _tmp14_;
12735 	_tmp16_ = vala_source_reference_get_file (_tmp15_);
12736 	_tmp17_ = _tmp16_;
12737 	_tmp18_ = vala_source_file_get_filename (_tmp17_);
12738 	_tmp19_ = _tmp18_;
12739 	_tmp20_ = g_strdup_printf ("%s-%s", gir_name, gir_version);
12740 	_tmp21_ = _tmp20_;
12741 	_tmp22_ = string_contains (_tmp19_, _tmp21_);
12742 	_g_free0 (_tmp21_);
12743 	result = _tmp22_;
12744 	_g_free0 (gir_version);
12745 	_g_free0 (gir_name);
12746 	return result;
12747 }
12748 
12749 static void
vala_gir_parser_process_namespace_method(ValaGirParser * self,ValaGirParserNode * ns,ValaGirParserNode * node)12750 vala_gir_parser_process_namespace_method (ValaGirParser* self,
12751                                           ValaGirParserNode* ns,
12752                                           ValaGirParserNode* node)
12753 {
12754 	gchar* ns_cprefix = NULL;
12755 	gchar* _tmp0_;
12756 	ValaMethod* method = NULL;
12757 	ValaSymbol* _tmp1_;
12758 	ValaMethod* _tmp2_;
12759 	gchar* cname = NULL;
12760 	gchar* _tmp3_;
12761 	ValaParameter* first_param = NULL;
12762 	ValaList* _tmp4_;
12763 	gint _tmp5_;
12764 	gint _tmp6_;
12765 	gboolean _tmp12_ = FALSE;
12766 	gboolean _tmp13_ = FALSE;
12767 	ValaParameter* _tmp14_;
12768 	gint match = 0;
12769 	ValaGirParserNode* parent = NULL;
12770 	ValaGirParserNode* _tmp73_;
12771 	const gchar* _tmp74_;
12772 	gchar* new_name = NULL;
12773 	ValaMethod* _tmp75_;
12774 	const gchar* _tmp76_;
12775 	const gchar* _tmp77_;
12776 	ValaGirParserNode* _tmp78_;
12777 	gchar* _tmp79_;
12778 	gchar* _tmp80_;
12779 	gint _tmp81_;
12780 	gint _tmp82_;
12781 	const gchar* _tmp83_;
12782 	gint _tmp84_;
12783 	gint _tmp85_;
12784 	gchar* _tmp86_;
12785 	gchar* _tmp87_;
12786 	gboolean _tmp88_ = FALSE;
12787 	ValaMethod* _tmp89_;
12788 	ValaGirParserNode* _tmp90_;
12789 	ValaSymbol* _tmp91_;
12790 	g_return_if_fail (self != NULL);
12791 	g_return_if_fail (ns != NULL);
12792 	g_return_if_fail (node != NULL);
12793 	_tmp0_ = vala_gir_parser_node_get_lower_case_cprefix (ns);
12794 	ns_cprefix = _tmp0_;
12795 	_tmp1_ = node->symbol;
12796 	_tmp2_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_METHOD, ValaMethod));
12797 	method = _tmp2_;
12798 	_tmp3_ = vala_gir_parser_node_get_cname (node);
12799 	cname = _tmp3_;
12800 	first_param = NULL;
12801 	_tmp4_ = node->parameters;
12802 	_tmp5_ = vala_collection_get_size ((ValaCollection*) _tmp4_);
12803 	_tmp6_ = _tmp5_;
12804 	if (_tmp6_ > 0) {
12805 		ValaList* _tmp7_;
12806 		gpointer _tmp8_;
12807 		ValaGirParserParameterInfo* _tmp9_;
12808 		ValaParameter* _tmp10_;
12809 		ValaParameter* _tmp11_;
12810 		_tmp7_ = node->parameters;
12811 		_tmp8_ = vala_list_get (_tmp7_, 0);
12812 		_tmp9_ = (ValaGirParserParameterInfo*) _tmp8_;
12813 		_tmp10_ = _tmp9_->param;
12814 		_tmp11_ = _vala_code_node_ref0 (_tmp10_);
12815 		_vala_code_node_unref0 (first_param);
12816 		first_param = _tmp11_;
12817 		_vala_gir_parser_parameter_info_unref0 (_tmp9_);
12818 	}
12819 	_tmp14_ = first_param;
12820 	if (_tmp14_ != NULL) {
12821 		ValaParameter* _tmp15_;
12822 		ValaParameterDirection _tmp16_;
12823 		ValaParameterDirection _tmp17_;
12824 		_tmp15_ = first_param;
12825 		_tmp16_ = vala_parameter_get_direction (_tmp15_);
12826 		_tmp17_ = _tmp16_;
12827 		_tmp13_ = _tmp17_ == VALA_PARAMETER_DIRECTION_IN;
12828 	} else {
12829 		_tmp13_ = FALSE;
12830 	}
12831 	if (_tmp13_) {
12832 		ValaParameter* _tmp18_;
12833 		ValaDataType* _tmp19_;
12834 		ValaDataType* _tmp20_;
12835 		_tmp18_ = first_param;
12836 		_tmp19_ = vala_variable_get_variable_type ((ValaVariable*) _tmp18_);
12837 		_tmp20_ = _tmp19_;
12838 		_tmp12_ = VALA_IS_UNRESOLVED_TYPE (_tmp20_);
12839 	} else {
12840 		_tmp12_ = FALSE;
12841 	}
12842 	if (_tmp12_) {
12843 		ValaUnresolvedSymbol* sym = NULL;
12844 		ValaParameter* _tmp21_;
12845 		ValaDataType* _tmp22_;
12846 		ValaDataType* _tmp23_;
12847 		ValaUnresolvedSymbol* _tmp24_;
12848 		ValaUnresolvedSymbol* _tmp25_;
12849 		ValaUnresolvedSymbol* _tmp26_;
12850 		ValaGirParserNode* parent = NULL;
12851 		ValaUnresolvedSymbol* _tmp27_;
12852 		ValaGirParserNode* _tmp28_;
12853 		gboolean _tmp29_ = FALSE;
12854 		gboolean _tmp30_ = FALSE;
12855 		gboolean _tmp31_ = FALSE;
12856 		gboolean _tmp32_ = FALSE;
12857 		ValaGirParserNode* _tmp33_;
12858 		_tmp21_ = first_param;
12859 		_tmp22_ = vala_variable_get_variable_type ((ValaVariable*) _tmp21_);
12860 		_tmp23_ = _tmp22_;
12861 		_tmp24_ = vala_unresolved_type_get_unresolved_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp23_, VALA_TYPE_UNRESOLVED_TYPE, ValaUnresolvedType));
12862 		_tmp25_ = _tmp24_;
12863 		_tmp26_ = _vala_code_node_ref0 (_tmp25_);
12864 		sym = _tmp26_;
12865 		_tmp27_ = sym;
12866 		_tmp28_ = vala_gir_parser_resolve_node (self, ns, _tmp27_, FALSE);
12867 		parent = _tmp28_;
12868 		_tmp33_ = parent;
12869 		if (_tmp33_ != NULL) {
12870 			ValaMethod* _tmp34_;
12871 			ValaGirParserNode* _tmp35_;
12872 			ValaSymbol* _tmp36_;
12873 			_tmp34_ = method;
12874 			_tmp35_ = parent;
12875 			_tmp36_ = _tmp35_->symbol;
12876 			_tmp32_ = vala_gir_parser_same_gir (self, (ValaSymbol*) _tmp34_, _tmp36_);
12877 		} else {
12878 			_tmp32_ = FALSE;
12879 		}
12880 		if (_tmp32_) {
12881 			ValaGirParserNode* _tmp37_;
12882 			ValaGirParserNode* _tmp38_;
12883 			_tmp37_ = parent;
12884 			_tmp38_ = _tmp37_->parent;
12885 			_tmp31_ = _tmp38_ == ns;
12886 		} else {
12887 			_tmp31_ = FALSE;
12888 		}
12889 		if (_tmp31_) {
12890 			ValaGirParserNode* _tmp39_;
12891 			ValaSymbol* _tmp40_;
12892 			_tmp39_ = parent;
12893 			_tmp40_ = _tmp39_->symbol;
12894 			_tmp30_ = vala_gir_parser_is_container (_tmp40_);
12895 		} else {
12896 			_tmp30_ = FALSE;
12897 		}
12898 		if (_tmp30_) {
12899 			const gchar* _tmp41_;
12900 			ValaGirParserNode* _tmp42_;
12901 			gchar* _tmp43_;
12902 			gchar* _tmp44_;
12903 			_tmp41_ = cname;
12904 			_tmp42_ = parent;
12905 			_tmp43_ = vala_gir_parser_node_get_lower_case_cprefix (_tmp42_);
12906 			_tmp44_ = _tmp43_;
12907 			_tmp29_ = g_str_has_prefix (_tmp41_, _tmp44_);
12908 			_g_free0 (_tmp44_);
12909 		} else {
12910 			_tmp29_ = FALSE;
12911 		}
12912 		if (_tmp29_) {
12913 			gchar* new_name = NULL;
12914 			ValaMethod* _tmp45_;
12915 			const gchar* _tmp46_;
12916 			const gchar* _tmp47_;
12917 			ValaGirParserNode* _tmp48_;
12918 			gchar* _tmp49_;
12919 			gchar* _tmp50_;
12920 			gint _tmp51_;
12921 			gint _tmp52_;
12922 			const gchar* _tmp53_;
12923 			gint _tmp54_;
12924 			gint _tmp55_;
12925 			gchar* _tmp56_;
12926 			gchar* _tmp57_;
12927 			ValaGirParserNode* _tmp58_;
12928 			const gchar* _tmp59_;
12929 			ValaGirParserNode* _tmp60_;
12930 			ValaGirParserNode* _tmp61_;
12931 			gboolean _tmp62_;
12932 			_tmp45_ = method;
12933 			_tmp46_ = vala_symbol_get_name ((ValaSymbol*) _tmp45_);
12934 			_tmp47_ = _tmp46_;
12935 			_tmp48_ = parent;
12936 			_tmp49_ = vala_gir_parser_node_get_lower_case_cprefix (_tmp48_);
12937 			_tmp50_ = _tmp49_;
12938 			_tmp51_ = strlen (_tmp50_);
12939 			_tmp52_ = _tmp51_;
12940 			_tmp53_ = ns_cprefix;
12941 			_tmp54_ = strlen (_tmp53_);
12942 			_tmp55_ = _tmp54_;
12943 			_tmp56_ = string_substring (_tmp47_, (glong) (_tmp52_ - _tmp55_), (glong) -1);
12944 			_tmp57_ = _tmp56_;
12945 			_g_free0 (_tmp50_);
12946 			new_name = _tmp57_;
12947 			_tmp58_ = parent;
12948 			_tmp59_ = new_name;
12949 			_tmp60_ = vala_gir_parser_node_lookup (_tmp58_, _tmp59_, FALSE, NULL);
12950 			_tmp61_ = _tmp60_;
12951 			_tmp62_ = _tmp61_ == NULL;
12952 			_vala_gir_parser_node_unref0 (_tmp61_);
12953 			if (_tmp62_) {
12954 				const gchar* _tmp63_;
12955 				gchar* _tmp64_;
12956 				ValaList* _tmp65_;
12957 				gpointer _tmp66_;
12958 				ValaGirParserParameterInfo* _tmp67_;
12959 				gint _tmp68_;
12960 				ValaMethod* _tmp69_;
12961 				const gchar* _tmp70_;
12962 				ValaMethod* _tmp71_;
12963 				ValaGirParserNode* _tmp72_;
12964 				vala_gir_parser_node_remove_member (ns, node);
12965 				_tmp63_ = new_name;
12966 				_tmp64_ = g_strdup (_tmp63_);
12967 				_g_free0 (node->name);
12968 				node->name = _tmp64_;
12969 				_tmp65_ = node->parameters;
12970 				_tmp66_ = vala_list_remove_at (_tmp65_, 0);
12971 				_tmp67_ = (ValaGirParserParameterInfo*) _tmp66_;
12972 				_vala_gir_parser_parameter_info_unref0 (_tmp67_);
12973 				_tmp68_ = node->return_array_length_idx;
12974 				node->return_array_length_idx = _tmp68_ - 1;
12975 				_tmp69_ = method;
12976 				_tmp70_ = new_name;
12977 				vala_symbol_set_name ((ValaSymbol*) _tmp69_, _tmp70_);
12978 				_tmp71_ = method;
12979 				vala_method_set_binding (_tmp71_, VALA_MEMBER_BINDING_INSTANCE);
12980 				_tmp72_ = parent;
12981 				vala_gir_parser_node_add_member (_tmp72_, node);
12982 			}
12983 			_g_free0 (new_name);
12984 			_vala_gir_parser_node_unref0 (parent);
12985 			_vala_code_node_unref0 (sym);
12986 			_vala_code_node_unref0 (first_param);
12987 			_g_free0 (cname);
12988 			_vala_code_node_unref0 (method);
12989 			_g_free0 (ns_cprefix);
12990 			return;
12991 		}
12992 		_vala_gir_parser_node_unref0 (parent);
12993 		_vala_code_node_unref0 (sym);
12994 	}
12995 	match = 0;
12996 	_tmp73_ = _vala_gir_parser_node_ref0 (ns);
12997 	parent = _tmp73_;
12998 	_tmp74_ = cname;
12999 	vala_gir_parser_find_parent (self, _tmp74_, ns, &parent, &match);
13000 	_tmp75_ = method;
13001 	_tmp76_ = vala_symbol_get_name ((ValaSymbol*) _tmp75_);
13002 	_tmp77_ = _tmp76_;
13003 	_tmp78_ = parent;
13004 	_tmp79_ = vala_gir_parser_node_get_lower_case_cprefix (_tmp78_);
13005 	_tmp80_ = _tmp79_;
13006 	_tmp81_ = strlen (_tmp80_);
13007 	_tmp82_ = _tmp81_;
13008 	_tmp83_ = ns_cprefix;
13009 	_tmp84_ = strlen (_tmp83_);
13010 	_tmp85_ = _tmp84_;
13011 	_tmp86_ = string_substring (_tmp77_, (glong) (_tmp82_ - _tmp85_), (glong) -1);
13012 	_tmp87_ = _tmp86_;
13013 	_g_free0 (_tmp80_);
13014 	new_name = _tmp87_;
13015 	_tmp89_ = method;
13016 	_tmp90_ = parent;
13017 	_tmp91_ = _tmp90_->symbol;
13018 	if (vala_gir_parser_same_gir (self, (ValaSymbol*) _tmp89_, _tmp91_)) {
13019 		ValaGirParserNode* _tmp92_;
13020 		const gchar* _tmp93_;
13021 		ValaGirParserNode* _tmp94_;
13022 		ValaGirParserNode* _tmp95_;
13023 		_tmp92_ = parent;
13024 		_tmp93_ = new_name;
13025 		_tmp94_ = vala_gir_parser_node_lookup (_tmp92_, _tmp93_, FALSE, NULL);
13026 		_tmp95_ = _tmp94_;
13027 		_tmp88_ = _tmp95_ == NULL;
13028 		_vala_gir_parser_node_unref0 (_tmp95_);
13029 	} else {
13030 		_tmp88_ = FALSE;
13031 	}
13032 	if (_tmp88_) {
13033 		const gchar* _tmp96_;
13034 		gchar* _tmp97_;
13035 		ValaMethod* _tmp98_;
13036 		const gchar* _tmp99_;
13037 		ValaGirParserNode* _tmp100_;
13038 		vala_gir_parser_node_remove_member (ns, node);
13039 		_tmp96_ = new_name;
13040 		_tmp97_ = g_strdup (_tmp96_);
13041 		_g_free0 (node->name);
13042 		node->name = _tmp97_;
13043 		_tmp98_ = method;
13044 		_tmp99_ = new_name;
13045 		vala_symbol_set_name ((ValaSymbol*) _tmp98_, _tmp99_);
13046 		_tmp100_ = parent;
13047 		vala_gir_parser_node_add_member (_tmp100_, node);
13048 	}
13049 	_g_free0 (new_name);
13050 	_vala_gir_parser_node_unref0 (parent);
13051 	_vala_code_node_unref0 (first_param);
13052 	_g_free0 (cname);
13053 	_vala_code_node_unref0 (method);
13054 	_g_free0 (ns_cprefix);
13055 }
13056 
13057 static void
vala_gir_parser_process_virtual_method_field(ValaGirParser * self,ValaGirParserNode * node,ValaDelegate * d,ValaUnresolvedSymbol * gtype_struct_for)13058 vala_gir_parser_process_virtual_method_field (ValaGirParser* self,
13059                                               ValaGirParserNode* node,
13060                                               ValaDelegate* d,
13061                                               ValaUnresolvedSymbol* gtype_struct_for)
13062 {
13063 	ValaGirParserNode* gtype_node = NULL;
13064 	ValaGirParserNode* _tmp0_;
13065 	ValaGirParserNode* _tmp1_;
13066 	gboolean _tmp2_ = FALSE;
13067 	ValaGirParserNode* _tmp3_;
13068 	ValaArrayList* nodes = NULL;
13069 	ValaGirParserNode* _tmp14_;
13070 	const gchar* _tmp15_;
13071 	const gchar* _tmp16_;
13072 	ValaArrayList* _tmp17_;
13073 	ValaArrayList* _tmp18_;
13074 	g_return_if_fail (self != NULL);
13075 	g_return_if_fail (node != NULL);
13076 	g_return_if_fail (d != NULL);
13077 	g_return_if_fail (gtype_struct_for != NULL);
13078 	_tmp0_ = node->parent;
13079 	_tmp1_ = vala_gir_parser_resolve_node (self, _tmp0_, gtype_struct_for, FALSE);
13080 	gtype_node = _tmp1_;
13081 	_tmp3_ = gtype_node;
13082 	if (_tmp3_ == NULL) {
13083 		_tmp2_ = TRUE;
13084 	} else {
13085 		ValaGirParserNode* _tmp4_;
13086 		ValaSymbol* _tmp5_;
13087 		_tmp4_ = gtype_node;
13088 		_tmp5_ = _tmp4_->symbol;
13089 		_tmp2_ = !VALA_IS_OBJECT_TYPE_SYMBOL (_tmp5_);
13090 	}
13091 	if (_tmp2_) {
13092 		ValaSourceReference* _tmp6_;
13093 		ValaSourceReference* _tmp7_;
13094 		gchar* _tmp8_;
13095 		gchar* _tmp9_;
13096 		gchar* _tmp10_;
13097 		gchar* _tmp11_;
13098 		gchar* _tmp12_;
13099 		gchar* _tmp13_;
13100 		_tmp6_ = vala_code_node_get_source_reference ((ValaCodeNode*) gtype_struct_for);
13101 		_tmp7_ = _tmp6_;
13102 		_tmp8_ = vala_code_node_to_string ((ValaCodeNode*) gtype_struct_for);
13103 		_tmp9_ = _tmp8_;
13104 		_tmp10_ = vala_gir_parser_node_to_string (node);
13105 		_tmp11_ = _tmp10_;
13106 		_tmp12_ = g_strdup_printf ("Unknown symbol `%s' for virtual method field `%s'", _tmp9_, _tmp11_);
13107 		_tmp13_ = _tmp12_;
13108 		vala_report_error (_tmp7_, _tmp13_);
13109 		_g_free0 (_tmp13_);
13110 		_g_free0 (_tmp11_);
13111 		_g_free0 (_tmp9_);
13112 	}
13113 	_tmp14_ = gtype_node;
13114 	_tmp15_ = vala_symbol_get_name ((ValaSymbol*) d);
13115 	_tmp16_ = _tmp15_;
13116 	_tmp17_ = vala_gir_parser_node_lookup_all (_tmp14_, _tmp16_);
13117 	nodes = _tmp17_;
13118 	_tmp18_ = nodes;
13119 	if (_tmp18_ == NULL) {
13120 		_vala_iterable_unref0 (nodes);
13121 		_vala_gir_parser_node_unref0 (gtype_node);
13122 		return;
13123 	}
13124 	{
13125 		ValaArrayList* _n_list = NULL;
13126 		ValaArrayList* _tmp19_;
13127 		ValaArrayList* _tmp20_;
13128 		gint _n_size = 0;
13129 		ValaArrayList* _tmp21_;
13130 		gint _tmp22_;
13131 		gint _tmp23_;
13132 		gint _n_index = 0;
13133 		_tmp19_ = nodes;
13134 		_tmp20_ = _vala_iterable_ref0 (_tmp19_);
13135 		_n_list = _tmp20_;
13136 		_tmp21_ = _n_list;
13137 		_tmp22_ = vala_collection_get_size ((ValaCollection*) _tmp21_);
13138 		_tmp23_ = _tmp22_;
13139 		_n_size = _tmp23_;
13140 		_n_index = -1;
13141 		while (TRUE) {
13142 			gint _tmp24_;
13143 			gint _tmp25_;
13144 			ValaGirParserNode* n = NULL;
13145 			ValaArrayList* _tmp26_;
13146 			gpointer _tmp27_;
13147 			ValaGirParserNode* _tmp28_;
13148 			_n_index = _n_index + 1;
13149 			_tmp24_ = _n_index;
13150 			_tmp25_ = _n_size;
13151 			if (!(_tmp24_ < _tmp25_)) {
13152 				break;
13153 			}
13154 			_tmp26_ = _n_list;
13155 			_tmp27_ = vala_list_get ((ValaList*) _tmp26_, _n_index);
13156 			n = (ValaGirParserNode*) _tmp27_;
13157 			_tmp28_ = n;
13158 			if (node != _tmp28_) {
13159 				ValaGirParserNode* _tmp29_;
13160 				_tmp29_ = n;
13161 				vala_gir_parser_node_process (_tmp29_, self);
13162 			}
13163 			_vala_gir_parser_node_unref0 (n);
13164 		}
13165 		_vala_iterable_unref0 (_n_list);
13166 	}
13167 	{
13168 		ValaArrayList* _n_list = NULL;
13169 		ValaArrayList* _tmp30_;
13170 		ValaArrayList* _tmp31_;
13171 		gint _n_size = 0;
13172 		ValaArrayList* _tmp32_;
13173 		gint _tmp33_;
13174 		gint _tmp34_;
13175 		gint _n_index = 0;
13176 		_tmp30_ = nodes;
13177 		_tmp31_ = _vala_iterable_ref0 (_tmp30_);
13178 		_n_list = _tmp31_;
13179 		_tmp32_ = _n_list;
13180 		_tmp33_ = vala_collection_get_size ((ValaCollection*) _tmp32_);
13181 		_tmp34_ = _tmp33_;
13182 		_n_size = _tmp34_;
13183 		_n_index = -1;
13184 		while (TRUE) {
13185 			gint _tmp35_;
13186 			gint _tmp36_;
13187 			ValaGirParserNode* n = NULL;
13188 			ValaArrayList* _tmp37_;
13189 			gpointer _tmp38_;
13190 			ValaGirParserNode* _tmp39_;
13191 			ValaSymbol* sym = NULL;
13192 			ValaGirParserNode* _tmp40_;
13193 			ValaSymbol* _tmp41_;
13194 			ValaSymbol* _tmp42_;
13195 			ValaSymbol* _tmp43_;
13196 			_n_index = _n_index + 1;
13197 			_tmp35_ = _n_index;
13198 			_tmp36_ = _n_size;
13199 			if (!(_tmp35_ < _tmp36_)) {
13200 				break;
13201 			}
13202 			_tmp37_ = _n_list;
13203 			_tmp38_ = vala_list_get ((ValaList*) _tmp37_, _n_index);
13204 			n = (ValaGirParserNode*) _tmp38_;
13205 			_tmp39_ = n;
13206 			if (_tmp39_->merged) {
13207 				_vala_gir_parser_node_unref0 (n);
13208 				continue;
13209 			}
13210 			_tmp40_ = n;
13211 			_tmp41_ = _tmp40_->symbol;
13212 			_tmp42_ = _vala_code_node_ref0 (_tmp41_);
13213 			sym = _tmp42_;
13214 			_tmp43_ = sym;
13215 			if (VALA_IS_SIGNAL (_tmp43_)) {
13216 				ValaSignal* sig = NULL;
13217 				ValaSymbol* _tmp44_;
13218 				ValaSignal* _tmp45_;
13219 				ValaSignal* _tmp46_;
13220 				ValaSignal* _tmp47_;
13221 				_tmp44_ = sym;
13222 				_tmp45_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp44_, VALA_TYPE_SIGNAL, ValaSignal));
13223 				sig = _tmp45_;
13224 				_tmp46_ = sig;
13225 				vala_signal_set_is_virtual (_tmp46_, TRUE);
13226 				_tmp47_ = sig;
13227 				vala_gir_parser_assume_parameter_names (self, _tmp47_, (ValaSymbol*) d, TRUE);
13228 				_vala_code_node_unref0 (sig);
13229 			} else {
13230 				ValaSymbol* _tmp48_;
13231 				_tmp48_ = sym;
13232 				if (VALA_IS_PROPERTY (_tmp48_)) {
13233 					ValaProperty* prop = NULL;
13234 					ValaSymbol* _tmp49_;
13235 					ValaProperty* _tmp50_;
13236 					ValaProperty* _tmp51_;
13237 					_tmp49_ = sym;
13238 					_tmp50_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp49_, VALA_TYPE_PROPERTY, ValaProperty));
13239 					prop = _tmp50_;
13240 					_tmp51_ = prop;
13241 					vala_property_set_is_virtual (_tmp51_, TRUE);
13242 					_vala_code_node_unref0 (prop);
13243 				}
13244 			}
13245 			_vala_code_node_unref0 (sym);
13246 			_vala_gir_parser_node_unref0 (n);
13247 		}
13248 		_vala_iterable_unref0 (_n_list);
13249 	}
13250 	_vala_iterable_unref0 (nodes);
13251 	_vala_gir_parser_node_unref0 (gtype_node);
13252 }
13253 
13254 static void
vala_gir_parser_process_async_method(ValaGirParser * self,ValaGirParserNode * node)13255 vala_gir_parser_process_async_method (ValaGirParser* self,
13256                                       ValaGirParserNode* node)
13257 {
13258 	ValaMethod* m = NULL;
13259 	ValaSymbol* _tmp0_;
13260 	ValaMethod* _tmp1_;
13261 	gboolean requires_pointer = FALSE;
13262 	gchar* finish_method_base = NULL;
13263 	ValaMethod* _tmp28_;
13264 	const gchar* _tmp29_;
13265 	const gchar* _tmp30_;
13266 	ValaGirParserNode* finish_method_node = NULL;
13267 	ValaGirParserNode* _tmp51_;
13268 	const gchar* _tmp52_;
13269 	gchar* _tmp53_;
13270 	gchar* _tmp54_;
13271 	ValaGirParserNode* _tmp55_;
13272 	ValaGirParserNode* _tmp56_;
13273 	ValaGirParserNode* _tmp57_;
13274 	ValaMethod* method = NULL;
13275 	ValaMethod* _tmp78_;
13276 	ValaMethod* _tmp79_;
13277 	gboolean _tmp80_ = FALSE;
13278 	ValaGirParserNode* _tmp81_;
13279 	g_return_if_fail (self != NULL);
13280 	g_return_if_fail (node != NULL);
13281 	_tmp0_ = node->symbol;
13282 	_tmp1_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALA_TYPE_METHOD, ValaMethod));
13283 	m = _tmp1_;
13284 	requires_pointer = FALSE;
13285 	{
13286 		ValaList* _param_list = NULL;
13287 		ValaMethod* _tmp2_;
13288 		ValaList* _tmp3_;
13289 		ValaList* _tmp4_;
13290 		gint _param_size = 0;
13291 		ValaList* _tmp5_;
13292 		gint _tmp6_;
13293 		gint _tmp7_;
13294 		gint _param_index = 0;
13295 		_tmp2_ = m;
13296 		_tmp3_ = vala_callable_get_parameters ((ValaCallable*) _tmp2_);
13297 		_tmp4_ = _vala_iterable_ref0 (_tmp3_);
13298 		_param_list = _tmp4_;
13299 		_tmp5_ = _param_list;
13300 		_tmp6_ = vala_collection_get_size ((ValaCollection*) _tmp5_);
13301 		_tmp7_ = _tmp6_;
13302 		_param_size = _tmp7_;
13303 		_param_index = -1;
13304 		while (TRUE) {
13305 			gint _tmp8_;
13306 			gint _tmp9_;
13307 			ValaParameter* param = NULL;
13308 			ValaList* _tmp10_;
13309 			gpointer _tmp11_;
13310 			ValaParameter* _tmp12_;
13311 			ValaParameterDirection _tmp13_;
13312 			ValaParameterDirection _tmp14_;
13313 			_param_index = _param_index + 1;
13314 			_tmp8_ = _param_index;
13315 			_tmp9_ = _param_size;
13316 			if (!(_tmp8_ < _tmp9_)) {
13317 				break;
13318 			}
13319 			_tmp10_ = _param_list;
13320 			_tmp11_ = vala_list_get (_tmp10_, _param_index);
13321 			param = (ValaParameter*) _tmp11_;
13322 			_tmp12_ = param;
13323 			_tmp13_ = vala_parameter_get_direction (_tmp12_);
13324 			_tmp14_ = _tmp13_;
13325 			if (_tmp14_ == VALA_PARAMETER_DIRECTION_IN) {
13326 				requires_pointer = TRUE;
13327 			} else {
13328 				if (requires_pointer) {
13329 					ValaParameter* _tmp15_;
13330 					ValaParameter* _tmp16_;
13331 					ValaDataType* _tmp17_;
13332 					ValaDataType* _tmp18_;
13333 					ValaParameter* _tmp19_;
13334 					ValaParameter* _tmp20_;
13335 					ValaDataType* _tmp21_;
13336 					ValaDataType* _tmp22_;
13337 					ValaPointerType* _tmp23_;
13338 					ValaPointerType* _tmp24_;
13339 					ValaParameter* _tmp25_;
13340 					ValaSourceReference* _tmp26_;
13341 					ValaSourceReference* _tmp27_;
13342 					_tmp15_ = param;
13343 					vala_parameter_set_direction (_tmp15_, VALA_PARAMETER_DIRECTION_IN);
13344 					_tmp16_ = param;
13345 					_tmp17_ = vala_variable_get_variable_type ((ValaVariable*) _tmp16_);
13346 					_tmp18_ = _tmp17_;
13347 					vala_data_type_set_nullable (_tmp18_, FALSE);
13348 					_tmp19_ = param;
13349 					_tmp20_ = param;
13350 					_tmp21_ = vala_variable_get_variable_type ((ValaVariable*) _tmp20_);
13351 					_tmp22_ = _tmp21_;
13352 					_tmp23_ = vala_pointer_type_new (_tmp22_, NULL);
13353 					_tmp24_ = _tmp23_;
13354 					vala_variable_set_variable_type ((ValaVariable*) _tmp19_, (ValaDataType*) _tmp24_);
13355 					_vala_code_node_unref0 (_tmp24_);
13356 					_tmp25_ = param;
13357 					_tmp26_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp25_);
13358 					_tmp27_ = _tmp26_;
13359 					vala_report_warning (_tmp27_, "Synchronous out-parameters are not supported in async methods");
13360 				}
13361 			}
13362 			_vala_code_node_unref0 (param);
13363 		}
13364 		_vala_iterable_unref0 (_param_list);
13365 	}
13366 	_tmp28_ = m;
13367 	_tmp29_ = vala_symbol_get_name ((ValaSymbol*) _tmp28_);
13368 	_tmp30_ = _tmp29_;
13369 	if (_tmp30_ == NULL) {
13370 		ValaMethod* _tmp31_;
13371 		gchar* _tmp32_;
13372 		_tmp31_ = m;
13373 		_vala_assert (VALA_IS_CREATION_METHOD (_tmp31_), "m is CreationMethod");
13374 		_tmp32_ = g_strdup ("new");
13375 		_g_free0 (finish_method_base);
13376 		finish_method_base = _tmp32_;
13377 	} else {
13378 		ValaMethod* _tmp33_;
13379 		const gchar* _tmp34_;
13380 		const gchar* _tmp35_;
13381 		_tmp33_ = m;
13382 		_tmp34_ = vala_symbol_get_name ((ValaSymbol*) _tmp33_);
13383 		_tmp35_ = _tmp34_;
13384 		if (g_str_has_suffix (_tmp35_, "_async")) {
13385 			ValaMethod* _tmp36_;
13386 			const gchar* _tmp37_;
13387 			const gchar* _tmp38_;
13388 			ValaMethod* _tmp39_;
13389 			const gchar* _tmp40_;
13390 			const gchar* _tmp41_;
13391 			gint _tmp42_;
13392 			gint _tmp43_;
13393 			gint _tmp44_;
13394 			gint _tmp45_;
13395 			gchar* _tmp46_;
13396 			_tmp36_ = m;
13397 			_tmp37_ = vala_symbol_get_name ((ValaSymbol*) _tmp36_);
13398 			_tmp38_ = _tmp37_;
13399 			_tmp39_ = m;
13400 			_tmp40_ = vala_symbol_get_name ((ValaSymbol*) _tmp39_);
13401 			_tmp41_ = _tmp40_;
13402 			_tmp42_ = strlen (_tmp41_);
13403 			_tmp43_ = _tmp42_;
13404 			_tmp44_ = strlen ("_async");
13405 			_tmp45_ = _tmp44_;
13406 			_tmp46_ = string_substring (_tmp38_, (glong) 0, (glong) (_tmp43_ - _tmp45_));
13407 			_g_free0 (finish_method_base);
13408 			finish_method_base = _tmp46_;
13409 		} else {
13410 			ValaMethod* _tmp47_;
13411 			const gchar* _tmp48_;
13412 			const gchar* _tmp49_;
13413 			gchar* _tmp50_;
13414 			_tmp47_ = m;
13415 			_tmp48_ = vala_symbol_get_name ((ValaSymbol*) _tmp47_);
13416 			_tmp49_ = _tmp48_;
13417 			_tmp50_ = g_strdup (_tmp49_);
13418 			_g_free0 (finish_method_base);
13419 			finish_method_base = _tmp50_;
13420 		}
13421 	}
13422 	_tmp51_ = node->parent;
13423 	_tmp52_ = finish_method_base;
13424 	_tmp53_ = g_strconcat (_tmp52_, "_finish", NULL);
13425 	_tmp54_ = _tmp53_;
13426 	_tmp55_ = vala_gir_parser_node_lookup (_tmp51_, _tmp54_, FALSE, NULL);
13427 	_tmp56_ = _tmp55_;
13428 	_g_free0 (_tmp54_);
13429 	finish_method_node = _tmp56_;
13430 	_tmp57_ = finish_method_node;
13431 	if (_tmp57_ == NULL) {
13432 		gchar* method_cname = NULL;
13433 		gchar* _tmp58_;
13434 		_tmp58_ = vala_gir_parser_node_get_finish_cname (node);
13435 		method_cname = _tmp58_;
13436 		{
13437 			ValaArrayList* _n_list = NULL;
13438 			ValaGirParserNode* _tmp59_;
13439 			ValaArrayList* _tmp60_;
13440 			ValaArrayList* _tmp61_;
13441 			gint _n_size = 0;
13442 			ValaArrayList* _tmp62_;
13443 			gint _tmp63_;
13444 			gint _tmp64_;
13445 			gint _n_index = 0;
13446 			_tmp59_ = node->parent;
13447 			_tmp60_ = _tmp59_->members;
13448 			_tmp61_ = _vala_iterable_ref0 (_tmp60_);
13449 			_n_list = _tmp61_;
13450 			_tmp62_ = _n_list;
13451 			_tmp63_ = vala_collection_get_size ((ValaCollection*) _tmp62_);
13452 			_tmp64_ = _tmp63_;
13453 			_n_size = _tmp64_;
13454 			_n_index = -1;
13455 			while (TRUE) {
13456 				gint _tmp65_;
13457 				gint _tmp66_;
13458 				ValaGirParserNode* n = NULL;
13459 				ValaArrayList* _tmp67_;
13460 				gpointer _tmp68_;
13461 				gboolean _tmp69_ = FALSE;
13462 				ValaGirParserNode* _tmp70_;
13463 				ValaSymbol* _tmp71_;
13464 				_n_index = _n_index + 1;
13465 				_tmp65_ = _n_index;
13466 				_tmp66_ = _n_size;
13467 				if (!(_tmp65_ < _tmp66_)) {
13468 					break;
13469 				}
13470 				_tmp67_ = _n_list;
13471 				_tmp68_ = vala_list_get ((ValaList*) _tmp67_, _n_index);
13472 				n = (ValaGirParserNode*) _tmp68_;
13473 				_tmp70_ = n;
13474 				_tmp71_ = _tmp70_->symbol;
13475 				if (VALA_IS_METHOD (_tmp71_)) {
13476 					ValaGirParserNode* _tmp72_;
13477 					gchar* _tmp73_;
13478 					gchar* _tmp74_;
13479 					const gchar* _tmp75_;
13480 					_tmp72_ = n;
13481 					_tmp73_ = vala_gir_parser_node_get_cname (_tmp72_);
13482 					_tmp74_ = _tmp73_;
13483 					_tmp75_ = method_cname;
13484 					_tmp69_ = g_strcmp0 (_tmp74_, _tmp75_) == 0;
13485 					_g_free0 (_tmp74_);
13486 				} else {
13487 					_tmp69_ = FALSE;
13488 				}
13489 				if (_tmp69_) {
13490 					ValaGirParserNode* _tmp76_;
13491 					ValaGirParserNode* _tmp77_;
13492 					_tmp76_ = n;
13493 					_tmp77_ = _vala_gir_parser_node_ref0 (_tmp76_);
13494 					_vala_gir_parser_node_unref0 (finish_method_node);
13495 					finish_method_node = _tmp77_;
13496 					_vala_gir_parser_node_unref0 (n);
13497 					break;
13498 				}
13499 				_vala_gir_parser_node_unref0 (n);
13500 			}
13501 			_vala_iterable_unref0 (_n_list);
13502 		}
13503 		_g_free0 (method_cname);
13504 	}
13505 	_tmp78_ = m;
13506 	_tmp79_ = _vala_code_node_ref0 (_tmp78_);
13507 	method = _tmp79_;
13508 	_tmp81_ = finish_method_node;
13509 	if (_tmp81_ != NULL) {
13510 		ValaGirParserNode* _tmp82_;
13511 		ValaSymbol* _tmp83_;
13512 		_tmp82_ = finish_method_node;
13513 		_tmp83_ = _tmp82_->symbol;
13514 		_tmp80_ = VALA_IS_METHOD (_tmp83_);
13515 	} else {
13516 		_tmp80_ = FALSE;
13517 	}
13518 	if (_tmp80_) {
13519 		ValaGirParserNode* _tmp84_;
13520 		ValaMethod* finish_method = NULL;
13521 		ValaGirParserNode* _tmp85_;
13522 		ValaSymbol* _tmp86_;
13523 		ValaMethod* _tmp87_;
13524 		ValaMethod* _tmp88_;
13525 		ValaMethod* _tmp158_;
13526 		ValaMethod* _tmp159_;
13527 		ValaArrayList* error_types = NULL;
13528 		GEqualFunc _tmp192_;
13529 		ValaArrayList* _tmp193_;
13530 		ValaMethod* _tmp194_;
13531 		ValaArrayList* _tmp195_;
13532 		ValaMethod* _tmp196_;
13533 		ValaSourceReference* _tmp197_;
13534 		ValaSourceReference* _tmp198_;
13535 		ValaGirParserNode* _tmp210_;
13536 		ValaGirParserNode* _tmp211_;
13537 		_tmp84_ = finish_method_node;
13538 		vala_gir_parser_node_process (_tmp84_, self);
13539 		_tmp85_ = finish_method_node;
13540 		_tmp86_ = _tmp85_->symbol;
13541 		_tmp87_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp86_, VALA_TYPE_METHOD, ValaMethod));
13542 		finish_method = _tmp87_;
13543 		_tmp88_ = finish_method;
13544 		if (VALA_IS_CREATION_METHOD (_tmp88_)) {
13545 			ValaMethod* _tmp89_;
13546 			const gchar* _tmp90_;
13547 			const gchar* _tmp91_;
13548 			ValaMethod* _tmp92_;
13549 			ValaSourceReference* _tmp93_;
13550 			ValaSourceReference* _tmp94_;
13551 			ValaCreationMethod* _tmp95_;
13552 			ValaMethod* _tmp96_;
13553 			ValaMethod* _tmp97_;
13554 			ValaSymbolAccessibility _tmp98_;
13555 			ValaSymbolAccessibility _tmp99_;
13556 			ValaMethod* _tmp100_;
13557 			ValaMethod* _tmp101_;
13558 			ValaMethod* _tmp102_;
13559 			gboolean _tmp103_;
13560 			gboolean _tmp104_;
13561 			ValaMethod* _tmp105_;
13562 			GList* _tmp106_;
13563 			ValaMethod* _tmp111_;
13564 			gchar* _tmp112_;
13565 			gchar* _tmp113_;
13566 			const gchar* _tmp114_;
13567 			ValaMethod* _tmp137_;
13568 			ValaSymbol* _tmp138_;
13569 			_tmp89_ = finish_method;
13570 			_tmp90_ = vala_creation_method_get_class_name (G_TYPE_CHECK_INSTANCE_CAST (_tmp89_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod));
13571 			_tmp91_ = _tmp90_;
13572 			_tmp92_ = m;
13573 			_tmp93_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp92_);
13574 			_tmp94_ = _tmp93_;
13575 			_tmp95_ = vala_creation_method_new (_tmp91_, NULL, _tmp94_, NULL);
13576 			_vala_code_node_unref0 (method);
13577 			method = (ValaMethod*) _tmp95_;
13578 			_tmp96_ = method;
13579 			_tmp97_ = m;
13580 			_tmp98_ = vala_symbol_get_access ((ValaSymbol*) _tmp97_);
13581 			_tmp99_ = _tmp98_;
13582 			vala_symbol_set_access ((ValaSymbol*) _tmp96_, _tmp99_);
13583 			_tmp100_ = method;
13584 			vala_method_set_coroutine (_tmp100_, TRUE);
13585 			_tmp101_ = method;
13586 			_tmp102_ = finish_method;
13587 			_tmp103_ = vala_method_get_has_construct_function (_tmp102_);
13588 			_tmp104_ = _tmp103_;
13589 			vala_method_set_has_construct_function (_tmp101_, _tmp104_);
13590 			_tmp105_ = m;
13591 			_tmp106_ = ((ValaCodeNode*) _tmp105_)->attributes;
13592 			{
13593 				GList* a_collection = NULL;
13594 				GList* a_it = NULL;
13595 				a_collection = _tmp106_;
13596 				for (a_it = a_collection; a_it != NULL; a_it = a_it->next) {
13597 					ValaAttribute* _tmp107_;
13598 					ValaAttribute* a = NULL;
13599 					_tmp107_ = _vala_code_node_ref0 ((ValaAttribute*) a_it->data);
13600 					a = _tmp107_;
13601 					{
13602 						ValaMethod* _tmp108_;
13603 						ValaAttribute* _tmp109_;
13604 						ValaAttribute* _tmp110_;
13605 						_tmp108_ = method;
13606 						_tmp109_ = a;
13607 						_tmp110_ = _vala_code_node_ref0 (_tmp109_);
13608 						((ValaCodeNode*) _tmp108_)->attributes = g_list_append (((ValaCodeNode*) _tmp108_)->attributes, _tmp110_);
13609 						_vala_code_node_unref0 (a);
13610 					}
13611 				}
13612 			}
13613 			_tmp111_ = method;
13614 			_tmp112_ = vala_gir_parser_node_get_cname (node);
13615 			_tmp113_ = _tmp112_;
13616 			vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp111_, "CCode", "cname", _tmp113_, NULL);
13617 			_g_free0 (_tmp113_);
13618 			_tmp114_ = finish_method_base;
13619 			if (g_strcmp0 (_tmp114_, "new") == 0) {
13620 				ValaMethod* _tmp115_;
13621 				_tmp115_ = method;
13622 				vala_symbol_set_name ((ValaSymbol*) _tmp115_, NULL);
13623 			} else {
13624 				const gchar* _tmp116_;
13625 				_tmp116_ = finish_method_base;
13626 				if (g_str_has_prefix (_tmp116_, "new_")) {
13627 					ValaMethod* _tmp117_;
13628 					ValaMethod* _tmp118_;
13629 					const gchar* _tmp119_;
13630 					const gchar* _tmp120_;
13631 					gint _tmp121_;
13632 					gint _tmp122_;
13633 					gchar* _tmp123_;
13634 					gchar* _tmp124_;
13635 					_tmp117_ = method;
13636 					_tmp118_ = m;
13637 					_tmp119_ = vala_symbol_get_name ((ValaSymbol*) _tmp118_);
13638 					_tmp120_ = _tmp119_;
13639 					_tmp121_ = strlen ("new_");
13640 					_tmp122_ = _tmp121_;
13641 					_tmp123_ = string_substring (_tmp120_, (glong) _tmp122_, (glong) -1);
13642 					_tmp124_ = _tmp123_;
13643 					vala_symbol_set_name ((ValaSymbol*) _tmp117_, _tmp124_);
13644 					_g_free0 (_tmp124_);
13645 				}
13646 			}
13647 			{
13648 				ValaList* _param_list = NULL;
13649 				ValaMethod* _tmp125_;
13650 				ValaList* _tmp126_;
13651 				ValaList* _tmp127_;
13652 				gint _param_size = 0;
13653 				ValaList* _tmp128_;
13654 				gint _tmp129_;
13655 				gint _tmp130_;
13656 				gint _param_index = 0;
13657 				_tmp125_ = m;
13658 				_tmp126_ = vala_callable_get_parameters ((ValaCallable*) _tmp125_);
13659 				_tmp127_ = _vala_iterable_ref0 (_tmp126_);
13660 				_param_list = _tmp127_;
13661 				_tmp128_ = _param_list;
13662 				_tmp129_ = vala_collection_get_size ((ValaCollection*) _tmp128_);
13663 				_tmp130_ = _tmp129_;
13664 				_param_size = _tmp130_;
13665 				_param_index = -1;
13666 				while (TRUE) {
13667 					gint _tmp131_;
13668 					gint _tmp132_;
13669 					ValaParameter* param = NULL;
13670 					ValaList* _tmp133_;
13671 					gpointer _tmp134_;
13672 					ValaMethod* _tmp135_;
13673 					ValaParameter* _tmp136_;
13674 					_param_index = _param_index + 1;
13675 					_tmp131_ = _param_index;
13676 					_tmp132_ = _param_size;
13677 					if (!(_tmp131_ < _tmp132_)) {
13678 						break;
13679 					}
13680 					_tmp133_ = _param_list;
13681 					_tmp134_ = vala_list_get (_tmp133_, _param_index);
13682 					param = (ValaParameter*) _tmp134_;
13683 					_tmp135_ = method;
13684 					_tmp136_ = param;
13685 					vala_callable_add_parameter ((ValaCallable*) _tmp135_, _tmp136_);
13686 					_vala_code_node_unref0 (param);
13687 				}
13688 				_vala_iterable_unref0 (_param_list);
13689 			}
13690 			_tmp137_ = method;
13691 			_tmp138_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp137_);
13692 			_vala_code_node_unref0 (node->symbol);
13693 			node->symbol = _tmp138_;
13694 		} else {
13695 			ValaMethod* _tmp139_;
13696 			ValaMethod* _tmp140_;
13697 			ValaDataType* _tmp141_;
13698 			ValaDataType* _tmp142_;
13699 			ValaDataType* _tmp143_;
13700 			ValaDataType* _tmp144_;
13701 			ValaAttribute* a = NULL;
13702 			ValaMethod* _tmp145_;
13703 			ValaAttribute* _tmp146_;
13704 			ValaAttribute* _tmp147_;
13705 			gboolean _tmp148_ = FALSE;
13706 			ValaAttribute* _tmp149_;
13707 			gboolean _tmp153_ = FALSE;
13708 			ValaAttribute* _tmp154_;
13709 			_tmp139_ = method;
13710 			_tmp140_ = finish_method;
13711 			_tmp141_ = vala_callable_get_return_type ((ValaCallable*) _tmp140_);
13712 			_tmp142_ = _tmp141_;
13713 			_tmp143_ = vala_data_type_copy (_tmp142_);
13714 			_tmp144_ = _tmp143_;
13715 			vala_callable_set_return_type ((ValaCallable*) _tmp139_, _tmp144_);
13716 			_vala_code_node_unref0 (_tmp144_);
13717 			_tmp145_ = finish_method;
13718 			_tmp146_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp145_, "CCode");
13719 			_tmp147_ = _vala_code_node_ref0 (_tmp146_);
13720 			a = _tmp147_;
13721 			_tmp149_ = a;
13722 			if (_tmp149_ != NULL) {
13723 				ValaAttribute* _tmp150_;
13724 				_tmp150_ = a;
13725 				_tmp148_ = vala_attribute_has_argument (_tmp150_, "array_length");
13726 			} else {
13727 				_tmp148_ = FALSE;
13728 			}
13729 			if (_tmp148_) {
13730 				ValaMethod* _tmp151_;
13731 				ValaAttribute* _tmp152_;
13732 				_tmp151_ = method;
13733 				_tmp152_ = a;
13734 				vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp151_, "CCode", "array_length", vala_attribute_get_bool (_tmp152_, "array_length", FALSE), NULL);
13735 			}
13736 			_tmp154_ = a;
13737 			if (_tmp154_ != NULL) {
13738 				ValaAttribute* _tmp155_;
13739 				_tmp155_ = a;
13740 				_tmp153_ = vala_attribute_has_argument (_tmp155_, "array_null_terminated");
13741 			} else {
13742 				_tmp153_ = FALSE;
13743 			}
13744 			if (_tmp153_) {
13745 				ValaMethod* _tmp156_;
13746 				ValaAttribute* _tmp157_;
13747 				_tmp156_ = method;
13748 				_tmp157_ = a;
13749 				vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp156_, "CCode", "array_null_terminated", vala_attribute_get_bool (_tmp157_, "array_null_terminated", FALSE), NULL);
13750 			}
13751 			_vala_code_node_unref0 (a);
13752 		}
13753 		_tmp158_ = method;
13754 		_tmp159_ = finish_method;
13755 		vala_code_node_copy_attribute_double ((ValaCodeNode*) _tmp158_, (ValaCodeNode*) _tmp159_, "CCode", "async_result_pos");
13756 		{
13757 			ValaList* _param_list = NULL;
13758 			ValaMethod* _tmp160_;
13759 			ValaList* _tmp161_;
13760 			ValaList* _tmp162_;
13761 			gint _param_size = 0;
13762 			ValaList* _tmp163_;
13763 			gint _tmp164_;
13764 			gint _tmp165_;
13765 			gint _param_index = 0;
13766 			_tmp160_ = finish_method;
13767 			_tmp161_ = vala_callable_get_parameters ((ValaCallable*) _tmp160_);
13768 			_tmp162_ = _vala_iterable_ref0 (_tmp161_);
13769 			_param_list = _tmp162_;
13770 			_tmp163_ = _param_list;
13771 			_tmp164_ = vala_collection_get_size ((ValaCollection*) _tmp163_);
13772 			_tmp165_ = _tmp164_;
13773 			_param_size = _tmp165_;
13774 			_param_index = -1;
13775 			while (TRUE) {
13776 				gint _tmp166_;
13777 				gint _tmp167_;
13778 				ValaParameter* param = NULL;
13779 				ValaList* _tmp168_;
13780 				gpointer _tmp169_;
13781 				ValaParameter* _tmp170_;
13782 				ValaParameterDirection _tmp171_;
13783 				ValaParameterDirection _tmp172_;
13784 				_param_index = _param_index + 1;
13785 				_tmp166_ = _param_index;
13786 				_tmp167_ = _param_size;
13787 				if (!(_tmp166_ < _tmp167_)) {
13788 					break;
13789 				}
13790 				_tmp168_ = _param_list;
13791 				_tmp169_ = vala_list_get (_tmp168_, _param_index);
13792 				param = (ValaParameter*) _tmp169_;
13793 				_tmp170_ = param;
13794 				_tmp171_ = vala_parameter_get_direction (_tmp170_);
13795 				_tmp172_ = _tmp171_;
13796 				if (_tmp172_ == VALA_PARAMETER_DIRECTION_OUT) {
13797 					ValaParameter* async_param = NULL;
13798 					ValaParameter* _tmp173_;
13799 					ValaParameter* _tmp174_;
13800 					ValaMethod* _tmp175_;
13801 					ValaScope* _tmp176_;
13802 					ValaScope* _tmp177_;
13803 					ValaParameter* _tmp178_;
13804 					const gchar* _tmp179_;
13805 					const gchar* _tmp180_;
13806 					ValaSymbol* _tmp181_;
13807 					ValaSymbol* _tmp182_;
13808 					gboolean _tmp183_;
13809 					ValaMethod* _tmp190_;
13810 					ValaParameter* _tmp191_;
13811 					_tmp173_ = param;
13812 					_tmp174_ = vala_parameter_copy (_tmp173_);
13813 					async_param = _tmp174_;
13814 					_tmp175_ = method;
13815 					_tmp176_ = vala_symbol_get_scope ((ValaSymbol*) _tmp175_);
13816 					_tmp177_ = _tmp176_;
13817 					_tmp178_ = param;
13818 					_tmp179_ = vala_symbol_get_name ((ValaSymbol*) _tmp178_);
13819 					_tmp180_ = _tmp179_;
13820 					_tmp181_ = vala_scope_lookup (_tmp177_, _tmp180_);
13821 					_tmp182_ = _tmp181_;
13822 					_tmp183_ = _tmp182_ != NULL;
13823 					_vala_code_node_unref0 (_tmp182_);
13824 					if (_tmp183_) {
13825 						ValaParameter* _tmp184_;
13826 						ValaParameter* _tmp185_;
13827 						const gchar* _tmp186_;
13828 						const gchar* _tmp187_;
13829 						gchar* _tmp188_;
13830 						gchar* _tmp189_;
13831 						_tmp184_ = async_param;
13832 						_tmp185_ = async_param;
13833 						_tmp186_ = vala_symbol_get_name ((ValaSymbol*) _tmp185_);
13834 						_tmp187_ = _tmp186_;
13835 						_tmp188_ = g_strconcat (_tmp187_, "_out", NULL);
13836 						_tmp189_ = _tmp188_;
13837 						vala_symbol_set_name ((ValaSymbol*) _tmp185_, _tmp189_);
13838 						_g_free0 (_tmp189_);
13839 					}
13840 					_tmp190_ = method;
13841 					_tmp191_ = async_param;
13842 					vala_callable_add_parameter ((ValaCallable*) _tmp190_, _tmp191_);
13843 					_vala_code_node_unref0 (async_param);
13844 				}
13845 				_vala_code_node_unref0 (param);
13846 			}
13847 			_vala_iterable_unref0 (_param_list);
13848 		}
13849 		_tmp192_ = g_direct_equal;
13850 		_tmp193_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp192_);
13851 		error_types = _tmp193_;
13852 		_tmp194_ = finish_method;
13853 		_tmp195_ = error_types;
13854 		_tmp196_ = method;
13855 		_tmp197_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp196_);
13856 		_tmp198_ = _tmp197_;
13857 		vala_code_node_get_error_types ((ValaCodeNode*) _tmp194_, (ValaCollection*) _tmp195_, _tmp198_);
13858 		{
13859 			ValaArrayList* _error_type_list = NULL;
13860 			ValaArrayList* _tmp199_;
13861 			ValaArrayList* _tmp200_;
13862 			gint _error_type_size = 0;
13863 			ValaArrayList* _tmp201_;
13864 			gint _tmp202_;
13865 			gint _tmp203_;
13866 			gint _error_type_index = 0;
13867 			_tmp199_ = error_types;
13868 			_tmp200_ = _vala_iterable_ref0 (_tmp199_);
13869 			_error_type_list = _tmp200_;
13870 			_tmp201_ = _error_type_list;
13871 			_tmp202_ = vala_collection_get_size ((ValaCollection*) _tmp201_);
13872 			_tmp203_ = _tmp202_;
13873 			_error_type_size = _tmp203_;
13874 			_error_type_index = -1;
13875 			while (TRUE) {
13876 				gint _tmp204_;
13877 				gint _tmp205_;
13878 				ValaDataType* error_type = NULL;
13879 				ValaArrayList* _tmp206_;
13880 				gpointer _tmp207_;
13881 				ValaMethod* _tmp208_;
13882 				ValaDataType* _tmp209_;
13883 				_error_type_index = _error_type_index + 1;
13884 				_tmp204_ = _error_type_index;
13885 				_tmp205_ = _error_type_size;
13886 				if (!(_tmp204_ < _tmp205_)) {
13887 					break;
13888 				}
13889 				_tmp206_ = _error_type_list;
13890 				_tmp207_ = vala_list_get ((ValaList*) _tmp206_, _error_type_index);
13891 				error_type = (ValaDataType*) _tmp207_;
13892 				_tmp208_ = method;
13893 				_tmp209_ = error_type;
13894 				vala_method_add_error_type (_tmp208_, _tmp209_);
13895 				_vala_code_node_unref0 (error_type);
13896 			}
13897 			_vala_iterable_unref0 (_error_type_list);
13898 		}
13899 		_tmp210_ = finish_method_node;
13900 		_tmp210_->processed = TRUE;
13901 		_tmp211_ = finish_method_node;
13902 		_tmp211_->merged = TRUE;
13903 		_vala_iterable_unref0 (error_types);
13904 		_vala_code_node_unref0 (finish_method);
13905 	}
13906 	_vala_code_node_unref0 (method);
13907 	_vala_gir_parser_node_unref0 (finish_method_node);
13908 	_g_free0 (finish_method_base);
13909 	_vala_code_node_unref0 (m);
13910 }
13911 
13912 static guint
vala_gir_parser_unresolved_symbol_hash(ValaUnresolvedSymbol * sym)13913 vala_gir_parser_unresolved_symbol_hash (ValaUnresolvedSymbol* sym)
13914 {
13915 	GString* builder = NULL;
13916 	GString* _tmp0_;
13917 	GString* _tmp6_;
13918 	const gchar* _tmp7_;
13919 	guint result = 0U;
13920 	_tmp0_ = g_string_new ("");
13921 	builder = _tmp0_;
13922 	while (TRUE) {
13923 		GString* _tmp1_;
13924 		const gchar* _tmp2_;
13925 		const gchar* _tmp3_;
13926 		ValaUnresolvedSymbol* _tmp4_;
13927 		ValaUnresolvedSymbol* _tmp5_;
13928 		if (!(sym != NULL)) {
13929 			break;
13930 		}
13931 		_tmp1_ = builder;
13932 		_tmp2_ = vala_symbol_get_name ((ValaSymbol*) sym);
13933 		_tmp3_ = _tmp2_;
13934 		g_string_append (_tmp1_, _tmp3_);
13935 		_tmp4_ = vala_unresolved_symbol_get_inner (sym);
13936 		_tmp5_ = _tmp4_;
13937 		sym = _tmp5_;
13938 	}
13939 	_tmp6_ = builder;
13940 	_tmp7_ = _tmp6_->str;
13941 	result = g_str_hash (_tmp7_);
13942 	_g_string_free0 (builder);
13943 	return result;
13944 }
13945 
13946 static gboolean
vala_gir_parser_unresolved_symbol_equal(ValaUnresolvedSymbol * sym1,ValaUnresolvedSymbol * sym2)13947 vala_gir_parser_unresolved_symbol_equal (ValaUnresolvedSymbol* sym1,
13948                                          ValaUnresolvedSymbol* sym2)
13949 {
13950 	gboolean result = FALSE;
13951 	while (TRUE) {
13952 		gboolean _tmp0_ = FALSE;
13953 		const gchar* _tmp1_;
13954 		const gchar* _tmp2_;
13955 		const gchar* _tmp3_;
13956 		const gchar* _tmp4_;
13957 		ValaUnresolvedSymbol* _tmp5_;
13958 		ValaUnresolvedSymbol* _tmp6_;
13959 		ValaUnresolvedSymbol* _tmp7_;
13960 		ValaUnresolvedSymbol* _tmp8_;
13961 		if (!(sym1 != sym2)) {
13962 			break;
13963 		}
13964 		if (sym1 == NULL) {
13965 			_tmp0_ = TRUE;
13966 		} else {
13967 			_tmp0_ = sym2 == NULL;
13968 		}
13969 		if (_tmp0_) {
13970 			result = FALSE;
13971 			return result;
13972 		}
13973 		_tmp1_ = vala_symbol_get_name ((ValaSymbol*) sym1);
13974 		_tmp2_ = _tmp1_;
13975 		_tmp3_ = vala_symbol_get_name ((ValaSymbol*) sym2);
13976 		_tmp4_ = _tmp3_;
13977 		if (g_strcmp0 (_tmp2_, _tmp4_) != 0) {
13978 			result = FALSE;
13979 			return result;
13980 		}
13981 		_tmp5_ = vala_unresolved_symbol_get_inner (sym1);
13982 		_tmp6_ = _tmp5_;
13983 		sym1 = _tmp6_;
13984 		_tmp7_ = vala_unresolved_symbol_get_inner (sym2);
13985 		_tmp8_ = _tmp7_;
13986 		sym2 = _tmp8_;
13987 	}
13988 	result = TRUE;
13989 	return result;
13990 }
13991 
13992 static ValaGirParserNode*
vala_gir_parser_base_interface_property(ValaGirParser * self,ValaGirParserNode * prop_node)13993 vala_gir_parser_base_interface_property (ValaGirParser* self,
13994                                          ValaGirParserNode* prop_node)
13995 {
13996 	ValaClass* cl = NULL;
13997 	ValaGirParserNode* _tmp0_;
13998 	ValaSymbol* _tmp1_;
13999 	ValaClass* _tmp2_;
14000 	ValaClass* _tmp3_;
14001 	ValaGirParserNode* result = NULL;
14002 	g_return_val_if_fail (self != NULL, NULL);
14003 	g_return_val_if_fail (prop_node != NULL, NULL);
14004 	_tmp0_ = prop_node->parent;
14005 	_tmp1_ = _tmp0_->symbol;
14006 	_tmp2_ = _vala_code_node_ref0 (VALA_IS_CLASS (_tmp1_) ? ((ValaClass*) _tmp1_) : NULL);
14007 	cl = _tmp2_;
14008 	_tmp3_ = cl;
14009 	if (_tmp3_ == NULL) {
14010 		result = NULL;
14011 		_vala_code_node_unref0 (cl);
14012 		return result;
14013 	}
14014 	{
14015 		ValaList* _type_list = NULL;
14016 		ValaClass* _tmp4_;
14017 		ValaList* _tmp5_;
14018 		ValaList* _tmp6_;
14019 		gint _type_size = 0;
14020 		ValaList* _tmp7_;
14021 		gint _tmp8_;
14022 		gint _tmp9_;
14023 		gint _type_index = 0;
14024 		_tmp4_ = cl;
14025 		_tmp5_ = vala_class_get_base_types (_tmp4_);
14026 		_tmp6_ = _vala_iterable_ref0 (_tmp5_);
14027 		_type_list = _tmp6_;
14028 		_tmp7_ = _type_list;
14029 		_tmp8_ = vala_collection_get_size ((ValaCollection*) _tmp7_);
14030 		_tmp9_ = _tmp8_;
14031 		_type_size = _tmp9_;
14032 		_type_index = -1;
14033 		while (TRUE) {
14034 			gint _tmp10_;
14035 			gint _tmp11_;
14036 			ValaDataType* type = NULL;
14037 			ValaList* _tmp12_;
14038 			gpointer _tmp13_;
14039 			ValaDataType* _tmp14_;
14040 			ValaGirParserNode* base_node = NULL;
14041 			ValaGirParserNode* _tmp15_;
14042 			ValaDataType* _tmp16_;
14043 			ValaUnresolvedSymbol* _tmp17_;
14044 			ValaUnresolvedSymbol* _tmp18_;
14045 			ValaGirParserNode* _tmp19_;
14046 			gboolean _tmp20_ = FALSE;
14047 			ValaGirParserNode* _tmp21_;
14048 			_type_index = _type_index + 1;
14049 			_tmp10_ = _type_index;
14050 			_tmp11_ = _type_size;
14051 			if (!(_tmp10_ < _tmp11_)) {
14052 				break;
14053 			}
14054 			_tmp12_ = _type_list;
14055 			_tmp13_ = vala_list_get (_tmp12_, _type_index);
14056 			type = (ValaDataType*) _tmp13_;
14057 			_tmp14_ = type;
14058 			if (!VALA_IS_UNRESOLVED_TYPE (_tmp14_)) {
14059 				_vala_code_node_unref0 (type);
14060 				continue;
14061 			}
14062 			_tmp15_ = prop_node->parent;
14063 			_tmp16_ = type;
14064 			_tmp17_ = vala_unresolved_type_get_unresolved_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp16_, VALA_TYPE_UNRESOLVED_TYPE, ValaUnresolvedType));
14065 			_tmp18_ = _tmp17_;
14066 			_tmp19_ = vala_gir_parser_resolve_node (self, _tmp15_, _tmp18_, FALSE);
14067 			base_node = _tmp19_;
14068 			_tmp21_ = base_node;
14069 			if (_tmp21_ != NULL) {
14070 				ValaGirParserNode* _tmp22_;
14071 				ValaSymbol* _tmp23_;
14072 				_tmp22_ = base_node;
14073 				_tmp23_ = _tmp22_->symbol;
14074 				_tmp20_ = VALA_IS_INTERFACE (_tmp23_);
14075 			} else {
14076 				_tmp20_ = FALSE;
14077 			}
14078 			if (_tmp20_) {
14079 				ValaGirParserNode* base_prop_node = NULL;
14080 				ValaGirParserNode* _tmp24_;
14081 				const gchar* _tmp25_;
14082 				ValaGirParserNode* _tmp26_;
14083 				gboolean _tmp27_ = FALSE;
14084 				ValaGirParserNode* _tmp28_;
14085 				_tmp24_ = base_node;
14086 				_tmp25_ = prop_node->name;
14087 				_tmp26_ = vala_gir_parser_node_lookup (_tmp24_, _tmp25_, FALSE, NULL);
14088 				base_prop_node = _tmp26_;
14089 				_tmp28_ = base_prop_node;
14090 				if (_tmp28_ != NULL) {
14091 					ValaGirParserNode* _tmp29_;
14092 					ValaSymbol* _tmp30_;
14093 					_tmp29_ = base_prop_node;
14094 					_tmp30_ = _tmp29_->symbol;
14095 					_tmp27_ = VALA_IS_PROPERTY (_tmp30_);
14096 				} else {
14097 					_tmp27_ = FALSE;
14098 				}
14099 				if (_tmp27_) {
14100 					ValaProperty* base_property = NULL;
14101 					ValaGirParserNode* _tmp31_;
14102 					ValaSymbol* _tmp32_;
14103 					ValaProperty* _tmp33_;
14104 					gboolean _tmp34_ = FALSE;
14105 					ValaProperty* _tmp35_;
14106 					gboolean _tmp36_;
14107 					gboolean _tmp37_;
14108 					_tmp31_ = base_prop_node;
14109 					_tmp32_ = _tmp31_->symbol;
14110 					_tmp33_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp32_, VALA_TYPE_PROPERTY, ValaProperty));
14111 					base_property = _tmp33_;
14112 					_tmp35_ = base_property;
14113 					_tmp36_ = vala_property_get_is_abstract (_tmp35_);
14114 					_tmp37_ = _tmp36_;
14115 					if (_tmp37_) {
14116 						_tmp34_ = TRUE;
14117 					} else {
14118 						ValaProperty* _tmp38_;
14119 						gboolean _tmp39_;
14120 						gboolean _tmp40_;
14121 						_tmp38_ = base_property;
14122 						_tmp39_ = vala_property_get_is_virtual (_tmp38_);
14123 						_tmp40_ = _tmp39_;
14124 						_tmp34_ = _tmp40_;
14125 					}
14126 					if (_tmp34_) {
14127 						result = base_prop_node;
14128 						_vala_code_node_unref0 (base_property);
14129 						_vala_gir_parser_node_unref0 (base_node);
14130 						_vala_code_node_unref0 (type);
14131 						_vala_iterable_unref0 (_type_list);
14132 						_vala_code_node_unref0 (cl);
14133 						return result;
14134 					}
14135 					_vala_code_node_unref0 (base_property);
14136 				}
14137 				_vala_gir_parser_node_unref0 (base_prop_node);
14138 			}
14139 			_vala_gir_parser_node_unref0 (base_node);
14140 			_vala_code_node_unref0 (type);
14141 		}
14142 		_vala_iterable_unref0 (_type_list);
14143 	}
14144 	result = NULL;
14145 	_vala_code_node_unref0 (cl);
14146 	return result;
14147 }
14148 
14149 ValaGirParser*
vala_gir_parser_construct(GType object_type)14150 vala_gir_parser_construct (GType object_type)
14151 {
14152 	ValaGirParser* self = NULL;
14153 	self = (ValaGirParser*) vala_code_visitor_construct (object_type);
14154 	return self;
14155 }
14156 
14157 ValaGirParser*
vala_gir_parser_new(void)14158 vala_gir_parser_new (void)
14159 {
14160 	return vala_gir_parser_construct (VALA_TYPE_GIR_PARSER);
14161 }
14162 
14163 static gpointer
_vala_source_reference_ref0(gpointer self)14164 _vala_source_reference_ref0 (gpointer self)
14165 {
14166 	return self ? vala_source_reference_ref (self) : NULL;
14167 }
14168 
14169 static ValaGirParserArgument*
vala_gir_parser_argument_construct(GType object_type,ValaExpression * expression,ValaSourceReference * source_reference)14170 vala_gir_parser_argument_construct (GType object_type,
14171                                     ValaExpression* expression,
14172                                     ValaSourceReference* source_reference)
14173 {
14174 	ValaGirParserArgument* self = NULL;
14175 	ValaExpression* _tmp0_;
14176 	ValaSourceReference* _tmp1_;
14177 	g_return_val_if_fail (expression != NULL, NULL);
14178 	self = (ValaGirParserArgument*) g_type_create_instance (object_type);
14179 	_tmp0_ = _vala_code_node_ref0 (expression);
14180 	_vala_code_node_unref0 (self->expression);
14181 	self->expression = _tmp0_;
14182 	_tmp1_ = _vala_source_reference_ref0 (source_reference);
14183 	_vala_source_reference_unref0 (self->source_reference);
14184 	self->source_reference = _tmp1_;
14185 	return self;
14186 }
14187 
14188 static ValaGirParserArgument*
vala_gir_parser_argument_new(ValaExpression * expression,ValaSourceReference * source_reference)14189 vala_gir_parser_argument_new (ValaExpression* expression,
14190                               ValaSourceReference* source_reference)
14191 {
14192 	return vala_gir_parser_argument_construct (VALA_GIR_PARSER_TYPE_ARGUMENT, expression, source_reference);
14193 }
14194 
14195 static void
vala_gir_parser_value_argument_init(GValue * value)14196 vala_gir_parser_value_argument_init (GValue* value)
14197 {
14198 	value->data[0].v_pointer = NULL;
14199 }
14200 
14201 static void
vala_gir_parser_value_argument_free_value(GValue * value)14202 vala_gir_parser_value_argument_free_value (GValue* value)
14203 {
14204 	if (value->data[0].v_pointer) {
14205 		vala_gir_parser_argument_unref (value->data[0].v_pointer);
14206 	}
14207 }
14208 
14209 static void
vala_gir_parser_value_argument_copy_value(const GValue * src_value,GValue * dest_value)14210 vala_gir_parser_value_argument_copy_value (const GValue* src_value,
14211                                            GValue* dest_value)
14212 {
14213 	if (src_value->data[0].v_pointer) {
14214 		dest_value->data[0].v_pointer = vala_gir_parser_argument_ref (src_value->data[0].v_pointer);
14215 	} else {
14216 		dest_value->data[0].v_pointer = NULL;
14217 	}
14218 }
14219 
14220 static gpointer
vala_gir_parser_value_argument_peek_pointer(const GValue * value)14221 vala_gir_parser_value_argument_peek_pointer (const GValue* value)
14222 {
14223 	return value->data[0].v_pointer;
14224 }
14225 
14226 static gchar*
vala_gir_parser_value_argument_collect_value(GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)14227 vala_gir_parser_value_argument_collect_value (GValue* value,
14228                                               guint n_collect_values,
14229                                               GTypeCValue* collect_values,
14230                                               guint collect_flags)
14231 {
14232 	if (collect_values[0].v_pointer) {
14233 		ValaGirParserArgument * object;
14234 		object = collect_values[0].v_pointer;
14235 		if (object->parent_instance.g_class == NULL) {
14236 			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
14237 		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
14238 			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
14239 		}
14240 		value->data[0].v_pointer = vala_gir_parser_argument_ref (object);
14241 	} else {
14242 		value->data[0].v_pointer = NULL;
14243 	}
14244 	return NULL;
14245 }
14246 
14247 static gchar*
vala_gir_parser_value_argument_lcopy_value(const GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)14248 vala_gir_parser_value_argument_lcopy_value (const GValue* value,
14249                                             guint n_collect_values,
14250                                             GTypeCValue* collect_values,
14251                                             guint collect_flags)
14252 {
14253 	ValaGirParserArgument ** object_p;
14254 	object_p = collect_values[0].v_pointer;
14255 	if (!object_p) {
14256 		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
14257 	}
14258 	if (!value->data[0].v_pointer) {
14259 		*object_p = NULL;
14260 	} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
14261 		*object_p = value->data[0].v_pointer;
14262 	} else {
14263 		*object_p = vala_gir_parser_argument_ref (value->data[0].v_pointer);
14264 	}
14265 	return NULL;
14266 }
14267 
14268 static GParamSpec*
vala_gir_parser_param_spec_argument(const gchar * name,const gchar * nick,const gchar * blurb,GType object_type,GParamFlags flags)14269 vala_gir_parser_param_spec_argument (const gchar* name,
14270                                      const gchar* nick,
14271                                      const gchar* blurb,
14272                                      GType object_type,
14273                                      GParamFlags flags)
14274 {
14275 	ValaGirParserParamSpecArgument* spec;
14276 	g_return_val_if_fail (g_type_is_a (object_type, VALA_GIR_PARSER_TYPE_ARGUMENT), NULL);
14277 	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
14278 	G_PARAM_SPEC (spec)->value_type = object_type;
14279 	return G_PARAM_SPEC (spec);
14280 }
14281 
14282 static gpointer
vala_gir_parser_value_get_argument(const GValue * value)14283 vala_gir_parser_value_get_argument (const GValue* value)
14284 {
14285 	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_GIR_PARSER_TYPE_ARGUMENT), NULL);
14286 	return value->data[0].v_pointer;
14287 }
14288 
14289 static void
vala_gir_parser_value_set_argument(GValue * value,gpointer v_object)14290 vala_gir_parser_value_set_argument (GValue* value,
14291                                     gpointer v_object)
14292 {
14293 	ValaGirParserArgument * old;
14294 	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_GIR_PARSER_TYPE_ARGUMENT));
14295 	old = value->data[0].v_pointer;
14296 	if (v_object) {
14297 		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_GIR_PARSER_TYPE_ARGUMENT));
14298 		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
14299 		value->data[0].v_pointer = v_object;
14300 		vala_gir_parser_argument_ref (value->data[0].v_pointer);
14301 	} else {
14302 		value->data[0].v_pointer = NULL;
14303 	}
14304 	if (old) {
14305 		vala_gir_parser_argument_unref (old);
14306 	}
14307 }
14308 
14309 static void
vala_gir_parser_value_take_argument(GValue * value,gpointer v_object)14310 vala_gir_parser_value_take_argument (GValue* value,
14311                                      gpointer v_object)
14312 {
14313 	ValaGirParserArgument * old;
14314 	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_GIR_PARSER_TYPE_ARGUMENT));
14315 	old = value->data[0].v_pointer;
14316 	if (v_object) {
14317 		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_GIR_PARSER_TYPE_ARGUMENT));
14318 		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
14319 		value->data[0].v_pointer = v_object;
14320 	} else {
14321 		value->data[0].v_pointer = NULL;
14322 	}
14323 	if (old) {
14324 		vala_gir_parser_argument_unref (old);
14325 	}
14326 }
14327 
14328 static void
vala_gir_parser_argument_class_init(ValaGirParserArgumentClass * klass,gpointer klass_data)14329 vala_gir_parser_argument_class_init (ValaGirParserArgumentClass * klass,
14330                                      gpointer klass_data)
14331 {
14332 	vala_gir_parser_argument_parent_class = g_type_class_peek_parent (klass);
14333 	((ValaGirParserArgumentClass *) klass)->finalize = vala_gir_parser_argument_finalize;
14334 }
14335 
14336 static void
vala_gir_parser_argument_instance_init(ValaGirParserArgument * self,gpointer klass)14337 vala_gir_parser_argument_instance_init (ValaGirParserArgument * self,
14338                                         gpointer klass)
14339 {
14340 	self->used = FALSE;
14341 	self->ref_count = 1;
14342 }
14343 
14344 static void
vala_gir_parser_argument_finalize(ValaGirParserArgument * obj)14345 vala_gir_parser_argument_finalize (ValaGirParserArgument * obj)
14346 {
14347 	ValaGirParserArgument * self;
14348 	self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_GIR_PARSER_TYPE_ARGUMENT, ValaGirParserArgument);
14349 	g_signal_handlers_destroy (self);
14350 	_vala_code_node_unref0 (self->expression);
14351 	_vala_source_reference_unref0 (self->source_reference);
14352 }
14353 
14354 static GType
vala_gir_parser_argument_get_type_once(void)14355 vala_gir_parser_argument_get_type_once (void)
14356 {
14357 	static const GTypeValueTable g_define_type_value_table = { vala_gir_parser_value_argument_init, vala_gir_parser_value_argument_free_value, vala_gir_parser_value_argument_copy_value, vala_gir_parser_value_argument_peek_pointer, "p", vala_gir_parser_value_argument_collect_value, "p", vala_gir_parser_value_argument_lcopy_value };
14358 	static const GTypeInfo g_define_type_info = { sizeof (ValaGirParserArgumentClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_gir_parser_argument_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaGirParserArgument), 0, (GInstanceInitFunc) vala_gir_parser_argument_instance_init, &g_define_type_value_table };
14359 	static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
14360 	GType vala_gir_parser_argument_type_id;
14361 	vala_gir_parser_argument_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ValaGirParserArgument", &g_define_type_info, &g_define_type_fundamental_info, 0);
14362 	return vala_gir_parser_argument_type_id;
14363 }
14364 
14365 static GType
vala_gir_parser_argument_get_type(void)14366 vala_gir_parser_argument_get_type (void)
14367 {
14368 	static volatile gsize vala_gir_parser_argument_type_id__volatile = 0;
14369 	if (g_once_init_enter (&vala_gir_parser_argument_type_id__volatile)) {
14370 		GType vala_gir_parser_argument_type_id;
14371 		vala_gir_parser_argument_type_id = vala_gir_parser_argument_get_type_once ();
14372 		g_once_init_leave (&vala_gir_parser_argument_type_id__volatile, vala_gir_parser_argument_type_id);
14373 	}
14374 	return vala_gir_parser_argument_type_id__volatile;
14375 }
14376 
14377 static gpointer
vala_gir_parser_argument_ref(gpointer instance)14378 vala_gir_parser_argument_ref (gpointer instance)
14379 {
14380 	ValaGirParserArgument * self;
14381 	self = instance;
14382 	g_atomic_int_inc (&self->ref_count);
14383 	return instance;
14384 }
14385 
14386 static void
vala_gir_parser_argument_unref(gpointer instance)14387 vala_gir_parser_argument_unref (gpointer instance)
14388 {
14389 	ValaGirParserArgument * self;
14390 	self = instance;
14391 	if (g_atomic_int_dec_and_test (&self->ref_count)) {
14392 		VALA_GIR_PARSER_ARGUMENT_GET_CLASS (self)->finalize (self);
14393 		g_type_free_instance ((GTypeInstance *) self);
14394 	}
14395 }
14396 
14397 static ValaGirParserMetadataSet*
vala_gir_parser_metadata_set_construct(GType object_type,const gchar * selector)14398 vala_gir_parser_metadata_set_construct (GType object_type,
14399                                         const gchar* selector)
14400 {
14401 	ValaGirParserMetadataSet* self = NULL;
14402 	self = (ValaGirParserMetadataSet*) vala_gir_parser_metadata_construct (object_type, "", selector, NULL);
14403 	return self;
14404 }
14405 
14406 static ValaGirParserMetadataSet*
vala_gir_parser_metadata_set_new(const gchar * selector)14407 vala_gir_parser_metadata_set_new (const gchar* selector)
14408 {
14409 	return vala_gir_parser_metadata_set_construct (VALA_GIR_PARSER_TYPE_METADATA_SET, selector);
14410 }
14411 
14412 static void
vala_gir_parser_metadata_set_add_sibling(ValaGirParserMetadataSet * self,ValaGirParserMetadata * metadata)14413 vala_gir_parser_metadata_set_add_sibling (ValaGirParserMetadataSet* self,
14414                                           ValaGirParserMetadata* metadata)
14415 {
14416 	g_return_if_fail (self != NULL);
14417 	g_return_if_fail (metadata != NULL);
14418 	{
14419 		ValaArrayList* _child_list = NULL;
14420 		ValaArrayList* _tmp0_;
14421 		ValaArrayList* _tmp1_;
14422 		gint _child_size = 0;
14423 		ValaArrayList* _tmp2_;
14424 		gint _tmp3_;
14425 		gint _tmp4_;
14426 		gint _child_index = 0;
14427 		_tmp0_ = metadata->children;
14428 		_tmp1_ = _vala_iterable_ref0 (_tmp0_);
14429 		_child_list = _tmp1_;
14430 		_tmp2_ = _child_list;
14431 		_tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
14432 		_tmp4_ = _tmp3_;
14433 		_child_size = _tmp4_;
14434 		_child_index = -1;
14435 		while (TRUE) {
14436 			gint _tmp5_;
14437 			gint _tmp6_;
14438 			ValaGirParserMetadata* child = NULL;
14439 			ValaArrayList* _tmp7_;
14440 			gpointer _tmp8_;
14441 			ValaGirParserMetadata* _tmp9_;
14442 			_child_index = _child_index + 1;
14443 			_tmp5_ = _child_index;
14444 			_tmp6_ = _child_size;
14445 			if (!(_tmp5_ < _tmp6_)) {
14446 				break;
14447 			}
14448 			_tmp7_ = _child_list;
14449 			_tmp8_ = vala_list_get ((ValaList*) _tmp7_, _child_index);
14450 			child = (ValaGirParserMetadata*) _tmp8_;
14451 			_tmp9_ = child;
14452 			vala_gir_parser_metadata_add_child ((ValaGirParserMetadata*) self, _tmp9_);
14453 			_vala_gir_parser_metadata_unref0 (child);
14454 		}
14455 		_vala_iterable_unref0 (_child_list);
14456 	}
14457 	{
14458 		ValaIterator* _key_it = NULL;
14459 		ValaMap* _tmp10_;
14460 		ValaSet* _tmp11_;
14461 		ValaSet* _tmp12_;
14462 		ValaIterator* _tmp13_;
14463 		ValaIterator* _tmp14_;
14464 		_tmp10_ = metadata->args;
14465 		_tmp11_ = vala_map_get_keys (_tmp10_);
14466 		_tmp12_ = _tmp11_;
14467 		_tmp13_ = vala_iterable_iterator ((ValaIterable*) _tmp12_);
14468 		_tmp14_ = _tmp13_;
14469 		_vala_iterable_unref0 (_tmp12_);
14470 		_key_it = _tmp14_;
14471 		while (TRUE) {
14472 			ValaIterator* _tmp15_;
14473 			ValaGirParserArgumentType key = 0;
14474 			ValaIterator* _tmp16_;
14475 			gpointer _tmp17_;
14476 			ValaMap* _tmp18_;
14477 			ValaGirParserArgumentType _tmp19_;
14478 			ValaMap* _tmp20_;
14479 			ValaGirParserArgumentType _tmp21_;
14480 			gpointer _tmp22_;
14481 			ValaGirParserArgument* _tmp23_;
14482 			_tmp15_ = _key_it;
14483 			if (!vala_iterator_next (_tmp15_)) {
14484 				break;
14485 			}
14486 			_tmp16_ = _key_it;
14487 			_tmp17_ = vala_iterator_get (_tmp16_);
14488 			key = (ValaGirParserArgumentType) ((gintptr) _tmp17_);
14489 			_tmp18_ = ((ValaGirParserMetadata*) self)->args;
14490 			_tmp19_ = key;
14491 			_tmp20_ = metadata->args;
14492 			_tmp21_ = key;
14493 			_tmp22_ = vala_map_get (_tmp20_, (gpointer) ((gintptr) _tmp21_));
14494 			_tmp23_ = (ValaGirParserArgument*) _tmp22_;
14495 			vala_map_set (_tmp18_, (gpointer) ((gintptr) _tmp19_), _tmp23_);
14496 			_vala_gir_parser_argument_unref0 (_tmp23_);
14497 		}
14498 		_vala_iterator_unref0 (_key_it);
14499 	}
14500 }
14501 
14502 static void
vala_gir_parser_metadata_set_class_init(ValaGirParserMetadataSetClass * klass,gpointer klass_data)14503 vala_gir_parser_metadata_set_class_init (ValaGirParserMetadataSetClass * klass,
14504                                          gpointer klass_data)
14505 {
14506 	vala_gir_parser_metadata_set_parent_class = g_type_class_peek_parent (klass);
14507 }
14508 
14509 static void
vala_gir_parser_metadata_set_instance_init(ValaGirParserMetadataSet * self,gpointer klass)14510 vala_gir_parser_metadata_set_instance_init (ValaGirParserMetadataSet * self,
14511                                             gpointer klass)
14512 {
14513 }
14514 
14515 static GType
vala_gir_parser_metadata_set_get_type_once(void)14516 vala_gir_parser_metadata_set_get_type_once (void)
14517 {
14518 	static const GTypeInfo g_define_type_info = { sizeof (ValaGirParserMetadataSetClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_gir_parser_metadata_set_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaGirParserMetadataSet), 0, (GInstanceInitFunc) vala_gir_parser_metadata_set_instance_init, NULL };
14519 	GType vala_gir_parser_metadata_set_type_id;
14520 	vala_gir_parser_metadata_set_type_id = g_type_register_static (VALA_GIR_PARSER_TYPE_METADATA, "ValaGirParserMetadataSet", &g_define_type_info, 0);
14521 	return vala_gir_parser_metadata_set_type_id;
14522 }
14523 
14524 static GType
vala_gir_parser_metadata_set_get_type(void)14525 vala_gir_parser_metadata_set_get_type (void)
14526 {
14527 	static volatile gsize vala_gir_parser_metadata_set_type_id__volatile = 0;
14528 	if (g_once_init_enter (&vala_gir_parser_metadata_set_type_id__volatile)) {
14529 		GType vala_gir_parser_metadata_set_type_id;
14530 		vala_gir_parser_metadata_set_type_id = vala_gir_parser_metadata_set_get_type_once ();
14531 		g_once_init_leave (&vala_gir_parser_metadata_set_type_id__volatile, vala_gir_parser_metadata_set_type_id);
14532 	}
14533 	return vala_gir_parser_metadata_set_type_id__volatile;
14534 }
14535 
14536 static ValaGirParserMetadata*
vala_gir_parser_metadata_get_empty(void)14537 vala_gir_parser_metadata_get_empty (void)
14538 {
14539 	ValaGirParserMetadata* result;
14540 	ValaGirParserMetadata* _tmp0_;
14541 	ValaGirParserMetadata* _tmp2_;
14542 	_tmp0_ = vala_gir_parser_metadata__empty;
14543 	if (_tmp0_ == NULL) {
14544 		ValaGirParserMetadata* _tmp1_;
14545 		_tmp1_ = vala_gir_parser_metadata_new ("", NULL, NULL);
14546 		_vala_gir_parser_metadata_unref0 (vala_gir_parser_metadata__empty);
14547 		vala_gir_parser_metadata__empty = _tmp1_;
14548 	}
14549 	_tmp2_ = vala_gir_parser_metadata__empty;
14550 	result = _tmp2_;
14551 	return result;
14552 }
14553 
14554 static ValaGirParserMetadata*
vala_gir_parser_metadata_construct(GType object_type,const gchar * pattern,const gchar * selector,ValaSourceReference * source_reference)14555 vala_gir_parser_metadata_construct (GType object_type,
14556                                     const gchar* pattern,
14557                                     const gchar* selector,
14558                                     ValaSourceReference* source_reference)
14559 {
14560 	ValaGirParserMetadata* self = NULL;
14561 	GPatternSpec* _tmp0_;
14562 	gchar* _tmp1_;
14563 	ValaSourceReference* _tmp2_;
14564 	g_return_val_if_fail (pattern != NULL, NULL);
14565 	self = (ValaGirParserMetadata*) g_type_create_instance (object_type);
14566 	_tmp0_ = g_pattern_spec_new (pattern);
14567 	_g_pattern_spec_free0 (self->pattern_spec);
14568 	self->pattern_spec = _tmp0_;
14569 	_tmp1_ = g_strdup (selector);
14570 	_g_free0 (self->selector);
14571 	self->selector = _tmp1_;
14572 	_tmp2_ = _vala_source_reference_ref0 (source_reference);
14573 	_vala_source_reference_unref0 (self->source_reference);
14574 	self->source_reference = _tmp2_;
14575 	return self;
14576 }
14577 
14578 static ValaGirParserMetadata*
vala_gir_parser_metadata_new(const gchar * pattern,const gchar * selector,ValaSourceReference * source_reference)14579 vala_gir_parser_metadata_new (const gchar* pattern,
14580                               const gchar* selector,
14581                               ValaSourceReference* source_reference)
14582 {
14583 	return vala_gir_parser_metadata_construct (VALA_GIR_PARSER_TYPE_METADATA, pattern, selector, source_reference);
14584 }
14585 
14586 static void
vala_gir_parser_metadata_add_child(ValaGirParserMetadata * self,ValaGirParserMetadata * metadata)14587 vala_gir_parser_metadata_add_child (ValaGirParserMetadata* self,
14588                                     ValaGirParserMetadata* metadata)
14589 {
14590 	ValaArrayList* _tmp0_;
14591 	g_return_if_fail (self != NULL);
14592 	g_return_if_fail (metadata != NULL);
14593 	_tmp0_ = self->children;
14594 	vala_collection_add ((ValaCollection*) _tmp0_, metadata);
14595 }
14596 
14597 static ValaGirParserMetadata*
vala_gir_parser_metadata_match_child(ValaGirParserMetadata * self,const gchar * name,const gchar * selector)14598 vala_gir_parser_metadata_match_child (ValaGirParserMetadata* self,
14599                                       const gchar* name,
14600                                       const gchar* selector)
14601 {
14602 	ValaGirParserMetadata* _result_ = NULL;
14603 	ValaGirParserMetadata* _tmp0_;
14604 	ValaGirParserMetadata* _tmp1_;
14605 	ValaGirParserMetadata* _tmp2_;
14606 	ValaGirParserMetadata* result = NULL;
14607 	g_return_val_if_fail (self != NULL, NULL);
14608 	g_return_val_if_fail (name != NULL, NULL);
14609 	_tmp0_ = vala_gir_parser_metadata_get_empty ();
14610 	_tmp1_ = _tmp0_;
14611 	_tmp2_ = _vala_gir_parser_metadata_ref0 (_tmp1_);
14612 	_result_ = _tmp2_;
14613 	{
14614 		ValaArrayList* _metadata_list = NULL;
14615 		ValaArrayList* _tmp3_;
14616 		ValaArrayList* _tmp4_;
14617 		gint _metadata_size = 0;
14618 		ValaArrayList* _tmp5_;
14619 		gint _tmp6_;
14620 		gint _tmp7_;
14621 		gint _metadata_index = 0;
14622 		_tmp3_ = self->children;
14623 		_tmp4_ = _vala_iterable_ref0 (_tmp3_);
14624 		_metadata_list = _tmp4_;
14625 		_tmp5_ = _metadata_list;
14626 		_tmp6_ = vala_collection_get_size ((ValaCollection*) _tmp5_);
14627 		_tmp7_ = _tmp6_;
14628 		_metadata_size = _tmp7_;
14629 		_metadata_index = -1;
14630 		while (TRUE) {
14631 			gint _tmp8_;
14632 			gint _tmp9_;
14633 			ValaGirParserMetadata* metadata = NULL;
14634 			ValaArrayList* _tmp10_;
14635 			gpointer _tmp11_;
14636 			gboolean _tmp12_ = FALSE;
14637 			gboolean _tmp13_ = FALSE;
14638 			gboolean _tmp14_ = FALSE;
14639 			_metadata_index = _metadata_index + 1;
14640 			_tmp8_ = _metadata_index;
14641 			_tmp9_ = _metadata_size;
14642 			if (!(_tmp8_ < _tmp9_)) {
14643 				break;
14644 			}
14645 			_tmp10_ = _metadata_list;
14646 			_tmp11_ = vala_list_get ((ValaList*) _tmp10_, _metadata_index);
14647 			metadata = (ValaGirParserMetadata*) _tmp11_;
14648 			if (selector == NULL) {
14649 				_tmp14_ = TRUE;
14650 			} else {
14651 				ValaGirParserMetadata* _tmp15_;
14652 				const gchar* _tmp16_;
14653 				_tmp15_ = metadata;
14654 				_tmp16_ = _tmp15_->selector;
14655 				_tmp14_ = _tmp16_ == NULL;
14656 			}
14657 			if (_tmp14_) {
14658 				_tmp13_ = TRUE;
14659 			} else {
14660 				ValaGirParserMetadata* _tmp17_;
14661 				const gchar* _tmp18_;
14662 				_tmp17_ = metadata;
14663 				_tmp18_ = _tmp17_->selector;
14664 				_tmp13_ = g_strcmp0 (_tmp18_, selector) == 0;
14665 			}
14666 			if (_tmp13_) {
14667 				ValaGirParserMetadata* _tmp19_;
14668 				GPatternSpec* _tmp20_;
14669 				_tmp19_ = metadata;
14670 				_tmp20_ = _tmp19_->pattern_spec;
14671 				_tmp12_ = g_pattern_match_string (_tmp20_, name);
14672 			} else {
14673 				_tmp12_ = FALSE;
14674 			}
14675 			if (_tmp12_) {
14676 				ValaGirParserMetadata* _tmp21_;
14677 				ValaGirParserMetadata* _tmp22_;
14678 				ValaGirParserMetadata* _tmp23_;
14679 				ValaGirParserMetadata* _tmp24_;
14680 				_tmp21_ = metadata;
14681 				_tmp21_->used = TRUE;
14682 				_tmp22_ = _result_;
14683 				_tmp23_ = vala_gir_parser_metadata_get_empty ();
14684 				_tmp24_ = _tmp23_;
14685 				if (_tmp22_ == _tmp24_) {
14686 					ValaGirParserMetadata* _tmp25_;
14687 					ValaGirParserMetadata* _tmp26_;
14688 					_tmp25_ = metadata;
14689 					_tmp26_ = _vala_gir_parser_metadata_ref0 (_tmp25_);
14690 					_vala_gir_parser_metadata_unref0 (_result_);
14691 					_result_ = _tmp26_;
14692 				} else {
14693 					ValaGirParserMetadataSet* ms = NULL;
14694 					ValaGirParserMetadata* _tmp27_;
14695 					ValaGirParserMetadataSet* _tmp28_;
14696 					ValaGirParserMetadataSet* _tmp29_;
14697 					ValaGirParserMetadataSet* _tmp33_;
14698 					ValaGirParserMetadata* _tmp34_;
14699 					ValaGirParserMetadataSet* _tmp35_;
14700 					ValaGirParserMetadata* _tmp36_;
14701 					_tmp27_ = _result_;
14702 					_tmp28_ = _vala_gir_parser_metadata_ref0 (VALA_GIR_PARSER_IS_METADATA_SET (_tmp27_) ? ((ValaGirParserMetadataSet*) _tmp27_) : NULL);
14703 					ms = _tmp28_;
14704 					_tmp29_ = ms;
14705 					if (_tmp29_ == NULL) {
14706 						ValaGirParserMetadataSet* _tmp30_;
14707 						ValaGirParserMetadataSet* _tmp31_;
14708 						ValaGirParserMetadata* _tmp32_;
14709 						_tmp30_ = vala_gir_parser_metadata_set_new (selector);
14710 						_vala_gir_parser_metadata_unref0 (ms);
14711 						ms = _tmp30_;
14712 						_tmp31_ = ms;
14713 						_tmp32_ = _result_;
14714 						vala_gir_parser_metadata_set_add_sibling (_tmp31_, _tmp32_);
14715 					}
14716 					_tmp33_ = ms;
14717 					_tmp34_ = metadata;
14718 					vala_gir_parser_metadata_set_add_sibling (_tmp33_, _tmp34_);
14719 					_tmp35_ = ms;
14720 					_tmp36_ = _vala_gir_parser_metadata_ref0 ((ValaGirParserMetadata*) _tmp35_);
14721 					_vala_gir_parser_metadata_unref0 (_result_);
14722 					_result_ = _tmp36_;
14723 					_vala_gir_parser_metadata_unref0 (ms);
14724 				}
14725 			}
14726 			_vala_gir_parser_metadata_unref0 (metadata);
14727 		}
14728 		_vala_iterable_unref0 (_metadata_list);
14729 	}
14730 	result = _result_;
14731 	return result;
14732 }
14733 
14734 static void
vala_gir_parser_metadata_add_argument(ValaGirParserMetadata * self,ValaGirParserArgumentType key,ValaGirParserArgument * value)14735 vala_gir_parser_metadata_add_argument (ValaGirParserMetadata* self,
14736                                        ValaGirParserArgumentType key,
14737                                        ValaGirParserArgument* value)
14738 {
14739 	ValaMap* _tmp0_;
14740 	g_return_if_fail (self != NULL);
14741 	g_return_if_fail (value != NULL);
14742 	_tmp0_ = self->args;
14743 	vala_map_set (_tmp0_, (gpointer) ((gintptr) key), value);
14744 }
14745 
14746 static gboolean
vala_gir_parser_metadata_has_argument(ValaGirParserMetadata * self,ValaGirParserArgumentType key)14747 vala_gir_parser_metadata_has_argument (ValaGirParserMetadata* self,
14748                                        ValaGirParserArgumentType key)
14749 {
14750 	ValaMap* _tmp0_;
14751 	gboolean result = FALSE;
14752 	g_return_val_if_fail (self != NULL, FALSE);
14753 	_tmp0_ = self->args;
14754 	result = vala_map_contains (_tmp0_, (gpointer) ((gintptr) key));
14755 	return result;
14756 }
14757 
14758 static ValaExpression*
vala_gir_parser_metadata_get_expression(ValaGirParserMetadata * self,ValaGirParserArgumentType arg)14759 vala_gir_parser_metadata_get_expression (ValaGirParserMetadata* self,
14760                                          ValaGirParserArgumentType arg)
14761 {
14762 	ValaGirParserArgument* val = NULL;
14763 	ValaMap* _tmp0_;
14764 	gpointer _tmp1_;
14765 	ValaGirParserArgument* _tmp2_;
14766 	ValaExpression* result = NULL;
14767 	g_return_val_if_fail (self != NULL, NULL);
14768 	_tmp0_ = self->args;
14769 	_tmp1_ = vala_map_get (_tmp0_, (gpointer) ((gintptr) arg));
14770 	val = (ValaGirParserArgument*) _tmp1_;
14771 	_tmp2_ = val;
14772 	if (_tmp2_ != NULL) {
14773 		ValaGirParserArgument* _tmp3_;
14774 		ValaGirParserArgument* _tmp4_;
14775 		ValaExpression* _tmp5_;
14776 		ValaExpression* _tmp6_;
14777 		_tmp3_ = val;
14778 		_tmp3_->used = TRUE;
14779 		_tmp4_ = val;
14780 		_tmp5_ = _tmp4_->expression;
14781 		_tmp6_ = _vala_code_node_ref0 (_tmp5_);
14782 		result = _tmp6_;
14783 		_vala_gir_parser_argument_unref0 (val);
14784 		return result;
14785 	}
14786 	result = NULL;
14787 	_vala_gir_parser_argument_unref0 (val);
14788 	return result;
14789 }
14790 
14791 static gchar*
vala_gir_parser_metadata_get_string(ValaGirParserMetadata * self,ValaGirParserArgumentType arg)14792 vala_gir_parser_metadata_get_string (ValaGirParserMetadata* self,
14793                                      ValaGirParserArgumentType arg)
14794 {
14795 	ValaStringLiteral* lit = NULL;
14796 	ValaExpression* _tmp0_;
14797 	ValaStringLiteral* _tmp1_;
14798 	ValaStringLiteral* _tmp2_;
14799 	gchar* result = NULL;
14800 	g_return_val_if_fail (self != NULL, NULL);
14801 	_tmp0_ = vala_gir_parser_metadata_get_expression (self, arg);
14802 	_tmp1_ = VALA_IS_STRING_LITERAL (_tmp0_) ? ((ValaStringLiteral*) _tmp0_) : NULL;
14803 	if (_tmp1_ == NULL) {
14804 		_vala_code_node_unref0 (_tmp0_);
14805 	}
14806 	lit = _tmp1_;
14807 	_tmp2_ = lit;
14808 	if (_tmp2_ != NULL) {
14809 		ValaStringLiteral* _tmp3_;
14810 		gchar* _tmp4_;
14811 		_tmp3_ = lit;
14812 		_tmp4_ = vala_string_literal_eval (_tmp3_);
14813 		result = _tmp4_;
14814 		_vala_code_node_unref0 (lit);
14815 		return result;
14816 	}
14817 	result = NULL;
14818 	_vala_code_node_unref0 (lit);
14819 	return result;
14820 }
14821 
14822 static gint
vala_gir_parser_metadata_get_integer(ValaGirParserMetadata * self,ValaGirParserArgumentType arg)14823 vala_gir_parser_metadata_get_integer (ValaGirParserMetadata* self,
14824                                       ValaGirParserArgumentType arg)
14825 {
14826 	ValaUnaryExpression* unary = NULL;
14827 	ValaExpression* _tmp0_;
14828 	ValaUnaryExpression* _tmp1_;
14829 	gboolean _tmp2_ = FALSE;
14830 	ValaUnaryExpression* _tmp3_;
14831 	gint result = 0;
14832 	g_return_val_if_fail (self != NULL, 0);
14833 	_tmp0_ = vala_gir_parser_metadata_get_expression (self, arg);
14834 	_tmp1_ = VALA_IS_UNARY_EXPRESSION (_tmp0_) ? ((ValaUnaryExpression*) _tmp0_) : NULL;
14835 	if (_tmp1_ == NULL) {
14836 		_vala_code_node_unref0 (_tmp0_);
14837 	}
14838 	unary = _tmp1_;
14839 	_tmp3_ = unary;
14840 	if (_tmp3_ != NULL) {
14841 		ValaUnaryExpression* _tmp4_;
14842 		ValaUnaryOperator _tmp5_;
14843 		ValaUnaryOperator _tmp6_;
14844 		_tmp4_ = unary;
14845 		_tmp5_ = vala_unary_expression_get_operator (_tmp4_);
14846 		_tmp6_ = _tmp5_;
14847 		_tmp2_ = _tmp6_ == VALA_UNARY_OPERATOR_MINUS;
14848 	} else {
14849 		_tmp2_ = FALSE;
14850 	}
14851 	if (_tmp2_) {
14852 		ValaIntegerLiteral* lit = NULL;
14853 		ValaUnaryExpression* _tmp7_;
14854 		ValaExpression* _tmp8_;
14855 		ValaExpression* _tmp9_;
14856 		ValaIntegerLiteral* _tmp10_;
14857 		ValaIntegerLiteral* _tmp11_;
14858 		_tmp7_ = unary;
14859 		_tmp8_ = vala_unary_expression_get_inner (_tmp7_);
14860 		_tmp9_ = _tmp8_;
14861 		_tmp10_ = _vala_code_node_ref0 (VALA_IS_INTEGER_LITERAL (_tmp9_) ? ((ValaIntegerLiteral*) _tmp9_) : NULL);
14862 		lit = _tmp10_;
14863 		_tmp11_ = lit;
14864 		if (_tmp11_ != NULL) {
14865 			ValaIntegerLiteral* _tmp12_;
14866 			const gchar* _tmp13_;
14867 			const gchar* _tmp14_;
14868 			_tmp12_ = lit;
14869 			_tmp13_ = vala_integer_literal_get_value (_tmp12_);
14870 			_tmp14_ = _tmp13_;
14871 			result = -atoi (_tmp14_);
14872 			_vala_code_node_unref0 (lit);
14873 			_vala_code_node_unref0 (unary);
14874 			return result;
14875 		}
14876 		_vala_code_node_unref0 (lit);
14877 	} else {
14878 		ValaIntegerLiteral* lit = NULL;
14879 		ValaExpression* _tmp15_;
14880 		ValaIntegerLiteral* _tmp16_;
14881 		ValaIntegerLiteral* _tmp17_;
14882 		_tmp15_ = vala_gir_parser_metadata_get_expression (self, arg);
14883 		_tmp16_ = VALA_IS_INTEGER_LITERAL (_tmp15_) ? ((ValaIntegerLiteral*) _tmp15_) : NULL;
14884 		if (_tmp16_ == NULL) {
14885 			_vala_code_node_unref0 (_tmp15_);
14886 		}
14887 		lit = _tmp16_;
14888 		_tmp17_ = lit;
14889 		if (_tmp17_ != NULL) {
14890 			ValaIntegerLiteral* _tmp18_;
14891 			const gchar* _tmp19_;
14892 			const gchar* _tmp20_;
14893 			_tmp18_ = lit;
14894 			_tmp19_ = vala_integer_literal_get_value (_tmp18_);
14895 			_tmp20_ = _tmp19_;
14896 			result = atoi (_tmp20_);
14897 			_vala_code_node_unref0 (lit);
14898 			_vala_code_node_unref0 (unary);
14899 			return result;
14900 		}
14901 		_vala_code_node_unref0 (lit);
14902 	}
14903 	result = 0;
14904 	_vala_code_node_unref0 (unary);
14905 	return result;
14906 }
14907 
14908 static gboolean
vala_gir_parser_metadata_get_bool(ValaGirParserMetadata * self,ValaGirParserArgumentType arg,gboolean default_value)14909 vala_gir_parser_metadata_get_bool (ValaGirParserMetadata* self,
14910                                    ValaGirParserArgumentType arg,
14911                                    gboolean default_value)
14912 {
14913 	ValaBooleanLiteral* lit = NULL;
14914 	ValaExpression* _tmp0_;
14915 	ValaBooleanLiteral* _tmp1_;
14916 	ValaBooleanLiteral* _tmp2_;
14917 	gboolean result = FALSE;
14918 	g_return_val_if_fail (self != NULL, FALSE);
14919 	_tmp0_ = vala_gir_parser_metadata_get_expression (self, arg);
14920 	_tmp1_ = VALA_IS_BOOLEAN_LITERAL (_tmp0_) ? ((ValaBooleanLiteral*) _tmp0_) : NULL;
14921 	if (_tmp1_ == NULL) {
14922 		_vala_code_node_unref0 (_tmp0_);
14923 	}
14924 	lit = _tmp1_;
14925 	_tmp2_ = lit;
14926 	if (_tmp2_ != NULL) {
14927 		ValaBooleanLiteral* _tmp3_;
14928 		gboolean _tmp4_;
14929 		gboolean _tmp5_;
14930 		_tmp3_ = lit;
14931 		_tmp4_ = vala_boolean_literal_get_value (_tmp3_);
14932 		_tmp5_ = _tmp4_;
14933 		result = _tmp5_;
14934 		_vala_code_node_unref0 (lit);
14935 		return result;
14936 	}
14937 	result = default_value;
14938 	_vala_code_node_unref0 (lit);
14939 	return result;
14940 }
14941 
14942 static ValaSourceReference*
vala_gir_parser_metadata_get_source_reference(ValaGirParserMetadata * self,ValaGirParserArgumentType arg)14943 vala_gir_parser_metadata_get_source_reference (ValaGirParserMetadata* self,
14944                                                ValaGirParserArgumentType arg)
14945 {
14946 	ValaGirParserArgument* val = NULL;
14947 	ValaMap* _tmp0_;
14948 	gpointer _tmp1_;
14949 	ValaGirParserArgument* _tmp2_;
14950 	ValaSourceReference* result = NULL;
14951 	g_return_val_if_fail (self != NULL, NULL);
14952 	_tmp0_ = self->args;
14953 	_tmp1_ = vala_map_get (_tmp0_, (gpointer) ((gintptr) arg));
14954 	val = (ValaGirParserArgument*) _tmp1_;
14955 	_tmp2_ = val;
14956 	if (_tmp2_ != NULL) {
14957 		ValaGirParserArgument* _tmp3_;
14958 		ValaSourceReference* _tmp4_;
14959 		ValaSourceReference* _tmp5_;
14960 		_tmp3_ = val;
14961 		_tmp4_ = _tmp3_->source_reference;
14962 		_tmp5_ = _vala_source_reference_ref0 (_tmp4_);
14963 		result = _tmp5_;
14964 		_vala_gir_parser_argument_unref0 (val);
14965 		return result;
14966 	}
14967 	result = NULL;
14968 	_vala_gir_parser_argument_unref0 (val);
14969 	return result;
14970 }
14971 
14972 static void
vala_gir_parser_value_metadata_init(GValue * value)14973 vala_gir_parser_value_metadata_init (GValue* value)
14974 {
14975 	value->data[0].v_pointer = NULL;
14976 }
14977 
14978 static void
vala_gir_parser_value_metadata_free_value(GValue * value)14979 vala_gir_parser_value_metadata_free_value (GValue* value)
14980 {
14981 	if (value->data[0].v_pointer) {
14982 		vala_gir_parser_metadata_unref (value->data[0].v_pointer);
14983 	}
14984 }
14985 
14986 static void
vala_gir_parser_value_metadata_copy_value(const GValue * src_value,GValue * dest_value)14987 vala_gir_parser_value_metadata_copy_value (const GValue* src_value,
14988                                            GValue* dest_value)
14989 {
14990 	if (src_value->data[0].v_pointer) {
14991 		dest_value->data[0].v_pointer = vala_gir_parser_metadata_ref (src_value->data[0].v_pointer);
14992 	} else {
14993 		dest_value->data[0].v_pointer = NULL;
14994 	}
14995 }
14996 
14997 static gpointer
vala_gir_parser_value_metadata_peek_pointer(const GValue * value)14998 vala_gir_parser_value_metadata_peek_pointer (const GValue* value)
14999 {
15000 	return value->data[0].v_pointer;
15001 }
15002 
15003 static gchar*
vala_gir_parser_value_metadata_collect_value(GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)15004 vala_gir_parser_value_metadata_collect_value (GValue* value,
15005                                               guint n_collect_values,
15006                                               GTypeCValue* collect_values,
15007                                               guint collect_flags)
15008 {
15009 	if (collect_values[0].v_pointer) {
15010 		ValaGirParserMetadata * object;
15011 		object = collect_values[0].v_pointer;
15012 		if (object->parent_instance.g_class == NULL) {
15013 			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
15014 		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
15015 			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
15016 		}
15017 		value->data[0].v_pointer = vala_gir_parser_metadata_ref (object);
15018 	} else {
15019 		value->data[0].v_pointer = NULL;
15020 	}
15021 	return NULL;
15022 }
15023 
15024 static gchar*
vala_gir_parser_value_metadata_lcopy_value(const GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)15025 vala_gir_parser_value_metadata_lcopy_value (const GValue* value,
15026                                             guint n_collect_values,
15027                                             GTypeCValue* collect_values,
15028                                             guint collect_flags)
15029 {
15030 	ValaGirParserMetadata ** object_p;
15031 	object_p = collect_values[0].v_pointer;
15032 	if (!object_p) {
15033 		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
15034 	}
15035 	if (!value->data[0].v_pointer) {
15036 		*object_p = NULL;
15037 	} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
15038 		*object_p = value->data[0].v_pointer;
15039 	} else {
15040 		*object_p = vala_gir_parser_metadata_ref (value->data[0].v_pointer);
15041 	}
15042 	return NULL;
15043 }
15044 
15045 static GParamSpec*
vala_gir_parser_param_spec_metadata(const gchar * name,const gchar * nick,const gchar * blurb,GType object_type,GParamFlags flags)15046 vala_gir_parser_param_spec_metadata (const gchar* name,
15047                                      const gchar* nick,
15048                                      const gchar* blurb,
15049                                      GType object_type,
15050                                      GParamFlags flags)
15051 {
15052 	ValaGirParserParamSpecMetadata* spec;
15053 	g_return_val_if_fail (g_type_is_a (object_type, VALA_GIR_PARSER_TYPE_METADATA), NULL);
15054 	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
15055 	G_PARAM_SPEC (spec)->value_type = object_type;
15056 	return G_PARAM_SPEC (spec);
15057 }
15058 
15059 static gpointer
vala_gir_parser_value_get_metadata(const GValue * value)15060 vala_gir_parser_value_get_metadata (const GValue* value)
15061 {
15062 	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_GIR_PARSER_TYPE_METADATA), NULL);
15063 	return value->data[0].v_pointer;
15064 }
15065 
15066 static void
vala_gir_parser_value_set_metadata(GValue * value,gpointer v_object)15067 vala_gir_parser_value_set_metadata (GValue* value,
15068                                     gpointer v_object)
15069 {
15070 	ValaGirParserMetadata * old;
15071 	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_GIR_PARSER_TYPE_METADATA));
15072 	old = value->data[0].v_pointer;
15073 	if (v_object) {
15074 		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_GIR_PARSER_TYPE_METADATA));
15075 		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
15076 		value->data[0].v_pointer = v_object;
15077 		vala_gir_parser_metadata_ref (value->data[0].v_pointer);
15078 	} else {
15079 		value->data[0].v_pointer = NULL;
15080 	}
15081 	if (old) {
15082 		vala_gir_parser_metadata_unref (old);
15083 	}
15084 }
15085 
15086 static void
vala_gir_parser_value_take_metadata(GValue * value,gpointer v_object)15087 vala_gir_parser_value_take_metadata (GValue* value,
15088                                      gpointer v_object)
15089 {
15090 	ValaGirParserMetadata * old;
15091 	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_GIR_PARSER_TYPE_METADATA));
15092 	old = value->data[0].v_pointer;
15093 	if (v_object) {
15094 		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_GIR_PARSER_TYPE_METADATA));
15095 		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
15096 		value->data[0].v_pointer = v_object;
15097 	} else {
15098 		value->data[0].v_pointer = NULL;
15099 	}
15100 	if (old) {
15101 		vala_gir_parser_metadata_unref (old);
15102 	}
15103 }
15104 
15105 static void
vala_gir_parser_metadata_class_init(ValaGirParserMetadataClass * klass,gpointer klass_data)15106 vala_gir_parser_metadata_class_init (ValaGirParserMetadataClass * klass,
15107                                      gpointer klass_data)
15108 {
15109 	vala_gir_parser_metadata_parent_class = g_type_class_peek_parent (klass);
15110 	((ValaGirParserMetadataClass *) klass)->finalize = vala_gir_parser_metadata_finalize;
15111 }
15112 
15113 static void
vala_gir_parser_metadata_instance_init(ValaGirParserMetadata * self,gpointer klass)15114 vala_gir_parser_metadata_instance_init (ValaGirParserMetadata * self,
15115                                         gpointer klass)
15116 {
15117 	GHashFunc _tmp0_;
15118 	GEqualFunc _tmp1_;
15119 	GEqualFunc _tmp2_;
15120 	ValaHashMap* _tmp3_;
15121 	GEqualFunc _tmp4_;
15122 	ValaArrayList* _tmp5_;
15123 	self->used = FALSE;
15124 	_tmp0_ = g_direct_hash;
15125 	_tmp1_ = g_direct_equal;
15126 	_tmp2_ = g_direct_equal;
15127 	_tmp3_ = vala_hash_map_new (VALA_GIR_PARSER_TYPE_ARGUMENT_TYPE, NULL, NULL, VALA_GIR_PARSER_TYPE_ARGUMENT, (GBoxedCopyFunc) vala_gir_parser_argument_ref, (GDestroyNotify) vala_gir_parser_argument_unref, _tmp0_, _tmp1_, _tmp2_);
15128 	self->args = (ValaMap*) _tmp3_;
15129 	_tmp4_ = g_direct_equal;
15130 	_tmp5_ = vala_array_list_new (VALA_GIR_PARSER_TYPE_METADATA, (GBoxedCopyFunc) vala_gir_parser_metadata_ref, (GDestroyNotify) vala_gir_parser_metadata_unref, _tmp4_);
15131 	self->children = _tmp5_;
15132 	self->ref_count = 1;
15133 }
15134 
15135 static void
vala_gir_parser_metadata_finalize(ValaGirParserMetadata * obj)15136 vala_gir_parser_metadata_finalize (ValaGirParserMetadata * obj)
15137 {
15138 	ValaGirParserMetadata * self;
15139 	self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_GIR_PARSER_TYPE_METADATA, ValaGirParserMetadata);
15140 	g_signal_handlers_destroy (self);
15141 	_g_pattern_spec_free0 (self->pattern_spec);
15142 	_g_free0 (self->selector);
15143 	_vala_source_reference_unref0 (self->source_reference);
15144 	_vala_map_unref0 (self->args);
15145 	_vala_iterable_unref0 (self->children);
15146 }
15147 
15148 static GType
vala_gir_parser_metadata_get_type_once(void)15149 vala_gir_parser_metadata_get_type_once (void)
15150 {
15151 	static const GTypeValueTable g_define_type_value_table = { vala_gir_parser_value_metadata_init, vala_gir_parser_value_metadata_free_value, vala_gir_parser_value_metadata_copy_value, vala_gir_parser_value_metadata_peek_pointer, "p", vala_gir_parser_value_metadata_collect_value, "p", vala_gir_parser_value_metadata_lcopy_value };
15152 	static const GTypeInfo g_define_type_info = { sizeof (ValaGirParserMetadataClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_gir_parser_metadata_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaGirParserMetadata), 0, (GInstanceInitFunc) vala_gir_parser_metadata_instance_init, &g_define_type_value_table };
15153 	static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
15154 	GType vala_gir_parser_metadata_type_id;
15155 	vala_gir_parser_metadata_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ValaGirParserMetadata", &g_define_type_info, &g_define_type_fundamental_info, 0);
15156 	return vala_gir_parser_metadata_type_id;
15157 }
15158 
15159 static GType
vala_gir_parser_metadata_get_type(void)15160 vala_gir_parser_metadata_get_type (void)
15161 {
15162 	static volatile gsize vala_gir_parser_metadata_type_id__volatile = 0;
15163 	if (g_once_init_enter (&vala_gir_parser_metadata_type_id__volatile)) {
15164 		GType vala_gir_parser_metadata_type_id;
15165 		vala_gir_parser_metadata_type_id = vala_gir_parser_metadata_get_type_once ();
15166 		g_once_init_leave (&vala_gir_parser_metadata_type_id__volatile, vala_gir_parser_metadata_type_id);
15167 	}
15168 	return vala_gir_parser_metadata_type_id__volatile;
15169 }
15170 
15171 static gpointer
vala_gir_parser_metadata_ref(gpointer instance)15172 vala_gir_parser_metadata_ref (gpointer instance)
15173 {
15174 	ValaGirParserMetadata * self;
15175 	self = instance;
15176 	g_atomic_int_inc (&self->ref_count);
15177 	return instance;
15178 }
15179 
15180 static void
vala_gir_parser_metadata_unref(gpointer instance)15181 vala_gir_parser_metadata_unref (gpointer instance)
15182 {
15183 	ValaGirParserMetadata * self;
15184 	self = instance;
15185 	if (g_atomic_int_dec_and_test (&self->ref_count)) {
15186 		VALA_GIR_PARSER_METADATA_GET_CLASS (self)->finalize (self);
15187 		g_type_free_instance ((GTypeInstance *) self);
15188 	}
15189 }
15190 
15191 static inline gpointer
vala_gir_parser_metadata_parser_get_instance_private(ValaGirParserMetadataParser * self)15192 vala_gir_parser_metadata_parser_get_instance_private (ValaGirParserMetadataParser* self)
15193 {
15194 	return G_STRUCT_MEMBER_P (self, ValaGirParserMetadataParser_private_offset);
15195 }
15196 
15197 static ValaGirParserMetadataParser*
vala_gir_parser_metadata_parser_construct(GType object_type)15198 vala_gir_parser_metadata_parser_construct (GType object_type)
15199 {
15200 	ValaGirParserMetadataParser* self = NULL;
15201 	ValaGirParserMetadata* _tmp0_;
15202 	self = (ValaGirParserMetadataParser*) g_type_create_instance (object_type);
15203 	_tmp0_ = self->priv->tree;
15204 	_tmp0_->used = TRUE;
15205 	return self;
15206 }
15207 
15208 static ValaGirParserMetadataParser*
vala_gir_parser_metadata_parser_new(void)15209 vala_gir_parser_metadata_parser_new (void)
15210 {
15211 	return vala_gir_parser_metadata_parser_construct (VALA_GIR_PARSER_TYPE_METADATA_PARSER);
15212 }
15213 
15214 static ValaSourceReference*
vala_gir_parser_metadata_parser_get_current_src(ValaGirParserMetadataParser * self)15215 vala_gir_parser_metadata_parser_get_current_src (ValaGirParserMetadataParser* self)
15216 {
15217 	ValaScanner* _tmp0_;
15218 	ValaSourceFile* _tmp1_;
15219 	ValaSourceFile* _tmp2_;
15220 	ValaSourceLocation _tmp3_;
15221 	ValaSourceLocation _tmp4_;
15222 	ValaSourceReference* _tmp5_;
15223 	ValaSourceReference* result = NULL;
15224 	g_return_val_if_fail (self != NULL, NULL);
15225 	_tmp0_ = self->priv->scanner;
15226 	_tmp1_ = vala_scanner_get_source_file (_tmp0_);
15227 	_tmp2_ = _tmp1_;
15228 	_tmp3_ = self->priv->begin;
15229 	_tmp4_ = self->priv->end;
15230 	_tmp5_ = vala_source_reference_new (_tmp2_, &_tmp3_, &_tmp4_);
15231 	result = _tmp5_;
15232 	return result;
15233 }
15234 
15235 static ValaSourceReference*
vala_gir_parser_metadata_parser_get_src(ValaGirParserMetadataParser * self,ValaSourceLocation * begin,ValaSourceLocation * end)15236 vala_gir_parser_metadata_parser_get_src (ValaGirParserMetadataParser* self,
15237                                          ValaSourceLocation* begin,
15238                                          ValaSourceLocation* end)
15239 {
15240 	ValaSourceLocation e = {0};
15241 	ValaSourceLocation _tmp0_;
15242 	ValaScanner* _tmp1_;
15243 	ValaSourceFile* _tmp2_;
15244 	ValaSourceFile* _tmp3_;
15245 	ValaSourceLocation _tmp4_;
15246 	ValaSourceLocation _tmp5_;
15247 	ValaSourceReference* _tmp6_;
15248 	ValaSourceReference* result = NULL;
15249 	g_return_val_if_fail (self != NULL, NULL);
15250 	g_return_val_if_fail (begin != NULL, NULL);
15251 	_tmp0_ = self->priv->end;
15252 	e = _tmp0_;
15253 	if (end != NULL) {
15254 		e = *end;
15255 	}
15256 	_tmp1_ = self->priv->scanner;
15257 	_tmp2_ = vala_scanner_get_source_file (_tmp1_);
15258 	_tmp3_ = _tmp2_;
15259 	_tmp4_ = *begin;
15260 	_tmp5_ = e;
15261 	_tmp6_ = vala_source_reference_new (_tmp3_, &_tmp4_, &_tmp5_);
15262 	result = _tmp6_;
15263 	return result;
15264 }
15265 
15266 static ValaGirParserMetadata*
vala_gir_parser_metadata_parser_parse_metadata(ValaGirParserMetadataParser * self,ValaSourceFile * metadata_file)15267 vala_gir_parser_metadata_parser_parse_metadata (ValaGirParserMetadataParser* self,
15268                                                 ValaSourceFile* metadata_file)
15269 {
15270 	ValaScanner* _tmp0_;
15271 	ValaGirParserMetadata* _tmp5_;
15272 	ValaGirParserMetadata* _tmp6_;
15273 	ValaGirParserMetadata* result = NULL;
15274 	g_return_val_if_fail (self != NULL, NULL);
15275 	g_return_val_if_fail (metadata_file != NULL, NULL);
15276 	_tmp0_ = vala_scanner_new (metadata_file);
15277 	_vala_scanner_unref0 (self->priv->scanner);
15278 	self->priv->scanner = _tmp0_;
15279 	vala_gir_parser_metadata_parser_next (self);
15280 	while (TRUE) {
15281 		ValaTokenType _tmp1_;
15282 		_tmp1_ = self->priv->current;
15283 		if (!(_tmp1_ != VALA_TOKEN_TYPE_EOF)) {
15284 			break;
15285 		}
15286 		if (!vala_gir_parser_metadata_parser_parse_rule (self)) {
15287 			ValaGirParserMetadata* _tmp2_;
15288 			ValaGirParserMetadata* _tmp3_;
15289 			ValaGirParserMetadata* _tmp4_;
15290 			_tmp2_ = vala_gir_parser_metadata_get_empty ();
15291 			_tmp3_ = _tmp2_;
15292 			_tmp4_ = _vala_gir_parser_metadata_ref0 (_tmp3_);
15293 			result = _tmp4_;
15294 			return result;
15295 		}
15296 	}
15297 	_tmp5_ = self->priv->tree;
15298 	_tmp6_ = _vala_gir_parser_metadata_ref0 (_tmp5_);
15299 	result = _tmp6_;
15300 	return result;
15301 }
15302 
15303 static ValaTokenType
vala_gir_parser_metadata_parser_next(ValaGirParserMetadataParser * self)15304 vala_gir_parser_metadata_parser_next (ValaGirParserMetadataParser* self)
15305 {
15306 	ValaSourceLocation _tmp0_;
15307 	ValaScanner* _tmp1_;
15308 	ValaSourceLocation _tmp2_ = {0};
15309 	ValaSourceLocation _tmp3_ = {0};
15310 	ValaTokenType _tmp4_;
15311 	ValaTokenType _tmp5_;
15312 	ValaTokenType result = 0;
15313 	g_return_val_if_fail (self != NULL, 0);
15314 	_tmp0_ = self->priv->end;
15315 	self->priv->old_end = _tmp0_;
15316 	_tmp1_ = self->priv->scanner;
15317 	_tmp4_ = vala_scanner_read_token (_tmp1_, &_tmp2_, &_tmp3_);
15318 	self->priv->begin = _tmp2_;
15319 	self->priv->end = _tmp3_;
15320 	self->priv->current = _tmp4_;
15321 	_tmp5_ = self->priv->current;
15322 	result = _tmp5_;
15323 	return result;
15324 }
15325 
15326 static gboolean
vala_gir_parser_metadata_parser_has_space(ValaGirParserMetadataParser * self)15327 vala_gir_parser_metadata_parser_has_space (ValaGirParserMetadataParser* self)
15328 {
15329 	ValaSourceLocation _tmp0_;
15330 	gchar* _tmp1_;
15331 	ValaSourceLocation _tmp2_;
15332 	gchar* _tmp3_;
15333 	gboolean result = FALSE;
15334 	g_return_val_if_fail (self != NULL, FALSE);
15335 	_tmp0_ = self->priv->old_end;
15336 	_tmp1_ = _tmp0_.pos;
15337 	_tmp2_ = self->priv->begin;
15338 	_tmp3_ = _tmp2_.pos;
15339 	result = _tmp1_ != _tmp3_;
15340 	return result;
15341 }
15342 
15343 static gboolean
vala_gir_parser_metadata_parser_has_newline(ValaGirParserMetadataParser * self)15344 vala_gir_parser_metadata_parser_has_newline (ValaGirParserMetadataParser* self)
15345 {
15346 	ValaSourceLocation _tmp0_;
15347 	ValaSourceLocation _tmp1_;
15348 	gboolean result = FALSE;
15349 	g_return_val_if_fail (self != NULL, FALSE);
15350 	_tmp0_ = self->priv->old_end;
15351 	_tmp1_ = self->priv->begin;
15352 	result = _tmp0_.line != _tmp1_.line;
15353 	return result;
15354 }
15355 
15356 static gchar*
vala_gir_parser_metadata_parser_get_string(ValaGirParserMetadataParser * self,ValaSourceLocation * begin,ValaSourceLocation * end)15357 vala_gir_parser_metadata_parser_get_string (ValaGirParserMetadataParser* self,
15358                                             ValaSourceLocation* begin,
15359                                             ValaSourceLocation* end)
15360 {
15361 	ValaSourceLocation b = {0};
15362 	ValaSourceLocation _tmp0_;
15363 	ValaSourceLocation e = {0};
15364 	ValaSourceLocation _tmp1_;
15365 	ValaSourceLocation _tmp2_;
15366 	gchar* _tmp3_;
15367 	ValaSourceLocation _tmp4_;
15368 	gchar* _tmp5_;
15369 	ValaSourceLocation _tmp6_;
15370 	gchar* _tmp7_;
15371 	gchar* _tmp8_;
15372 	gchar* result = NULL;
15373 	g_return_val_if_fail (self != NULL, NULL);
15374 	_tmp0_ = self->priv->begin;
15375 	b = _tmp0_;
15376 	_tmp1_ = self->priv->end;
15377 	e = _tmp1_;
15378 	if (begin != NULL) {
15379 		b = *begin;
15380 	}
15381 	if (end != NULL) {
15382 		e = *end;
15383 	}
15384 	_tmp2_ = b;
15385 	_tmp3_ = _tmp2_.pos;
15386 	_tmp4_ = e;
15387 	_tmp5_ = _tmp4_.pos;
15388 	_tmp6_ = b;
15389 	_tmp7_ = _tmp6_.pos;
15390 	_tmp8_ = string_substring ((const gchar*) _tmp3_, (glong) 0, (glong) ((gint) (_tmp5_ - _tmp7_)));
15391 	result = _tmp8_;
15392 	return result;
15393 }
15394 
15395 static gchar*
vala_gir_parser_metadata_parser_parse_identifier(ValaGirParserMetadataParser * self,gboolean is_glob)15396 vala_gir_parser_metadata_parser_parse_identifier (ValaGirParserMetadataParser* self,
15397                                                   gboolean is_glob)
15398 {
15399 	ValaSourceLocation begin = {0};
15400 	ValaSourceLocation _tmp0_;
15401 	gboolean _tmp1_ = FALSE;
15402 	ValaTokenType _tmp2_;
15403 	ValaSourceLocation _tmp15_;
15404 	ValaSourceLocation _tmp16_;
15405 	gchar* _tmp17_;
15406 	gchar* result = NULL;
15407 	g_return_val_if_fail (self != NULL, NULL);
15408 	_tmp0_ = self->priv->begin;
15409 	begin = _tmp0_;
15410 	_tmp2_ = self->priv->current;
15411 	if (_tmp2_ == VALA_TOKEN_TYPE_DOT) {
15412 		_tmp1_ = TRUE;
15413 	} else {
15414 		ValaTokenType _tmp3_;
15415 		_tmp3_ = self->priv->current;
15416 		_tmp1_ = _tmp3_ == VALA_TOKEN_TYPE_HASH;
15417 	}
15418 	if (_tmp1_) {
15419 		if (is_glob) {
15420 			ValaSourceLocation _tmp4_;
15421 			ValaSourceReference* _tmp5_;
15422 			ValaSourceReference* _tmp6_;
15423 			_tmp4_ = begin;
15424 			_tmp5_ = vala_gir_parser_metadata_parser_get_src (self, &_tmp4_, NULL);
15425 			_tmp6_ = _tmp5_;
15426 			vala_report_error (_tmp6_, "expected glob-style pattern");
15427 			_vala_source_reference_unref0 (_tmp6_);
15428 		} else {
15429 			ValaSourceLocation _tmp7_;
15430 			ValaSourceReference* _tmp8_;
15431 			ValaSourceReference* _tmp9_;
15432 			_tmp7_ = begin;
15433 			_tmp8_ = vala_gir_parser_metadata_parser_get_src (self, &_tmp7_, NULL);
15434 			_tmp9_ = _tmp8_;
15435 			vala_report_error (_tmp9_, "expected identifier");
15436 			_vala_source_reference_unref0 (_tmp9_);
15437 		}
15438 		result = NULL;
15439 		return result;
15440 	}
15441 	if (is_glob) {
15442 		while (TRUE) {
15443 			gboolean _tmp10_ = FALSE;
15444 			gboolean _tmp11_ = FALSE;
15445 			ValaTokenType _tmp12_;
15446 			_tmp12_ = self->priv->current;
15447 			if (_tmp12_ != VALA_TOKEN_TYPE_EOF) {
15448 				ValaTokenType _tmp13_;
15449 				_tmp13_ = self->priv->current;
15450 				_tmp11_ = _tmp13_ != VALA_TOKEN_TYPE_DOT;
15451 			} else {
15452 				_tmp11_ = FALSE;
15453 			}
15454 			if (_tmp11_) {
15455 				ValaTokenType _tmp14_;
15456 				_tmp14_ = self->priv->current;
15457 				_tmp10_ = _tmp14_ != VALA_TOKEN_TYPE_HASH;
15458 			} else {
15459 				_tmp10_ = FALSE;
15460 			}
15461 			if (!_tmp10_) {
15462 				break;
15463 			}
15464 			vala_gir_parser_metadata_parser_next (self);
15465 			if (vala_gir_parser_metadata_parser_has_space (self)) {
15466 				break;
15467 			}
15468 		}
15469 	} else {
15470 		vala_gir_parser_metadata_parser_next (self);
15471 	}
15472 	_tmp15_ = begin;
15473 	_tmp16_ = self->priv->old_end;
15474 	_tmp17_ = vala_gir_parser_metadata_parser_get_string (self, &_tmp15_, &_tmp16_);
15475 	result = _tmp17_;
15476 	return result;
15477 }
15478 
15479 static gchar*
vala_gir_parser_metadata_parser_parse_selector(ValaGirParserMetadataParser * self)15480 vala_gir_parser_metadata_parser_parse_selector (ValaGirParserMetadataParser* self)
15481 {
15482 	gboolean _tmp0_ = FALSE;
15483 	ValaTokenType _tmp1_;
15484 	gchar* _tmp2_;
15485 	gchar* result = NULL;
15486 	g_return_val_if_fail (self != NULL, NULL);
15487 	_tmp1_ = self->priv->current;
15488 	if (_tmp1_ != VALA_TOKEN_TYPE_HASH) {
15489 		_tmp0_ = TRUE;
15490 	} else {
15491 		_tmp0_ = vala_gir_parser_metadata_parser_has_space (self);
15492 	}
15493 	if (_tmp0_) {
15494 		result = NULL;
15495 		return result;
15496 	}
15497 	vala_gir_parser_metadata_parser_next (self);
15498 	_tmp2_ = vala_gir_parser_metadata_parser_parse_identifier (self, FALSE);
15499 	result = _tmp2_;
15500 	return result;
15501 }
15502 
15503 static ValaGirParserMetadata*
vala_gir_parser_metadata_parser_parse_pattern(ValaGirParserMetadataParser * self)15504 vala_gir_parser_metadata_parser_parse_pattern (ValaGirParserMetadataParser* self)
15505 {
15506 	ValaGirParserMetadata* metadata = NULL;
15507 	gboolean is_relative = FALSE;
15508 	gboolean _tmp0_ = FALSE;
15509 	ValaTokenType _tmp1_;
15510 	ValaGirParserMetadata* _tmp12_;
15511 	ValaSourceLocation begin = {0};
15512 	ValaSourceLocation _tmp15_;
15513 	gchar* pattern = NULL;
15514 	gchar* _tmp16_;
15515 	const gchar* _tmp17_;
15516 	const gchar* _tmp18_;
15517 	gchar* _tmp19_;
15518 	gchar* _tmp20_;
15519 	ValaSourceLocation _tmp21_;
15520 	ValaSourceReference* _tmp22_;
15521 	ValaSourceReference* _tmp23_;
15522 	ValaGirParserMetadata* _tmp24_;
15523 	ValaGirParserMetadata* _tmp25_;
15524 	ValaGirParserMetadata* _tmp26_;
15525 	ValaGirParserMetadata* result = NULL;
15526 	g_return_val_if_fail (self != NULL, NULL);
15527 	is_relative = FALSE;
15528 	_tmp1_ = self->priv->current;
15529 	if (_tmp1_ == VALA_TOKEN_TYPE_IDENTIFIER) {
15530 		_tmp0_ = TRUE;
15531 	} else {
15532 		ValaTokenType _tmp2_;
15533 		_tmp2_ = self->priv->current;
15534 		_tmp0_ = _tmp2_ == VALA_TOKEN_TYPE_STAR;
15535 	}
15536 	if (_tmp0_) {
15537 		ValaGirParserMetadata* _tmp3_;
15538 		ValaGirParserMetadata* _tmp4_;
15539 		_tmp3_ = self->priv->tree;
15540 		_tmp4_ = _vala_gir_parser_metadata_ref0 (_tmp3_);
15541 		_vala_gir_parser_metadata_unref0 (self->priv->parent_metadata);
15542 		self->priv->parent_metadata = _tmp4_;
15543 	} else {
15544 		ValaTokenType _tmp5_;
15545 		_tmp5_ = self->priv->current;
15546 		if (_tmp5_ != VALA_TOKEN_TYPE_DOT) {
15547 			ValaSourceReference* _tmp6_;
15548 			ValaSourceReference* _tmp7_;
15549 			ValaTokenType _tmp8_;
15550 			const gchar* _tmp9_;
15551 			gchar* _tmp10_;
15552 			gchar* _tmp11_;
15553 			_tmp6_ = vala_gir_parser_metadata_parser_get_current_src (self);
15554 			_tmp7_ = _tmp6_;
15555 			_tmp8_ = self->priv->current;
15556 			_tmp9_ = vala_token_type_to_string (_tmp8_);
15557 			_tmp10_ = g_strdup_printf ("expected pattern or `.', got %s", _tmp9_);
15558 			_tmp11_ = _tmp10_;
15559 			vala_report_error (_tmp7_, _tmp11_);
15560 			_g_free0 (_tmp11_);
15561 			_vala_source_reference_unref0 (_tmp7_);
15562 			result = NULL;
15563 			_vala_gir_parser_metadata_unref0 (metadata);
15564 			return result;
15565 		}
15566 		vala_gir_parser_metadata_parser_next (self);
15567 		is_relative = TRUE;
15568 	}
15569 	_tmp12_ = self->priv->parent_metadata;
15570 	if (_tmp12_ == NULL) {
15571 		ValaSourceReference* _tmp13_;
15572 		ValaSourceReference* _tmp14_;
15573 		_tmp13_ = vala_gir_parser_metadata_parser_get_current_src (self);
15574 		_tmp14_ = _tmp13_;
15575 		vala_report_error (_tmp14_, "cannot determinate parent metadata");
15576 		_vala_source_reference_unref0 (_tmp14_);
15577 		result = NULL;
15578 		_vala_gir_parser_metadata_unref0 (metadata);
15579 		return result;
15580 	}
15581 	_tmp15_ = self->priv->begin;
15582 	begin = _tmp15_;
15583 	_tmp16_ = vala_gir_parser_metadata_parser_parse_identifier (self, TRUE);
15584 	pattern = _tmp16_;
15585 	_tmp17_ = pattern;
15586 	if (_tmp17_ == NULL) {
15587 		result = NULL;
15588 		_g_free0 (pattern);
15589 		_vala_gir_parser_metadata_unref0 (metadata);
15590 		return result;
15591 	}
15592 	_tmp18_ = pattern;
15593 	_tmp19_ = vala_gir_parser_metadata_parser_parse_selector (self);
15594 	_tmp20_ = _tmp19_;
15595 	_tmp21_ = begin;
15596 	_tmp22_ = vala_gir_parser_metadata_parser_get_src (self, &_tmp21_, NULL);
15597 	_tmp23_ = _tmp22_;
15598 	_tmp24_ = vala_gir_parser_metadata_new (_tmp18_, _tmp20_, _tmp23_);
15599 	_vala_gir_parser_metadata_unref0 (metadata);
15600 	metadata = _tmp24_;
15601 	_vala_source_reference_unref0 (_tmp23_);
15602 	_g_free0 (_tmp20_);
15603 	_tmp25_ = self->priv->parent_metadata;
15604 	_tmp26_ = metadata;
15605 	vala_gir_parser_metadata_add_child (_tmp25_, _tmp26_);
15606 	while (TRUE) {
15607 		gboolean _tmp27_ = FALSE;
15608 		ValaTokenType _tmp28_;
15609 		ValaTokenType _tmp29_;
15610 		ValaSourceLocation _tmp36_;
15611 		gchar* _tmp37_;
15612 		const gchar* _tmp38_;
15613 		ValaGirParserMetadata* child = NULL;
15614 		const gchar* _tmp39_;
15615 		gchar* _tmp40_;
15616 		gchar* _tmp41_;
15617 		ValaSourceLocation _tmp42_;
15618 		ValaSourceLocation _tmp43_;
15619 		ValaSourceReference* _tmp44_;
15620 		ValaSourceReference* _tmp45_;
15621 		ValaGirParserMetadata* _tmp46_;
15622 		ValaGirParserMetadata* _tmp47_;
15623 		ValaGirParserMetadata* _tmp48_;
15624 		ValaGirParserMetadata* _tmp49_;
15625 		ValaGirParserMetadata* _tmp50_;
15626 		ValaGirParserMetadata* _tmp51_;
15627 		_tmp28_ = self->priv->current;
15628 		if (_tmp28_ != VALA_TOKEN_TYPE_EOF) {
15629 			_tmp27_ = !vala_gir_parser_metadata_parser_has_space (self);
15630 		} else {
15631 			_tmp27_ = FALSE;
15632 		}
15633 		if (!_tmp27_) {
15634 			break;
15635 		}
15636 		_tmp29_ = self->priv->current;
15637 		if (_tmp29_ != VALA_TOKEN_TYPE_DOT) {
15638 			ValaSourceReference* _tmp30_;
15639 			ValaSourceReference* _tmp31_;
15640 			ValaTokenType _tmp32_;
15641 			const gchar* _tmp33_;
15642 			gchar* _tmp34_;
15643 			gchar* _tmp35_;
15644 			_tmp30_ = vala_gir_parser_metadata_parser_get_current_src (self);
15645 			_tmp31_ = _tmp30_;
15646 			_tmp32_ = self->priv->current;
15647 			_tmp33_ = vala_token_type_to_string (_tmp32_);
15648 			_tmp34_ = g_strdup_printf ("expected `.' got %s", _tmp33_);
15649 			_tmp35_ = _tmp34_;
15650 			vala_report_error (_tmp31_, _tmp35_);
15651 			_g_free0 (_tmp35_);
15652 			_vala_source_reference_unref0 (_tmp31_);
15653 			break;
15654 		}
15655 		vala_gir_parser_metadata_parser_next (self);
15656 		_tmp36_ = self->priv->begin;
15657 		begin = _tmp36_;
15658 		_tmp37_ = vala_gir_parser_metadata_parser_parse_identifier (self, TRUE);
15659 		_g_free0 (pattern);
15660 		pattern = _tmp37_;
15661 		_tmp38_ = pattern;
15662 		if (_tmp38_ == NULL) {
15663 			result = NULL;
15664 			_g_free0 (pattern);
15665 			_vala_gir_parser_metadata_unref0 (metadata);
15666 			return result;
15667 		}
15668 		_tmp39_ = pattern;
15669 		_tmp40_ = vala_gir_parser_metadata_parser_parse_selector (self);
15670 		_tmp41_ = _tmp40_;
15671 		_tmp42_ = begin;
15672 		_tmp43_ = self->priv->old_end;
15673 		_tmp44_ = vala_gir_parser_metadata_parser_get_src (self, &_tmp42_, &_tmp43_);
15674 		_tmp45_ = _tmp44_;
15675 		_tmp46_ = vala_gir_parser_metadata_new (_tmp39_, _tmp41_, _tmp45_);
15676 		_tmp47_ = _tmp46_;
15677 		_vala_source_reference_unref0 (_tmp45_);
15678 		_g_free0 (_tmp41_);
15679 		child = _tmp47_;
15680 		_tmp48_ = metadata;
15681 		_tmp49_ = child;
15682 		vala_gir_parser_metadata_add_child (_tmp48_, _tmp49_);
15683 		_tmp50_ = child;
15684 		_tmp51_ = _vala_gir_parser_metadata_ref0 (_tmp50_);
15685 		_vala_gir_parser_metadata_unref0 (metadata);
15686 		metadata = _tmp51_;
15687 		_vala_gir_parser_metadata_unref0 (child);
15688 	}
15689 	if (!is_relative) {
15690 		ValaGirParserMetadata* _tmp52_;
15691 		ValaGirParserMetadata* _tmp53_;
15692 		_tmp52_ = metadata;
15693 		_tmp53_ = _vala_gir_parser_metadata_ref0 (_tmp52_);
15694 		_vala_gir_parser_metadata_unref0 (self->priv->parent_metadata);
15695 		self->priv->parent_metadata = _tmp53_;
15696 	}
15697 	result = metadata;
15698 	_g_free0 (pattern);
15699 	return result;
15700 }
15701 
15702 static ValaExpression*
vala_gir_parser_metadata_parser_parse_expression(ValaGirParserMetadataParser * self)15703 vala_gir_parser_metadata_parser_parse_expression (ValaGirParserMetadataParser* self)
15704 {
15705 	ValaSourceLocation begin = {0};
15706 	ValaSourceLocation _tmp0_;
15707 	ValaSourceReference* src = NULL;
15708 	ValaSourceReference* _tmp1_;
15709 	ValaExpression* expr = NULL;
15710 	ValaTokenType _tmp2_;
15711 	ValaExpression* result = NULL;
15712 	g_return_val_if_fail (self != NULL, NULL);
15713 	_tmp0_ = self->priv->begin;
15714 	begin = _tmp0_;
15715 	_tmp1_ = vala_gir_parser_metadata_parser_get_current_src (self);
15716 	src = _tmp1_;
15717 	expr = NULL;
15718 	_tmp2_ = self->priv->current;
15719 	switch (_tmp2_) {
15720 		case VALA_TOKEN_TYPE_NULL:
15721 		{
15722 			ValaSourceReference* _tmp3_;
15723 			ValaNullLiteral* _tmp4_;
15724 			_tmp3_ = src;
15725 			_tmp4_ = vala_null_literal_new (_tmp3_);
15726 			_vala_code_node_unref0 (expr);
15727 			expr = (ValaExpression*) _tmp4_;
15728 			break;
15729 		}
15730 		case VALA_TOKEN_TYPE_TRUE:
15731 		{
15732 			ValaSourceReference* _tmp5_;
15733 			ValaBooleanLiteral* _tmp6_;
15734 			_tmp5_ = src;
15735 			_tmp6_ = vala_boolean_literal_new (TRUE, _tmp5_);
15736 			_vala_code_node_unref0 (expr);
15737 			expr = (ValaExpression*) _tmp6_;
15738 			break;
15739 		}
15740 		case VALA_TOKEN_TYPE_FALSE:
15741 		{
15742 			ValaSourceReference* _tmp7_;
15743 			ValaBooleanLiteral* _tmp8_;
15744 			_tmp7_ = src;
15745 			_tmp8_ = vala_boolean_literal_new (FALSE, _tmp7_);
15746 			_vala_code_node_unref0 (expr);
15747 			expr = (ValaExpression*) _tmp8_;
15748 			break;
15749 		}
15750 		case VALA_TOKEN_TYPE_MINUS:
15751 		{
15752 			ValaExpression* inner = NULL;
15753 			ValaExpression* _tmp9_;
15754 			ValaExpression* _tmp10_;
15755 			vala_gir_parser_metadata_parser_next (self);
15756 			_tmp9_ = vala_gir_parser_metadata_parser_parse_expression (self);
15757 			inner = _tmp9_;
15758 			_tmp10_ = inner;
15759 			if (_tmp10_ == NULL) {
15760 				ValaSourceReference* _tmp11_;
15761 				ValaTokenType _tmp12_;
15762 				const gchar* _tmp13_;
15763 				gchar* _tmp14_;
15764 				gchar* _tmp15_;
15765 				_tmp11_ = src;
15766 				_tmp12_ = self->priv->current;
15767 				_tmp13_ = vala_token_type_to_string (_tmp12_);
15768 				_tmp14_ = g_strdup_printf ("expected expression after `-', got %s", _tmp13_);
15769 				_tmp15_ = _tmp14_;
15770 				vala_report_error (_tmp11_, _tmp15_);
15771 				_g_free0 (_tmp15_);
15772 			} else {
15773 				ValaExpression* _tmp16_;
15774 				ValaSourceLocation _tmp17_;
15775 				ValaSourceReference* _tmp18_;
15776 				ValaSourceReference* _tmp19_;
15777 				ValaUnaryExpression* _tmp20_;
15778 				_tmp16_ = inner;
15779 				_tmp17_ = begin;
15780 				_tmp18_ = vala_gir_parser_metadata_parser_get_src (self, &_tmp17_, NULL);
15781 				_tmp19_ = _tmp18_;
15782 				_tmp20_ = vala_unary_expression_new (VALA_UNARY_OPERATOR_MINUS, _tmp16_, _tmp19_);
15783 				_vala_code_node_unref0 (expr);
15784 				expr = (ValaExpression*) _tmp20_;
15785 				_vala_source_reference_unref0 (_tmp19_);
15786 			}
15787 			result = expr;
15788 			_vala_code_node_unref0 (inner);
15789 			_vala_source_reference_unref0 (src);
15790 			return result;
15791 		}
15792 		case VALA_TOKEN_TYPE_INTEGER_LITERAL:
15793 		{
15794 			gchar* _tmp21_;
15795 			gchar* _tmp22_;
15796 			ValaSourceReference* _tmp23_;
15797 			ValaIntegerLiteral* _tmp24_;
15798 			_tmp21_ = vala_gir_parser_metadata_parser_get_string (self, NULL, NULL);
15799 			_tmp22_ = _tmp21_;
15800 			_tmp23_ = src;
15801 			_tmp24_ = vala_integer_literal_new (_tmp22_, _tmp23_);
15802 			_vala_code_node_unref0 (expr);
15803 			expr = (ValaExpression*) _tmp24_;
15804 			_g_free0 (_tmp22_);
15805 			break;
15806 		}
15807 		case VALA_TOKEN_TYPE_REAL_LITERAL:
15808 		{
15809 			gchar* _tmp25_;
15810 			gchar* _tmp26_;
15811 			ValaSourceReference* _tmp27_;
15812 			ValaRealLiteral* _tmp28_;
15813 			_tmp25_ = vala_gir_parser_metadata_parser_get_string (self, NULL, NULL);
15814 			_tmp26_ = _tmp25_;
15815 			_tmp27_ = src;
15816 			_tmp28_ = vala_real_literal_new (_tmp26_, _tmp27_);
15817 			_vala_code_node_unref0 (expr);
15818 			expr = (ValaExpression*) _tmp28_;
15819 			_g_free0 (_tmp26_);
15820 			break;
15821 		}
15822 		case VALA_TOKEN_TYPE_STRING_LITERAL:
15823 		{
15824 			gchar* _tmp29_;
15825 			gchar* _tmp30_;
15826 			ValaSourceReference* _tmp31_;
15827 			ValaStringLiteral* _tmp32_;
15828 			_tmp29_ = vala_gir_parser_metadata_parser_get_string (self, NULL, NULL);
15829 			_tmp30_ = _tmp29_;
15830 			_tmp31_ = src;
15831 			_tmp32_ = vala_string_literal_new (_tmp30_, _tmp31_);
15832 			_vala_code_node_unref0 (expr);
15833 			expr = (ValaExpression*) _tmp32_;
15834 			_g_free0 (_tmp30_);
15835 			break;
15836 		}
15837 		case VALA_TOKEN_TYPE_IDENTIFIER:
15838 		{
15839 			gchar* _tmp33_;
15840 			gchar* _tmp34_;
15841 			ValaSourceReference* _tmp35_;
15842 			ValaMemberAccess* _tmp36_;
15843 			_tmp33_ = vala_gir_parser_metadata_parser_get_string (self, NULL, NULL);
15844 			_tmp34_ = _tmp33_;
15845 			_tmp35_ = src;
15846 			_tmp36_ = vala_member_access_new (NULL, _tmp34_, _tmp35_);
15847 			_vala_code_node_unref0 (expr);
15848 			expr = (ValaExpression*) _tmp36_;
15849 			_g_free0 (_tmp34_);
15850 			while (TRUE) {
15851 				ValaExpression* _tmp43_;
15852 				gchar* _tmp44_;
15853 				gchar* _tmp45_;
15854 				ValaSourceReference* _tmp46_;
15855 				ValaSourceReference* _tmp47_;
15856 				ValaMemberAccess* _tmp48_;
15857 				if (!(vala_gir_parser_metadata_parser_next (self) == VALA_TOKEN_TYPE_DOT)) {
15858 					break;
15859 				}
15860 				if (vala_gir_parser_metadata_parser_next (self) != VALA_TOKEN_TYPE_IDENTIFIER) {
15861 					ValaSourceReference* _tmp37_;
15862 					ValaSourceReference* _tmp38_;
15863 					ValaTokenType _tmp39_;
15864 					const gchar* _tmp40_;
15865 					gchar* _tmp41_;
15866 					gchar* _tmp42_;
15867 					_tmp37_ = vala_gir_parser_metadata_parser_get_current_src (self);
15868 					_tmp38_ = _tmp37_;
15869 					_tmp39_ = self->priv->current;
15870 					_tmp40_ = vala_token_type_to_string (_tmp39_);
15871 					_tmp41_ = g_strdup_printf ("expected identifier got %s", _tmp40_);
15872 					_tmp42_ = _tmp41_;
15873 					vala_report_error (_tmp38_, _tmp42_);
15874 					_g_free0 (_tmp42_);
15875 					_vala_source_reference_unref0 (_tmp38_);
15876 					break;
15877 				}
15878 				_tmp43_ = expr;
15879 				_tmp44_ = vala_gir_parser_metadata_parser_get_string (self, NULL, NULL);
15880 				_tmp45_ = _tmp44_;
15881 				_tmp46_ = vala_gir_parser_metadata_parser_get_current_src (self);
15882 				_tmp47_ = _tmp46_;
15883 				_tmp48_ = vala_member_access_new (_tmp43_, _tmp45_, _tmp47_);
15884 				_vala_code_node_unref0 (expr);
15885 				expr = (ValaExpression*) _tmp48_;
15886 				_vala_source_reference_unref0 (_tmp47_);
15887 				_g_free0 (_tmp45_);
15888 			}
15889 			result = expr;
15890 			_vala_source_reference_unref0 (src);
15891 			return result;
15892 		}
15893 		case VALA_TOKEN_TYPE_OPEN_PARENS:
15894 		{
15895 			ValaSourceReference* _tmp55_;
15896 			ValaTuple* _tmp56_;
15897 			if (vala_gir_parser_metadata_parser_next (self) != VALA_TOKEN_TYPE_CLOSE_PARENS) {
15898 				ValaSourceReference* _tmp49_;
15899 				ValaSourceReference* _tmp50_;
15900 				ValaTokenType _tmp51_;
15901 				const gchar* _tmp52_;
15902 				gchar* _tmp53_;
15903 				gchar* _tmp54_;
15904 				_tmp49_ = vala_gir_parser_metadata_parser_get_current_src (self);
15905 				_tmp50_ = _tmp49_;
15906 				_tmp51_ = self->priv->current;
15907 				_tmp52_ = vala_token_type_to_string (_tmp51_);
15908 				_tmp53_ = g_strdup_printf ("expected `)', got %s", _tmp52_);
15909 				_tmp54_ = _tmp53_;
15910 				vala_report_error (_tmp50_, _tmp54_);
15911 				_g_free0 (_tmp54_);
15912 				_vala_source_reference_unref0 (_tmp50_);
15913 				break;
15914 			}
15915 			_tmp55_ = src;
15916 			_tmp56_ = vala_tuple_new (_tmp55_);
15917 			_vala_code_node_unref0 (expr);
15918 			expr = (ValaExpression*) _tmp56_;
15919 			break;
15920 		}
15921 		default:
15922 		{
15923 			ValaSourceReference* _tmp57_;
15924 			ValaTokenType _tmp58_;
15925 			const gchar* _tmp59_;
15926 			gchar* _tmp60_;
15927 			gchar* _tmp61_;
15928 			_tmp57_ = src;
15929 			_tmp58_ = self->priv->current;
15930 			_tmp59_ = vala_token_type_to_string (_tmp58_);
15931 			_tmp60_ = g_strdup_printf ("expected literal or symbol got %s", _tmp59_);
15932 			_tmp61_ = _tmp60_;
15933 			vala_report_error (_tmp57_, _tmp61_);
15934 			_g_free0 (_tmp61_);
15935 			break;
15936 		}
15937 	}
15938 	vala_gir_parser_metadata_parser_next (self);
15939 	result = expr;
15940 	_vala_source_reference_unref0 (src);
15941 	return result;
15942 }
15943 
15944 static gboolean
vala_gir_parser_metadata_parser_parse_args(ValaGirParserMetadataParser * self,ValaGirParserMetadata * metadata)15945 vala_gir_parser_metadata_parser_parse_args (ValaGirParserMetadataParser* self,
15946                                             ValaGirParserMetadata* metadata)
15947 {
15948 	gboolean result = FALSE;
15949 	g_return_val_if_fail (self != NULL, FALSE);
15950 	g_return_val_if_fail (metadata != NULL, FALSE);
15951 	while (TRUE) {
15952 		gboolean _tmp0_ = FALSE;
15953 		gboolean _tmp1_ = FALSE;
15954 		ValaTokenType _tmp2_;
15955 		ValaSourceLocation begin = {0};
15956 		ValaSourceLocation _tmp3_;
15957 		gchar* id = NULL;
15958 		gchar* _tmp4_;
15959 		const gchar* _tmp5_;
15960 		ValaGirParserArgumentType* arg_type = NULL;
15961 		const gchar* _tmp6_;
15962 		ValaGirParserArgumentType* _tmp7_;
15963 		ValaGirParserArgumentType* _tmp8_;
15964 		ValaTokenType _tmp16_;
15965 		ValaExpression* expr = NULL;
15966 		ValaExpression* _tmp28_;
15967 		ValaExpression* _tmp29_;
15968 		ValaGirParserArgumentType* _tmp30_;
15969 		ValaExpression* _tmp31_;
15970 		ValaSourceLocation _tmp32_;
15971 		ValaSourceReference* _tmp33_;
15972 		ValaSourceReference* _tmp34_;
15973 		ValaGirParserArgument* _tmp35_;
15974 		ValaGirParserArgument* _tmp36_;
15975 		_tmp2_ = self->priv->current;
15976 		if (_tmp2_ != VALA_TOKEN_TYPE_EOF) {
15977 			_tmp1_ = vala_gir_parser_metadata_parser_has_space (self);
15978 		} else {
15979 			_tmp1_ = FALSE;
15980 		}
15981 		if (_tmp1_) {
15982 			_tmp0_ = !vala_gir_parser_metadata_parser_has_newline (self);
15983 		} else {
15984 			_tmp0_ = FALSE;
15985 		}
15986 		if (!_tmp0_) {
15987 			break;
15988 		}
15989 		_tmp3_ = self->priv->begin;
15990 		begin = _tmp3_;
15991 		_tmp4_ = vala_gir_parser_metadata_parser_parse_identifier (self, FALSE);
15992 		id = _tmp4_;
15993 		_tmp5_ = id;
15994 		if (_tmp5_ == NULL) {
15995 			result = FALSE;
15996 			_g_free0 (id);
15997 			return result;
15998 		}
15999 		_tmp6_ = id;
16000 		_tmp7_ = vala_gir_parser_argument_type_from_string (_tmp6_);
16001 		arg_type = _tmp7_;
16002 		_tmp8_ = arg_type;
16003 		if (_tmp8_ == NULL) {
16004 			ValaSourceLocation _tmp9_;
16005 			ValaSourceLocation _tmp10_;
16006 			ValaSourceReference* _tmp11_;
16007 			ValaSourceReference* _tmp12_;
16008 			const gchar* _tmp13_;
16009 			gchar* _tmp14_;
16010 			gchar* _tmp15_;
16011 			_tmp9_ = begin;
16012 			_tmp10_ = self->priv->old_end;
16013 			_tmp11_ = vala_gir_parser_metadata_parser_get_src (self, &_tmp9_, &_tmp10_);
16014 			_tmp12_ = _tmp11_;
16015 			_tmp13_ = id;
16016 			_tmp14_ = g_strdup_printf ("unknown argument `%s'", _tmp13_);
16017 			_tmp15_ = _tmp14_;
16018 			vala_report_warning (_tmp12_, _tmp15_);
16019 			_g_free0 (_tmp15_);
16020 			_vala_source_reference_unref0 (_tmp12_);
16021 			_g_free0 (arg_type);
16022 			_g_free0 (id);
16023 			continue;
16024 		}
16025 		_tmp16_ = self->priv->current;
16026 		if (_tmp16_ != VALA_TOKEN_TYPE_ASSIGN) {
16027 			ValaGirParserArgumentType* _tmp17_;
16028 			ValaSourceLocation _tmp18_;
16029 			ValaSourceReference* _tmp19_;
16030 			ValaSourceReference* _tmp20_;
16031 			ValaBooleanLiteral* _tmp21_;
16032 			ValaBooleanLiteral* _tmp22_;
16033 			ValaSourceLocation _tmp23_;
16034 			ValaSourceReference* _tmp24_;
16035 			ValaSourceReference* _tmp25_;
16036 			ValaGirParserArgument* _tmp26_;
16037 			ValaGirParserArgument* _tmp27_;
16038 			_tmp17_ = arg_type;
16039 			_tmp18_ = begin;
16040 			_tmp19_ = vala_gir_parser_metadata_parser_get_src (self, &_tmp18_, NULL);
16041 			_tmp20_ = _tmp19_;
16042 			_tmp21_ = vala_boolean_literal_new (TRUE, _tmp20_);
16043 			_tmp22_ = _tmp21_;
16044 			_tmp23_ = begin;
16045 			_tmp24_ = vala_gir_parser_metadata_parser_get_src (self, &_tmp23_, NULL);
16046 			_tmp25_ = _tmp24_;
16047 			_tmp26_ = vala_gir_parser_argument_new ((ValaExpression*) _tmp22_, _tmp25_);
16048 			_tmp27_ = _tmp26_;
16049 			vala_gir_parser_metadata_add_argument (metadata, *_tmp17_, _tmp27_);
16050 			_vala_gir_parser_argument_unref0 (_tmp27_);
16051 			_vala_source_reference_unref0 (_tmp25_);
16052 			_vala_code_node_unref0 (_tmp22_);
16053 			_vala_source_reference_unref0 (_tmp20_);
16054 			_g_free0 (arg_type);
16055 			_g_free0 (id);
16056 			continue;
16057 		}
16058 		vala_gir_parser_metadata_parser_next (self);
16059 		_tmp28_ = vala_gir_parser_metadata_parser_parse_expression (self);
16060 		expr = _tmp28_;
16061 		_tmp29_ = expr;
16062 		if (_tmp29_ == NULL) {
16063 			result = FALSE;
16064 			_vala_code_node_unref0 (expr);
16065 			_g_free0 (arg_type);
16066 			_g_free0 (id);
16067 			return result;
16068 		}
16069 		_tmp30_ = arg_type;
16070 		_tmp31_ = expr;
16071 		_tmp32_ = begin;
16072 		_tmp33_ = vala_gir_parser_metadata_parser_get_src (self, &_tmp32_, NULL);
16073 		_tmp34_ = _tmp33_;
16074 		_tmp35_ = vala_gir_parser_argument_new (_tmp31_, _tmp34_);
16075 		_tmp36_ = _tmp35_;
16076 		vala_gir_parser_metadata_add_argument (metadata, *_tmp30_, _tmp36_);
16077 		_vala_gir_parser_argument_unref0 (_tmp36_);
16078 		_vala_source_reference_unref0 (_tmp34_);
16079 		_vala_code_node_unref0 (expr);
16080 		_g_free0 (arg_type);
16081 		_g_free0 (id);
16082 	}
16083 	result = TRUE;
16084 	return result;
16085 }
16086 
16087 static gboolean
vala_gir_parser_metadata_parser_parse_rule(ValaGirParserMetadataParser * self)16088 vala_gir_parser_metadata_parser_parse_rule (ValaGirParserMetadataParser* self)
16089 {
16090 	ValaSourceLocation old_end = {0};
16091 	ValaSourceLocation _tmp0_;
16092 	ValaGirParserMetadata* metadata = NULL;
16093 	ValaGirParserMetadata* _tmp1_;
16094 	ValaGirParserMetadata* _tmp2_;
16095 	gboolean _tmp3_ = FALSE;
16096 	ValaTokenType _tmp4_;
16097 	ValaGirParserMetadata* _tmp7_;
16098 	gboolean result = FALSE;
16099 	g_return_val_if_fail (self != NULL, FALSE);
16100 	_tmp0_ = self->priv->end;
16101 	old_end = _tmp0_;
16102 	_tmp1_ = vala_gir_parser_metadata_parser_parse_pattern (self);
16103 	metadata = _tmp1_;
16104 	_tmp2_ = metadata;
16105 	if (_tmp2_ == NULL) {
16106 		result = FALSE;
16107 		_vala_gir_parser_metadata_unref0 (metadata);
16108 		return result;
16109 	}
16110 	_tmp4_ = self->priv->current;
16111 	if (_tmp4_ == VALA_TOKEN_TYPE_EOF) {
16112 		_tmp3_ = TRUE;
16113 	} else {
16114 		ValaSourceLocation _tmp5_;
16115 		ValaSourceLocation _tmp6_;
16116 		_tmp5_ = old_end;
16117 		_tmp6_ = self->priv->end;
16118 		_tmp3_ = _tmp5_.line != _tmp6_.line;
16119 	}
16120 	if (_tmp3_) {
16121 		result = TRUE;
16122 		_vala_gir_parser_metadata_unref0 (metadata);
16123 		return result;
16124 	}
16125 	_tmp7_ = metadata;
16126 	result = vala_gir_parser_metadata_parser_parse_args (self, _tmp7_);
16127 	_vala_gir_parser_metadata_unref0 (metadata);
16128 	return result;
16129 }
16130 
16131 static void
vala_gir_parser_value_metadata_parser_init(GValue * value)16132 vala_gir_parser_value_metadata_parser_init (GValue* value)
16133 {
16134 	value->data[0].v_pointer = NULL;
16135 }
16136 
16137 static void
vala_gir_parser_value_metadata_parser_free_value(GValue * value)16138 vala_gir_parser_value_metadata_parser_free_value (GValue* value)
16139 {
16140 	if (value->data[0].v_pointer) {
16141 		vala_gir_parser_metadata_parser_unref (value->data[0].v_pointer);
16142 	}
16143 }
16144 
16145 static void
vala_gir_parser_value_metadata_parser_copy_value(const GValue * src_value,GValue * dest_value)16146 vala_gir_parser_value_metadata_parser_copy_value (const GValue* src_value,
16147                                                   GValue* dest_value)
16148 {
16149 	if (src_value->data[0].v_pointer) {
16150 		dest_value->data[0].v_pointer = vala_gir_parser_metadata_parser_ref (src_value->data[0].v_pointer);
16151 	} else {
16152 		dest_value->data[0].v_pointer = NULL;
16153 	}
16154 }
16155 
16156 static gpointer
vala_gir_parser_value_metadata_parser_peek_pointer(const GValue * value)16157 vala_gir_parser_value_metadata_parser_peek_pointer (const GValue* value)
16158 {
16159 	return value->data[0].v_pointer;
16160 }
16161 
16162 static gchar*
vala_gir_parser_value_metadata_parser_collect_value(GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)16163 vala_gir_parser_value_metadata_parser_collect_value (GValue* value,
16164                                                      guint n_collect_values,
16165                                                      GTypeCValue* collect_values,
16166                                                      guint collect_flags)
16167 {
16168 	if (collect_values[0].v_pointer) {
16169 		ValaGirParserMetadataParser * object;
16170 		object = collect_values[0].v_pointer;
16171 		if (object->parent_instance.g_class == NULL) {
16172 			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
16173 		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
16174 			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
16175 		}
16176 		value->data[0].v_pointer = vala_gir_parser_metadata_parser_ref (object);
16177 	} else {
16178 		value->data[0].v_pointer = NULL;
16179 	}
16180 	return NULL;
16181 }
16182 
16183 static gchar*
vala_gir_parser_value_metadata_parser_lcopy_value(const GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)16184 vala_gir_parser_value_metadata_parser_lcopy_value (const GValue* value,
16185                                                    guint n_collect_values,
16186                                                    GTypeCValue* collect_values,
16187                                                    guint collect_flags)
16188 {
16189 	ValaGirParserMetadataParser ** object_p;
16190 	object_p = collect_values[0].v_pointer;
16191 	if (!object_p) {
16192 		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
16193 	}
16194 	if (!value->data[0].v_pointer) {
16195 		*object_p = NULL;
16196 	} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
16197 		*object_p = value->data[0].v_pointer;
16198 	} else {
16199 		*object_p = vala_gir_parser_metadata_parser_ref (value->data[0].v_pointer);
16200 	}
16201 	return NULL;
16202 }
16203 
16204 static GParamSpec*
vala_gir_parser_param_spec_metadata_parser(const gchar * name,const gchar * nick,const gchar * blurb,GType object_type,GParamFlags flags)16205 vala_gir_parser_param_spec_metadata_parser (const gchar* name,
16206                                             const gchar* nick,
16207                                             const gchar* blurb,
16208                                             GType object_type,
16209                                             GParamFlags flags)
16210 {
16211 	ValaGirParserParamSpecMetadataParser* spec;
16212 	g_return_val_if_fail (g_type_is_a (object_type, VALA_GIR_PARSER_TYPE_METADATA_PARSER), NULL);
16213 	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
16214 	G_PARAM_SPEC (spec)->value_type = object_type;
16215 	return G_PARAM_SPEC (spec);
16216 }
16217 
16218 static gpointer
vala_gir_parser_value_get_metadata_parser(const GValue * value)16219 vala_gir_parser_value_get_metadata_parser (const GValue* value)
16220 {
16221 	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_GIR_PARSER_TYPE_METADATA_PARSER), NULL);
16222 	return value->data[0].v_pointer;
16223 }
16224 
16225 static void
vala_gir_parser_value_set_metadata_parser(GValue * value,gpointer v_object)16226 vala_gir_parser_value_set_metadata_parser (GValue* value,
16227                                            gpointer v_object)
16228 {
16229 	ValaGirParserMetadataParser * old;
16230 	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_GIR_PARSER_TYPE_METADATA_PARSER));
16231 	old = value->data[0].v_pointer;
16232 	if (v_object) {
16233 		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_GIR_PARSER_TYPE_METADATA_PARSER));
16234 		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
16235 		value->data[0].v_pointer = v_object;
16236 		vala_gir_parser_metadata_parser_ref (value->data[0].v_pointer);
16237 	} else {
16238 		value->data[0].v_pointer = NULL;
16239 	}
16240 	if (old) {
16241 		vala_gir_parser_metadata_parser_unref (old);
16242 	}
16243 }
16244 
16245 static void
vala_gir_parser_value_take_metadata_parser(GValue * value,gpointer v_object)16246 vala_gir_parser_value_take_metadata_parser (GValue* value,
16247                                             gpointer v_object)
16248 {
16249 	ValaGirParserMetadataParser * old;
16250 	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_GIR_PARSER_TYPE_METADATA_PARSER));
16251 	old = value->data[0].v_pointer;
16252 	if (v_object) {
16253 		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_GIR_PARSER_TYPE_METADATA_PARSER));
16254 		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
16255 		value->data[0].v_pointer = v_object;
16256 	} else {
16257 		value->data[0].v_pointer = NULL;
16258 	}
16259 	if (old) {
16260 		vala_gir_parser_metadata_parser_unref (old);
16261 	}
16262 }
16263 
16264 static void
vala_gir_parser_metadata_parser_class_init(ValaGirParserMetadataParserClass * klass,gpointer klass_data)16265 vala_gir_parser_metadata_parser_class_init (ValaGirParserMetadataParserClass * klass,
16266                                             gpointer klass_data)
16267 {
16268 	vala_gir_parser_metadata_parser_parent_class = g_type_class_peek_parent (klass);
16269 	((ValaGirParserMetadataParserClass *) klass)->finalize = vala_gir_parser_metadata_parser_finalize;
16270 	g_type_class_adjust_private_offset (klass, &ValaGirParserMetadataParser_private_offset);
16271 }
16272 
16273 static void
vala_gir_parser_metadata_parser_instance_init(ValaGirParserMetadataParser * self,gpointer klass)16274 vala_gir_parser_metadata_parser_instance_init (ValaGirParserMetadataParser * self,
16275                                                gpointer klass)
16276 {
16277 	ValaGirParserMetadata* _tmp0_;
16278 	self->priv = vala_gir_parser_metadata_parser_get_instance_private (self);
16279 	_tmp0_ = vala_gir_parser_metadata_new ("", NULL, NULL);
16280 	self->priv->tree = _tmp0_;
16281 	self->ref_count = 1;
16282 }
16283 
16284 static void
vala_gir_parser_metadata_parser_finalize(ValaGirParserMetadataParser * obj)16285 vala_gir_parser_metadata_parser_finalize (ValaGirParserMetadataParser * obj)
16286 {
16287 	ValaGirParserMetadataParser * self;
16288 	self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_GIR_PARSER_TYPE_METADATA_PARSER, ValaGirParserMetadataParser);
16289 	g_signal_handlers_destroy (self);
16290 	_vala_gir_parser_metadata_unref0 (self->priv->tree);
16291 	_vala_scanner_unref0 (self->priv->scanner);
16292 	_vala_gir_parser_metadata_unref0 (self->priv->parent_metadata);
16293 }
16294 
16295 static GType
vala_gir_parser_metadata_parser_get_type_once(void)16296 vala_gir_parser_metadata_parser_get_type_once (void)
16297 {
16298 	static const GTypeValueTable g_define_type_value_table = { vala_gir_parser_value_metadata_parser_init, vala_gir_parser_value_metadata_parser_free_value, vala_gir_parser_value_metadata_parser_copy_value, vala_gir_parser_value_metadata_parser_peek_pointer, "p", vala_gir_parser_value_metadata_parser_collect_value, "p", vala_gir_parser_value_metadata_parser_lcopy_value };
16299 	static const GTypeInfo g_define_type_info = { sizeof (ValaGirParserMetadataParserClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_gir_parser_metadata_parser_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaGirParserMetadataParser), 0, (GInstanceInitFunc) vala_gir_parser_metadata_parser_instance_init, &g_define_type_value_table };
16300 	static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
16301 	GType vala_gir_parser_metadata_parser_type_id;
16302 	vala_gir_parser_metadata_parser_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ValaGirParserMetadataParser", &g_define_type_info, &g_define_type_fundamental_info, 0);
16303 	ValaGirParserMetadataParser_private_offset = g_type_add_instance_private (vala_gir_parser_metadata_parser_type_id, sizeof (ValaGirParserMetadataParserPrivate));
16304 	return vala_gir_parser_metadata_parser_type_id;
16305 }
16306 
16307 static GType
vala_gir_parser_metadata_parser_get_type(void)16308 vala_gir_parser_metadata_parser_get_type (void)
16309 {
16310 	static volatile gsize vala_gir_parser_metadata_parser_type_id__volatile = 0;
16311 	if (g_once_init_enter (&vala_gir_parser_metadata_parser_type_id__volatile)) {
16312 		GType vala_gir_parser_metadata_parser_type_id;
16313 		vala_gir_parser_metadata_parser_type_id = vala_gir_parser_metadata_parser_get_type_once ();
16314 		g_once_init_leave (&vala_gir_parser_metadata_parser_type_id__volatile, vala_gir_parser_metadata_parser_type_id);
16315 	}
16316 	return vala_gir_parser_metadata_parser_type_id__volatile;
16317 }
16318 
16319 static gpointer
vala_gir_parser_metadata_parser_ref(gpointer instance)16320 vala_gir_parser_metadata_parser_ref (gpointer instance)
16321 {
16322 	ValaGirParserMetadataParser * self;
16323 	self = instance;
16324 	g_atomic_int_inc (&self->ref_count);
16325 	return instance;
16326 }
16327 
16328 static void
vala_gir_parser_metadata_parser_unref(gpointer instance)16329 vala_gir_parser_metadata_parser_unref (gpointer instance)
16330 {
16331 	ValaGirParserMetadataParser * self;
16332 	self = instance;
16333 	if (g_atomic_int_dec_and_test (&self->ref_count)) {
16334 		VALA_GIR_PARSER_METADATA_PARSER_GET_CLASS (self)->finalize (self);
16335 		g_type_free_instance ((GTypeInstance *) self);
16336 	}
16337 }
16338 
16339 static ValaGirParserNode*
vala_gir_parser_node_construct(GType object_type,const gchar * name)16340 vala_gir_parser_node_construct (GType object_type,
16341                                 const gchar* name)
16342 {
16343 	ValaGirParserNode* self = NULL;
16344 	gchar* _tmp0_;
16345 	self = (ValaGirParserNode*) g_type_create_instance (object_type);
16346 	_tmp0_ = g_strdup (name);
16347 	_g_free0 (self->name);
16348 	self->name = _tmp0_;
16349 	return self;
16350 }
16351 
16352 static ValaGirParserNode*
vala_gir_parser_node_new(const gchar * name)16353 vala_gir_parser_node_new (const gchar* name)
16354 {
16355 	return vala_gir_parser_node_construct (VALA_GIR_PARSER_TYPE_NODE, name);
16356 }
16357 
16358 static void
vala_gir_parser_node_add_member(ValaGirParserNode * self,ValaGirParserNode * node)16359 vala_gir_parser_node_add_member (ValaGirParserNode* self,
16360                                  ValaGirParserNode* node)
16361 {
16362 	ValaArrayList* nodes = NULL;
16363 	ValaHashMap* _tmp0_;
16364 	const gchar* _tmp1_;
16365 	gpointer _tmp2_;
16366 	ValaArrayList* _tmp3_;
16367 	ValaArrayList* _tmp9_;
16368 	ValaArrayList* _tmp10_;
16369 	g_return_if_fail (self != NULL);
16370 	g_return_if_fail (node != NULL);
16371 	_tmp0_ = self->scope;
16372 	_tmp1_ = node->name;
16373 	_tmp2_ = vala_map_get ((ValaMap*) _tmp0_, _tmp1_);
16374 	nodes = (ValaArrayList*) _tmp2_;
16375 	_tmp3_ = nodes;
16376 	if (_tmp3_ == NULL) {
16377 		GEqualFunc _tmp4_;
16378 		ValaArrayList* _tmp5_;
16379 		ValaHashMap* _tmp6_;
16380 		const gchar* _tmp7_;
16381 		ValaArrayList* _tmp8_;
16382 		_tmp4_ = g_direct_equal;
16383 		_tmp5_ = vala_array_list_new (VALA_GIR_PARSER_TYPE_NODE, (GBoxedCopyFunc) vala_gir_parser_node_ref, (GDestroyNotify) vala_gir_parser_node_unref, _tmp4_);
16384 		_vala_iterable_unref0 (nodes);
16385 		nodes = _tmp5_;
16386 		_tmp6_ = self->scope;
16387 		_tmp7_ = node->name;
16388 		_tmp8_ = nodes;
16389 		vala_map_set ((ValaMap*) _tmp6_, _tmp7_, _tmp8_);
16390 	}
16391 	_tmp9_ = nodes;
16392 	vala_collection_add ((ValaCollection*) _tmp9_, node);
16393 	_tmp10_ = self->members;
16394 	vala_collection_add ((ValaCollection*) _tmp10_, node);
16395 	node->parent = self;
16396 	_vala_iterable_unref0 (nodes);
16397 }
16398 
16399 static void
vala_gir_parser_node_remove_member(ValaGirParserNode * self,ValaGirParserNode * node)16400 vala_gir_parser_node_remove_member (ValaGirParserNode* self,
16401                                     ValaGirParserNode* node)
16402 {
16403 	ValaArrayList* nodes = NULL;
16404 	ValaHashMap* _tmp0_;
16405 	const gchar* _tmp1_;
16406 	gpointer _tmp2_;
16407 	ValaArrayList* _tmp3_;
16408 	ValaArrayList* _tmp4_;
16409 	gint _tmp5_;
16410 	gint _tmp6_;
16411 	ValaArrayList* _tmp9_;
16412 	g_return_if_fail (self != NULL);
16413 	g_return_if_fail (node != NULL);
16414 	_tmp0_ = self->scope;
16415 	_tmp1_ = node->name;
16416 	_tmp2_ = vala_map_get ((ValaMap*) _tmp0_, _tmp1_);
16417 	nodes = (ValaArrayList*) _tmp2_;
16418 	_tmp3_ = nodes;
16419 	vala_collection_remove ((ValaCollection*) _tmp3_, node);
16420 	_tmp4_ = nodes;
16421 	_tmp5_ = vala_collection_get_size ((ValaCollection*) _tmp4_);
16422 	_tmp6_ = _tmp5_;
16423 	if (_tmp6_ == 0) {
16424 		ValaHashMap* _tmp7_;
16425 		const gchar* _tmp8_;
16426 		_tmp7_ = self->scope;
16427 		_tmp8_ = node->name;
16428 		vala_map_remove ((ValaMap*) _tmp7_, _tmp8_);
16429 	}
16430 	_tmp9_ = self->members;
16431 	vala_collection_remove ((ValaCollection*) _tmp9_, node);
16432 	node->parent = NULL;
16433 	_vala_iterable_unref0 (nodes);
16434 }
16435 
16436 static ValaGirParserNode*
vala_gir_parser_node_lookup(ValaGirParserNode * self,const gchar * name,gboolean create_namespace,ValaSourceReference * source_reference)16437 vala_gir_parser_node_lookup (ValaGirParserNode* self,
16438                              const gchar* name,
16439                              gboolean create_namespace,
16440                              ValaSourceReference* source_reference)
16441 {
16442 	ValaArrayList* nodes = NULL;
16443 	ValaHashMap* _tmp0_;
16444 	gpointer _tmp1_;
16445 	ValaGirParserNode* node = NULL;
16446 	ValaArrayList* _tmp2_;
16447 	ValaGirParserNode* _tmp5_;
16448 	ValaGirParserNode* result = NULL;
16449 	g_return_val_if_fail (self != NULL, NULL);
16450 	g_return_val_if_fail (name != NULL, NULL);
16451 	_tmp0_ = self->scope;
16452 	_tmp1_ = vala_map_get ((ValaMap*) _tmp0_, name);
16453 	nodes = (ValaArrayList*) _tmp1_;
16454 	node = NULL;
16455 	_tmp2_ = nodes;
16456 	if (_tmp2_ != NULL) {
16457 		ValaArrayList* _tmp3_;
16458 		gpointer _tmp4_;
16459 		_tmp3_ = nodes;
16460 		_tmp4_ = vala_list_get ((ValaList*) _tmp3_, 0);
16461 		_vala_gir_parser_node_unref0 (node);
16462 		node = (ValaGirParserNode*) _tmp4_;
16463 	}
16464 	_tmp5_ = node;
16465 	if (_tmp5_ == NULL) {
16466 		ValaSymbol* sym = NULL;
16467 		ValaSymbol* _tmp6_;
16468 		gboolean _tmp11_ = FALSE;
16469 		ValaSymbol* _tmp12_;
16470 		sym = NULL;
16471 		_tmp6_ = self->symbol;
16472 		if (_tmp6_ != NULL) {
16473 			ValaSymbol* _tmp7_;
16474 			ValaScope* _tmp8_;
16475 			ValaScope* _tmp9_;
16476 			ValaSymbol* _tmp10_;
16477 			_tmp7_ = self->symbol;
16478 			_tmp8_ = vala_symbol_get_scope (_tmp7_);
16479 			_tmp9_ = _tmp8_;
16480 			_tmp10_ = vala_scope_lookup (_tmp9_, name);
16481 			_vala_code_node_unref0 (sym);
16482 			sym = _tmp10_;
16483 		}
16484 		_tmp12_ = sym;
16485 		if (_tmp12_ != NULL) {
16486 			_tmp11_ = TRUE;
16487 		} else {
16488 			_tmp11_ = create_namespace;
16489 		}
16490 		if (_tmp11_) {
16491 			ValaGirParserNode* _tmp13_;
16492 			ValaGirParserNode* _tmp14_;
16493 			ValaSymbol* _tmp15_;
16494 			ValaSymbol* _tmp16_;
16495 			ValaGirParserNode* _tmp17_;
16496 			ValaGirParserNode* _tmp18_;
16497 			ValaSymbol* _tmp19_;
16498 			ValaGirParserNode* _tmp20_;
16499 			ValaSourceReference* _tmp21_;
16500 			ValaGirParserNode* _tmp22_;
16501 			ValaSymbol* _tmp23_;
16502 			_tmp13_ = vala_gir_parser_node_new (name);
16503 			_vala_gir_parser_node_unref0 (node);
16504 			node = _tmp13_;
16505 			_tmp14_ = node;
16506 			_tmp15_ = sym;
16507 			_tmp16_ = _vala_code_node_ref0 (_tmp15_);
16508 			_vala_code_node_unref0 (_tmp14_->symbol);
16509 			_tmp14_->symbol = _tmp16_;
16510 			_tmp17_ = node;
16511 			_tmp18_ = node;
16512 			_tmp19_ = _tmp18_->symbol;
16513 			_tmp17_->new_symbol = _tmp19_ == NULL;
16514 			_tmp20_ = node;
16515 			_tmp21_ = _vala_source_reference_ref0 (source_reference);
16516 			_vala_source_reference_unref0 (_tmp20_->source_reference);
16517 			_tmp20_->source_reference = _tmp21_;
16518 			_tmp22_ = node;
16519 			vala_gir_parser_node_add_member (self, _tmp22_);
16520 			_tmp23_ = sym;
16521 			if (_tmp23_ == NULL) {
16522 				ValaArrayList* _tmp24_;
16523 				ValaGirParserNode* _tmp25_;
16524 				_tmp24_ = vala_gir_parser_node_new_namespaces;
16525 				_tmp25_ = node;
16526 				vala_collection_add ((ValaCollection*) _tmp24_, _tmp25_);
16527 			}
16528 		}
16529 		_vala_code_node_unref0 (sym);
16530 	}
16531 	result = node;
16532 	_vala_iterable_unref0 (nodes);
16533 	return result;
16534 }
16535 
16536 static ValaArrayList*
vala_gir_parser_node_lookup_all(ValaGirParserNode * self,const gchar * name)16537 vala_gir_parser_node_lookup_all (ValaGirParserNode* self,
16538                                  const gchar* name)
16539 {
16540 	ValaHashMap* _tmp0_;
16541 	gpointer _tmp1_;
16542 	ValaArrayList* result = NULL;
16543 	g_return_val_if_fail (self != NULL, NULL);
16544 	g_return_val_if_fail (name != NULL, NULL);
16545 	_tmp0_ = self->scope;
16546 	_tmp1_ = vala_map_get ((ValaMap*) _tmp0_, name);
16547 	result = (ValaArrayList*) _tmp1_;
16548 	return result;
16549 }
16550 
16551 static ValaUnresolvedSymbol*
vala_gir_parser_node_get_unresolved_symbol(ValaGirParserNode * self)16552 vala_gir_parser_node_get_unresolved_symbol (ValaGirParserNode* self)
16553 {
16554 	ValaGirParserNode* _tmp0_;
16555 	const gchar* _tmp1_;
16556 	ValaUnresolvedSymbol* result = NULL;
16557 	g_return_val_if_fail (self != NULL, NULL);
16558 	_tmp0_ = self->parent;
16559 	_tmp1_ = _tmp0_->name;
16560 	if (_tmp1_ == NULL) {
16561 		const gchar* _tmp2_;
16562 		ValaUnresolvedSymbol* _tmp3_;
16563 		_tmp2_ = self->name;
16564 		_tmp3_ = vala_unresolved_symbol_new (NULL, _tmp2_, NULL);
16565 		result = _tmp3_;
16566 		return result;
16567 	} else {
16568 		ValaGirParserNode* _tmp4_;
16569 		ValaUnresolvedSymbol* _tmp5_;
16570 		ValaUnresolvedSymbol* _tmp6_;
16571 		const gchar* _tmp7_;
16572 		ValaUnresolvedSymbol* _tmp8_;
16573 		ValaUnresolvedSymbol* _tmp9_;
16574 		_tmp4_ = self->parent;
16575 		_tmp5_ = vala_gir_parser_node_get_unresolved_symbol (_tmp4_);
16576 		_tmp6_ = _tmp5_;
16577 		_tmp7_ = self->name;
16578 		_tmp8_ = vala_unresolved_symbol_new (_tmp6_, _tmp7_, NULL);
16579 		_tmp9_ = _tmp8_;
16580 		_vala_code_node_unref0 (_tmp6_);
16581 		result = _tmp9_;
16582 		return result;
16583 	}
16584 }
16585 
16586 static gchar*
vala_gir_parser_node_get_full_name(ValaGirParserNode * self)16587 vala_gir_parser_node_get_full_name (ValaGirParserNode* self)
16588 {
16589 	ValaGirParserNode* _tmp0_;
16590 	const gchar* _tmp3_;
16591 	ValaGirParserNode* _tmp6_;
16592 	gchar* _tmp7_;
16593 	gchar* _tmp8_;
16594 	gboolean _tmp9_;
16595 	ValaGirParserNode* _tmp12_;
16596 	gchar* _tmp13_;
16597 	gchar* _tmp14_;
16598 	const gchar* _tmp15_;
16599 	gchar* _tmp16_;
16600 	gchar* _tmp17_;
16601 	gchar* result = NULL;
16602 	g_return_val_if_fail (self != NULL, NULL);
16603 	_tmp0_ = self->parent;
16604 	if (_tmp0_ == NULL) {
16605 		const gchar* _tmp1_;
16606 		gchar* _tmp2_;
16607 		_tmp1_ = self->name;
16608 		_tmp2_ = g_strdup (_tmp1_);
16609 		result = _tmp2_;
16610 		return result;
16611 	}
16612 	_tmp3_ = self->name;
16613 	if (_tmp3_ == NULL) {
16614 		ValaGirParserNode* _tmp4_;
16615 		gchar* _tmp5_;
16616 		_tmp4_ = self->parent;
16617 		_tmp5_ = vala_gir_parser_node_get_full_name (_tmp4_);
16618 		result = _tmp5_;
16619 		return result;
16620 	}
16621 	_tmp6_ = self->parent;
16622 	_tmp7_ = vala_gir_parser_node_get_full_name (_tmp6_);
16623 	_tmp8_ = _tmp7_;
16624 	_tmp9_ = _tmp8_ == NULL;
16625 	_g_free0 (_tmp8_);
16626 	if (_tmp9_) {
16627 		const gchar* _tmp10_;
16628 		gchar* _tmp11_;
16629 		_tmp10_ = self->name;
16630 		_tmp11_ = g_strdup (_tmp10_);
16631 		result = _tmp11_;
16632 		return result;
16633 	}
16634 	_tmp12_ = self->parent;
16635 	_tmp13_ = vala_gir_parser_node_get_full_name (_tmp12_);
16636 	_tmp14_ = _tmp13_;
16637 	_tmp15_ = self->name;
16638 	_tmp16_ = g_strdup_printf ("%s.%s", _tmp14_, _tmp15_);
16639 	_tmp17_ = _tmp16_;
16640 	_g_free0 (_tmp14_);
16641 	result = _tmp17_;
16642 	return result;
16643 }
16644 
16645 static gchar*
vala_gir_parser_node_get_default_gir_name(ValaGirParserNode * self)16646 vala_gir_parser_node_get_default_gir_name (ValaGirParserNode* self)
16647 {
16648 	GString* default_name = NULL;
16649 	GString* _tmp0_;
16650 	GString* _tmp15_;
16651 	const gchar* _tmp16_;
16652 	gchar* _tmp17_;
16653 	gchar* result = NULL;
16654 	g_return_val_if_fail (self != NULL, NULL);
16655 	_tmp0_ = g_string_new ("");
16656 	default_name = _tmp0_;
16657 	{
16658 		ValaGirParserNode* node = NULL;
16659 		node = self;
16660 		{
16661 			gboolean _tmp1_ = FALSE;
16662 			_tmp1_ = TRUE;
16663 			while (TRUE) {
16664 				ValaGirParserNode* _tmp4_;
16665 				ValaGirParserNode* _tmp5_;
16666 				ValaSymbol* _tmp6_;
16667 				GString* _tmp12_;
16668 				ValaGirParserNode* _tmp13_;
16669 				const gchar* _tmp14_;
16670 				if (!_tmp1_) {
16671 					ValaGirParserNode* _tmp2_;
16672 					ValaGirParserNode* _tmp3_;
16673 					_tmp2_ = node;
16674 					_tmp3_ = _tmp2_->parent;
16675 					node = _tmp3_;
16676 				}
16677 				_tmp1_ = FALSE;
16678 				_tmp4_ = node;
16679 				if (!(_tmp4_ != NULL)) {
16680 					break;
16681 				}
16682 				_tmp5_ = node;
16683 				_tmp6_ = _tmp5_->symbol;
16684 				if (VALA_IS_NAMESPACE (_tmp6_)) {
16685 					ValaGirParserNode* _tmp7_;
16686 					ValaSymbol* _tmp8_;
16687 					gchar* _tmp9_;
16688 					gchar* _tmp10_;
16689 					gboolean _tmp11_;
16690 					_tmp7_ = node;
16691 					_tmp8_ = _tmp7_->symbol;
16692 					_tmp9_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp8_, "CCode", "gir_namespace", NULL);
16693 					_tmp10_ = _tmp9_;
16694 					_tmp11_ = _tmp10_ != NULL;
16695 					_g_free0 (_tmp10_);
16696 					if (_tmp11_) {
16697 						break;
16698 					}
16699 				}
16700 				_tmp12_ = default_name;
16701 				_tmp13_ = node;
16702 				_tmp14_ = _tmp13_->name;
16703 				g_string_prepend (_tmp12_, _tmp14_);
16704 			}
16705 		}
16706 	}
16707 	_tmp15_ = default_name;
16708 	_tmp16_ = _tmp15_->str;
16709 	_tmp17_ = g_strdup (_tmp16_);
16710 	result = _tmp17_;
16711 	_g_string_free0 (default_name);
16712 	return result;
16713 }
16714 
16715 static gchar*
vala_gir_parser_node_get_gir_name(ValaGirParserNode * self)16716 vala_gir_parser_node_get_gir_name (ValaGirParserNode* self)
16717 {
16718 	gchar* gir_name = NULL;
16719 	ValaMap* _tmp0_;
16720 	gpointer _tmp1_;
16721 	const gchar* _tmp2_;
16722 	gchar* result = NULL;
16723 	g_return_val_if_fail (self != NULL, NULL);
16724 	_tmp0_ = self->girdata;
16725 	_tmp1_ = vala_map_get (_tmp0_, "name");
16726 	gir_name = (gchar*) _tmp1_;
16727 	_tmp2_ = gir_name;
16728 	if (_tmp2_ == NULL) {
16729 		ValaMap* _tmp3_;
16730 		gpointer _tmp4_;
16731 		_tmp3_ = self->girdata;
16732 		_tmp4_ = vala_map_get (_tmp3_, "glib:name");
16733 		_g_free0 (gir_name);
16734 		gir_name = (gchar*) _tmp4_;
16735 	}
16736 	result = gir_name;
16737 	return result;
16738 }
16739 
16740 static gchar*
vala_gir_parser_node_get_lower_case_cprefix(ValaGirParserNode * self)16741 vala_gir_parser_node_get_lower_case_cprefix (ValaGirParserNode* self)
16742 {
16743 	const gchar* _tmp0_;
16744 	gchar* prefix = NULL;
16745 	ValaSymbol* _tmp2_;
16746 	gchar* _tmp3_;
16747 	gboolean _tmp4_ = FALSE;
16748 	const gchar* _tmp5_;
16749 	gboolean _tmp17_ = FALSE;
16750 	gboolean _tmp18_ = FALSE;
16751 	const gchar* _tmp19_;
16752 	const gchar* _tmp46_;
16753 	gchar* result = NULL;
16754 	g_return_val_if_fail (self != NULL, NULL);
16755 	_tmp0_ = self->name;
16756 	if (_tmp0_ == NULL) {
16757 		gchar* _tmp1_;
16758 		_tmp1_ = g_strdup ("");
16759 		result = _tmp1_;
16760 		return result;
16761 	}
16762 	_tmp2_ = self->symbol;
16763 	_tmp3_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp2_, "CCode", "lower_case_cprefix", NULL);
16764 	prefix = _tmp3_;
16765 	_tmp5_ = prefix;
16766 	if (_tmp5_ == NULL) {
16767 		gboolean _tmp6_ = FALSE;
16768 		ValaSymbol* _tmp7_;
16769 		_tmp7_ = self->symbol;
16770 		if (VALA_IS_OBJECT_TYPE_SYMBOL (_tmp7_)) {
16771 			_tmp6_ = TRUE;
16772 		} else {
16773 			ValaSymbol* _tmp8_;
16774 			_tmp8_ = self->symbol;
16775 			_tmp6_ = VALA_IS_STRUCT (_tmp8_);
16776 		}
16777 		_tmp4_ = _tmp6_;
16778 	} else {
16779 		_tmp4_ = FALSE;
16780 	}
16781 	if (_tmp4_) {
16782 		ValaGirParserMetadata* _tmp9_;
16783 		_tmp9_ = self->metadata;
16784 		if (vala_gir_parser_metadata_has_argument (_tmp9_, VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CPREFIX)) {
16785 			ValaGirParserMetadata* _tmp10_;
16786 			gchar* _tmp11_;
16787 			_tmp10_ = self->metadata;
16788 			_tmp11_ = vala_gir_parser_metadata_get_string (_tmp10_, VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CPREFIX);
16789 			_g_free0 (prefix);
16790 			prefix = _tmp11_;
16791 		} else {
16792 			ValaGirParserMetadata* _tmp12_;
16793 			_tmp12_ = self->metadata;
16794 			if (vala_gir_parser_metadata_has_argument (_tmp12_, VALA_GIR_PARSER_ARGUMENT_TYPE_CPREFIX)) {
16795 				ValaGirParserMetadata* _tmp13_;
16796 				gchar* _tmp14_;
16797 				_tmp13_ = self->metadata;
16798 				_tmp14_ = vala_gir_parser_metadata_get_string (_tmp13_, VALA_GIR_PARSER_ARGUMENT_TYPE_CPREFIX);
16799 				_g_free0 (prefix);
16800 				prefix = _tmp14_;
16801 			} else {
16802 				ValaSymbol* _tmp15_;
16803 				gchar* _tmp16_;
16804 				_tmp15_ = self->symbol;
16805 				_tmp16_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp15_, "CCode", "cprefix", NULL);
16806 				_g_free0 (prefix);
16807 				prefix = _tmp16_;
16808 			}
16809 		}
16810 	}
16811 	_tmp19_ = prefix;
16812 	if (_tmp19_ == NULL) {
16813 		ValaMap* _tmp20_;
16814 		_tmp20_ = self->girdata;
16815 		_tmp18_ = _tmp20_ != NULL;
16816 	} else {
16817 		_tmp18_ = FALSE;
16818 	}
16819 	if (_tmp18_) {
16820 		gboolean _tmp21_ = FALSE;
16821 		ValaMap* _tmp22_;
16822 		_tmp22_ = self->girdata;
16823 		if (vala_map_contains (_tmp22_, "c:symbol-prefix")) {
16824 			_tmp21_ = TRUE;
16825 		} else {
16826 			ValaMap* _tmp23_;
16827 			_tmp23_ = self->girdata;
16828 			_tmp21_ = vala_map_contains (_tmp23_, "c:symbol-prefixes");
16829 		}
16830 		_tmp17_ = _tmp21_;
16831 	} else {
16832 		_tmp17_ = FALSE;
16833 	}
16834 	if (_tmp17_) {
16835 		ValaGirParserNode* cur = NULL;
16836 		cur = self;
16837 		{
16838 			gboolean _tmp24_ = FALSE;
16839 			_tmp24_ = TRUE;
16840 			while (TRUE) {
16841 				ValaGirParserNode* _tmp26_;
16842 				ValaMap* _tmp27_;
16843 				ValaGirParserNode* _tmp44_;
16844 				ValaGirParserNode* _tmp45_;
16845 				if (!_tmp24_) {
16846 					ValaGirParserNode* _tmp25_;
16847 					_tmp25_ = cur;
16848 					if (!(_tmp25_ != NULL)) {
16849 						break;
16850 					}
16851 				}
16852 				_tmp24_ = FALSE;
16853 				_tmp26_ = cur;
16854 				_tmp27_ = _tmp26_->girdata;
16855 				if (_tmp27_ != NULL) {
16856 					gchar* p = NULL;
16857 					ValaGirParserNode* _tmp28_;
16858 					ValaMap* _tmp29_;
16859 					gpointer _tmp30_;
16860 					const gchar* _tmp31_;
16861 					const gchar* _tmp39_;
16862 					_tmp28_ = cur;
16863 					_tmp29_ = _tmp28_->girdata;
16864 					_tmp30_ = vala_map_get (_tmp29_, "c:symbol-prefix");
16865 					p = (gchar*) _tmp30_;
16866 					_tmp31_ = p;
16867 					if (_tmp31_ == NULL) {
16868 						ValaGirParserNode* _tmp32_;
16869 						ValaMap* _tmp33_;
16870 						gpointer _tmp34_;
16871 						const gchar* _tmp35_;
16872 						_tmp32_ = cur;
16873 						_tmp33_ = _tmp32_->girdata;
16874 						_tmp34_ = vala_map_get (_tmp33_, "c:symbol-prefixes");
16875 						_g_free0 (p);
16876 						p = (gchar*) _tmp34_;
16877 						_tmp35_ = p;
16878 						if (_tmp35_ != NULL) {
16879 							gint idx = 0;
16880 							const gchar* _tmp36_;
16881 							_tmp36_ = p;
16882 							idx = string_index_of (_tmp36_, ",", 0);
16883 							if (idx >= 0) {
16884 								const gchar* _tmp37_;
16885 								gchar* _tmp38_;
16886 								_tmp37_ = p;
16887 								_tmp38_ = string_substring (_tmp37_, (glong) 0, (glong) idx);
16888 								_g_free0 (p);
16889 								p = _tmp38_;
16890 							}
16891 						}
16892 					}
16893 					_tmp39_ = p;
16894 					if (_tmp39_ != NULL) {
16895 						const gchar* _tmp40_ = NULL;
16896 						const gchar* _tmp41_;
16897 						const gchar* _tmp42_;
16898 						gchar* _tmp43_;
16899 						_tmp41_ = prefix;
16900 						_tmp40_ = _tmp41_;
16901 						if (_tmp40_ == NULL) {
16902 							_tmp40_ = "";
16903 						}
16904 						_tmp42_ = p;
16905 						_tmp43_ = g_strdup_printf ("%s_%s", _tmp42_, _tmp40_);
16906 						_g_free0 (prefix);
16907 						prefix = _tmp43_;
16908 					}
16909 					_g_free0 (p);
16910 				}
16911 				_tmp44_ = cur;
16912 				_tmp45_ = _tmp44_->parent;
16913 				cur = _tmp45_;
16914 			}
16915 		}
16916 	}
16917 	_tmp46_ = prefix;
16918 	if (_tmp46_ == NULL) {
16919 		gchar* _tmp47_;
16920 		_tmp47_ = vala_gir_parser_node_get_default_lower_case_cprefix (self);
16921 		_g_free0 (prefix);
16922 		prefix = _tmp47_;
16923 	}
16924 	result = prefix;
16925 	return result;
16926 }
16927 
16928 static gchar*
vala_gir_parser_node_get_default_lower_case_cprefix(ValaGirParserNode * self)16929 vala_gir_parser_node_get_default_lower_case_cprefix (ValaGirParserNode* self)
16930 {
16931 	ValaGirParserNode* _tmp0_;
16932 	gchar* _tmp1_;
16933 	gchar* _tmp2_;
16934 	gchar* _tmp3_;
16935 	gchar* _tmp4_;
16936 	gchar* _tmp5_;
16937 	gchar* _tmp6_;
16938 	gchar* result = NULL;
16939 	g_return_val_if_fail (self != NULL, NULL);
16940 	_tmp0_ = self->parent;
16941 	_tmp1_ = vala_gir_parser_node_get_lower_case_cprefix (_tmp0_);
16942 	_tmp2_ = _tmp1_;
16943 	_tmp3_ = vala_gir_parser_node_get_lower_case_csuffix (self);
16944 	_tmp4_ = _tmp3_;
16945 	_tmp5_ = g_strdup_printf ("%s%s_", _tmp2_, _tmp4_);
16946 	_tmp6_ = _tmp5_;
16947 	_g_free0 (_tmp4_);
16948 	_g_free0 (_tmp2_);
16949 	result = _tmp6_;
16950 	return result;
16951 }
16952 
16953 static gchar*
vala_gir_parser_node_get_lower_case_csuffix(ValaGirParserNode * self)16954 vala_gir_parser_node_get_lower_case_csuffix (ValaGirParserNode* self)
16955 {
16956 	gchar* suffix = NULL;
16957 	ValaSymbol* _tmp0_;
16958 	gchar* _tmp1_;
16959 	ValaGirParserMetadata* _tmp2_;
16960 	gboolean _tmp5_ = FALSE;
16961 	gboolean _tmp6_ = FALSE;
16962 	gboolean _tmp7_ = FALSE;
16963 	const gchar* _tmp8_;
16964 	const gchar* _tmp16_;
16965 	gchar* result = NULL;
16966 	g_return_val_if_fail (self != NULL, NULL);
16967 	_tmp0_ = self->symbol;
16968 	_tmp1_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp0_, "CCode", "lower_case_csuffix", NULL);
16969 	suffix = _tmp1_;
16970 	_tmp2_ = self->metadata;
16971 	if (vala_gir_parser_metadata_has_argument (_tmp2_, VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CSUFFIX)) {
16972 		ValaGirParserMetadata* _tmp3_;
16973 		gchar* _tmp4_;
16974 		_tmp3_ = self->metadata;
16975 		_tmp4_ = vala_gir_parser_metadata_get_string (_tmp3_, VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CSUFFIX);
16976 		_g_free0 (suffix);
16977 		suffix = _tmp4_;
16978 	}
16979 	_tmp8_ = suffix;
16980 	if (_tmp8_ == NULL) {
16981 		ValaMap* _tmp9_;
16982 		_tmp9_ = self->girdata;
16983 		_tmp7_ = _tmp9_ != NULL;
16984 	} else {
16985 		_tmp7_ = FALSE;
16986 	}
16987 	if (_tmp7_) {
16988 		ValaMap* _tmp10_;
16989 		gpointer _tmp11_;
16990 		gchar* _tmp12_;
16991 		_tmp10_ = self->girdata;
16992 		_tmp11_ = vala_map_get (_tmp10_, "c:symbol-prefix");
16993 		_tmp12_ = (gchar*) _tmp11_;
16994 		_tmp6_ = _tmp12_ != NULL;
16995 		_g_free0 (_tmp12_);
16996 	} else {
16997 		_tmp6_ = FALSE;
16998 	}
16999 	if (_tmp6_) {
17000 		ValaGirParserMetadata* _tmp13_;
17001 		_tmp13_ = self->metadata;
17002 		_tmp5_ = !vala_gir_parser_metadata_has_argument (_tmp13_, VALA_GIR_PARSER_ARGUMENT_TYPE_NAME);
17003 	} else {
17004 		_tmp5_ = FALSE;
17005 	}
17006 	if (_tmp5_) {
17007 		ValaMap* _tmp14_;
17008 		gpointer _tmp15_;
17009 		_tmp14_ = self->girdata;
17010 		_tmp15_ = vala_map_get (_tmp14_, "c:symbol-prefix");
17011 		_g_free0 (suffix);
17012 		suffix = (gchar*) _tmp15_;
17013 	}
17014 	_tmp16_ = suffix;
17015 	if (_tmp16_ == NULL) {
17016 		gchar* _tmp17_;
17017 		_tmp17_ = vala_gir_parser_node_get_default_lower_case_csuffix (self);
17018 		_g_free0 (suffix);
17019 		suffix = _tmp17_;
17020 	}
17021 	result = suffix;
17022 	return result;
17023 }
17024 
17025 static gchar*
vala_gir_parser_node_get_default_lower_case_csuffix(ValaGirParserNode * self)17026 vala_gir_parser_node_get_default_lower_case_csuffix (ValaGirParserNode* self)
17027 {
17028 	gchar* csuffix = NULL;
17029 	const gchar* _tmp0_;
17030 	gchar* _tmp1_;
17031 	const gchar* _tmp2_;
17032 	const gchar* _tmp16_;
17033 	gchar* result = NULL;
17034 	g_return_val_if_fail (self != NULL, NULL);
17035 	_tmp0_ = self->name;
17036 	_tmp1_ = vala_symbol_camel_case_to_lower_case (_tmp0_);
17037 	csuffix = _tmp1_;
17038 	_tmp2_ = csuffix;
17039 	if (g_str_has_prefix (_tmp2_, "type_")) {
17040 		const gchar* _tmp3_;
17041 		gint _tmp4_;
17042 		gint _tmp5_;
17043 		gchar* _tmp6_;
17044 		gchar* _tmp7_;
17045 		gchar* _tmp8_;
17046 		_tmp3_ = csuffix;
17047 		_tmp4_ = strlen ("type_");
17048 		_tmp5_ = _tmp4_;
17049 		_tmp6_ = string_substring (_tmp3_, (glong) _tmp5_, (glong) -1);
17050 		_tmp7_ = _tmp6_;
17051 		_tmp8_ = g_strconcat ("type", _tmp7_, NULL);
17052 		_g_free0 (csuffix);
17053 		csuffix = _tmp8_;
17054 		_g_free0 (_tmp7_);
17055 	} else {
17056 		const gchar* _tmp9_;
17057 		_tmp9_ = csuffix;
17058 		if (g_str_has_prefix (_tmp9_, "is_")) {
17059 			const gchar* _tmp10_;
17060 			gint _tmp11_;
17061 			gint _tmp12_;
17062 			gchar* _tmp13_;
17063 			gchar* _tmp14_;
17064 			gchar* _tmp15_;
17065 			_tmp10_ = csuffix;
17066 			_tmp11_ = strlen ("is_");
17067 			_tmp12_ = _tmp11_;
17068 			_tmp13_ = string_substring (_tmp10_, (glong) _tmp12_, (glong) -1);
17069 			_tmp14_ = _tmp13_;
17070 			_tmp15_ = g_strconcat ("is", _tmp14_, NULL);
17071 			_g_free0 (csuffix);
17072 			csuffix = _tmp15_;
17073 			_g_free0 (_tmp14_);
17074 		}
17075 	}
17076 	_tmp16_ = csuffix;
17077 	if (g_str_has_suffix (_tmp16_, "_class")) {
17078 		const gchar* _tmp17_;
17079 		const gchar* _tmp18_;
17080 		gint _tmp19_;
17081 		gint _tmp20_;
17082 		gint _tmp21_;
17083 		gint _tmp22_;
17084 		gchar* _tmp23_;
17085 		gchar* _tmp24_;
17086 		gchar* _tmp25_;
17087 		_tmp17_ = csuffix;
17088 		_tmp18_ = csuffix;
17089 		_tmp19_ = strlen (_tmp18_);
17090 		_tmp20_ = _tmp19_;
17091 		_tmp21_ = strlen ("_class");
17092 		_tmp22_ = _tmp21_;
17093 		_tmp23_ = string_substring (_tmp17_, (glong) 0, (glong) (_tmp20_ - _tmp22_));
17094 		_tmp24_ = _tmp23_;
17095 		_tmp25_ = g_strconcat (_tmp24_, "class", NULL);
17096 		_g_free0 (csuffix);
17097 		csuffix = _tmp25_;
17098 		_g_free0 (_tmp24_);
17099 	}
17100 	result = csuffix;
17101 	return result;
17102 }
17103 
17104 static gchar*
vala_gir_parser_node_get_cprefix(ValaGirParserNode * self)17105 vala_gir_parser_node_get_cprefix (ValaGirParserNode* self)
17106 {
17107 	const gchar* _tmp0_;
17108 	gchar* prefix = NULL;
17109 	ValaGirParserMetadata* _tmp2_;
17110 	gboolean _tmp7_ = FALSE;
17111 	gboolean _tmp8_ = FALSE;
17112 	const gchar* _tmp9_;
17113 	const gchar* _tmp19_;
17114 	gchar* result = NULL;
17115 	g_return_val_if_fail (self != NULL, NULL);
17116 	_tmp0_ = self->name;
17117 	if (_tmp0_ == NULL) {
17118 		gchar* _tmp1_;
17119 		_tmp1_ = g_strdup ("");
17120 		result = _tmp1_;
17121 		return result;
17122 	}
17123 	_tmp2_ = self->metadata;
17124 	if (vala_gir_parser_metadata_has_argument (_tmp2_, VALA_GIR_PARSER_ARGUMENT_TYPE_CPREFIX)) {
17125 		ValaGirParserMetadata* _tmp3_;
17126 		gchar* _tmp4_;
17127 		_tmp3_ = self->metadata;
17128 		_tmp4_ = vala_gir_parser_metadata_get_string (_tmp3_, VALA_GIR_PARSER_ARGUMENT_TYPE_CPREFIX);
17129 		_g_free0 (prefix);
17130 		prefix = _tmp4_;
17131 	} else {
17132 		ValaSymbol* _tmp5_;
17133 		gchar* _tmp6_;
17134 		_tmp5_ = self->symbol;
17135 		_tmp6_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp5_, "CCode", "cprefix", NULL);
17136 		_g_free0 (prefix);
17137 		prefix = _tmp6_;
17138 	}
17139 	_tmp9_ = prefix;
17140 	if (_tmp9_ == NULL) {
17141 		ValaMap* _tmp10_;
17142 		_tmp10_ = self->girdata;
17143 		_tmp8_ = _tmp10_ != NULL;
17144 	} else {
17145 		_tmp8_ = FALSE;
17146 	}
17147 	if (_tmp8_) {
17148 		ValaMap* _tmp11_;
17149 		gpointer _tmp12_;
17150 		gchar* _tmp13_;
17151 		_tmp11_ = self->girdata;
17152 		_tmp12_ = vala_map_get (_tmp11_, "c:identifier-prefixes");
17153 		_tmp13_ = (gchar*) _tmp12_;
17154 		_tmp7_ = _tmp13_ != NULL;
17155 		_g_free0 (_tmp13_);
17156 	} else {
17157 		_tmp7_ = FALSE;
17158 	}
17159 	if (_tmp7_) {
17160 		ValaMap* _tmp14_;
17161 		gpointer _tmp15_;
17162 		gint idx = 0;
17163 		const gchar* _tmp16_;
17164 		_tmp14_ = self->girdata;
17165 		_tmp15_ = vala_map_get (_tmp14_, "c:identifier-prefixes");
17166 		_g_free0 (prefix);
17167 		prefix = (gchar*) _tmp15_;
17168 		_tmp16_ = prefix;
17169 		idx = string_index_of (_tmp16_, ",", 0);
17170 		if (idx != -1) {
17171 			const gchar* _tmp17_;
17172 			gchar* _tmp18_;
17173 			_tmp17_ = prefix;
17174 			_tmp18_ = string_substring (_tmp17_, (glong) 0, (glong) idx);
17175 			_g_free0 (prefix);
17176 			prefix = _tmp18_;
17177 		}
17178 	}
17179 	_tmp19_ = prefix;
17180 	if (_tmp19_ == NULL) {
17181 		gboolean _tmp20_ = FALSE;
17182 		ValaSymbol* _tmp21_;
17183 		_tmp21_ = self->symbol;
17184 		if (VALA_IS_ENUM (_tmp21_)) {
17185 			_tmp20_ = TRUE;
17186 		} else {
17187 			ValaSymbol* _tmp22_;
17188 			_tmp22_ = self->symbol;
17189 			_tmp20_ = VALA_IS_ERROR_DOMAIN (_tmp22_);
17190 		}
17191 		if (_tmp20_) {
17192 			ValaGirParserNode* _tmp23_;
17193 			gchar* _tmp24_;
17194 			gchar* _tmp25_;
17195 			gchar* _tmp26_;
17196 			gchar* _tmp27_;
17197 			const gchar* _tmp28_;
17198 			gchar* _tmp29_;
17199 			_tmp23_ = self->parent;
17200 			_tmp24_ = vala_gir_parser_node_get_lower_case_cprefix (_tmp23_);
17201 			_tmp25_ = _tmp24_;
17202 			_tmp26_ = g_ascii_strup (_tmp25_, (gssize) -1);
17203 			_tmp27_ = _tmp26_;
17204 			_tmp28_ = self->name;
17205 			_tmp29_ = g_strdup_printf ("%s%s", _tmp27_, _tmp28_);
17206 			_g_free0 (prefix);
17207 			prefix = _tmp29_;
17208 			_g_free0 (_tmp27_);
17209 			_g_free0 (_tmp25_);
17210 		} else {
17211 			gchar* _tmp30_;
17212 			_tmp30_ = vala_gir_parser_node_get_cname (self);
17213 			_g_free0 (prefix);
17214 			prefix = _tmp30_;
17215 		}
17216 	}
17217 	result = prefix;
17218 	return result;
17219 }
17220 
17221 static gchar*
vala_gir_parser_node_get_cname(ValaGirParserNode * self)17222 vala_gir_parser_node_get_cname (ValaGirParserNode* self)
17223 {
17224 	const gchar* _tmp0_;
17225 	gchar* cname = NULL;
17226 	ValaGirParserMetadata* _tmp2_;
17227 	ValaMap* _tmp7_;
17228 	const gchar* _tmp17_;
17229 	gchar* result = NULL;
17230 	g_return_val_if_fail (self != NULL, NULL);
17231 	_tmp0_ = self->name;
17232 	if (_tmp0_ == NULL) {
17233 		gchar* _tmp1_;
17234 		_tmp1_ = g_strdup ("");
17235 		result = _tmp1_;
17236 		return result;
17237 	}
17238 	_tmp2_ = self->metadata;
17239 	if (vala_gir_parser_metadata_has_argument (_tmp2_, VALA_GIR_PARSER_ARGUMENT_TYPE_CNAME)) {
17240 		ValaGirParserMetadata* _tmp3_;
17241 		gchar* _tmp4_;
17242 		_tmp3_ = self->metadata;
17243 		_tmp4_ = vala_gir_parser_metadata_get_string (_tmp3_, VALA_GIR_PARSER_ARGUMENT_TYPE_CNAME);
17244 		_g_free0 (cname);
17245 		cname = _tmp4_;
17246 	} else {
17247 		ValaSymbol* _tmp5_;
17248 		gchar* _tmp6_;
17249 		_tmp5_ = self->symbol;
17250 		_tmp6_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp5_, "CCode", "cname", NULL);
17251 		_g_free0 (cname);
17252 		cname = _tmp6_;
17253 	}
17254 	_tmp7_ = self->girdata;
17255 	if (_tmp7_ != NULL) {
17256 		const gchar* _tmp8_;
17257 		const gchar* _tmp11_;
17258 		const gchar* _tmp14_;
17259 		_tmp8_ = cname;
17260 		if (_tmp8_ == NULL) {
17261 			ValaMap* _tmp9_;
17262 			gpointer _tmp10_;
17263 			_tmp9_ = self->girdata;
17264 			_tmp10_ = vala_map_get (_tmp9_, "c:identifier");
17265 			_g_free0 (cname);
17266 			cname = (gchar*) _tmp10_;
17267 		}
17268 		_tmp11_ = cname;
17269 		if (_tmp11_ == NULL) {
17270 			ValaMap* _tmp12_;
17271 			gpointer _tmp13_;
17272 			_tmp12_ = self->girdata;
17273 			_tmp13_ = vala_map_get (_tmp12_, "c:type");
17274 			_g_free0 (cname);
17275 			cname = (gchar*) _tmp13_;
17276 		}
17277 		_tmp14_ = cname;
17278 		if (_tmp14_ == NULL) {
17279 			ValaMap* _tmp15_;
17280 			gpointer _tmp16_;
17281 			_tmp15_ = self->girdata;
17282 			_tmp16_ = vala_map_get (_tmp15_, "glib:type-name");
17283 			_g_free0 (cname);
17284 			cname = (gchar*) _tmp16_;
17285 		}
17286 	}
17287 	_tmp17_ = cname;
17288 	if (_tmp17_ == NULL) {
17289 		gchar* _tmp18_;
17290 		_tmp18_ = vala_gir_parser_node_get_default_cname (self);
17291 		_g_free0 (cname);
17292 		cname = _tmp18_;
17293 	}
17294 	result = cname;
17295 	return result;
17296 }
17297 
17298 static gchar*
vala_gir_parser_node_get_default_cname(ValaGirParserNode * self)17299 vala_gir_parser_node_get_default_cname (ValaGirParserNode* self)
17300 {
17301 	const gchar* _tmp0_;
17302 	ValaSymbol* _tmp2_;
17303 	gchar* result = NULL;
17304 	g_return_val_if_fail (self != NULL, NULL);
17305 	_tmp0_ = self->name;
17306 	if (_tmp0_ == NULL) {
17307 		gchar* _tmp1_;
17308 		_tmp1_ = g_strdup ("");
17309 		result = _tmp1_;
17310 		return result;
17311 	}
17312 	_tmp2_ = self->symbol;
17313 	if (VALA_IS_FIELD (_tmp2_)) {
17314 		ValaSymbol* _tmp3_;
17315 		ValaMemberBinding _tmp4_;
17316 		ValaMemberBinding _tmp5_;
17317 		_tmp3_ = self->symbol;
17318 		_tmp4_ = vala_field_get_binding (G_TYPE_CHECK_INSTANCE_CAST (_tmp3_, VALA_TYPE_FIELD, ValaField));
17319 		_tmp5_ = _tmp4_;
17320 		if (_tmp5_ == VALA_MEMBER_BINDING_STATIC) {
17321 			ValaGirParserNode* _tmp6_;
17322 			gchar* _tmp7_;
17323 			gchar* _tmp8_;
17324 			const gchar* _tmp9_;
17325 			gchar* _tmp10_;
17326 			gchar* _tmp11_;
17327 			_tmp6_ = self->parent;
17328 			_tmp7_ = vala_gir_parser_node_get_lower_case_cprefix (_tmp6_);
17329 			_tmp8_ = _tmp7_;
17330 			_tmp9_ = self->name;
17331 			_tmp10_ = g_strconcat (_tmp8_, _tmp9_, NULL);
17332 			_tmp11_ = _tmp10_;
17333 			_g_free0 (_tmp8_);
17334 			result = _tmp11_;
17335 			return result;
17336 		} else {
17337 			const gchar* _tmp12_;
17338 			gchar* _tmp13_;
17339 			_tmp12_ = self->name;
17340 			_tmp13_ = g_strdup (_tmp12_);
17341 			result = _tmp13_;
17342 			return result;
17343 		}
17344 	} else {
17345 		ValaSymbol* _tmp14_;
17346 		_tmp14_ = self->symbol;
17347 		if (VALA_IS_METHOD (_tmp14_)) {
17348 			ValaGirParserNode* _tmp15_;
17349 			gchar* _tmp16_;
17350 			gchar* _tmp17_;
17351 			const gchar* _tmp18_;
17352 			gchar* _tmp19_;
17353 			gchar* _tmp20_;
17354 			_tmp15_ = self->parent;
17355 			_tmp16_ = vala_gir_parser_node_get_lower_case_cprefix (_tmp15_);
17356 			_tmp17_ = _tmp16_;
17357 			_tmp18_ = self->name;
17358 			_tmp19_ = g_strdup_printf ("%s%s", _tmp17_, _tmp18_);
17359 			_tmp20_ = _tmp19_;
17360 			_g_free0 (_tmp17_);
17361 			result = _tmp20_;
17362 			return result;
17363 		} else {
17364 			ValaGirParserNode* _tmp21_;
17365 			gchar* _tmp22_;
17366 			gchar* _tmp23_;
17367 			const gchar* _tmp24_;
17368 			gchar* _tmp25_;
17369 			gchar* _tmp26_;
17370 			_tmp21_ = self->parent;
17371 			_tmp22_ = vala_gir_parser_node_get_cprefix (_tmp21_);
17372 			_tmp23_ = _tmp22_;
17373 			_tmp24_ = self->name;
17374 			_tmp25_ = g_strdup_printf ("%s%s", _tmp23_, _tmp24_);
17375 			_tmp26_ = _tmp25_;
17376 			_g_free0 (_tmp23_);
17377 			result = _tmp26_;
17378 			return result;
17379 		}
17380 	}
17381 }
17382 
17383 static gchar*
vala_gir_parser_node_get_finish_cname(ValaGirParserNode * self)17384 vala_gir_parser_node_get_finish_cname (ValaGirParserNode* self)
17385 {
17386 	gchar* finish_cname = NULL;
17387 	ValaSymbol* _tmp0_;
17388 	gchar* _tmp1_;
17389 	const gchar* _tmp2_;
17390 	gchar* result = NULL;
17391 	g_return_val_if_fail (self != NULL, NULL);
17392 	_tmp0_ = self->symbol;
17393 	_tmp1_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp0_, "CCode", "finish_name", NULL);
17394 	finish_cname = _tmp1_;
17395 	_tmp2_ = finish_cname;
17396 	if (_tmp2_ == NULL) {
17397 		gchar* _tmp3_;
17398 		const gchar* _tmp4_;
17399 		const gchar* _tmp12_;
17400 		gchar* _tmp13_;
17401 		_tmp3_ = vala_gir_parser_node_get_cname (self);
17402 		_g_free0 (finish_cname);
17403 		finish_cname = _tmp3_;
17404 		_tmp4_ = finish_cname;
17405 		if (g_str_has_suffix (_tmp4_, "_async")) {
17406 			const gchar* _tmp5_;
17407 			const gchar* _tmp6_;
17408 			gint _tmp7_;
17409 			gint _tmp8_;
17410 			gint _tmp9_;
17411 			gint _tmp10_;
17412 			gchar* _tmp11_;
17413 			_tmp5_ = finish_cname;
17414 			_tmp6_ = finish_cname;
17415 			_tmp7_ = strlen (_tmp6_);
17416 			_tmp8_ = _tmp7_;
17417 			_tmp9_ = strlen ("_async");
17418 			_tmp10_ = _tmp9_;
17419 			_tmp11_ = string_substring (_tmp5_, (glong) 0, (glong) (_tmp8_ - _tmp10_));
17420 			_g_free0 (finish_cname);
17421 			finish_cname = _tmp11_;
17422 		}
17423 		_tmp12_ = finish_cname;
17424 		_tmp13_ = g_strdup_printf ("%s_finish", _tmp12_);
17425 		_g_free0 (finish_cname);
17426 		finish_cname = _tmp13_;
17427 	}
17428 	result = finish_cname;
17429 	return result;
17430 }
17431 
17432 static gchar*
vala_gir_parser_node_get_cheader_filename(ValaGirParserNode * self)17433 vala_gir_parser_node_get_cheader_filename (ValaGirParserNode* self)
17434 {
17435 	ValaGirParserMetadata* _tmp0_;
17436 	gchar* cheader_filename = NULL;
17437 	ValaSymbol* _tmp3_;
17438 	gchar* _tmp4_;
17439 	const gchar* _tmp5_;
17440 	ValaGirParserNode* _tmp6_;
17441 	const gchar* _tmp7_;
17442 	gchar* _tmp19_;
17443 	gchar* result = NULL;
17444 	g_return_val_if_fail (self != NULL, NULL);
17445 	_tmp0_ = self->metadata;
17446 	if (vala_gir_parser_metadata_has_argument (_tmp0_, VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME)) {
17447 		ValaGirParserMetadata* _tmp1_;
17448 		gchar* _tmp2_;
17449 		_tmp1_ = self->metadata;
17450 		_tmp2_ = vala_gir_parser_metadata_get_string (_tmp1_, VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME);
17451 		result = _tmp2_;
17452 		return result;
17453 	}
17454 	_tmp3_ = self->symbol;
17455 	_tmp4_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp3_, "CCode", "cheader_filename", NULL);
17456 	cheader_filename = _tmp4_;
17457 	_tmp5_ = cheader_filename;
17458 	if (_tmp5_ != NULL) {
17459 		result = cheader_filename;
17460 		return result;
17461 	}
17462 	_tmp6_ = self->parent;
17463 	_tmp7_ = _tmp6_->name;
17464 	if (_tmp7_ != NULL) {
17465 		ValaGirParserNode* _tmp8_;
17466 		gchar* _tmp9_;
17467 		_tmp8_ = self->parent;
17468 		_tmp9_ = vala_gir_parser_node_get_cheader_filename (_tmp8_);
17469 		result = _tmp9_;
17470 		_g_free0 (cheader_filename);
17471 		return result;
17472 	} else {
17473 		ValaSymbol* _tmp10_;
17474 		ValaSourceReference* _tmp11_;
17475 		ValaSourceReference* _tmp12_;
17476 		_tmp10_ = self->symbol;
17477 		_tmp11_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp10_);
17478 		_tmp12_ = _tmp11_;
17479 		if (_tmp12_ != NULL) {
17480 			ValaSymbol* _tmp13_;
17481 			ValaSourceReference* _tmp14_;
17482 			ValaSourceReference* _tmp15_;
17483 			ValaSourceFile* _tmp16_;
17484 			ValaSourceFile* _tmp17_;
17485 			gchar* _tmp18_;
17486 			_tmp13_ = self->symbol;
17487 			_tmp14_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp13_);
17488 			_tmp15_ = _tmp14_;
17489 			_tmp16_ = vala_source_reference_get_file (_tmp15_);
17490 			_tmp17_ = _tmp16_;
17491 			_tmp18_ = vala_source_file_get_cinclude_filename (_tmp17_);
17492 			result = _tmp18_;
17493 			_g_free0 (cheader_filename);
17494 			return result;
17495 		}
17496 	}
17497 	_tmp19_ = g_strdup ("");
17498 	result = _tmp19_;
17499 	_g_free0 (cheader_filename);
17500 	return result;
17501 }
17502 
17503 static gboolean
int64_try_parse(const gchar * str,gint64 * _result_,const gchar ** unparsed,guint _base)17504 int64_try_parse (const gchar* str,
17505                  gint64* _result_,
17506                  const gchar* * unparsed,
17507                  guint _base)
17508 {
17509 	gint64 _vala__result_ = 0LL;
17510 	const gchar* _vala_unparsed = NULL;
17511 	gchar* endptr = NULL;
17512 	gchar* _tmp0_ = NULL;
17513 	gint64 _tmp1_;
17514 	gchar* _tmp2_;
17515 	gint _tmp3_;
17516 	gint _tmp4_;
17517 	gboolean result = FALSE;
17518 	g_return_val_if_fail (str != NULL, FALSE);
17519 	errno = 0;
17520 	_tmp1_ = g_ascii_strtoll (str, &_tmp0_, _base);
17521 	endptr = _tmp0_;
17522 	_vala__result_ = _tmp1_;
17523 	_tmp2_ = endptr;
17524 	_tmp3_ = strlen (str);
17525 	_tmp4_ = _tmp3_;
17526 	if (_tmp2_ == (((gchar*) str) + _tmp4_)) {
17527 		gboolean _tmp5_ = FALSE;
17528 		_vala_unparsed = "";
17529 		if (errno != ERANGE) {
17530 			_tmp5_ = errno != EINVAL;
17531 		} else {
17532 			_tmp5_ = FALSE;
17533 		}
17534 		result = _tmp5_;
17535 		if (_result_) {
17536 			*_result_ = _vala__result_;
17537 		}
17538 		if (unparsed) {
17539 			*unparsed = _vala_unparsed;
17540 		}
17541 		return result;
17542 	} else {
17543 		gchar* _tmp6_;
17544 		_tmp6_ = endptr;
17545 		_vala_unparsed = (const gchar*) _tmp6_;
17546 		result = FALSE;
17547 		if (_result_) {
17548 			*_result_ = _vala__result_;
17549 		}
17550 		if (unparsed) {
17551 			*unparsed = _vala_unparsed;
17552 		}
17553 		return result;
17554 	}
17555 	if (_result_) {
17556 		*_result_ = _vala__result_;
17557 	}
17558 	if (unparsed) {
17559 		*unparsed = _vala_unparsed;
17560 	}
17561 }
17562 
17563 static guint64
vala_gir_parser_node_parse_version_string(const gchar * version)17564 vala_gir_parser_node_parse_version_string (const gchar* version)
17565 {
17566 	gint64 res = 0LL;
17567 	gint shift = 0;
17568 	gchar** tokens = NULL;
17569 	gchar** _tmp0_;
17570 	gchar** _tmp1_;
17571 	gint tokens_length1;
17572 	gint _tokens_size_;
17573 	gchar** _tmp2_;
17574 	gint _tmp2__length1;
17575 	guint64 result = 0ULL;
17576 	g_return_val_if_fail (version != NULL, 0ULL);
17577 	res = (gint64) 0;
17578 	shift = 16;
17579 	_tmp1_ = _tmp0_ = g_strsplit (version, ".", 3);
17580 	tokens = _tmp1_;
17581 	tokens_length1 = _vala_array_length (_tmp0_);
17582 	_tokens_size_ = tokens_length1;
17583 	_tmp2_ = tokens;
17584 	_tmp2__length1 = tokens_length1;
17585 	{
17586 		gchar** token_collection = NULL;
17587 		gint token_collection_length1 = 0;
17588 		gint _token_collection_size_ = 0;
17589 		gint token_it = 0;
17590 		token_collection = _tmp2_;
17591 		token_collection_length1 = _tmp2__length1;
17592 		for (token_it = 0; token_it < token_collection_length1; token_it = token_it + 1) {
17593 			const gchar* token = NULL;
17594 			token = token_collection[token_it];
17595 			{
17596 				gint64 t = 0LL;
17597 				const gchar* _tmp3_;
17598 				gint64 _tmp4_ = 0LL;
17599 				gboolean _tmp5_;
17600 				_tmp3_ = token;
17601 				_tmp5_ = int64_try_parse (_tmp3_, &_tmp4_, NULL, (guint) 0);
17602 				t = _tmp4_;
17603 				if (!_tmp5_) {
17604 					result = (guint64) 0;
17605 					tokens = (_vala_array_free (tokens, tokens_length1, (GDestroyNotify) g_free), NULL);
17606 					return result;
17607 				}
17608 				if (t > ((gint64) 0xffff)) {
17609 					result = (guint64) 0;
17610 					tokens = (_vala_array_free (tokens, tokens_length1, (GDestroyNotify) g_free), NULL);
17611 					return result;
17612 				}
17613 				res |= t << shift;
17614 				shift -= 8;
17615 			}
17616 		}
17617 	}
17618 	result = (guint64) res;
17619 	tokens = (_vala_array_free (tokens, tokens_length1, (GDestroyNotify) g_free), NULL);
17620 	return result;
17621 }
17622 
17623 static void
vala_gir_parser_node_move_class_methods(ValaGirParserNode * target,ValaGirParserNode * source)17624 vala_gir_parser_node_move_class_methods (ValaGirParserNode* target,
17625                                          ValaGirParserNode* source)
17626 {
17627 	gint i = 0;
17628 	g_return_if_fail (target != NULL);
17629 	if (source == NULL) {
17630 		return;
17631 	}
17632 	i = 0;
17633 	while (TRUE) {
17634 		ValaArrayList* _tmp0_;
17635 		gint _tmp1_;
17636 		gint _tmp2_;
17637 		ValaGirParserNode* node = NULL;
17638 		ValaArrayList* _tmp3_;
17639 		gpointer _tmp4_;
17640 		ValaGirParserNode* _tmp5_;
17641 		ValaSymbol* _tmp6_;
17642 		_tmp0_ = source->members;
17643 		_tmp1_ = vala_collection_get_size ((ValaCollection*) _tmp0_);
17644 		_tmp2_ = _tmp1_;
17645 		if (!(i < _tmp2_)) {
17646 			break;
17647 		}
17648 		_tmp3_ = source->members;
17649 		_tmp4_ = vala_list_get ((ValaList*) _tmp3_, i);
17650 		node = (ValaGirParserNode*) _tmp4_;
17651 		_tmp5_ = node;
17652 		_tmp6_ = _tmp5_->symbol;
17653 		if (VALA_IS_METHOD (_tmp6_)) {
17654 			ValaGirParserNode* _tmp7_;
17655 			ValaGirParserNode* _tmp8_;
17656 			ValaGirParserNode* _tmp9_;
17657 			ValaSymbol* _tmp10_;
17658 			_tmp7_ = node;
17659 			vala_gir_parser_node_remove_member (source, _tmp7_);
17660 			_tmp8_ = node;
17661 			vala_gir_parser_node_add_member (target, _tmp8_);
17662 			_tmp9_ = node;
17663 			_tmp10_ = _tmp9_->symbol;
17664 			vala_method_set_binding (G_TYPE_CHECK_INSTANCE_CAST (_tmp10_, VALA_TYPE_METHOD, ValaMethod), VALA_MEMBER_BINDING_CLASS);
17665 		} else {
17666 			gint _tmp11_;
17667 			_tmp11_ = i;
17668 			i = _tmp11_ + 1;
17669 		}
17670 		_vala_gir_parser_node_unref0 (node);
17671 	}
17672 }
17673 
17674 static void
vala_gir_parser_node_process(ValaGirParserNode * self,ValaGirParser * parser)17675 vala_gir_parser_node_process (ValaGirParserNode* self,
17676                               ValaGirParser* parser)
17677 {
17678 	gboolean _tmp0_ = FALSE;
17679 	ValaSymbol* _tmp1_;
17680 	gboolean _tmp37_ = FALSE;
17681 	ValaSymbol* _tmp38_;
17682 	ValaMap* _tmp65_;
17683 	gboolean _tmp823_ = FALSE;
17684 	gboolean _tmp824_ = FALSE;
17685 	g_return_if_fail (self != NULL);
17686 	g_return_if_fail (parser != NULL);
17687 	if (self->processed) {
17688 		return;
17689 	}
17690 	_tmp1_ = self->symbol;
17691 	if (VALA_IS_NAMESPACE (_tmp1_)) {
17692 		ValaGirParserNode* _tmp2_;
17693 		ValaGirParserNode* _tmp3_;
17694 		_tmp2_ = self->parent;
17695 		_tmp3_ = parser->priv->root;
17696 		_tmp0_ = _tmp2_ == _tmp3_;
17697 	} else {
17698 		_tmp0_ = FALSE;
17699 	}
17700 	if (_tmp0_) {
17701 		{
17702 			ValaArrayList* _node_list = NULL;
17703 			ValaArrayList* _tmp4_;
17704 			ValaArrayList* _tmp5_;
17705 			gint _node_size = 0;
17706 			ValaArrayList* _tmp6_;
17707 			gint _tmp7_;
17708 			gint _tmp8_;
17709 			gint _node_index = 0;
17710 			_tmp4_ = self->members;
17711 			_tmp5_ = _vala_iterable_ref0 (_tmp4_);
17712 			_node_list = _tmp5_;
17713 			_tmp6_ = _node_list;
17714 			_tmp7_ = vala_collection_get_size ((ValaCollection*) _tmp6_);
17715 			_tmp8_ = _tmp7_;
17716 			_node_size = _tmp8_;
17717 			_node_index = -1;
17718 			while (TRUE) {
17719 				gint _tmp9_;
17720 				gint _tmp10_;
17721 				ValaGirParserNode* node = NULL;
17722 				ValaArrayList* _tmp11_;
17723 				gpointer _tmp12_;
17724 				ValaGirParserNode* _tmp13_;
17725 				const gchar* _tmp14_;
17726 				_node_index = _node_index + 1;
17727 				_tmp9_ = _node_index;
17728 				_tmp10_ = _node_size;
17729 				if (!(_tmp9_ < _tmp10_)) {
17730 					break;
17731 				}
17732 				_tmp11_ = _node_list;
17733 				_tmp12_ = vala_list_get ((ValaList*) _tmp11_, _node_index);
17734 				node = (ValaGirParserNode*) _tmp12_;
17735 				_tmp13_ = node;
17736 				_tmp14_ = _tmp13_->element_type;
17737 				if (g_strcmp0 (_tmp14_, "alias") == 0) {
17738 					ValaGirParserNode* _tmp15_;
17739 					_tmp15_ = node;
17740 					vala_gir_parser_process_alias (parser, _tmp15_);
17741 				}
17742 				_vala_gir_parser_node_unref0 (node);
17743 			}
17744 			_vala_iterable_unref0 (_node_list);
17745 		}
17746 		{
17747 			gint i = 0;
17748 			i = 0;
17749 			{
17750 				gboolean _tmp16_ = FALSE;
17751 				_tmp16_ = TRUE;
17752 				while (TRUE) {
17753 					ValaArrayList* _tmp18_;
17754 					gint _tmp19_;
17755 					gint _tmp20_;
17756 					ValaGirParserNode* node = NULL;
17757 					ValaArrayList* _tmp21_;
17758 					gpointer _tmp22_;
17759 					gboolean _tmp23_ = FALSE;
17760 					ValaGirParserNode* _tmp24_;
17761 					ValaSymbol* _tmp25_;
17762 					if (!_tmp16_) {
17763 						gint _tmp17_;
17764 						_tmp17_ = i;
17765 						i = _tmp17_ + 1;
17766 					}
17767 					_tmp16_ = FALSE;
17768 					_tmp18_ = self->members;
17769 					_tmp19_ = vala_collection_get_size ((ValaCollection*) _tmp18_);
17770 					_tmp20_ = _tmp19_;
17771 					if (!(i < _tmp20_)) {
17772 						break;
17773 					}
17774 					_tmp21_ = self->members;
17775 					_tmp22_ = vala_list_get ((ValaList*) _tmp21_, i);
17776 					node = (ValaGirParserNode*) _tmp22_;
17777 					_tmp24_ = node;
17778 					_tmp25_ = _tmp24_->symbol;
17779 					if (VALA_IS_METHOD (_tmp25_)) {
17780 						ValaGirParserNode* _tmp26_;
17781 						_tmp26_ = node;
17782 						_tmp23_ = _tmp26_->new_symbol;
17783 					} else {
17784 						_tmp23_ = FALSE;
17785 					}
17786 					if (_tmp23_) {
17787 						ValaGirParserNode* _tmp27_;
17788 						gboolean _tmp28_ = FALSE;
17789 						ValaArrayList* _tmp29_;
17790 						gint _tmp30_;
17791 						gint _tmp31_;
17792 						_tmp27_ = node;
17793 						vala_gir_parser_process_namespace_method (parser, self, _tmp27_);
17794 						_tmp29_ = self->members;
17795 						_tmp30_ = vala_collection_get_size ((ValaCollection*) _tmp29_);
17796 						_tmp31_ = _tmp30_;
17797 						if (i < _tmp31_) {
17798 							ValaArrayList* _tmp32_;
17799 							gpointer _tmp33_;
17800 							ValaGirParserNode* _tmp34_;
17801 							ValaGirParserNode* _tmp35_;
17802 							_tmp32_ = self->members;
17803 							_tmp33_ = vala_list_get ((ValaList*) _tmp32_, i);
17804 							_tmp34_ = (ValaGirParserNode*) _tmp33_;
17805 							_tmp35_ = node;
17806 							_tmp28_ = _tmp34_ != _tmp35_;
17807 							_vala_gir_parser_node_unref0 (_tmp34_);
17808 						} else {
17809 							_tmp28_ = FALSE;
17810 						}
17811 						if (_tmp28_) {
17812 							gint _tmp36_;
17813 							_tmp36_ = i;
17814 							i = _tmp36_ - 1;
17815 						}
17816 					}
17817 					_vala_gir_parser_node_unref0 (node);
17818 				}
17819 			}
17820 		}
17821 	}
17822 	_tmp38_ = self->symbol;
17823 	if (VALA_IS_CLASS (_tmp38_)) {
17824 		ValaMap* _tmp39_;
17825 		_tmp39_ = self->girdata;
17826 		_tmp37_ = _tmp39_ != NULL;
17827 	} else {
17828 		_tmp37_ = FALSE;
17829 	}
17830 	if (_tmp37_) {
17831 		ValaUnresolvedSymbol* _tmp40_;
17832 		gchar* class_struct = NULL;
17833 		ValaMap* _tmp45_;
17834 		gpointer _tmp46_;
17835 		const gchar* _tmp47_;
17836 		_tmp40_ = self->type_struct;
17837 		if (_tmp40_ != NULL) {
17838 			ValaGirParserNode* _tmp41_;
17839 			ValaUnresolvedSymbol* _tmp42_;
17840 			ValaGirParserNode* _tmp43_;
17841 			ValaGirParserNode* _tmp44_;
17842 			_tmp41_ = self->parent;
17843 			_tmp42_ = self->type_struct;
17844 			_tmp43_ = vala_gir_parser_resolve_node (parser, _tmp41_, _tmp42_, FALSE);
17845 			_tmp44_ = _tmp43_;
17846 			vala_gir_parser_node_move_class_methods (self, _tmp44_);
17847 			_vala_gir_parser_node_unref0 (_tmp44_);
17848 		}
17849 		_tmp45_ = self->girdata;
17850 		_tmp46_ = vala_map_get (_tmp45_, "glib:type-struct");
17851 		class_struct = (gchar*) _tmp46_;
17852 		_tmp47_ = class_struct;
17853 		if (_tmp47_ != NULL) {
17854 			ValaGirParserNode* _tmp48_;
17855 			const gchar* _tmp49_;
17856 			ValaSourceReference* _tmp50_;
17857 			ValaUnresolvedSymbol* _tmp51_;
17858 			ValaUnresolvedSymbol* _tmp52_;
17859 			ValaGirParserNode* _tmp53_;
17860 			ValaGirParserNode* _tmp54_;
17861 			_tmp48_ = self->parent;
17862 			_tmp49_ = class_struct;
17863 			_tmp50_ = self->source_reference;
17864 			_tmp51_ = vala_gir_parser_parse_symbol_from_string (parser, _tmp49_, _tmp50_);
17865 			_tmp52_ = _tmp51_;
17866 			_tmp53_ = vala_gir_parser_resolve_node (parser, _tmp48_, _tmp52_, FALSE);
17867 			_tmp54_ = _tmp53_;
17868 			vala_gir_parser_node_move_class_methods (self, _tmp54_);
17869 			_vala_gir_parser_node_unref0 (_tmp54_);
17870 			_vala_code_node_unref0 (_tmp52_);
17871 		}
17872 		_g_free0 (class_struct);
17873 	}
17874 	{
17875 		ValaArrayList* _node_list = NULL;
17876 		ValaArrayList* _tmp55_;
17877 		ValaArrayList* _tmp56_;
17878 		gint _node_size = 0;
17879 		ValaArrayList* _tmp57_;
17880 		gint _tmp58_;
17881 		gint _tmp59_;
17882 		gint _node_index = 0;
17883 		_tmp55_ = self->members;
17884 		_tmp56_ = _vala_iterable_ref0 (_tmp55_);
17885 		_node_list = _tmp56_;
17886 		_tmp57_ = _node_list;
17887 		_tmp58_ = vala_collection_get_size ((ValaCollection*) _tmp57_);
17888 		_tmp59_ = _tmp58_;
17889 		_node_size = _tmp59_;
17890 		_node_index = -1;
17891 		while (TRUE) {
17892 			gint _tmp60_;
17893 			gint _tmp61_;
17894 			ValaGirParserNode* node = NULL;
17895 			ValaArrayList* _tmp62_;
17896 			gpointer _tmp63_;
17897 			ValaGirParserNode* _tmp64_;
17898 			_node_index = _node_index + 1;
17899 			_tmp60_ = _node_index;
17900 			_tmp61_ = _node_size;
17901 			if (!(_tmp60_ < _tmp61_)) {
17902 				break;
17903 			}
17904 			_tmp62_ = _node_list;
17905 			_tmp63_ = vala_list_get ((ValaList*) _tmp62_, _node_index);
17906 			node = (ValaGirParserNode*) _tmp63_;
17907 			_tmp64_ = node;
17908 			vala_gir_parser_node_process (_tmp64_, parser);
17909 			_vala_gir_parser_node_unref0 (node);
17910 		}
17911 		_vala_iterable_unref0 (_node_list);
17912 	}
17913 	_tmp65_ = self->girdata;
17914 	if (_tmp65_ != NULL) {
17915 		ValaSymbol* _tmp66_;
17916 		ValaGirParserMetadata* _tmp730_;
17917 		ValaGirParserMetadata* _tmp733_;
17918 		ValaGirParserMetadata* _tmp742_;
17919 		const gchar* _tmp748_;
17920 		ValaGirParserMetadata* _tmp750_;
17921 		ValaGirParserMetadata* _tmp753_;
17922 		ValaGirParserNode* _tmp771_;
17923 		ValaSymbol* _tmp772_;
17924 		gchar* _tmp781_;
17925 		gchar* _tmp782_;
17926 		gchar* _tmp783_;
17927 		gchar* _tmp784_;
17928 		gboolean _tmp785_;
17929 		ValaGirParserMetadata* _tmp789_;
17930 		gchar* _tmp794_;
17931 		gchar* _tmp795_;
17932 		gchar* _tmp796_;
17933 		gchar* _tmp797_;
17934 		gboolean _tmp798_;
17935 		gchar* _tmp802_;
17936 		gchar* _tmp803_;
17937 		gchar* _tmp804_;
17938 		gchar* _tmp805_;
17939 		gboolean _tmp806_;
17940 		gchar* gir_name = NULL;
17941 		gchar* _tmp810_;
17942 		gchar* default_gir_name = NULL;
17943 		gchar* _tmp811_;
17944 		gboolean _tmp812_ = FALSE;
17945 		gboolean _tmp813_ = FALSE;
17946 		ValaSymbol* _tmp814_;
17947 		_tmp66_ = self->symbol;
17948 		if (VALA_IS_METHOD (_tmp66_)) {
17949 			ValaMethod* m = NULL;
17950 			ValaSymbol* _tmp67_;
17951 			ValaMethod* _tmp68_;
17952 			ValaArrayList* colliding = NULL;
17953 			ValaGirParserNode* _tmp69_;
17954 			const gchar* _tmp70_;
17955 			ValaArrayList* _tmp71_;
17956 			ValaMethod* _tmp180_;
17957 			ValaGirParserMetadata* _tmp199_;
17958 			ValaMethod* _tmp202_;
17959 			gboolean _tmp203_;
17960 			gboolean _tmp204_;
17961 			_tmp67_ = self->symbol;
17962 			_tmp68_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp67_, VALA_TYPE_METHOD, ValaMethod));
17963 			m = _tmp68_;
17964 			vala_gir_parser_process_callable (parser, self);
17965 			_tmp69_ = self->parent;
17966 			_tmp70_ = self->name;
17967 			_tmp71_ = vala_gir_parser_node_lookup_all (_tmp69_, _tmp70_);
17968 			colliding = _tmp71_;
17969 			{
17970 				ValaArrayList* _node_list = NULL;
17971 				ValaArrayList* _tmp72_;
17972 				ValaArrayList* _tmp73_;
17973 				gint _node_size = 0;
17974 				ValaArrayList* _tmp74_;
17975 				gint _tmp75_;
17976 				gint _tmp76_;
17977 				gint _node_index = 0;
17978 				_tmp72_ = colliding;
17979 				_tmp73_ = _vala_iterable_ref0 (_tmp72_);
17980 				_node_list = _tmp73_;
17981 				_tmp74_ = _node_list;
17982 				_tmp75_ = vala_collection_get_size ((ValaCollection*) _tmp74_);
17983 				_tmp76_ = _tmp75_;
17984 				_node_size = _tmp76_;
17985 				_node_index = -1;
17986 				while (TRUE) {
17987 					gint _tmp77_;
17988 					gint _tmp78_;
17989 					ValaGirParserNode* node = NULL;
17990 					ValaArrayList* _tmp79_;
17991 					gpointer _tmp80_;
17992 					ValaSymbol* sym = NULL;
17993 					ValaGirParserNode* _tmp81_;
17994 					ValaSymbol* _tmp82_;
17995 					ValaSymbol* _tmp83_;
17996 					ValaSymbol* _tmp84_;
17997 					_node_index = _node_index + 1;
17998 					_tmp77_ = _node_index;
17999 					_tmp78_ = _node_size;
18000 					if (!(_tmp77_ < _tmp78_)) {
18001 						break;
18002 					}
18003 					_tmp79_ = _node_list;
18004 					_tmp80_ = vala_list_get ((ValaList*) _tmp79_, _node_index);
18005 					node = (ValaGirParserNode*) _tmp80_;
18006 					_tmp81_ = node;
18007 					_tmp82_ = _tmp81_->symbol;
18008 					_tmp83_ = _vala_code_node_ref0 (_tmp82_);
18009 					sym = _tmp83_;
18010 					_tmp84_ = sym;
18011 					if (VALA_IS_FIELD (_tmp84_)) {
18012 						gboolean _tmp85_ = FALSE;
18013 						ValaMethod* _tmp86_;
18014 						ValaDataType* _tmp87_;
18015 						ValaDataType* _tmp88_;
18016 						ValaSymbol* _tmp89_;
18017 						ValaDataType* _tmp90_;
18018 						ValaDataType* _tmp91_;
18019 						_tmp86_ = m;
18020 						_tmp87_ = vala_callable_get_return_type ((ValaCallable*) _tmp86_);
18021 						_tmp88_ = _tmp87_;
18022 						_tmp89_ = sym;
18023 						_tmp90_ = vala_variable_get_variable_type ((ValaVariable*) G_TYPE_CHECK_INSTANCE_CAST (_tmp89_, VALA_TYPE_FIELD, ValaField));
18024 						_tmp91_ = _tmp90_;
18025 						if (vala_data_type_compatible (_tmp88_, _tmp91_)) {
18026 							ValaMethod* _tmp92_;
18027 							ValaList* _tmp93_;
18028 							gint _tmp94_;
18029 							gint _tmp95_;
18030 							_tmp92_ = m;
18031 							_tmp93_ = vala_callable_get_parameters ((ValaCallable*) _tmp92_);
18032 							_tmp94_ = vala_collection_get_size ((ValaCollection*) _tmp93_);
18033 							_tmp95_ = _tmp94_;
18034 							_tmp85_ = _tmp95_ == 0;
18035 						} else {
18036 							_tmp85_ = FALSE;
18037 						}
18038 						if (_tmp85_) {
18039 							self->merged = TRUE;
18040 						} else {
18041 							ValaSymbol* _tmp96_;
18042 							ValaSourceReference* _tmp97_;
18043 							ValaSourceReference* _tmp98_;
18044 							gchar* _tmp99_;
18045 							gchar* _tmp100_;
18046 							gchar* _tmp101_;
18047 							gchar* _tmp102_;
18048 							_tmp96_ = self->symbol;
18049 							_tmp97_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp96_);
18050 							_tmp98_ = _tmp97_;
18051 							_tmp99_ = vala_gir_parser_node_get_full_name (self);
18052 							_tmp100_ = _tmp99_;
18053 							_tmp101_ = g_strdup_printf ("Field `%s' conflicts with method of the same name", _tmp100_);
18054 							_tmp102_ = _tmp101_;
18055 							vala_report_warning (_tmp98_, _tmp102_);
18056 							_g_free0 (_tmp102_);
18057 							_g_free0 (_tmp100_);
18058 						}
18059 					} else {
18060 						ValaSymbol* _tmp103_;
18061 						_tmp103_ = sym;
18062 						if (VALA_IS_SIGNAL (_tmp103_)) {
18063 							ValaGirParserNode* _tmp104_;
18064 							ValaSignal* sig = NULL;
18065 							ValaSymbol* _tmp105_;
18066 							ValaSignal* _tmp106_;
18067 							gboolean _tmp107_ = FALSE;
18068 							ValaMethod* _tmp108_;
18069 							gboolean _tmp109_;
18070 							gboolean _tmp110_;
18071 							ValaSignal* _tmp116_;
18072 							ValaMethod* _tmp117_;
18073 							ValaMethod* _tmp118_;
18074 							ValaList* _tmp119_;
18075 							gint _tmp120_;
18076 							gint _tmp121_;
18077 							ValaSignal* _tmp122_;
18078 							ValaList* _tmp123_;
18079 							gint _tmp124_;
18080 							gint _tmp125_;
18081 							_tmp104_ = node;
18082 							vala_gir_parser_node_process (_tmp104_, parser);
18083 							_tmp105_ = sym;
18084 							_tmp106_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp105_, VALA_TYPE_SIGNAL, ValaSignal));
18085 							sig = _tmp106_;
18086 							_tmp108_ = m;
18087 							_tmp109_ = vala_method_get_is_virtual (_tmp108_);
18088 							_tmp110_ = _tmp109_;
18089 							if (_tmp110_) {
18090 								_tmp107_ = TRUE;
18091 							} else {
18092 								ValaMethod* _tmp111_;
18093 								gboolean _tmp112_;
18094 								gboolean _tmp113_;
18095 								_tmp111_ = m;
18096 								_tmp112_ = vala_method_get_is_abstract (_tmp111_);
18097 								_tmp113_ = _tmp112_;
18098 								_tmp107_ = _tmp113_;
18099 							}
18100 							if (_tmp107_) {
18101 								ValaSignal* _tmp114_;
18102 								_tmp114_ = sig;
18103 								vala_signal_set_is_virtual (_tmp114_, TRUE);
18104 							} else {
18105 								ValaSignal* _tmp115_;
18106 								_tmp115_ = sig;
18107 								vala_code_node_set_attribute ((ValaCodeNode*) _tmp115_, "HasEmitter", TRUE, NULL);
18108 							}
18109 							_tmp116_ = sig;
18110 							_tmp117_ = m;
18111 							vala_gir_parser_assume_parameter_names (parser, _tmp116_, (ValaSymbol*) _tmp117_, FALSE);
18112 							_tmp118_ = m;
18113 							_tmp119_ = vala_callable_get_parameters ((ValaCallable*) _tmp118_);
18114 							_tmp120_ = vala_collection_get_size ((ValaCollection*) _tmp119_);
18115 							_tmp121_ = _tmp120_;
18116 							_tmp122_ = sig;
18117 							_tmp123_ = vala_callable_get_parameters ((ValaCallable*) _tmp122_);
18118 							_tmp124_ = vala_collection_get_size ((ValaCollection*) _tmp123_);
18119 							_tmp125_ = _tmp124_;
18120 							if (_tmp121_ != _tmp125_) {
18121 								ValaSymbol* _tmp126_;
18122 								ValaSourceReference* _tmp127_;
18123 								ValaSourceReference* _tmp128_;
18124 								gchar* _tmp129_;
18125 								gchar* _tmp130_;
18126 								gchar* _tmp131_;
18127 								gchar* _tmp132_;
18128 								_tmp126_ = self->symbol;
18129 								_tmp127_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp126_);
18130 								_tmp128_ = _tmp127_;
18131 								_tmp129_ = vala_gir_parser_node_get_full_name (self);
18132 								_tmp130_ = _tmp129_;
18133 								_tmp131_ = g_strdup_printf ("Signal `%s' conflicts with method of the same name", _tmp130_);
18134 								_tmp132_ = _tmp131_;
18135 								vala_report_warning (_tmp128_, _tmp132_);
18136 								_g_free0 (_tmp132_);
18137 								_g_free0 (_tmp130_);
18138 							}
18139 							self->merged = TRUE;
18140 							_vala_code_node_unref0 (sig);
18141 						} else {
18142 							gboolean _tmp133_ = FALSE;
18143 							gboolean _tmp134_ = FALSE;
18144 							ValaSymbol* _tmp135_;
18145 							_tmp135_ = sym;
18146 							if (VALA_IS_METHOD (_tmp135_)) {
18147 								ValaSymbol* _tmp136_;
18148 								_tmp136_ = sym;
18149 								_tmp134_ = !VALA_IS_CREATION_METHOD (_tmp136_);
18150 							} else {
18151 								_tmp134_ = FALSE;
18152 							}
18153 							if (_tmp134_) {
18154 								ValaGirParserNode* _tmp137_;
18155 								_tmp137_ = node;
18156 								_tmp133_ = _tmp137_ != self;
18157 							} else {
18158 								_tmp133_ = FALSE;
18159 							}
18160 							if (_tmp133_) {
18161 								gboolean _tmp138_ = FALSE;
18162 								ValaMethod* _tmp139_;
18163 								gboolean _tmp140_;
18164 								gboolean _tmp141_;
18165 								_tmp139_ = m;
18166 								_tmp140_ = vala_method_get_is_virtual (_tmp139_);
18167 								_tmp141_ = _tmp140_;
18168 								if (_tmp141_) {
18169 									_tmp138_ = TRUE;
18170 								} else {
18171 									ValaMethod* _tmp142_;
18172 									gboolean _tmp143_;
18173 									gboolean _tmp144_;
18174 									_tmp142_ = m;
18175 									_tmp143_ = vala_method_get_is_abstract (_tmp142_);
18176 									_tmp144_ = _tmp143_;
18177 									_tmp138_ = _tmp144_;
18178 								}
18179 								if (_tmp138_) {
18180 									gboolean different_invoker = FALSE;
18181 									ValaAttribute* attr = NULL;
18182 									ValaMethod* _tmp145_;
18183 									ValaAttribute* _tmp146_;
18184 									ValaAttribute* _tmp147_;
18185 									ValaAttribute* _tmp148_;
18186 									different_invoker = FALSE;
18187 									_tmp145_ = m;
18188 									_tmp146_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp145_, "NoWrapper");
18189 									_tmp147_ = _vala_code_node_ref0 (_tmp146_);
18190 									attr = _tmp147_;
18191 									_tmp148_ = attr;
18192 									if (_tmp148_ != NULL) {
18193 										ValaGirParserNode* invoker = NULL;
18194 										ValaGirParserNode* _tmp149_;
18195 										ValaGirParserNode* _tmp150_;
18196 										_tmp149_ = vala_gir_parser_find_invoker (parser, self);
18197 										invoker = _tmp149_;
18198 										_tmp150_ = invoker;
18199 										if (_tmp150_ != NULL) {
18200 											ValaMethod* _tmp151_;
18201 											ValaMethod* _tmp152_;
18202 											const gchar* _tmp153_;
18203 											const gchar* _tmp154_;
18204 											ValaMethod* _tmp155_;
18205 											ValaGirParserNode* _tmp156_;
18206 											ValaSymbol* _tmp157_;
18207 											const gchar* _tmp158_;
18208 											const gchar* _tmp159_;
18209 											ValaMethod* _tmp160_;
18210 											ValaGirParserNode* _tmp161_;
18211 											_tmp151_ = m;
18212 											_tmp152_ = m;
18213 											_tmp153_ = vala_symbol_get_name ((ValaSymbol*) _tmp152_);
18214 											_tmp154_ = _tmp153_;
18215 											vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp151_, "CCode", "vfunc_name", _tmp154_, NULL);
18216 											_tmp155_ = m;
18217 											_tmp156_ = invoker;
18218 											_tmp157_ = _tmp156_->symbol;
18219 											_tmp158_ = vala_symbol_get_name (_tmp157_);
18220 											_tmp159_ = _tmp158_;
18221 											vala_symbol_set_name ((ValaSymbol*) _tmp155_, _tmp159_);
18222 											_tmp160_ = m;
18223 											vala_code_node_set_attribute ((ValaCodeNode*) _tmp160_, "NoWrapper", FALSE, NULL);
18224 											_tmp161_ = invoker;
18225 											_tmp161_->merged = TRUE;
18226 											different_invoker = TRUE;
18227 										}
18228 										_vala_gir_parser_node_unref0 (invoker);
18229 									}
18230 									if (!different_invoker) {
18231 										ValaAttribute* _tmp162_;
18232 										ValaGirParserNode* _tmp170_;
18233 										_tmp162_ = attr;
18234 										if (_tmp162_ != NULL) {
18235 											ValaSymbol* _tmp163_;
18236 											ValaSourceReference* _tmp164_;
18237 											ValaSourceReference* _tmp165_;
18238 											gchar* _tmp166_;
18239 											gchar* _tmp167_;
18240 											gchar* _tmp168_;
18241 											gchar* _tmp169_;
18242 											_tmp163_ = self->symbol;
18243 											_tmp164_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp163_);
18244 											_tmp165_ = _tmp164_;
18245 											_tmp166_ = vala_gir_parser_node_get_full_name (self);
18246 											_tmp167_ = _tmp166_;
18247 											_tmp168_ = g_strdup_printf ("Virtual method `%s' conflicts with method of the same name", _tmp167_);
18248 											_tmp169_ = _tmp168_;
18249 											vala_report_warning (_tmp165_, _tmp169_);
18250 											_g_free0 (_tmp169_);
18251 											_g_free0 (_tmp167_);
18252 										}
18253 										_tmp170_ = node;
18254 										_tmp170_->merged = TRUE;
18255 									}
18256 									_vala_code_node_unref0 (attr);
18257 								} else {
18258 									ValaMethod* _tmp171_;
18259 									_tmp171_ = m;
18260 									if (vala_symbol_is_class_member ((ValaSymbol*) _tmp171_)) {
18261 										ValaSymbol* _tmp172_;
18262 										ValaSourceReference* _tmp173_;
18263 										ValaSourceReference* _tmp174_;
18264 										gchar* _tmp175_;
18265 										gchar* _tmp176_;
18266 										gchar* _tmp177_;
18267 										gchar* _tmp178_;
18268 										ValaGirParserNode* _tmp179_;
18269 										_tmp172_ = self->symbol;
18270 										_tmp173_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp172_);
18271 										_tmp174_ = _tmp173_;
18272 										_tmp175_ = vala_gir_parser_node_get_full_name (self);
18273 										_tmp176_ = _tmp175_;
18274 										_tmp177_ = g_strdup_printf ("Class method `%s' conflicts with method of the same name", _tmp176_);
18275 										_tmp178_ = _tmp177_;
18276 										vala_report_warning (_tmp174_, _tmp178_);
18277 										_g_free0 (_tmp178_);
18278 										_g_free0 (_tmp176_);
18279 										_tmp179_ = node;
18280 										_tmp179_->merged = TRUE;
18281 									}
18282 								}
18283 							}
18284 						}
18285 					}
18286 					_vala_code_node_unref0 (sym);
18287 					_vala_gir_parser_node_unref0 (node);
18288 				}
18289 				_vala_iterable_unref0 (_node_list);
18290 			}
18291 			_tmp180_ = m;
18292 			if (!VALA_IS_CREATION_METHOD (_tmp180_)) {
18293 				ValaGirParserMetadata* _tmp181_;
18294 				ValaGirParserMetadata* _tmp184_;
18295 				ValaGirParserMetadata* _tmp187_;
18296 				_tmp181_ = self->metadata;
18297 				if (vala_gir_parser_metadata_has_argument (_tmp181_, VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROYS_INSTANCE)) {
18298 					ValaMethod* _tmp182_;
18299 					ValaGirParserMetadata* _tmp183_;
18300 					_tmp182_ = m;
18301 					_tmp183_ = self->metadata;
18302 					vala_code_node_set_attribute ((ValaCodeNode*) _tmp182_, "DestroysInstance", vala_gir_parser_metadata_get_bool (_tmp183_, VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROYS_INSTANCE, FALSE), NULL);
18303 				}
18304 				_tmp184_ = self->metadata;
18305 				if (vala_gir_parser_metadata_has_argument (_tmp184_, VALA_GIR_PARSER_ARGUMENT_TYPE_RETURNS_MODIFIED_POINTER)) {
18306 					ValaMethod* _tmp185_;
18307 					ValaGirParserMetadata* _tmp186_;
18308 					_tmp185_ = m;
18309 					_tmp186_ = self->metadata;
18310 					vala_code_node_set_attribute ((ValaCodeNode*) _tmp185_, "ReturnsModifiedPointer", vala_gir_parser_metadata_get_bool (_tmp186_, VALA_GIR_PARSER_ARGUMENT_TYPE_RETURNS_MODIFIED_POINTER, FALSE), NULL);
18311 				}
18312 				_tmp187_ = self->metadata;
18313 				if (vala_gir_parser_metadata_has_argument (_tmp187_, VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME)) {
18314 					ValaGirParserNode* vfunc = NULL;
18315 					ValaGirParserNode* _tmp188_;
18316 					ValaGirParserMetadata* _tmp189_;
18317 					gchar* _tmp190_;
18318 					gchar* _tmp191_;
18319 					ValaGirParserNode* _tmp192_;
18320 					ValaGirParserNode* _tmp193_;
18321 					gboolean _tmp194_ = FALSE;
18322 					ValaGirParserNode* _tmp195_;
18323 					_tmp188_ = self->parent;
18324 					_tmp189_ = self->metadata;
18325 					_tmp190_ = vala_gir_parser_metadata_get_string (_tmp189_, VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME);
18326 					_tmp191_ = _tmp190_;
18327 					_tmp192_ = vala_gir_parser_node_lookup (_tmp188_, _tmp191_, FALSE, NULL);
18328 					_tmp193_ = _tmp192_;
18329 					_g_free0 (_tmp191_);
18330 					vfunc = _tmp193_;
18331 					_tmp195_ = vfunc;
18332 					if (_tmp195_ != NULL) {
18333 						ValaGirParserNode* _tmp196_;
18334 						_tmp196_ = vfunc;
18335 						_tmp194_ = _tmp196_ != self;
18336 					} else {
18337 						_tmp194_ = FALSE;
18338 					}
18339 					if (_tmp194_) {
18340 						ValaGirParserNode* _tmp197_;
18341 						ValaGirParserNode* _tmp198_;
18342 						_tmp197_ = vfunc;
18343 						_tmp197_->processed = TRUE;
18344 						_tmp198_ = vfunc;
18345 						_tmp198_->merged = TRUE;
18346 					}
18347 					_vala_gir_parser_node_unref0 (vfunc);
18348 				}
18349 			}
18350 			_tmp199_ = self->metadata;
18351 			if (vala_gir_parser_metadata_has_argument (_tmp199_, VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET)) {
18352 				ValaMethod* _tmp200_;
18353 				ValaGirParserMetadata* _tmp201_;
18354 				_tmp200_ = m;
18355 				_tmp201_ = self->metadata;
18356 				vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp200_, "CCode", "delegate_target", vala_gir_parser_metadata_get_bool (_tmp201_, VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET, FALSE), NULL);
18357 			}
18358 			_tmp202_ = m;
18359 			_tmp203_ = vala_method_get_coroutine (_tmp202_);
18360 			_tmp204_ = _tmp203_;
18361 			if (_tmp204_) {
18362 				vala_gir_parser_process_async_method (parser, self);
18363 			}
18364 			_vala_iterable_unref0 (colliding);
18365 			_vala_code_node_unref0 (m);
18366 		} else {
18367 			ValaSymbol* _tmp205_;
18368 			_tmp205_ = self->symbol;
18369 			if (VALA_IS_PROPERTY (_tmp205_)) {
18370 				ValaArrayList* colliding = NULL;
18371 				ValaGirParserNode* _tmp206_;
18372 				const gchar* _tmp207_;
18373 				ValaArrayList* _tmp208_;
18374 				ValaProperty* prop = NULL;
18375 				ValaSymbol* _tmp232_;
18376 				ValaProperty* _tmp233_;
18377 				gchar* readable = NULL;
18378 				ValaMap* _tmp234_;
18379 				gpointer _tmp235_;
18380 				gchar* writable = NULL;
18381 				ValaMap* _tmp236_;
18382 				gpointer _tmp237_;
18383 				gchar* construct_ = NULL;
18384 				ValaMap* _tmp238_;
18385 				gpointer _tmp239_;
18386 				gchar* construct_only = NULL;
18387 				ValaMap* _tmp240_;
18388 				gpointer _tmp241_;
18389 				const gchar* _tmp242_;
18390 				gboolean _tmp251_ = FALSE;
18391 				const gchar* _tmp252_;
18392 				ValaProperty* _tmp268_;
18393 				ValaDataType* _tmp269_;
18394 				ValaDataType* _tmp270_;
18395 				ValaGirParserNode* getter = NULL;
18396 				ValaArrayList* getters = NULL;
18397 				ValaGirParserNode* _tmp271_;
18398 				const gchar* _tmp272_;
18399 				gchar* _tmp273_;
18400 				gchar* _tmp274_;
18401 				ValaArrayList* _tmp275_;
18402 				ValaArrayList* _tmp276_;
18403 				ValaArrayList* _tmp277_;
18404 				ValaGirParserNode* setter = NULL;
18405 				ValaArrayList* setters = NULL;
18406 				ValaGirParserNode* _tmp302_;
18407 				const gchar* _tmp303_;
18408 				gchar* _tmp304_;
18409 				gchar* _tmp305_;
18410 				ValaArrayList* _tmp306_;
18411 				ValaArrayList* _tmp307_;
18412 				ValaArrayList* _tmp308_;
18413 				gboolean _tmp333_ = FALSE;
18414 				const gchar* _tmp334_;
18415 				ValaProperty* _tmp336_;
18416 				ValaProperty* _tmp337_;
18417 				ValaPropertyAccessor* _tmp338_;
18418 				ValaPropertyAccessor* _tmp339_;
18419 				gboolean _tmp398_ = FALSE;
18420 				gboolean _tmp399_ = FALSE;
18421 				ValaProperty* _tmp400_;
18422 				ValaAttribute* _tmp401_;
18423 				ValaProperty* _tmp466_;
18424 				ValaAttribute* _tmp467_;
18425 				ValaGirParserMetadata* _tmp513_;
18426 				ValaProperty* _tmp516_;
18427 				ValaAttribute* _tmp517_;
18428 				_tmp206_ = self->parent;
18429 				_tmp207_ = self->name;
18430 				_tmp208_ = vala_gir_parser_node_lookup_all (_tmp206_, _tmp207_);
18431 				colliding = _tmp208_;
18432 				{
18433 					ValaArrayList* _node_list = NULL;
18434 					ValaArrayList* _tmp209_;
18435 					ValaArrayList* _tmp210_;
18436 					gint _node_size = 0;
18437 					ValaArrayList* _tmp211_;
18438 					gint _tmp212_;
18439 					gint _tmp213_;
18440 					gint _node_index = 0;
18441 					_tmp209_ = colliding;
18442 					_tmp210_ = _vala_iterable_ref0 (_tmp209_);
18443 					_node_list = _tmp210_;
18444 					_tmp211_ = _node_list;
18445 					_tmp212_ = vala_collection_get_size ((ValaCollection*) _tmp211_);
18446 					_tmp213_ = _tmp212_;
18447 					_node_size = _tmp213_;
18448 					_node_index = -1;
18449 					while (TRUE) {
18450 						gint _tmp214_;
18451 						gint _tmp215_;
18452 						ValaGirParserNode* node = NULL;
18453 						ValaArrayList* _tmp216_;
18454 						gpointer _tmp217_;
18455 						ValaGirParserNode* _tmp218_;
18456 						ValaSymbol* _tmp219_;
18457 						_node_index = _node_index + 1;
18458 						_tmp214_ = _node_index;
18459 						_tmp215_ = _node_size;
18460 						if (!(_tmp214_ < _tmp215_)) {
18461 							break;
18462 						}
18463 						_tmp216_ = _node_list;
18464 						_tmp217_ = vala_list_get ((ValaList*) _tmp216_, _node_index);
18465 						node = (ValaGirParserNode*) _tmp217_;
18466 						_tmp218_ = node;
18467 						_tmp219_ = _tmp218_->symbol;
18468 						if (VALA_IS_SIGNAL (_tmp219_)) {
18469 							ValaGirParserNode* _tmp220_;
18470 							ValaGirParserNode* _tmp221_;
18471 							ValaSymbol* _tmp222_;
18472 							ValaSourceReference* _tmp223_;
18473 							ValaSourceReference* _tmp224_;
18474 							gchar* _tmp225_;
18475 							gchar* _tmp226_;
18476 							gchar* _tmp227_;
18477 							gchar* _tmp228_;
18478 							_tmp220_ = node;
18479 							_tmp220_->processed = TRUE;
18480 							_tmp221_ = node;
18481 							_tmp221_->merged = TRUE;
18482 							_tmp222_ = self->symbol;
18483 							_tmp223_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp222_);
18484 							_tmp224_ = _tmp223_;
18485 							_tmp225_ = vala_gir_parser_node_get_full_name (self);
18486 							_tmp226_ = _tmp225_;
18487 							_tmp227_ = g_strdup_printf ("Signal `%s' conflicts with property of the same name", _tmp226_);
18488 							_tmp228_ = _tmp227_;
18489 							vala_report_warning (_tmp224_, _tmp228_);
18490 							_g_free0 (_tmp228_);
18491 							_g_free0 (_tmp226_);
18492 						} else {
18493 							ValaGirParserNode* _tmp229_;
18494 							ValaSymbol* _tmp230_;
18495 							_tmp229_ = node;
18496 							_tmp230_ = _tmp229_->symbol;
18497 							if (VALA_IS_METHOD (_tmp230_)) {
18498 								ValaGirParserNode* _tmp231_;
18499 								_tmp231_ = node;
18500 								_tmp231_->merged = TRUE;
18501 							}
18502 						}
18503 						_vala_gir_parser_node_unref0 (node);
18504 					}
18505 					_vala_iterable_unref0 (_node_list);
18506 				}
18507 				_tmp232_ = self->symbol;
18508 				_tmp233_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp232_, VALA_TYPE_PROPERTY, ValaProperty));
18509 				prop = _tmp233_;
18510 				_tmp234_ = self->girdata;
18511 				_tmp235_ = vala_map_get (_tmp234_, "readable");
18512 				readable = (gchar*) _tmp235_;
18513 				_tmp236_ = self->girdata;
18514 				_tmp237_ = vala_map_get (_tmp236_, "writable");
18515 				writable = (gchar*) _tmp237_;
18516 				_tmp238_ = self->girdata;
18517 				_tmp239_ = vala_map_get (_tmp238_, "construct");
18518 				construct_ = (gchar*) _tmp239_;
18519 				_tmp240_ = self->girdata;
18520 				_tmp241_ = vala_map_get (_tmp240_, "construct-only");
18521 				construct_only = (gchar*) _tmp241_;
18522 				_tmp242_ = readable;
18523 				if (g_strcmp0 (_tmp242_, "0") != 0) {
18524 					ValaProperty* _tmp243_;
18525 					ValaProperty* _tmp244_;
18526 					ValaDataType* _tmp245_;
18527 					ValaDataType* _tmp246_;
18528 					ValaDataType* _tmp247_;
18529 					ValaDataType* _tmp248_;
18530 					ValaPropertyAccessor* _tmp249_;
18531 					ValaPropertyAccessor* _tmp250_;
18532 					_tmp243_ = prop;
18533 					_tmp244_ = prop;
18534 					_tmp245_ = vala_property_get_property_type (_tmp244_);
18535 					_tmp246_ = _tmp245_;
18536 					_tmp247_ = vala_data_type_copy (_tmp246_);
18537 					_tmp248_ = _tmp247_;
18538 					_tmp249_ = vala_property_accessor_new (TRUE, FALSE, FALSE, _tmp248_, NULL, NULL, NULL);
18539 					_tmp250_ = _tmp249_;
18540 					vala_property_set_get_accessor (_tmp243_, _tmp250_);
18541 					_vala_code_node_unref0 (_tmp250_);
18542 					_vala_code_node_unref0 (_tmp248_);
18543 				}
18544 				_tmp252_ = writable;
18545 				if (g_strcmp0 (_tmp252_, "1") == 0) {
18546 					_tmp251_ = TRUE;
18547 				} else {
18548 					const gchar* _tmp253_;
18549 					_tmp253_ = construct_only;
18550 					_tmp251_ = g_strcmp0 (_tmp253_, "1") == 0;
18551 				}
18552 				if (_tmp251_) {
18553 					gboolean _tmp254_ = FALSE;
18554 					const gchar* _tmp255_;
18555 					gboolean _tmp257_ = FALSE;
18556 					const gchar* _tmp258_;
18557 					ValaProperty* _tmp260_;
18558 					ValaProperty* _tmp261_;
18559 					ValaDataType* _tmp262_;
18560 					ValaDataType* _tmp263_;
18561 					ValaDataType* _tmp264_;
18562 					ValaDataType* _tmp265_;
18563 					ValaPropertyAccessor* _tmp266_;
18564 					ValaPropertyAccessor* _tmp267_;
18565 					_tmp255_ = construct_only;
18566 					if (g_strcmp0 (_tmp255_, "1") != 0) {
18567 						const gchar* _tmp256_;
18568 						_tmp256_ = writable;
18569 						_tmp254_ = g_strcmp0 (_tmp256_, "1") == 0;
18570 					} else {
18571 						_tmp254_ = FALSE;
18572 					}
18573 					_tmp258_ = construct_only;
18574 					if (g_strcmp0 (_tmp258_, "1") == 0) {
18575 						_tmp257_ = TRUE;
18576 					} else {
18577 						const gchar* _tmp259_;
18578 						_tmp259_ = construct_;
18579 						_tmp257_ = g_strcmp0 (_tmp259_, "1") == 0;
18580 					}
18581 					_tmp260_ = prop;
18582 					_tmp261_ = prop;
18583 					_tmp262_ = vala_property_get_property_type (_tmp261_);
18584 					_tmp263_ = _tmp262_;
18585 					_tmp264_ = vala_data_type_copy (_tmp263_);
18586 					_tmp265_ = _tmp264_;
18587 					_tmp266_ = vala_property_accessor_new (FALSE, _tmp254_, _tmp257_, _tmp265_, NULL, NULL, NULL);
18588 					_tmp267_ = _tmp266_;
18589 					vala_property_set_set_accessor (_tmp260_, _tmp267_);
18590 					_vala_code_node_unref0 (_tmp267_);
18591 					_vala_code_node_unref0 (_tmp265_);
18592 				}
18593 				_tmp268_ = prop;
18594 				_tmp269_ = vala_property_get_property_type (_tmp268_);
18595 				_tmp270_ = _tmp269_;
18596 				vala_data_type_set_value_owned (_tmp270_, TRUE);
18597 				getter = NULL;
18598 				_tmp271_ = self->parent;
18599 				_tmp272_ = self->name;
18600 				_tmp273_ = g_strdup_printf ("get_%s", _tmp272_);
18601 				_tmp274_ = _tmp273_;
18602 				_tmp275_ = vala_gir_parser_node_lookup_all (_tmp271_, _tmp274_);
18603 				_tmp276_ = _tmp275_;
18604 				_g_free0 (_tmp274_);
18605 				getters = _tmp276_;
18606 				_tmp277_ = getters;
18607 				if (_tmp277_ != NULL) {
18608 					{
18609 						ValaArrayList* _g_list = NULL;
18610 						ValaArrayList* _tmp278_;
18611 						ValaArrayList* _tmp279_;
18612 						gint _g_size = 0;
18613 						ValaArrayList* _tmp280_;
18614 						gint _tmp281_;
18615 						gint _tmp282_;
18616 						gint _g_index = 0;
18617 						_tmp278_ = getters;
18618 						_tmp279_ = _vala_iterable_ref0 (_tmp278_);
18619 						_g_list = _tmp279_;
18620 						_tmp280_ = _g_list;
18621 						_tmp281_ = vala_collection_get_size ((ValaCollection*) _tmp280_);
18622 						_tmp282_ = _tmp281_;
18623 						_g_size = _tmp282_;
18624 						_g_index = -1;
18625 						while (TRUE) {
18626 							gint _tmp283_;
18627 							gint _tmp284_;
18628 							ValaGirParserNode* g = NULL;
18629 							ValaArrayList* _tmp285_;
18630 							gpointer _tmp286_;
18631 							gboolean _tmp287_ = FALSE;
18632 							gboolean _tmp288_ = FALSE;
18633 							ValaGirParserNode* _tmp289_;
18634 							_g_index = _g_index + 1;
18635 							_tmp283_ = _g_index;
18636 							_tmp284_ = _g_size;
18637 							if (!(_tmp283_ < _tmp284_)) {
18638 								break;
18639 							}
18640 							_tmp285_ = _g_list;
18641 							_tmp286_ = vala_list_get ((ValaList*) _tmp285_, _g_index);
18642 							g = (ValaGirParserNode*) _tmp286_;
18643 							_tmp289_ = getter;
18644 							if (_tmp289_ == NULL) {
18645 								_tmp288_ = TRUE;
18646 							} else {
18647 								ValaGirParserNode* _tmp290_;
18648 								_tmp290_ = g;
18649 								_tmp288_ = !_tmp290_->merged;
18650 							}
18651 							if (_tmp288_) {
18652 								ValaGirParserNode* _tmp291_;
18653 								gchar* _tmp292_;
18654 								gchar* _tmp293_;
18655 								ValaGirParserNode* _tmp294_;
18656 								gchar* _tmp295_;
18657 								gchar* _tmp296_;
18658 								const gchar* _tmp297_;
18659 								gchar* _tmp298_;
18660 								gchar* _tmp299_;
18661 								_tmp291_ = g;
18662 								_tmp292_ = vala_gir_parser_node_get_cname (_tmp291_);
18663 								_tmp293_ = _tmp292_;
18664 								_tmp294_ = self->parent;
18665 								_tmp295_ = vala_gir_parser_node_get_lower_case_cprefix (_tmp294_);
18666 								_tmp296_ = _tmp295_;
18667 								_tmp297_ = self->name;
18668 								_tmp298_ = g_strdup_printf ("%sget_%s", _tmp296_, _tmp297_);
18669 								_tmp299_ = _tmp298_;
18670 								_tmp287_ = g_strcmp0 (_tmp293_, _tmp299_) == 0;
18671 								_g_free0 (_tmp299_);
18672 								_g_free0 (_tmp296_);
18673 								_g_free0 (_tmp293_);
18674 							} else {
18675 								_tmp287_ = FALSE;
18676 							}
18677 							if (_tmp287_) {
18678 								ValaGirParserNode* _tmp300_;
18679 								ValaGirParserNode* _tmp301_;
18680 								_tmp300_ = g;
18681 								_tmp301_ = _vala_gir_parser_node_ref0 (_tmp300_);
18682 								_vala_gir_parser_node_unref0 (getter);
18683 								getter = _tmp301_;
18684 							}
18685 							_vala_gir_parser_node_unref0 (g);
18686 						}
18687 						_vala_iterable_unref0 (_g_list);
18688 					}
18689 				}
18690 				setter = NULL;
18691 				_tmp302_ = self->parent;
18692 				_tmp303_ = self->name;
18693 				_tmp304_ = g_strdup_printf ("set_%s", _tmp303_);
18694 				_tmp305_ = _tmp304_;
18695 				_tmp306_ = vala_gir_parser_node_lookup_all (_tmp302_, _tmp305_);
18696 				_tmp307_ = _tmp306_;
18697 				_g_free0 (_tmp305_);
18698 				setters = _tmp307_;
18699 				_tmp308_ = setters;
18700 				if (_tmp308_ != NULL) {
18701 					{
18702 						ValaArrayList* _s_list = NULL;
18703 						ValaArrayList* _tmp309_;
18704 						ValaArrayList* _tmp310_;
18705 						gint _s_size = 0;
18706 						ValaArrayList* _tmp311_;
18707 						gint _tmp312_;
18708 						gint _tmp313_;
18709 						gint _s_index = 0;
18710 						_tmp309_ = setters;
18711 						_tmp310_ = _vala_iterable_ref0 (_tmp309_);
18712 						_s_list = _tmp310_;
18713 						_tmp311_ = _s_list;
18714 						_tmp312_ = vala_collection_get_size ((ValaCollection*) _tmp311_);
18715 						_tmp313_ = _tmp312_;
18716 						_s_size = _tmp313_;
18717 						_s_index = -1;
18718 						while (TRUE) {
18719 							gint _tmp314_;
18720 							gint _tmp315_;
18721 							ValaGirParserNode* s = NULL;
18722 							ValaArrayList* _tmp316_;
18723 							gpointer _tmp317_;
18724 							gboolean _tmp318_ = FALSE;
18725 							gboolean _tmp319_ = FALSE;
18726 							ValaGirParserNode* _tmp320_;
18727 							_s_index = _s_index + 1;
18728 							_tmp314_ = _s_index;
18729 							_tmp315_ = _s_size;
18730 							if (!(_tmp314_ < _tmp315_)) {
18731 								break;
18732 							}
18733 							_tmp316_ = _s_list;
18734 							_tmp317_ = vala_list_get ((ValaList*) _tmp316_, _s_index);
18735 							s = (ValaGirParserNode*) _tmp317_;
18736 							_tmp320_ = setter;
18737 							if (_tmp320_ == NULL) {
18738 								_tmp319_ = TRUE;
18739 							} else {
18740 								ValaGirParserNode* _tmp321_;
18741 								_tmp321_ = s;
18742 								_tmp319_ = !_tmp321_->merged;
18743 							}
18744 							if (_tmp319_) {
18745 								ValaGirParserNode* _tmp322_;
18746 								gchar* _tmp323_;
18747 								gchar* _tmp324_;
18748 								ValaGirParserNode* _tmp325_;
18749 								gchar* _tmp326_;
18750 								gchar* _tmp327_;
18751 								const gchar* _tmp328_;
18752 								gchar* _tmp329_;
18753 								gchar* _tmp330_;
18754 								_tmp322_ = s;
18755 								_tmp323_ = vala_gir_parser_node_get_cname (_tmp322_);
18756 								_tmp324_ = _tmp323_;
18757 								_tmp325_ = self->parent;
18758 								_tmp326_ = vala_gir_parser_node_get_lower_case_cprefix (_tmp325_);
18759 								_tmp327_ = _tmp326_;
18760 								_tmp328_ = self->name;
18761 								_tmp329_ = g_strdup_printf ("%sset_%s", _tmp327_, _tmp328_);
18762 								_tmp330_ = _tmp329_;
18763 								_tmp318_ = g_strcmp0 (_tmp324_, _tmp330_) == 0;
18764 								_g_free0 (_tmp330_);
18765 								_g_free0 (_tmp327_);
18766 								_g_free0 (_tmp324_);
18767 							} else {
18768 								_tmp318_ = FALSE;
18769 							}
18770 							if (_tmp318_) {
18771 								ValaGirParserNode* _tmp331_;
18772 								ValaGirParserNode* _tmp332_;
18773 								_tmp331_ = s;
18774 								_tmp332_ = _vala_gir_parser_node_ref0 (_tmp331_);
18775 								_vala_gir_parser_node_unref0 (setter);
18776 								setter = _tmp332_;
18777 							}
18778 							_vala_gir_parser_node_unref0 (s);
18779 						}
18780 						_vala_iterable_unref0 (_s_list);
18781 					}
18782 				}
18783 				_tmp334_ = readable;
18784 				if (g_strcmp0 (_tmp334_, "0") == 0) {
18785 					const gchar* _tmp335_;
18786 					_tmp335_ = construct_only;
18787 					_tmp333_ = g_strcmp0 (_tmp335_, "1") == 0;
18788 				} else {
18789 					_tmp333_ = FALSE;
18790 				}
18791 				_tmp336_ = prop;
18792 				vala_code_node_set_attribute ((ValaCodeNode*) _tmp336_, "NoAccessorMethod", _tmp333_, NULL);
18793 				_tmp337_ = prop;
18794 				_tmp338_ = vala_property_get_get_accessor (_tmp337_);
18795 				_tmp339_ = _tmp338_;
18796 				if (_tmp339_ != NULL) {
18797 					ValaMethod* _tmp340_ = NULL;
18798 					ValaGirParserNode* _tmp341_;
18799 					ValaMethod* m = NULL;
18800 					ValaMethod* _tmp344_;
18801 					ValaMethod* _tmp345_;
18802 					_tmp341_ = getter;
18803 					if (_tmp341_ != NULL) {
18804 						ValaGirParserNode* _tmp342_;
18805 						ValaSymbol* _tmp343_;
18806 						_tmp342_ = getter;
18807 						_tmp343_ = _tmp342_->symbol;
18808 						_tmp340_ = VALA_IS_METHOD (_tmp343_) ? ((ValaMethod*) _tmp343_) : NULL;
18809 					} else {
18810 						_tmp340_ = NULL;
18811 					}
18812 					_tmp344_ = _vala_code_node_ref0 (_tmp340_);
18813 					m = _tmp344_;
18814 					_tmp345_ = m;
18815 					if (_tmp345_ != NULL) {
18816 						ValaGirParserNode* _tmp346_;
18817 						gboolean _tmp347_ = FALSE;
18818 						gboolean _tmp348_ = FALSE;
18819 						ValaMethod* _tmp349_;
18820 						ValaDataType* _tmp350_;
18821 						ValaDataType* _tmp351_;
18822 						_tmp346_ = getter;
18823 						vala_gir_parser_node_process (_tmp346_, parser);
18824 						_tmp349_ = m;
18825 						_tmp350_ = vala_callable_get_return_type ((ValaCallable*) _tmp349_);
18826 						_tmp351_ = _tmp350_;
18827 						if (VALA_IS_VOID_TYPE (_tmp351_)) {
18828 							_tmp348_ = TRUE;
18829 						} else {
18830 							ValaMethod* _tmp352_;
18831 							ValaList* _tmp353_;
18832 							gint _tmp354_;
18833 							gint _tmp355_;
18834 							_tmp352_ = m;
18835 							_tmp353_ = vala_callable_get_parameters ((ValaCallable*) _tmp352_);
18836 							_tmp354_ = vala_collection_get_size ((ValaCollection*) _tmp353_);
18837 							_tmp355_ = _tmp354_;
18838 							_tmp348_ = _tmp355_ != 0;
18839 						}
18840 						if (_tmp348_) {
18841 							_tmp347_ = TRUE;
18842 						} else {
18843 							ValaMethod* _tmp356_;
18844 							gboolean _tmp357_;
18845 							gboolean _tmp358_;
18846 							_tmp356_ = m;
18847 							_tmp357_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp356_);
18848 							_tmp358_ = _tmp357_;
18849 							_tmp347_ = _tmp358_;
18850 						}
18851 						if (_tmp347_) {
18852 							ValaProperty* _tmp359_;
18853 							_tmp359_ = prop;
18854 							vala_code_node_set_attribute ((ValaCodeNode*) _tmp359_, "NoAccessorMethod", TRUE, NULL);
18855 						} else {
18856 							ValaGirParserNode* _tmp360_;
18857 							const gchar* _tmp361_;
18858 							const gchar* _tmp362_;
18859 							ValaProperty* _tmp375_;
18860 							ValaPropertyAccessor* _tmp376_;
18861 							ValaPropertyAccessor* _tmp377_;
18862 							ValaDataType* _tmp378_;
18863 							ValaDataType* _tmp379_;
18864 							ValaMethod* _tmp380_;
18865 							ValaDataType* _tmp381_;
18866 							ValaDataType* _tmp382_;
18867 							gboolean _tmp383_;
18868 							gboolean _tmp384_;
18869 							gboolean _tmp385_ = FALSE;
18870 							gboolean _tmp386_ = FALSE;
18871 							ValaMethod* _tmp387_;
18872 							gboolean _tmp388_;
18873 							gboolean _tmp389_;
18874 							_tmp360_ = getter;
18875 							_tmp361_ = _tmp360_->name;
18876 							_tmp362_ = self->name;
18877 							if (g_strcmp0 (_tmp361_, _tmp362_) == 0) {
18878 								{
18879 									ValaArrayList* _node_list = NULL;
18880 									ValaArrayList* _tmp363_;
18881 									ValaArrayList* _tmp364_;
18882 									gint _node_size = 0;
18883 									ValaArrayList* _tmp365_;
18884 									gint _tmp366_;
18885 									gint _tmp367_;
18886 									gint _node_index = 0;
18887 									_tmp363_ = colliding;
18888 									_tmp364_ = _vala_iterable_ref0 (_tmp363_);
18889 									_node_list = _tmp364_;
18890 									_tmp365_ = _node_list;
18891 									_tmp366_ = vala_collection_get_size ((ValaCollection*) _tmp365_);
18892 									_tmp367_ = _tmp366_;
18893 									_node_size = _tmp367_;
18894 									_node_index = -1;
18895 									while (TRUE) {
18896 										gint _tmp368_;
18897 										gint _tmp369_;
18898 										ValaGirParserNode* node = NULL;
18899 										ValaArrayList* _tmp370_;
18900 										gpointer _tmp371_;
18901 										ValaGirParserNode* _tmp372_;
18902 										ValaSymbol* _tmp373_;
18903 										_node_index = _node_index + 1;
18904 										_tmp368_ = _node_index;
18905 										_tmp369_ = _node_size;
18906 										if (!(_tmp368_ < _tmp369_)) {
18907 											break;
18908 										}
18909 										_tmp370_ = _node_list;
18910 										_tmp371_ = vala_list_get ((ValaList*) _tmp370_, _node_index);
18911 										node = (ValaGirParserNode*) _tmp371_;
18912 										_tmp372_ = node;
18913 										_tmp373_ = _tmp372_->symbol;
18914 										if (VALA_IS_METHOD (_tmp373_)) {
18915 											ValaGirParserNode* _tmp374_;
18916 											_tmp374_ = node;
18917 											_tmp374_->merged = TRUE;
18918 										}
18919 										_vala_gir_parser_node_unref0 (node);
18920 									}
18921 									_vala_iterable_unref0 (_node_list);
18922 								}
18923 							}
18924 							_tmp375_ = prop;
18925 							_tmp376_ = vala_property_get_get_accessor (_tmp375_);
18926 							_tmp377_ = _tmp376_;
18927 							_tmp378_ = vala_property_accessor_get_value_type (_tmp377_);
18928 							_tmp379_ = _tmp378_;
18929 							_tmp380_ = m;
18930 							_tmp381_ = vala_callable_get_return_type ((ValaCallable*) _tmp380_);
18931 							_tmp382_ = _tmp381_;
18932 							_tmp383_ = vala_data_type_get_value_owned (_tmp382_);
18933 							_tmp384_ = _tmp383_;
18934 							vala_data_type_set_value_owned (_tmp379_, _tmp384_);
18935 							_tmp387_ = m;
18936 							_tmp388_ = vala_method_get_is_abstract (_tmp387_);
18937 							_tmp389_ = _tmp388_;
18938 							if (!_tmp389_) {
18939 								ValaMethod* _tmp390_;
18940 								gboolean _tmp391_;
18941 								gboolean _tmp392_;
18942 								_tmp390_ = m;
18943 								_tmp391_ = vala_method_get_is_virtual (_tmp390_);
18944 								_tmp392_ = _tmp391_;
18945 								_tmp386_ = !_tmp392_;
18946 							} else {
18947 								_tmp386_ = FALSE;
18948 							}
18949 							if (_tmp386_) {
18950 								ValaProperty* _tmp393_;
18951 								gboolean _tmp394_;
18952 								gboolean _tmp395_;
18953 								_tmp393_ = prop;
18954 								_tmp394_ = vala_property_get_is_abstract (_tmp393_);
18955 								_tmp395_ = _tmp394_;
18956 								_tmp385_ = _tmp395_;
18957 							} else {
18958 								_tmp385_ = FALSE;
18959 							}
18960 							if (_tmp385_) {
18961 								ValaProperty* _tmp396_;
18962 								_tmp396_ = prop;
18963 								vala_code_node_set_attribute ((ValaCodeNode*) _tmp396_, "ConcreteAccessor", TRUE, NULL);
18964 							}
18965 						}
18966 					} else {
18967 						ValaProperty* _tmp397_;
18968 						_tmp397_ = prop;
18969 						vala_code_node_set_attribute ((ValaCodeNode*) _tmp397_, "NoAccessorMethod", TRUE, NULL);
18970 					}
18971 					_vala_code_node_unref0 (m);
18972 				}
18973 				_tmp400_ = prop;
18974 				_tmp401_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp400_, "NoAccessorMethod");
18975 				if (_tmp401_ == NULL) {
18976 					ValaProperty* _tmp402_;
18977 					ValaPropertyAccessor* _tmp403_;
18978 					ValaPropertyAccessor* _tmp404_;
18979 					_tmp402_ = prop;
18980 					_tmp403_ = vala_property_get_set_accessor (_tmp402_);
18981 					_tmp404_ = _tmp403_;
18982 					_tmp399_ = _tmp404_ != NULL;
18983 				} else {
18984 					_tmp399_ = FALSE;
18985 				}
18986 				if (_tmp399_) {
18987 					ValaProperty* _tmp405_;
18988 					ValaPropertyAccessor* _tmp406_;
18989 					ValaPropertyAccessor* _tmp407_;
18990 					gboolean _tmp408_;
18991 					gboolean _tmp409_;
18992 					_tmp405_ = prop;
18993 					_tmp406_ = vala_property_get_set_accessor (_tmp405_);
18994 					_tmp407_ = _tmp406_;
18995 					_tmp408_ = vala_property_accessor_get_writable (_tmp407_);
18996 					_tmp409_ = _tmp408_;
18997 					_tmp398_ = _tmp409_;
18998 				} else {
18999 					_tmp398_ = FALSE;
19000 				}
19001 				if (_tmp398_) {
19002 					ValaMethod* _tmp410_ = NULL;
19003 					ValaGirParserNode* _tmp411_;
19004 					ValaMethod* m = NULL;
19005 					ValaMethod* _tmp414_;
19006 					ValaMethod* _tmp415_;
19007 					_tmp411_ = setter;
19008 					if (_tmp411_ != NULL) {
19009 						ValaGirParserNode* _tmp412_;
19010 						ValaSymbol* _tmp413_;
19011 						_tmp412_ = setter;
19012 						_tmp413_ = _tmp412_->symbol;
19013 						_tmp410_ = VALA_IS_METHOD (_tmp413_) ? ((ValaMethod*) _tmp413_) : NULL;
19014 					} else {
19015 						_tmp410_ = NULL;
19016 					}
19017 					_tmp414_ = _vala_code_node_ref0 (_tmp410_);
19018 					m = _tmp414_;
19019 					_tmp415_ = m;
19020 					if (_tmp415_ != NULL) {
19021 						ValaGirParserNode* _tmp416_;
19022 						gboolean _tmp417_ = FALSE;
19023 						gboolean _tmp418_ = FALSE;
19024 						gboolean _tmp419_ = FALSE;
19025 						ValaMethod* _tmp420_;
19026 						ValaDataType* _tmp421_;
19027 						ValaDataType* _tmp422_;
19028 						_tmp416_ = setter;
19029 						vala_gir_parser_node_process (_tmp416_, parser);
19030 						_tmp420_ = m;
19031 						_tmp421_ = vala_callable_get_return_type ((ValaCallable*) _tmp420_);
19032 						_tmp422_ = _tmp421_;
19033 						if (VALA_IS_VOID_TYPE (_tmp422_)) {
19034 							_tmp419_ = TRUE;
19035 						} else {
19036 							ValaMethod* _tmp423_;
19037 							ValaDataType* _tmp424_;
19038 							ValaDataType* _tmp425_;
19039 							_tmp423_ = m;
19040 							_tmp424_ = vala_callable_get_return_type ((ValaCallable*) _tmp423_);
19041 							_tmp425_ = _tmp424_;
19042 							_tmp419_ = VALA_IS_BOOLEAN_TYPE (_tmp425_);
19043 						}
19044 						if (!_tmp419_) {
19045 							_tmp418_ = TRUE;
19046 						} else {
19047 							ValaMethod* _tmp426_;
19048 							ValaList* _tmp427_;
19049 							gint _tmp428_;
19050 							gint _tmp429_;
19051 							_tmp426_ = m;
19052 							_tmp427_ = vala_callable_get_parameters ((ValaCallable*) _tmp426_);
19053 							_tmp428_ = vala_collection_get_size ((ValaCollection*) _tmp427_);
19054 							_tmp429_ = _tmp428_;
19055 							_tmp418_ = _tmp429_ != 1;
19056 						}
19057 						if (_tmp418_) {
19058 							_tmp417_ = TRUE;
19059 						} else {
19060 							ValaMethod* _tmp430_;
19061 							gboolean _tmp431_;
19062 							gboolean _tmp432_;
19063 							_tmp430_ = m;
19064 							_tmp431_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp430_);
19065 							_tmp432_ = _tmp431_;
19066 							_tmp417_ = _tmp432_;
19067 						}
19068 						if (_tmp417_) {
19069 							ValaProperty* _tmp433_;
19070 							ValaProperty* _tmp434_;
19071 							_tmp433_ = prop;
19072 							vala_code_node_set_attribute ((ValaCodeNode*) _tmp433_, "NoAccessorMethod", TRUE, NULL);
19073 							_tmp434_ = prop;
19074 							vala_code_node_set_attribute ((ValaCodeNode*) _tmp434_, "ConcreteAccessor", FALSE, NULL);
19075 						} else {
19076 							ValaProperty* _tmp435_;
19077 							ValaPropertyAccessor* _tmp436_;
19078 							ValaPropertyAccessor* _tmp437_;
19079 							ValaDataType* _tmp438_;
19080 							ValaDataType* _tmp439_;
19081 							ValaMethod* _tmp440_;
19082 							ValaList* _tmp441_;
19083 							gpointer _tmp442_;
19084 							ValaParameter* _tmp443_;
19085 							ValaDataType* _tmp444_;
19086 							ValaDataType* _tmp445_;
19087 							gboolean _tmp446_;
19088 							gboolean _tmp447_;
19089 							gboolean _tmp448_ = FALSE;
19090 							gboolean _tmp449_ = FALSE;
19091 							gboolean _tmp450_ = FALSE;
19092 							ValaProperty* _tmp451_;
19093 							ValaAttribute* _tmp452_;
19094 							_tmp435_ = prop;
19095 							_tmp436_ = vala_property_get_set_accessor (_tmp435_);
19096 							_tmp437_ = _tmp436_;
19097 							_tmp438_ = vala_property_accessor_get_value_type (_tmp437_);
19098 							_tmp439_ = _tmp438_;
19099 							_tmp440_ = m;
19100 							_tmp441_ = vala_callable_get_parameters ((ValaCallable*) _tmp440_);
19101 							_tmp442_ = vala_list_get (_tmp441_, 0);
19102 							_tmp443_ = (ValaParameter*) _tmp442_;
19103 							_tmp444_ = vala_variable_get_variable_type ((ValaVariable*) _tmp443_);
19104 							_tmp445_ = _tmp444_;
19105 							_tmp446_ = vala_data_type_get_value_owned (_tmp445_);
19106 							_tmp447_ = _tmp446_;
19107 							vala_data_type_set_value_owned (_tmp439_, _tmp447_);
19108 							_vala_code_node_unref0 (_tmp443_);
19109 							_tmp451_ = prop;
19110 							_tmp452_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp451_, "ConcreteAccessor");
19111 							if (_tmp452_ != NULL) {
19112 								ValaMethod* _tmp453_;
19113 								gboolean _tmp454_;
19114 								gboolean _tmp455_;
19115 								_tmp453_ = m;
19116 								_tmp454_ = vala_method_get_is_abstract (_tmp453_);
19117 								_tmp455_ = _tmp454_;
19118 								_tmp450_ = !_tmp455_;
19119 							} else {
19120 								_tmp450_ = FALSE;
19121 							}
19122 							if (_tmp450_) {
19123 								ValaMethod* _tmp456_;
19124 								gboolean _tmp457_;
19125 								gboolean _tmp458_;
19126 								_tmp456_ = m;
19127 								_tmp457_ = vala_method_get_is_virtual (_tmp456_);
19128 								_tmp458_ = _tmp457_;
19129 								_tmp449_ = !_tmp458_;
19130 							} else {
19131 								_tmp449_ = FALSE;
19132 							}
19133 							if (_tmp449_) {
19134 								ValaProperty* _tmp459_;
19135 								gboolean _tmp460_;
19136 								gboolean _tmp461_;
19137 								_tmp459_ = prop;
19138 								_tmp460_ = vala_property_get_is_abstract (_tmp459_);
19139 								_tmp461_ = _tmp460_;
19140 								_tmp448_ = _tmp461_;
19141 							} else {
19142 								_tmp448_ = FALSE;
19143 							}
19144 							if (_tmp448_) {
19145 								ValaProperty* _tmp462_;
19146 								ValaProperty* _tmp463_;
19147 								_tmp462_ = prop;
19148 								vala_code_node_set_attribute ((ValaCodeNode*) _tmp462_, "ConcreteAccessor", TRUE, NULL);
19149 								_tmp463_ = prop;
19150 								vala_code_node_set_attribute ((ValaCodeNode*) _tmp463_, "NoAccessorMethod", FALSE, NULL);
19151 							}
19152 						}
19153 					} else {
19154 						ValaProperty* _tmp464_;
19155 						ValaProperty* _tmp465_;
19156 						_tmp464_ = prop;
19157 						vala_code_node_set_attribute ((ValaCodeNode*) _tmp464_, "NoAccessorMethod", TRUE, NULL);
19158 						_tmp465_ = prop;
19159 						vala_code_node_set_attribute ((ValaCodeNode*) _tmp465_, "ConcreteAccessor", FALSE, NULL);
19160 					}
19161 					_vala_code_node_unref0 (m);
19162 				}
19163 				_tmp466_ = prop;
19164 				_tmp467_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp466_, "NoAccessorMethod");
19165 				if (_tmp467_ != NULL) {
19166 					gboolean _tmp468_ = FALSE;
19167 					ValaProperty* _tmp469_;
19168 					gboolean _tmp470_;
19169 					gboolean _tmp471_;
19170 					_tmp469_ = prop;
19171 					_tmp470_ = vala_property_get_overrides (_tmp469_);
19172 					_tmp471_ = _tmp470_;
19173 					if (!_tmp471_) {
19174 						ValaGirParserNode* _tmp472_;
19175 						ValaSymbol* _tmp473_;
19176 						_tmp472_ = self->parent;
19177 						_tmp473_ = _tmp472_->symbol;
19178 						_tmp468_ = VALA_IS_CLASS (_tmp473_);
19179 					} else {
19180 						_tmp468_ = FALSE;
19181 					}
19182 					if (_tmp468_) {
19183 						ValaGirParserNode* base_prop_node = NULL;
19184 						ValaGirParserNode* _tmp474_;
19185 						ValaGirParserNode* _tmp475_;
19186 						_tmp474_ = vala_gir_parser_base_interface_property (parser, self);
19187 						base_prop_node = _tmp474_;
19188 						_tmp475_ = base_prop_node;
19189 						if (_tmp475_ != NULL) {
19190 							ValaGirParserNode* _tmp476_;
19191 							ValaProperty* base_property = NULL;
19192 							ValaGirParserNode* _tmp477_;
19193 							ValaSymbol* _tmp478_;
19194 							ValaProperty* _tmp479_;
19195 							ValaProperty* _tmp480_;
19196 							ValaAttribute* _tmp481_;
19197 							_tmp476_ = base_prop_node;
19198 							vala_gir_parser_node_process (_tmp476_, parser);
19199 							_tmp477_ = base_prop_node;
19200 							_tmp478_ = _tmp477_->symbol;
19201 							_tmp479_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp478_, VALA_TYPE_PROPERTY, ValaProperty));
19202 							base_property = _tmp479_;
19203 							_tmp480_ = base_property;
19204 							_tmp481_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp480_, "ConcreteAccessor");
19205 							if (_tmp481_ != NULL) {
19206 								ValaProperty* _tmp482_;
19207 								ValaProperty* _tmp483_;
19208 								ValaPropertyAccessor* _tmp484_;
19209 								ValaPropertyAccessor* _tmp485_;
19210 								ValaProperty* _tmp498_;
19211 								ValaPropertyAccessor* _tmp499_;
19212 								ValaPropertyAccessor* _tmp500_;
19213 								_tmp482_ = prop;
19214 								vala_code_node_set_attribute ((ValaCodeNode*) _tmp482_, "NoAccessorMethod", FALSE, NULL);
19215 								_tmp483_ = prop;
19216 								_tmp484_ = vala_property_get_get_accessor (_tmp483_);
19217 								_tmp485_ = _tmp484_;
19218 								if (_tmp485_ != NULL) {
19219 									ValaProperty* _tmp486_;
19220 									ValaPropertyAccessor* _tmp487_;
19221 									ValaPropertyAccessor* _tmp488_;
19222 									ValaDataType* _tmp489_;
19223 									ValaDataType* _tmp490_;
19224 									ValaProperty* _tmp491_;
19225 									ValaPropertyAccessor* _tmp492_;
19226 									ValaPropertyAccessor* _tmp493_;
19227 									ValaDataType* _tmp494_;
19228 									ValaDataType* _tmp495_;
19229 									gboolean _tmp496_;
19230 									gboolean _tmp497_;
19231 									_tmp486_ = prop;
19232 									_tmp487_ = vala_property_get_get_accessor (_tmp486_);
19233 									_tmp488_ = _tmp487_;
19234 									_tmp489_ = vala_property_accessor_get_value_type (_tmp488_);
19235 									_tmp490_ = _tmp489_;
19236 									_tmp491_ = base_property;
19237 									_tmp492_ = vala_property_get_get_accessor (_tmp491_);
19238 									_tmp493_ = _tmp492_;
19239 									_tmp494_ = vala_property_accessor_get_value_type (_tmp493_);
19240 									_tmp495_ = _tmp494_;
19241 									_tmp496_ = vala_data_type_get_value_owned (_tmp495_);
19242 									_tmp497_ = _tmp496_;
19243 									vala_data_type_set_value_owned (_tmp490_, _tmp497_);
19244 								}
19245 								_tmp498_ = prop;
19246 								_tmp499_ = vala_property_get_set_accessor (_tmp498_);
19247 								_tmp500_ = _tmp499_;
19248 								if (_tmp500_ != NULL) {
19249 									ValaProperty* _tmp501_;
19250 									ValaPropertyAccessor* _tmp502_;
19251 									ValaPropertyAccessor* _tmp503_;
19252 									ValaDataType* _tmp504_;
19253 									ValaDataType* _tmp505_;
19254 									ValaProperty* _tmp506_;
19255 									ValaPropertyAccessor* _tmp507_;
19256 									ValaPropertyAccessor* _tmp508_;
19257 									ValaDataType* _tmp509_;
19258 									ValaDataType* _tmp510_;
19259 									gboolean _tmp511_;
19260 									gboolean _tmp512_;
19261 									_tmp501_ = prop;
19262 									_tmp502_ = vala_property_get_set_accessor (_tmp501_);
19263 									_tmp503_ = _tmp502_;
19264 									_tmp504_ = vala_property_accessor_get_value_type (_tmp503_);
19265 									_tmp505_ = _tmp504_;
19266 									_tmp506_ = base_property;
19267 									_tmp507_ = vala_property_get_set_accessor (_tmp506_);
19268 									_tmp508_ = _tmp507_;
19269 									_tmp509_ = vala_property_accessor_get_value_type (_tmp508_);
19270 									_tmp510_ = _tmp509_;
19271 									_tmp511_ = vala_data_type_get_value_owned (_tmp510_);
19272 									_tmp512_ = _tmp511_;
19273 									vala_data_type_set_value_owned (_tmp505_, _tmp512_);
19274 								}
19275 							}
19276 							_vala_code_node_unref0 (base_property);
19277 						}
19278 						_vala_gir_parser_node_unref0 (base_prop_node);
19279 					}
19280 				}
19281 				_tmp513_ = self->metadata;
19282 				if (vala_gir_parser_metadata_has_argument (_tmp513_, VALA_GIR_PARSER_ARGUMENT_TYPE_NO_ACCESSOR_METHOD)) {
19283 					ValaProperty* _tmp514_;
19284 					ValaGirParserMetadata* _tmp515_;
19285 					_tmp514_ = prop;
19286 					_tmp515_ = self->metadata;
19287 					vala_code_node_set_attribute ((ValaCodeNode*) _tmp514_, "NoAccessorMethod", vala_gir_parser_metadata_get_bool (_tmp515_, VALA_GIR_PARSER_ARGUMENT_TYPE_NO_ACCESSOR_METHOD, FALSE), NULL);
19288 				}
19289 				_tmp516_ = prop;
19290 				_tmp517_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp516_, "NoAccessorMethod");
19291 				if (_tmp517_ != NULL) {
19292 					ValaProperty* _tmp518_;
19293 					ValaPropertyAccessor* _tmp519_;
19294 					ValaPropertyAccessor* _tmp520_;
19295 					ValaProperty* _tmp526_;
19296 					ValaPropertyAccessor* _tmp527_;
19297 					ValaPropertyAccessor* _tmp528_;
19298 					_tmp518_ = prop;
19299 					_tmp519_ = vala_property_get_get_accessor (_tmp518_);
19300 					_tmp520_ = _tmp519_;
19301 					if (_tmp520_ != NULL) {
19302 						ValaProperty* _tmp521_;
19303 						ValaPropertyAccessor* _tmp522_;
19304 						ValaPropertyAccessor* _tmp523_;
19305 						ValaDataType* _tmp524_;
19306 						ValaDataType* _tmp525_;
19307 						_tmp521_ = prop;
19308 						_tmp522_ = vala_property_get_get_accessor (_tmp521_);
19309 						_tmp523_ = _tmp522_;
19310 						_tmp524_ = vala_property_accessor_get_value_type (_tmp523_);
19311 						_tmp525_ = _tmp524_;
19312 						vala_data_type_set_value_owned (_tmp525_, TRUE);
19313 					}
19314 					_tmp526_ = prop;
19315 					_tmp527_ = vala_property_get_set_accessor (_tmp526_);
19316 					_tmp528_ = _tmp527_;
19317 					if (_tmp528_ != NULL) {
19318 						ValaProperty* _tmp529_;
19319 						ValaPropertyAccessor* _tmp530_;
19320 						ValaPropertyAccessor* _tmp531_;
19321 						ValaDataType* _tmp532_;
19322 						ValaDataType* _tmp533_;
19323 						_tmp529_ = prop;
19324 						_tmp530_ = vala_property_get_set_accessor (_tmp529_);
19325 						_tmp531_ = _tmp530_;
19326 						_tmp532_ = vala_property_accessor_get_value_type (_tmp531_);
19327 						_tmp533_ = _tmp532_;
19328 						vala_data_type_set_value_owned (_tmp533_, FALSE);
19329 					}
19330 				}
19331 				_vala_iterable_unref0 (setters);
19332 				_vala_gir_parser_node_unref0 (setter);
19333 				_vala_iterable_unref0 (getters);
19334 				_vala_gir_parser_node_unref0 (getter);
19335 				_g_free0 (construct_only);
19336 				_g_free0 (construct_);
19337 				_g_free0 (writable);
19338 				_g_free0 (readable);
19339 				_vala_code_node_unref0 (prop);
19340 				_vala_iterable_unref0 (colliding);
19341 			} else {
19342 				ValaSymbol* _tmp534_;
19343 				_tmp534_ = self->symbol;
19344 				if (VALA_IS_FIELD (_tmp534_)) {
19345 					ValaField* field = NULL;
19346 					ValaSymbol* _tmp535_;
19347 					ValaField* _tmp536_;
19348 					ValaArrayList* colliding = NULL;
19349 					ValaGirParserNode* _tmp537_;
19350 					const gchar* _tmp538_;
19351 					ValaArrayList* _tmp539_;
19352 					ValaArrayList* _tmp540_;
19353 					gint _tmp541_;
19354 					gint _tmp542_;
19355 					ValaGirParserMetadata* _tmp543_;
19356 					ValaGirParserMetadata* _tmp546_;
19357 					ValaGirParserMetadata* _tmp551_;
19358 					gboolean _tmp556_ = FALSE;
19359 					ValaField* _tmp557_;
19360 					ValaDataType* _tmp558_;
19361 					ValaDataType* _tmp559_;
19362 					_tmp535_ = self->symbol;
19363 					_tmp536_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp535_, VALA_TYPE_FIELD, ValaField));
19364 					field = _tmp536_;
19365 					_tmp537_ = self->parent;
19366 					_tmp538_ = self->name;
19367 					_tmp539_ = vala_gir_parser_node_lookup_all (_tmp537_, _tmp538_);
19368 					colliding = _tmp539_;
19369 					_tmp540_ = colliding;
19370 					_tmp541_ = vala_collection_get_size ((ValaCollection*) _tmp540_);
19371 					_tmp542_ = _tmp541_;
19372 					if (_tmp542_ > 1) {
19373 						self->merged = TRUE;
19374 					}
19375 					_tmp543_ = self->metadata;
19376 					if (vala_gir_parser_metadata_has_argument (_tmp543_, VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET)) {
19377 						ValaField* _tmp544_;
19378 						ValaGirParserMetadata* _tmp545_;
19379 						_tmp544_ = field;
19380 						_tmp545_ = self->metadata;
19381 						vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp544_, "CCode", "delegate_target", vala_gir_parser_metadata_get_bool (_tmp545_, VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET, FALSE), NULL);
19382 					}
19383 					_tmp546_ = self->metadata;
19384 					if (vala_gir_parser_metadata_has_argument (_tmp546_, VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET_CNAME)) {
19385 						ValaField* _tmp547_;
19386 						ValaGirParserMetadata* _tmp548_;
19387 						gchar* _tmp549_;
19388 						gchar* _tmp550_;
19389 						_tmp547_ = field;
19390 						_tmp548_ = self->metadata;
19391 						_tmp549_ = vala_gir_parser_metadata_get_string (_tmp548_, VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET_CNAME);
19392 						_tmp550_ = _tmp549_;
19393 						vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp547_, "CCode", "delegate_target_cname", _tmp550_, NULL);
19394 						_g_free0 (_tmp550_);
19395 					}
19396 					_tmp551_ = self->metadata;
19397 					if (vala_gir_parser_metadata_has_argument (_tmp551_, VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROY_NOTIFY_CNAME)) {
19398 						ValaField* _tmp552_;
19399 						ValaGirParserMetadata* _tmp553_;
19400 						gchar* _tmp554_;
19401 						gchar* _tmp555_;
19402 						_tmp552_ = field;
19403 						_tmp553_ = self->metadata;
19404 						_tmp554_ = vala_gir_parser_metadata_get_string (_tmp553_, VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROY_NOTIFY_CNAME);
19405 						_tmp555_ = _tmp554_;
19406 						vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp552_, "CCode", "destroy_notify_cname", _tmp555_, NULL);
19407 						_g_free0 (_tmp555_);
19408 					}
19409 					_tmp557_ = field;
19410 					_tmp558_ = vala_variable_get_variable_type ((ValaVariable*) _tmp557_);
19411 					_tmp559_ = _tmp558_;
19412 					if (VALA_IS_DELEGATE_TYPE (_tmp559_)) {
19413 						ValaGirParserNode* _tmp560_;
19414 						ValaUnresolvedSymbol* _tmp561_;
19415 						_tmp560_ = self->parent;
19416 						_tmp561_ = _tmp560_->gtype_struct_for;
19417 						_tmp556_ = _tmp561_ != NULL;
19418 					} else {
19419 						_tmp556_ = FALSE;
19420 					}
19421 					if (_tmp556_) {
19422 						ValaDelegate* d = NULL;
19423 						ValaField* _tmp562_;
19424 						ValaDataType* _tmp563_;
19425 						ValaDataType* _tmp564_;
19426 						ValaDelegate* _tmp565_;
19427 						ValaDelegate* _tmp566_;
19428 						ValaDelegate* _tmp567_;
19429 						ValaDelegate* _tmp568_;
19430 						ValaGirParserNode* _tmp569_;
19431 						ValaUnresolvedSymbol* _tmp570_;
19432 						_tmp562_ = field;
19433 						_tmp563_ = vala_variable_get_variable_type ((ValaVariable*) _tmp562_);
19434 						_tmp564_ = _tmp563_;
19435 						_tmp565_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp564_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
19436 						_tmp566_ = _tmp565_;
19437 						_tmp567_ = _vala_code_node_ref0 (_tmp566_);
19438 						d = _tmp567_;
19439 						_tmp568_ = d;
19440 						_tmp569_ = self->parent;
19441 						_tmp570_ = _tmp569_->gtype_struct_for;
19442 						vala_gir_parser_process_virtual_method_field (parser, self, _tmp568_, _tmp570_);
19443 						self->merged = TRUE;
19444 						_vala_code_node_unref0 (d);
19445 					} else {
19446 						ValaField* _tmp571_;
19447 						ValaDataType* _tmp572_;
19448 						ValaDataType* _tmp573_;
19449 						_tmp571_ = field;
19450 						_tmp572_ = vala_variable_get_variable_type ((ValaVariable*) _tmp571_);
19451 						_tmp573_ = _tmp572_;
19452 						if (VALA_IS_ARRAY_TYPE (_tmp573_)) {
19453 							ValaGirParserNode* array_length = NULL;
19454 							ValaGirParserMetadata* _tmp574_;
19455 							gboolean _tmp619_ = FALSE;
19456 							ValaGirParserNode* _tmp620_;
19457 							_tmp574_ = self->metadata;
19458 							if (vala_gir_parser_metadata_has_argument (_tmp574_, VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_FIELD)) {
19459 								ValaGirParserNode* _tmp575_;
19460 								ValaGirParserMetadata* _tmp576_;
19461 								gchar* _tmp577_;
19462 								gchar* _tmp578_;
19463 								ValaGirParserNode* _tmp579_;
19464 								_tmp575_ = self->parent;
19465 								_tmp576_ = self->metadata;
19466 								_tmp577_ = vala_gir_parser_metadata_get_string (_tmp576_, VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_FIELD);
19467 								_tmp578_ = _tmp577_;
19468 								_tmp579_ = vala_gir_parser_node_lookup (_tmp575_, _tmp578_, FALSE, NULL);
19469 								_vala_gir_parser_node_unref0 (array_length);
19470 								array_length = _tmp579_;
19471 								_g_free0 (_tmp578_);
19472 							} else {
19473 								gboolean _tmp580_ = FALSE;
19474 								if (self->array_length_idx > -1) {
19475 									ValaGirParserNode* _tmp581_;
19476 									ValaArrayList* _tmp582_;
19477 									gint _tmp583_;
19478 									gint _tmp584_;
19479 									_tmp581_ = self->parent;
19480 									_tmp582_ = _tmp581_->members;
19481 									_tmp583_ = vala_collection_get_size ((ValaCollection*) _tmp582_);
19482 									_tmp584_ = _tmp583_;
19483 									_tmp580_ = _tmp584_ > self->array_length_idx;
19484 								} else {
19485 									_tmp580_ = FALSE;
19486 								}
19487 								if (_tmp580_) {
19488 									ValaGirParserNode* _tmp585_;
19489 									ValaArrayList* _tmp586_;
19490 									gpointer _tmp587_;
19491 									_tmp585_ = self->parent;
19492 									_tmp586_ = _tmp585_->members;
19493 									_tmp587_ = vala_list_get ((ValaList*) _tmp586_, self->array_length_idx);
19494 									_vala_gir_parser_node_unref0 (array_length);
19495 									array_length = (ValaGirParserNode*) _tmp587_;
19496 								} else {
19497 									ValaGirParserNode* _tmp588_;
19498 									ValaField* _tmp589_;
19499 									const gchar* _tmp590_;
19500 									const gchar* _tmp591_;
19501 									gchar* _tmp592_;
19502 									gchar* _tmp593_;
19503 									ValaGirParserNode* _tmp594_;
19504 									ValaGirParserNode* _tmp595_;
19505 									_tmp588_ = self->parent;
19506 									_tmp589_ = field;
19507 									_tmp590_ = vala_symbol_get_name ((ValaSymbol*) _tmp589_);
19508 									_tmp591_ = _tmp590_;
19509 									_tmp592_ = g_strdup_printf ("n_%s", _tmp591_);
19510 									_tmp593_ = _tmp592_;
19511 									_tmp594_ = vala_gir_parser_node_lookup (_tmp588_, _tmp593_, FALSE, NULL);
19512 									_vala_gir_parser_node_unref0 (array_length);
19513 									array_length = _tmp594_;
19514 									_g_free0 (_tmp593_);
19515 									_tmp595_ = array_length;
19516 									if (_tmp595_ == NULL) {
19517 										ValaGirParserNode* _tmp596_;
19518 										ValaField* _tmp597_;
19519 										const gchar* _tmp598_;
19520 										const gchar* _tmp599_;
19521 										gchar* _tmp600_;
19522 										gchar* _tmp601_;
19523 										ValaGirParserNode* _tmp602_;
19524 										ValaGirParserNode* _tmp603_;
19525 										_tmp596_ = self->parent;
19526 										_tmp597_ = field;
19527 										_tmp598_ = vala_symbol_get_name ((ValaSymbol*) _tmp597_);
19528 										_tmp599_ = _tmp598_;
19529 										_tmp600_ = g_strdup_printf ("num_%s", _tmp599_);
19530 										_tmp601_ = _tmp600_;
19531 										_tmp602_ = vala_gir_parser_node_lookup (_tmp596_, _tmp601_, FALSE, NULL);
19532 										_vala_gir_parser_node_unref0 (array_length);
19533 										array_length = _tmp602_;
19534 										_g_free0 (_tmp601_);
19535 										_tmp603_ = array_length;
19536 										if (_tmp603_ == NULL) {
19537 											ValaGirParserNode* _tmp604_;
19538 											ValaField* _tmp605_;
19539 											const gchar* _tmp606_;
19540 											const gchar* _tmp607_;
19541 											gchar* _tmp608_;
19542 											gchar* _tmp609_;
19543 											ValaGirParserNode* _tmp610_;
19544 											ValaGirParserNode* _tmp611_;
19545 											_tmp604_ = self->parent;
19546 											_tmp605_ = field;
19547 											_tmp606_ = vala_symbol_get_name ((ValaSymbol*) _tmp605_);
19548 											_tmp607_ = _tmp606_;
19549 											_tmp608_ = g_strdup_printf ("%s_length", _tmp607_);
19550 											_tmp609_ = _tmp608_;
19551 											_tmp610_ = vala_gir_parser_node_lookup (_tmp604_, _tmp609_, FALSE, NULL);
19552 											_vala_gir_parser_node_unref0 (array_length);
19553 											array_length = _tmp610_;
19554 											_g_free0 (_tmp609_);
19555 											_tmp611_ = array_length;
19556 											if (_tmp611_ == NULL) {
19557 												ValaGirParserNode* _tmp612_;
19558 												ValaField* _tmp613_;
19559 												const gchar* _tmp614_;
19560 												const gchar* _tmp615_;
19561 												gchar* _tmp616_;
19562 												gchar* _tmp617_;
19563 												ValaGirParserNode* _tmp618_;
19564 												_tmp612_ = self->parent;
19565 												_tmp613_ = field;
19566 												_tmp614_ = vala_symbol_get_name ((ValaSymbol*) _tmp613_);
19567 												_tmp615_ = _tmp614_;
19568 												_tmp616_ = g_strdup_printf ("%s_length1", _tmp615_);
19569 												_tmp617_ = _tmp616_;
19570 												_tmp618_ = vala_gir_parser_node_lookup (_tmp612_, _tmp617_, FALSE, NULL);
19571 												_vala_gir_parser_node_unref0 (array_length);
19572 												array_length = _tmp618_;
19573 												_g_free0 (_tmp617_);
19574 											}
19575 										}
19576 									}
19577 								}
19578 							}
19579 							_tmp620_ = array_length;
19580 							if (_tmp620_ != NULL) {
19581 								ValaGirParserNode* _tmp621_;
19582 								ValaSymbol* _tmp622_;
19583 								_tmp621_ = array_length;
19584 								_tmp622_ = _tmp621_->symbol;
19585 								_tmp619_ = VALA_IS_FIELD (_tmp622_);
19586 							} else {
19587 								_tmp619_ = FALSE;
19588 							}
19589 							if (_tmp619_) {
19590 								ValaField* length_field = NULL;
19591 								ValaGirParserNode* _tmp623_;
19592 								ValaSymbol* _tmp624_;
19593 								ValaField* _tmp625_;
19594 								ValaField* _tmp626_;
19595 								ValaField* _tmp627_;
19596 								const gchar* _tmp628_;
19597 								const gchar* _tmp629_;
19598 								gchar* length_type = NULL;
19599 								ValaField* _tmp630_;
19600 								ValaDataType* _tmp631_;
19601 								ValaDataType* _tmp632_;
19602 								gchar* _tmp633_;
19603 								const gchar* _tmp634_;
19604 								ValaField* _tmp643_;
19605 								ValaField* _tmp644_;
19606 								_tmp623_ = array_length;
19607 								_tmp624_ = _tmp623_->symbol;
19608 								_tmp625_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp624_, VALA_TYPE_FIELD, ValaField));
19609 								length_field = _tmp625_;
19610 								_tmp626_ = field;
19611 								_tmp627_ = length_field;
19612 								_tmp628_ = vala_symbol_get_name ((ValaSymbol*) _tmp627_);
19613 								_tmp629_ = _tmp628_;
19614 								vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp626_, "CCode", "array_length_cname", _tmp629_, NULL);
19615 								_tmp630_ = length_field;
19616 								_tmp631_ = vala_variable_get_variable_type ((ValaVariable*) _tmp630_);
19617 								_tmp632_ = _tmp631_;
19618 								_tmp633_ = vala_data_type_to_qualified_string (_tmp632_, NULL);
19619 								length_type = _tmp633_;
19620 								_tmp634_ = length_type;
19621 								if (g_strcmp0 (_tmp634_, "int") != 0) {
19622 									ValaGirParserNode* st = NULL;
19623 									ValaGirParserNode* _tmp635_;
19624 									const gchar* _tmp636_;
19625 									ValaGirParserNode* _tmp637_;
19626 									ValaGirParserNode* _tmp638_;
19627 									_tmp635_ = parser->priv->root;
19628 									_tmp636_ = length_type;
19629 									_tmp637_ = vala_gir_parser_node_lookup (_tmp635_, _tmp636_, FALSE, NULL);
19630 									st = _tmp637_;
19631 									_tmp638_ = st;
19632 									if (_tmp638_ != NULL) {
19633 										ValaField* _tmp639_;
19634 										ValaGirParserNode* _tmp640_;
19635 										gchar* _tmp641_;
19636 										gchar* _tmp642_;
19637 										_tmp639_ = field;
19638 										_tmp640_ = st;
19639 										_tmp641_ = vala_gir_parser_node_get_cname (_tmp640_);
19640 										_tmp642_ = _tmp641_;
19641 										vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp639_, "CCode", "array_length_type", _tmp642_, NULL);
19642 										_g_free0 (_tmp642_);
19643 									}
19644 									_vala_gir_parser_node_unref0 (st);
19645 								}
19646 								_tmp643_ = field;
19647 								vala_code_node_remove_attribute_argument ((ValaCodeNode*) _tmp643_, "CCode", "array_length");
19648 								_tmp644_ = field;
19649 								vala_code_node_remove_attribute_argument ((ValaCodeNode*) _tmp644_, "CCode", "array_null_terminated");
19650 								_g_free0 (length_type);
19651 								_vala_code_node_unref0 (length_field);
19652 							}
19653 							_vala_gir_parser_node_unref0 (array_length);
19654 						}
19655 					}
19656 					_vala_iterable_unref0 (colliding);
19657 					_vala_code_node_unref0 (field);
19658 				} else {
19659 					gboolean _tmp645_ = FALSE;
19660 					ValaSymbol* _tmp646_;
19661 					_tmp646_ = self->symbol;
19662 					if (VALA_IS_SIGNAL (_tmp646_)) {
19663 						_tmp645_ = TRUE;
19664 					} else {
19665 						ValaSymbol* _tmp647_;
19666 						_tmp647_ = self->symbol;
19667 						_tmp645_ = VALA_IS_DELEGATE (_tmp647_);
19668 					}
19669 					if (_tmp645_) {
19670 						vala_gir_parser_process_callable (parser, self);
19671 					} else {
19672 						ValaSymbol* _tmp648_;
19673 						_tmp648_ = self->symbol;
19674 						if (VALA_IS_INTERFACE (_tmp648_)) {
19675 							vala_gir_parser_process_interface (parser, self);
19676 						} else {
19677 							ValaSymbol* _tmp649_;
19678 							_tmp649_ = self->symbol;
19679 							if (VALA_IS_STRUCT (_tmp649_)) {
19680 								gboolean _tmp650_ = FALSE;
19681 								ValaGirParserNode* _tmp651_;
19682 								ValaSymbol* _tmp652_;
19683 								_tmp651_ = self->parent;
19684 								_tmp652_ = _tmp651_->symbol;
19685 								if (VALA_IS_OBJECT_TYPE_SYMBOL (_tmp652_)) {
19686 									_tmp650_ = TRUE;
19687 								} else {
19688 									ValaGirParserNode* _tmp653_;
19689 									ValaSymbol* _tmp654_;
19690 									_tmp653_ = self->parent;
19691 									_tmp654_ = _tmp653_->symbol;
19692 									_tmp650_ = VALA_IS_STRUCT (_tmp654_);
19693 								}
19694 								if (_tmp650_) {
19695 									{
19696 										ValaArrayList* _fn_list = NULL;
19697 										ValaArrayList* _tmp655_;
19698 										ValaArrayList* _tmp656_;
19699 										gint _fn_size = 0;
19700 										ValaArrayList* _tmp657_;
19701 										gint _tmp658_;
19702 										gint _tmp659_;
19703 										gint _fn_index = 0;
19704 										_tmp655_ = self->members;
19705 										_tmp656_ = _vala_iterable_ref0 (_tmp655_);
19706 										_fn_list = _tmp656_;
19707 										_tmp657_ = _fn_list;
19708 										_tmp658_ = vala_collection_get_size ((ValaCollection*) _tmp657_);
19709 										_tmp659_ = _tmp658_;
19710 										_fn_size = _tmp659_;
19711 										_fn_index = -1;
19712 										while (TRUE) {
19713 											gint _tmp660_;
19714 											gint _tmp661_;
19715 											ValaGirParserNode* fn = NULL;
19716 											ValaArrayList* _tmp662_;
19717 											gpointer _tmp663_;
19718 											ValaField* f = NULL;
19719 											ValaGirParserNode* _tmp664_;
19720 											ValaSymbol* _tmp665_;
19721 											ValaField* _tmp666_;
19722 											ValaField* _tmp667_;
19723 											_fn_index = _fn_index + 1;
19724 											_tmp660_ = _fn_index;
19725 											_tmp661_ = _fn_size;
19726 											if (!(_tmp660_ < _tmp661_)) {
19727 												break;
19728 											}
19729 											_tmp662_ = _fn_list;
19730 											_tmp663_ = vala_list_get ((ValaList*) _tmp662_, _fn_index);
19731 											fn = (ValaGirParserNode*) _tmp663_;
19732 											_tmp664_ = fn;
19733 											_tmp665_ = _tmp664_->symbol;
19734 											_tmp666_ = _vala_code_node_ref0 (VALA_IS_FIELD (_tmp665_) ? ((ValaField*) _tmp665_) : NULL);
19735 											f = _tmp666_;
19736 											_tmp667_ = f;
19737 											if (_tmp667_ != NULL) {
19738 												ValaField* _tmp668_;
19739 												ValaMemberBinding _tmp669_;
19740 												ValaMemberBinding _tmp670_;
19741 												ValaField* _tmp678_;
19742 												ValaSymbol* _tmp679_;
19743 												const gchar* _tmp680_;
19744 												const gchar* _tmp681_;
19745 												ValaField* _tmp682_;
19746 												const gchar* _tmp683_;
19747 												const gchar* _tmp684_;
19748 												gchar* _tmp685_;
19749 												gchar* _tmp686_;
19750 												ValaGirParserNode* _tmp687_;
19751 												ValaField* _tmp688_;
19752 												const gchar* _tmp689_;
19753 												const gchar* _tmp690_;
19754 												gchar* _tmp691_;
19755 												ValaGirParserNode* _tmp692_;
19756 												ValaGirParserNode* _tmp693_;
19757 												_tmp668_ = f;
19758 												_tmp669_ = vala_field_get_binding (_tmp668_);
19759 												_tmp670_ = _tmp669_;
19760 												if (_tmp670_ == VALA_MEMBER_BINDING_INSTANCE) {
19761 													ValaField* _tmp671_;
19762 													const gchar* _tmp672_;
19763 													ValaGirParserNode* _tmp673_;
19764 													gchar* _tmp674_;
19765 													gchar* _tmp675_;
19766 													gchar* _tmp676_;
19767 													gchar* _tmp677_;
19768 													_tmp671_ = f;
19769 													_tmp672_ = self->name;
19770 													_tmp673_ = fn;
19771 													_tmp674_ = vala_gir_parser_node_get_cname (_tmp673_);
19772 													_tmp675_ = _tmp674_;
19773 													_tmp676_ = g_strdup_printf ("%s.%s", _tmp672_, _tmp675_);
19774 													_tmp677_ = _tmp676_;
19775 													vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp671_, "CCode", "cname", _tmp677_, NULL);
19776 													_g_free0 (_tmp677_);
19777 													_g_free0 (_tmp675_);
19778 												}
19779 												_tmp678_ = f;
19780 												_tmp679_ = self->symbol;
19781 												_tmp680_ = vala_symbol_get_name (_tmp679_);
19782 												_tmp681_ = _tmp680_;
19783 												_tmp682_ = f;
19784 												_tmp683_ = vala_symbol_get_name ((ValaSymbol*) _tmp682_);
19785 												_tmp684_ = _tmp683_;
19786 												_tmp685_ = g_strdup_printf ("%s_%s", _tmp681_, _tmp684_);
19787 												_tmp686_ = _tmp685_;
19788 												vala_symbol_set_name ((ValaSymbol*) _tmp678_, _tmp686_);
19789 												_g_free0 (_tmp686_);
19790 												_tmp687_ = fn;
19791 												_tmp688_ = f;
19792 												_tmp689_ = vala_symbol_get_name ((ValaSymbol*) _tmp688_);
19793 												_tmp690_ = _tmp689_;
19794 												_tmp691_ = g_strdup (_tmp690_);
19795 												_g_free0 (_tmp687_->name);
19796 												_tmp687_->name = _tmp691_;
19797 												_tmp692_ = self->parent;
19798 												_tmp693_ = fn;
19799 												vala_gir_parser_node_add_member (_tmp692_, _tmp693_);
19800 											}
19801 											_vala_code_node_unref0 (f);
19802 											_vala_gir_parser_node_unref0 (fn);
19803 										}
19804 										_vala_iterable_unref0 (_fn_list);
19805 									}
19806 									self->merged = TRUE;
19807 								} else {
19808 									ValaUnresolvedSymbol* _tmp694_;
19809 									_tmp694_ = self->gtype_struct_for;
19810 									if (_tmp694_ != NULL) {
19811 										ValaGirParserNode* obj = NULL;
19812 										ValaGirParserNode* _tmp695_;
19813 										ValaUnresolvedSymbol* _tmp696_;
19814 										ValaGirParserNode* _tmp697_;
19815 										gboolean _tmp698_ = FALSE;
19816 										gboolean _tmp699_ = FALSE;
19817 										ValaGirParserNode* _tmp700_;
19818 										_tmp695_ = self->parent;
19819 										_tmp696_ = self->gtype_struct_for;
19820 										_tmp697_ = vala_gir_parser_resolve_node (parser, _tmp695_, _tmp696_, FALSE);
19821 										obj = _tmp697_;
19822 										_tmp700_ = obj;
19823 										if (_tmp700_ != NULL) {
19824 											ValaGirParserNode* _tmp701_;
19825 											ValaSymbol* _tmp702_;
19826 											_tmp701_ = obj;
19827 											_tmp702_ = _tmp701_->symbol;
19828 											_tmp699_ = VALA_IS_INTERFACE (_tmp702_);
19829 										} else {
19830 											_tmp699_ = FALSE;
19831 										}
19832 										if (_tmp699_) {
19833 											ValaGirParserNode* _tmp703_;
19834 											gchar* _tmp704_;
19835 											gchar* _tmp705_;
19836 											gchar* _tmp706_;
19837 											gchar* _tmp707_;
19838 											gchar* _tmp708_;
19839 											gchar* _tmp709_;
19840 											_tmp703_ = obj;
19841 											_tmp704_ = vala_gir_parser_node_get_cname (_tmp703_);
19842 											_tmp705_ = _tmp704_;
19843 											_tmp706_ = g_strdup_printf ("%sIface", _tmp705_);
19844 											_tmp707_ = _tmp706_;
19845 											_tmp708_ = vala_gir_parser_node_get_cname (self);
19846 											_tmp709_ = _tmp708_;
19847 											_tmp698_ = g_strcmp0 (_tmp707_, _tmp709_) != 0;
19848 											_g_free0 (_tmp709_);
19849 											_g_free0 (_tmp707_);
19850 											_g_free0 (_tmp705_);
19851 										} else {
19852 											_tmp698_ = FALSE;
19853 										}
19854 										if (_tmp698_) {
19855 											ValaGirParserNode* _tmp710_;
19856 											ValaSymbol* _tmp711_;
19857 											gchar* _tmp712_;
19858 											gchar* _tmp713_;
19859 											_tmp710_ = obj;
19860 											_tmp711_ = _tmp710_->symbol;
19861 											_tmp712_ = vala_gir_parser_node_get_cname (self);
19862 											_tmp713_ = _tmp712_;
19863 											vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp711_, "CCode", "type_cname", _tmp713_, NULL);
19864 											_g_free0 (_tmp713_);
19865 										} else {
19866 											gboolean _tmp714_ = FALSE;
19867 											gboolean _tmp715_ = FALSE;
19868 											ValaGirParserNode* _tmp716_;
19869 											_tmp716_ = obj;
19870 											if (_tmp716_ != NULL) {
19871 												ValaGirParserNode* _tmp717_;
19872 												ValaSymbol* _tmp718_;
19873 												_tmp717_ = obj;
19874 												_tmp718_ = _tmp717_->symbol;
19875 												_tmp715_ = VALA_IS_CLASS (_tmp718_);
19876 											} else {
19877 												_tmp715_ = FALSE;
19878 											}
19879 											if (_tmp715_) {
19880 												ValaGirParserNode* _tmp719_;
19881 												gchar* _tmp720_;
19882 												gchar* _tmp721_;
19883 												gchar* _tmp722_;
19884 												gchar* _tmp723_;
19885 												gchar* _tmp724_;
19886 												gchar* _tmp725_;
19887 												_tmp719_ = obj;
19888 												_tmp720_ = vala_gir_parser_node_get_cname (_tmp719_);
19889 												_tmp721_ = _tmp720_;
19890 												_tmp722_ = g_strdup_printf ("%sClass", _tmp721_);
19891 												_tmp723_ = _tmp722_;
19892 												_tmp724_ = vala_gir_parser_node_get_cname (self);
19893 												_tmp725_ = _tmp724_;
19894 												_tmp714_ = g_strcmp0 (_tmp723_, _tmp725_) != 0;
19895 												_g_free0 (_tmp725_);
19896 												_g_free0 (_tmp723_);
19897 												_g_free0 (_tmp721_);
19898 											} else {
19899 												_tmp714_ = FALSE;
19900 											}
19901 											if (_tmp714_) {
19902 												ValaGirParserNode* _tmp726_;
19903 												ValaSymbol* _tmp727_;
19904 												gchar* _tmp728_;
19905 												gchar* _tmp729_;
19906 												_tmp726_ = obj;
19907 												_tmp727_ = _tmp726_->symbol;
19908 												_tmp728_ = vala_gir_parser_node_get_cname (self);
19909 												_tmp729_ = _tmp728_;
19910 												vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp727_, "CCode", "type_cname", _tmp729_, NULL);
19911 												_g_free0 (_tmp729_);
19912 											}
19913 										}
19914 										self->merged = TRUE;
19915 										_vala_gir_parser_node_unref0 (obj);
19916 									}
19917 								}
19918 							}
19919 						}
19920 					}
19921 				}
19922 			}
19923 		}
19924 		_tmp730_ = self->metadata;
19925 		if (vala_gir_parser_metadata_has_argument (_tmp730_, VALA_GIR_PARSER_ARGUMENT_TYPE_REPLACEMENT)) {
19926 			ValaGirParserMetadata* _tmp731_;
19927 			gchar* _tmp732_;
19928 			self->deprecated = TRUE;
19929 			_tmp731_ = self->metadata;
19930 			_tmp732_ = vala_gir_parser_metadata_get_string (_tmp731_, VALA_GIR_PARSER_ARGUMENT_TYPE_REPLACEMENT);
19931 			_g_free0 (self->deprecated_replacement);
19932 			self->deprecated_replacement = _tmp732_;
19933 		}
19934 		_tmp733_ = self->metadata;
19935 		if (vala_gir_parser_metadata_has_argument (_tmp733_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED_SINCE)) {
19936 			ValaGirParserMetadata* _tmp734_;
19937 			gchar* _tmp735_;
19938 			self->deprecated = TRUE;
19939 			_tmp734_ = self->metadata;
19940 			_tmp735_ = vala_gir_parser_metadata_get_string (_tmp734_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED_SINCE);
19941 			_g_free0 (self->deprecated_since);
19942 			self->deprecated_since = _tmp735_;
19943 		} else {
19944 			ValaMap* _tmp736_;
19945 			gpointer _tmp737_;
19946 			gchar* _tmp738_;
19947 			gboolean _tmp739_;
19948 			_tmp736_ = self->girdata;
19949 			_tmp737_ = vala_map_get (_tmp736_, "deprecated-version");
19950 			_tmp738_ = (gchar*) _tmp737_;
19951 			_tmp739_ = _tmp738_ != NULL;
19952 			_g_free0 (_tmp738_);
19953 			if (_tmp739_) {
19954 				ValaMap* _tmp740_;
19955 				gpointer _tmp741_;
19956 				self->deprecated = TRUE;
19957 				_tmp740_ = self->girdata;
19958 				_tmp741_ = vala_map_get (_tmp740_, "deprecated-version");
19959 				_g_free0 (self->deprecated_since);
19960 				self->deprecated_since = (gchar*) _tmp741_;
19961 			}
19962 		}
19963 		_tmp742_ = self->metadata;
19964 		if (vala_gir_parser_metadata_has_argument (_tmp742_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED)) {
19965 			ValaGirParserMetadata* _tmp743_;
19966 			_tmp743_ = self->metadata;
19967 			self->deprecated = vala_gir_parser_metadata_get_bool (_tmp743_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED, TRUE);
19968 			if (!self->deprecated) {
19969 				_g_free0 (self->deprecated_since);
19970 				self->deprecated_since = NULL;
19971 				_g_free0 (self->deprecated_replacement);
19972 				self->deprecated_replacement = NULL;
19973 			}
19974 		} else {
19975 			ValaMap* _tmp744_;
19976 			gpointer _tmp745_;
19977 			gchar* _tmp746_;
19978 			gboolean _tmp747_;
19979 			_tmp744_ = self->girdata;
19980 			_tmp745_ = vala_map_get (_tmp744_, "deprecated");
19981 			_tmp746_ = (gchar*) _tmp745_;
19982 			_tmp747_ = _tmp746_ != NULL;
19983 			_g_free0 (_tmp746_);
19984 			if (_tmp747_) {
19985 				self->deprecated = TRUE;
19986 			}
19987 		}
19988 		_tmp748_ = self->deprecated_since;
19989 		if (_tmp748_ != NULL) {
19990 			const gchar* _tmp749_;
19991 			_tmp749_ = self->deprecated_since;
19992 			self->deprecated_version = vala_gir_parser_node_parse_version_string (_tmp749_);
19993 		}
19994 		_tmp750_ = self->metadata;
19995 		if (vala_gir_parser_metadata_has_argument (_tmp750_, VALA_GIR_PARSER_ARGUMENT_TYPE_EXPERIMENTAL)) {
19996 			ValaSymbol* _tmp751_;
19997 			ValaGirParserMetadata* _tmp752_;
19998 			_tmp751_ = self->symbol;
19999 			_tmp752_ = self->metadata;
20000 			vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp751_, "Version", "experimental", vala_gir_parser_metadata_get_bool (_tmp752_, VALA_GIR_PARSER_ARGUMENT_TYPE_EXPERIMENTAL, FALSE), NULL);
20001 		}
20002 		_tmp753_ = self->metadata;
20003 		if (vala_gir_parser_metadata_has_argument (_tmp753_, VALA_GIR_PARSER_ARGUMENT_TYPE_SINCE)) {
20004 			ValaSymbol* _tmp754_;
20005 			ValaVersionAttribute* _tmp755_;
20006 			ValaVersionAttribute* _tmp756_;
20007 			ValaGirParserMetadata* _tmp757_;
20008 			gchar* _tmp758_;
20009 			gchar* _tmp759_;
20010 			_tmp754_ = self->symbol;
20011 			_tmp755_ = vala_symbol_get_version (_tmp754_);
20012 			_tmp756_ = _tmp755_;
20013 			_tmp757_ = self->metadata;
20014 			_tmp758_ = vala_gir_parser_metadata_get_string (_tmp757_, VALA_GIR_PARSER_ARGUMENT_TYPE_SINCE);
20015 			_tmp759_ = _tmp758_;
20016 			vala_version_attribute_set_since (_tmp756_, _tmp759_);
20017 			_g_free0 (_tmp759_);
20018 		} else {
20019 			gboolean _tmp760_ = FALSE;
20020 			ValaSymbol* _tmp761_;
20021 			_tmp761_ = self->symbol;
20022 			if (VALA_IS_NAMESPACE (_tmp761_) == FALSE) {
20023 				ValaMap* _tmp762_;
20024 				gpointer _tmp763_;
20025 				gchar* _tmp764_;
20026 				_tmp762_ = self->girdata;
20027 				_tmp763_ = vala_map_get (_tmp762_, "version");
20028 				_tmp764_ = (gchar*) _tmp763_;
20029 				_tmp760_ = _tmp764_ != NULL;
20030 				_g_free0 (_tmp764_);
20031 			} else {
20032 				_tmp760_ = FALSE;
20033 			}
20034 			if (_tmp760_) {
20035 				ValaSymbol* _tmp765_;
20036 				ValaVersionAttribute* _tmp766_;
20037 				ValaVersionAttribute* _tmp767_;
20038 				ValaMap* _tmp768_;
20039 				gpointer _tmp769_;
20040 				gchar* _tmp770_;
20041 				_tmp765_ = self->symbol;
20042 				_tmp766_ = vala_symbol_get_version (_tmp765_);
20043 				_tmp767_ = _tmp766_;
20044 				_tmp768_ = self->girdata;
20045 				_tmp769_ = vala_map_get (_tmp768_, "version");
20046 				_tmp770_ = (gchar*) _tmp769_;
20047 				vala_version_attribute_set_since (_tmp767_, _tmp770_);
20048 				_g_free0 (_tmp770_);
20049 			}
20050 		}
20051 		_tmp771_ = self->parent;
20052 		_tmp772_ = _tmp771_->symbol;
20053 		if (VALA_IS_NAMESPACE (_tmp772_)) {
20054 			ValaSymbol* _tmp773_;
20055 			gchar* _tmp774_;
20056 			gchar* _tmp775_;
20057 			_tmp773_ = self->symbol;
20058 			_tmp774_ = vala_gir_parser_node_get_cheader_filename (self);
20059 			_tmp775_ = _tmp774_;
20060 			vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp773_, "CCode", "cheader_filename", _tmp775_, NULL);
20061 			_g_free0 (_tmp775_);
20062 		} else {
20063 			ValaGirParserMetadata* _tmp776_;
20064 			_tmp776_ = self->metadata;
20065 			if (vala_gir_parser_metadata_has_argument (_tmp776_, VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME)) {
20066 				ValaSymbol* _tmp777_;
20067 				ValaGirParserMetadata* _tmp778_;
20068 				gchar* _tmp779_;
20069 				gchar* _tmp780_;
20070 				_tmp777_ = self->symbol;
20071 				_tmp778_ = self->metadata;
20072 				_tmp779_ = vala_gir_parser_metadata_get_string (_tmp778_, VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME);
20073 				_tmp780_ = _tmp779_;
20074 				vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp777_, "CCode", "cheader_filename", _tmp780_, NULL);
20075 				_g_free0 (_tmp780_);
20076 			}
20077 		}
20078 		_tmp781_ = vala_gir_parser_node_get_cname (self);
20079 		_tmp782_ = _tmp781_;
20080 		_tmp783_ = vala_gir_parser_node_get_default_cname (self);
20081 		_tmp784_ = _tmp783_;
20082 		_tmp785_ = g_strcmp0 (_tmp782_, _tmp784_) != 0;
20083 		_g_free0 (_tmp784_);
20084 		_g_free0 (_tmp782_);
20085 		if (_tmp785_) {
20086 			ValaSymbol* _tmp786_;
20087 			gchar* _tmp787_;
20088 			gchar* _tmp788_;
20089 			_tmp786_ = self->symbol;
20090 			_tmp787_ = vala_gir_parser_node_get_cname (self);
20091 			_tmp788_ = _tmp787_;
20092 			vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp786_, "CCode", "cname", _tmp788_, NULL);
20093 			_g_free0 (_tmp788_);
20094 		}
20095 		_tmp789_ = self->metadata;
20096 		if (vala_gir_parser_metadata_has_argument (_tmp789_, VALA_GIR_PARSER_ARGUMENT_TYPE_FEATURE_TEST_MACRO)) {
20097 			ValaSymbol* _tmp790_;
20098 			ValaGirParserMetadata* _tmp791_;
20099 			gchar* _tmp792_;
20100 			gchar* _tmp793_;
20101 			_tmp790_ = self->symbol;
20102 			_tmp791_ = self->metadata;
20103 			_tmp792_ = vala_gir_parser_metadata_get_string (_tmp791_, VALA_GIR_PARSER_ARGUMENT_TYPE_FEATURE_TEST_MACRO);
20104 			_tmp793_ = _tmp792_;
20105 			vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp790_, "CCode", "feature_test_macro", _tmp793_, NULL);
20106 			_g_free0 (_tmp793_);
20107 		}
20108 		_tmp794_ = vala_gir_parser_node_get_lower_case_cprefix (self);
20109 		_tmp795_ = _tmp794_;
20110 		_tmp796_ = vala_gir_parser_node_get_default_lower_case_cprefix (self);
20111 		_tmp797_ = _tmp796_;
20112 		_tmp798_ = g_strcmp0 (_tmp795_, _tmp797_) != 0;
20113 		_g_free0 (_tmp797_);
20114 		_g_free0 (_tmp795_);
20115 		if (_tmp798_) {
20116 			ValaSymbol* _tmp799_;
20117 			gchar* _tmp800_;
20118 			gchar* _tmp801_;
20119 			_tmp799_ = self->symbol;
20120 			_tmp800_ = vala_gir_parser_node_get_lower_case_cprefix (self);
20121 			_tmp801_ = _tmp800_;
20122 			vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp799_, "CCode", "lower_case_cprefix", _tmp801_, NULL);
20123 			_g_free0 (_tmp801_);
20124 		}
20125 		_tmp802_ = vala_gir_parser_node_get_lower_case_csuffix (self);
20126 		_tmp803_ = _tmp802_;
20127 		_tmp804_ = vala_gir_parser_node_get_default_lower_case_csuffix (self);
20128 		_tmp805_ = _tmp804_;
20129 		_tmp806_ = g_strcmp0 (_tmp803_, _tmp805_) != 0;
20130 		_g_free0 (_tmp805_);
20131 		_g_free0 (_tmp803_);
20132 		if (_tmp806_) {
20133 			ValaSymbol* _tmp807_;
20134 			gchar* _tmp808_;
20135 			gchar* _tmp809_;
20136 			_tmp807_ = self->symbol;
20137 			_tmp808_ = vala_gir_parser_node_get_lower_case_csuffix (self);
20138 			_tmp809_ = _tmp808_;
20139 			vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp807_, "CCode", "lower_case_csuffix", _tmp809_, NULL);
20140 			_g_free0 (_tmp809_);
20141 		}
20142 		_tmp810_ = vala_gir_parser_node_get_gir_name (self);
20143 		gir_name = _tmp810_;
20144 		_tmp811_ = vala_gir_parser_node_get_default_gir_name (self);
20145 		default_gir_name = _tmp811_;
20146 		_tmp814_ = self->symbol;
20147 		if (vala_gir_parser_is_container (_tmp814_)) {
20148 			ValaSymbol* _tmp815_;
20149 			_tmp815_ = self->symbol;
20150 			_tmp813_ = !VALA_IS_NAMESPACE (_tmp815_);
20151 		} else {
20152 			_tmp813_ = FALSE;
20153 		}
20154 		if (_tmp813_) {
20155 			gboolean _tmp816_ = FALSE;
20156 			const gchar* _tmp817_;
20157 			const gchar* _tmp818_;
20158 			_tmp817_ = self->name;
20159 			_tmp818_ = gir_name;
20160 			if (g_strcmp0 (_tmp817_, _tmp818_) != 0) {
20161 				_tmp816_ = TRUE;
20162 			} else {
20163 				const gchar* _tmp819_;
20164 				const gchar* _tmp820_;
20165 				_tmp819_ = gir_name;
20166 				_tmp820_ = default_gir_name;
20167 				_tmp816_ = g_strcmp0 (_tmp819_, _tmp820_) != 0;
20168 			}
20169 			_tmp812_ = _tmp816_;
20170 		} else {
20171 			_tmp812_ = FALSE;
20172 		}
20173 		if (_tmp812_) {
20174 			ValaSymbol* _tmp821_;
20175 			const gchar* _tmp822_;
20176 			_tmp821_ = self->symbol;
20177 			_tmp822_ = gir_name;
20178 			vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp821_, "GIR", "name", _tmp822_, NULL);
20179 		}
20180 		_g_free0 (default_gir_name);
20181 		_g_free0 (gir_name);
20182 	}
20183 	if (self->new_symbol) {
20184 		_tmp824_ = self->merged;
20185 	} else {
20186 		_tmp824_ = FALSE;
20187 	}
20188 	if (!_tmp824_) {
20189 		ValaSymbol* _tmp825_;
20190 		_tmp825_ = self->symbol;
20191 		_tmp823_ = vala_gir_parser_is_container (_tmp825_);
20192 	} else {
20193 		_tmp823_ = FALSE;
20194 	}
20195 	if (_tmp823_) {
20196 		ValaClass* cl = NULL;
20197 		ValaSymbol* _tmp870_;
20198 		ValaClass* _tmp871_;
20199 		gboolean _tmp872_ = FALSE;
20200 		gboolean _tmp873_ = FALSE;
20201 		ValaClass* _tmp874_;
20202 		{
20203 			ValaArrayList* _node_list = NULL;
20204 			ValaArrayList* _tmp826_;
20205 			ValaArrayList* _tmp827_;
20206 			gint _node_size = 0;
20207 			ValaArrayList* _tmp828_;
20208 			gint _tmp829_;
20209 			gint _tmp830_;
20210 			gint _node_index = 0;
20211 			_tmp826_ = self->members;
20212 			_tmp827_ = _vala_iterable_ref0 (_tmp826_);
20213 			_node_list = _tmp827_;
20214 			_tmp828_ = _node_list;
20215 			_tmp829_ = vala_collection_get_size ((ValaCollection*) _tmp828_);
20216 			_tmp830_ = _tmp829_;
20217 			_node_size = _tmp830_;
20218 			_node_index = -1;
20219 			while (TRUE) {
20220 				gint _tmp831_;
20221 				gint _tmp832_;
20222 				ValaGirParserNode* node = NULL;
20223 				ValaArrayList* _tmp833_;
20224 				gpointer _tmp834_;
20225 				gboolean _tmp835_ = FALSE;
20226 				ValaGirParserNode* _tmp841_;
20227 				ValaGirParserNode* _tmp846_;
20228 				const gchar* _tmp847_;
20229 				ValaGirParserNode* _tmp854_;
20230 				const gchar* _tmp855_;
20231 				gboolean _tmp862_ = FALSE;
20232 				gboolean _tmp863_ = FALSE;
20233 				ValaGirParserNode* _tmp864_;
20234 				_node_index = _node_index + 1;
20235 				_tmp831_ = _node_index;
20236 				_tmp832_ = _node_size;
20237 				if (!(_tmp831_ < _tmp832_)) {
20238 					break;
20239 				}
20240 				_tmp833_ = _node_list;
20241 				_tmp834_ = vala_list_get ((ValaList*) _tmp833_, _node_index);
20242 				node = (ValaGirParserNode*) _tmp834_;
20243 				if (self->deprecated_version > ((guint64) 0)) {
20244 					ValaGirParserNode* _tmp836_;
20245 					_tmp836_ = node;
20246 					_tmp835_ = _tmp836_->deprecated_version > ((guint64) 0);
20247 				} else {
20248 					_tmp835_ = FALSE;
20249 				}
20250 				if (_tmp835_) {
20251 					ValaGirParserNode* _tmp837_;
20252 					_tmp837_ = node;
20253 					if (self->deprecated_version <= _tmp837_->deprecated_version) {
20254 						ValaGirParserNode* _tmp838_;
20255 						ValaGirParserNode* _tmp839_;
20256 						ValaGirParserNode* _tmp840_;
20257 						_tmp838_ = node;
20258 						_tmp838_->deprecated = FALSE;
20259 						_tmp839_ = node;
20260 						_g_free0 (_tmp839_->deprecated_since);
20261 						_tmp839_->deprecated_since = NULL;
20262 						_tmp840_ = node;
20263 						_g_free0 (_tmp840_->deprecated_replacement);
20264 						_tmp840_->deprecated_replacement = NULL;
20265 					}
20266 				}
20267 				_tmp841_ = node;
20268 				if (_tmp841_->deprecated) {
20269 					ValaGirParserNode* _tmp842_;
20270 					ValaSymbol* _tmp843_;
20271 					ValaVersionAttribute* _tmp844_;
20272 					ValaVersionAttribute* _tmp845_;
20273 					_tmp842_ = node;
20274 					_tmp843_ = _tmp842_->symbol;
20275 					_tmp844_ = vala_symbol_get_version (_tmp843_);
20276 					_tmp845_ = _tmp844_;
20277 					vala_version_attribute_set_deprecated (_tmp845_, TRUE);
20278 				}
20279 				_tmp846_ = node;
20280 				_tmp847_ = _tmp846_->deprecated_since;
20281 				if (_tmp847_ != NULL) {
20282 					ValaGirParserNode* _tmp848_;
20283 					ValaSymbol* _tmp849_;
20284 					ValaVersionAttribute* _tmp850_;
20285 					ValaVersionAttribute* _tmp851_;
20286 					ValaGirParserNode* _tmp852_;
20287 					const gchar* _tmp853_;
20288 					_tmp848_ = node;
20289 					_tmp849_ = _tmp848_->symbol;
20290 					_tmp850_ = vala_symbol_get_version (_tmp849_);
20291 					_tmp851_ = _tmp850_;
20292 					_tmp852_ = node;
20293 					_tmp853_ = _tmp852_->deprecated_since;
20294 					vala_version_attribute_set_deprecated_since (_tmp851_, _tmp853_);
20295 				}
20296 				_tmp854_ = node;
20297 				_tmp855_ = _tmp854_->deprecated_replacement;
20298 				if (_tmp855_ != NULL) {
20299 					ValaGirParserNode* _tmp856_;
20300 					ValaSymbol* _tmp857_;
20301 					ValaVersionAttribute* _tmp858_;
20302 					ValaVersionAttribute* _tmp859_;
20303 					ValaGirParserNode* _tmp860_;
20304 					const gchar* _tmp861_;
20305 					_tmp856_ = node;
20306 					_tmp857_ = _tmp856_->symbol;
20307 					_tmp858_ = vala_symbol_get_version (_tmp857_);
20308 					_tmp859_ = _tmp858_;
20309 					_tmp860_ = node;
20310 					_tmp861_ = _tmp860_->deprecated_replacement;
20311 					vala_version_attribute_set_replacement (_tmp859_, _tmp861_);
20312 				}
20313 				_tmp864_ = node;
20314 				if (_tmp864_->new_symbol) {
20315 					ValaGirParserNode* _tmp865_;
20316 					_tmp865_ = node;
20317 					_tmp863_ = !_tmp865_->merged;
20318 				} else {
20319 					_tmp863_ = FALSE;
20320 				}
20321 				if (_tmp863_) {
20322 					ValaGirParserMetadata* _tmp866_;
20323 					_tmp866_ = self->metadata;
20324 					_tmp862_ = !vala_gir_parser_metadata_get_bool (_tmp866_, VALA_GIR_PARSER_ARGUMENT_TYPE_HIDDEN, FALSE);
20325 				} else {
20326 					_tmp862_ = FALSE;
20327 				}
20328 				if (_tmp862_) {
20329 					ValaSymbol* _tmp867_;
20330 					ValaGirParserNode* _tmp868_;
20331 					ValaSymbol* _tmp869_;
20332 					_tmp867_ = self->symbol;
20333 					_tmp868_ = node;
20334 					_tmp869_ = _tmp868_->symbol;
20335 					vala_gir_parser_add_symbol_to_container (_tmp867_, _tmp869_);
20336 				}
20337 				_vala_gir_parser_node_unref0 (node);
20338 			}
20339 			_vala_iterable_unref0 (_node_list);
20340 		}
20341 		_tmp870_ = self->symbol;
20342 		_tmp871_ = _vala_code_node_ref0 (VALA_IS_CLASS (_tmp870_) ? ((ValaClass*) _tmp870_) : NULL);
20343 		cl = _tmp871_;
20344 		_tmp874_ = cl;
20345 		if (_tmp874_ != NULL) {
20346 			ValaClass* _tmp875_;
20347 			gboolean _tmp876_;
20348 			gboolean _tmp877_;
20349 			_tmp875_ = cl;
20350 			_tmp876_ = vala_class_get_is_compact (_tmp875_);
20351 			_tmp877_ = _tmp876_;
20352 			_tmp873_ = !_tmp877_;
20353 		} else {
20354 			_tmp873_ = FALSE;
20355 		}
20356 		if (_tmp873_) {
20357 			ValaClass* _tmp878_;
20358 			ValaCreationMethod* _tmp879_;
20359 			ValaCreationMethod* _tmp880_;
20360 			_tmp878_ = cl;
20361 			_tmp879_ = vala_class_get_default_construction_method (_tmp878_);
20362 			_tmp880_ = _tmp879_;
20363 			_tmp872_ = _tmp880_ == NULL;
20364 		} else {
20365 			_tmp872_ = FALSE;
20366 		}
20367 		if (_tmp872_) {
20368 			ValaCreationMethod* cm = NULL;
20369 			ValaClass* _tmp881_;
20370 			ValaSourceReference* _tmp882_;
20371 			ValaSourceReference* _tmp883_;
20372 			ValaCreationMethod* _tmp884_;
20373 			ValaCreationMethod* _tmp885_;
20374 			ValaCreationMethod* _tmp886_;
20375 			ValaClass* _tmp887_;
20376 			ValaCreationMethod* _tmp888_;
20377 			_tmp881_ = cl;
20378 			_tmp882_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp881_);
20379 			_tmp883_ = _tmp882_;
20380 			_tmp884_ = vala_creation_method_new (NULL, NULL, _tmp883_, NULL);
20381 			cm = _tmp884_;
20382 			_tmp885_ = cm;
20383 			vala_method_set_has_construct_function ((ValaMethod*) _tmp885_, FALSE);
20384 			_tmp886_ = cm;
20385 			vala_symbol_set_access ((ValaSymbol*) _tmp886_, VALA_SYMBOL_ACCESSIBILITY_PROTECTED);
20386 			_tmp887_ = cl;
20387 			_tmp888_ = cm;
20388 			vala_symbol_add_method ((ValaSymbol*) _tmp887_, (ValaMethod*) _tmp888_);
20389 			_vala_code_node_unref0 (cm);
20390 		}
20391 		_vala_code_node_unref0 (cl);
20392 	}
20393 	self->processed = TRUE;
20394 }
20395 
20396 static gchar*
vala_gir_parser_node_to_string(ValaGirParserNode * self)20397 vala_gir_parser_node_to_string (ValaGirParserNode* self)
20398 {
20399 	ValaGirParserNode* _tmp0_;
20400 	const gchar* _tmp1_;
20401 	gchar* result = NULL;
20402 	g_return_val_if_fail (self != NULL, NULL);
20403 	_tmp0_ = self->parent;
20404 	_tmp1_ = _tmp0_->name;
20405 	if (_tmp1_ == NULL) {
20406 		const gchar* _tmp2_;
20407 		gchar* _tmp3_;
20408 		_tmp2_ = self->name;
20409 		_tmp3_ = g_strdup (_tmp2_);
20410 		result = _tmp3_;
20411 		return result;
20412 	} else {
20413 		ValaGirParserNode* _tmp4_;
20414 		gchar* _tmp5_;
20415 		gchar* _tmp6_;
20416 		const gchar* _tmp7_;
20417 		gchar* _tmp8_;
20418 		gchar* _tmp9_;
20419 		_tmp4_ = self->parent;
20420 		_tmp5_ = vala_gir_parser_node_to_string (_tmp4_);
20421 		_tmp6_ = _tmp5_;
20422 		_tmp7_ = self->name;
20423 		_tmp8_ = g_strdup_printf ("%s.%s", _tmp6_, _tmp7_);
20424 		_tmp9_ = _tmp8_;
20425 		_g_free0 (_tmp6_);
20426 		result = _tmp9_;
20427 		return result;
20428 	}
20429 }
20430 
20431 static void
vala_gir_parser_value_node_init(GValue * value)20432 vala_gir_parser_value_node_init (GValue* value)
20433 {
20434 	value->data[0].v_pointer = NULL;
20435 }
20436 
20437 static void
vala_gir_parser_value_node_free_value(GValue * value)20438 vala_gir_parser_value_node_free_value (GValue* value)
20439 {
20440 	if (value->data[0].v_pointer) {
20441 		vala_gir_parser_node_unref (value->data[0].v_pointer);
20442 	}
20443 }
20444 
20445 static void
vala_gir_parser_value_node_copy_value(const GValue * src_value,GValue * dest_value)20446 vala_gir_parser_value_node_copy_value (const GValue* src_value,
20447                                        GValue* dest_value)
20448 {
20449 	if (src_value->data[0].v_pointer) {
20450 		dest_value->data[0].v_pointer = vala_gir_parser_node_ref (src_value->data[0].v_pointer);
20451 	} else {
20452 		dest_value->data[0].v_pointer = NULL;
20453 	}
20454 }
20455 
20456 static gpointer
vala_gir_parser_value_node_peek_pointer(const GValue * value)20457 vala_gir_parser_value_node_peek_pointer (const GValue* value)
20458 {
20459 	return value->data[0].v_pointer;
20460 }
20461 
20462 static gchar*
vala_gir_parser_value_node_collect_value(GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)20463 vala_gir_parser_value_node_collect_value (GValue* value,
20464                                           guint n_collect_values,
20465                                           GTypeCValue* collect_values,
20466                                           guint collect_flags)
20467 {
20468 	if (collect_values[0].v_pointer) {
20469 		ValaGirParserNode * object;
20470 		object = collect_values[0].v_pointer;
20471 		if (object->parent_instance.g_class == NULL) {
20472 			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
20473 		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
20474 			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
20475 		}
20476 		value->data[0].v_pointer = vala_gir_parser_node_ref (object);
20477 	} else {
20478 		value->data[0].v_pointer = NULL;
20479 	}
20480 	return NULL;
20481 }
20482 
20483 static gchar*
vala_gir_parser_value_node_lcopy_value(const GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)20484 vala_gir_parser_value_node_lcopy_value (const GValue* value,
20485                                         guint n_collect_values,
20486                                         GTypeCValue* collect_values,
20487                                         guint collect_flags)
20488 {
20489 	ValaGirParserNode ** object_p;
20490 	object_p = collect_values[0].v_pointer;
20491 	if (!object_p) {
20492 		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
20493 	}
20494 	if (!value->data[0].v_pointer) {
20495 		*object_p = NULL;
20496 	} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
20497 		*object_p = value->data[0].v_pointer;
20498 	} else {
20499 		*object_p = vala_gir_parser_node_ref (value->data[0].v_pointer);
20500 	}
20501 	return NULL;
20502 }
20503 
20504 static GParamSpec*
vala_gir_parser_param_spec_node(const gchar * name,const gchar * nick,const gchar * blurb,GType object_type,GParamFlags flags)20505 vala_gir_parser_param_spec_node (const gchar* name,
20506                                  const gchar* nick,
20507                                  const gchar* blurb,
20508                                  GType object_type,
20509                                  GParamFlags flags)
20510 {
20511 	ValaGirParserParamSpecNode* spec;
20512 	g_return_val_if_fail (g_type_is_a (object_type, VALA_GIR_PARSER_TYPE_NODE), NULL);
20513 	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
20514 	G_PARAM_SPEC (spec)->value_type = object_type;
20515 	return G_PARAM_SPEC (spec);
20516 }
20517 
20518 static gpointer
vala_gir_parser_value_get_node(const GValue * value)20519 vala_gir_parser_value_get_node (const GValue* value)
20520 {
20521 	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_GIR_PARSER_TYPE_NODE), NULL);
20522 	return value->data[0].v_pointer;
20523 }
20524 
20525 static void
vala_gir_parser_value_set_node(GValue * value,gpointer v_object)20526 vala_gir_parser_value_set_node (GValue* value,
20527                                 gpointer v_object)
20528 {
20529 	ValaGirParserNode * old;
20530 	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_GIR_PARSER_TYPE_NODE));
20531 	old = value->data[0].v_pointer;
20532 	if (v_object) {
20533 		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_GIR_PARSER_TYPE_NODE));
20534 		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
20535 		value->data[0].v_pointer = v_object;
20536 		vala_gir_parser_node_ref (value->data[0].v_pointer);
20537 	} else {
20538 		value->data[0].v_pointer = NULL;
20539 	}
20540 	if (old) {
20541 		vala_gir_parser_node_unref (old);
20542 	}
20543 }
20544 
20545 static void
vala_gir_parser_value_take_node(GValue * value,gpointer v_object)20546 vala_gir_parser_value_take_node (GValue* value,
20547                                  gpointer v_object)
20548 {
20549 	ValaGirParserNode * old;
20550 	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_GIR_PARSER_TYPE_NODE));
20551 	old = value->data[0].v_pointer;
20552 	if (v_object) {
20553 		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_GIR_PARSER_TYPE_NODE));
20554 		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
20555 		value->data[0].v_pointer = v_object;
20556 	} else {
20557 		value->data[0].v_pointer = NULL;
20558 	}
20559 	if (old) {
20560 		vala_gir_parser_node_unref (old);
20561 	}
20562 }
20563 
20564 static void
vala_gir_parser_node_class_init(ValaGirParserNodeClass * klass,gpointer klass_data)20565 vala_gir_parser_node_class_init (ValaGirParserNodeClass * klass,
20566                                  gpointer klass_data)
20567 {
20568 	GEqualFunc _tmp0_;
20569 	ValaArrayList* _tmp1_;
20570 	vala_gir_parser_node_parent_class = g_type_class_peek_parent (klass);
20571 	((ValaGirParserNodeClass *) klass)->finalize = vala_gir_parser_node_finalize;
20572 	_tmp0_ = g_direct_equal;
20573 	_tmp1_ = vala_array_list_new (VALA_GIR_PARSER_TYPE_NODE, (GBoxedCopyFunc) vala_gir_parser_node_ref, (GDestroyNotify) vala_gir_parser_node_unref, _tmp0_);
20574 	vala_gir_parser_node_new_namespaces = _tmp1_;
20575 }
20576 
20577 static void
vala_gir_parser_node_instance_init(ValaGirParserNode * self,gpointer klass)20578 vala_gir_parser_node_instance_init (ValaGirParserNode * self,
20579                                     gpointer klass)
20580 {
20581 	ValaGirParserMetadata* _tmp0_;
20582 	ValaGirParserMetadata* _tmp1_;
20583 	ValaGirParserMetadata* _tmp2_;
20584 	GEqualFunc _tmp3_;
20585 	ValaArrayList* _tmp4_;
20586 	GHashFunc _tmp5_;
20587 	GEqualFunc _tmp6_;
20588 	GEqualFunc _tmp7_;
20589 	ValaHashMap* _tmp8_;
20590 	self->girdata = NULL;
20591 	_tmp0_ = vala_gir_parser_metadata_get_empty ();
20592 	_tmp1_ = _tmp0_;
20593 	_tmp2_ = _vala_gir_parser_metadata_ref0 (_tmp1_);
20594 	self->metadata = _tmp2_;
20595 	self->source_reference = NULL;
20596 	_tmp3_ = g_direct_equal;
20597 	_tmp4_ = vala_array_list_new (VALA_GIR_PARSER_TYPE_NODE, (GBoxedCopyFunc) vala_gir_parser_node_ref, (GDestroyNotify) vala_gir_parser_node_unref, _tmp3_);
20598 	self->members = _tmp4_;
20599 	_tmp5_ = g_str_hash;
20600 	_tmp6_ = g_str_equal;
20601 	_tmp7_ = g_direct_equal;
20602 	_tmp8_ = vala_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, VALA_TYPE_ARRAY_LIST, (GBoxedCopyFunc) vala_iterable_ref, (GDestroyNotify) vala_iterable_unref, _tmp5_, _tmp6_, _tmp7_);
20603 	self->scope = _tmp8_;
20604 	self->return_array_length_idx = -1;
20605 	self->array_length_idx = -1;
20606 	self->deprecated = FALSE;
20607 	self->deprecated_version = (guint64) 0;
20608 	self->deprecated_since = NULL;
20609 	self->deprecated_replacement = NULL;
20610 	self->ref_count = 1;
20611 }
20612 
20613 static void
vala_gir_parser_node_finalize(ValaGirParserNode * obj)20614 vala_gir_parser_node_finalize (ValaGirParserNode * obj)
20615 {
20616 	ValaGirParserNode * self;
20617 	self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_GIR_PARSER_TYPE_NODE, ValaGirParserNode);
20618 	g_signal_handlers_destroy (self);
20619 	_g_free0 (self->element_type);
20620 	_g_free0 (self->name);
20621 	_vala_map_unref0 (self->girdata);
20622 	_vala_gir_parser_metadata_unref0 (self->metadata);
20623 	_vala_source_reference_unref0 (self->source_reference);
20624 	_vala_iterable_unref0 (self->members);
20625 	_vala_map_unref0 (self->scope);
20626 	_vala_comment_unref0 (self->comment);
20627 	_vala_code_node_unref0 (self->symbol);
20628 	_vala_iterable_unref0 (self->parameters);
20629 	_vala_iterable_unref0 (self->array_length_parameters);
20630 	_vala_iterable_unref0 (self->closure_parameters);
20631 	_vala_iterable_unref0 (self->destroy_parameters);
20632 	_vala_code_node_unref0 (self->gtype_struct_for);
20633 	_vala_code_node_unref0 (self->type_struct);
20634 	_vala_code_node_unref0 (self->base_type);
20635 	_g_free0 (self->deprecated_since);
20636 	_g_free0 (self->deprecated_replacement);
20637 }
20638 
20639 static GType
vala_gir_parser_node_get_type_once(void)20640 vala_gir_parser_node_get_type_once (void)
20641 {
20642 	static const GTypeValueTable g_define_type_value_table = { vala_gir_parser_value_node_init, vala_gir_parser_value_node_free_value, vala_gir_parser_value_node_copy_value, vala_gir_parser_value_node_peek_pointer, "p", vala_gir_parser_value_node_collect_value, "p", vala_gir_parser_value_node_lcopy_value };
20643 	static const GTypeInfo g_define_type_info = { sizeof (ValaGirParserNodeClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_gir_parser_node_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaGirParserNode), 0, (GInstanceInitFunc) vala_gir_parser_node_instance_init, &g_define_type_value_table };
20644 	static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
20645 	GType vala_gir_parser_node_type_id;
20646 	vala_gir_parser_node_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ValaGirParserNode", &g_define_type_info, &g_define_type_fundamental_info, 0);
20647 	return vala_gir_parser_node_type_id;
20648 }
20649 
20650 static GType
vala_gir_parser_node_get_type(void)20651 vala_gir_parser_node_get_type (void)
20652 {
20653 	static volatile gsize vala_gir_parser_node_type_id__volatile = 0;
20654 	if (g_once_init_enter (&vala_gir_parser_node_type_id__volatile)) {
20655 		GType vala_gir_parser_node_type_id;
20656 		vala_gir_parser_node_type_id = vala_gir_parser_node_get_type_once ();
20657 		g_once_init_leave (&vala_gir_parser_node_type_id__volatile, vala_gir_parser_node_type_id);
20658 	}
20659 	return vala_gir_parser_node_type_id__volatile;
20660 }
20661 
20662 static gpointer
vala_gir_parser_node_ref(gpointer instance)20663 vala_gir_parser_node_ref (gpointer instance)
20664 {
20665 	ValaGirParserNode * self;
20666 	self = instance;
20667 	g_atomic_int_inc (&self->ref_count);
20668 	return instance;
20669 }
20670 
20671 static void
vala_gir_parser_node_unref(gpointer instance)20672 vala_gir_parser_node_unref (gpointer instance)
20673 {
20674 	ValaGirParserNode * self;
20675 	self = instance;
20676 	if (g_atomic_int_dec_and_test (&self->ref_count)) {
20677 		VALA_GIR_PARSER_NODE_GET_CLASS (self)->finalize (self);
20678 		g_type_free_instance ((GTypeInstance *) self);
20679 	}
20680 }
20681 
20682 static ValaGirParserParameterInfo*
vala_gir_parser_parameter_info_construct(GType object_type,ValaParameter * param,gint array_length_idx,gint closure_idx,gint destroy_idx,gboolean is_async)20683 vala_gir_parser_parameter_info_construct (GType object_type,
20684                                           ValaParameter* param,
20685                                           gint array_length_idx,
20686                                           gint closure_idx,
20687                                           gint destroy_idx,
20688                                           gboolean is_async)
20689 {
20690 	ValaGirParserParameterInfo* self = NULL;
20691 	ValaParameter* _tmp0_;
20692 	g_return_val_if_fail (param != NULL, NULL);
20693 	self = (ValaGirParserParameterInfo*) g_type_create_instance (object_type);
20694 	_tmp0_ = _vala_code_node_ref0 (param);
20695 	_vala_code_node_unref0 (self->param);
20696 	self->param = _tmp0_;
20697 	self->array_length_idx = array_length_idx;
20698 	self->closure_idx = closure_idx;
20699 	self->destroy_idx = destroy_idx;
20700 	self->vala_idx = 0.0F;
20701 	self->keep = TRUE;
20702 	self->is_async = is_async;
20703 	return self;
20704 }
20705 
20706 static ValaGirParserParameterInfo*
vala_gir_parser_parameter_info_new(ValaParameter * param,gint array_length_idx,gint closure_idx,gint destroy_idx,gboolean is_async)20707 vala_gir_parser_parameter_info_new (ValaParameter* param,
20708                                     gint array_length_idx,
20709                                     gint closure_idx,
20710                                     gint destroy_idx,
20711                                     gboolean is_async)
20712 {
20713 	return vala_gir_parser_parameter_info_construct (VALA_GIR_PARSER_TYPE_PARAMETER_INFO, param, array_length_idx, closure_idx, destroy_idx, is_async);
20714 }
20715 
20716 static void
vala_gir_parser_value_parameter_info_init(GValue * value)20717 vala_gir_parser_value_parameter_info_init (GValue* value)
20718 {
20719 	value->data[0].v_pointer = NULL;
20720 }
20721 
20722 static void
vala_gir_parser_value_parameter_info_free_value(GValue * value)20723 vala_gir_parser_value_parameter_info_free_value (GValue* value)
20724 {
20725 	if (value->data[0].v_pointer) {
20726 		vala_gir_parser_parameter_info_unref (value->data[0].v_pointer);
20727 	}
20728 }
20729 
20730 static void
vala_gir_parser_value_parameter_info_copy_value(const GValue * src_value,GValue * dest_value)20731 vala_gir_parser_value_parameter_info_copy_value (const GValue* src_value,
20732                                                  GValue* dest_value)
20733 {
20734 	if (src_value->data[0].v_pointer) {
20735 		dest_value->data[0].v_pointer = vala_gir_parser_parameter_info_ref (src_value->data[0].v_pointer);
20736 	} else {
20737 		dest_value->data[0].v_pointer = NULL;
20738 	}
20739 }
20740 
20741 static gpointer
vala_gir_parser_value_parameter_info_peek_pointer(const GValue * value)20742 vala_gir_parser_value_parameter_info_peek_pointer (const GValue* value)
20743 {
20744 	return value->data[0].v_pointer;
20745 }
20746 
20747 static gchar*
vala_gir_parser_value_parameter_info_collect_value(GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)20748 vala_gir_parser_value_parameter_info_collect_value (GValue* value,
20749                                                     guint n_collect_values,
20750                                                     GTypeCValue* collect_values,
20751                                                     guint collect_flags)
20752 {
20753 	if (collect_values[0].v_pointer) {
20754 		ValaGirParserParameterInfo * object;
20755 		object = collect_values[0].v_pointer;
20756 		if (object->parent_instance.g_class == NULL) {
20757 			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
20758 		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
20759 			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
20760 		}
20761 		value->data[0].v_pointer = vala_gir_parser_parameter_info_ref (object);
20762 	} else {
20763 		value->data[0].v_pointer = NULL;
20764 	}
20765 	return NULL;
20766 }
20767 
20768 static gchar*
vala_gir_parser_value_parameter_info_lcopy_value(const GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)20769 vala_gir_parser_value_parameter_info_lcopy_value (const GValue* value,
20770                                                   guint n_collect_values,
20771                                                   GTypeCValue* collect_values,
20772                                                   guint collect_flags)
20773 {
20774 	ValaGirParserParameterInfo ** object_p;
20775 	object_p = collect_values[0].v_pointer;
20776 	if (!object_p) {
20777 		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
20778 	}
20779 	if (!value->data[0].v_pointer) {
20780 		*object_p = NULL;
20781 	} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
20782 		*object_p = value->data[0].v_pointer;
20783 	} else {
20784 		*object_p = vala_gir_parser_parameter_info_ref (value->data[0].v_pointer);
20785 	}
20786 	return NULL;
20787 }
20788 
20789 static GParamSpec*
vala_gir_parser_param_spec_parameter_info(const gchar * name,const gchar * nick,const gchar * blurb,GType object_type,GParamFlags flags)20790 vala_gir_parser_param_spec_parameter_info (const gchar* name,
20791                                            const gchar* nick,
20792                                            const gchar* blurb,
20793                                            GType object_type,
20794                                            GParamFlags flags)
20795 {
20796 	ValaGirParserParamSpecParameterInfo* spec;
20797 	g_return_val_if_fail (g_type_is_a (object_type, VALA_GIR_PARSER_TYPE_PARAMETER_INFO), NULL);
20798 	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
20799 	G_PARAM_SPEC (spec)->value_type = object_type;
20800 	return G_PARAM_SPEC (spec);
20801 }
20802 
20803 static gpointer
vala_gir_parser_value_get_parameter_info(const GValue * value)20804 vala_gir_parser_value_get_parameter_info (const GValue* value)
20805 {
20806 	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_GIR_PARSER_TYPE_PARAMETER_INFO), NULL);
20807 	return value->data[0].v_pointer;
20808 }
20809 
20810 static void
vala_gir_parser_value_set_parameter_info(GValue * value,gpointer v_object)20811 vala_gir_parser_value_set_parameter_info (GValue* value,
20812                                           gpointer v_object)
20813 {
20814 	ValaGirParserParameterInfo * old;
20815 	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_GIR_PARSER_TYPE_PARAMETER_INFO));
20816 	old = value->data[0].v_pointer;
20817 	if (v_object) {
20818 		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_GIR_PARSER_TYPE_PARAMETER_INFO));
20819 		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
20820 		value->data[0].v_pointer = v_object;
20821 		vala_gir_parser_parameter_info_ref (value->data[0].v_pointer);
20822 	} else {
20823 		value->data[0].v_pointer = NULL;
20824 	}
20825 	if (old) {
20826 		vala_gir_parser_parameter_info_unref (old);
20827 	}
20828 }
20829 
20830 static void
vala_gir_parser_value_take_parameter_info(GValue * value,gpointer v_object)20831 vala_gir_parser_value_take_parameter_info (GValue* value,
20832                                            gpointer v_object)
20833 {
20834 	ValaGirParserParameterInfo * old;
20835 	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_GIR_PARSER_TYPE_PARAMETER_INFO));
20836 	old = value->data[0].v_pointer;
20837 	if (v_object) {
20838 		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_GIR_PARSER_TYPE_PARAMETER_INFO));
20839 		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
20840 		value->data[0].v_pointer = v_object;
20841 	} else {
20842 		value->data[0].v_pointer = NULL;
20843 	}
20844 	if (old) {
20845 		vala_gir_parser_parameter_info_unref (old);
20846 	}
20847 }
20848 
20849 static void
vala_gir_parser_parameter_info_class_init(ValaGirParserParameterInfoClass * klass,gpointer klass_data)20850 vala_gir_parser_parameter_info_class_init (ValaGirParserParameterInfoClass * klass,
20851                                            gpointer klass_data)
20852 {
20853 	vala_gir_parser_parameter_info_parent_class = g_type_class_peek_parent (klass);
20854 	((ValaGirParserParameterInfoClass *) klass)->finalize = vala_gir_parser_parameter_info_finalize;
20855 }
20856 
20857 static void
vala_gir_parser_parameter_info_instance_init(ValaGirParserParameterInfo * self,gpointer klass)20858 vala_gir_parser_parameter_info_instance_init (ValaGirParserParameterInfo * self,
20859                                               gpointer klass)
20860 {
20861 	self->ref_count = 1;
20862 }
20863 
20864 static void
vala_gir_parser_parameter_info_finalize(ValaGirParserParameterInfo * obj)20865 vala_gir_parser_parameter_info_finalize (ValaGirParserParameterInfo * obj)
20866 {
20867 	ValaGirParserParameterInfo * self;
20868 	self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_GIR_PARSER_TYPE_PARAMETER_INFO, ValaGirParserParameterInfo);
20869 	g_signal_handlers_destroy (self);
20870 	_vala_code_node_unref0 (self->param);
20871 }
20872 
20873 static GType
vala_gir_parser_parameter_info_get_type_once(void)20874 vala_gir_parser_parameter_info_get_type_once (void)
20875 {
20876 	static const GTypeValueTable g_define_type_value_table = { vala_gir_parser_value_parameter_info_init, vala_gir_parser_value_parameter_info_free_value, vala_gir_parser_value_parameter_info_copy_value, vala_gir_parser_value_parameter_info_peek_pointer, "p", vala_gir_parser_value_parameter_info_collect_value, "p", vala_gir_parser_value_parameter_info_lcopy_value };
20877 	static const GTypeInfo g_define_type_info = { sizeof (ValaGirParserParameterInfoClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_gir_parser_parameter_info_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaGirParserParameterInfo), 0, (GInstanceInitFunc) vala_gir_parser_parameter_info_instance_init, &g_define_type_value_table };
20878 	static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
20879 	GType vala_gir_parser_parameter_info_type_id;
20880 	vala_gir_parser_parameter_info_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ValaGirParserParameterInfo", &g_define_type_info, &g_define_type_fundamental_info, 0);
20881 	return vala_gir_parser_parameter_info_type_id;
20882 }
20883 
20884 static GType
vala_gir_parser_parameter_info_get_type(void)20885 vala_gir_parser_parameter_info_get_type (void)
20886 {
20887 	static volatile gsize vala_gir_parser_parameter_info_type_id__volatile = 0;
20888 	if (g_once_init_enter (&vala_gir_parser_parameter_info_type_id__volatile)) {
20889 		GType vala_gir_parser_parameter_info_type_id;
20890 		vala_gir_parser_parameter_info_type_id = vala_gir_parser_parameter_info_get_type_once ();
20891 		g_once_init_leave (&vala_gir_parser_parameter_info_type_id__volatile, vala_gir_parser_parameter_info_type_id);
20892 	}
20893 	return vala_gir_parser_parameter_info_type_id__volatile;
20894 }
20895 
20896 static gpointer
vala_gir_parser_parameter_info_ref(gpointer instance)20897 vala_gir_parser_parameter_info_ref (gpointer instance)
20898 {
20899 	ValaGirParserParameterInfo * self;
20900 	self = instance;
20901 	g_atomic_int_inc (&self->ref_count);
20902 	return instance;
20903 }
20904 
20905 static void
vala_gir_parser_parameter_info_unref(gpointer instance)20906 vala_gir_parser_parameter_info_unref (gpointer instance)
20907 {
20908 	ValaGirParserParameterInfo * self;
20909 	self = instance;
20910 	if (g_atomic_int_dec_and_test (&self->ref_count)) {
20911 		VALA_GIR_PARSER_PARAMETER_INFO_GET_CLASS (self)->finalize (self);
20912 		g_type_free_instance ((GTypeInstance *) self);
20913 	}
20914 }
20915 
20916 static void
vala_gir_parser_class_init(ValaGirParserClass * klass,gpointer klass_data)20917 vala_gir_parser_class_init (ValaGirParserClass * klass,
20918                             gpointer klass_data)
20919 {
20920 	vala_gir_parser_parent_class = g_type_class_peek_parent (klass);
20921 	((ValaCodeVisitorClass *) klass)->finalize = vala_gir_parser_finalize;
20922 	g_type_class_adjust_private_offset (klass, &ValaGirParser_private_offset);
20923 	((ValaCodeVisitorClass *) klass)->visit_source_file = (void (*) (ValaCodeVisitor*, ValaSourceFile*)) vala_gir_parser_real_visit_source_file;
20924 }
20925 
20926 static void
vala_gir_parser_instance_init(ValaGirParser * self,gpointer klass)20927 vala_gir_parser_instance_init (ValaGirParser * self,
20928                                gpointer klass)
20929 {
20930 	GEqualFunc _tmp0_;
20931 	ValaArrayList* _tmp1_;
20932 	GHashFunc _tmp2_;
20933 	GEqualFunc _tmp3_;
20934 	ValaHashSet* _tmp4_;
20935 	GEqualFunc _tmp5_;
20936 	ValaHashMap* _tmp6_;
20937 	GEqualFunc _tmp7_;
20938 	ValaArrayList* _tmp8_;
20939 	GHashFunc _tmp9_;
20940 	GEqualFunc _tmp10_;
20941 	GEqualFunc _tmp11_;
20942 	ValaHashMap* _tmp12_;
20943 	GEqualFunc _tmp13_;
20944 	ValaArrayList* _tmp14_;
20945 	self->priv = vala_gir_parser_get_instance_private (self);
20946 	_tmp0_ = g_direct_equal;
20947 	_tmp1_ = vala_array_list_new (VALA_GIR_PARSER_TYPE_METADATA, (GBoxedCopyFunc) vala_gir_parser_metadata_ref, (GDestroyNotify) vala_gir_parser_metadata_unref, _tmp0_);
20948 	self->priv->metadata_roots = _tmp1_;
20949 	_tmp2_ = g_str_hash;
20950 	_tmp3_ = g_str_equal;
20951 	_tmp4_ = vala_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, _tmp2_, _tmp3_);
20952 	self->priv->provided_namespaces = (ValaSet*) _tmp4_;
20953 	_tmp5_ = g_direct_equal;
20954 	_tmp6_ = vala_hash_map_new (VALA_TYPE_UNRESOLVED_SYMBOL, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, VALA_TYPE_SYMBOL, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _vala_gir_parser_unresolved_symbol_hash_ghash_func, _vala_gir_parser_unresolved_symbol_equal_gequal_func, _tmp5_);
20955 	self->priv->unresolved_symbols_map = _tmp6_;
20956 	_tmp7_ = g_direct_equal;
20957 	_tmp8_ = vala_array_list_new (VALA_TYPE_UNRESOLVED_SYMBOL, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp7_);
20958 	self->priv->unresolved_gir_symbols = _tmp8_;
20959 	_tmp9_ = g_direct_hash;
20960 	_tmp10_ = g_direct_equal;
20961 	_tmp11_ = g_direct_equal;
20962 	_tmp12_ = vala_hash_map_new (VALA_TYPE_UNRESOLVED_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, VALA_GIR_PARSER_TYPE_NODE, (GBoxedCopyFunc) vala_gir_parser_node_ref, (GDestroyNotify) vala_gir_parser_node_unref, _tmp9_, _tmp10_, _tmp11_);
20963 	self->priv->unresolved_type_arguments = _tmp12_;
20964 	_tmp13_ = g_direct_equal;
20965 	_tmp14_ = vala_array_list_new (VALA_TYPE_INTERFACE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp13_);
20966 	self->priv->ifaces_needing_object_prereq = _tmp14_;
20967 }
20968 
20969 static void
vala_gir_parser_finalize(ValaCodeVisitor * obj)20970 vala_gir_parser_finalize (ValaCodeVisitor * obj)
20971 {
20972 	ValaGirParser * self;
20973 	self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_GIR_PARSER, ValaGirParser);
20974 	_vala_markup_reader_unref0 (self->priv->reader);
20975 	_vala_code_context_unref0 (self->priv->context);
20976 	_vala_source_file_unref0 (self->priv->current_source_file);
20977 	_vala_gir_parser_node_unref0 (self->priv->root);
20978 	_vala_iterable_unref0 (self->priv->metadata_roots);
20979 	self->priv->cheader_filenames = (_vala_array_free (self->priv->cheader_filenames, self->priv->cheader_filenames_length1, (GDestroyNotify) g_free), NULL);
20980 	_vala_iterable_unref0 (self->priv->metadata_stack);
20981 	_vala_gir_parser_metadata_unref0 (self->priv->metadata);
20982 	_vala_iterable_unref0 (self->priv->tree_stack);
20983 	_vala_gir_parser_node_unref0 (self->priv->current);
20984 	_vala_gir_parser_node_unref0 (self->priv->old_current);
20985 	_vala_iterable_unref0 (self->priv->provided_namespaces);
20986 	_vala_map_unref0 (self->priv->unresolved_symbols_map);
20987 	_vala_iterable_unref0 (self->priv->unresolved_gir_symbols);
20988 	_vala_map_unref0 (self->priv->unresolved_type_arguments);
20989 	_vala_iterable_unref0 (self->priv->ifaces_needing_object_prereq);
20990 	VALA_CODE_VISITOR_CLASS (vala_gir_parser_parent_class)->finalize (obj);
20991 }
20992 
20993 /**
20994  * Code visitor parsing all GIR source files.
20995  *
20996  * Pipeline:
20997  * 1) Parse metadata
20998  * 2) Parse GIR with metadata, track unresolved GIR symbols, create Vala symbols
20999  * 3) Reconciliate the tree by mapping tracked symbols
21000  * 4) Process the tree
21001  */
21002 static GType
vala_gir_parser_get_type_once(void)21003 vala_gir_parser_get_type_once (void)
21004 {
21005 	static const GTypeInfo g_define_type_info = { sizeof (ValaGirParserClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_gir_parser_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaGirParser), 0, (GInstanceInitFunc) vala_gir_parser_instance_init, NULL };
21006 	GType vala_gir_parser_type_id;
21007 	vala_gir_parser_type_id = g_type_register_static (VALA_TYPE_CODE_VISITOR, "ValaGirParser", &g_define_type_info, 0);
21008 	ValaGirParser_private_offset = g_type_add_instance_private (vala_gir_parser_type_id, sizeof (ValaGirParserPrivate));
21009 	return vala_gir_parser_type_id;
21010 }
21011 
21012 GType
vala_gir_parser_get_type(void)21013 vala_gir_parser_get_type (void)
21014 {
21015 	static volatile gsize vala_gir_parser_type_id__volatile = 0;
21016 	if (g_once_init_enter (&vala_gir_parser_type_id__volatile)) {
21017 		GType vala_gir_parser_type_id;
21018 		vala_gir_parser_type_id = vala_gir_parser_get_type_once ();
21019 		g_once_init_leave (&vala_gir_parser_type_id__volatile, vala_gir_parser_type_id);
21020 	}
21021 	return vala_gir_parser_type_id__volatile;
21022 }
21023 
21024 static void
_vala_array_destroy(gpointer array,gint array_length,GDestroyNotify destroy_func)21025 _vala_array_destroy (gpointer array,
21026                      gint array_length,
21027                      GDestroyNotify destroy_func)
21028 {
21029 	if ((array != NULL) && (destroy_func != NULL)) {
21030 		gint i;
21031 		for (i = 0; i < array_length; i = i + 1) {
21032 			if (((gpointer*) array)[i] != NULL) {
21033 				destroy_func (((gpointer*) array)[i]);
21034 			}
21035 		}
21036 	}
21037 }
21038 
21039 static void
_vala_array_free(gpointer array,gint array_length,GDestroyNotify destroy_func)21040 _vala_array_free (gpointer array,
21041                   gint array_length,
21042                   GDestroyNotify destroy_func)
21043 {
21044 	_vala_array_destroy (array, array_length, destroy_func);
21045 	g_free (array);
21046 }
21047 
21048 static gint
_vala_array_length(gpointer array)21049 _vala_array_length (gpointer array)
21050 {
21051 	gint length;
21052 	length = 0;
21053 	if (array) {
21054 		while (((gpointer*) array)[length]) {
21055 			length++;
21056 		}
21057 	}
21058 	return length;
21059 }
21060 
21061