← Back to branch summary

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

« back to all changes in this revision

Viewing changes to vala/valaenum.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/valaenum.c
460
460
        gboolean (*is_instance_member) (ValaSymbol* self);
461
461
        gboolean (*is_class_member) (ValaSymbol* self);
462
462
        void (*process_deprecated_attribute) (ValaSymbol* self, ValaAttribute* attr);
 
463
        void (*process_experimental_attribute) (ValaSymbol* self, ValaAttribute* attr);
463
464
        void (*add_namespace) (ValaSymbol* self, ValaNamespace* ns);
464
465
        void (*add_class) (ValaSymbol* self, ValaClass* cl);
465
466
        void (*add_interface) (ValaSymbol* self, ValaInterface* iface);
817
818
                _tmp13_ = vala_code_context_get ();
818
819
                _tmp14_ = _tmp13_;
819
820
                _tmp15_ = vala_code_context_get_profile (_tmp14_);
820
 
                if ((_tmp16_ = _tmp15_ == VALA_PROFILE_DOVA, _vala_code_context_unref0 (_tmp14_), _tmp16_)) {
 
821
                _tmp16_ = _tmp15_ == VALA_PROFILE_DOVA;
 
822
                _vala_code_context_unref0 (_tmp14_);
 
823
                if (_tmp16_) {
821
824
                        _tmp12_ = TRUE;
822
825
                } else {
823
826
                        ValaList* _tmp17_ = NULL;
1027
1030
static gchar* vala_enum_real_get_cname (ValaTypeSymbol* base, gboolean const_type) {
1028
1031
        ValaEnum * self;
1029
1032
        gchar* result = NULL;
1030
 
        gchar* _tmp9_;
 
1033
        gchar* _tmp7_;
1031
1034
        self = (ValaEnum*) base;
1032
1035
        if (self->priv->cname == NULL) {
1033
1036
                ValaAttribute* _tmp0_ = NULL;
1036
1039
                attr = _tmp0_;
1037
1040
                if (attr != NULL) {
1038
1041
                        gchar* _tmp1_ = NULL;
1039
 
                        gchar* _tmp2_;
1040
1042
                        _tmp1_ = vala_attribute_get_string (attr, "cname");
1041
 
                        _tmp2_ = _tmp1_;
1042
1043
                        _g_free0 (self->priv->cname);
1043
 
                        self->priv->cname = _tmp2_;
 
1044
                        self->priv->cname = _tmp1_;
1044
1045
                }
1045
1046
                if (self->priv->cname == NULL) {
1046
 
                        ValaSymbol* _tmp3_ = NULL;
1047
 
                        gchar* _tmp4_ = NULL;
1048
 
                        gchar* _tmp5_;
1049
 
                        const gchar* _tmp6_ = NULL;
1050
 
                        gchar* _tmp7_ = NULL;
1051
 
                        gchar* _tmp8_;
1052
 
                        _tmp3_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
1053
 
                        _tmp4_ = vala_symbol_get_cprefix (_tmp3_);
1054
 
                        _tmp5_ = _tmp4_;
1055
 
                        _tmp6_ = vala_symbol_get_name ((ValaSymbol*) self);
1056
 
                        _tmp7_ = g_strdup_printf ("%s%s", _tmp5_, _tmp6_);
1057
 
                        _tmp8_ = _tmp7_;
 
1047
                        ValaSymbol* _tmp2_ = NULL;
 
1048
                        gchar* _tmp3_ = NULL;
 
1049
                        gchar* _tmp4_;
 
1050
                        const gchar* _tmp5_ = NULL;
 
1051
                        gchar* _tmp6_ = NULL;
 
1052
                        _tmp2_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
 
1053
                        _tmp3_ = vala_symbol_get_cprefix (_tmp2_);
 
1054
                        _tmp4_ = _tmp3_;
 
1055
                        _tmp5_ = vala_symbol_get_name ((ValaSymbol*) self);
 
1056
                        _tmp6_ = g_strdup_printf ("%s%s", _tmp4_, _tmp5_);
1058
1057
                        _g_free0 (self->priv->cname);
1059
 
                        self->priv->cname = _tmp8_;
1060
 
                        _g_free0 (_tmp5_);
 
1058
                        self->priv->cname = _tmp6_;
 
1059
                        _g_free0 (_tmp4_);
1061
1060
                }
1062
1061
                _vala_code_node_unref0 (attr);
1063
1062
        }
1064
 
        _tmp9_ = g_strdup (self->priv->cname);
1065
 
        result = _tmp9_;
 
1063
        _tmp7_ = g_strdup (self->priv->cname);
 
1064
        result = _tmp7_;
1066
1065
        return result;
1067
1066
}
1068
1067
 
1069
1068
 
1070
1069
void vala_enum_set_cname (ValaEnum* self, const gchar* cname) {
1071
1070
        gchar* _tmp0_;
1072
 
        gchar* _tmp1_;
1073
1071
        g_return_if_fail (self != NULL);
1074
1072
        g_return_if_fail (cname != NULL);
1075
1073
        _tmp0_ = g_strdup (cname);
1076
 
        _tmp1_ = _tmp0_;
1077
1074
        _g_free0 (self->priv->cname);
1078
 
        self->priv->cname = _tmp1_;
 
1075
        self->priv->cname = _tmp0_;
1079
1076
}
1080
1077
 
1081
1078
 
1082
1079
static gchar* vala_enum_real_get_lower_case_cprefix (ValaSymbol* base) {
1083
1080
        ValaEnum * self;
1084
1081
        gchar* result = NULL;
1085
 
        gchar* _tmp4_;
 
1082
        gchar* _tmp3_;
1086
1083
        self = (ValaEnum*) base;
1087
1084
        if (self->priv->lower_case_cprefix == NULL) {
1088
1085
                gchar* _tmp0_ = NULL;
1089
1086
                gchar* _tmp1_;
1090
1087
                gchar* _tmp2_ = NULL;
1091
 
                gchar* _tmp3_;
1092
1088
                _tmp0_ = vala_symbol_get_lower_case_cname ((ValaSymbol*) self, NULL);
1093
1089
                _tmp1_ = _tmp0_;
1094
1090
                _tmp2_ = g_strdup_printf ("%s_", _tmp1_);
1095
 
                _tmp3_ = _tmp2_;
1096
1091
                _g_free0 (self->priv->lower_case_cprefix);
1097
 
                self->priv->lower_case_cprefix = _tmp3_;
 
1092
                self->priv->lower_case_cprefix = _tmp2_;
1098
1093
                _g_free0 (_tmp1_);
1099
1094
        }
1100
 
        _tmp4_ = g_strdup (self->priv->lower_case_cprefix);
1101
 
        result = _tmp4_;
 
1095
        _tmp3_ = g_strdup (self->priv->lower_case_cprefix);
 
1096
        result = _tmp3_;
1102
1097
        return result;
1103
1098
}
1104
1099
 
1105
1100
 
1106
1101
static gchar* vala_enum_get_lower_case_csuffix (ValaEnum* self) {
1107
1102
        gchar* result = NULL;
1108
 
        gchar* _tmp3_;
 
1103
        gchar* _tmp2_;
1109
1104
        g_return_val_if_fail (self != NULL, NULL);
1110
1105
        if (self->priv->lower_case_csuffix == NULL) {
1111
1106
                const gchar* _tmp0_ = NULL;
1112
1107
                gchar* _tmp1_ = NULL;
1113
 
                gchar* _tmp2_;
1114
1108
                _tmp0_ = vala_symbol_get_name ((ValaSymbol*) self);
1115
1109
                _tmp1_ = vala_symbol_camel_case_to_lower_case (_tmp0_);
1116
 
                _tmp2_ = _tmp1_;
1117
1110
                _g_free0 (self->priv->lower_case_csuffix);
1118
 
                self->priv->lower_case_csuffix = _tmp2_;
 
1111
                self->priv->lower_case_csuffix = _tmp1_;
1119
1112
        }
1120
 
        _tmp3_ = g_strdup (self->priv->lower_case_csuffix);
1121
 
        result = _tmp3_;
 
1113
        _tmp2_ = g_strdup (self->priv->lower_case_csuffix);
 
1114
        result = _tmp2_;
1122
1115
        return result;
1123
1116
}
1124
1117
 
1143
1136
        _tmp3_ = vala_enum_get_lower_case_csuffix (self);
1144
1137
        _tmp4_ = _tmp3_;
1145
1138
        _tmp5_ = g_strdup_printf ("%s%s%s", _tmp2_, infix, _tmp4_);
1146
 
        result = (_tmp6_ = _tmp5_, _g_free0 (_tmp4_), _g_free0 (_tmp2_), _tmp6_);
 
1139
        _tmp6_ = _tmp5_;
 
1140
        _g_free0 (_tmp4_);
 
1141
        _g_free0 (_tmp2_);
 
1142
        result = _tmp6_;
1147
1143
        return result;
1148
1144
}
1149
1145
 
1159
1155
        _tmp0_ = vala_symbol_get_lower_case_cname ((ValaSymbol*) self, infix);
1160
1156
        _tmp1_ = _tmp0_;
1161
1157
        _tmp2_ = g_utf8_strup (_tmp1_, (gssize) (-1));
1162
 
        result = (_tmp3_ = _tmp2_, _g_free0 (_tmp1_), _tmp3_);
 
1158
        _tmp3_ = _tmp2_;
 
1159
        _g_free0 (_tmp1_);
 
1160
        result = _tmp3_;
1163
1161
        return result;
1164
1162
}
1165
1163
 
1176
1174
static gchar* vala_enum_real_get_cprefix (ValaSymbol* base) {
1177
1175
        ValaEnum * self;
1178
1176
        gchar* result = NULL;
1179
 
        gchar* _tmp4_;
 
1177
        gchar* _tmp3_;
1180
1178
        self = (ValaEnum*) base;
1181
1179
        if (self->priv->cprefix == NULL) {
1182
1180
                gchar* _tmp0_ = NULL;
1183
1181
                gchar* _tmp1_;
1184
1182
                gchar* _tmp2_ = NULL;
1185
 
                gchar* _tmp3_;
1186
1183
                _tmp0_ = vala_typesymbol_get_upper_case_cname ((ValaTypeSymbol*) self, NULL);
1187
1184
                _tmp1_ = _tmp0_;
1188
1185
                _tmp2_ = g_strdup_printf ("%s_", _tmp1_);
1189
 
                _tmp3_ = _tmp2_;
1190
1186
                _g_free0 (self->priv->cprefix);
1191
 
                self->priv->cprefix = _tmp3_;
 
1187
                self->priv->cprefix = _tmp2_;
1192
1188
                _g_free0 (_tmp1_);
1193
1189
        }
1194
 
        _tmp4_ = g_strdup (self->priv->cprefix);
1195
 
        result = _tmp4_;
 
1190
        _tmp3_ = g_strdup (self->priv->cprefix);
 
1191
        result = _tmp3_;
1196
1192
        return result;
1197
1193
}
1198
1194
 
1205
1201
 */
1206
1202
void vala_enum_set_cprefix (ValaEnum* self, const gchar* cprefix) {
1207
1203
        gchar* _tmp0_;
1208
 
        gchar* _tmp1_;
1209
1204
        g_return_if_fail (self != NULL);
1210
1205
        _tmp0_ = g_strdup (cprefix);
1211
 
        _tmp1_ = _tmp0_;
1212
1206
        _g_free0 (self->priv->cprefix);
1213
 
        self->priv->cprefix = _tmp1_;
 
1207
        self->priv->cprefix = _tmp0_;
1214
1208
}
1215
1209
 
1216
1210
 
1217
1211
static void vala_enum_process_ccode_attribute (ValaEnum* self, ValaAttribute* a) {
1218
1212
        gboolean _tmp0_;
1219
1213
        gboolean _tmp3_;
1220
 
        gboolean _tmp6_;
1221
 
        gboolean _tmp11_;
1222
 
        gboolean _tmp13_;
 
1214
        gboolean _tmp5_;
 
1215
        gboolean _tmp10_;
 
1216
        gboolean _tmp12_;
1223
1217
        g_return_if_fail (self != NULL);
1224
1218
        g_return_if_fail (a != NULL);
1225
1219
        _tmp0_ = vala_attribute_has_argument (a, "cprefix");
1234
1228
        _tmp3_ = vala_attribute_has_argument (a, "lower_case_csuffix");
1235
1229
        if (_tmp3_) {
1236
1230
                gchar* _tmp4_ = NULL;
1237
 
                gchar* _tmp5_;
1238
1231
                _tmp4_ = vala_attribute_get_string (a, "lower_case_csuffix");
1239
 
                _tmp5_ = _tmp4_;
1240
1232
                _g_free0 (self->priv->lower_case_csuffix);
1241
 
                self->priv->lower_case_csuffix = _tmp5_;
 
1233
                self->priv->lower_case_csuffix = _tmp4_;
1242
1234
        }
1243
 
        _tmp6_ = vala_attribute_has_argument (a, "cheader_filename");
1244
 
        if (_tmp6_) {
1245
 
                gchar* _tmp7_ = NULL;
 
1235
        _tmp5_ = vala_attribute_has_argument (a, "cheader_filename");
 
1236
        if (_tmp5_) {
 
1237
                gchar* _tmp6_ = NULL;
1246
1238
                gchar* val;
1247
 
                gchar** _tmp8_;
1248
 
                gchar** _tmp9_ = NULL;
1249
 
                _tmp7_ = vala_attribute_get_string (a, "cheader_filename");
1250
 
                val = _tmp7_;
1251
 
                _tmp9_ = _tmp8_ = g_strsplit (val, ",", 0);
 
1239
                gchar** _tmp7_;
 
1240
                gchar** _tmp8_ = NULL;
 
1241
                _tmp6_ = vala_attribute_get_string (a, "cheader_filename");
 
1242
                val = _tmp6_;
 
1243
                _tmp8_ = _tmp7_ = g_strsplit (val, ",", 0);
1252
1244
                {
1253
1245
                        gchar** filename_collection;
1254
1246
                        int filename_collection_length1;
1255
1247
                        int filename_it;
1256
 
                        filename_collection = _tmp9_;
1257
 
                        filename_collection_length1 = _vala_array_length (_tmp8_);
1258
 
                        for (filename_it = 0; filename_it < _vala_array_length (_tmp8_); filename_it = filename_it + 1) {
1259
 
                                gchar* _tmp10_;
 
1248
                        filename_collection = _tmp8_;
 
1249
                        filename_collection_length1 = _vala_array_length (_tmp7_);
 
1250
                        for (filename_it = 0; filename_it < _vala_array_length (_tmp7_); filename_it = filename_it + 1) {
 
1251
                                gchar* _tmp9_;
1260
1252
                                gchar* filename;
1261
 
                                _tmp10_ = g_strdup (filename_collection[filename_it]);
1262
 
                                filename = _tmp10_;
 
1253
                                _tmp9_ = g_strdup (filename_collection[filename_it]);
 
1254
                                filename = _tmp9_;
1263
1255
                                {
1264
1256
                                        vala_symbol_add_cheader_filename ((ValaSymbol*) self, filename);
1265
1257
                                        _g_free0 (filename);
1269
1261
                }
1270
1262
                _g_free0 (val);
1271
1263
        }
1272
 
        _tmp11_ = vala_attribute_has_argument (a, "has_type_id");
1273
 
        if (_tmp11_) {
1274
 
                gboolean _tmp12_;
1275
 
                _tmp12_ = vala_attribute_get_bool (a, "has_type_id");
1276
 
                vala_enum_set_has_type_id (self, _tmp12_);
 
1264
        _tmp10_ = vala_attribute_has_argument (a, "has_type_id");
 
1265
        if (_tmp10_) {
 
1266
                gboolean _tmp11_;
 
1267
                _tmp11_ = vala_attribute_get_bool (a, "has_type_id");
 
1268
                vala_enum_set_has_type_id (self, _tmp11_);
1277
1269
        }
1278
 
        _tmp13_ = vala_attribute_has_argument (a, "type_id");
1279
 
        if (_tmp13_) {
1280
 
                gchar* _tmp14_ = NULL;
1281
 
                gchar* _tmp15_;
1282
 
                _tmp14_ = vala_attribute_get_string (a, "type_id");
1283
 
                _tmp15_ = _tmp14_;
 
1270
        _tmp12_ = vala_attribute_has_argument (a, "type_id");
 
1271
        if (_tmp12_) {
 
1272
                gchar* _tmp13_ = NULL;
 
1273
                _tmp13_ = vala_attribute_get_string (a, "type_id");
1284
1274
                _g_free0 (self->priv->type_id);
1285
 
                self->priv->type_id = _tmp15_;
 
1275
                self->priv->type_id = _tmp13_;
1286
1276
        }
1287
1277
}
1288
1278
 
1333
1323
 
1334
1324
void vala_enum_set_type_id (ValaEnum* self, const gchar* type_id) {
1335
1325
        gchar* _tmp0_;
1336
 
        gchar* _tmp1_;
1337
1326
        g_return_if_fail (self != NULL);
1338
1327
        _tmp0_ = g_strdup (type_id);
1339
 
        _tmp1_ = _tmp0_;
1340
1328
        _g_free0 (self->priv->type_id);
1341
 
        self->priv->type_id = _tmp1_;
 
1329
        self->priv->type_id = _tmp0_;
1342
1330
}
1343
1331
 
1344
1332
 
1345
1333
static gchar* vala_enum_real_get_type_id (ValaTypeSymbol* base) {
1346
1334
        ValaEnum * self;
1347
1335
        gchar* result = NULL;
1348
 
        gchar* _tmp5_;
 
1336
        gchar* _tmp3_;
1349
1337
        self = (ValaEnum*) base;
1350
1338
        if (self->priv->type_id == NULL) {
1351
1339
                if (self->priv->_has_type_id) {
1352
1340
                        gchar* _tmp0_ = NULL;
1353
 
                        gchar* _tmp1_;
1354
1341
                        _tmp0_ = vala_typesymbol_get_upper_case_cname ((ValaTypeSymbol*) self, "TYPE_");
1355
 
                        _tmp1_ = _tmp0_;
1356
1342
                        _g_free0 (self->priv->type_id);
1357
 
                        self->priv->type_id = _tmp1_;
 
1343
                        self->priv->type_id = _tmp0_;
1358
1344
                } else {
1359
 
                        const gchar* _tmp2_ = NULL;
1360
 
                        gchar* _tmp3_;
1361
 
                        gchar* _tmp4_;
 
1345
                        const gchar* _tmp1_ = NULL;
 
1346
                        gchar* _tmp2_;
1362
1347
                        if (self->priv->_is_flags) {
1363
 
                                _tmp2_ = "G_TYPE_UINT";
 
1348
                                _tmp1_ = "G_TYPE_UINT";
1364
1349
                        } else {
1365
 
                                _tmp2_ = "G_TYPE_INT";
 
1350
                                _tmp1_ = "G_TYPE_INT";
1366
1351
                        }
1367
 
                        _tmp3_ = g_strdup (_tmp2_);
1368
 
                        _tmp4_ = _tmp3_;
 
1352
                        _tmp2_ = g_strdup (_tmp1_);
1369
1353
                        _g_free0 (self->priv->type_id);
1370
 
                        self->priv->type_id = _tmp4_;
 
1354
                        self->priv->type_id = _tmp2_;
1371
1355
                }
1372
1356
        }
1373
 
        _tmp5_ = g_strdup (self->priv->type_id);
1374
 
        result = _tmp5_;
 
1357
        _tmp3_ = g_strdup (self->priv->type_id);
 
1358
        result = _tmp3_;
1375
1359
        return result;
1376
1360
}
1377
1361