← Back to branch summary

~ubuntu-branches/ubuntu/maverick/vala/maverick

« back to all changes in this revision

Viewing changes to vala/valagirparser.c

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2010-04-02 10:10:55 UTC
  • mfrom: (1.4.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20100402101055-qbx3okzv0tnp3wpp
Tags: 0.8.0-0ubuntu1
* New upstream release:
  - Infer type arguments when calling generic methods.
  - Support `in' operator for arrays.
  - Add experimental support for regular expression literals.
  - Add experimental support for chained relational expressions.
  - Add va_list support.
  - Add clutter-gtk-0.10 bindings (Gordon Allott).
  - Add gdl-1.0 bindings (Nicolas Joseph).
  - Add gstreamer-app-0.10 bindings (Sebastian Dröge).
  - Add gstreamer-cdda-0.10 bindings (Sebastian Dröge).
  - Add gudev-1.0 bindings (Jim Nelson).
  - Add libgda-report-4.0 bindings (Shawn Ferris).
  - Add libgvc (graphviz) bindings (Martin Olsson).
  - Add purple bindings (Adrien Bustany).
  - Many bug fixes and binding updates.
* debian/patches/99_ltmain_as-needed.patch: refreshed

Show diffs side-by-side

added added

removed removed

Lines of Context:
vala/valagirparser.c
565
565
typedef struct _ValaLockStatement ValaLockStatement;
566
566
typedef struct _ValaLockStatementClass ValaLockStatementClass;
567
567
 
 
568
#define VALA_TYPE_UNLOCK_STATEMENT (vala_unlock_statement_get_type ())
 
569
#define VALA_UNLOCK_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_UNLOCK_STATEMENT, ValaUnlockStatement))
 
570
#define VALA_UNLOCK_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_UNLOCK_STATEMENT, ValaUnlockStatementClass))
 
571
#define VALA_IS_UNLOCK_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_UNLOCK_STATEMENT))
 
572
#define VALA_IS_UNLOCK_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_UNLOCK_STATEMENT))
 
573
#define VALA_UNLOCK_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_UNLOCK_STATEMENT, ValaUnlockStatementClass))
 
574
 
 
575
typedef struct _ValaUnlockStatement ValaUnlockStatement;
 
576
typedef struct _ValaUnlockStatementClass ValaUnlockStatementClass;
 
577
 
568
578
#define VALA_TYPE_DELETE_STATEMENT (vala_delete_statement_get_type ())
569
579
#define VALA_DELETE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DELETE_STATEMENT, ValaDeleteStatement))
570
580
#define VALA_DELETE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DELETE_STATEMENT, ValaDeleteStatementClass))
635
645
typedef struct _ValaRealLiteral ValaRealLiteral;
636
646
typedef struct _ValaRealLiteralClass ValaRealLiteralClass;
637
647
 
 
648
#define VALA_TYPE_REGEX_LITERAL (vala_regex_literal_get_type ())
 
649
#define VALA_REGEX_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_REGEX_LITERAL, ValaRegexLiteral))
 
650
#define VALA_REGEX_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_REGEX_LITERAL, ValaRegexLiteralClass))
 
651
#define VALA_IS_REGEX_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_REGEX_LITERAL))
 
652
#define VALA_IS_REGEX_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_REGEX_LITERAL))
 
653
#define VALA_REGEX_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_REGEX_LITERAL, ValaRegexLiteralClass))
 
654
 
 
655
typedef struct _ValaRegexLiteral ValaRegexLiteral;
 
656
typedef struct _ValaRegexLiteralClass ValaRegexLiteralClass;
 
657
 
638
658
#define VALA_TYPE_STRING_LITERAL (vala_string_literal_get_type ())
639
659
#define VALA_STRING_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_STRING_LITERAL, ValaStringLiteral))
640
660
#define VALA_STRING_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_STRING_LITERAL, ValaStringLiteralClass))
655
675
typedef struct _ValaTemplate ValaTemplate;
656
676
typedef struct _ValaTemplateClass ValaTemplateClass;
657
677
 
 
678
#define VALA_TYPE_LIST_LITERAL (vala_list_literal_get_type ())
 
679
#define VALA_LIST_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_LIST_LITERAL, ValaListLiteral))
 
680
#define VALA_LIST_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_LIST_LITERAL, ValaListLiteralClass))
 
681
#define VALA_IS_LIST_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_LIST_LITERAL))
 
682
#define VALA_IS_LIST_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_LIST_LITERAL))
 
683
#define VALA_LIST_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_LIST_LITERAL, ValaListLiteralClass))
 
684
 
 
685
typedef struct _ValaListLiteral ValaListLiteral;
 
686
typedef struct _ValaListLiteralClass ValaListLiteralClass;
 
687
 
 
688
#define VALA_TYPE_SET_LITERAL (vala_set_literal_get_type ())
 
689
#define VALA_SET_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SET_LITERAL, ValaSetLiteral))
 
690
#define VALA_SET_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SET_LITERAL, ValaSetLiteralClass))
 
691
#define VALA_IS_SET_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SET_LITERAL))
 
692
#define VALA_IS_SET_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SET_LITERAL))
 
693
#define VALA_SET_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SET_LITERAL, ValaSetLiteralClass))
 
694
 
 
695
typedef struct _ValaSetLiteral ValaSetLiteral;
 
696
typedef struct _ValaSetLiteralClass ValaSetLiteralClass;
 
697
 
 
698
#define VALA_TYPE_MAP_LITERAL (vala_map_literal_get_type ())
 
699
#define VALA_MAP_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_MAP_LITERAL, ValaMapLiteral))
 
700
#define VALA_MAP_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_MAP_LITERAL, ValaMapLiteralClass))
 
701
#define VALA_IS_MAP_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_MAP_LITERAL))
 
702
#define VALA_IS_MAP_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_MAP_LITERAL))
 
703
#define VALA_MAP_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_MAP_LITERAL, ValaMapLiteralClass))
 
704
 
 
705
typedef struct _ValaMapLiteral ValaMapLiteral;
 
706
typedef struct _ValaMapLiteralClass ValaMapLiteralClass;
 
707
 
 
708
#define VALA_TYPE_TUPLE (vala_tuple_get_type ())
 
709
#define VALA_TUPLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TUPLE, ValaTuple))
 
710
#define VALA_TUPLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TUPLE, ValaTupleClass))
 
711
#define VALA_IS_TUPLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TUPLE))
 
712
#define VALA_IS_TUPLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TUPLE))
 
713
#define VALA_TUPLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TUPLE, ValaTupleClass))
 
714
 
 
715
typedef struct _ValaTuple ValaTuple;
 
716
typedef struct _ValaTupleClass ValaTupleClass;
 
717
 
658
718
#define VALA_TYPE_NULL_LITERAL (vala_null_literal_get_type ())
659
719
#define VALA_NULL_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_NULL_LITERAL, ValaNullLiteral))
660
720
#define VALA_NULL_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_NULL_LITERAL, ValaNullLiteralClass))
1116
1176
        void (*visit_try_statement) (ValaCodeVisitor* self, ValaTryStatement* stmt);
1117
1177
        void (*visit_catch_clause) (ValaCodeVisitor* self, ValaCatchClause* clause);
1118
1178
        void (*visit_lock_statement) (ValaCodeVisitor* self, ValaLockStatement* stmt);
 
1179
        void (*visit_unlock_statement) (ValaCodeVisitor* self, ValaUnlockStatement* stmt);
1119
1180
        void (*visit_delete_statement) (ValaCodeVisitor* self, ValaDeleteStatement* stmt);
1120
1181
        void (*visit_expression) (ValaCodeVisitor* self, ValaExpression* expr);
1121
1182
        void (*visit_array_creation_expression) (ValaCodeVisitor* self, ValaArrayCreationExpression* expr);
1123
1184
        void (*visit_character_literal) (ValaCodeVisitor* self, ValaCharacterLiteral* lit);
1124
1185
        void (*visit_integer_literal) (ValaCodeVisitor* self, ValaIntegerLiteral* lit);
1125
1186
        void (*visit_real_literal) (ValaCodeVisitor* self, ValaRealLiteral* lit);
 
1187
        void (*visit_regex_literal) (ValaCodeVisitor* self, ValaRegexLiteral* lit);
1126
1188
        void (*visit_string_literal) (ValaCodeVisitor* self, ValaStringLiteral* lit);
1127
1189
        void (*visit_template) (ValaCodeVisitor* self, ValaTemplate* tmpl);
 
1190
        void (*visit_list_literal) (ValaCodeVisitor* self, ValaListLiteral* lit);
 
1191
        void (*visit_set_literal) (ValaCodeVisitor* self, ValaSetLiteral* lit);
 
1192
        void (*visit_map_literal) (ValaCodeVisitor* self, ValaMapLiteral* lit);
 
1193
        void (*visit_tuple) (ValaCodeVisitor* self, ValaTuple* tuple);
1128
1194
        void (*visit_null_literal) (ValaCodeVisitor* self, ValaNullLiteral* lit);
1129
1195
        void (*visit_member_access) (ValaCodeVisitor* self, ValaMemberAccess* expr);
1130
1196
        void (*visit_method_call) (ValaCodeVisitor* self, ValaMethodCall* expr);
1182
1248
        ValaMarkupTokenType current_token;
1183
1249
        char** cheader_filenames;
1184
1250
        gint cheader_filenames_length1;
1185
 
        gint cheader_filenames_size;
 
1251
        gint _cheader_filenames_size_;
1186
1252
        char** package_names;
1187
1253
        gint package_names_length1;
1188
 
        gint package_names_size;
 
1254
        gint _package_names_size_;
1189
1255
        ValaHashMap* attributes_map;
1190
1256
        ValaHashMap* gtype_callbacks;
1191
1257
};
1258
1324
void vala_code_visitor_unref (gpointer instance);
1259
1325
GParamSpec* vala_param_spec_code_visitor (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
1260
1326
void vala_value_set_code_visitor (GValue* value, gpointer v_object);
 
1327
void vala_value_take_code_visitor (GValue* value, gpointer v_object);
1261
1328
gpointer vala_value_get_code_visitor (const GValue* value);
1262
1329
GType vala_code_visitor_get_type (void);
1263
1330
gpointer vala_source_file_ref (gpointer instance);
1264
1331
void vala_source_file_unref (gpointer instance);
1265
1332
GParamSpec* vala_param_spec_source_file (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
1266
1333
void vala_value_set_source_file (GValue* value, gpointer v_object);
 
1334
void vala_value_take_source_file (GValue* value, gpointer v_object);
1267
1335
gpointer vala_value_get_source_file (const GValue* value);
1268
1336
GType vala_source_file_get_type (void);
1269
1337
gpointer vala_code_node_ref (gpointer instance);
1270
1338
void vala_code_node_unref (gpointer instance);
1271
1339
GParamSpec* vala_param_spec_code_node (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
1272
1340
void vala_value_set_code_node (GValue* value, gpointer v_object);
 
1341
void vala_value_take_code_node (GValue* value, gpointer v_object);
1273
1342
gpointer vala_value_get_code_node (const GValue* value);
1274
1343
GType vala_code_node_get_type (void);
1275
1344
GType vala_symbol_get_type (void);
1322
1391
GType vala_try_statement_get_type (void);
1323
1392
GType vala_catch_clause_get_type (void);
1324
1393
GType vala_lock_statement_get_type (void);
 
1394
GType vala_unlock_statement_get_type (void);
1325
1395
GType vala_delete_statement_get_type (void);
1326
1396
GType vala_array_creation_expression_get_type (void);
1327
1397
GType vala_literal_get_type (void);
1329
1399
GType vala_character_literal_get_type (void);
1330
1400
GType vala_integer_literal_get_type (void);
1331
1401
GType vala_real_literal_get_type (void);
 
1402
GType vala_regex_literal_get_type (void);
1332
1403
GType vala_string_literal_get_type (void);
1333
1404
GType vala_template_get_type (void);
 
1405
GType vala_list_literal_get_type (void);
 
1406
GType vala_set_literal_get_type (void);
 
1407
GType vala_map_literal_get_type (void);
 
1408
GType vala_tuple_get_type (void);
1334
1409
GType vala_null_literal_get_type (void);
1335
1410
GType vala_member_access_get_type (void);
1336
1411
GType vala_method_call_get_type (void);
1358
1433
void vala_code_context_unref (gpointer instance);
1359
1434
GParamSpec* vala_param_spec_code_context (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
1360
1435
void vala_value_set_code_context (GValue* value, gpointer v_object);
 
1436
void vala_value_take_code_context (GValue* value, gpointer v_object);
1361
1437
gpointer vala_value_get_code_context (const GValue* value);
1362
1438
GType vala_code_context_get_type (void);
1363
1439
GType vala_source_location_get_type (void);
1373
1449
void vala_scope_unref (gpointer instance);
1374
1450
GParamSpec* vala_param_spec_scope (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
1375
1451
void vala_value_set_scope (GValue* value, gpointer v_object);
 
1452
void vala_value_take_scope (GValue* value, gpointer v_object);
1376
1453
gpointer vala_value_get_scope (const GValue* value);
1377
1454
GType vala_scope_get_type (void);
1378
1455
ValaScope* vala_symbol_get_scope (ValaSymbol* self);
1397
1474
void vala_source_reference_unref (gpointer instance);
1398
1475
GParamSpec* vala_param_spec_source_reference (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
1399
1476
void vala_value_set_source_reference (GValue* value, gpointer v_object);
 
1477
void vala_value_take_source_reference (GValue* value, gpointer v_object);
1400
1478
gpointer vala_value_get_source_reference (const GValue* value);
1401
1479
GType vala_source_reference_get_type (void);
1402
1480
void vala_report_error (ValaSourceReference* source, const char* message);
1449
1527
void vala_comment_unref (gpointer instance);
1450
1528
GParamSpec* vala_param_spec_comment (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
1451
1529
void vala_value_set_comment (GValue* value, gpointer v_object);
 
1530
void vala_value_take_comment (GValue* value, gpointer v_object);
1452
1531
gpointer vala_value_get_comment (const GValue* value);
1453
1532
GType vala_comment_get_type (void);
1454
1533
ValaStruct* vala_struct_new (const char* name, ValaSourceReference* source_reference, ValaComment* comment);
1553
1632
GType vala_error_type_get_type (void);
1554
1633
ValaMethod* vala_method_new (const char* name, ValaDataType* return_type, ValaSourceReference* source_reference, ValaComment* comment);
1555
1634
ValaMethod* vala_method_construct (GType object_type, const char* name, ValaDataType* return_type, ValaSourceReference* source_reference, ValaComment* comment);
 
1635
void vala_method_set_cname (ValaMethod* self, const char* cname);
1556
1636
GType member_binding_get_type (void);
1557
1637
void vala_method_set_binding (ValaMethod* self, MemberBinding value);
1558
1638
static gpointer vala_gir_parser_method_info_ref (gpointer instance);
1559
1639
static void vala_gir_parser_method_info_unref (gpointer instance);
1560
 
static GParamSpec* vala_gir_parser_param_spec_method_info (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
1561
 
static void vala_gir_parser_value_set_method_info (GValue* value, gpointer v_object);
1562
 
static gpointer vala_gir_parser_value_get_method_info (const GValue* value);
1563
 
static GType vala_gir_parser_method_info_get_type (void);
 
1640
static GParamSpec* vala_gir_parser_param_spec_method_info (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) G_GNUC_UNUSED;
 
1641
static void vala_gir_parser_value_set_method_info (GValue* value, gpointer v_object) G_GNUC_UNUSED;
 
1642
static void vala_gir_parser_value_take_method_info (GValue* value, gpointer v_object) G_GNUC_UNUSED;
 
1643
static gpointer vala_gir_parser_value_get_method_info (const GValue* value) G_GNUC_UNUSED;
 
1644
static GType vala_gir_parser_method_info_get_type (void) G_GNUC_UNUSED;
1564
1645
static ValaGirParserMethodInfo* vala_gir_parser_method_info_new (ValaFormalParameter* param, gint array_length_idx, gint closure_idx, gint destroy_idx);
1565
1646
static ValaGirParserMethodInfo* vala_gir_parser_method_info_construct (GType object_type, ValaFormalParameter* param, gint array_length_idx, gint closure_idx, gint destroy_idx);
1566
1647
void vala_formal_parameter_set_carray_length_parameter_position (ValaFormalParameter* self, double value);
1764
1845
 
1765
1846
 
1766
1847
static ValaSourceReference* vala_gir_parser_get_current_src (ValaGirParser* self) {
1767
 
        ValaSourceReference* result;
 
1848
        ValaSourceReference* result = NULL;
1768
1849
        g_return_val_if_fail (self != NULL, NULL);
1769
1850
        result = vala_source_reference_new (self->priv->current_source_file, self->priv->begin.line, self->priv->begin.column, self->priv->end.line, self->priv->end.column);
1770
1851
        return result;
1843
1924
static void vala_gir_parser_parse_c_include (ValaGirParser* self) {
1844
1925
        g_return_if_fail (self != NULL);
1845
1926
        vala_gir_parser_start_element (self, "c:include");
1846
 
        _vala_array_add1 (&self->priv->cheader_filenames, &self->priv->cheader_filenames_length1, &self->priv->cheader_filenames_size, vala_markup_reader_get_attribute (self->priv->reader, "name"));
 
1927
        _vala_array_add1 (&self->priv->cheader_filenames, &self->priv->cheader_filenames_length1, &self->priv->_cheader_filenames_size_, vala_markup_reader_get_attribute (self->priv->reader, "name"));
1847
1928
        vala_gir_parser_next (self);
1848
1929
        vala_gir_parser_end_element (self, "c:include");
1849
1930
}
1856
1937
 
1857
1938
 
1858
1939
static ValaNamespace* vala_gir_parser_parse_namespace (ValaGirParser* self) {
1859
 
        ValaNamespace* result;
 
1940
        ValaNamespace* result = NULL;
1860
1941
        gboolean new_namespace;
1861
1942
        char* _tmp0_;
1862
1943
        char* _tmp1_;
2024
2105
 
2025
2106
 
2026
2107
static ValaStruct* vala_gir_parser_parse_alias (ValaGirParser* self) {
2027
 
        ValaStruct* result;
 
2108
        ValaStruct* result = NULL;
2028
2109
        ValaSourceReference* _tmp1_;
2029
2110
        char* _tmp0_;
2030
2111
        ValaStruct* _tmp2_;
2055
2136
 
2056
2137
 
2057
2138
static ValaEnum* vala_gir_parser_parse_enumeration (ValaGirParser* self) {
2058
 
        ValaEnum* result;
 
2139
        ValaEnum* result = NULL;
2059
2140
        ValaSourceReference* _tmp1_;
2060
2141
        char* _tmp0_;
2061
2142
        ValaEnum* _tmp2_;
2148
2229
 
2149
2230
 
2150
2231
static ValaEnum* vala_gir_parser_parse_bitfield (ValaGirParser* self) {
2151
 
        ValaEnum* result;
 
2232
        ValaEnum* result = NULL;
2152
2233
        ValaSourceReference* _tmp1_;
2153
2234
        char* _tmp0_;
2154
2235
        ValaEnum* _tmp2_;
2177
2258
 
2178
2259
 
2179
2260
static ValaEnumValue* vala_gir_parser_parse_enumeration_member (ValaGirParser* self) {
2180
 
        ValaEnumValue* result;
 
2261
        ValaEnumValue* result = NULL;
2181
2262
        char* _tmp4_;
2182
2263
        gint _tmp3__length1;
2183
2264
        char** _tmp3_;
2200
2281
 
2201
2282
 
2202
2283
static ValaDataType* vala_gir_parser_parse_return_value (ValaGirParser* self, char** ctype) {
2203
 
        ValaDataType* result;
 
2284
        ValaDataType* result = NULL;
2204
2285
        char* transfer;
2205
2286
        char* allow_none;
2206
2287
        ValaDataType* _tmp0_;
2241
2322
 
2242
2323
 
2243
2324
static ValaFormalParameter* vala_gir_parser_parse_parameter (ValaGirParser* self, gint* array_length_idx, gint* closure_idx, gint* destroy_idx) {
2244
 
        ValaFormalParameter* result;
 
2325
        ValaFormalParameter* result = NULL;
2245
2326
        ValaFormalParameter* param;
2246
2327
        char* name;
2247
2328
        char* direction;
2329
2410
 
2330
2411
 
2331
2412
static ValaDataType* vala_gir_parser_parse_type (ValaGirParser* self, char** ctype, gint* array_length_index) {
2332
 
        ValaDataType* result;
 
2413
        ValaDataType* result = NULL;
2333
2414
        g_return_val_if_fail (self != NULL, NULL);
2334
2415
        if (ctype != NULL) {
2335
2416
                *ctype = NULL;
2391
2472
 
2392
2473
 
2393
2474
static ValaDataType* vala_gir_parser_parse_type_from_name (ValaGirParser* self, const char* type_name) {
2394
 
        ValaDataType* result;
 
2475
        ValaDataType* result = NULL;
2395
2476
        ValaDataType* type;
2396
2477
        g_return_val_if_fail (self != NULL, NULL);
2397
2478
        g_return_val_if_fail (type_name != NULL, NULL);
2415
2496
                                _vala_code_node_unref0 (_tmp3_);
2416
2497
                        } else {
2417
2498
                                char** _tmp7_;
2418
 
                                gint type_components_size;
 
2499
                                gint _type_components_size_;
2419
2500
                                gint type_components_length1;
2420
2501
                                char** _tmp6_;
2421
2502
                                char** type_components;
2450
2531
                                                }
2451
2532
                                        }
2452
2533
                                }
2453
 
                                type_components = (_tmp7_ = _tmp6_ = g_strsplit (type_name, ".", 0), type_components_length1 = _vala_array_length (_tmp6_), type_components_size = type_components_length1, _tmp7_);
 
2534
                                type_components = (_tmp7_ = _tmp6_ = g_strsplit (type_name, ".", 0), type_components_length1 = _vala_array_length (_tmp6_), _type_components_size_ = type_components_length1, _tmp7_);
2454
2535
                                if (type_components[1] != NULL) {
2455
2536
                                        char* namespace_name;
2456
2537
                                        char* transformed_type_name;
2480
2561
 
2481
2562
 
2482
2563
static char* vala_gir_parser_transform_namespace_name (ValaGirParser* self, const char* gir_module_name) {
2483
 
        char* result;
 
2564
        char* result = NULL;
2484
2565
        g_return_val_if_fail (self != NULL, NULL);
2485
2566
        g_return_val_if_fail (gir_module_name != NULL, NULL);
2486
2567
        if (_vala_strcmp0 (gir_module_name, "GObject") == 0) {
2503
2584
 
2504
2585
 
2505
2586
static ValaStruct* vala_gir_parser_parse_record (ValaGirParser* self) {
2506
 
        ValaStruct* result;
 
2587
        ValaStruct* result = NULL;
2507
2588
        ValaSourceReference* _tmp1_;
2508
2589
        char* _tmp0_;
2509
2590
        ValaStruct* _tmp2_;
2685
2766
 
2686
2767
 
2687
2768
static ValaClass* vala_gir_parser_parse_class (ValaGirParser* self) {
2688
 
        ValaClass* result;
 
2769
        ValaClass* result = NULL;
2689
2770
        ValaSourceReference* _tmp1_;
2690
2771
        char* _tmp0_;
2691
2772
        ValaClass* _tmp2_;
2968
3049
 
2969
3050
 
2970
3051
static ValaInterface* vala_gir_parser_parse_interface (ValaGirParser* self) {
2971
 
        ValaInterface* result;
 
3052
        ValaInterface* result = NULL;
2972
3053
        ValaSourceReference* _tmp1_;
2973
3054
        char* _tmp0_;
2974
3055
        ValaInterface* _tmp2_;
3123
3204
 
3124
3205
 
3125
3206
static ValaField* vala_gir_parser_parse_field (ValaGirParser* self) {
3126
 
        ValaField* result;
 
3207
        ValaField* result = NULL;
3127
3208
        char* name;
3128
3209
        char* allow_none;
3129
3210
        ValaDataType* type;
3151
3232
 
3152
3233
 
3153
3234
static ValaProperty* vala_gir_parser_parse_property (ValaGirParser* self) {
3154
 
        ValaProperty* result;
 
3235
        ValaProperty* result = NULL;
3155
3236
        gint _tmp2__length1;
3156
3237
        char** _tmp2_;
3157
3238
        char** _tmp1_;
3222
3303
 
3223
3304
 
3224
3305
static ValaDelegate* vala_gir_parser_parse_callback (ValaGirParser* self) {
3225
 
        ValaDelegate* result;
 
3306
        ValaDelegate* result = NULL;
3226
3307
        char* name;
3227
3308
        ValaDataType* return_type;
3228
3309
        gboolean _tmp0_ = FALSE;
3276
3357
 
3277
3358
 
3278
3359
static ValaMethod* vala_gir_parser_parse_constructor (ValaGirParser* self, const char* parent_ctype) {
3279
 
        ValaMethod* result;
 
3360
        ValaMethod* result = NULL;
3280
3361
        char* name;
3281
3362
        char* throws_string;
3282
3363
        char* ctype;
3356
3437
 
3357
3438
 
3358
3439
static ValaMethod* vala_gir_parser_parse_method (ValaGirParser* self, const char* element_name) {
3359
 
        ValaMethod* result;
 
3440
        ValaMethod* result = NULL;
3360
3441
        char* name;
 
3442
        char* cname;
3361
3443
        char* throws_string;
3362
3444
        char* invoker;
3363
3445
        ValaDataType* return_type;
3381
3463
        g_return_val_if_fail (element_name != NULL, NULL);
3382
3464
        vala_gir_parser_start_element (self, element_name);
3383
3465
        name = vala_markup_reader_get_attribute (self->priv->reader, "name");
 
3466
        cname = vala_markup_reader_get_attribute (self->priv->reader, "c:identifier");
3384
3467
        throws_string = vala_markup_reader_get_attribute (self->priv->reader, "throws");
3385
3468
        invoker = vala_markup_reader_get_attribute (self->priv->reader, "invoker");
3386
3469
        vala_gir_parser_next (self);
3399
3482
        }
3400
3483
        m = (_tmp4_ = vala_method_new (name, return_type, _tmp3_ = vala_gir_parser_get_current_src (self), NULL), _vala_source_reference_unref0 (_tmp3_), _tmp4_);
3401
3484
        vala_symbol_set_access ((ValaSymbol*) m, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
 
3485
        if (cname != NULL) {
 
3486
                vala_method_set_cname (m, cname);
 
3487
        }
3402
3488
        if (_vala_strcmp0 (element_name, "virtual-method") == 0) {
3403
3489
                _tmp5_ = TRUE;
3404
3490
        } else {
3596
3682
        vala_gir_parser_end_element (self, element_name);
3597
3683
        result = m;
3598
3684
        _g_free0 (name);
 
3685
        _g_free0 (cname);
3599
3686
        _g_free0 (throws_string);
3600
3687
        _g_free0 (invoker);
3601
3688
        _vala_code_node_unref0 (return_type);
3608
3695
 
3609
3696
 
3610
3697
static ValaSignal* vala_gir_parser_parse_signal (ValaGirParser* self) {
3611
 
        ValaSignal* result;
 
3698
        ValaSignal* result = NULL;
3612
3699
        gint _tmp2__length1;
3613
3700
        char** _tmp2_;
3614
3701
        char** _tmp1_;
3666
3753
 
3667
3754
 
3668
3755
static ValaStruct* vala_gir_parser_parse_boxed (ValaGirParser* self) {
3669
 
        ValaStruct* result;
 
3756
        ValaStruct* result = NULL;
3670
3757
        char* _tmp0_;
3671
3758
        ValaStruct* _tmp1_;
3672
3759
        ValaStruct* st;
3718
3805
 
3719
3806
 
3720
3807
static ValaStruct* vala_gir_parser_parse_union (ValaGirParser* self) {
3721
 
        ValaStruct* result;
 
3808
        ValaStruct* result = NULL;
3722
3809
        char* _tmp0_;
3723
3810
        ValaStruct* _tmp1_;
3724
3811
        ValaStruct* st;
3801
3888
 
3802
3889
 
3803
3890
static ValaConstant* vala_gir_parser_parse_constant (ValaGirParser* self) {
3804
 
        ValaConstant* result;
 
3891
        ValaConstant* result = NULL;
3805
3892
        char* name;
3806
3893
        ValaDataType* type;
3807
3894
        ValaSourceReference* _tmp0_;
3824
3911
 
3825
3912
 
3826
3913
static char* string_substring (const char* self, glong offset, glong len) {
3827
 
        char* result;
 
3914
        char* result = NULL;
3828
3915
        glong string_length;
3829
3916
        const char* start;
3830
3917
        g_return_val_if_fail (self != NULL, NULL);
3853
3940
        if (g_file_test (metadata_filename, G_FILE_TEST_EXISTS)) {
3854
3941
                {
3855
3942
                        char* metadata;
3856
 
                        char* _tmp2_;
3857
 
                        gboolean _tmp1_;
 
3943
                        char* _tmp1_;
3858
3944
                        char* _tmp0_ = NULL;
3859
3945
                        metadata = NULL;
3860
 
                        _tmp1_ = g_file_get_contents (metadata_filename, &_tmp0_, NULL, &_inner_error_);
3861
 
                        metadata = (_tmp2_ = _tmp0_, _g_free0 (metadata), _tmp2_);
3862
 
                        _tmp1_;
 
3946
                        g_file_get_contents (metadata_filename, &_tmp0_, NULL, &_inner_error_);
 
3947
                        metadata = (_tmp1_ = _tmp0_, _g_free0 (metadata), _tmp1_);
3863
3948
                        if (_inner_error_ != NULL) {
3864
3949
                                _g_free0 (metadata);
3865
3950
                                if (_inner_error_->domain == G_FILE_ERROR) {
3871
3956
                                return;
3872
3957
                        }
3873
3958
                        {
3874
 
                                char** _tmp3_;
 
3959
                                char** _tmp2_;
3875
3960
                                char** line_collection;
3876
3961
                                int line_collection_length1;
3877
3962
                                int line_it;
3878
 
                                line_collection = _tmp3_ = g_strsplit (metadata, "\n", 0);
3879
 
                                line_collection_length1 = _vala_array_length (_tmp3_);
3880
 
                                for (line_it = 0; line_it < _vala_array_length (_tmp3_); line_it = line_it + 1) {
 
3963
                                line_collection = _tmp2_ = g_strsplit (metadata, "\n", 0);
 
3964
                                line_collection_length1 = _vala_array_length (_tmp2_);
 
3965
                                for (line_it = 0; line_it < _vala_array_length (_tmp2_); line_it = line_it + 1) {
3881
3966
                                        char* line;
3882
3967
                                        line = g_strdup (line_collection[line_it]);
3883
3968
                                        {
3884
 
                                                char** _tmp5_;
3885
 
                                                gint tokens_size;
 
3969
                                                char** _tmp4_;
 
3970
                                                gint _tokens_size_;
3886
3971
                                                gint tokens_length1;
3887
 
                                                char** _tmp4_;
 
3972
                                                char** _tmp3_;
3888
3973
                                                char** tokens;
3889
3974
                                                if (g_str_has_prefix (line, "#")) {
3890
3975
                                                        _g_free0 (line);
3891
3976
                                                        continue;
3892
3977
                                                }
3893
 
                                                tokens = (_tmp5_ = _tmp4_ = g_strsplit (line, " ", 2), tokens_length1 = _vala_array_length (_tmp4_), tokens_size = tokens_length1, _tmp5_);
 
3978
                                                tokens = (_tmp4_ = _tmp3_ = g_strsplit (line, " ", 2), tokens_length1 = _vala_array_length (_tmp3_), _tokens_size_ = tokens_length1, _tmp4_);
3894
3979
                                                if (NULL == tokens[0]) {
3895
3980
                                                        _g_free0 (line);
3896
3981
                                                        tokens = (_vala_array_free (tokens, tokens_length1, (GDestroyNotify) g_free), NULL);
3897
3982
                                                        continue;
3898
3983
                                                }
3899
3984
                                                {
3900
 
                                                        char** _tmp6_;
 
3985
                                                        char** _tmp5_;
3901
3986
                                                        char** attribute_collection;
3902
3987
                                                        int attribute_collection_length1;
3903
3988
                                                        int attribute_it;
3904
 
                                                        attribute_collection = _tmp6_ = g_strsplit (tokens[1], " ", 0);
3905
 
                                                        attribute_collection_length1 = _vala_array_length (_tmp6_);
3906
 
                                                        for (attribute_it = 0; attribute_it < _vala_array_length (_tmp6_); attribute_it = attribute_it + 1) {
 
3989
                                                        attribute_collection = _tmp5_ = g_strsplit (tokens[1], " ", 0);
 
3990
                                                        attribute_collection_length1 = _vala_array_length (_tmp5_);
 
3991
                                                        for (attribute_it = 0; attribute_it < _vala_array_length (_tmp5_); attribute_it = attribute_it + 1) {
3907
3992
                                                                char* attribute;
3908
3993
                                                                attribute = g_strdup (attribute_collection[attribute_it]);
3909
3994
                                                                {
3910
 
                                                                        char** _tmp8_;
3911
 
                                                                        gint pair_size;
 
3995
                                                                        char** _tmp7_;
 
3996
                                                                        gint _pair_size_;
3912
3997
                                                                        gint pair_length1;
3913
 
                                                                        char** _tmp7_;
 
3998
                                                                        char** _tmp6_;
3914
3999
                                                                        char** pair;
3915
 
                                                                        gboolean _tmp9_ = FALSE;
 
4000
                                                                        gboolean _tmp8_ = FALSE;
3916
4001
                                                                        char* key;
3917
 
                                                                        char* _tmp10_;
3918
 
                                                                        pair = (_tmp8_ = _tmp7_ = g_strsplit (attribute, "=", 2), pair_length1 = _vala_array_length (_tmp7_), pair_size = pair_length1, _tmp8_);
 
4002
                                                                        char* _tmp9_;
 
4003
                                                                        pair = (_tmp7_ = _tmp6_ = g_strsplit (attribute, "=", 2), pair_length1 = _vala_array_length (_tmp6_), _pair_size_ = pair_length1, _tmp7_);
3919
4004
                                                                        if (pair[0] == NULL) {
3920
 
                                                                                _tmp9_ = TRUE;
 
4005
                                                                                _tmp8_ = TRUE;
3921
4006
                                                                        } else {
3922
 
                                                                                _tmp9_ = pair[1] == NULL;
 
4007
                                                                                _tmp8_ = pair[1] == NULL;
3923
4008
                                                                        }
3924
 
                                                                        if (_tmp9_) {
 
4009
                                                                        if (_tmp8_) {
3925
4010
                                                                                _g_free0 (attribute);
3926
4011
                                                                                pair = (_vala_array_free (pair, pair_length1, (GDestroyNotify) g_free), NULL);
3927
4012
                                                                                continue;
3928
4013
                                                                        }
3929
4014
                                                                        key = g_strdup_printf ("%s/@%s", tokens[0], pair[0]);
3930
 
                                                                        vala_map_set ((ValaMap*) self->priv->attributes_map, key, _tmp10_ = string_substring (pair[1], (glong) 1, string_get_length (pair[1]) - 2));
3931
 
                                                                        _g_free0 (_tmp10_);
 
4015
                                                                        vala_map_set ((ValaMap*) self->priv->attributes_map, key, _tmp9_ = string_substring (pair[1], (glong) 1, string_get_length (pair[1]) - 2));
 
4016
                                                                        _g_free0 (_tmp9_);
3932
4017
                                                                        _g_free0 (attribute);
3933
4018
                                                                        pair = (_vala_array_free (pair, pair_length1, (GDestroyNotify) g_free), NULL);
3934
4019
                                                                        _g_free0 (key);
3951
4036
                        e = _inner_error_;
3952
4037
                        _inner_error_ = NULL;
3953
4038
                        {
3954
 
                                char* _tmp11_;
3955
 
                                vala_report_error (NULL, _tmp11_ = g_strdup_printf ("Unable to read metadata file: %s", e->message));
3956
 
                                _g_free0 (_tmp11_);
 
4039
                                char* _tmp10_;
 
4040
                                vala_report_error (NULL, _tmp10_ = g_strdup_printf ("Unable to read metadata file: %s", e->message));
 
4041
                                _g_free0 (_tmp10_);
3957
4042
                                _g_error_free0 (e);
3958
4043
                        }
3959
4044
                }
3964
4049
                        return;
3965
4050
                }
3966
4051
        } else {
3967
 
                char* _tmp12_;
3968
 
                vala_report_error (NULL, _tmp12_ = g_strdup_printf ("Metadata file `%s' not found", metadata_filename));
3969
 
                _g_free0 (_tmp12_);
 
4052
                char* _tmp11_;
 
4053
                vala_report_error (NULL, _tmp11_ = g_strdup_printf ("Metadata file `%s' not found", metadata_filename));
 
4054
                _g_free0 (_tmp11_);
3970
4055
        }
3971
4056
}
3972
4057
 
3986
4071
        g_return_if_fail (name != NULL);
3987
4072
        if (self->priv->package_names == NULL) {
3988
4073
                char** _tmp0_;
3989
 
                self->priv->package_names = (_tmp0_ = g_new0 (char*, 0 + 1), self->priv->package_names = (_vala_array_free (self->priv->package_names, self->priv->package_names_length1, (GDestroyNotify) g_free), NULL), self->priv->package_names_length1 = 0, self->priv->package_names_size = self->priv->package_names_length1, _tmp0_);
 
4074
                self->priv->package_names = (_tmp0_ = g_new0 (char*, 0 + 1), self->priv->package_names = (_vala_array_free (self->priv->package_names, self->priv->package_names_length1, (GDestroyNotify) g_free), NULL), self->priv->package_names_length1 = 0, self->priv->_package_names_size_ = self->priv->package_names_length1, _tmp0_);
3990
4075
        }
3991
4076
        {
3992
4077
                char** existing_collection;
4006
4091
                        }
4007
4092
                }
4008
4093
        }
4009
 
        _vala_array_add2 (&self->priv->package_names, &self->priv->package_names_length1, &self->priv->package_names_size, g_strdup (name));
 
4094
        _vala_array_add2 (&self->priv->package_names, &self->priv->package_names_length1, &self->priv->_package_names_size_, g_strdup (name));
4010
4095
}
4011
4096
 
4012
4097
 
4022
4107
 
4023
4108
 
4024
4109
char** vala_gir_parser_get_package_names (ValaGirParser* self, int* result_length1) {
4025
 
        char** result;
 
4110
        char** result = NULL;
4026
4111
        char** _tmp0_;
4027
4112
        char** _tmp1_;
4028
4113
        g_return_val_if_fail (self != NULL, NULL);
4156
4241
}
4157
4242
 
4158
4243
 
 
4244
static void vala_gir_parser_value_take_method_info (GValue* value, gpointer v_object) {
 
4245
        ValaGirParserMethodInfo* old;
 
4246
        g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_GIR_PARSER_TYPE_METHOD_INFO));
 
4247
        old = value->data[0].v_pointer;
 
4248
        if (v_object) {
 
4249
                g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_GIR_PARSER_TYPE_METHOD_INFO));
 
4250
                g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 
4251
                value->data[0].v_pointer = v_object;
 
4252
        } else {
 
4253
                value->data[0].v_pointer = NULL;
 
4254
        }
 
4255
        if (old) {
 
4256
                vala_gir_parser_method_info_unref (old);
 
4257
        }
 
4258
}
 
4259
 
 
4260
 
4159
4261
static void vala_gir_parser_method_info_class_init (ValaGirParserMethodInfoClass * klass) {
4160
4262
        vala_gir_parser_method_info_parent_class = g_type_class_peek_parent (klass);
4161
4263
        VALA_GIR_PARSER_METHOD_INFO_CLASS (klass)->finalize = vala_gir_parser_method_info_finalize;
4175
4277
 
4176
4278
 
4177
4279
static GType vala_gir_parser_method_info_get_type (void) {
4178
 
        static GType vala_gir_parser_method_info_type_id = 0;
4179
 
        if (vala_gir_parser_method_info_type_id == 0) {
 
4280
        static volatile gsize vala_gir_parser_method_info_type_id__volatile = 0;
 
4281
        if (g_once_init_enter (&vala_gir_parser_method_info_type_id__volatile)) {
4180
4282
                static const GTypeValueTable g_define_type_value_table = { vala_gir_parser_value_method_info_init, vala_gir_parser_value_method_info_free_value, vala_gir_parser_value_method_info_copy_value, vala_gir_parser_value_method_info_peek_pointer, "p", vala_gir_parser_value_method_info_collect_value, "p", vala_gir_parser_value_method_info_lcopy_value };
4181
4283
                static const GTypeInfo g_define_type_info = { sizeof (ValaGirParserMethodInfoClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_gir_parser_method_info_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaGirParserMethodInfo), 0, (GInstanceInitFunc) vala_gir_parser_method_info_instance_init, &g_define_type_value_table };
4182
4284
                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) };
 
4285
                GType vala_gir_parser_method_info_type_id;
4183
4286
                vala_gir_parser_method_info_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ValaGirParserMethodInfo", &g_define_type_info, &g_define_type_fundamental_info, 0);
 
4287
                g_once_init_leave (&vala_gir_parser_method_info_type_id__volatile, vala_gir_parser_method_info_type_id);
4184
4288
        }
4185
 
        return vala_gir_parser_method_info_type_id;
 
4289
        return vala_gir_parser_method_info_type_id__volatile;
4186
4290
}
4187
4291
 
4188
4292
 
4235
4339
 
4236
4340
 
4237
4341
GType vala_gir_parser_get_type (void) {
4238
 
        static GType vala_gir_parser_type_id = 0;
4239
 
        if (vala_gir_parser_type_id == 0) {
 
4342
        static volatile gsize vala_gir_parser_type_id__volatile = 0;
 
4343
        if (g_once_init_enter (&vala_gir_parser_type_id__volatile)) {
4240
4344
                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 };
 
4345
                GType vala_gir_parser_type_id;
4241
4346
                vala_gir_parser_type_id = g_type_register_static (VALA_TYPE_CODE_VISITOR, "ValaGirParser", &g_define_type_info, 0);
 
4347
                g_once_init_leave (&vala_gir_parser_type_id__volatile, vala_gir_parser_type_id);
4242
4348
        }
4243
 
        return vala_gir_parser_type_id;
 
4349
        return vala_gir_parser_type_id__volatile;
4244
4350
}
4245
4351
 
4246
4352