← Back to branch summary

~ubuntu-branches/ubuntu/quantal/vala/quantal

« back to all changes in this revision

Viewing changes to vala/valacodecontext.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Ancell
  • Date: 2011-03-17 09:35:15 UTC
  • mfrom: (1.5.17 upstream)
  • Revision ID: james.westby@ubuntu.com-20110317093515-veyqriw9egujkws2
Tags: 0.11.7-0ubuntu1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
vala/valacodecontext.c
697
697
        gboolean _tmp0_;
698
698
        gchar* _tmp1_ = NULL;
699
699
        gchar* path;
700
 
        ValaSourceFile* _tmp6_ = NULL;
701
 
        ValaSourceFile* _tmp7_;
702
 
        gchar* _tmp8_ = NULL;
703
 
        gchar* _tmp9_;
704
 
        gchar* _tmp10_ = NULL;
705
 
        gchar* _tmp11_;
706
 
        gchar* _tmp12_ = NULL;
707
 
        gchar* _tmp13_;
 
700
        ValaSourceFile* _tmp5_ = NULL;
 
701
        ValaSourceFile* _tmp6_;
 
702
        gchar* _tmp7_ = NULL;
 
703
        gchar* _tmp8_;
 
704
        gchar* _tmp9_ = NULL;
 
705
        gchar* _tmp10_;
 
706
        gchar* _tmp11_ = NULL;
 
707
        gchar* _tmp12_;
708
708
        gchar* deps_filename;
709
 
        gboolean _tmp14_;
 
709
        gboolean _tmp13_;
710
710
        g_return_val_if_fail (self != NULL, FALSE);
711
711
        g_return_val_if_fail (pkg != NULL, FALSE);
712
712
        _tmp0_ = vala_code_context_has_package (self, pkg);
718
718
        path = _tmp1_;
719
719
        if (path == NULL) {
720
720
                gchar* _tmp2_ = NULL;
721
 
                gchar* _tmp3_;
722
721
                _tmp2_ = vala_code_context_get_gir_path (self, pkg);
723
 
                _tmp3_ = _tmp2_;
724
722
                _g_free0 (path);
725
 
                path = _tmp3_;
 
723
                path = _tmp2_;
726
724
        }
727
725
        if (path == NULL) {
728
 
                gchar* _tmp4_ = NULL;
729
 
                gchar* _tmp5_;
730
 
                _tmp4_ = g_strdup_printf ("Package `%s' not found in specified Vala API directories or GObject-In" \
 
726
                gchar* _tmp3_ = NULL;
 
727
                gchar* _tmp4_;
 
728
                _tmp3_ = g_strdup_printf ("Package `%s' not found in specified Vala API directories or GObject-In" \
731
729
"trospection GIR directories", pkg);
732
 
                _tmp5_ = _tmp4_;
733
 
                vala_report_error (NULL, _tmp5_);
734
 
                _g_free0 (_tmp5_);
 
730
                _tmp4_ = _tmp3_;
 
731
                vala_report_error (NULL, _tmp4_);
 
732
                _g_free0 (_tmp4_);
735
733
                result = FALSE;
736
734
                _g_free0 (path);
737
735
                return result;
738
736
        }
739
737
        vala_code_context_add_package (self, pkg);
740
 
        _tmp6_ = vala_source_file_new (self, VALA_SOURCE_FILE_TYPE_PACKAGE, path, NULL);
741
 
        _tmp7_ = _tmp6_;
742
 
        vala_code_context_add_source_file (self, _tmp7_);
743
 
        _vala_source_file_unref0 (_tmp7_);
744
 
        _tmp8_ = g_path_get_dirname (path);
745
 
        _tmp9_ = _tmp8_;
746
 
        _tmp10_ = g_strdup_printf ("%s.deps", pkg);
747
 
        _tmp11_ = _tmp10_;
748
 
        _tmp12_ = g_build_filename (_tmp9_, _tmp11_, NULL);
749
 
        deps_filename = (_tmp13_ = _tmp12_, _g_free0 (_tmp11_), _g_free0 (_tmp9_), _tmp13_);
750
 
        _tmp14_ = vala_code_context_add_packages_from_file (self, deps_filename);
751
 
        if (!_tmp14_) {
 
738
        _tmp5_ = vala_source_file_new (self, VALA_SOURCE_FILE_TYPE_PACKAGE, path, NULL);
 
739
        _tmp6_ = _tmp5_;
 
740
        vala_code_context_add_source_file (self, _tmp6_);
 
741
        _vala_source_file_unref0 (_tmp6_);
 
742
        _tmp7_ = g_path_get_dirname (path);
 
743
        _tmp8_ = _tmp7_;
 
744
        _tmp9_ = g_strdup_printf ("%s.deps", pkg);
 
745
        _tmp10_ = _tmp9_;
 
746
        _tmp11_ = g_build_filename (_tmp8_, _tmp10_, NULL);
 
747
        _tmp12_ = _tmp11_;
 
748
        _g_free0 (_tmp10_);
 
749
        _g_free0 (_tmp8_);
 
750
        deps_filename = _tmp12_;
 
751
        _tmp13_ = vala_code_context_add_packages_from_file (self, deps_filename);
 
752
        if (!_tmp13_) {
752
753
                result = FALSE;
753
754
                _g_free0 (deps_filename);
754
755
                _g_free0 (path);
823
824
                        package = _tmp4_;
824
825
                        {
825
826
                                gchar* _tmp5_ = NULL;
826
 
                                gchar* _tmp6_;
827
827
                                _tmp5_ = string_strip (package);
828
 
                                _tmp6_ = _tmp5_;
829
828
                                _g_free0 (package);
830
 
                                package = _tmp6_;
 
829
                                package = _tmp5_;
831
830
                                if (g_strcmp0 (package, "") != 0) {
832
831
                                        vala_code_context_add_external_package (self, package);
833
832
                                }
841
840
        __catch0_g_file_error:
842
841
        {
843
842
                GError * e;
844
 
                gchar* _tmp7_ = NULL;
845
 
                gchar* _tmp8_;
 
843
                gchar* _tmp6_ = NULL;
 
844
                gchar* _tmp7_;
846
845
                e = _inner_error_;
847
846
                _inner_error_ = NULL;
848
 
                _tmp7_ = g_strdup_printf ("Unable to read dependency file: %s", e->message);
849
 
                _tmp8_ = _tmp7_;
850
 
                vala_report_error (NULL, _tmp8_);
851
 
                _g_free0 (_tmp8_);
 
847
                _tmp6_ = g_strdup_printf ("Unable to read dependency file: %s", e->message);
 
848
                _tmp7_ = _tmp6_;
 
849
                vala_report_error (NULL, _tmp7_);
 
850
                _g_free0 (_tmp7_);
852
851
                result = FALSE;
853
852
                _g_error_free0 (e);
854
853
                return result;
872
871
 * @param is_source true to force adding the file as .vala or .gs
873
872
 * @return false if the file is not recognized or the file does not exist
874
873
 */
 
874
static glong string_strnlen (gchar* str, glong maxlen) {
 
875
        glong result = 0L;
 
876
        gchar* _tmp0_ = NULL;
 
877
        gchar* end;
 
878
        _tmp0_ = memchr (str, 0, (gsize) maxlen);
 
879
        end = _tmp0_;
 
880
        if (end == NULL) {
 
881
                result = maxlen;
 
882
                return result;
 
883
        } else {
 
884
                result = (glong) (end - str);
 
885
                return result;
 
886
        }
 
887
}
 
888
 
 
889
 
875
890
static gchar* string_substring (const gchar* self, glong offset, glong len) {
876
891
        gchar* result = NULL;
877
892
        glong string_length = 0L;
885
900
        }
886
901
        if (_tmp0_) {
887
902
                glong _tmp1_;
888
 
                _tmp1_ = strnlen ((gchar*) self, (gsize) (offset + len));
 
903
                _tmp1_ = string_strnlen ((gchar*) self, offset + len);
889
904
                string_length = _tmp1_;
890
905
        } else {
891
906
                gint _tmp2_;
960
975
                        _tmp9_ = vala_unresolved_symbol_new (NULL, "Posix", NULL);
961
976
                        _tmp10_ = _tmp9_;
962
977
                        _tmp11_ = vala_using_directive_new ((ValaSymbol*) _tmp10_, NULL);
963
 
                        ns_ref = (_tmp12_ = _tmp11_, _vala_code_node_unref0 (_tmp10_), _tmp12_);
 
978
                        _tmp12_ = _tmp11_;
 
979
                        _vala_code_node_unref0 (_tmp10_);
 
980
                        ns_ref = _tmp12_;
964
981
                        vala_source_file_add_using_directive (source_file, ns_ref);
965
982
                        _tmp13_ = vala_code_context_get_root (self);
966
983
                        vala_namespace_add_using_directive (_tmp13_, ns_ref);
976
993
                                _tmp14_ = vala_unresolved_symbol_new (NULL, "GLib", NULL);
977
994
                                _tmp15_ = _tmp14_;
978
995
                                _tmp16_ = vala_using_directive_new ((ValaSymbol*) _tmp15_, NULL);
979
 
                                ns_ref = (_tmp17_ = _tmp16_, _vala_code_node_unref0 (_tmp15_), _tmp17_);
 
996
                                _tmp17_ = _tmp16_;
 
997
                                _vala_code_node_unref0 (_tmp15_);
 
998
                                ns_ref = _tmp17_;
980
999
                                vala_source_file_add_using_directive (source_file, ns_ref);
981
1000
                                _tmp18_ = vala_code_context_get_root (self);
982
1001
                                vala_namespace_add_using_directive (_tmp18_, ns_ref);
992
1011
                                        _tmp19_ = vala_unresolved_symbol_new (NULL, "Dova", NULL);
993
1012
                                        _tmp20_ = _tmp19_;
994
1013
                                        _tmp21_ = vala_using_directive_new ((ValaSymbol*) _tmp20_, NULL);
995
 
                                        ns_ref = (_tmp22_ = _tmp21_, _vala_code_node_unref0 (_tmp20_), _tmp22_);
 
1014
                                        _tmp22_ = _tmp21_;
 
1015
                                        _vala_code_node_unref0 (_tmp20_);
 
1016
                                        ns_ref = _tmp22_;
996
1017
                                        vala_source_file_add_using_directive (source_file, ns_ref);
997
1018
                                        _tmp23_ = vala_code_context_get_root (self);
998
1019
                                        vala_namespace_add_using_directive (_tmp23_, ns_ref);
1033
1054
                        _tmp30_ = string_substring (filename, (glong) 0, (glong) (_tmp28_ - _tmp29_));
1034
1055
                        _tmp31_ = _tmp30_;
1035
1056
                        _tmp32_ = g_strdup_printf ("%s.deps", _tmp31_);
1036
 
                        deps_filename = (_tmp33_ = _tmp32_, _g_free0 (_tmp31_), _tmp33_);
 
1057
                        _tmp33_ = _tmp32_;
 
1058
                        _g_free0 (_tmp31_);
 
1059
                        deps_filename = _tmp33_;
1037
1060
                        _tmp34_ = vala_code_context_add_packages_from_file (self, deps_filename);
1038
1061
                        if (!_tmp34_) {
1039
1062
                                result = FALSE;
1142
1165
gchar* vala_code_context_get_vapi_path (ValaCodeContext* self, const gchar* pkg) {
1143
1166
        gchar* result = NULL;
1144
1167
        gchar* _tmp0_;
1145
 
        gchar* _tmp1_ = NULL;
1146
 
        gchar* _tmp2_;
 
1168
        gchar* _tmp1_;
 
1169
        gchar* _tmp2_ = NULL;
 
1170
        gchar* _tmp3_;
1147
1171
        gchar* path;
1148
1172
        g_return_val_if_fail (self != NULL, NULL);
1149
1173
        g_return_val_if_fail (pkg != NULL, NULL);
1150
1174
        _tmp0_ = g_strconcat (pkg, ".vapi", NULL);
1151
 
        _tmp1_ = vala_code_context_get_file_path (self, _tmp0_, "vala" PACKAGE_SUFFIX "/vapi", "vala/vapi", self->vapi_directories, self->vapi_directories_length1);
1152
 
        path = (_tmp2_ = _tmp1_, _g_free0 (_tmp0_), _tmp2_);
 
1175
        _tmp1_ = _tmp0_;
 
1176
        _tmp2_ = vala_code_context_get_file_path (self, _tmp1_, "vala" PACKAGE_SUFFIX "/vapi", "vala/vapi", self->vapi_directories, self->vapi_directories_length1);
 
1177
        _tmp3_ = _tmp2_;
 
1178
        _g_free0 (_tmp1_);
 
1179
        path = _tmp3_;
1153
1180
        if (path == NULL) {
1154
 
                gchar* _tmp3_;
1155
 
                gchar* _tmp4_ = NULL;
 
1181
                gchar* _tmp4_;
1156
1182
                gchar* _tmp5_;
 
1183
                gchar* _tmp6_ = NULL;
 
1184
                gchar* _tmp7_;
1157
1185
                gchar* filename;
1158
 
                gboolean _tmp6_;
1159
 
                _tmp3_ = g_strconcat (pkg, ".vapi", NULL);
1160
 
                _tmp4_ = g_build_filename (PACKAGE_DATADIR, "vapi", _tmp3_, NULL);
1161
 
                filename = (_tmp5_ = _tmp4_, _g_free0 (_tmp3_), _tmp5_);
1162
 
                _tmp6_ = g_file_test (filename, G_FILE_TEST_EXISTS);
1163
 
                if (_tmp6_) {
1164
 
                        gchar* _tmp7_;
1165
 
                        gchar* _tmp8_;
1166
 
                        _tmp7_ = g_strdup (filename);
1167
 
                        _tmp8_ = _tmp7_;
 
1186
                gboolean _tmp8_;
 
1187
                _tmp4_ = g_strconcat (pkg, ".vapi", NULL);
 
1188
                _tmp5_ = _tmp4_;
 
1189
                _tmp6_ = g_build_filename (PACKAGE_DATADIR, "vapi", _tmp5_, NULL);
 
1190
                _tmp7_ = _tmp6_;
 
1191
                _g_free0 (_tmp5_);
 
1192
                filename = _tmp7_;
 
1193
                _tmp8_ = g_file_test (filename, G_FILE_TEST_EXISTS);
 
1194
                if (_tmp8_) {
 
1195
                        gchar* _tmp9_;
 
1196
                        _tmp9_ = g_strdup (filename);
1168
1197
                        _g_free0 (path);
1169
 
                        path = _tmp8_;
 
1198
                        path = _tmp9_;
1170
1199
                }
1171
1200
                _g_free0 (filename);
1172
1201
        }
1178
1207
gchar* vala_code_context_get_gir_path (ValaCodeContext* self, const gchar* gir) {
1179
1208
        gchar* result = NULL;
1180
1209
        gchar* _tmp0_;
1181
 
        gchar* _tmp1_ = NULL;
1182
 
        gchar* _tmp2_;
 
1210
        gchar* _tmp1_;
 
1211
        gchar* _tmp2_ = NULL;
 
1212
        gchar* _tmp3_;
1183
1213
        g_return_val_if_fail (self != NULL, NULL);
1184
1214
        g_return_val_if_fail (gir != NULL, NULL);
1185
1215
        _tmp0_ = g_strconcat (gir, ".gir", NULL);
1186
 
        _tmp1_ = vala_code_context_get_file_path (self, _tmp0_, "gir-1.0", NULL, self->gir_directories, self->gir_directories_length1);
1187
 
        result = (_tmp2_ = _tmp1_, _g_free0 (_tmp0_), _tmp2_);
 
1216
        _tmp1_ = _tmp0_;
 
1217
        _tmp2_ = vala_code_context_get_file_path (self, _tmp1_, "gir-1.0", NULL, self->gir_directories, self->gir_directories_length1);
 
1218
        _tmp3_ = _tmp2_;
 
1219
        _g_free0 (_tmp1_);
 
1220
        result = _tmp3_;
1188
1221
        return result;
1189
1222
}
1190
1223
 
1192
1225
static gchar* vala_code_context_get_file_path (ValaCodeContext* self, const gchar* basename, const gchar* versioned_data_dir, const gchar* data_dir, gchar** directories, int directories_length1) {
1193
1226
        gchar* result = NULL;
1194
1227
        gchar* filename;
1195
 
        gchar** _tmp4_;
1196
 
        gchar** _tmp5_ = NULL;
 
1228
        gchar** _tmp3_;
 
1229
        gchar** _tmp4_ = NULL;
1197
1230
        g_return_val_if_fail (self != NULL, NULL);
1198
1231
        g_return_val_if_fail (basename != NULL, NULL);
1199
1232
        g_return_val_if_fail (versioned_data_dir != NULL, NULL);
1212
1245
                                dir = _tmp0_;
1213
1246
                                {
1214
1247
                                        gchar* _tmp1_ = NULL;
1215
 
                                        gchar* _tmp2_;
1216
 
                                        gboolean _tmp3_;
 
1248
                                        gboolean _tmp2_;
1217
1249
                                        _tmp1_ = g_build_filename (dir, basename, NULL);
1218
 
                                        _tmp2_ = _tmp1_;
1219
1250
                                        _g_free0 (filename);
1220
 
                                        filename = _tmp2_;
1221
 
                                        _tmp3_ = g_file_test (filename, G_FILE_TEST_EXISTS);
1222
 
                                        if (_tmp3_) {
 
1251
                                        filename = _tmp1_;
 
1252
                                        _tmp2_ = g_file_test (filename, G_FILE_TEST_EXISTS);
 
1253
                                        if (_tmp2_) {
1223
1254
                                                result = filename;
1224
1255
                                                _g_free0 (dir);
1225
1256
                                                return result;
1229
1260
                        }
1230
1261
                }
1231
1262
        }
1232
 
        _tmp5_ = _tmp4_ = g_get_system_data_dirs ();
 
1263
        _tmp4_ = _tmp3_ = g_get_system_data_dirs ();
1233
1264
        {
1234
1265
                gchar** dir_collection;
1235
1266
                int dir_collection_length1;
1236
1267
                int dir_it;
1237
 
                dir_collection = _tmp5_;
1238
 
                dir_collection_length1 = _vala_array_length (_tmp4_);
1239
 
                for (dir_it = 0; dir_it < _vala_array_length (_tmp4_); dir_it = dir_it + 1) {
1240
 
                        gchar* _tmp6_;
 
1268
                dir_collection = _tmp4_;
 
1269
                dir_collection_length1 = _vala_array_length (_tmp3_);
 
1270
                for (dir_it = 0; dir_it < _vala_array_length (_tmp3_); dir_it = dir_it + 1) {
 
1271
                        gchar* _tmp5_;
1241
1272
                        gchar* dir;
1242
 
                        _tmp6_ = g_strdup (dir_collection[dir_it]);
1243
 
                        dir = _tmp6_;
 
1273
                        _tmp5_ = g_strdup (dir_collection[dir_it]);
 
1274
                        dir = _tmp5_;
1244
1275
                        {
1245
 
                                gchar* _tmp7_ = NULL;
1246
 
                                gchar* _tmp8_;
1247
 
                                gboolean _tmp9_;
1248
 
                                _tmp7_ = g_build_filename (dir, versioned_data_dir, basename, NULL);
1249
 
                                _tmp8_ = _tmp7_;
 
1276
                                gchar* _tmp6_ = NULL;
 
1277
                                gboolean _tmp7_;
 
1278
                                _tmp6_ = g_build_filename (dir, versioned_data_dir, basename, NULL);
1250
1279
                                _g_free0 (filename);
1251
 
                                filename = _tmp8_;
1252
 
                                _tmp9_ = g_file_test (filename, G_FILE_TEST_EXISTS);
1253
 
                                if (_tmp9_) {
 
1280
                                filename = _tmp6_;
 
1281
                                _tmp7_ = g_file_test (filename, G_FILE_TEST_EXISTS);
 
1282
                                if (_tmp7_) {
1254
1283
                                        result = filename;
1255
1284
                                        _g_free0 (dir);
1256
1285
                                        return result;
1260
1289
                }
1261
1290
        }
1262
1291
        if (data_dir != NULL) {
1263
 
                gchar** _tmp10_;
1264
 
                gchar** _tmp11_ = NULL;
1265
 
                _tmp11_ = _tmp10_ = g_get_system_data_dirs ();
 
1292
                gchar** _tmp8_;
 
1293
                gchar** _tmp9_ = NULL;
 
1294
                _tmp9_ = _tmp8_ = g_get_system_data_dirs ();
1266
1295
                {
1267
1296
                        gchar** dir_collection;
1268
1297
                        int dir_collection_length1;
1269
1298
                        int dir_it;
1270
 
                        dir_collection = _tmp11_;
1271
 
                        dir_collection_length1 = _vala_array_length (_tmp10_);
1272
 
                        for (dir_it = 0; dir_it < _vala_array_length (_tmp10_); dir_it = dir_it + 1) {
1273
 
                                gchar* _tmp12_;
 
1299
                        dir_collection = _tmp9_;
 
1300
                        dir_collection_length1 = _vala_array_length (_tmp8_);
 
1301
                        for (dir_it = 0; dir_it < _vala_array_length (_tmp8_); dir_it = dir_it + 1) {
 
1302
                                gchar* _tmp10_;
1274
1303
                                gchar* dir;
1275
 
                                _tmp12_ = g_strdup (dir_collection[dir_it]);
1276
 
                                dir = _tmp12_;
 
1304
                                _tmp10_ = g_strdup (dir_collection[dir_it]);
 
1305
                                dir = _tmp10_;
1277
1306
                                {
1278
 
                                        gchar* _tmp13_ = NULL;
1279
 
                                        gchar* _tmp14_;
1280
 
                                        gboolean _tmp15_;
1281
 
                                        _tmp13_ = g_build_filename (dir, data_dir, basename, NULL);
1282
 
                                        _tmp14_ = _tmp13_;
 
1307
                                        gchar* _tmp11_ = NULL;
 
1308
                                        gboolean _tmp12_;
 
1309
                                        _tmp11_ = g_build_filename (dir, data_dir, basename, NULL);
1283
1310
                                        _g_free0 (filename);
1284
 
                                        filename = _tmp14_;
1285
 
                                        _tmp15_ = g_file_test (filename, G_FILE_TEST_EXISTS);
1286
 
                                        if (_tmp15_) {
 
1311
                                        filename = _tmp11_;
 
1312
                                        _tmp12_ = g_file_test (filename, G_FILE_TEST_EXISTS);
 
1313
                                        if (_tmp12_) {
1287
1314
                                                result = filename;
1288
1315
                                                _g_free0 (dir);
1289
1316
                                                return result;
1391
1418
        const gchar* start = NULL;
1392
1419
        const gchar* end = NULL;
1393
1420
        gboolean _tmp0_;
1394
 
        const gchar* _tmp6_ = NULL;
 
1421
        const gchar* _tmp4_ = NULL;
1395
1422
        glong root_len;
1396
 
        gboolean _tmp33_ = FALSE;
1397
 
        gint _tmp34_;
 
1423
        gboolean _tmp30_ = FALSE;
 
1424
        gint _tmp31_;
1398
1425
        g_return_val_if_fail (name != NULL, NULL);
1399
1426
        _tmp0_ = g_path_is_absolute (name);
1400
1427
        if (!_tmp0_) {
1401
1428
                gchar* _tmp1_ = NULL;
1402
 
                gchar* _tmp2_;
1403
1429
                _tmp1_ = g_get_current_dir ();
1404
 
                _tmp2_ = _tmp1_;
1405
1430
                _g_free0 (rpath);
1406
 
                rpath = _tmp2_;
 
1431
                rpath = _tmp1_;
1407
1432
                end = name;
1408
1433
                start = end;
1409
1434
        } else {
1410
 
                const gchar* _tmp3_ = NULL;
1411
 
                gchar* _tmp4_ = NULL;
1412
 
                gchar* _tmp5_;
1413
 
                _tmp3_ = g_path_skip_root (name);
1414
 
                end = _tmp3_;
 
1435
                const gchar* _tmp2_ = NULL;
 
1436
                gchar* _tmp3_ = NULL;
 
1437
                _tmp2_ = g_path_skip_root (name);
 
1438
                end = _tmp2_;
1415
1439
                start = end;
1416
 
                _tmp4_ = string_substring (name, (glong) 0, (glong) ((gint) (((gchar*) start) - ((gchar*) name))));
1417
 
                _tmp5_ = _tmp4_;
 
1440
                _tmp3_ = string_substring (name, (glong) 0, (glong) ((gint) (((gchar*) start) - ((gchar*) name))));
1418
1441
                _g_free0 (rpath);
1419
 
                rpath = _tmp5_;
 
1442
                rpath = _tmp3_;
1420
1443
        }
1421
 
        _tmp6_ = g_path_skip_root (rpath);
1422
 
        root_len = (glong) (((gchar*) _tmp6_) - ((gchar*) rpath));
 
1444
        _tmp4_ = g_path_skip_root (rpath);
 
1445
        root_len = (glong) (((gchar*) _tmp4_) - ((gchar*) rpath));
1423
1446
        {
1424
 
                gboolean _tmp7_;
1425
 
                _tmp7_ = TRUE;
 
1447
                gboolean _tmp5_;
 
1448
                _tmp5_ = TRUE;
1426
1449
                while (TRUE) {
1427
 
                        gunichar _tmp8_;
 
1450
                        gunichar _tmp6_;
1428
1451
                        glong len;
1429
 
                        if (!_tmp7_) {
 
1452
                        if (!_tmp5_) {
1430
1453
                                start = end;
1431
1454
                        }
1432
 
                        _tmp7_ = FALSE;
1433
 
                        _tmp8_ = string_get_char (start, (glong) 0);
1434
 
                        if (!(_tmp8_ != 0)) {
 
1455
                        _tmp5_ = FALSE;
 
1456
                        _tmp6_ = string_get_char (start, (glong) 0);
 
1457
                        if (!(_tmp6_ != 0)) {
1435
1458
                                break;
1436
1459
                        }
1437
1460
                        while (TRUE) {
1438
 
                                gunichar _tmp9_;
1439
 
                                gboolean _tmp10_;
1440
 
                                const gchar* _tmp11_ = NULL;
1441
 
                                _tmp9_ = string_get_char (start, (glong) 0);
1442
 
                                _tmp10_ = G_IS_DIR_SEPARATOR (_tmp9_);
1443
 
                                if (!_tmp10_) {
 
1461
                                gunichar _tmp7_;
 
1462
                                gboolean _tmp8_;
 
1463
                                const gchar* _tmp9_ = NULL;
 
1464
                                _tmp7_ = string_get_char (start, (glong) 0);
 
1465
                                _tmp8_ = G_IS_DIR_SEPARATOR (_tmp7_);
 
1466
                                if (!_tmp8_) {
1444
1467
                                        break;
1445
1468
                                }
1446
 
                                _tmp11_ = g_utf8_next_char (start);
1447
 
                                start = _tmp11_;
 
1469
                                _tmp9_ = g_utf8_next_char (start);
 
1470
                                start = _tmp9_;
1448
1471
                        }
1449
1472
                        len = (glong) 0;
1450
1473
                        {
1451
 
                                gboolean _tmp12_;
 
1474
                                gboolean _tmp10_;
1452
1475
                                end = start;
1453
 
                                _tmp12_ = TRUE;
 
1476
                                _tmp10_ = TRUE;
1454
1477
                                while (TRUE) {
1455
 
                                        gboolean _tmp14_ = FALSE;
1456
 
                                        gunichar _tmp15_;
 
1478
                                        gboolean _tmp12_ = FALSE;
 
1479
                                        gunichar _tmp13_;
 
1480
                                        if (!_tmp10_) {
 
1481
                                                const gchar* _tmp11_ = NULL;
 
1482
                                                _tmp11_ = g_utf8_next_char (end);
 
1483
                                                end = _tmp11_;
 
1484
                                        }
 
1485
                                        _tmp10_ = FALSE;
 
1486
                                        _tmp13_ = string_get_char (end, (glong) 0);
 
1487
                                        if (_tmp13_ != 0) {
 
1488
                                                gunichar _tmp14_;
 
1489
                                                gboolean _tmp15_;
 
1490
                                                _tmp14_ = string_get_char (end, (glong) 0);
 
1491
                                                _tmp15_ = G_IS_DIR_SEPARATOR (_tmp14_);
 
1492
                                                _tmp12_ = !_tmp15_;
 
1493
                                        } else {
 
1494
                                                _tmp12_ = FALSE;
 
1495
                                        }
1457
1496
                                        if (!_tmp12_) {
1458
 
                                                const gchar* _tmp13_ = NULL;
1459
 
                                                _tmp13_ = g_utf8_next_char (end);
1460
 
                                                end = _tmp13_;
1461
 
                                        }
1462
 
                                        _tmp12_ = FALSE;
1463
 
                                        _tmp15_ = string_get_char (end, (glong) 0);
1464
 
                                        if (_tmp15_ != 0) {
1465
 
                                                gunichar _tmp16_;
1466
 
                                                gboolean _tmp17_;
1467
 
                                                _tmp16_ = string_get_char (end, (glong) 0);
1468
 
                                                _tmp17_ = G_IS_DIR_SEPARATOR (_tmp16_);
1469
 
                                                _tmp14_ = !_tmp17_;
1470
 
                                        } else {
1471
 
                                                _tmp14_ = FALSE;
1472
 
                                        }
1473
 
                                        if (!_tmp14_) {
1474
1497
                                                break;
1475
1498
                                        }
1476
1499
                                        len++;
1479
1502
                        if (len == 0) {
1480
1503
                                break;
1481
1504
                        } else {
1482
 
                                gboolean _tmp18_ = FALSE;
 
1505
                                gboolean _tmp16_ = FALSE;
1483
1506
                                if (len == 1) {
1484
 
                                        gunichar _tmp19_;
1485
 
                                        _tmp19_ = string_get_char (start, (glong) 0);
1486
 
                                        _tmp18_ = _tmp19_ == '.';
 
1507
                                        gunichar _tmp17_;
 
1508
                                        _tmp17_ = string_get_char (start, (glong) 0);
 
1509
                                        _tmp16_ = _tmp17_ == '.';
1487
1510
                                } else {
1488
 
                                        _tmp18_ = FALSE;
 
1511
                                        _tmp16_ = FALSE;
1489
1512
                                }
1490
 
                                if (_tmp18_) {
 
1513
                                if (_tmp16_) {
1491
1514
                                } else {
1492
 
                                        gboolean _tmp20_ = FALSE;
 
1515
                                        gboolean _tmp18_ = FALSE;
1493
1516
                                        if (len == 2) {
1494
 
                                                gboolean _tmp21_;
1495
 
                                                _tmp21_ = g_str_has_prefix (start, "..");
1496
 
                                                _tmp20_ = _tmp21_;
 
1517
                                                gboolean _tmp19_;
 
1518
                                                _tmp19_ = g_str_has_prefix (start, "..");
 
1519
                                                _tmp18_ = _tmp19_;
1497
1520
                                        } else {
1498
 
                                                _tmp20_ = FALSE;
 
1521
                                                _tmp18_ = FALSE;
1499
1522
                                        }
1500
 
                                        if (_tmp20_) {
1501
 
                                                gint _tmp22_;
1502
 
                                                _tmp22_ = strlen (rpath);
1503
 
                                                if (_tmp22_ > root_len) {
 
1523
                                        if (_tmp18_) {
 
1524
                                                gint _tmp20_;
 
1525
                                                _tmp20_ = strlen (rpath);
 
1526
                                                if (_tmp20_ > root_len) {
1504
1527
                                                        {
1505
 
                                                                gboolean _tmp23_;
1506
 
                                                                _tmp23_ = TRUE;
 
1528
                                                                gboolean _tmp21_;
 
1529
                                                                _tmp21_ = TRUE;
1507
1530
                                                                while (TRUE) {
1508
 
                                                                        gint _tmp25_;
1509
 
                                                                        gchar* _tmp26_ = NULL;
1510
 
                                                                        gchar* _tmp27_;
1511
 
                                                                        if (!_tmp23_) {
1512
 
                                                                                gboolean _tmp24_;
1513
 
                                                                                _tmp24_ = vala_code_context_ends_with_dir_separator (rpath);
1514
 
                                                                                if (!(!_tmp24_)) {
 
1531
                                                                        gint _tmp23_;
 
1532
                                                                        gchar* _tmp24_ = NULL;
 
1533
                                                                        if (!_tmp21_) {
 
1534
                                                                                gboolean _tmp22_;
 
1535
                                                                                _tmp22_ = vala_code_context_ends_with_dir_separator (rpath);
 
1536
                                                                                if (!(!_tmp22_)) {
1515
1537
                                                                                        break;
1516
1538
                                                                                }
1517
1539
                                                                        }
1518
 
                                                                        _tmp23_ = FALSE;
1519
 
                                                                        _tmp25_ = strlen (rpath);
1520
 
                                                                        _tmp26_ = string_substring (rpath, (glong) 0, (glong) (_tmp25_ - 1));
1521
 
                                                                        _tmp27_ = _tmp26_;
 
1540
                                                                        _tmp21_ = FALSE;
 
1541
                                                                        _tmp23_ = strlen (rpath);
 
1542
                                                                        _tmp24_ = string_substring (rpath, (glong) 0, (glong) (_tmp23_ - 1));
1522
1543
                                                                        _g_free0 (rpath);
1523
 
                                                                        rpath = _tmp27_;
 
1544
                                                                        rpath = _tmp24_;
1524
1545
                                                                }
1525
1546
                                                        }
1526
1547
                                                }
1527
1548
                                        } else {
1528
 
                                                gboolean _tmp28_;
1529
 
                                                gchar* _tmp30_ = NULL;
1530
 
                                                gchar* _tmp31_;
1531
 
                                                gchar* _tmp32_;
1532
 
                                                _tmp28_ = vala_code_context_ends_with_dir_separator (rpath);
1533
 
                                                if (!_tmp28_) {
1534
 
                                                        gchar* _tmp29_;
1535
 
                                                        _tmp29_ = g_strconcat (rpath, G_DIR_SEPARATOR_S, NULL);
 
1549
                                                gboolean _tmp25_;
 
1550
                                                gchar* _tmp27_ = NULL;
 
1551
                                                gchar* _tmp28_;
 
1552
                                                gchar* _tmp29_;
 
1553
                                                _tmp25_ = vala_code_context_ends_with_dir_separator (rpath);
 
1554
                                                if (!_tmp25_) {
 
1555
                                                        gchar* _tmp26_;
 
1556
                                                        _tmp26_ = g_strconcat (rpath, G_DIR_SEPARATOR_S, NULL);
1536
1557
                                                        _g_free0 (rpath);
1537
 
                                                        rpath = _tmp29_;
 
1558
                                                        rpath = _tmp26_;
1538
1559
                                                }
1539
 
                                                _tmp30_ = string_substring (start, (glong) 0, len);
1540
 
                                                _tmp31_ = _tmp30_;
1541
 
                                                _tmp32_ = g_strconcat (rpath, _tmp31_, NULL);
 
1560
                                                _tmp27_ = string_substring (start, (glong) 0, len);
 
1561
                                                _tmp28_ = _tmp27_;
 
1562
                                                _tmp29_ = g_strconcat (rpath, _tmp28_, NULL);
1542
1563
                                                _g_free0 (rpath);
1543
 
                                                rpath = _tmp32_;
1544
 
                                                _g_free0 (_tmp31_);
 
1564
                                                rpath = _tmp29_;
 
1565
                                                _g_free0 (_tmp28_);
1545
1566
                                        }
1546
1567
                                }
1547
1568
                        }
1548
1569
                }
1549
1570
        }
1550
 
        _tmp34_ = strlen (rpath);
1551
 
        if (_tmp34_ > root_len) {
1552
 
                gboolean _tmp35_;
1553
 
                _tmp35_ = vala_code_context_ends_with_dir_separator (rpath);
1554
 
                _tmp33_ = _tmp35_;
 
1571
        _tmp31_ = strlen (rpath);
 
1572
        if (_tmp31_ > root_len) {
 
1573
                gboolean _tmp32_;
 
1574
                _tmp32_ = vala_code_context_ends_with_dir_separator (rpath);
 
1575
                _tmp30_ = _tmp32_;
1555
1576
        } else {
1556
 
                _tmp33_ = FALSE;
 
1577
                _tmp30_ = FALSE;
1557
1578
        }
1558
 
        if (_tmp33_) {
1559
 
                gint _tmp36_;
1560
 
                gchar* _tmp37_ = NULL;
1561
 
                gchar* _tmp38_;
1562
 
                _tmp36_ = strlen (rpath);
1563
 
                _tmp37_ = string_substring (rpath, (glong) 0, (glong) (_tmp36_ - 1));
1564
 
                _tmp38_ = _tmp37_;
 
1579
        if (_tmp30_) {
 
1580
                gint _tmp33_;
 
1581
                gchar* _tmp34_ = NULL;
 
1582
                _tmp33_ = strlen (rpath);
 
1583
                _tmp34_ = string_substring (rpath, (glong) 0, (glong) (_tmp33_ - 1));
1565
1584
                _g_free0 (rpath);
1566
 
                rpath = _tmp38_;
 
1585
                rpath = _tmp34_;
1567
1586
        }
1568
1587
        if (G_DIR_SEPARATOR != '/') {
1569
 
                gchar** _tmp39_;
1570
 
                gchar** _tmp40_ = NULL;
 
1588
                gchar** _tmp35_;
 
1589
                gchar** _tmp36_ = NULL;
1571
1590
                gchar** components;
1572
1591
                gint components_length1;
1573
1592
                gint _components_size_;
1574
 
                gchar* _tmp41_ = NULL;
1575
 
                gchar* _tmp42_;
1576
 
                _tmp40_ = _tmp39_ = g_strsplit (rpath, "\\", 0);
1577
 
                components = _tmp40_;
1578
 
                components_length1 = _vala_array_length (_tmp39_);
1579
 
                _components_size_ = _vala_array_length (_tmp39_);
1580
 
                _tmp41_ = g_strjoinv ("/", components);
1581
 
                _tmp42_ = _tmp41_;
 
1593
                gchar* _tmp37_ = NULL;
 
1594
                _tmp36_ = _tmp35_ = g_strsplit (rpath, "\\", 0);
 
1595
                components = _tmp36_;
 
1596
                components_length1 = _vala_array_length (_tmp35_);
 
1597
                _components_size_ = _vala_array_length (_tmp35_);
 
1598
                _tmp37_ = g_strjoinv ("/", components);
1582
1599
                _g_free0 (rpath);
1583
 
                rpath = _tmp42_;
 
1600
                rpath = _tmp37_;
1584
1601
                components = (_vala_array_free (components, components_length1, (GDestroyNotify) g_free), NULL);
1585
1602
        }
1586
1603
        result = rpath;
1696
1713
 
1697
1714
void vala_code_context_set_header_filename (ValaCodeContext* self, const gchar* value) {
1698
1715
        gchar* _tmp0_;
1699
 
        gchar* _tmp1_;
1700
1716
        g_return_if_fail (self != NULL);
1701
1717
        _tmp0_ = g_strdup (value);
1702
 
        _tmp1_ = _tmp0_;
1703
1718
        _g_free0 (self->priv->_header_filename);
1704
 
        self->priv->_header_filename = _tmp1_;
 
1719
        self->priv->_header_filename = _tmp0_;
1705
1720
}
1706
1721
 
1707
1722
 
1715
1730
 
1716
1731
void vala_code_context_set_internal_header_filename (ValaCodeContext* self, const gchar* value) {
1717
1732
        gchar* _tmp0_;
1718
 
        gchar* _tmp1_;
1719
1733
        g_return_if_fail (self != NULL);
1720
1734
        _tmp0_ = g_strdup (value);
1721
 
        _tmp1_ = _tmp0_;
1722
1735
        _g_free0 (self->priv->_internal_header_filename);
1723
 
        self->priv->_internal_header_filename = _tmp1_;
 
1736
        self->priv->_internal_header_filename = _tmp0_;
1724
1737
}
1725
1738
 
1726
1739
 
1748
1761
 
1749
1762
void vala_code_context_set_includedir (ValaCodeContext* self, const gchar* value) {
1750
1763
        gchar* _tmp0_;
1751
 
        gchar* _tmp1_;
1752
1764
        g_return_if_fail (self != NULL);
1753
1765
        _tmp0_ = g_strdup (value);
1754
 
        _tmp1_ = _tmp0_;
1755
1766
        _g_free0 (self->priv->_includedir);
1756
 
        self->priv->_includedir = _tmp1_;
 
1767
        self->priv->_includedir = _tmp0_;
1757
1768
}
1758
1769
 
1759
1770
 
1767
1778
 
1768
1779
void vala_code_context_set_symbols_filename (ValaCodeContext* self, const gchar* value) {
1769
1780
        gchar* _tmp0_;
1770
 
        gchar* _tmp1_;
1771
1781
        g_return_if_fail (self != NULL);
1772
1782
        _tmp0_ = g_strdup (value);
1773
 
        _tmp1_ = _tmp0_;
1774
1783
        _g_free0 (self->priv->_symbols_filename);
1775
 
        self->priv->_symbols_filename = _tmp1_;
 
1784
        self->priv->_symbols_filename = _tmp0_;
1776
1785
}
1777
1786
 
1778
1787
 
1800
1809
 
1801
1810
void vala_code_context_set_output (ValaCodeContext* self, const gchar* value) {
1802
1811
        gchar* _tmp0_;
1803
 
        gchar* _tmp1_;
1804
1812
        g_return_if_fail (self != NULL);
1805
1813
        _tmp0_ = g_strdup (value);
1806
 
        _tmp1_ = _tmp0_;
1807
1814
        _g_free0 (self->priv->_output);
1808
 
        self->priv->_output = _tmp1_;
 
1815
        self->priv->_output = _tmp0_;
1809
1816
}
1810
1817
 
1811
1818
 
1819
1826
 
1820
1827
void vala_code_context_set_basedir (ValaCodeContext* self, const gchar* value) {
1821
1828
        gchar* _tmp0_;
1822
 
        gchar* _tmp1_;
1823
1829
        g_return_if_fail (self != NULL);
1824
1830
        _tmp0_ = g_strdup (value);
1825
 
        _tmp1_ = _tmp0_;
1826
1831
        _g_free0 (self->priv->_basedir);
1827
 
        self->priv->_basedir = _tmp1_;
 
1832
        self->priv->_basedir = _tmp0_;
1828
1833
}
1829
1834
 
1830
1835
 
1838
1843
 
1839
1844
void vala_code_context_set_directory (ValaCodeContext* self, const gchar* value) {
1840
1845
        gchar* _tmp0_;
1841
 
        gchar* _tmp1_;
1842
1846
        g_return_if_fail (self != NULL);
1843
1847
        _tmp0_ = g_strdup (value);
1844
 
        _tmp1_ = _tmp0_;
1845
1848
        _g_free0 (self->priv->_directory);
1846
 
        self->priv->_directory = _tmp1_;
 
1849
        self->priv->_directory = _tmp0_;
1847
1850
}
1848
1851
 
1849
1852
 
1918
1921
 
1919
1922
void vala_code_context_set_module_init_method (ValaCodeContext* self, ValaMethod* value) {
1920
1923
        ValaMethod* _tmp0_;
1921
 
        ValaMethod* _tmp1_;
1922
1924
        g_return_if_fail (self != NULL);
1923
1925
        _tmp0_ = _vala_code_node_ref0 (value);
1924
 
        _tmp1_ = _tmp0_;
1925
1926
        _vala_code_node_unref0 (self->priv->_module_init_method);
1926
 
        self->priv->_module_init_method = _tmp1_;
 
1927
        self->priv->_module_init_method = _tmp0_;
1927
1928
}
1928
1929
 
1929
1930
 
2048
2049
 
2049
2050
void vala_code_context_set_report (ValaCodeContext* self, ValaReport* value) {
2050
2051
        ValaReport* _tmp0_;
2051
 
        ValaReport* _tmp1_;
2052
2052
        g_return_if_fail (self != NULL);
2053
2053
        _tmp0_ = _g_object_ref0 (value);
2054
 
        _tmp1_ = _tmp0_;
2055
2054
        _g_object_unref0 (self->priv->_report);
2056
 
        self->priv->_report = _tmp1_;
 
2055
        self->priv->_report = _tmp0_;
2057
2056
}
2058
2057
 
2059
2058
 
2067
2066
 
2068
2067
void vala_code_context_set_entry_point (ValaCodeContext* self, ValaMethod* value) {
2069
2068
        ValaMethod* _tmp0_;
2070
 
        ValaMethod* _tmp1_;
2071
2069
        g_return_if_fail (self != NULL);
2072
2070
        _tmp0_ = _vala_code_node_ref0 (value);
2073
 
        _tmp1_ = _tmp0_;
2074
2071
        _vala_code_node_unref0 (self->priv->_entry_point);
2075
 
        self->priv->_entry_point = _tmp1_;
 
2072
        self->priv->_entry_point = _tmp0_;
2076
2073
}
2077
2074
 
2078
2075
 
2086
2083
 
2087
2084
void vala_code_context_set_entry_point_name (ValaCodeContext* self, const gchar* value) {
2088
2085
        gchar* _tmp0_;
2089
 
        gchar* _tmp1_;
2090
2086
        g_return_if_fail (self != NULL);
2091
2087
        _tmp0_ = g_strdup (value);
2092
 
        _tmp1_ = _tmp0_;
2093
2088
        _g_free0 (self->priv->_entry_point_name);
2094
 
        self->priv->_entry_point_name = _tmp1_;
 
2089
        self->priv->_entry_point_name = _tmp0_;
2095
2090
}
2096
2091
 
2097
2092
 
2132
2127
 
2133
2128
static void vala_code_context_set_resolver (ValaCodeContext* self, ValaSymbolResolver* value) {
2134
2129
        ValaSymbolResolver* _tmp0_;
2135
 
        ValaSymbolResolver* _tmp1_;
2136
2130
        g_return_if_fail (self != NULL);
2137
2131
        _tmp0_ = _vala_code_visitor_ref0 (value);
2138
 
        _tmp1_ = _tmp0_;
2139
2132
        _vala_code_visitor_unref0 (self->priv->_resolver);
2140
 
        self->priv->_resolver = _tmp1_;
 
2133
        self->priv->_resolver = _tmp0_;
2141
2134
}
2142
2135
 
2143
2136
 
2151
2144
 
2152
2145
static void vala_code_context_set_analyzer (ValaCodeContext* self, ValaSemanticAnalyzer* value) {
2153
2146
        ValaSemanticAnalyzer* _tmp0_;
2154
 
        ValaSemanticAnalyzer* _tmp1_;
2155
2147
        g_return_if_fail (self != NULL);
2156
2148
        _tmp0_ = _vala_code_visitor_ref0 (value);
2157
 
        _tmp1_ = _tmp0_;
2158
2149
        _vala_code_visitor_unref0 (self->priv->_analyzer);
2159
 
        self->priv->_analyzer = _tmp1_;
 
2150
        self->priv->_analyzer = _tmp0_;
2160
2151
}
2161
2152
 
2162
2153
 
2170
2161
 
2171
2162
static void vala_code_context_set_flow_analyzer (ValaCodeContext* self, ValaFlowAnalyzer* value) {
2172
2163
        ValaFlowAnalyzer* _tmp0_;
2173
 
        ValaFlowAnalyzer* _tmp1_;
2174
2164
        g_return_if_fail (self != NULL);
2175
2165
        _tmp0_ = _vala_code_visitor_ref0 (value);
2176
 
        _tmp1_ = _tmp0_;
2177
2166
        _vala_code_visitor_unref0 (self->priv->_flow_analyzer);
2178
 
        self->priv->_flow_analyzer = _tmp1_;
 
2167
        self->priv->_flow_analyzer = _tmp0_;
2179
2168
}
2180
2169
 
2181
2170
 
2189
2178
 
2190
2179
void vala_code_context_set_codegen (ValaCodeContext* self, ValaCodeGenerator* value) {
2191
2180
        ValaCodeGenerator* _tmp0_;
2192
 
        ValaCodeGenerator* _tmp1_;
2193
2181
        g_return_if_fail (self != NULL);
2194
2182
        _tmp0_ = _vala_code_visitor_ref0 (value);
2195
 
        _tmp1_ = _tmp0_;
2196
2183
        _vala_code_visitor_unref0 (self->priv->_codegen);
2197
 
        self->priv->_codegen = _tmp1_;
 
2184
        self->priv->_codegen = _tmp0_;
2198
2185
}
2199
2186
 
2200
2187