#--- vala-0.14.2.orig/vala/valagirparser.vala 2013-08-25 16:13:32.847674291 +0200 #+++ vala-0.14.2/vala/valagirparser.vala 2013-08-25 16:15:39.986609678 +0200 #@@ -1848,6 +1848,11 @@ # # next (); # while (current_token == MarkupTokenType.START_ELEMENT) { #+ if (reader.name == "instance-parameter") { #+ skip_element (); #+ continue; #+ } #+ # if (!push_metadata ()) { # skip_element (); # continue; --- vala-0.14.2.orig/vala/valagirparser.c 2013-08-25 16:13:32.851674320 +0200 +++ vala-0.14.2/vala/valagirparser.c 2013-08-25 16:21:57.754141165 +0200 @@ -6343,176 +6343,186 @@ vala_gir_parser_next (self); while (TRUE) { ValaMarkupTokenType _tmp108_; - gboolean _tmp109_ = FALSE; - ValaMarkupReader* _tmp110_; + ValaMarkupReader* _tmp109_; + const gchar* _tmp110_; const gchar* _tmp111_; - const gchar* _tmp112_; + gboolean _tmp112_ = FALSE; + ValaMarkupReader* _tmp113_; + const gchar* _tmp114_; + const gchar* _tmp115_; _tmp108_ = self->priv->current_token; if (!(_tmp108_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT)) { break; } - _tmp109_ = vala_gir_parser_push_metadata (self); - if (!_tmp109_) { + _tmp109_ = self->priv->reader; + _tmp110_ = vala_markup_reader_get_name (_tmp109_); + _tmp111_ = _tmp110_; + if (g_strcmp0 (_tmp111_, "instance-parameter") == 0) { vala_gir_parser_skip_element (self); continue; } - _tmp110_ = self->priv->reader; - _tmp111_ = vala_markup_reader_get_name (_tmp110_); - _tmp112_ = _tmp111_; - if (g_strcmp0 (_tmp112_, "alias") == 0) { + _tmp112_ = vala_gir_parser_push_metadata (self); + if (!_tmp112_) { + vala_gir_parser_skip_element (self); + continue; + } + _tmp113_ = self->priv->reader; + _tmp114_ = vala_markup_reader_get_name (_tmp113_); + _tmp115_ = _tmp114_; + if (g_strcmp0 (_tmp115_, "alias") == 0) { vala_gir_parser_parse_alias (self); } else { - ValaMarkupReader* _tmp113_; - const gchar* _tmp114_; - const gchar* _tmp115_; - _tmp113_ = self->priv->reader; - _tmp114_ = vala_markup_reader_get_name (_tmp113_); - _tmp115_ = _tmp114_; - if (g_strcmp0 (_tmp115_, "enumeration") == 0) { - ValaGirParserMetadata* _tmp116_; - gboolean _tmp117_ = FALSE; - _tmp116_ = self->priv->metadata; - _tmp117_ = vala_gir_parser_metadata_has_argument (_tmp116_, VALA_GIR_PARSER_ARGUMENT_TYPE_ERRORDOMAIN); - if (_tmp117_) { - ValaGirParserMetadata* _tmp118_; - gboolean _tmp119_ = FALSE; - _tmp118_ = self->priv->metadata; - _tmp119_ = vala_gir_parser_metadata_get_bool (_tmp118_, VALA_GIR_PARSER_ARGUMENT_TYPE_ERRORDOMAIN, FALSE); - if (_tmp119_) { + ValaMarkupReader* _tmp116_; + const gchar* _tmp117_; + const gchar* _tmp118_; + _tmp116_ = self->priv->reader; + _tmp117_ = vala_markup_reader_get_name (_tmp116_); + _tmp118_ = _tmp117_; + if (g_strcmp0 (_tmp118_, "enumeration") == 0) { + ValaGirParserMetadata* _tmp119_; + gboolean _tmp120_ = FALSE; + _tmp119_ = self->priv->metadata; + _tmp120_ = vala_gir_parser_metadata_has_argument (_tmp119_, VALA_GIR_PARSER_ARGUMENT_TYPE_ERRORDOMAIN); + if (_tmp120_) { + ValaGirParserMetadata* _tmp121_; + gboolean _tmp122_ = FALSE; + _tmp121_ = self->priv->metadata; + _tmp122_ = vala_gir_parser_metadata_get_bool (_tmp121_, VALA_GIR_PARSER_ARGUMENT_TYPE_ERRORDOMAIN, FALSE); + if (_tmp122_) { vala_gir_parser_parse_error_domain (self); } else { vala_gir_parser_parse_enumeration (self, "enumeration", FALSE); } } else { - gboolean _tmp120_ = FALSE; - ValaMarkupReader* _tmp121_; - gchar* _tmp122_ = NULL; - gchar* _tmp123_; - gboolean _tmp124_; - gboolean _tmp128_; - _tmp121_ = self->priv->reader; - _tmp122_ = vala_markup_reader_get_attribute (_tmp121_, "glib:error-quark"); - _tmp123_ = _tmp122_; - _tmp124_ = _tmp123_ != NULL; - _g_free0 (_tmp123_); - if (_tmp124_) { - _tmp120_ = TRUE; + gboolean _tmp123_ = FALSE; + ValaMarkupReader* _tmp124_; + gchar* _tmp125_ = NULL; + gchar* _tmp126_; + gboolean _tmp127_; + gboolean _tmp131_; + _tmp124_ = self->priv->reader; + _tmp125_ = vala_markup_reader_get_attribute (_tmp124_, "glib:error-quark"); + _tmp126_ = _tmp125_; + _tmp127_ = _tmp126_ != NULL; + _g_free0 (_tmp126_); + if (_tmp127_) { + _tmp123_ = TRUE; } else { - ValaMarkupReader* _tmp125_; - gchar* _tmp126_ = NULL; - gchar* _tmp127_; - _tmp125_ = self->priv->reader; - _tmp126_ = vala_markup_reader_get_attribute (_tmp125_, "glib:error-domain"); - _tmp127_ = _tmp126_; - _tmp120_ = _tmp127_ != NULL; - _g_free0 (_tmp127_); + ValaMarkupReader* _tmp128_; + gchar* _tmp129_ = NULL; + gchar* _tmp130_; + _tmp128_ = self->priv->reader; + _tmp129_ = vala_markup_reader_get_attribute (_tmp128_, "glib:error-domain"); + _tmp130_ = _tmp129_; + _tmp123_ = _tmp130_ != NULL; + _g_free0 (_tmp130_); } - _tmp128_ = _tmp120_; - if (_tmp128_) { + _tmp131_ = _tmp123_; + if (_tmp131_) { vala_gir_parser_parse_error_domain (self); } else { vala_gir_parser_parse_enumeration (self, "enumeration", FALSE); } } } else { - ValaMarkupReader* _tmp129_; - const gchar* _tmp130_; - const gchar* _tmp131_; - _tmp129_ = self->priv->reader; - _tmp130_ = vala_markup_reader_get_name (_tmp129_); - _tmp131_ = _tmp130_; - if (g_strcmp0 (_tmp131_, "bitfield") == 0) { + ValaMarkupReader* _tmp132_; + const gchar* _tmp133_; + const gchar* _tmp134_; + _tmp132_ = self->priv->reader; + _tmp133_ = vala_markup_reader_get_name (_tmp132_); + _tmp134_ = _tmp133_; + if (g_strcmp0 (_tmp134_, "bitfield") == 0) { vala_gir_parser_parse_bitfield (self); } else { - ValaMarkupReader* _tmp132_; - const gchar* _tmp133_; - const gchar* _tmp134_; - _tmp132_ = self->priv->reader; - _tmp133_ = vala_markup_reader_get_name (_tmp132_); - _tmp134_ = _tmp133_; - if (g_strcmp0 (_tmp134_, "function") == 0) { + ValaMarkupReader* _tmp135_; + const gchar* _tmp136_; + const gchar* _tmp137_; + _tmp135_ = self->priv->reader; + _tmp136_ = vala_markup_reader_get_name (_tmp135_); + _tmp137_ = _tmp136_; + if (g_strcmp0 (_tmp137_, "function") == 0) { vala_gir_parser_parse_method (self, "function"); } else { - ValaMarkupReader* _tmp135_; - const gchar* _tmp136_; - const gchar* _tmp137_; - _tmp135_ = self->priv->reader; - _tmp136_ = vala_markup_reader_get_name (_tmp135_); - _tmp137_ = _tmp136_; - if (g_strcmp0 (_tmp137_, "callback") == 0) { + ValaMarkupReader* _tmp138_; + const gchar* _tmp139_; + const gchar* _tmp140_; + _tmp138_ = self->priv->reader; + _tmp139_ = vala_markup_reader_get_name (_tmp138_); + _tmp140_ = _tmp139_; + if (g_strcmp0 (_tmp140_, "callback") == 0) { vala_gir_parser_parse_callback (self); } else { - ValaMarkupReader* _tmp138_; - const gchar* _tmp139_; - const gchar* _tmp140_; - _tmp138_ = self->priv->reader; - _tmp139_ = vala_markup_reader_get_name (_tmp138_); - _tmp140_ = _tmp139_; - if (g_strcmp0 (_tmp140_, "record") == 0) { - ValaGirParserMetadata* _tmp141_; - gboolean _tmp142_ = FALSE; - _tmp141_ = self->priv->metadata; - _tmp142_ = vala_gir_parser_metadata_has_argument (_tmp141_, VALA_GIR_PARSER_ARGUMENT_TYPE_STRUCT); - if (_tmp142_) { - ValaGirParserMetadata* _tmp143_; - gboolean _tmp144_ = FALSE; - _tmp143_ = self->priv->metadata; - _tmp144_ = vala_gir_parser_metadata_get_bool (_tmp143_, VALA_GIR_PARSER_ARGUMENT_TYPE_STRUCT, FALSE); - if (_tmp144_) { + ValaMarkupReader* _tmp141_; + const gchar* _tmp142_; + const gchar* _tmp143_; + _tmp141_ = self->priv->reader; + _tmp142_ = vala_markup_reader_get_name (_tmp141_); + _tmp143_ = _tmp142_; + if (g_strcmp0 (_tmp143_, "record") == 0) { + ValaGirParserMetadata* _tmp144_; + gboolean _tmp145_ = FALSE; + _tmp144_ = self->priv->metadata; + _tmp145_ = vala_gir_parser_metadata_has_argument (_tmp144_, VALA_GIR_PARSER_ARGUMENT_TYPE_STRUCT); + if (_tmp145_) { + ValaGirParserMetadata* _tmp146_; + gboolean _tmp147_ = FALSE; + _tmp146_ = self->priv->metadata; + _tmp147_ = vala_gir_parser_metadata_get_bool (_tmp146_, VALA_GIR_PARSER_ARGUMENT_TYPE_STRUCT, FALSE); + if (_tmp147_) { vala_gir_parser_parse_record (self); } else { vala_gir_parser_parse_boxed (self, "record"); } } else { - ValaMarkupReader* _tmp145_; - gchar* _tmp146_ = NULL; - gchar* _tmp147_; - gboolean _tmp148_; - _tmp145_ = self->priv->reader; - _tmp146_ = vala_markup_reader_get_attribute (_tmp145_, "glib:get-type"); - _tmp147_ = _tmp146_; - _tmp148_ = _tmp147_ != NULL; - _g_free0 (_tmp147_); - if (_tmp148_) { + ValaMarkupReader* _tmp148_; + gchar* _tmp149_ = NULL; + gchar* _tmp150_; + gboolean _tmp151_; + _tmp148_ = self->priv->reader; + _tmp149_ = vala_markup_reader_get_attribute (_tmp148_, "glib:get-type"); + _tmp150_ = _tmp149_; + _tmp151_ = _tmp150_ != NULL; + _g_free0 (_tmp150_); + if (_tmp151_) { vala_gir_parser_parse_boxed (self, "record"); } else { - ValaMarkupReader* _tmp149_; - gchar* _tmp150_ = NULL; - gchar* _tmp151_; - gboolean _tmp152_ = FALSE; - gboolean _tmp153_; - _tmp149_ = self->priv->reader; - _tmp150_ = vala_markup_reader_get_attribute (_tmp149_, "name"); - _tmp151_ = _tmp150_; - _tmp152_ = g_str_has_suffix (_tmp151_, "Private"); - _tmp153_ = !_tmp152_; - _g_free0 (_tmp151_); - if (_tmp153_) { - gboolean _tmp154_ = FALSE; - ValaMarkupReader* _tmp155_; - gchar* _tmp156_ = NULL; - gchar* _tmp157_; - gboolean _tmp158_; - gboolean _tmp162_; - _tmp155_ = self->priv->reader; - _tmp156_ = vala_markup_reader_get_attribute (_tmp155_, "glib:is-gtype-struct-for"); - _tmp157_ = _tmp156_; - _tmp158_ = _tmp157_ == NULL; - _g_free0 (_tmp157_); - if (_tmp158_) { - ValaMarkupReader* _tmp159_; - gchar* _tmp160_ = NULL; - gchar* _tmp161_; - _tmp159_ = self->priv->reader; - _tmp160_ = vala_markup_reader_get_attribute (_tmp159_, "disguised"); - _tmp161_ = _tmp160_; - _tmp154_ = g_strcmp0 (_tmp161_, "1") == 0; - _g_free0 (_tmp161_); + ValaMarkupReader* _tmp152_; + gchar* _tmp153_ = NULL; + gchar* _tmp154_; + gboolean _tmp155_ = FALSE; + gboolean _tmp156_; + _tmp152_ = self->priv->reader; + _tmp153_ = vala_markup_reader_get_attribute (_tmp152_, "name"); + _tmp154_ = _tmp153_; + _tmp155_ = g_str_has_suffix (_tmp154_, "Private"); + _tmp156_ = !_tmp155_; + _g_free0 (_tmp154_); + if (_tmp156_) { + gboolean _tmp157_ = FALSE; + ValaMarkupReader* _tmp158_; + gchar* _tmp159_ = NULL; + gchar* _tmp160_; + gboolean _tmp161_; + gboolean _tmp165_; + _tmp158_ = self->priv->reader; + _tmp159_ = vala_markup_reader_get_attribute (_tmp158_, "glib:is-gtype-struct-for"); + _tmp160_ = _tmp159_; + _tmp161_ = _tmp160_ == NULL; + _g_free0 (_tmp160_); + if (_tmp161_) { + ValaMarkupReader* _tmp162_; + gchar* _tmp163_ = NULL; + gchar* _tmp164_; + _tmp162_ = self->priv->reader; + _tmp163_ = vala_markup_reader_get_attribute (_tmp162_, "disguised"); + _tmp164_ = _tmp163_; + _tmp157_ = g_strcmp0 (_tmp164_, "1") == 0; + _g_free0 (_tmp164_); } else { - _tmp154_ = FALSE; + _tmp157_ = FALSE; } - _tmp162_ = _tmp154_; - if (_tmp162_) { + _tmp165_ = _tmp157_; + if (_tmp165_) { vala_gir_parser_parse_boxed (self, "record"); } else { vala_gir_parser_parse_record (self); @@ -6523,93 +6533,93 @@ } } } else { - ValaMarkupReader* _tmp163_; - const gchar* _tmp164_; - const gchar* _tmp165_; - _tmp163_ = self->priv->reader; - _tmp164_ = vala_markup_reader_get_name (_tmp163_); - _tmp165_ = _tmp164_; - if (g_strcmp0 (_tmp165_, "class") == 0) { + ValaMarkupReader* _tmp166_; + const gchar* _tmp167_; + const gchar* _tmp168_; + _tmp166_ = self->priv->reader; + _tmp167_ = vala_markup_reader_get_name (_tmp166_); + _tmp168_ = _tmp167_; + if (g_strcmp0 (_tmp168_, "class") == 0) { vala_gir_parser_parse_class (self); } else { - ValaMarkupReader* _tmp166_; - const gchar* _tmp167_; - const gchar* _tmp168_; - _tmp166_ = self->priv->reader; - _tmp167_ = vala_markup_reader_get_name (_tmp166_); - _tmp168_ = _tmp167_; - if (g_strcmp0 (_tmp168_, "interface") == 0) { + ValaMarkupReader* _tmp169_; + const gchar* _tmp170_; + const gchar* _tmp171_; + _tmp169_ = self->priv->reader; + _tmp170_ = vala_markup_reader_get_name (_tmp169_); + _tmp171_ = _tmp170_; + if (g_strcmp0 (_tmp171_, "interface") == 0) { vala_gir_parser_parse_interface (self); } else { - ValaMarkupReader* _tmp169_; - const gchar* _tmp170_; - const gchar* _tmp171_; - _tmp169_ = self->priv->reader; - _tmp170_ = vala_markup_reader_get_name (_tmp169_); - _tmp171_ = _tmp170_; - if (g_strcmp0 (_tmp171_, "glib:boxed") == 0) { + ValaMarkupReader* _tmp172_; + const gchar* _tmp173_; + const gchar* _tmp174_; + _tmp172_ = self->priv->reader; + _tmp173_ = vala_markup_reader_get_name (_tmp172_); + _tmp174_ = _tmp173_; + if (g_strcmp0 (_tmp174_, "glib:boxed") == 0) { vala_gir_parser_parse_boxed (self, "glib:boxed"); } else { - ValaMarkupReader* _tmp172_; - const gchar* _tmp173_; - const gchar* _tmp174_; - _tmp172_ = self->priv->reader; - _tmp173_ = vala_markup_reader_get_name (_tmp172_); - _tmp174_ = _tmp173_; - if (g_strcmp0 (_tmp174_, "union") == 0) { - gboolean _tmp175_ = FALSE; - ValaMarkupReader* _tmp176_; - gchar* _tmp177_ = NULL; - gchar* _tmp178_; - gboolean _tmp179_; + ValaMarkupReader* _tmp175_; + const gchar* _tmp176_; + const gchar* _tmp177_; + _tmp175_ = self->priv->reader; + _tmp176_ = vala_markup_reader_get_name (_tmp175_); + _tmp177_ = _tmp176_; + if (g_strcmp0 (_tmp177_, "union") == 0) { + gboolean _tmp178_ = FALSE; + ValaMarkupReader* _tmp179_; + gchar* _tmp180_ = NULL; + gchar* _tmp181_; gboolean _tmp182_; - _tmp176_ = self->priv->reader; - _tmp177_ = vala_markup_reader_get_attribute (_tmp176_, "glib:get-type"); - _tmp178_ = _tmp177_; - _tmp179_ = _tmp178_ != NULL; - _g_free0 (_tmp178_); - if (_tmp179_) { - ValaGirParserMetadata* _tmp180_; - gboolean _tmp181_ = FALSE; - _tmp180_ = self->priv->metadata; - _tmp181_ = vala_gir_parser_metadata_get_bool (_tmp180_, VALA_GIR_PARSER_ARGUMENT_TYPE_STRUCT, FALSE); - _tmp175_ = !_tmp181_; + gboolean _tmp185_; + _tmp179_ = self->priv->reader; + _tmp180_ = vala_markup_reader_get_attribute (_tmp179_, "glib:get-type"); + _tmp181_ = _tmp180_; + _tmp182_ = _tmp181_ != NULL; + _g_free0 (_tmp181_); + if (_tmp182_) { + ValaGirParserMetadata* _tmp183_; + gboolean _tmp184_ = FALSE; + _tmp183_ = self->priv->metadata; + _tmp184_ = vala_gir_parser_metadata_get_bool (_tmp183_, VALA_GIR_PARSER_ARGUMENT_TYPE_STRUCT, FALSE); + _tmp178_ = !_tmp184_; } else { - _tmp175_ = FALSE; + _tmp178_ = FALSE; } - _tmp182_ = _tmp175_; - if (_tmp182_) { + _tmp185_ = _tmp178_; + if (_tmp185_) { vala_gir_parser_parse_boxed (self, "union"); } else { vala_gir_parser_parse_union (self); } } else { - ValaMarkupReader* _tmp183_; - const gchar* _tmp184_; - const gchar* _tmp185_; - _tmp183_ = self->priv->reader; - _tmp184_ = vala_markup_reader_get_name (_tmp183_); - _tmp185_ = _tmp184_; - if (g_strcmp0 (_tmp185_, "constant") == 0) { + ValaMarkupReader* _tmp186_; + const gchar* _tmp187_; + const gchar* _tmp188_; + _tmp186_ = self->priv->reader; + _tmp187_ = vala_markup_reader_get_name (_tmp186_); + _tmp188_ = _tmp187_; + if (g_strcmp0 (_tmp188_, "constant") == 0) { vala_gir_parser_parse_constant (self); } else { - ValaSourceReference* _tmp186_ = NULL; - ValaSourceReference* _tmp187_; - ValaMarkupReader* _tmp188_; - const gchar* _tmp189_; - const gchar* _tmp190_; - gchar* _tmp191_ = NULL; - gchar* _tmp192_; - _tmp186_ = vala_gir_parser_get_current_src (self); - _tmp187_ = _tmp186_; - _tmp188_ = self->priv->reader; - _tmp189_ = vala_markup_reader_get_name (_tmp188_); + ValaSourceReference* _tmp189_ = NULL; + ValaSourceReference* _tmp190_; + ValaMarkupReader* _tmp191_; + const gchar* _tmp192_; + const gchar* _tmp193_; + gchar* _tmp194_ = NULL; + gchar* _tmp195_; + _tmp189_ = vala_gir_parser_get_current_src (self); _tmp190_ = _tmp189_; - _tmp191_ = g_strdup_printf ("unknown child element `%s' in `namespace'", _tmp190_); - _tmp192_ = _tmp191_; - vala_report_error (_tmp187_, _tmp192_); - _g_free0 (_tmp192_); - _vala_source_reference_unref0 (_tmp187_); + _tmp191_ = self->priv->reader; + _tmp192_ = vala_markup_reader_get_name (_tmp191_); + _tmp193_ = _tmp192_; + _tmp194_ = g_strdup_printf ("unknown child element `%s' in `namespace'", _tmp193_); + _tmp195_ = _tmp194_; + vala_report_error (_tmp190_, _tmp195_); + _g_free0 (_tmp195_); + _vala_source_reference_unref0 (_tmp190_); vala_gir_parser_skip_element (self); } }