« back to all changes in this revision
Viewing changes to vala/valaparser.c
- browse files at revision 47
- compare with another revision
- download diff
- download tarball
- view history from revision 47
- 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
- files modified:
- .tarball-version
added
removed
vala/valaparser.c
2225
2225
ValaParser* vala_parser_construct (GType object_type) {
2226
2226
ValaParser* self = NULL;
2227
2227
ValaParserTokenInfo* _tmp0_ = NULL;
2228
ValaParserTokenInfo* _tmp1_;
2229
2228
self = (ValaParser*) vala_code_visitor_construct (object_type);
2230
2229
_tmp0_ = g_new0 (ValaParserTokenInfo, VALA_PARSER_BUFFER_SIZE);
2231
_tmp1_ = _tmp0_;
2232
2230
self->priv->tokens = (g_free (self->priv->tokens), NULL);
2231
self->priv->tokens = _tmp0_;
2233
2232
self->priv->tokens_length1 = VALA_PARSER_BUFFER_SIZE;
2234
self->priv->_tokens_size_ = self->priv->tokens_length1;
2235
self->priv->tokens = _tmp1_;
2233
self->priv->_tokens_size_ = VALA_PARSER_BUFFER_SIZE;
2236
2234
return self;
2237
2235
}
2238
2236
2255
2253
2256
2254
void vala_parser_parse (ValaParser* self, ValaCodeContext* context) {
2257
2255
ValaCodeContext* _tmp0_;
2258
ValaCodeContext* _tmp1_;
2259
2256
g_return_if_fail (self != NULL);
2260
2257
g_return_if_fail (context != NULL);
2261
2258
_tmp0_ = _vala_code_context_ref0 (context);
2262
_tmp1_ = _tmp0_;
2263
2259
_vala_code_context_unref0 (self->priv->context);
2264
self->priv->context = _tmp1_;
2260
self->priv->context = _tmp0_;
2265
2261
vala_code_context_accept (context, (ValaCodeVisitor*) self);
2266
2262
}
2267
2263
2364
2360
ValaSourceReference* _tmp3_;
2365
2361
gchar* _tmp4_;
2366
2362
gchar* _tmp5_;
2363
gchar* _tmp6_;
2367
2364
g_return_val_if_fail (self != NULL, NULL);
2368
2365
g_return_val_if_fail (msg != NULL, NULL);
2369
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
2366
vala_parser_get_location (self, &_tmp0_);
2367
_tmp1_ = _tmp0_;
2370
2368
begin = _tmp1_;
2371
2369
vala_parser_next (self);
2372
2370
_tmp2_ = vala_parser_get_src (self, &begin);
2373
2371
_tmp3_ = _tmp2_;
2374
2372
_tmp4_ = g_strconcat ("syntax error, ", msg, NULL);
2375
vala_report_error (_tmp3_, _tmp4_);
2376
_g_free0 (_tmp4_);
2373
_tmp5_ = _tmp4_;
2374
vala_report_error (_tmp3_, _tmp5_);
2375
_g_free0 (_tmp5_);
2377
2376
_vala_source_reference_unref0 (_tmp3_);
2378
_tmp5_ = g_strdup (msg);
2379
result = _tmp5_;
2377
_tmp6_ = g_strdup (msg);
2378
result = _tmp6_;
2380
2379
return result;
2381
2380
}
2382
2381
2404
2403
_tmp4_ = vala_parser_get_error (self, _tmp3_);
2405
2404
_tmp5_ = _tmp4_;
2406
2405
_tmp6_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp5_);
2407
_inner_error_ = (_tmp7_ = _tmp6_, _g_free0 (_tmp5_), _g_free0 (_tmp3_), _tmp7_);
2406
_tmp7_ = _tmp6_;
2407
_g_free0 (_tmp5_);
2408
_g_free0 (_tmp3_);
2409
_inner_error_ = _tmp7_;
2408
2410
if (_inner_error_->domain == VALA_PARSE_ERROR) {
2409
2411
g_propagate_error (error, _inner_error_);
2410
2412
return FALSE;
2423
2425
}
2424
2426
2425
2427
2428
static glong string_strnlen (gchar* str, glong maxlen) {
2429
glong result = 0L;
2430
gchar* _tmp0_ = NULL;
2431
gchar* end;
2432
_tmp0_ = memchr (str, 0, (gsize) maxlen);
2433
end = _tmp0_;
2434
if (end == NULL) {
2435
result = maxlen;
2436
return result;
2437
} else {
2438
result = (glong) (end - str);
2439
return result;
2440
}
2441
}
2442
2443
2426
2444
static gchar* string_substring (const gchar* self, glong offset, glong len) {
2427
2445
gchar* result = NULL;
2428
2446
glong string_length = 0L;
2436
2454
}
2437
2455
if (_tmp0_) {
2438
2456
glong _tmp1_;
2439
_tmp1_ = strnlen ((gchar*) self, (gsize) (offset + len));
2457
_tmp1_ = string_strnlen ((gchar*) self, offset + len);
2440
2458
string_length = _tmp1_;
2441
2459
} else {
2442
2460
gint _tmp2_;
2675
2693
_tmp7_ = vala_parser_get_error (self, "expected identifier");
2676
2694
_tmp8_ = _tmp7_;
2677
2695
_tmp9_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp8_);
2678
_inner_error_ = (_tmp10_ = _tmp9_, _g_free0 (_tmp8_), _tmp10_);
2696
_tmp10_ = _tmp9_;
2697
_g_free0 (_tmp8_);
2698
_inner_error_ = _tmp10_;
2679
2699
if (_inner_error_->domain == VALA_PARSE_ERROR) {
2680
2700
g_propagate_error (error, _inner_error_);
2681
2701
return;
2719
2739
ValaTokenType _tmp2_;
2720
2740
GError * _inner_error_ = NULL;
2721
2741
g_return_val_if_fail (self != NULL, NULL);
2722
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
2742
vala_parser_get_location (self, &_tmp0_);
2743
_tmp1_ = _tmp0_;
2723
2744
begin = _tmp1_;
2724
2745
_tmp2_ = vala_parser_current (self);
2725
2746
switch (_tmp2_) {
2733
2754
_tmp3_ = vala_parser_get_src (self, &begin);
2734
2755
_tmp4_ = _tmp3_;
2735
2756
_tmp5_ = vala_boolean_literal_new (TRUE, _tmp4_);
2736
result = (_tmp6_ = (ValaExpression*) _tmp5_, _vala_source_reference_unref0 (_tmp4_), _tmp6_);
2757
_tmp6_ = (ValaExpression*) _tmp5_;
2758
_vala_source_reference_unref0 (_tmp4_);
2759
result = _tmp6_;
2737
2760
return result;
2738
2761
}
2739
2762
case VALA_TOKEN_TYPE_FALSE:
2746
2769
_tmp7_ = vala_parser_get_src (self, &begin);
2747
2770
_tmp8_ = _tmp7_;
2748
2771
_tmp9_ = vala_boolean_literal_new (FALSE, _tmp8_);
2749
result = (_tmp10_ = (ValaExpression*) _tmp9_, _vala_source_reference_unref0 (_tmp8_), _tmp10_);
2772
_tmp10_ = (ValaExpression*) _tmp9_;
2773
_vala_source_reference_unref0 (_tmp8_);
2774
result = _tmp10_;
2750
2775
return result;
2751
2776
}
2752
2777
case VALA_TOKEN_TYPE_INTEGER_LITERAL:
2763
2788
_tmp13_ = vala_parser_get_src (self, &begin);
2764
2789
_tmp14_ = _tmp13_;
2765
2790
_tmp15_ = vala_integer_literal_new (_tmp12_, _tmp14_);
2766
result = (_tmp16_ = (ValaExpression*) _tmp15_, _vala_source_reference_unref0 (_tmp14_), _g_free0 (_tmp12_), _tmp16_);
2791
_tmp16_ = (ValaExpression*) _tmp15_;
2792
_vala_source_reference_unref0 (_tmp14_);
2793
_g_free0 (_tmp12_);
2794
result = _tmp16_;
2767
2795
return result;
2768
2796
}
2769
2797
case VALA_TOKEN_TYPE_REAL_LITERAL:
2780
2808
_tmp19_ = vala_parser_get_src (self, &begin);
2781
2809
_tmp20_ = _tmp19_;
2782
2810
_tmp21_ = vala_real_literal_new (_tmp18_, _tmp20_);
2783
result = (_tmp22_ = (ValaExpression*) _tmp21_, _vala_source_reference_unref0 (_tmp20_), _g_free0 (_tmp18_), _tmp22_);
2811
_tmp22_ = (ValaExpression*) _tmp21_;
2812
_vala_source_reference_unref0 (_tmp20_);
2813
_g_free0 (_tmp18_);
2814
result = _tmp22_;
2784
2815
return result;
2785
2816
}
2786
2817
case VALA_TOKEN_TYPE_CHARACTER_LITERAL:
2799
2830
_tmp25_ = vala_parser_get_src (self, &begin);
2800
2831
_tmp26_ = _tmp25_;
2801
2832
_tmp27_ = vala_character_literal_new (_tmp24_, _tmp26_);
2802
lit = (_tmp28_ = _tmp27_, _vala_source_reference_unref0 (_tmp26_), _g_free0 (_tmp24_), _tmp28_);
2833
_tmp28_ = _tmp27_;
2834
_vala_source_reference_unref0 (_tmp26_);
2835
_g_free0 (_tmp24_);
2836
lit = _tmp28_;
2803
2837
_tmp29_ = vala_code_node_get_error ((ValaCodeNode*) lit);
2804
2838
if (_tmp29_) {
2805
2839
ValaSourceReference* _tmp30_ = NULL;
2846
2880
_tmp34_ = g_strdup_printf ("%s/%s", close_token, match_part);
2847
2881
_tmp35_ = _tmp34_;
2848
2882
_tmp36_ = vala_regex_literal_new (_tmp35_, src_begin);
2849
result = (_tmp37_ = (ValaExpression*) _tmp36_, _g_free0 (_tmp35_), _tmp37_);
2883
_tmp37_ = (ValaExpression*) _tmp36_;
2884
_g_free0 (_tmp35_);
2885
result = _tmp37_;
2850
2886
_g_free0 (close_token);
2851
2887
_vala_source_reference_unref0 (src_begin);
2852
2888
_g_free0 (match_part);
2866
2902
_tmp40_ = vala_parser_get_src (self, &begin);
2867
2903
_tmp41_ = _tmp40_;
2868
2904
_tmp42_ = vala_string_literal_new (_tmp39_, _tmp41_);
2869
result = (_tmp43_ = (ValaExpression*) _tmp42_, _vala_source_reference_unref0 (_tmp41_), _g_free0 (_tmp39_), _tmp43_);
2905
_tmp43_ = (ValaExpression*) _tmp42_;
2906
_vala_source_reference_unref0 (_tmp41_);
2907
_g_free0 (_tmp39_);
2908
result = _tmp43_;
2870
2909
return result;
2871
2910
}
2872
2911
case VALA_TOKEN_TYPE_TEMPLATE_STRING_LITERAL:
2887
2926
_tmp48_ = vala_parser_get_src (self, &begin);
2888
2927
_tmp49_ = _tmp48_;
2889
2928
_tmp50_ = vala_string_literal_new (_tmp47_, _tmp49_);
2890
result = (_tmp51_ = (ValaExpression*) _tmp50_, _vala_source_reference_unref0 (_tmp49_), _g_free0 (_tmp47_), _g_free0 (_tmp45_), _tmp51_);
2929
_tmp51_ = (ValaExpression*) _tmp50_;
2930
_vala_source_reference_unref0 (_tmp49_);
2931
_g_free0 (_tmp47_);
2932
_g_free0 (_tmp45_);
2933
result = _tmp51_;
2891
2934
return result;
2892
2935
}
2893
2936
case VALA_TOKEN_TYPE_VERBATIM_STRING_LITERAL:
2913
2956
_tmp54_ = string_substring (raw_string, (glong) 3, (glong) (_tmp53_ - 6));
2914
2957
_tmp55_ = _tmp54_;
2915
2958
_tmp56_ = g_strescape (_tmp55_, "");
2916
escaped_string = (_tmp57_ = _tmp56_, _g_free0 (_tmp55_), _tmp57_);
2959
_tmp57_ = _tmp56_;
2960
_g_free0 (_tmp55_);
2961
escaped_string = _tmp57_;
2917
2962
_tmp58_ = g_strdup_printf ("\"%s\"", escaped_string);
2918
2963
_tmp59_ = _tmp58_;
2919
2964
_tmp60_ = vala_parser_get_src (self, &begin);
2920
2965
_tmp61_ = _tmp60_;
2921
2966
_tmp62_ = vala_string_literal_new (_tmp59_, _tmp61_);
2922
result = (_tmp63_ = (ValaExpression*) _tmp62_, _vala_source_reference_unref0 (_tmp61_), _g_free0 (_tmp59_), _tmp63_);
2967
_tmp63_ = (ValaExpression*) _tmp62_;
2968
_vala_source_reference_unref0 (_tmp61_);
2969
_g_free0 (_tmp59_);
2970
result = _tmp63_;
2923
2971
_g_free0 (escaped_string);
2924
2972
_g_free0 (raw_string);
2925
2973
return result;
2934
2982
_tmp64_ = vala_parser_get_src (self, &begin);
2935
2983
_tmp65_ = _tmp64_;
2936
2984
_tmp66_ = vala_null_literal_new (_tmp65_);
2937
result = (_tmp67_ = (ValaExpression*) _tmp66_, _vala_source_reference_unref0 (_tmp65_), _tmp67_);
2985
_tmp67_ = (ValaExpression*) _tmp66_;
2986
_vala_source_reference_unref0 (_tmp65_);
2987
result = _tmp67_;
2938
2988
return result;
2939
2989
}
2940
2990
default:
2946
2996
_tmp68_ = vala_parser_get_error (self, "expected literal");
2947
2997
_tmp69_ = _tmp68_;
2948
2998
_tmp70_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp69_);
2949
_inner_error_ = (_tmp71_ = _tmp70_, _g_free0 (_tmp69_), _tmp71_);
2999
_tmp71_ = _tmp70_;
3000
_g_free0 (_tmp69_);
3001
_inner_error_ = _tmp71_;
2950
3002
if (_inner_error_->domain == VALA_PARSE_ERROR) {
2951
3003
g_propagate_error (error, _inner_error_);
2952
3004
return NULL;
2962
3014
2963
3015
void vala_parser_parse_file (ValaParser* self, ValaSourceFile* source_file) {
2964
3016
ValaScanner* _tmp0_ = NULL;
2965
ValaScanner* _tmp1_;
3017
ValaNamespace* _tmp1_ = NULL;
2966
3018
ValaNamespace* _tmp2_ = NULL;
2967
ValaNamespace* _tmp3_ = NULL;
2968
gboolean _tmp4_;
2969
ValaScanner* _tmp9_;
3019
gboolean _tmp3_;
2970
3020
GError * _inner_error_ = NULL;
2971
3021
g_return_if_fail (self != NULL);
2972
3022
g_return_if_fail (source_file != NULL);
2973
3023
_tmp0_ = vala_scanner_new (source_file);
2974
_tmp1_ = _tmp0_;
2975
3024
_vala_scanner_unref0 (self->priv->scanner);
2976
self->priv->scanner = _tmp1_;
3025
self->priv->scanner = _tmp0_;
2977
3026
vala_parser_parse_file_comments (self);
2978
3027
self->priv->index = -1;
2979
3028
self->priv->size = 0;
2980
3029
vala_parser_next (self);
3030
_tmp1_ = vala_code_context_get_root (self->priv->context);
3031
vala_parser_parse_using_directives (self, _tmp1_, &_inner_error_);
3032
if (_inner_error_ != NULL) {
3033
if (_inner_error_->domain == VALA_PARSE_ERROR) {
3034
goto __catch9_vala_parse_error;
3035
}
3036
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
3037
g_clear_error (&_inner_error_);
3038
return;
3039
}
2981
3040
_tmp2_ = vala_code_context_get_root (self->priv->context);
2982
vala_parser_parse_using_directives (self, _tmp2_, &_inner_error_);
2983
if (_inner_error_ != NULL) {
2984
if (_inner_error_->domain == VALA_PARSE_ERROR) {
2985
goto __catch9_vala_parse_error;
2986
}
2987
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
2988
g_clear_error (&_inner_error_);
2989
return;
2990
}
2991
_tmp3_ = vala_code_context_get_root (self->priv->context);
2992
vala_parser_parse_declarations (self, (ValaSymbol*) _tmp3_, TRUE, &_inner_error_);
2993
if (_inner_error_ != NULL) {
2994
if (_inner_error_->domain == VALA_PARSE_ERROR) {
2995
goto __catch9_vala_parse_error;
2996
}
2997
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
2998
g_clear_error (&_inner_error_);
2999
return;
3000
}
3001
_tmp4_ = vala_parser_accept (self, VALA_TOKEN_TYPE_CLOSE_BRACE);
3002
if (_tmp4_) {
3003
ValaReport* _tmp5_ = NULL;
3004
gint _tmp6_;
3005
_tmp5_ = vala_code_context_get_report (self->priv->context);
3006
_tmp6_ = vala_report_get_errors (_tmp5_);
3007
if (_tmp6_ == 0) {
3008
ValaSourceReference* _tmp7_ = NULL;
3009
ValaSourceReference* _tmp8_;
3010
_tmp7_ = vala_parser_get_last_src (self);
3011
_tmp8_ = _tmp7_;
3012
vala_report_error (_tmp8_, "unexpected `}'");
3013
_vala_source_reference_unref0 (_tmp8_);
3041
vala_parser_parse_declarations (self, (ValaSymbol*) _tmp2_, TRUE, &_inner_error_);
3042
if (_inner_error_ != NULL) {
3043
if (_inner_error_->domain == VALA_PARSE_ERROR) {
3044
goto __catch9_vala_parse_error;
3045
}
3046
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
3047
g_clear_error (&_inner_error_);
3048
return;
3049
}
3050
_tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_CLOSE_BRACE);
3051
if (_tmp3_) {
3052
ValaReport* _tmp4_ = NULL;
3053
gint _tmp5_;
3054
_tmp4_ = vala_code_context_get_report (self->priv->context);
3055
_tmp5_ = vala_report_get_errors (_tmp4_);
3056
if (_tmp5_ == 0) {
3057
ValaSourceReference* _tmp6_ = NULL;
3058
ValaSourceReference* _tmp7_;
3059
_tmp6_ = vala_parser_get_last_src (self);
3060
_tmp7_ = _tmp6_;
3061
vala_report_error (_tmp7_, "unexpected `}'");
3062
_vala_source_reference_unref0 (_tmp7_);
3014
3063
}
3015
3064
}
3016
3065
goto __finally9;
3027
3076
g_clear_error (&_inner_error_);
3028
3077
return;
3029
3078
}
3030
_tmp9_ = NULL;
3031
3079
_vala_scanner_unref0 (self->priv->scanner);
3032
self->priv->scanner = _tmp9_;
3080
self->priv->scanner = NULL;
3033
3081
}
3034
3082
3035
3083
3086
3134
ValaUnresolvedSymbol* sym;
3087
3135
GError * _inner_error_ = NULL;
3088
3136
g_return_val_if_fail (self != NULL, NULL);
3089
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
3137
vala_parser_get_location (self, &_tmp0_);
3138
_tmp1_ = _tmp0_;
3090
3139
begin = _tmp1_;
3091
3140
sym = NULL;
3092
3141
{
3096
3145
gchar* _tmp4_ = NULL;
3097
3146
gchar* name;
3098
3147
gboolean _tmp5_ = FALSE;
3099
ValaSourceReference* _tmp14_ = NULL;
3100
ValaSourceReference* _tmp15_;
3101
ValaUnresolvedSymbol* _tmp16_ = NULL;
3102
ValaUnresolvedSymbol* _tmp17_;
3148
ValaSourceReference* _tmp12_ = NULL;
3149
ValaSourceReference* _tmp13_;
3150
ValaUnresolvedSymbol* _tmp14_ = NULL;
3103
3151
if (!_tmp2_) {
3104
3152
gboolean _tmp3_;
3105
3153
_tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_DOT);
3132
3180
if (_tmp5_) {
3133
3181
gchar* _tmp7_ = NULL;
3134
3182
gchar* _tmp8_;
3135
gchar* _tmp9_;
3136
ValaSourceReference* _tmp10_ = NULL;
3137
ValaSourceReference* _tmp11_;
3138
ValaUnresolvedSymbol* _tmp12_ = NULL;
3139
ValaUnresolvedSymbol* _tmp13_;
3183
ValaSourceReference* _tmp9_ = NULL;
3184
ValaSourceReference* _tmp10_;
3185
ValaUnresolvedSymbol* _tmp11_ = NULL;
3140
3186
_tmp7_ = vala_parser_parse_identifier (self, &_inner_error_);
3141
3187
_tmp8_ = _tmp7_;
3142
3188
if (_inner_error_ != NULL) {
3153
3199
return NULL;
3154
3200
}
3155
3201
}
3156
_tmp9_ = _tmp8_;
3157
3202
_g_free0 (name);
3158
name = _tmp9_;
3159
_tmp10_ = vala_parser_get_src (self, &begin);
3160
_tmp11_ = _tmp10_;
3161
_tmp12_ = vala_unresolved_symbol_new (sym, name, _tmp11_);
3162
_tmp13_ = _tmp12_;
3203
name = _tmp8_;
3204
_tmp9_ = vala_parser_get_src (self, &begin);
3205
_tmp10_ = _tmp9_;
3206
_tmp11_ = vala_unresolved_symbol_new (sym, name, _tmp10_);
3163
3207
_vala_code_node_unref0 (sym);
3164
sym = _tmp13_;
3165
_vala_source_reference_unref0 (_tmp11_);
3208
sym = _tmp11_;
3209
_vala_source_reference_unref0 (_tmp10_);
3166
3210
vala_unresolved_symbol_set_qualified (sym, TRUE);
3167
3211
_g_free0 (name);
3168
3212
continue;
3169
3213
}
3170
_tmp14_ = vala_parser_get_src (self, &begin);
3171
_tmp15_ = _tmp14_;
3172
_tmp16_ = vala_unresolved_symbol_new (sym, name, _tmp15_);
3173
_tmp17_ = _tmp16_;
3214
_tmp12_ = vala_parser_get_src (self, &begin);
3215
_tmp13_ = _tmp12_;
3216
_tmp14_ = vala_unresolved_symbol_new (sym, name, _tmp13_);
3174
3217
_vala_code_node_unref0 (sym);
3175
sym = _tmp17_;
3176
_vala_source_reference_unref0 (_tmp15_);
3218
sym = _tmp14_;
3219
_vala_source_reference_unref0 (_tmp13_);
3177
3220
_g_free0 (name);
3178
3221
}
3179
3222
}
3312
3355
ValaSourceLocation _tmp1_ = {0};
3313
3356
ValaSourceLocation begin;
3314
3357
gboolean _tmp2_;
3315
gboolean _tmp10_;
3358
gboolean _tmp9_;
3316
3359
gboolean is_dynamic;
3317
3360
gboolean value_owned;
3318
ValaUnresolvedSymbol* _tmp23_ = NULL;
3361
ValaUnresolvedSymbol* _tmp22_ = NULL;
3319
3362
ValaUnresolvedSymbol* sym;
3320
ValaList* _tmp24_ = NULL;
3363
ValaList* _tmp23_ = NULL;
3321
3364
ValaList* type_arg_list;
3322
ValaSourceReference* _tmp25_ = NULL;
3323
ValaSourceReference* _tmp26_;
3324
ValaUnresolvedType* _tmp27_ = NULL;
3325
ValaDataType* _tmp28_;
3365
ValaSourceReference* _tmp24_ = NULL;
3366
ValaSourceReference* _tmp25_;
3367
ValaUnresolvedType* _tmp26_ = NULL;
3368
ValaDataType* _tmp27_;
3326
3369
ValaDataType* type;
3327
gboolean _tmp55_;
3370
gboolean _tmp52_;
3328
3371
GError * _inner_error_ = NULL;
3329
3372
g_return_val_if_fail (self != NULL, NULL);
3330
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
3373
vala_parser_get_location (self, &_tmp0_);
3374
_tmp1_ = _tmp0_;
3331
3375
begin = _tmp1_;
3332
3376
_tmp2_ = vala_parser_accept (self, VALA_TOKEN_TYPE_VOID);
3333
3377
if (_tmp2_) {
3339
3383
_tmp3_ = vala_parser_get_src (self, &begin);
3340
3384
_tmp4_ = _tmp3_;
3341
3385
_tmp5_ = vala_void_type_new (_tmp4_);
3342
type = (_tmp6_ = (ValaDataType*) _tmp5_, _vala_source_reference_unref0 (_tmp4_), _tmp6_);
3386
_tmp6_ = (ValaDataType*) _tmp5_;
3387
_vala_source_reference_unref0 (_tmp4_);
3388
type = _tmp6_;
3343
3389
while (TRUE) {
3344
3390
gboolean _tmp7_;
3345
3391
ValaPointerType* _tmp8_ = NULL;
3346
ValaDataType* _tmp9_;
3347
3392
_tmp7_ = vala_parser_accept (self, VALA_TOKEN_TYPE_STAR);
3348
3393
if (!_tmp7_) {
3349
3394
break;
3350
3395
}
3351
3396
_tmp8_ = vala_pointer_type_new (type, NULL);
3352
_tmp9_ = (ValaDataType*) _tmp8_;
3353
3397
_vala_code_node_unref0 (type);
3354
type = _tmp9_;
3398
type = (ValaDataType*) _tmp8_;
3355
3399
}
3356
3400
result = type;
3357
3401
return result;
3358
3402
}
3359
_tmp10_ = vala_parser_accept (self, VALA_TOKEN_TYPE_DYNAMIC);
3360
is_dynamic = _tmp10_;
3403
_tmp9_ = vala_parser_accept (self, VALA_TOKEN_TYPE_DYNAMIC);
3404
is_dynamic = _tmp9_;
3361
3405
value_owned = owned_by_default;
3362
3406
if (owned_by_default) {
3363
ValaProfile _tmp11_;
3364
_tmp11_ = vala_code_context_get_profile (self->priv->context);
3365
if (_tmp11_ == VALA_PROFILE_DOVA) {
3366
gboolean _tmp12_ = FALSE;
3407
ValaProfile _tmp10_;
3408
_tmp10_ = vala_code_context_get_profile (self->priv->context);
3409
if (_tmp10_ == VALA_PROFILE_DOVA) {
3410
gboolean _tmp11_ = FALSE;
3367
3411
if (can_weak_ref) {
3368
gboolean _tmp13_;
3369
_tmp13_ = vala_parser_accept (self, VALA_TOKEN_TYPE_WEAK);
3370
_tmp12_ = _tmp13_;
3412
gboolean _tmp12_;
3413
_tmp12_ = vala_parser_accept (self, VALA_TOKEN_TYPE_WEAK);
3414
_tmp11_ = _tmp12_;
3371
3415
} else {
3372
_tmp12_ = FALSE;
3416
_tmp11_ = FALSE;
3373
3417
}
3374
if (_tmp12_) {
3418
if (_tmp11_) {
3375
3419
value_owned = FALSE;
3376
3420
}
3377
3421
} else {
3378
gboolean _tmp14_;
3379
_tmp14_ = vala_parser_accept (self, VALA_TOKEN_TYPE_UNOWNED);
3380
if (_tmp14_) {
3422
gboolean _tmp13_;
3423
_tmp13_ = vala_parser_accept (self, VALA_TOKEN_TYPE_UNOWNED);
3424
if (_tmp13_) {
3381
3425
value_owned = FALSE;
3382
3426
} else {
3383
gboolean _tmp15_;
3384
_tmp15_ = vala_parser_accept (self, VALA_TOKEN_TYPE_WEAK);
3385
if (_tmp15_) {
3386
gboolean _tmp16_ = FALSE;
3427
gboolean _tmp14_;
3428
_tmp14_ = vala_parser_accept (self, VALA_TOKEN_TYPE_WEAK);
3429
if (_tmp14_) {
3430
gboolean _tmp15_ = FALSE;
3387
3431
if (!can_weak_ref) {
3388
gboolean _tmp17_;
3389
_tmp17_ = vala_code_context_get_deprecated (self->priv->context);
3390
_tmp16_ = !_tmp17_;
3432
gboolean _tmp16_;
3433
_tmp16_ = vala_code_context_get_deprecated (self->priv->context);
3434
_tmp15_ = !_tmp16_;
3391
3435
} else {
3392
_tmp16_ = FALSE;
3436
_tmp15_ = FALSE;
3393
3437
}
3394
if (_tmp16_) {
3395
ValaSourceReference* _tmp18_ = NULL;
3396
ValaSourceReference* _tmp19_;
3397
_tmp18_ = vala_parser_get_last_src (self);
3398
_tmp19_ = _tmp18_;
3399
vala_report_warning (_tmp19_, "deprecated syntax, use `unowned` modifier");
3400
_vala_source_reference_unref0 (_tmp19_);
3438
if (_tmp15_) {
3439
ValaSourceReference* _tmp17_ = NULL;
3440
ValaSourceReference* _tmp18_;
3441
_tmp17_ = vala_parser_get_last_src (self);
3442
_tmp18_ = _tmp17_;
3443
vala_report_warning (_tmp18_, "deprecated syntax, use `unowned` modifier");
3444
_vala_source_reference_unref0 (_tmp18_);
3401
3445
}
3402
3446
value_owned = FALSE;
3403
3447
}
3404
3448
}
3405
3449
}
3406
3450
} else {
3407
gboolean _tmp20_ = FALSE;
3408
ValaProfile _tmp21_;
3409
_tmp21_ = vala_code_context_get_profile (self->priv->context);
3410
if (_tmp21_ != VALA_PROFILE_DOVA) {
3411
gboolean _tmp22_;
3412
_tmp22_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OWNED);
3413
_tmp20_ = _tmp22_;
3414
} else {
3415
_tmp20_ = FALSE;
3416
}
3417
value_owned = _tmp20_;
3418
}
3419
_tmp23_ = vala_parser_parse_symbol_name (self, &_inner_error_);
3420
sym = _tmp23_;
3421
if (_inner_error_ != NULL) {
3422
if (_inner_error_->domain == VALA_PARSE_ERROR) {
3423
g_propagate_error (error, _inner_error_);
3424
return NULL;
3425
} else {
3426
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
3427
g_clear_error (&_inner_error_);
3428
return NULL;
3429
}
3430
}
3431
_tmp24_ = vala_parser_parse_type_argument_list (self, FALSE, &_inner_error_);
3432
type_arg_list = _tmp24_;
3433
if (_inner_error_ != NULL) {
3434
if (_inner_error_->domain == VALA_PARSE_ERROR) {
3435
g_propagate_error (error, _inner_error_);
3436
_vala_code_node_unref0 (sym);
3437
return NULL;
3438
} else {
3439
_vala_code_node_unref0 (sym);
3440
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
3441
g_clear_error (&_inner_error_);
3442
return NULL;
3443
}
3444
}
3445
_tmp25_ = vala_parser_get_src (self, &begin);
3446
_tmp26_ = _tmp25_;
3447
_tmp27_ = vala_unresolved_type_new_from_symbol (sym, _tmp26_);
3448
type = (_tmp28_ = (ValaDataType*) _tmp27_, _vala_source_reference_unref0 (_tmp26_), _tmp28_);
3451
gboolean _tmp19_ = FALSE;
3452
ValaProfile _tmp20_;
3453
_tmp20_ = vala_code_context_get_profile (self->priv->context);
3454
if (_tmp20_ != VALA_PROFILE_DOVA) {
3455
gboolean _tmp21_;
3456
_tmp21_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OWNED);
3457
_tmp19_ = _tmp21_;
3458
} else {
3459
_tmp19_ = FALSE;
3460
}
3461
value_owned = _tmp19_;
3462
}
3463
_tmp22_ = vala_parser_parse_symbol_name (self, &_inner_error_);
3464
sym = _tmp22_;
3465
if (_inner_error_ != NULL) {
3466
if (_inner_error_->domain == VALA_PARSE_ERROR) {
3467
g_propagate_error (error, _inner_error_);
3468
return NULL;
3469
} else {
3470
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
3471
g_clear_error (&_inner_error_);
3472
return NULL;
3473
}
3474
}
3475
_tmp23_ = vala_parser_parse_type_argument_list (self, FALSE, &_inner_error_);
3476
type_arg_list = _tmp23_;
3477
if (_inner_error_ != NULL) {
3478
if (_inner_error_->domain == VALA_PARSE_ERROR) {
3479
g_propagate_error (error, _inner_error_);
3480
_vala_code_node_unref0 (sym);
3481
return NULL;
3482
} else {
3483
_vala_code_node_unref0 (sym);
3484
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
3485
g_clear_error (&_inner_error_);
3486
return NULL;
3487
}
3488
}
3489
_tmp24_ = vala_parser_get_src (self, &begin);
3490
_tmp25_ = _tmp24_;
3491
_tmp26_ = vala_unresolved_type_new_from_symbol (sym, _tmp25_);
3492
_tmp27_ = (ValaDataType*) _tmp26_;
3493
_vala_source_reference_unref0 (_tmp25_);
3494
type = _tmp27_;
3449
3495
if (type_arg_list != NULL) {
3450
3496
{
3451
ValaList* _tmp29_;
3497
ValaList* _tmp28_;
3452
3498
ValaList* _type_arg_list;
3453
gint _tmp30_;
3499
gint _tmp29_;
3454
3500
gint _type_arg_size;
3455
3501
gint _type_arg_index;
3456
_tmp29_ = _vala_iterable_ref0 (type_arg_list);
3457
_type_arg_list = _tmp29_;
3458
_tmp30_ = vala_collection_get_size ((ValaCollection*) _type_arg_list);
3459
_type_arg_size = _tmp30_;
3502
_tmp28_ = _vala_iterable_ref0 (type_arg_list);
3503
_type_arg_list = _tmp28_;
3504
_tmp29_ = vala_collection_get_size ((ValaCollection*) _type_arg_list);
3505
_type_arg_size = _tmp29_;
3460
3506
_type_arg_index = -1;
3461
3507
while (TRUE) {
3462
gpointer _tmp31_ = NULL;
3508
gpointer _tmp30_ = NULL;
3463
3509
ValaDataType* type_arg;
3464
3510
_type_arg_index = _type_arg_index + 1;
3465
3511
if (!(_type_arg_index < _type_arg_size)) {
3466
3512
break;
3467
3513
}
3468
_tmp31_ = vala_list_get (_type_arg_list, _type_arg_index);
3469
type_arg = (ValaDataType*) _tmp31_;
3514
_tmp30_ = vala_list_get (_type_arg_list, _type_arg_index);
3515
type_arg = (ValaDataType*) _tmp30_;
3470
3516
vala_data_type_add_type_argument (type, type_arg);
3471
3517
_vala_code_node_unref0 (type_arg);
3472
3518
}
3474
3520
}
3475
3521
}
3476
3522
while (TRUE) {
3477
gboolean _tmp32_;
3478
ValaSourceReference* _tmp33_ = NULL;
3479
ValaSourceReference* _tmp34_;
3480
ValaPointerType* _tmp35_ = NULL;
3481
ValaDataType* _tmp36_;
3482
_tmp32_ = vala_parser_accept (self, VALA_TOKEN_TYPE_STAR);
3483
if (!_tmp32_) {
3523
gboolean _tmp31_;
3524
ValaSourceReference* _tmp32_ = NULL;
3525
ValaSourceReference* _tmp33_;
3526
ValaPointerType* _tmp34_ = NULL;
3527
_tmp31_ = vala_parser_accept (self, VALA_TOKEN_TYPE_STAR);
3528
if (!_tmp31_) {
3484
3529
break;
3485
3530
}
3486
_tmp33_ = vala_parser_get_src (self, &begin);
3487
_tmp34_ = _tmp33_;
3488
_tmp35_ = vala_pointer_type_new (type, _tmp34_);
3489
_tmp36_ = (ValaDataType*) _tmp35_;
3531
_tmp32_ = vala_parser_get_src (self, &begin);
3532
_tmp33_ = _tmp32_;
3533
_tmp34_ = vala_pointer_type_new (type, _tmp33_);
3490
3534
_vala_code_node_unref0 (type);
3491
type = _tmp36_;
3492
_vala_source_reference_unref0 (_tmp34_);
3535
type = (ValaDataType*) _tmp34_;
3536
_vala_source_reference_unref0 (_tmp33_);
3493
3537
}
3494
3538
if (!VALA_IS_POINTER_TYPE (type)) {
3495
gboolean _tmp37_;
3496
_tmp37_ = vala_parser_accept (self, VALA_TOKEN_TYPE_INTERR);
3497
vala_data_type_set_nullable (type, _tmp37_);
3539
gboolean _tmp35_;
3540
_tmp35_ = vala_parser_accept (self, VALA_TOKEN_TYPE_INTERR);
3541
vala_data_type_set_nullable (type, _tmp35_);
3498
3542
}
3499
3543
while (TRUE) {
3500
gboolean _tmp38_;
3544
gboolean _tmp36_;
3501
3545
gboolean invalid_array;
3502
3546
gint array_rank;
3503
ValaSourceReference* _tmp48_ = NULL;
3504
ValaSourceReference* _tmp49_;
3505
ValaArrayType* _tmp50_ = NULL;
3506
ValaArrayType* _tmp51_;
3547
ValaSourceReference* _tmp46_ = NULL;
3548
ValaSourceReference* _tmp47_;
3549
ValaArrayType* _tmp48_ = NULL;
3550
ValaArrayType* _tmp49_;
3507
3551
ValaArrayType* array_type;
3508
gboolean _tmp52_;
3509
ValaDataType* _tmp53_;
3510
ValaDataType* _tmp54_;
3511
_tmp38_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OPEN_BRACKET);
3512
if (!_tmp38_) {
3552
gboolean _tmp50_;
3553
ValaDataType* _tmp51_;
3554
_tmp36_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OPEN_BRACKET);
3555
if (!_tmp36_) {
3513
3556
break;
3514
3557
}
3515
3558
invalid_array = FALSE;
3516
3559
array_rank = 0;
3517
3560
{
3518
gboolean _tmp39_;
3519
_tmp39_ = TRUE;
3561
gboolean _tmp37_;
3562
_tmp37_ = TRUE;
3520
3563
while (TRUE) {
3521
gboolean _tmp43_ = FALSE;
3522
ValaTokenType _tmp44_;
3523
if (!_tmp39_) {
3524
gboolean _tmp40_ = FALSE;
3525
ValaProfile _tmp41_;
3526
_tmp41_ = vala_code_context_get_profile (self->priv->context);
3527
if (_tmp41_ != VALA_PROFILE_DOVA) {
3528
gboolean _tmp42_;
3529
_tmp42_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
3530
_tmp40_ = _tmp42_;
3564
gboolean _tmp41_ = FALSE;
3565
ValaTokenType _tmp42_;
3566
if (!_tmp37_) {
3567
gboolean _tmp38_ = FALSE;
3568
ValaProfile _tmp39_;
3569
_tmp39_ = vala_code_context_get_profile (self->priv->context);
3570
if (_tmp39_ != VALA_PROFILE_DOVA) {
3571
gboolean _tmp40_;
3572
_tmp40_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
3573
_tmp38_ = _tmp40_;
3531
3574
} else {
3532
_tmp40_ = FALSE;
3575
_tmp38_ = FALSE;
3533
3576
}
3534
if (!_tmp40_) {
3577
if (!_tmp38_) {
3535
3578
break;
3536
3579
}
3537
3580
}
3538
_tmp39_ = FALSE;
3581
_tmp37_ = FALSE;
3539
3582
array_rank++;
3540
_tmp44_ = vala_parser_current (self);
3541
if (_tmp44_ != VALA_TOKEN_TYPE_COMMA) {
3542
ValaTokenType _tmp45_;
3543
_tmp45_ = vala_parser_current (self);
3544
_tmp43_ = _tmp45_ != VALA_TOKEN_TYPE_CLOSE_BRACKET;
3583
_tmp42_ = vala_parser_current (self);
3584
if (_tmp42_ != VALA_TOKEN_TYPE_COMMA) {
3585
ValaTokenType _tmp43_;
3586
_tmp43_ = vala_parser_current (self);
3587
_tmp41_ = _tmp43_ != VALA_TOKEN_TYPE_CLOSE_BRACKET;
3545
3588
} else {
3546
_tmp43_ = FALSE;
3589
_tmp41_ = FALSE;
3547
3590
}
3548
if (_tmp43_) {
3549
ValaExpression* _tmp46_ = NULL;
3550
ValaExpression* _tmp47_;
3551
_tmp46_ = vala_parser_parse_expression (self, &_inner_error_);
3552
_tmp47_ = _tmp46_;
3553
_vala_code_node_unref0 (_tmp47_);
3591
if (_tmp41_) {
3592
ValaExpression* _tmp44_ = NULL;
3593
ValaExpression* _tmp45_;
3594
_tmp44_ = vala_parser_parse_expression (self, &_inner_error_);
3595
_tmp45_ = _tmp44_;
3596
_vala_code_node_unref0 (_tmp45_);
3554
3597
if (_inner_error_ != NULL) {
3555
3598
if (_inner_error_->domain == VALA_PARSE_ERROR) {
3556
3599
g_propagate_error (error, _inner_error_);
3589
3632
}
3590
3633
}
3591
3634
vala_data_type_set_value_owned (type, TRUE);
3592
_tmp48_ = vala_parser_get_src (self, &begin);
3635
_tmp46_ = vala_parser_get_src (self, &begin);
3636
_tmp47_ = _tmp46_;
3637
_tmp48_ = vala_array_type_new (type, array_rank, _tmp47_);
3593
3638
_tmp49_ = _tmp48_;
3594
_tmp50_ = vala_array_type_new (type, array_rank, _tmp49_);
3595
array_type = (_tmp51_ = _tmp50_, _vala_source_reference_unref0 (_tmp49_), _tmp51_);
3596
_tmp52_ = vala_parser_accept (self, VALA_TOKEN_TYPE_INTERR);
3597
vala_data_type_set_nullable ((ValaDataType*) array_type, _tmp52_);
3639
_vala_source_reference_unref0 (_tmp47_);
3640
array_type = _tmp49_;
3641
_tmp50_ = vala_parser_accept (self, VALA_TOKEN_TYPE_INTERR);
3642
vala_data_type_set_nullable ((ValaDataType*) array_type, _tmp50_);
3598
3643
vala_array_type_set_invalid_syntax (array_type, invalid_array);
3599
_tmp53_ = _vala_code_node_ref0 ((ValaDataType*) array_type);
3600
_tmp54_ = _tmp53_;
3644
_tmp51_ = _vala_code_node_ref0 ((ValaDataType*) array_type);
3601
3645
_vala_code_node_unref0 (type);
3602
type = _tmp54_;
3646
type = _tmp51_;
3603
3647
_vala_code_node_unref0 (array_type);
3604
3648
}
3605
_tmp55_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OP_NEG);
3606
if (_tmp55_) {
3607
ValaSourceReference* _tmp56_ = NULL;
3608
ValaSourceReference* _tmp57_;
3609
_tmp56_ = vala_parser_get_last_src (self);
3610
_tmp57_ = _tmp56_;
3611
vala_report_warning (_tmp57_, "obsolete syntax, types are non-null by default");
3612
_vala_source_reference_unref0 (_tmp57_);
3649
_tmp52_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OP_NEG);
3650
if (_tmp52_) {
3651
ValaSourceReference* _tmp53_ = NULL;
3652
ValaSourceReference* _tmp54_;
3653
_tmp53_ = vala_parser_get_last_src (self);
3654
_tmp54_ = _tmp53_;
3655
vala_report_warning (_tmp54_, "obsolete syntax, types are non-null by default");
3656
_vala_source_reference_unref0 (_tmp54_);
3613
3657
}
3614
3658
if (!owned_by_default) {
3615
gboolean _tmp58_ = FALSE;
3616
ValaProfile _tmp59_;
3617
_tmp59_ = vala_code_context_get_profile (self->priv->context);
3618
if (_tmp59_ != VALA_PROFILE_DOVA) {
3619
gboolean _tmp60_;
3620
_tmp60_ = vala_parser_accept (self, VALA_TOKEN_TYPE_HASH);
3621
_tmp58_ = _tmp60_;
3659
gboolean _tmp55_ = FALSE;
3660
ValaProfile _tmp56_;
3661
_tmp56_ = vala_code_context_get_profile (self->priv->context);
3662
if (_tmp56_ != VALA_PROFILE_DOVA) {
3663
gboolean _tmp57_;
3664
_tmp57_ = vala_parser_accept (self, VALA_TOKEN_TYPE_HASH);
3665
_tmp55_ = _tmp57_;
3622
3666
} else {
3623
_tmp58_ = FALSE;
3667
_tmp55_ = FALSE;
3624
3668
}
3625
if (_tmp58_) {
3626
gboolean _tmp61_;
3627
_tmp61_ = vala_code_context_get_deprecated (self->priv->context);
3628
if (!_tmp61_) {
3629
ValaSourceReference* _tmp62_ = NULL;
3630
ValaSourceReference* _tmp63_;
3631
_tmp62_ = vala_parser_get_last_src (self);
3632
_tmp63_ = _tmp62_;
3633
vala_report_warning (_tmp63_, "deprecated syntax, use `owned` modifier");
3634
_vala_source_reference_unref0 (_tmp63_);
3669
if (_tmp55_) {
3670
gboolean _tmp58_;
3671
_tmp58_ = vala_code_context_get_deprecated (self->priv->context);
3672
if (!_tmp58_) {
3673
ValaSourceReference* _tmp59_ = NULL;
3674
ValaSourceReference* _tmp60_;
3675
_tmp59_ = vala_parser_get_last_src (self);
3676
_tmp60_ = _tmp59_;
3677
vala_report_warning (_tmp60_, "deprecated syntax, use `owned` modifier");
3678
_vala_source_reference_unref0 (_tmp60_);
3635
3679
}
3636
3680
value_owned = TRUE;
3637
3681
}
3654
3698
ValaDataType* _tmp19_;
3655
3699
GError * _inner_error_ = NULL;
3656
3700
g_return_val_if_fail (self != NULL, NULL);
3657
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
3701
vala_parser_get_location (self, &_tmp0_);
3702
_tmp1_ = _tmp0_;
3658
3703
begin = _tmp1_;
3659
3704
if (type != NULL) {
3660
3705
gboolean _tmp3_;
3690
3735
_tmp6_ = vala_parser_get_error (self, "expected `]' or integer literal");
3691
3736
_tmp7_ = _tmp6_;
3692
3737
_tmp8_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp7_);
3693
_inner_error_ = (_tmp9_ = _tmp8_, _g_free0 (_tmp7_), _tmp9_);
3738
_tmp9_ = _tmp8_;
3739
_g_free0 (_tmp7_);
3740
_inner_error_ = _tmp9_;
3694
3741
if (_inner_error_->domain == VALA_PARSE_ERROR) {
3695
3742
g_propagate_error (error, _inner_error_);
3696
3743
return NULL;
3732
3779
_tmp14_ = vala_parser_get_src (self, &begin);
3733
3780
_tmp15_ = _tmp14_;
3734
3781
_tmp16_ = vala_array_type_new (type, 1, _tmp15_);
3735
array_type = (_tmp17_ = _tmp16_, _vala_source_reference_unref0 (_tmp15_), _tmp17_);
3782
_tmp17_ = _tmp16_;
3783
_vala_source_reference_unref0 (_tmp15_);
3784
array_type = _tmp17_;
3736
3785
vala_array_type_set_inline_allocated (array_type, TRUE);
3737
3786
if (array_length > 0) {
3738
3787
vala_array_type_set_fixed_length (array_type, TRUE);
3808
3857
gboolean _tmp2_;
3809
3858
GError * _inner_error_ = NULL;
3810
3859
g_return_val_if_fail (self != NULL, NULL);
3811
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
3860
vala_parser_get_location (self, &_tmp0_);
3861
_tmp1_ = _tmp0_;
3812
3862
begin = _tmp1_;
3813
3863
_tmp2_ = vala_parser_accept (self, VALA_TOKEN_TYPE_REF);
3814
3864
if (_tmp2_) {
3833
3883
_tmp4_ = vala_parser_get_src (self, &begin);
3834
3884
_tmp5_ = _tmp4_;
3835
3885
_tmp6_ = vala_unary_expression_new (VALA_UNARY_OPERATOR_REF, inner, _tmp5_);
3836
result = (_tmp7_ = (ValaExpression*) _tmp6_, _vala_source_reference_unref0 (_tmp5_), _tmp7_);
3886
_tmp7_ = (ValaExpression*) _tmp6_;
3887
_vala_source_reference_unref0 (_tmp5_);
3888
result = _tmp7_;
3837
3889
_vala_code_node_unref0 (inner);
3838
3890
return result;
3839
3891
} else {
3861
3913
_tmp10_ = vala_parser_get_src (self, &begin);
3862
3914
_tmp11_ = _tmp10_;
3863
3915
_tmp12_ = vala_unary_expression_new (VALA_UNARY_OPERATOR_OUT, inner, _tmp11_);
3864
result = (_tmp13_ = (ValaExpression*) _tmp12_, _vala_source_reference_unref0 (_tmp11_), _tmp13_);
3916
_tmp13_ = (ValaExpression*) _tmp12_;
3917
_vala_source_reference_unref0 (_tmp11_);
3918
result = _tmp13_;
3865
3919
_vala_code_node_unref0 (inner);
3866
3920
return result;
3867
3921
} else {
3884
3938
return NULL;
3885
3939
}
3886
3940
}
3887
_tmp16_ = _vala_code_node_ref0 ((_tmp15_ = expr, VALA_IS_MEMBER_ACCESS (_tmp15_) ? ((ValaMemberAccess*) _tmp15_) : NULL));
3941
_tmp15_ = expr;
3942
_tmp16_ = _vala_code_node_ref0 (VALA_IS_MEMBER_ACCESS (_tmp15_) ? ((ValaMemberAccess*) _tmp15_) : NULL);
3888
3943
ma = _tmp16_;
3889
3944
if (ma != NULL) {
3890
3945
ValaExpression* _tmp19_ = NULL;
3903
3958
if (_tmp17_) {
3904
3959
ValaExpression* _tmp21_ = NULL;
3905
3960
ValaExpression* _tmp22_;
3906
ValaExpression* _tmp23_;
3907
const gchar* _tmp24_ = NULL;
3908
ValaSourceReference* _tmp25_ = NULL;
3909
ValaSourceReference* _tmp26_;
3910
ValaNamedArgument* _tmp27_ = NULL;
3911
ValaExpression* _tmp28_;
3961
const gchar* _tmp23_ = NULL;
3962
ValaSourceReference* _tmp24_ = NULL;
3963
ValaSourceReference* _tmp25_;
3964
ValaNamedArgument* _tmp26_ = NULL;
3965
ValaExpression* _tmp27_;
3912
3966
_tmp21_ = vala_parser_parse_expression (self, &_inner_error_);
3913
3967
_tmp22_ = _tmp21_;
3914
3968
if (_inner_error_ != NULL) {
3925
3979
return NULL;
3926
3980
}
3927
3981
}
3928
_tmp23_ = _tmp22_;
3929
3982
_vala_code_node_unref0 (expr);
3930
expr = _tmp23_;
3931
_tmp24_ = vala_member_access_get_member_name (ma);
3932
_tmp25_ = vala_parser_get_src (self, &begin);
3933
_tmp26_ = _tmp25_;
3934
_tmp27_ = vala_named_argument_new (_tmp24_, expr, _tmp26_);
3935
result = (_tmp28_ = (ValaExpression*) _tmp27_, _vala_source_reference_unref0 (_tmp26_), _tmp28_);
3983
expr = _tmp22_;
3984
_tmp23_ = vala_member_access_get_member_name (ma);
3985
_tmp24_ = vala_parser_get_src (self, &begin);
3986
_tmp25_ = _tmp24_;
3987
_tmp26_ = vala_named_argument_new (_tmp23_, expr, _tmp25_);
3988
_tmp27_ = (ValaExpression*) _tmp26_;
3989
_vala_source_reference_unref0 (_tmp25_);
3990
result = _tmp27_;
3936
3991
_vala_code_node_unref0 (ma);
3937
3992
_vala_code_node_unref0 (expr);
3938
3993
return result;
3958
4013
gboolean found;
3959
4014
GError * _inner_error_ = NULL;
3960
4015
g_return_val_if_fail (self != NULL, NULL);
3961
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
4016
vala_parser_get_location (self, &_tmp0_);
4017
_tmp1_ = _tmp0_;
3962
4018
begin = _tmp1_;
3963
4019
_tmp2_ = vala_parser_current (self);
3964
4020
switch (_tmp2_) {
3975
4031
{
3976
4032
ValaExpression* _tmp3_ = NULL;
3977
4033
ValaExpression* _tmp4_;
3978
ValaExpression* _tmp5_;
3979
4034
_tmp3_ = vala_parser_parse_literal (self, &_inner_error_);
3980
4035
_tmp4_ = _tmp3_;
3981
4036
if (_inner_error_ != NULL) {
3990
4045
return NULL;
3991
4046
}
3992
4047
}
3993
_tmp5_ = _tmp4_;
3994
4048
_vala_code_node_unref0 (expr);
3995
expr = _tmp5_;
4049
expr = _tmp4_;
3996
4050
break;
3997
4051
}
3998
4052
case VALA_TOKEN_TYPE_OPEN_BRACE:
3999
4053
{
4000
ValaProfile _tmp6_;
4001
_tmp6_ = vala_code_context_get_profile (self->priv->context);
4002
if (_tmp6_ == VALA_PROFILE_DOVA) {
4003
ValaExpression* _tmp7_ = NULL;
4004
ValaExpression* _tmp8_;
4005
ValaExpression* _tmp9_;
4006
_tmp7_ = vala_parser_parse_set_literal (self, &_inner_error_);
4007
_tmp8_ = _tmp7_;
4054
ValaProfile _tmp5_;
4055
_tmp5_ = vala_code_context_get_profile (self->priv->context);
4056
if (_tmp5_ == VALA_PROFILE_DOVA) {
4057
ValaExpression* _tmp6_ = NULL;
4058
ValaExpression* _tmp7_;
4059
_tmp6_ = vala_parser_parse_set_literal (self, &_inner_error_);
4060
_tmp7_ = _tmp6_;
4008
4061
if (_inner_error_ != NULL) {
4009
4062
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4010
4063
g_propagate_error (error, _inner_error_);
4017
4070
return NULL;
4018
4071
}
4019
4072
}
4073
_vala_code_node_unref0 (expr);
4074
expr = _tmp7_;
4075
} else {
4076
ValaInitializerList* _tmp8_ = NULL;
4077
ValaInitializerList* _tmp9_;
4078
_tmp8_ = vala_parser_parse_initializer (self, &_inner_error_);
4020
4079
_tmp9_ = _tmp8_;
4021
_vala_code_node_unref0 (expr);
4022
expr = _tmp9_;
4023
} else {
4024
ValaInitializerList* _tmp10_ = NULL;
4025
ValaInitializerList* _tmp11_;
4026
ValaExpression* _tmp12_;
4027
_tmp10_ = vala_parser_parse_initializer (self, &_inner_error_);
4028
_tmp11_ = _tmp10_;
4029
4080
if (_inner_error_ != NULL) {
4030
4081
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4031
4082
g_propagate_error (error, _inner_error_);
4038
4089
return NULL;
4039
4090
}
4040
4091
}
4041
_tmp12_ = (ValaExpression*) _tmp11_;
4042
4092
_vala_code_node_unref0 (expr);
4043
expr = _tmp12_;
4093
expr = (ValaExpression*) _tmp9_;
4044
4094
}
4045
4095
break;
4046
4096
}
4047
4097
case VALA_TOKEN_TYPE_OPEN_BRACKET:
4048
4098
{
4049
ValaProfile _tmp13_;
4050
_tmp13_ = vala_code_context_get_profile (self->priv->context);
4051
if (_tmp13_ == VALA_PROFILE_DOVA) {
4052
ValaListLiteral* _tmp14_ = NULL;
4053
ValaListLiteral* _tmp15_;
4054
ValaExpression* _tmp16_;
4055
_tmp14_ = vala_parser_parse_list_literal (self, &_inner_error_);
4056
_tmp15_ = _tmp14_;
4099
ValaProfile _tmp10_;
4100
_tmp10_ = vala_code_context_get_profile (self->priv->context);
4101
if (_tmp10_ == VALA_PROFILE_DOVA) {
4102
ValaListLiteral* _tmp11_ = NULL;
4103
ValaListLiteral* _tmp12_;
4104
_tmp11_ = vala_parser_parse_list_literal (self, &_inner_error_);
4105
_tmp12_ = _tmp11_;
4057
4106
if (_inner_error_ != NULL) {
4058
4107
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4059
4108
g_propagate_error (error, _inner_error_);
4066
4115
return NULL;
4067
4116
}
4068
4117
}
4069
_tmp16_ = (ValaExpression*) _tmp15_;
4070
4118
_vala_code_node_unref0 (expr);
4071
expr = _tmp16_;
4119
expr = (ValaExpression*) _tmp12_;
4072
4120
} else {
4073
ValaExpression* _tmp17_ = NULL;
4074
ValaExpression* _tmp18_;
4075
ValaExpression* _tmp19_;
4076
_tmp17_ = vala_parser_parse_simple_name (self, &_inner_error_);
4077
_tmp18_ = _tmp17_;
4121
ValaExpression* _tmp13_ = NULL;
4122
ValaExpression* _tmp14_;
4123
_tmp13_ = vala_parser_parse_simple_name (self, &_inner_error_);
4124
_tmp14_ = _tmp13_;
4078
4125
if (_inner_error_ != NULL) {
4079
4126
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4080
4127
g_propagate_error (error, _inner_error_);
4087
4134
return NULL;
4088
4135
}
4089
4136
}
4090
_tmp19_ = _tmp18_;
4091
4137
_vala_code_node_unref0 (expr);
4092
expr = _tmp19_;
4138
expr = _tmp14_;
4093
4139
}
4094
4140
break;
4095
4141
}
4096
4142
case VALA_TOKEN_TYPE_OPEN_PARENS:
4097
4143
{
4098
ValaExpression* _tmp20_ = NULL;
4099
ValaExpression* _tmp21_;
4144
ValaExpression* _tmp15_ = NULL;
4145
ValaExpression* _tmp16_;
4146
_tmp15_ = vala_parser_parse_tuple (self, &_inner_error_);
4147
_tmp16_ = _tmp15_;
4148
if (_inner_error_ != NULL) {
4149
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4150
g_propagate_error (error, _inner_error_);
4151
_vala_code_node_unref0 (expr);
4152
return NULL;
4153
} else {
4154
_vala_code_node_unref0 (expr);
4155
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4156
g_clear_error (&_inner_error_);
4157
return NULL;
4158
}
4159
}
4160
_vala_code_node_unref0 (expr);
4161
expr = _tmp16_;
4162
break;
4163
}
4164
case VALA_TOKEN_TYPE_OPEN_TEMPLATE:
4165
{
4166
ValaExpression* _tmp17_ = NULL;
4167
ValaExpression* _tmp18_;
4168
_tmp17_ = vala_parser_parse_template (self, &_inner_error_);
4169
_tmp18_ = _tmp17_;
4170
if (_inner_error_ != NULL) {
4171
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4172
g_propagate_error (error, _inner_error_);
4173
_vala_code_node_unref0 (expr);
4174
return NULL;
4175
} else {
4176
_vala_code_node_unref0 (expr);
4177
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4178
g_clear_error (&_inner_error_);
4179
return NULL;
4180
}
4181
}
4182
_vala_code_node_unref0 (expr);
4183
expr = _tmp18_;
4184
break;
4185
}
4186
case VALA_TOKEN_TYPE_OPEN_REGEX_LITERAL:
4187
{
4188
ValaExpression* _tmp19_ = NULL;
4189
ValaExpression* _tmp20_;
4190
_tmp19_ = vala_parser_parse_regex_literal (self, &_inner_error_);
4191
_tmp20_ = _tmp19_;
4192
if (_inner_error_ != NULL) {
4193
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4194
g_propagate_error (error, _inner_error_);
4195
_vala_code_node_unref0 (expr);
4196
return NULL;
4197
} else {
4198
_vala_code_node_unref0 (expr);
4199
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4200
g_clear_error (&_inner_error_);
4201
return NULL;
4202
}
4203
}
4204
_vala_code_node_unref0 (expr);
4205
expr = _tmp20_;
4206
break;
4207
}
4208
case VALA_TOKEN_TYPE_THIS:
4209
{
4210
ValaExpression* _tmp21_ = NULL;
4100
4211
ValaExpression* _tmp22_;
4101
_tmp20_ = vala_parser_parse_tuple (self, &_inner_error_);
4102
_tmp21_ = _tmp20_;
4103
if (_inner_error_ != NULL) {
4104
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4105
g_propagate_error (error, _inner_error_);
4106
_vala_code_node_unref0 (expr);
4107
return NULL;
4108
} else {
4109
_vala_code_node_unref0 (expr);
4110
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4111
g_clear_error (&_inner_error_);
4112
return NULL;
4113
}
4114
}
4212
_tmp21_ = vala_parser_parse_this_access (self, &_inner_error_);
4115
4213
_tmp22_ = _tmp21_;
4214
if (_inner_error_ != NULL) {
4215
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4216
g_propagate_error (error, _inner_error_);
4217
_vala_code_node_unref0 (expr);
4218
return NULL;
4219
} else {
4220
_vala_code_node_unref0 (expr);
4221
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4222
g_clear_error (&_inner_error_);
4223
return NULL;
4224
}
4225
}
4116
4226
_vala_code_node_unref0 (expr);
4117
4227
expr = _tmp22_;
4118
4228
break;
4119
4229
}
4120
case VALA_TOKEN_TYPE_OPEN_TEMPLATE:
4230
case VALA_TOKEN_TYPE_BASE:
4121
4231
{
4122
4232
ValaExpression* _tmp23_ = NULL;
4123
4233
ValaExpression* _tmp24_;
4124
ValaExpression* _tmp25_;
4125
_tmp23_ = vala_parser_parse_template (self, &_inner_error_);
4234
_tmp23_ = vala_parser_parse_base_access (self, &_inner_error_);
4126
4235
_tmp24_ = _tmp23_;
4127
4236
if (_inner_error_ != NULL) {
4128
4237
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4136
4245
return NULL;
4137
4246
}
4138
4247
}
4139
_tmp25_ = _tmp24_;
4140
_vala_code_node_unref0 (expr);
4141
expr = _tmp25_;
4142
break;
4143
}
4144
case VALA_TOKEN_TYPE_OPEN_REGEX_LITERAL:
4145
{
4146
ValaExpression* _tmp26_ = NULL;
4147
ValaExpression* _tmp27_;
4248
_vala_code_node_unref0 (expr);
4249
expr = _tmp24_;
4250
break;
4251
}
4252
case VALA_TOKEN_TYPE_NEW:
4253
{
4254
ValaExpression* _tmp25_ = NULL;
4255
ValaExpression* _tmp26_;
4256
_tmp25_ = vala_parser_parse_object_or_array_creation_expression (self, &_inner_error_);
4257
_tmp26_ = _tmp25_;
4258
if (_inner_error_ != NULL) {
4259
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4260
g_propagate_error (error, _inner_error_);
4261
_vala_code_node_unref0 (expr);
4262
return NULL;
4263
} else {
4264
_vala_code_node_unref0 (expr);
4265
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4266
g_clear_error (&_inner_error_);
4267
return NULL;
4268
}
4269
}
4270
_vala_code_node_unref0 (expr);
4271
expr = _tmp26_;
4272
break;
4273
}
4274
case VALA_TOKEN_TYPE_YIELD:
4275
{
4276
ValaExpression* _tmp27_ = NULL;
4148
4277
ValaExpression* _tmp28_;
4149
_tmp26_ = vala_parser_parse_regex_literal (self, &_inner_error_);
4150
_tmp27_ = _tmp26_;
4278
_tmp27_ = vala_parser_parse_yield_expression (self, &_inner_error_);
4279
_tmp28_ = _tmp27_;
4151
4280
if (_inner_error_ != NULL) {
4152
4281
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4153
4282
g_propagate_error (error, _inner_error_);
4160
4289
return NULL;
4161
4290
}
4162
4291
}
4163
_tmp28_ = _tmp27_;
4164
4292
_vala_code_node_unref0 (expr);
4165
4293
expr = _tmp28_;
4166
4294
break;
4167
4295
}
4168
case VALA_TOKEN_TYPE_THIS:
4296
case VALA_TOKEN_TYPE_SIZEOF:
4169
4297
{
4170
4298
ValaExpression* _tmp29_ = NULL;
4171
4299
ValaExpression* _tmp30_;
4172
ValaExpression* _tmp31_;
4173
_tmp29_ = vala_parser_parse_this_access (self, &_inner_error_);
4300
_tmp29_ = vala_parser_parse_sizeof_expression (self, &_inner_error_);
4174
4301
_tmp30_ = _tmp29_;
4175
4302
if (_inner_error_ != NULL) {
4176
4303
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4184
4311
return NULL;
4185
4312
}
4186
4313
}
4187
_tmp31_ = _tmp30_;
4188
_vala_code_node_unref0 (expr);
4189
expr = _tmp31_;
4190
break;
4191
}
4192
case VALA_TOKEN_TYPE_BASE:
4193
{
4194
ValaExpression* _tmp32_ = NULL;
4195
ValaExpression* _tmp33_;
4314
_vala_code_node_unref0 (expr);
4315
expr = _tmp30_;
4316
break;
4317
}
4318
case VALA_TOKEN_TYPE_TYPEOF:
4319
{
4320
ValaExpression* _tmp31_ = NULL;
4321
ValaExpression* _tmp32_;
4322
_tmp31_ = vala_parser_parse_typeof_expression (self, &_inner_error_);
4323
_tmp32_ = _tmp31_;
4324
if (_inner_error_ != NULL) {
4325
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4326
g_propagate_error (error, _inner_error_);
4327
_vala_code_node_unref0 (expr);
4328
return NULL;
4329
} else {
4330
_vala_code_node_unref0 (expr);
4331
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4332
g_clear_error (&_inner_error_);
4333
return NULL;
4334
}
4335
}
4336
_vala_code_node_unref0 (expr);
4337
expr = _tmp32_;
4338
break;
4339
}
4340
default:
4341
{
4342
ValaExpression* _tmp33_ = NULL;
4196
4343
ValaExpression* _tmp34_;
4197
_tmp32_ = vala_parser_parse_base_access (self, &_inner_error_);
4198
_tmp33_ = _tmp32_;
4344
_tmp33_ = vala_parser_parse_simple_name (self, &_inner_error_);
4345
_tmp34_ = _tmp33_;
4199
4346
if (_inner_error_ != NULL) {
4200
4347
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4201
4348
g_propagate_error (error, _inner_error_);
4208
4355
return NULL;
4209
4356
}
4210
4357
}
4211
_tmp34_ = _tmp33_;
4212
4358
_vala_code_node_unref0 (expr);
4213
4359
expr = _tmp34_;
4214
4360
break;
4215
4361
}
4216
case VALA_TOKEN_TYPE_NEW:
4217
{
4218
ValaExpression* _tmp35_ = NULL;
4219
ValaExpression* _tmp36_;
4220
ValaExpression* _tmp37_;
4221
_tmp35_ = vala_parser_parse_object_or_array_creation_expression (self, &_inner_error_);
4222
_tmp36_ = _tmp35_;
4223
if (_inner_error_ != NULL) {
4224
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4225
g_propagate_error (error, _inner_error_);
4226
_vala_code_node_unref0 (expr);
4227
return NULL;
4228
} else {
4229
_vala_code_node_unref0 (expr);
4230
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4231
g_clear_error (&_inner_error_);
4232
return NULL;
4233
}
4234
}
4235
_tmp37_ = _tmp36_;
4236
_vala_code_node_unref0 (expr);
4237
expr = _tmp37_;
4238
break;
4239
}
4240
case VALA_TOKEN_TYPE_YIELD:
4241
{
4242
ValaExpression* _tmp38_ = NULL;
4243
ValaExpression* _tmp39_;
4244
ValaExpression* _tmp40_;
4245
_tmp38_ = vala_parser_parse_yield_expression (self, &_inner_error_);
4246
_tmp39_ = _tmp38_;
4247
if (_inner_error_ != NULL) {
4248
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4249
g_propagate_error (error, _inner_error_);
4250
_vala_code_node_unref0 (expr);
4251
return NULL;
4252
} else {
4253
_vala_code_node_unref0 (expr);
4254
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4255
g_clear_error (&_inner_error_);
4256
return NULL;
4257
}
4258
}
4259
_tmp40_ = _tmp39_;
4260
_vala_code_node_unref0 (expr);
4261
expr = _tmp40_;
4262
break;
4263
}
4264
case VALA_TOKEN_TYPE_SIZEOF:
4265
{
4266
ValaExpression* _tmp41_ = NULL;
4267
ValaExpression* _tmp42_;
4268
ValaExpression* _tmp43_;
4269
_tmp41_ = vala_parser_parse_sizeof_expression (self, &_inner_error_);
4270
_tmp42_ = _tmp41_;
4271
if (_inner_error_ != NULL) {
4272
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4273
g_propagate_error (error, _inner_error_);
4274
_vala_code_node_unref0 (expr);
4275
return NULL;
4276
} else {
4277
_vala_code_node_unref0 (expr);
4278
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4279
g_clear_error (&_inner_error_);
4280
return NULL;
4281
}
4282
}
4283
_tmp43_ = _tmp42_;
4284
_vala_code_node_unref0 (expr);
4285
expr = _tmp43_;
4286
break;
4287
}
4288
case VALA_TOKEN_TYPE_TYPEOF:
4289
{
4290
ValaExpression* _tmp44_ = NULL;
4291
ValaExpression* _tmp45_;
4292
ValaExpression* _tmp46_;
4293
_tmp44_ = vala_parser_parse_typeof_expression (self, &_inner_error_);
4294
_tmp45_ = _tmp44_;
4295
if (_inner_error_ != NULL) {
4296
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4297
g_propagate_error (error, _inner_error_);
4298
_vala_code_node_unref0 (expr);
4299
return NULL;
4300
} else {
4301
_vala_code_node_unref0 (expr);
4302
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4303
g_clear_error (&_inner_error_);
4304
return NULL;
4305
}
4306
}
4307
_tmp46_ = _tmp45_;
4308
_vala_code_node_unref0 (expr);
4309
expr = _tmp46_;
4310
break;
4311
}
4312
default:
4313
{
4314
ValaExpression* _tmp47_ = NULL;
4315
ValaExpression* _tmp48_;
4316
ValaExpression* _tmp49_;
4317
_tmp47_ = vala_parser_parse_simple_name (self, &_inner_error_);
4318
_tmp48_ = _tmp47_;
4319
if (_inner_error_ != NULL) {
4320
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4321
g_propagate_error (error, _inner_error_);
4322
_vala_code_node_unref0 (expr);
4323
return NULL;
4324
} else {
4325
_vala_code_node_unref0 (expr);
4326
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4327
g_clear_error (&_inner_error_);
4328
return NULL;
4329
}
4330
}
4331
_tmp49_ = _tmp48_;
4332
_vala_code_node_unref0 (expr);
4333
expr = _tmp49_;
4334
break;
4335
}
4336
4362
}
4337
4363
found = TRUE;
4338
4364
while (TRUE) {
4339
ValaTokenType _tmp50_;
4365
ValaTokenType _tmp35_;
4340
4366
if (!found) {
4341
4367
break;
4342
4368
}
4343
_tmp50_ = vala_parser_current (self);
4344
switch (_tmp50_) {
4369
_tmp35_ = vala_parser_current (self);
4370
switch (_tmp35_) {
4345
4371
case VALA_TOKEN_TYPE_DOT:
4346
4372
{
4373
ValaExpression* _tmp36_ = NULL;
4374
ValaExpression* _tmp37_;
4375
_tmp36_ = vala_parser_parse_member_access (self, &begin, expr, &_inner_error_);
4376
_tmp37_ = _tmp36_;
4377
if (_inner_error_ != NULL) {
4378
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4379
g_propagate_error (error, _inner_error_);
4380
_vala_code_node_unref0 (expr);
4381
return NULL;
4382
} else {
4383
_vala_code_node_unref0 (expr);
4384
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4385
g_clear_error (&_inner_error_);
4386
return NULL;
4387
}
4388
}
4389
_vala_code_node_unref0 (expr);
4390
expr = _tmp37_;
4391
break;
4392
}
4393
case VALA_TOKEN_TYPE_OP_PTR:
4394
{
4395
ValaProfile _tmp38_;
4396
_tmp38_ = vala_code_context_get_profile (self->priv->context);
4397
if (_tmp38_ == VALA_PROFILE_DOVA) {
4398
found = FALSE;
4399
} else {
4400
ValaExpression* _tmp39_ = NULL;
4401
ValaExpression* _tmp40_;
4402
_tmp39_ = vala_parser_parse_pointer_member_access (self, &begin, expr, &_inner_error_);
4403
_tmp40_ = _tmp39_;
4404
if (_inner_error_ != NULL) {
4405
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4406
g_propagate_error (error, _inner_error_);
4407
_vala_code_node_unref0 (expr);
4408
return NULL;
4409
} else {
4410
_vala_code_node_unref0 (expr);
4411
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4412
g_clear_error (&_inner_error_);
4413
return NULL;
4414
}
4415
}
4416
_vala_code_node_unref0 (expr);
4417
expr = _tmp40_;
4418
}
4419
break;
4420
}
4421
case VALA_TOKEN_TYPE_OPEN_PARENS:
4422
{
4423
ValaExpression* _tmp41_ = NULL;
4424
ValaExpression* _tmp42_;
4425
_tmp41_ = vala_parser_parse_method_call (self, &begin, expr, &_inner_error_);
4426
_tmp42_ = _tmp41_;
4427
if (_inner_error_ != NULL) {
4428
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4429
g_propagate_error (error, _inner_error_);
4430
_vala_code_node_unref0 (expr);
4431
return NULL;
4432
} else {
4433
_vala_code_node_unref0 (expr);
4434
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4435
g_clear_error (&_inner_error_);
4436
return NULL;
4437
}
4438
}
4439
_vala_code_node_unref0 (expr);
4440
expr = _tmp42_;
4441
break;
4442
}
4443
case VALA_TOKEN_TYPE_OPEN_BRACKET:
4444
{
4445
ValaExpression* _tmp43_ = NULL;
4446
ValaExpression* _tmp44_;
4447
_tmp43_ = vala_parser_parse_element_access (self, &begin, expr, &_inner_error_);
4448
_tmp44_ = _tmp43_;
4449
if (_inner_error_ != NULL) {
4450
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4451
g_propagate_error (error, _inner_error_);
4452
_vala_code_node_unref0 (expr);
4453
return NULL;
4454
} else {
4455
_vala_code_node_unref0 (expr);
4456
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4457
g_clear_error (&_inner_error_);
4458
return NULL;
4459
}
4460
}
4461
_vala_code_node_unref0 (expr);
4462
expr = _tmp44_;
4463
break;
4464
}
4465
case VALA_TOKEN_TYPE_OPEN_BRACE:
4466
{
4467
ValaExpression* _tmp45_;
4468
ValaMemberAccess* _tmp46_;
4469
ValaMemberAccess* ma;
4470
gboolean _tmp47_ = FALSE;
4471
ValaProfile _tmp48_;
4472
_tmp45_ = expr;
4473
_tmp46_ = _vala_code_node_ref0 (VALA_IS_MEMBER_ACCESS (_tmp45_) ? ((ValaMemberAccess*) _tmp45_) : NULL);
4474
ma = _tmp46_;
4475
_tmp48_ = vala_code_context_get_profile (self->priv->context);
4476
if (_tmp48_ == VALA_PROFILE_DOVA) {
4477
_tmp47_ = ma != NULL;
4478
} else {
4479
_tmp47_ = FALSE;
4480
}
4481
if (_tmp47_) {
4482
ValaExpression* _tmp49_ = NULL;
4483
ValaExpression* _tmp50_;
4484
_tmp49_ = vala_parser_parse_object_literal (self, &begin, ma, &_inner_error_);
4485
_tmp50_ = _tmp49_;
4486
if (_inner_error_ != NULL) {
4487
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4488
g_propagate_error (error, _inner_error_);
4489
_vala_code_node_unref0 (ma);
4490
_vala_code_node_unref0 (expr);
4491
return NULL;
4492
} else {
4493
_vala_code_node_unref0 (ma);
4494
_vala_code_node_unref0 (expr);
4495
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4496
g_clear_error (&_inner_error_);
4497
return NULL;
4498
}
4499
}
4500
_vala_code_node_unref0 (expr);
4501
expr = _tmp50_;
4502
} else {
4503
found = FALSE;
4504
}
4505
_vala_code_node_unref0 (ma);
4506
break;
4507
}
4508
case VALA_TOKEN_TYPE_OP_INC:
4509
{
4347
4510
ValaExpression* _tmp51_ = NULL;
4348
4511
ValaExpression* _tmp52_;
4349
ValaExpression* _tmp53_;
4350
_tmp51_ = vala_parser_parse_member_access (self, &begin, expr, &_inner_error_);
4512
_tmp51_ = vala_parser_parse_post_increment_expression (self, &begin, expr, &_inner_error_);
4351
4513
_tmp52_ = _tmp51_;
4352
4514
if (_inner_error_ != NULL) {
4353
4515
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4361
4523
return NULL;
4362
4524
}
4363
4525
}
4364
_tmp53_ = _tmp52_;
4365
_vala_code_node_unref0 (expr);
4366
expr = _tmp53_;
4367
break;
4368
}
4369
case VALA_TOKEN_TYPE_OP_PTR:
4370
{
4371
ValaProfile _tmp54_;
4372
_tmp54_ = vala_code_context_get_profile (self->priv->context);
4373
if (_tmp54_ == VALA_PROFILE_DOVA) {
4374
found = FALSE;
4375
} else {
4376
ValaExpression* _tmp55_ = NULL;
4377
ValaExpression* _tmp56_;
4378
ValaExpression* _tmp57_;
4379
_tmp55_ = vala_parser_parse_pointer_member_access (self, &begin, expr, &_inner_error_);
4380
_tmp56_ = _tmp55_;
4381
if (_inner_error_ != NULL) {
4382
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4383
g_propagate_error (error, _inner_error_);
4384
_vala_code_node_unref0 (expr);
4385
return NULL;
4386
} else {
4387
_vala_code_node_unref0 (expr);
4388
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4389
g_clear_error (&_inner_error_);
4390
return NULL;
4391
}
4392
}
4393
_tmp57_ = _tmp56_;
4394
_vala_code_node_unref0 (expr);
4395
expr = _tmp57_;
4396
}
4397
break;
4398
}
4399
case VALA_TOKEN_TYPE_OPEN_PARENS:
4400
{
4401
ValaExpression* _tmp58_ = NULL;
4402
ValaExpression* _tmp59_;
4403
ValaExpression* _tmp60_;
4404
_tmp58_ = vala_parser_parse_method_call (self, &begin, expr, &_inner_error_);
4405
_tmp59_ = _tmp58_;
4406
if (_inner_error_ != NULL) {
4407
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4408
g_propagate_error (error, _inner_error_);
4409
_vala_code_node_unref0 (expr);
4410
return NULL;
4411
} else {
4412
_vala_code_node_unref0 (expr);
4413
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4414
g_clear_error (&_inner_error_);
4415
return NULL;
4416
}
4417
}
4418
_tmp60_ = _tmp59_;
4419
_vala_code_node_unref0 (expr);
4420
expr = _tmp60_;
4421
break;
4422
}
4423
case VALA_TOKEN_TYPE_OPEN_BRACKET:
4424
{
4425
ValaExpression* _tmp61_ = NULL;
4426
ValaExpression* _tmp62_;
4427
ValaExpression* _tmp63_;
4428
_tmp61_ = vala_parser_parse_element_access (self, &begin, expr, &_inner_error_);
4429
_tmp62_ = _tmp61_;
4430
if (_inner_error_ != NULL) {
4431
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4432
g_propagate_error (error, _inner_error_);
4433
_vala_code_node_unref0 (expr);
4434
return NULL;
4435
} else {
4436
_vala_code_node_unref0 (expr);
4437
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4438
g_clear_error (&_inner_error_);
4439
return NULL;
4440
}
4441
}
4442
_tmp63_ = _tmp62_;
4443
_vala_code_node_unref0 (expr);
4444
expr = _tmp63_;
4445
break;
4446
}
4447
case VALA_TOKEN_TYPE_OPEN_BRACE:
4448
{
4449
ValaExpression* _tmp64_;
4450
ValaMemberAccess* _tmp65_;
4451
ValaMemberAccess* ma;
4452
gboolean _tmp66_ = FALSE;
4453
ValaProfile _tmp67_;
4454
_tmp65_ = _vala_code_node_ref0 ((_tmp64_ = expr, VALA_IS_MEMBER_ACCESS (_tmp64_) ? ((ValaMemberAccess*) _tmp64_) : NULL));
4455
ma = _tmp65_;
4456
_tmp67_ = vala_code_context_get_profile (self->priv->context);
4457
if (_tmp67_ == VALA_PROFILE_DOVA) {
4458
_tmp66_ = ma != NULL;
4459
} else {
4460
_tmp66_ = FALSE;
4461
}
4462
if (_tmp66_) {
4463
ValaExpression* _tmp68_ = NULL;
4464
ValaExpression* _tmp69_;
4465
ValaExpression* _tmp70_;
4466
_tmp68_ = vala_parser_parse_object_literal (self, &begin, ma, &_inner_error_);
4467
_tmp69_ = _tmp68_;
4468
if (_inner_error_ != NULL) {
4469
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4470
g_propagate_error (error, _inner_error_);
4471
_vala_code_node_unref0 (ma);
4472
_vala_code_node_unref0 (expr);
4473
return NULL;
4474
} else {
4475
_vala_code_node_unref0 (ma);
4476
_vala_code_node_unref0 (expr);
4477
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4478
g_clear_error (&_inner_error_);
4479
return NULL;
4480
}
4481
}
4482
_tmp70_ = _tmp69_;
4483
_vala_code_node_unref0 (expr);
4484
expr = _tmp70_;
4485
} else {
4486
found = FALSE;
4487
}
4488
_vala_code_node_unref0 (ma);
4489
break;
4490
}
4491
case VALA_TOKEN_TYPE_OP_INC:
4492
{
4493
ValaExpression* _tmp71_ = NULL;
4494
ValaExpression* _tmp72_;
4495
ValaExpression* _tmp73_;
4496
_tmp71_ = vala_parser_parse_post_increment_expression (self, &begin, expr, &_inner_error_);
4497
_tmp72_ = _tmp71_;
4498
if (_inner_error_ != NULL) {
4499
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4500
g_propagate_error (error, _inner_error_);
4501
_vala_code_node_unref0 (expr);
4502
return NULL;
4503
} else {
4504
_vala_code_node_unref0 (expr);
4505
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4506
g_clear_error (&_inner_error_);
4507
return NULL;
4508
}
4509
}
4510
_tmp73_ = _tmp72_;
4511
_vala_code_node_unref0 (expr);
4512
expr = _tmp73_;
4526
_vala_code_node_unref0 (expr);
4527
expr = _tmp52_;
4513
4528
break;
4514
4529
}
4515
4530
case VALA_TOKEN_TYPE_OP_DEC:
4516
4531
{
4517
ValaExpression* _tmp74_ = NULL;
4518
ValaExpression* _tmp75_;
4519
ValaExpression* _tmp76_;
4520
_tmp74_ = vala_parser_parse_post_decrement_expression (self, &begin, expr, &_inner_error_);
4521
_tmp75_ = _tmp74_;
4532
ValaExpression* _tmp53_ = NULL;
4533
ValaExpression* _tmp54_;
4534
_tmp53_ = vala_parser_parse_post_decrement_expression (self, &begin, expr, &_inner_error_);
4535
_tmp54_ = _tmp53_;
4522
4536
if (_inner_error_ != NULL) {
4523
4537
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4524
4538
g_propagate_error (error, _inner_error_);
4531
4545
return NULL;
4532
4546
}
4533
4547
}
4534
_tmp76_ = _tmp75_;
4535
4548
_vala_code_node_unref0 (expr);
4536
expr = _tmp76_;
4549
expr = _tmp54_;
4537
4550
break;
4538
4551
}
4539
4552
default:
4557
4570
gchar* id;
4558
4571
gboolean qualified;
4559
4572
gboolean _tmp3_ = FALSE;
4560
ValaList* _tmp8_ = NULL;
4573
ValaList* _tmp7_ = NULL;
4561
4574
ValaList* type_arg_list;
4562
ValaSourceReference* _tmp9_ = NULL;
4563
ValaSourceReference* _tmp10_;
4564
ValaMemberAccess* _tmp11_ = NULL;
4565
ValaMemberAccess* _tmp12_;
4575
ValaSourceReference* _tmp8_ = NULL;
4576
ValaSourceReference* _tmp9_;
4577
ValaMemberAccess* _tmp10_ = NULL;
4578
ValaMemberAccess* _tmp11_;
4566
4579
ValaMemberAccess* expr;
4567
4580
GError * _inner_error_ = NULL;
4568
4581
g_return_val_if_fail (self != NULL, NULL);
4569
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
4582
vala_parser_get_location (self, &_tmp0_);
4583
_tmp1_ = _tmp0_;
4570
4584
begin = _tmp1_;
4571
4585
_tmp2_ = vala_parser_parse_identifier (self, &_inner_error_);
4572
4586
id = _tmp2_;
4591
4605
if (_tmp3_) {
4592
4606
gchar* _tmp5_ = NULL;
4593
4607
gchar* _tmp6_;
4594
gchar* _tmp7_;
4595
4608
_tmp5_ = vala_parser_parse_identifier (self, &_inner_error_);
4596
4609
_tmp6_ = _tmp5_;
4597
4610
if (_inner_error_ != NULL) {
4606
4619
return NULL;
4607
4620
}
4608
4621
}
4609
_tmp7_ = _tmp6_;
4610
4622
_g_free0 (id);
4611
id = _tmp7_;
4623
id = _tmp6_;
4612
4624
qualified = TRUE;
4613
4625
}
4614
_tmp8_ = vala_parser_parse_type_argument_list (self, TRUE, &_inner_error_);
4615
type_arg_list = _tmp8_;
4626
_tmp7_ = vala_parser_parse_type_argument_list (self, TRUE, &_inner_error_);
4627
type_arg_list = _tmp7_;
4616
4628
if (_inner_error_ != NULL) {
4617
4629
if (_inner_error_->domain == VALA_PARSE_ERROR) {
4618
4630
g_propagate_error (error, _inner_error_);
4625
4637
return NULL;
4626
4638
}
4627
4639
}
4628
_tmp9_ = vala_parser_get_src (self, &begin);
4629
_tmp10_ = _tmp9_;
4630
_tmp11_ = vala_member_access_new (NULL, id, _tmp10_);
4631
expr = (_tmp12_ = _tmp11_, _vala_source_reference_unref0 (_tmp10_), _tmp12_);
4640
_tmp8_ = vala_parser_get_src (self, &begin);
4641
_tmp9_ = _tmp8_;
4642
_tmp10_ = vala_member_access_new (NULL, id, _tmp9_);
4643
_tmp11_ = _tmp10_;
4644
_vala_source_reference_unref0 (_tmp9_);
4645
expr = _tmp11_;
4632
4646
vala_member_access_set_qualified (expr, qualified);
4633
4647
if (type_arg_list != NULL) {
4634
4648
{
4635
ValaList* _tmp13_;
4649
ValaList* _tmp12_;
4636
4650
ValaList* _type_arg_list;
4637
gint _tmp14_;
4651
gint _tmp13_;
4638
4652
gint _type_arg_size;
4639
4653
gint _type_arg_index;
4640
_tmp13_ = _vala_iterable_ref0 (type_arg_list);
4641
_type_arg_list = _tmp13_;
4642
_tmp14_ = vala_collection_get_size ((ValaCollection*) _type_arg_list);
4643
_type_arg_size = _tmp14_;
4654
_tmp12_ = _vala_iterable_ref0 (type_arg_list);
4655
_type_arg_list = _tmp12_;
4656
_tmp13_ = vala_collection_get_size ((ValaCollection*) _type_arg_list);
4657
_type_arg_size = _tmp13_;
4644
4658
_type_arg_index = -1;
4645
4659
while (TRUE) {
4646
gpointer _tmp15_ = NULL;
4660
gpointer _tmp14_ = NULL;
4647
4661
ValaDataType* type_arg;
4648
4662
_type_arg_index = _type_arg_index + 1;
4649
4663
if (!(_type_arg_index < _type_arg_size)) {
4650
4664
break;
4651
4665
}
4652
_tmp15_ = vala_list_get (_type_arg_list, _type_arg_index);
4653
type_arg = (ValaDataType*) _tmp15_;
4666
_tmp14_ = vala_list_get (_type_arg_list, _type_arg_index);
4667
type_arg = (ValaDataType*) _tmp14_;
4654
4668
vala_member_access_add_type_argument (expr, type_arg);
4655
4669
_vala_code_node_unref0 (type_arg);
4656
4670
}
4676
4690
gpointer _tmp17_ = NULL;
4677
4691
GError * _inner_error_ = NULL;
4678
4692
g_return_val_if_fail (self != NULL, NULL);
4679
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
4693
vala_parser_get_location (self, &_tmp0_);
4694
_tmp1_ = _tmp0_;
4680
4695
begin = _tmp1_;
4681
4696
vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_PARENS, &_inner_error_);
4682
4697
if (_inner_error_ != NULL) {
4751
4766
_tmp10_ = vala_parser_get_src (self, &begin);
4752
4767
_tmp11_ = _tmp10_;
4753
4768
_tmp12_ = vala_tuple_new (_tmp11_);
4754
tuple = (_tmp13_ = _tmp12_, _vala_source_reference_unref0 (_tmp11_), _tmp13_);
4769
_tmp13_ = _tmp12_;
4770
_vala_source_reference_unref0 (_tmp11_);
4771
tuple = _tmp13_;
4755
4772
{
4756
4773
ValaArrayList* _tmp14_;
4757
4774
ValaArrayList* _expr_list;
4799
4816
ValaSourceReference* _tmp8_;
4800
4817
GError * _inner_error_ = NULL;
4801
4818
g_return_val_if_fail (self != NULL, NULL);
4802
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
4819
vala_parser_get_location (self, &_tmp0_);
4820
_tmp1_ = _tmp0_;
4803
4821
begin = _tmp1_;
4804
4822
_tmp2_ = vala_template_new (NULL);
4805
4823
template = _tmp2_;
4966
4984
_tmp2_ = vala_parser_get_src (self, begin);
4967
4985
_tmp3_ = _tmp2_;
4968
4986
_tmp4_ = vala_member_access_new (inner, id, _tmp3_);
4969
expr = (_tmp5_ = _tmp4_, _vala_source_reference_unref0 (_tmp3_), _tmp5_);
4987
_tmp5_ = _tmp4_;
4988
_vala_source_reference_unref0 (_tmp3_);
4989
expr = _tmp5_;
4970
4990
if (type_arg_list != NULL) {
4971
4991
{
4972
4992
ValaList* _tmp6_;
5055
5075
_tmp2_ = vala_parser_get_src (self, begin);
5056
5076
_tmp3_ = _tmp2_;
5057
5077
_tmp4_ = vala_member_access_new_pointer (inner, id, _tmp3_);
5058
expr = (_tmp5_ = _tmp4_, _vala_source_reference_unref0 (_tmp3_), _tmp5_);
5078
_tmp5_ = _tmp4_;
5079
_vala_source_reference_unref0 (_tmp3_);
5080
expr = _tmp5_;
5059
5081
if (type_arg_list != NULL) {
5060
5082
{
5061
5083
ValaList* _tmp6_;
5171
5193
_tmp5_ = vala_parser_get_src (self, begin);
5172
5194
_tmp6_ = _tmp5_;
5173
5195
_tmp7_ = vala_object_creation_expression_new (member, _tmp6_);
5174
expr = (_tmp8_ = _tmp7_, _vala_source_reference_unref0 (_tmp6_), _tmp8_);
5196
_tmp8_ = _tmp7_;
5197
_vala_source_reference_unref0 (_tmp6_);
5198
expr = _tmp8_;
5175
5199
vala_object_creation_expression_set_struct_creation (expr, TRUE);
5176
5200
{
5177
5201
ValaList* _tmp9_;
5237
5261
_tmp15_ = vala_parser_get_src (self, begin);
5238
5262
_tmp16_ = _tmp15_;
5239
5263
_tmp17_ = vala_method_call_new (inner, _tmp16_);
5240
expr = (_tmp18_ = _tmp17_, _vala_source_reference_unref0 (_tmp16_), _tmp18_);
5264
_tmp18_ = _tmp17_;
5265
_vala_source_reference_unref0 (_tmp16_);
5266
expr = _tmp18_;
5241
5267
{
5242
5268
ValaList* _tmp19_;
5243
5269
ValaList* _arg_list;
5318
5344
if (_tmp1_) {
5319
5345
ValaExpression* _tmp4_ = NULL;
5320
5346
ValaExpression* _tmp5_;
5321
ValaExpression* _tmp6_;
5322
5347
_tmp4_ = vala_parser_parse_expression (self, &_inner_error_);
5323
5348
_tmp5_ = _tmp4_;
5324
5349
if (_inner_error_ != NULL) {
5335
5360
return NULL;
5336
5361
}
5337
5362
}
5338
_tmp6_ = _tmp5_;
5339
5363
_vala_code_node_unref0 (stop);
5340
stop = _tmp6_;
5364
stop = _tmp5_;
5341
5365
}
5342
5366
vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_BRACKET, &_inner_error_);
5343
5367
if (_inner_error_ != NULL) {
5355
5379
}
5356
5380
}
5357
5381
if (stop == NULL) {
5358
ValaSourceReference* _tmp7_ = NULL;
5359
ValaSourceReference* _tmp8_;
5360
ValaElementAccess* _tmp9_ = NULL;
5361
ValaElementAccess* _tmp10_;
5382
ValaSourceReference* _tmp6_ = NULL;
5383
ValaSourceReference* _tmp7_;
5384
ValaElementAccess* _tmp8_ = NULL;
5385
ValaElementAccess* _tmp9_;
5362
5386
ValaElementAccess* expr;
5363
_tmp7_ = vala_parser_get_src (self, begin);
5364
_tmp8_ = _tmp7_;
5365
_tmp9_ = vala_element_access_new (inner, _tmp8_);
5366
expr = (_tmp10_ = _tmp9_, _vala_source_reference_unref0 (_tmp8_), _tmp10_);
5387
_tmp6_ = vala_parser_get_src (self, begin);
5388
_tmp7_ = _tmp6_;
5389
_tmp8_ = vala_element_access_new (inner, _tmp7_);
5390
_tmp9_ = _tmp8_;
5391
_vala_source_reference_unref0 (_tmp7_);
5392
expr = _tmp9_;
5367
5393
{
5368
ValaList* _tmp11_;
5394
ValaList* _tmp10_;
5369
5395
ValaList* _index_list;
5370
gint _tmp12_;
5396
gint _tmp11_;
5371
5397
gint _index_size;
5372
5398
gint _index_index;
5373
_tmp11_ = _vala_iterable_ref0 (index_list);
5374
_index_list = _tmp11_;
5375
_tmp12_ = vala_collection_get_size ((ValaCollection*) _index_list);
5376
_index_size = _tmp12_;
5399
_tmp10_ = _vala_iterable_ref0 (index_list);
5400
_index_list = _tmp10_;
5401
_tmp11_ = vala_collection_get_size ((ValaCollection*) _index_list);
5402
_index_size = _tmp11_;
5377
5403
_index_index = -1;
5378
5404
while (TRUE) {
5379
gpointer _tmp13_ = NULL;
5405
gpointer _tmp12_ = NULL;
5380
5406
ValaExpression* index;
5381
5407
_index_index = _index_index + 1;
5382
5408
if (!(_index_index < _index_size)) {
5383
5409
break;
5384
5410
}
5385
_tmp13_ = vala_list_get (_index_list, _index_index);
5386
index = (ValaExpression*) _tmp13_;
5411
_tmp12_ = vala_list_get (_index_list, _index_index);
5412
index = (ValaExpression*) _tmp12_;
5387
5413
vala_element_access_append_index (expr, index);
5388
5414
_vala_code_node_unref0 (index);
5389
5415
}
5394
5420
_vala_iterable_unref0 (index_list);
5395
5421
return result;
5396
5422
} else {
5397
gpointer _tmp14_ = NULL;
5398
ValaExpression* _tmp15_;
5399
ValaSourceReference* _tmp16_ = NULL;
5400
ValaSourceReference* _tmp17_;
5401
ValaSliceExpression* _tmp18_ = NULL;
5402
ValaExpression* _tmp19_;
5403
_tmp14_ = vala_list_get (index_list, 0);
5404
_tmp15_ = (ValaExpression*) _tmp14_;
5405
_tmp16_ = vala_parser_get_src (self, begin);
5406
_tmp17_ = _tmp16_;
5407
_tmp18_ = vala_slice_expression_new (inner, _tmp15_, stop, _tmp17_);
5408
result = (_tmp19_ = (ValaExpression*) _tmp18_, _vala_source_reference_unref0 (_tmp17_), _vala_code_node_unref0 (_tmp15_), _tmp19_);
5423
gpointer _tmp13_ = NULL;
5424
ValaExpression* _tmp14_;
5425
ValaSourceReference* _tmp15_ = NULL;
5426
ValaSourceReference* _tmp16_;
5427
ValaSliceExpression* _tmp17_ = NULL;
5428
ValaExpression* _tmp18_;
5429
_tmp13_ = vala_list_get (index_list, 0);
5430
_tmp14_ = (ValaExpression*) _tmp13_;
5431
_tmp15_ = vala_parser_get_src (self, begin);
5432
_tmp16_ = _tmp15_;
5433
_tmp17_ = vala_slice_expression_new (inner, _tmp14_, stop, _tmp16_);
5434
_tmp18_ = (ValaExpression*) _tmp17_;
5435
_vala_source_reference_unref0 (_tmp16_);
5436
_vala_code_node_unref0 (_tmp14_);
5437
result = _tmp18_;
5409
5438
_vala_code_node_unref0 (stop);
5410
5439
_vala_iterable_unref0 (index_list);
5411
5440
return result;
5473
5502
ValaExpression* _tmp5_;
5474
5503
GError * _inner_error_ = NULL;
5475
5504
g_return_val_if_fail (self != NULL, NULL);
5476
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
5505
vala_parser_get_location (self, &_tmp0_);
5506
_tmp1_ = _tmp0_;
5477
5507
begin = _tmp1_;
5478
5508
vala_parser_expect (self, VALA_TOKEN_TYPE_THIS, &_inner_error_);
5479
5509
if (_inner_error_ != NULL) {
5489
5519
_tmp2_ = vala_parser_get_src (self, &begin);
5490
5520
_tmp3_ = _tmp2_;
5491
5521
_tmp4_ = vala_member_access_new (NULL, "this", _tmp3_);
5492
result = (_tmp5_ = (ValaExpression*) _tmp4_, _vala_source_reference_unref0 (_tmp3_), _tmp5_);
5522
_tmp5_ = (ValaExpression*) _tmp4_;
5523
_vala_source_reference_unref0 (_tmp3_);
5524
result = _tmp5_;
5493
5525
return result;
5494
5526
}
5495
5527
5505
5537
ValaExpression* _tmp5_;
5506
5538
GError * _inner_error_ = NULL;
5507
5539
g_return_val_if_fail (self != NULL, NULL);
5508
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
5540
vala_parser_get_location (self, &_tmp0_);
5541
_tmp1_ = _tmp0_;
5509
5542
begin = _tmp1_;
5510
5543
vala_parser_expect (self, VALA_TOKEN_TYPE_BASE, &_inner_error_);
5511
5544
if (_inner_error_ != NULL) {
5521
5554
_tmp2_ = vala_parser_get_src (self, &begin);
5522
5555
_tmp3_ = _tmp2_;
5523
5556
_tmp4_ = vala_base_access_new (_tmp3_);
5524
result = (_tmp5_ = (ValaExpression*) _tmp4_, _vala_source_reference_unref0 (_tmp3_), _tmp5_);
5557
_tmp5_ = (ValaExpression*) _tmp4_;
5558
_vala_source_reference_unref0 (_tmp3_);
5559
result = _tmp5_;
5525
5560
return result;
5526
5561
}
5527
5562
5549
5584
_tmp0_ = vala_parser_get_src (self, begin);
5550
5585
_tmp1_ = _tmp0_;
5551
5586
_tmp2_ = vala_postfix_expression_new (inner, TRUE, _tmp1_);
5552
result = (_tmp3_ = (ValaExpression*) _tmp2_, _vala_source_reference_unref0 (_tmp1_), _tmp3_);
5587
_tmp3_ = (ValaExpression*) _tmp2_;
5588
_vala_source_reference_unref0 (_tmp1_);
5589
result = _tmp3_;
5553
5590
return result;
5554
5591
}
5555
5592
5577
5614
_tmp0_ = vala_parser_get_src (self, begin);
5578
5615
_tmp1_ = _tmp0_;
5579
5616
_tmp2_ = vala_postfix_expression_new (inner, FALSE, _tmp1_);
5580
result = (_tmp3_ = (ValaExpression*) _tmp2_, _vala_source_reference_unref0 (_tmp1_), _tmp3_);
5617
_tmp3_ = (ValaExpression*) _tmp2_;
5618
_vala_source_reference_unref0 (_tmp1_);
5619
result = _tmp3_;
5581
5620
return result;
5582
5621
}
5583
5622
5592
5631
gboolean _tmp3_;
5593
5632
GError * _inner_error_ = NULL;
5594
5633
g_return_val_if_fail (self != NULL, NULL);
5595
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
5634
vala_parser_get_location (self, &_tmp0_);
5635
_tmp1_ = _tmp0_;
5596
5636
begin = _tmp1_;
5597
5637
vala_parser_expect (self, VALA_TOKEN_TYPE_NEW, &_inner_error_);
5598
5638
if (_inner_error_ != NULL) {
5669
5709
_tmp7_ = vala_parser_get_error (self, "expected ( or [");
5670
5710
_tmp8_ = _tmp7_;
5671
5711
_tmp9_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp8_);
5672
_inner_error_ = (_tmp10_ = _tmp9_, _g_free0 (_tmp8_), _tmp10_);
5712
_tmp10_ = _tmp9_;
5713
_g_free0 (_tmp8_);
5714
_inner_error_ = _tmp10_;
5673
5715
if (_inner_error_->domain == VALA_PARSE_ERROR) {
5674
5716
g_propagate_error (error, _inner_error_);
5675
5717
_vala_code_node_unref0 (member);
5743
5785
_tmp2_ = vala_parser_get_src (self, begin);
5744
5786
_tmp3_ = _tmp2_;
5745
5787
_tmp4_ = vala_object_creation_expression_new (member, _tmp3_);
5746
expr = (_tmp5_ = _tmp4_, _vala_source_reference_unref0 (_tmp3_), _tmp5_);
5788
_tmp5_ = _tmp4_;
5789
_vala_source_reference_unref0 (_tmp3_);
5790
expr = _tmp5_;
5747
5791
{
5748
5792
ValaList* _tmp6_;
5749
5793
ValaList* _arg_list;
5815
5859
_tmp0_ = vala_parser_get_src (self, begin);
5816
5860
_tmp1_ = _tmp0_;
5817
5861
_tmp2_ = vala_object_creation_expression_new (member, _tmp1_);
5818
expr = (_tmp3_ = _tmp2_, _vala_source_reference_unref0 (_tmp1_), _tmp3_);
5862
_tmp3_ = _tmp2_;
5863
_vala_source_reference_unref0 (_tmp1_);
5864
expr = _tmp3_;
5819
5865
vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_BRACE, &_inner_error_);
5820
5866
if (_inner_error_ != NULL) {
5821
5867
if (_inner_error_->domain == VALA_PARSE_ERROR) {
5852
5898
}
5853
5899
}
5854
5900
_tmp4_ = FALSE;
5855
_tmp7_ = (vala_parser_get_location (self, &_tmp6_), _tmp6_);
5901
vala_parser_get_location (self, &_tmp6_);
5902
_tmp7_ = _tmp6_;
5856
5903
member_begin = _tmp7_;
5857
5904
_tmp8_ = vala_parser_parse_identifier (self, &_inner_error_);
5858
5905
id = _tmp8_;
5936
5983
ValaUnresolvedType* _tmp0_ = NULL;
5937
5984
ValaDataType* element_type;
5938
5985
ValaInitializerList* initializer;
5939
gboolean _tmp23_ = FALSE;
5940
ValaProfile _tmp24_;
5941
gint _tmp29_;
5942
ValaSourceReference* _tmp30_ = NULL;
5943
ValaSourceReference* _tmp31_;
5944
ValaArrayCreationExpression* _tmp32_ = NULL;
5945
ValaArrayCreationExpression* _tmp33_;
5986
gboolean _tmp20_ = FALSE;
5987
ValaProfile _tmp21_;
5988
gint _tmp25_;
5989
ValaSourceReference* _tmp26_ = NULL;
5990
ValaSourceReference* _tmp27_;
5991
ValaArrayCreationExpression* _tmp28_ = NULL;
5992
ValaArrayCreationExpression* _tmp29_;
5946
5993
ValaArrayCreationExpression* expr;
5947
5994
GError * _inner_error_ = NULL;
5948
5995
g_return_val_if_fail (self != NULL, NULL);
5956
6003
gboolean _tmp1_;
5957
6004
_tmp1_ = TRUE;
5958
6005
while (TRUE) {
5959
ValaArrayList* _tmp11_ = NULL;
5960
ValaList* _tmp12_;
6006
ValaArrayList* _tmp10_ = NULL;
5961
6007
if (!_tmp1_) {
5962
6008
gboolean _tmp2_;
5963
6009
_tmp2_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OPEN_BRACKET);
5970
6016
gint _tmp7_;
5971
6017
ValaSourceReference* _tmp8_ = NULL;
5972
6018
ValaArrayType* _tmp9_ = NULL;
5973
ValaDataType* _tmp10_;
5974
6019
if (size_specified) {
5975
6020
gchar* _tmp3_ = NULL;
5976
6021
gchar* _tmp4_;
5980
6025
"n");
5981
6026
_tmp4_ = _tmp3_;
5982
6027
_tmp5_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp4_);
5983
_inner_error_ = (_tmp6_ = _tmp5_, _g_free0 (_tmp4_), _tmp6_);
6028
_tmp6_ = _tmp5_;
6029
_g_free0 (_tmp4_);
6030
_inner_error_ = _tmp6_;
5984
6031
if (_inner_error_->domain == VALA_PARSE_ERROR) {
5985
6032
g_propagate_error (error, _inner_error_);
5986
6033
_vala_code_node_unref0 (element_type);
5997
6044
_tmp7_ = vala_collection_get_size ((ValaCollection*) size_specifier_list);
5998
6045
_tmp8_ = vala_code_node_get_source_reference ((ValaCodeNode*) element_type);
5999
6046
_tmp9_ = vala_array_type_new (element_type, _tmp7_, _tmp8_);
6000
_tmp10_ = (ValaDataType*) _tmp9_;
6001
6047
_vala_code_node_unref0 (element_type);
6002
element_type = _tmp10_;
6048
element_type = (ValaDataType*) _tmp9_;
6003
6049
} else {
6004
6050
first = FALSE;
6005
6051
}
6006
_tmp11_ = vala_array_list_new (VALA_TYPE_EXPRESSION, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
6007
_tmp12_ = (ValaList*) _tmp11_;
6052
_tmp10_ = vala_array_list_new (VALA_TYPE_EXPRESSION, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
6008
6053
_vala_iterable_unref0 (size_specifier_list);
6009
size_specifier_list = _tmp12_;
6054
size_specifier_list = (ValaList*) _tmp10_;
6010
6055
{
6011
gboolean _tmp13_;
6012
_tmp13_ = TRUE;
6056
gboolean _tmp11_;
6057
_tmp11_ = TRUE;
6013
6058
while (TRUE) {
6014
6059
ValaExpression* size;
6015
gboolean _tmp17_ = FALSE;
6016
ValaTokenType _tmp18_;
6017
if (!_tmp13_) {
6018
gboolean _tmp14_ = FALSE;
6019
ValaProfile _tmp15_;
6020
_tmp15_ = vala_code_context_get_profile (self->priv->context);
6021
if (_tmp15_ != VALA_PROFILE_DOVA) {
6022
gboolean _tmp16_;
6023
_tmp16_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
6024
_tmp14_ = _tmp16_;
6060
gboolean _tmp15_ = FALSE;
6061
ValaTokenType _tmp16_;
6062
if (!_tmp11_) {
6063
gboolean _tmp12_ = FALSE;
6064
ValaProfile _tmp13_;
6065
_tmp13_ = vala_code_context_get_profile (self->priv->context);
6066
if (_tmp13_ != VALA_PROFILE_DOVA) {
6067
gboolean _tmp14_;
6068
_tmp14_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
6069
_tmp12_ = _tmp14_;
6025
6070
} else {
6026
_tmp14_ = FALSE;
6071
_tmp12_ = FALSE;
6027
6072
}
6028
if (!_tmp14_) {
6073
if (!_tmp12_) {
6029
6074
break;
6030
6075
}
6031
6076
}
6032
_tmp13_ = FALSE;
6077
_tmp11_ = FALSE;
6033
6078
size = NULL;
6034
_tmp18_ = vala_parser_current (self);
6035
if (_tmp18_ != VALA_TOKEN_TYPE_CLOSE_BRACKET) {
6036
ValaTokenType _tmp19_;
6037
_tmp19_ = vala_parser_current (self);
6038
_tmp17_ = _tmp19_ != VALA_TOKEN_TYPE_COMMA;
6079
_tmp16_ = vala_parser_current (self);
6080
if (_tmp16_ != VALA_TOKEN_TYPE_CLOSE_BRACKET) {
6081
ValaTokenType _tmp17_;
6082
_tmp17_ = vala_parser_current (self);
6083
_tmp15_ = _tmp17_ != VALA_TOKEN_TYPE_COMMA;
6039
6084
} else {
6040
_tmp17_ = FALSE;
6085
_tmp15_ = FALSE;
6041
6086
}
6042
if (_tmp17_) {
6043
ValaExpression* _tmp20_ = NULL;
6044
ValaExpression* _tmp21_;
6045
ValaExpression* _tmp22_;
6046
_tmp20_ = vala_parser_parse_expression (self, &_inner_error_);
6047
_tmp21_ = _tmp20_;
6087
if (_tmp15_) {
6088
ValaExpression* _tmp18_ = NULL;
6089
ValaExpression* _tmp19_;
6090
_tmp18_ = vala_parser_parse_expression (self, &_inner_error_);
6091
_tmp19_ = _tmp18_;
6048
6092
if (_inner_error_ != NULL) {
6049
6093
if (_inner_error_->domain == VALA_PARSE_ERROR) {
6050
6094
g_propagate_error (error, _inner_error_);
6061
6105
return NULL;
6062
6106
}
6063
6107
}
6064
_tmp22_ = _tmp21_;
6065
6108
_vala_code_node_unref0 (size);
6066
size = _tmp22_;
6109
size = _tmp19_;
6067
6110
size_specified = TRUE;
6068
6111
}
6069
6112
vala_collection_add ((ValaCollection*) size_specifier_list, size);
6088
6131
}
6089
6132
}
6090
6133
initializer = NULL;
6091
_tmp24_ = vala_code_context_get_profile (self->priv->context);
6092
if (_tmp24_ != VALA_PROFILE_DOVA) {
6093
ValaTokenType _tmp25_;
6094
_tmp25_ = vala_parser_current (self);
6095
_tmp23_ = _tmp25_ == VALA_TOKEN_TYPE_OPEN_BRACE;
6134
_tmp21_ = vala_code_context_get_profile (self->priv->context);
6135
if (_tmp21_ != VALA_PROFILE_DOVA) {
6136
ValaTokenType _tmp22_;
6137
_tmp22_ = vala_parser_current (self);
6138
_tmp20_ = _tmp22_ == VALA_TOKEN_TYPE_OPEN_BRACE;
6096
6139
} else {
6097
_tmp23_ = FALSE;
6140
_tmp20_ = FALSE;
6098
6141
}
6099
if (_tmp23_) {
6100
ValaInitializerList* _tmp26_ = NULL;
6101
ValaInitializerList* _tmp27_;
6102
ValaInitializerList* _tmp28_;
6103
_tmp26_ = vala_parser_parse_initializer (self, &_inner_error_);
6104
_tmp27_ = _tmp26_;
6142
if (_tmp20_) {
6143
ValaInitializerList* _tmp23_ = NULL;
6144
ValaInitializerList* _tmp24_;
6145
_tmp23_ = vala_parser_parse_initializer (self, &_inner_error_);
6146
_tmp24_ = _tmp23_;
6105
6147
if (_inner_error_ != NULL) {
6106
6148
if (_inner_error_->domain == VALA_PARSE_ERROR) {
6107
6149
g_propagate_error (error, _inner_error_);
6118
6160
return NULL;
6119
6161
}
6120
6162
}
6121
_tmp28_ = _tmp27_;
6122
6163
_vala_code_node_unref0 (initializer);
6123
initializer = _tmp28_;
6164
initializer = _tmp24_;
6124
6165
}
6125
_tmp29_ = vala_collection_get_size ((ValaCollection*) size_specifier_list);
6126
_tmp30_ = vala_parser_get_src (self, begin);
6127
_tmp31_ = _tmp30_;
6128
_tmp32_ = vala_array_creation_expression_new (element_type, _tmp29_, initializer, _tmp31_);
6129
expr = (_tmp33_ = _tmp32_, _vala_source_reference_unref0 (_tmp31_), _tmp33_);
6166
_tmp25_ = vala_collection_get_size ((ValaCollection*) size_specifier_list);
6167
_tmp26_ = vala_parser_get_src (self, begin);
6168
_tmp27_ = _tmp26_;
6169
_tmp28_ = vala_array_creation_expression_new (element_type, _tmp25_, initializer, _tmp27_);
6170
_tmp29_ = _tmp28_;
6171
_vala_source_reference_unref0 (_tmp27_);
6172
expr = _tmp29_;
6130
6173
if (size_specified) {
6131
6174
{
6132
ValaList* _tmp34_;
6175
ValaList* _tmp30_;
6133
6176
ValaList* _size_list;
6134
gint _tmp35_;
6177
gint _tmp31_;
6135
6178
gint _size_size;
6136
6179
gint _size_index;
6137
_tmp34_ = _vala_iterable_ref0 (size_specifier_list);
6138
_size_list = _tmp34_;
6139
_tmp35_ = vala_collection_get_size ((ValaCollection*) _size_list);
6140
_size_size = _tmp35_;
6180
_tmp30_ = _vala_iterable_ref0 (size_specifier_list);
6181
_size_list = _tmp30_;
6182
_tmp31_ = vala_collection_get_size ((ValaCollection*) _size_list);
6183
_size_size = _tmp31_;
6141
6184
_size_index = -1;
6142
6185
while (TRUE) {
6143
gpointer _tmp36_ = NULL;
6186
gpointer _tmp32_ = NULL;
6144
6187
ValaExpression* size;
6145
6188
_size_index = _size_index + 1;
6146
6189
if (!(_size_index < _size_size)) {
6147
6190
break;
6148
6191
}
6149
_tmp36_ = vala_list_get (_size_list, _size_index);
6150
size = (ValaExpression*) _tmp36_;
6192
_tmp32_ = vala_list_get (_size_list, _size_index);
6193
size = (ValaExpression*) _tmp32_;
6151
6194
vala_array_creation_expression_append_size (expr, size);
6152
6195
_vala_code_node_unref0 (size);
6153
6196
}
6249
6292
ValaMemberInitializer* _tmp7_;
6250
6293
GError * _inner_error_ = NULL;
6251
6294
g_return_val_if_fail (self != NULL, NULL);
6252
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
6295
vala_parser_get_location (self, &_tmp0_);
6296
_tmp1_ = _tmp0_;
6253
6297
begin = _tmp1_;
6254
6298
_tmp2_ = vala_parser_parse_identifier (self, &_inner_error_);
6255
6299
id = _tmp2_;
6293
6337
_tmp4_ = vala_parser_get_src (self, &begin);
6294
6338
_tmp5_ = _tmp4_;
6295
6339
_tmp6_ = vala_member_initializer_new (id, expr, _tmp5_);
6296
result = (_tmp7_ = _tmp6_, _vala_source_reference_unref0 (_tmp5_), _tmp7_);
6340
_tmp7_ = _tmp6_;
6341
_vala_source_reference_unref0 (_tmp5_);
6342
result = _tmp7_;
6297
6343
_vala_code_node_unref0 (expr);
6298
6344
_g_free0 (id);
6299
6345
return result;
6332
6378
return NULL;
6333
6379
}
6334
6380
}
6335
_tmp2_ = _vala_code_node_ref0 ((_tmp1_ = expr, VALA_IS_METHOD_CALL (_tmp1_) ? ((ValaMethodCall*) _tmp1_) : NULL));
6381
_tmp1_ = expr;
6382
_tmp2_ = _vala_code_node_ref0 (VALA_IS_METHOD_CALL (_tmp1_) ? ((ValaMethodCall*) _tmp1_) : NULL);
6336
6383
call = _tmp2_;
6337
6384
if (call == NULL) {
6338
6385
ValaSourceReference* _tmp3_ = NULL;
6374
6421
ValaExpression* _tmp6_;
6375
6422
GError * _inner_error_ = NULL;
6376
6423
g_return_val_if_fail (self != NULL, NULL);
6377
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
6424
vala_parser_get_location (self, &_tmp0_);
6425
_tmp1_ = _tmp0_;
6378
6426
begin = _tmp1_;
6379
6427
vala_parser_expect (self, VALA_TOKEN_TYPE_SIZEOF, &_inner_error_);
6380
6428
if (_inner_error_ != NULL) {
6426
6474
_tmp3_ = vala_parser_get_src (self, &begin);
6427
6475
_tmp4_ = _tmp3_;
6428
6476
_tmp5_ = vala_sizeof_expression_new (type, _tmp4_);
6429
result = (_tmp6_ = (ValaExpression*) _tmp5_, _vala_source_reference_unref0 (_tmp4_), _tmp6_);
6477
_tmp6_ = (ValaExpression*) _tmp5_;
6478
_vala_source_reference_unref0 (_tmp4_);
6479
result = _tmp6_;
6430
6480
_vala_code_node_unref0 (type);
6431
6481
return result;
6432
6482
}
6445
6495
ValaExpression* _tmp6_;
6446
6496
GError * _inner_error_ = NULL;
6447
6497
g_return_val_if_fail (self != NULL, NULL);
6448
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
6498
vala_parser_get_location (self, &_tmp0_);
6499
_tmp1_ = _tmp0_;
6449
6500
begin = _tmp1_;
6450
6501
vala_parser_expect (self, VALA_TOKEN_TYPE_TYPEOF, &_inner_error_);
6451
6502
if (_inner_error_ != NULL) {
6497
6548
_tmp3_ = vala_parser_get_src (self, &begin);
6498
6549
_tmp4_ = _tmp3_;
6499
6550
_tmp5_ = vala_typeof_expression_new (type, _tmp4_);
6500
result = (_tmp6_ = (ValaExpression*) _tmp5_, _vala_source_reference_unref0 (_tmp4_), _tmp6_);
6551
_tmp6_ = (ValaExpression*) _tmp5_;
6552
_vala_source_reference_unref0 (_tmp4_);
6553
result = _tmp6_;
6501
6554
_vala_code_node_unref0 (type);
6502
6555
return result;
6503
6556
}
6559
6612
ValaExpression* expr;
6560
6613
GError * _inner_error_ = NULL;
6561
6614
g_return_val_if_fail (self != NULL, NULL);
6562
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
6615
vala_parser_get_location (self, &_tmp0_);
6616
_tmp1_ = _tmp0_;
6563
6617
begin = _tmp1_;
6564
6618
_tmp2_ = vala_parser_current (self);
6565
6619
_tmp3_ = vala_parser_get_unary_operator (self, _tmp2_);
6587
6641
_tmp5_ = vala_parser_get_src (self, &begin);
6588
6642
_tmp6_ = _tmp5_;
6589
6643
_tmp7_ = vala_unary_expression_new (operator, op, _tmp6_);
6590
result = (_tmp8_ = (ValaExpression*) _tmp7_, _vala_source_reference_unref0 (_tmp6_), _tmp8_);
6644
_tmp8_ = (ValaExpression*) _tmp7_;
6645
_vala_source_reference_unref0 (_tmp6_);
6646
result = _tmp8_;
6591
6647
_vala_code_node_unref0 (op);
6592
6648
return result;
6593
6649
}
6627
6683
_tmp14_ = vala_parser_get_src (self, &begin);
6628
6684
_tmp15_ = _tmp14_;
6629
6685
_tmp16_ = vala_reference_transfer_expression_new (op, _tmp15_);
6630
result = (_tmp17_ = (ValaExpression*) _tmp16_, _vala_source_reference_unref0 (_tmp15_), _tmp17_);
6686
_tmp17_ = (ValaExpression*) _tmp16_;
6687
_vala_source_reference_unref0 (_tmp15_);
6688
result = _tmp17_;
6631
6689
_vala_code_node_unref0 (op);
6632
6690
return result;
6633
6691
}
6664
6722
_tmp21_ = vala_parser_get_src (self, &begin);
6665
6723
_tmp22_ = _tmp21_;
6666
6724
_tmp23_ = vala_reference_transfer_expression_new (op, _tmp22_);
6667
result = (_tmp24_ = (ValaExpression*) _tmp23_, _vala_source_reference_unref0 (_tmp22_), _tmp24_);
6725
_tmp24_ = (ValaExpression*) _tmp23_;
6726
_vala_source_reference_unref0 (_tmp22_);
6727
result = _tmp24_;
6668
6728
_vala_code_node_unref0 (op);
6669
6729
return result;
6670
6730
}
6739
6799
_tmp29_ = vala_parser_get_src (self, &begin);
6740
6800
_tmp30_ = _tmp29_;
6741
6801
_tmp31_ = vala_cast_expression_new (inner, type, _tmp30_, FALSE);
6742
result = (_tmp32_ = (ValaExpression*) _tmp31_, _vala_source_reference_unref0 (_tmp30_), _tmp32_);
6802
_tmp32_ = (ValaExpression*) _tmp31_;
6803
_vala_source_reference_unref0 (_tmp30_);
6804
result = _tmp32_;
6743
6805
_vala_code_node_unref0 (inner);
6744
6806
_vala_code_node_unref0 (type);
6745
6807
return result;
6780
6842
_tmp35_ = vala_parser_get_src (self, &begin);
6781
6843
_tmp36_ = _tmp35_;
6782
6844
_tmp37_ = vala_cast_expression_new_non_null (inner, _tmp36_);
6783
result = (_tmp38_ = (ValaExpression*) _tmp37_, _vala_source_reference_unref0 (_tmp36_), _tmp38_);
6845
_tmp38_ = (ValaExpression*) _tmp37_;
6846
_vala_source_reference_unref0 (_tmp36_);
6847
result = _tmp38_;
6784
6848
_vala_code_node_unref0 (inner);
6785
6849
return result;
6786
6850
}
6818
6882
_tmp40_ = vala_parser_get_src (self, &begin);
6819
6883
_tmp41_ = _tmp40_;
6820
6884
_tmp42_ = vala_pointer_indirection_new (op, _tmp41_);
6821
result = (_tmp43_ = (ValaExpression*) _tmp42_, _vala_source_reference_unref0 (_tmp41_), _tmp43_);
6885
_tmp43_ = (ValaExpression*) _tmp42_;
6886
_vala_source_reference_unref0 (_tmp41_);
6887
result = _tmp43_;
6822
6888
_vala_code_node_unref0 (op);
6823
6889
return result;
6824
6890
}
6846
6912
_tmp45_ = vala_parser_get_src (self, &begin);
6847
6913
_tmp46_ = _tmp45_;
6848
6914
_tmp47_ = vala_addressof_expression_new (op, _tmp46_);
6849
result = (_tmp48_ = (ValaExpression*) _tmp47_, _vala_source_reference_unref0 (_tmp46_), _tmp48_);
6915
_tmp48_ = (ValaExpression*) _tmp47_;
6916
_vala_source_reference_unref0 (_tmp46_);
6917
result = _tmp48_;
6850
6918
_vala_code_node_unref0 (op);
6851
6919
return result;
6852
6920
}
6950
7018
gboolean found;
6951
7019
GError * _inner_error_ = NULL;
6952
7020
g_return_val_if_fail (self != NULL, NULL);
6953
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
7021
vala_parser_get_location (self, &_tmp0_);
7022
_tmp1_ = _tmp0_;
6954
7023
begin = _tmp1_;
6955
7024
_tmp2_ = vala_parser_parse_unary_expression (self, &_inner_error_);
6956
7025
left = _tmp2_;
6985
7054
ValaSourceReference* _tmp6_ = NULL;
6986
7055
ValaSourceReference* _tmp7_;
6987
7056
ValaBinaryExpression* _tmp8_ = NULL;
6988
ValaExpression* _tmp9_;
6989
7057
vala_parser_next (self);
6990
7058
_tmp5_ = vala_parser_parse_unary_expression (self, &_inner_error_);
6991
7059
right = _tmp5_;
7004
7072
_tmp6_ = vala_parser_get_src (self, &begin);
7005
7073
_tmp7_ = _tmp6_;
7006
7074
_tmp8_ = vala_binary_expression_new (operator, left, right, _tmp7_);
7007
_tmp9_ = (ValaExpression*) _tmp8_;
7008
7075
_vala_code_node_unref0 (left);
7009
left = _tmp9_;
7076
left = (ValaExpression*) _tmp8_;
7010
7077
_vala_source_reference_unref0 (_tmp7_);
7011
7078
_vala_code_node_unref0 (right);
7012
7079
break;
7033
7100
gboolean found;
7034
7101
GError * _inner_error_ = NULL;
7035
7102
g_return_val_if_fail (self != NULL, NULL);
7036
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
7103
vala_parser_get_location (self, &_tmp0_);
7104
_tmp1_ = _tmp0_;
7037
7105
begin = _tmp1_;
7038
7106
_tmp2_ = vala_parser_parse_multiplicative_expression (self, &_inner_error_);
7039
7107
left = _tmp2_;
7067
7135
ValaSourceReference* _tmp6_ = NULL;
7068
7136
ValaSourceReference* _tmp7_;
7069
7137
ValaBinaryExpression* _tmp8_ = NULL;
7070
ValaExpression* _tmp9_;
7071
7138
vala_parser_next (self);
7072
7139
_tmp5_ = vala_parser_parse_multiplicative_expression (self, &_inner_error_);
7073
7140
right = _tmp5_;
7086
7153
_tmp6_ = vala_parser_get_src (self, &begin);
7087
7154
_tmp7_ = _tmp6_;
7088
7155
_tmp8_ = vala_binary_expression_new (operator, left, right, _tmp7_);
7089
_tmp9_ = (ValaExpression*) _tmp8_;
7090
7156
_vala_code_node_unref0 (left);
7091
left = _tmp9_;
7157
left = (ValaExpression*) _tmp8_;
7092
7158
_vala_source_reference_unref0 (_tmp7_);
7093
7159
_vala_code_node_unref0 (right);
7094
7160
break;
7115
7181
gboolean found;
7116
7182
GError * _inner_error_ = NULL;
7117
7183
g_return_val_if_fail (self != NULL, NULL);
7118
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
7184
vala_parser_get_location (self, &_tmp0_);
7185
_tmp1_ = _tmp0_;
7119
7186
begin = _tmp1_;
7120
7187
_tmp2_ = vala_parser_parse_additive_expression (self, &_inner_error_);
7121
7188
left = _tmp2_;
7144
7211
ValaSourceReference* _tmp5_ = NULL;
7145
7212
ValaSourceReference* _tmp6_;
7146
7213
ValaBinaryExpression* _tmp7_ = NULL;
7147
ValaExpression* _tmp8_;
7148
7214
vala_parser_next (self);
7149
7215
_tmp4_ = vala_parser_parse_additive_expression (self, &_inner_error_);
7150
7216
right = _tmp4_;
7163
7229
_tmp5_ = vala_parser_get_src (self, &begin);
7164
7230
_tmp6_ = _tmp5_;
7165
7231
_tmp7_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_SHIFT_LEFT, left, right, _tmp6_);
7166
_tmp8_ = (ValaExpression*) _tmp7_;
7167
7232
_vala_code_node_unref0 (left);
7168
left = _tmp8_;
7233
left = (ValaExpression*) _tmp7_;
7169
7234
_vala_source_reference_unref0 (_tmp6_);
7170
7235
_vala_code_node_unref0 (right);
7171
7236
break;
7173
7238
case VALA_TOKEN_TYPE_OP_GT:
7174
7239
{
7175
7240
gchar* first_gt_pos;
7176
gboolean _tmp9_ = FALSE;
7177
ValaTokenType _tmp10_;
7241
gboolean _tmp8_ = FALSE;
7242
ValaTokenType _tmp9_;
7178
7243
first_gt_pos = self->priv->tokens[self->priv->index].begin.pos;
7179
7244
vala_parser_next (self);
7180
_tmp10_ = vala_parser_current (self);
7181
if (_tmp10_ == VALA_TOKEN_TYPE_OP_GT) {
7182
_tmp9_ = self->priv->tokens[self->priv->index].begin.pos == (first_gt_pos + 1);
7245
_tmp9_ = vala_parser_current (self);
7246
if (_tmp9_ == VALA_TOKEN_TYPE_OP_GT) {
7247
_tmp8_ = self->priv->tokens[self->priv->index].begin.pos == (first_gt_pos + 1);
7183
7248
} else {
7184
_tmp9_ = FALSE;
7249
_tmp8_ = FALSE;
7185
7250
}
7186
if (_tmp9_) {
7187
ValaExpression* _tmp11_ = NULL;
7251
if (_tmp8_) {
7252
ValaExpression* _tmp10_ = NULL;
7188
7253
ValaExpression* right;
7189
ValaSourceReference* _tmp12_ = NULL;
7190
ValaSourceReference* _tmp13_;
7191
ValaBinaryExpression* _tmp14_ = NULL;
7192
ValaExpression* _tmp15_;
7254
ValaSourceReference* _tmp11_ = NULL;
7255
ValaSourceReference* _tmp12_;
7256
ValaBinaryExpression* _tmp13_ = NULL;
7193
7257
vala_parser_next (self);
7194
_tmp11_ = vala_parser_parse_additive_expression (self, &_inner_error_);
7195
right = _tmp11_;
7258
_tmp10_ = vala_parser_parse_additive_expression (self, &_inner_error_);
7259
right = _tmp10_;
7196
7260
if (_inner_error_ != NULL) {
7197
7261
if (_inner_error_->domain == VALA_PARSE_ERROR) {
7198
7262
g_propagate_error (error, _inner_error_);
7205
7269
return NULL;
7206
7270
}
7207
7271
}
7208
_tmp12_ = vala_parser_get_src (self, &begin);
7209
_tmp13_ = _tmp12_;
7210
_tmp14_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_SHIFT_RIGHT, left, right, _tmp13_);
7211
_tmp15_ = (ValaExpression*) _tmp14_;
7272
_tmp11_ = vala_parser_get_src (self, &begin);
7273
_tmp12_ = _tmp11_;
7274
_tmp13_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_SHIFT_RIGHT, left, right, _tmp12_);
7212
7275
_vala_code_node_unref0 (left);
7213
left = _tmp15_;
7214
_vala_source_reference_unref0 (_tmp13_);
7276
left = (ValaExpression*) _tmp13_;
7277
_vala_source_reference_unref0 (_tmp12_);
7215
7278
_vala_code_node_unref0 (right);
7216
7279
} else {
7217
7280
vala_parser_prev (self);
7242
7305
gboolean found;
7243
7306
GError * _inner_error_ = NULL;
7244
7307
g_return_val_if_fail (self != NULL, NULL);
7245
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
7308
vala_parser_get_location (self, &_tmp0_);
7309
_tmp1_ = _tmp0_;
7246
7310
begin = _tmp1_;
7247
7311
_tmp2_ = vala_parser_parse_shift_expression (self, &_inner_error_);
7248
7312
left = _tmp2_;
7278
7342
ValaSourceReference* _tmp6_ = NULL;
7279
7343
ValaSourceReference* _tmp7_;
7280
7344
ValaBinaryExpression* _tmp8_ = NULL;
7281
ValaExpression* _tmp9_;
7282
7345
vala_parser_next (self);
7283
7346
_tmp5_ = vala_parser_parse_shift_expression (self, &_inner_error_);
7284
7347
right = _tmp5_;
7297
7360
_tmp6_ = vala_parser_get_src (self, &begin);
7298
7361
_tmp7_ = _tmp6_;
7299
7362
_tmp8_ = vala_binary_expression_new (operator, left, right, _tmp7_);
7300
_tmp9_ = (ValaExpression*) _tmp8_;
7301
7363
_vala_code_node_unref0 (left);
7302
left = _tmp9_;
7364
left = (ValaExpression*) _tmp8_;
7303
7365
_vala_source_reference_unref0 (_tmp7_);
7304
7366
if (!first) {
7305
ValaBinaryExpression* _tmp10_;
7367
ValaBinaryExpression* _tmp9_;
7306
7368
ValaBinaryExpression* be;
7307
gboolean _tmp11_;
7308
_tmp10_ = _vala_code_node_ref0 (VALA_BINARY_EXPRESSION (left));
7309
be = _tmp10_;
7369
gboolean _tmp10_;
7370
_tmp9_ = _vala_code_node_ref0 (VALA_BINARY_EXPRESSION (left));
7371
be = _tmp9_;
7310
7372
be->chained = TRUE;
7311
_tmp11_ = vala_code_context_get_experimental (self->priv->context);
7312
if (!_tmp11_) {
7313
ValaSourceReference* _tmp12_ = NULL;
7314
_tmp12_ = vala_code_node_get_source_reference ((ValaCodeNode*) left);
7315
vala_report_warning (_tmp12_, "chained relational expressions are experimental");
7373
_tmp10_ = vala_code_context_get_experimental (self->priv->context);
7374
if (!_tmp10_) {
7375
ValaSourceReference* _tmp11_ = NULL;
7376
_tmp11_ = vala_code_node_get_source_reference ((ValaCodeNode*) left);
7377
vala_report_warning (_tmp11_, "chained relational expressions are experimental");
7316
7378
}
7317
7379
_vala_code_node_unref0 (be);
7318
7380
}
7322
7384
}
7323
7385
case VALA_BINARY_OPERATOR_GREATER_THAN:
7324
7386
{
7325
gboolean _tmp13_ = FALSE;
7326
ValaTokenType _tmp14_;
7387
gboolean _tmp12_ = FALSE;
7388
ValaTokenType _tmp13_;
7327
7389
vala_parser_next (self);
7328
_tmp14_ = vala_parser_current (self);
7329
if (_tmp14_ != VALA_TOKEN_TYPE_OP_GT) {
7330
ValaTokenType _tmp15_;
7331
_tmp15_ = vala_parser_current (self);
7332
_tmp13_ = _tmp15_ != VALA_TOKEN_TYPE_OP_GE;
7390
_tmp13_ = vala_parser_current (self);
7391
if (_tmp13_ != VALA_TOKEN_TYPE_OP_GT) {
7392
ValaTokenType _tmp14_;
7393
_tmp14_ = vala_parser_current (self);
7394
_tmp12_ = _tmp14_ != VALA_TOKEN_TYPE_OP_GE;
7333
7395
} else {
7334
_tmp13_ = FALSE;
7396
_tmp12_ = FALSE;
7335
7397
}
7336
if (_tmp13_) {
7337
ValaExpression* _tmp16_ = NULL;
7398
if (_tmp12_) {
7399
ValaExpression* _tmp15_ = NULL;
7338
7400
ValaExpression* right;
7339
ValaSourceReference* _tmp17_ = NULL;
7340
ValaSourceReference* _tmp18_;
7341
ValaBinaryExpression* _tmp19_ = NULL;
7342
ValaExpression* _tmp20_;
7343
_tmp16_ = vala_parser_parse_shift_expression (self, &_inner_error_);
7344
right = _tmp16_;
7401
ValaSourceReference* _tmp16_ = NULL;
7402
ValaSourceReference* _tmp17_;
7403
ValaBinaryExpression* _tmp18_ = NULL;
7404
_tmp15_ = vala_parser_parse_shift_expression (self, &_inner_error_);
7405
right = _tmp15_;
7345
7406
if (_inner_error_ != NULL) {
7346
7407
if (_inner_error_->domain == VALA_PARSE_ERROR) {
7347
7408
g_propagate_error (error, _inner_error_);
7354
7415
return NULL;
7355
7416
}
7356
7417
}
7357
_tmp17_ = vala_parser_get_src (self, &begin);
7358
_tmp18_ = _tmp17_;
7359
_tmp19_ = vala_binary_expression_new (operator, left, right, _tmp18_);
7360
_tmp20_ = (ValaExpression*) _tmp19_;
7418
_tmp16_ = vala_parser_get_src (self, &begin);
7419
_tmp17_ = _tmp16_;
7420
_tmp18_ = vala_binary_expression_new (operator, left, right, _tmp17_);
7361
7421
_vala_code_node_unref0 (left);
7362
left = _tmp20_;
7363
_vala_source_reference_unref0 (_tmp18_);
7422
left = (ValaExpression*) _tmp18_;
7423
_vala_source_reference_unref0 (_tmp17_);
7364
7424
if (!first) {
7365
ValaBinaryExpression* _tmp21_;
7425
ValaBinaryExpression* _tmp19_;
7366
7426
ValaBinaryExpression* be;
7367
gboolean _tmp22_;
7368
_tmp21_ = _vala_code_node_ref0 (VALA_BINARY_EXPRESSION (left));
7369
be = _tmp21_;
7427
gboolean _tmp20_;
7428
_tmp19_ = _vala_code_node_ref0 (VALA_BINARY_EXPRESSION (left));
7429
be = _tmp19_;
7370
7430
be->chained = TRUE;
7371
_tmp22_ = vala_code_context_get_experimental (self->priv->context);
7372
if (!_tmp22_) {
7373
ValaSourceReference* _tmp23_ = NULL;
7374
_tmp23_ = vala_code_node_get_source_reference ((ValaCodeNode*) left);
7375
vala_report_warning (_tmp23_, "chained relational expressions are experimental");
7431
_tmp20_ = vala_code_context_get_experimental (self->priv->context);
7432
if (!_tmp20_) {
7433
ValaSourceReference* _tmp21_ = NULL;
7434
_tmp21_ = vala_code_node_get_source_reference ((ValaCodeNode*) left);
7435
vala_report_warning (_tmp21_, "chained relational expressions are experimental");
7376
7436
}
7377
7437
_vala_code_node_unref0 (be);
7378
7438
}
7386
7446
}
7387
7447
default:
7388
7448
{
7389
ValaTokenType _tmp24_;
7390
_tmp24_ = vala_parser_current (self);
7391
switch (_tmp24_) {
7449
ValaTokenType _tmp22_;
7450
_tmp22_ = vala_parser_current (self);
7451
switch (_tmp22_) {
7392
7452
case VALA_TOKEN_TYPE_IS:
7393
7453
{
7394
ValaDataType* _tmp25_ = NULL;
7454
ValaDataType* _tmp23_ = NULL;
7395
7455
ValaDataType* type;
7396
ValaSourceReference* _tmp26_ = NULL;
7397
ValaSourceReference* _tmp27_;
7398
ValaTypeCheck* _tmp28_ = NULL;
7399
ValaExpression* _tmp29_;
7456
ValaSourceReference* _tmp24_ = NULL;
7457
ValaSourceReference* _tmp25_;
7458
ValaTypeCheck* _tmp26_ = NULL;
7400
7459
vala_parser_next (self);
7401
_tmp25_ = vala_parser_parse_type (self, TRUE, FALSE, &_inner_error_);
7402
type = _tmp25_;
7460
_tmp23_ = vala_parser_parse_type (self, TRUE, FALSE, &_inner_error_);
7461
type = _tmp23_;
7403
7462
if (_inner_error_ != NULL) {
7404
7463
if (_inner_error_->domain == VALA_PARSE_ERROR) {
7405
7464
g_propagate_error (error, _inner_error_);
7412
7471
return NULL;
7413
7472
}
7414
7473
}
7415
_tmp26_ = vala_parser_get_src (self, &begin);
7416
_tmp27_ = _tmp26_;
7417
_tmp28_ = vala_typecheck_new (left, type, _tmp27_);
7418
_tmp29_ = (ValaExpression*) _tmp28_;
7474
_tmp24_ = vala_parser_get_src (self, &begin);
7475
_tmp25_ = _tmp24_;
7476
_tmp26_ = vala_typecheck_new (left, type, _tmp25_);
7419
7477
_vala_code_node_unref0 (left);
7420
left = _tmp29_;
7421
_vala_source_reference_unref0 (_tmp27_);
7478
left = (ValaExpression*) _tmp26_;
7479
_vala_source_reference_unref0 (_tmp25_);
7422
7480
_vala_code_node_unref0 (type);
7423
7481
break;
7424
7482
}
7425
7483
case VALA_TOKEN_TYPE_AS:
7426
7484
{
7427
ValaDataType* _tmp30_ = NULL;
7485
ValaDataType* _tmp27_ = NULL;
7428
7486
ValaDataType* type;
7429
ValaSourceReference* _tmp31_ = NULL;
7430
ValaSourceReference* _tmp32_;
7431
ValaCastExpression* _tmp33_ = NULL;
7432
ValaExpression* _tmp34_;
7487
ValaSourceReference* _tmp28_ = NULL;
7488
ValaSourceReference* _tmp29_;
7489
ValaCastExpression* _tmp30_ = NULL;
7433
7490
vala_parser_next (self);
7434
_tmp30_ = vala_parser_parse_type (self, TRUE, FALSE, &_inner_error_);
7435
type = _tmp30_;
7491
_tmp27_ = vala_parser_parse_type (self, TRUE, FALSE, &_inner_error_);
7492
type = _tmp27_;
7436
7493
if (_inner_error_ != NULL) {
7437
7494
if (_inner_error_->domain == VALA_PARSE_ERROR) {
7438
7495
g_propagate_error (error, _inner_error_);
7445
7502
return NULL;
7446
7503
}
7447
7504
}
7448
_tmp31_ = vala_parser_get_src (self, &begin);
7449
_tmp32_ = _tmp31_;
7450
_tmp33_ = vala_cast_expression_new (left, type, _tmp32_, TRUE);
7451
_tmp34_ = (ValaExpression*) _tmp33_;
7505
_tmp28_ = vala_parser_get_src (self, &begin);
7506
_tmp29_ = _tmp28_;
7507
_tmp30_ = vala_cast_expression_new (left, type, _tmp29_, TRUE);
7452
7508
_vala_code_node_unref0 (left);
7453
left = _tmp34_;
7454
_vala_source_reference_unref0 (_tmp32_);
7509
left = (ValaExpression*) _tmp30_;
7510
_vala_source_reference_unref0 (_tmp29_);
7455
7511
_vala_code_node_unref0 (type);
7456
7512
break;
7457
7513
}
7480
7536
gboolean found;
7481
7537
GError * _inner_error_ = NULL;
7482
7538
g_return_val_if_fail (self != NULL, NULL);
7483
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
7539
vala_parser_get_location (self, &_tmp0_);
7540
_tmp1_ = _tmp0_;
7484
7541
begin = _tmp1_;
7485
7542
_tmp2_ = vala_parser_parse_relational_expression (self, &_inner_error_);
7486
7543
left = _tmp2_;
7514
7571
ValaSourceReference* _tmp6_ = NULL;
7515
7572
ValaSourceReference* _tmp7_;
7516
7573
ValaBinaryExpression* _tmp8_ = NULL;
7517
ValaExpression* _tmp9_;
7518
7574
vala_parser_next (self);
7519
7575
_tmp5_ = vala_parser_parse_relational_expression (self, &_inner_error_);
7520
7576
right = _tmp5_;
7533
7589
_tmp6_ = vala_parser_get_src (self, &begin);
7534
7590
_tmp7_ = _tmp6_;
7535
7591
_tmp8_ = vala_binary_expression_new (operator, left, right, _tmp7_);
7536
_tmp9_ = (ValaExpression*) _tmp8_;
7537
7592
_vala_code_node_unref0 (left);
7538
left = _tmp9_;
7593
left = (ValaExpression*) _tmp8_;
7539
7594
_vala_source_reference_unref0 (_tmp7_);
7540
7595
_vala_code_node_unref0 (right);
7541
7596
break;
7561
7616
ValaExpression* left;
7562
7617
GError * _inner_error_ = NULL;
7563
7618
g_return_val_if_fail (self != NULL, NULL);
7564
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
7619
vala_parser_get_location (self, &_tmp0_);
7620
_tmp1_ = _tmp0_;
7565
7621
begin = _tmp1_;
7566
7622
_tmp2_ = vala_parser_parse_equality_expression (self, &_inner_error_);
7567
7623
left = _tmp2_;
7582
7638
ValaSourceReference* _tmp5_ = NULL;
7583
7639
ValaSourceReference* _tmp6_;
7584
7640
ValaBinaryExpression* _tmp7_ = NULL;
7585
ValaExpression* _tmp8_;
7586
7641
_tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_BITWISE_AND);
7587
7642
if (!_tmp3_) {
7588
7643
break;
7604
7659
_tmp5_ = vala_parser_get_src (self, &begin);
7605
7660
_tmp6_ = _tmp5_;
7606
7661
_tmp7_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_BITWISE_AND, left, right, _tmp6_);
7607
_tmp8_ = (ValaExpression*) _tmp7_;
7608
7662
_vala_code_node_unref0 (left);
7609
left = _tmp8_;
7663
left = (ValaExpression*) _tmp7_;
7610
7664
_vala_source_reference_unref0 (_tmp6_);
7611
7665
_vala_code_node_unref0 (right);
7612
7666
}
7624
7678
ValaExpression* left;
7625
7679
GError * _inner_error_ = NULL;
7626
7680
g_return_val_if_fail (self != NULL, NULL);
7627
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
7681
vala_parser_get_location (self, &_tmp0_);
7682
_tmp1_ = _tmp0_;
7628
7683
begin = _tmp1_;
7629
7684
_tmp2_ = vala_parser_parse_and_expression (self, &_inner_error_);
7630
7685
left = _tmp2_;
7645
7700
ValaSourceReference* _tmp5_ = NULL;
7646
7701
ValaSourceReference* _tmp6_;
7647
7702
ValaBinaryExpression* _tmp7_ = NULL;
7648
ValaExpression* _tmp8_;
7649
7703
_tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_CARRET);
7650
7704
if (!_tmp3_) {
7651
7705
break;
7667
7721
_tmp5_ = vala_parser_get_src (self, &begin);
7668
7722
_tmp6_ = _tmp5_;
7669
7723
_tmp7_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_BITWISE_XOR, left, right, _tmp6_);
7670
_tmp8_ = (ValaExpression*) _tmp7_;
7671
7724
_vala_code_node_unref0 (left);
7672
left = _tmp8_;
7725
left = (ValaExpression*) _tmp7_;
7673
7726
_vala_source_reference_unref0 (_tmp6_);
7674
7727
_vala_code_node_unref0 (right);
7675
7728
}
7687
7740
ValaExpression* left;
7688
7741
GError * _inner_error_ = NULL;
7689
7742
g_return_val_if_fail (self != NULL, NULL);
7690
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
7743
vala_parser_get_location (self, &_tmp0_);
7744
_tmp1_ = _tmp0_;
7691
7745
begin = _tmp1_;
7692
7746
_tmp2_ = vala_parser_parse_exclusive_or_expression (self, &_inner_error_);
7693
7747
left = _tmp2_;
7708
7762
ValaSourceReference* _tmp5_ = NULL;
7709
7763
ValaSourceReference* _tmp6_;
7710
7764
ValaBinaryExpression* _tmp7_ = NULL;
7711
ValaExpression* _tmp8_;
7712
7765
_tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_BITWISE_OR);
7713
7766
if (!_tmp3_) {
7714
7767
break;
7730
7783
_tmp5_ = vala_parser_get_src (self, &begin);
7731
7784
_tmp6_ = _tmp5_;
7732
7785
_tmp7_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_BITWISE_OR, left, right, _tmp6_);
7733
_tmp8_ = (ValaExpression*) _tmp7_;
7734
7786
_vala_code_node_unref0 (left);
7735
left = _tmp8_;
7787
left = (ValaExpression*) _tmp7_;
7736
7788
_vala_source_reference_unref0 (_tmp6_);
7737
7789
_vala_code_node_unref0 (right);
7738
7790
}
7750
7802
ValaExpression* left;
7751
7803
GError * _inner_error_ = NULL;
7752
7804
g_return_val_if_fail (self != NULL, NULL);
7753
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
7805
vala_parser_get_location (self, &_tmp0_);
7806
_tmp1_ = _tmp0_;
7754
7807
begin = _tmp1_;
7755
7808
_tmp2_ = vala_parser_parse_inclusive_or_expression (self, &_inner_error_);
7756
7809
left = _tmp2_;
7771
7824
ValaSourceReference* _tmp5_ = NULL;
7772
7825
ValaSourceReference* _tmp6_;
7773
7826
ValaBinaryExpression* _tmp7_ = NULL;
7774
ValaExpression* _tmp8_;
7775
7827
_tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_IN);
7776
7828
if (!_tmp3_) {
7777
7829
break;
7793
7845
_tmp5_ = vala_parser_get_src (self, &begin);
7794
7846
_tmp6_ = _tmp5_;
7795
7847
_tmp7_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_IN, left, right, _tmp6_);
7796
_tmp8_ = (ValaExpression*) _tmp7_;
7797
7848
_vala_code_node_unref0 (left);
7798
left = _tmp8_;
7849
left = (ValaExpression*) _tmp7_;
7799
7850
_vala_source_reference_unref0 (_tmp6_);
7800
7851
_vala_code_node_unref0 (right);
7801
7852
}
7813
7864
ValaExpression* left;
7814
7865
GError * _inner_error_ = NULL;
7815
7866
g_return_val_if_fail (self != NULL, NULL);
7816
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
7867
vala_parser_get_location (self, &_tmp0_);
7868
_tmp1_ = _tmp0_;
7817
7869
begin = _tmp1_;
7818
7870
_tmp2_ = vala_parser_parse_in_expression (self, &_inner_error_);
7819
7871
left = _tmp2_;
7834
7886
ValaSourceReference* _tmp5_ = NULL;
7835
7887
ValaSourceReference* _tmp6_;
7836
7888
ValaBinaryExpression* _tmp7_ = NULL;
7837
ValaExpression* _tmp8_;
7838
7889
_tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OP_AND);
7839
7890
if (!_tmp3_) {
7840
7891
break;
7856
7907
_tmp5_ = vala_parser_get_src (self, &begin);
7857
7908
_tmp6_ = _tmp5_;
7858
7909
_tmp7_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_AND, left, right, _tmp6_);
7859
_tmp8_ = (ValaExpression*) _tmp7_;
7860
7910
_vala_code_node_unref0 (left);
7861
left = _tmp8_;
7911
left = (ValaExpression*) _tmp7_;
7862
7912
_vala_source_reference_unref0 (_tmp6_);
7863
7913
_vala_code_node_unref0 (right);
7864
7914
}
7876
7926
ValaExpression* left;
7877
7927
GError * _inner_error_ = NULL;
7878
7928
g_return_val_if_fail (self != NULL, NULL);
7879
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
7929
vala_parser_get_location (self, &_tmp0_);
7930
_tmp1_ = _tmp0_;
7880
7931
begin = _tmp1_;
7881
7932
_tmp2_ = vala_parser_parse_conditional_and_expression (self, &_inner_error_);
7882
7933
left = _tmp2_;
7897
7948
ValaSourceReference* _tmp5_ = NULL;
7898
7949
ValaSourceReference* _tmp6_;
7899
7950
ValaBinaryExpression* _tmp7_ = NULL;
7900
ValaExpression* _tmp8_;
7901
7951
_tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OP_OR);
7902
7952
if (!_tmp3_) {
7903
7953
break;
7919
7969
_tmp5_ = vala_parser_get_src (self, &begin);
7920
7970
_tmp6_ = _tmp5_;
7921
7971
_tmp7_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_OR, left, right, _tmp6_);
7922
_tmp8_ = (ValaExpression*) _tmp7_;
7923
7972
_vala_code_node_unref0 (left);
7924
left = _tmp8_;
7973
left = (ValaExpression*) _tmp7_;
7925
7974
_vala_source_reference_unref0 (_tmp6_);
7926
7975
_vala_code_node_unref0 (right);
7927
7976
}
7940
7989
gboolean _tmp3_;
7941
7990
GError * _inner_error_ = NULL;
7942
7991
g_return_val_if_fail (self != NULL, NULL);
7943
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
7992
vala_parser_get_location (self, &_tmp0_);
7993
_tmp1_ = _tmp0_;
7944
7994
begin = _tmp1_;
7945
7995
_tmp2_ = vala_parser_parse_conditional_or_expression (self, &_inner_error_);
7946
7996
left = _tmp2_;
7979
8029
_tmp5_ = vala_parser_get_src (self, &begin);
7980
8030
_tmp6_ = _tmp5_;
7981
8031
_tmp7_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_COALESCE, left, right, _tmp6_);
7982
result = (_tmp8_ = (ValaExpression*) _tmp7_, _vala_source_reference_unref0 (_tmp6_), _tmp8_);
8032
_tmp8_ = (ValaExpression*) _tmp7_;
8033
_vala_source_reference_unref0 (_tmp6_);
8034
result = _tmp8_;
7983
8035
_vala_code_node_unref0 (right);
7984
8036
_vala_code_node_unref0 (left);
7985
8037
return result;
8001
8053
gboolean _tmp3_;
8002
8054
GError * _inner_error_ = NULL;
8003
8055
g_return_val_if_fail (self != NULL, NULL);
8004
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
8056
vala_parser_get_location (self, &_tmp0_);
8057
_tmp1_ = _tmp0_;
8005
8058
begin = _tmp1_;
8006
8059
_tmp2_ = vala_parser_parse_coalescing_expression (self, &_inner_error_);
8007
8060
condition = _tmp2_;
8073
8126
_tmp6_ = vala_parser_get_src (self, &begin);
8074
8127
_tmp7_ = _tmp6_;
8075
8128
_tmp8_ = vala_conditional_expression_new (condition, true_expr, false_expr, _tmp7_);
8076
result = (_tmp9_ = (ValaExpression*) _tmp8_, _vala_source_reference_unref0 (_tmp7_), _tmp9_);
8129
_tmp9_ = (ValaExpression*) _tmp8_;
8130
_vala_source_reference_unref0 (_tmp7_);
8131
result = _tmp9_;
8077
8132
_vala_code_node_unref0 (false_expr);
8078
8133
_vala_code_node_unref0 (true_expr);
8079
8134
_vala_code_node_unref0 (condition);
8098
8153
ValaTokenType _tmp13_;
8099
8154
GError * _inner_error_ = NULL;
8100
8155
g_return_val_if_fail (self != NULL, NULL);
8101
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
8156
vala_parser_get_location (self, &_tmp0_);
8157
_tmp1_ = _tmp0_;
8102
8158
begin = _tmp1_;
8103
8159
_tmp2_ = vala_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, g_direct_equal);
8104
8160
params = (ValaList*) _tmp2_;
8197
8253
ValaSourceReference* _tmp15_ = NULL;
8198
8254
ValaSourceReference* _tmp16_;
8199
8255
ValaLambdaExpression* _tmp17_ = NULL;
8200
ValaLambdaExpression* _tmp18_;
8201
8256
_tmp14_ = vala_parser_parse_block (self, &_inner_error_);
8202
8257
block = _tmp14_;
8203
8258
if (_inner_error_ != NULL) {
8217
8272
_tmp15_ = vala_parser_get_src (self, &begin);
8218
8273
_tmp16_ = _tmp15_;
8219
8274
_tmp17_ = vala_lambda_expression_new_with_statement_body (block, _tmp16_);
8220
_tmp18_ = _tmp17_;
8221
8275
_vala_code_node_unref0 (lambda);
8222
lambda = _tmp18_;
8276
lambda = _tmp17_;
8223
8277
_vala_source_reference_unref0 (_tmp16_);
8224
8278
_vala_code_node_unref0 (block);
8225
8279
} else {
8226
ValaExpression* _tmp19_ = NULL;
8280
ValaExpression* _tmp18_ = NULL;
8227
8281
ValaExpression* expr;
8228
ValaSourceReference* _tmp20_ = NULL;
8229
ValaSourceReference* _tmp21_;
8230
ValaLambdaExpression* _tmp22_ = NULL;
8231
ValaLambdaExpression* _tmp23_;
8232
_tmp19_ = vala_parser_parse_expression (self, &_inner_error_);
8233
expr = _tmp19_;
8282
ValaSourceReference* _tmp19_ = NULL;
8283
ValaSourceReference* _tmp20_;
8284
ValaLambdaExpression* _tmp21_ = NULL;
8285
_tmp18_ = vala_parser_parse_expression (self, &_inner_error_);
8286
expr = _tmp18_;
8234
8287
if (_inner_error_ != NULL) {
8235
8288
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8236
8289
g_propagate_error (error, _inner_error_);
8245
8298
return NULL;
8246
8299
}
8247
8300
}
8248
_tmp20_ = vala_parser_get_src (self, &begin);
8249
_tmp21_ = _tmp20_;
8250
_tmp22_ = vala_lambda_expression_new (expr, _tmp21_);
8251
_tmp23_ = _tmp22_;
8301
_tmp19_ = vala_parser_get_src (self, &begin);
8302
_tmp20_ = _tmp19_;
8303
_tmp21_ = vala_lambda_expression_new (expr, _tmp20_);
8252
8304
_vala_code_node_unref0 (lambda);
8253
lambda = _tmp23_;
8254
_vala_source_reference_unref0 (_tmp21_);
8305
lambda = _tmp21_;
8306
_vala_source_reference_unref0 (_tmp20_);
8255
8307
_vala_code_node_unref0 (expr);
8256
8308
}
8257
8309
{
8258
ValaList* _tmp24_;
8310
ValaList* _tmp22_;
8259
8311
ValaList* _param_list;
8260
gint _tmp25_;
8312
gint _tmp23_;
8261
8313
gint _param_size;
8262
8314
gint _param_index;
8263
_tmp24_ = _vala_iterable_ref0 (params);
8264
_param_list = _tmp24_;
8265
_tmp25_ = vala_collection_get_size ((ValaCollection*) _param_list);
8266
_param_size = _tmp25_;
8315
_tmp22_ = _vala_iterable_ref0 (params);
8316
_param_list = _tmp22_;
8317
_tmp23_ = vala_collection_get_size ((ValaCollection*) _param_list);
8318
_param_size = _tmp23_;
8267
8319
_param_index = -1;
8268
8320
while (TRUE) {
8269
gpointer _tmp26_ = NULL;
8321
gpointer _tmp24_ = NULL;
8270
8322
gchar* param;
8271
8323
_param_index = _param_index + 1;
8272
8324
if (!(_param_index < _param_size)) {
8273
8325
break;
8274
8326
}
8275
_tmp26_ = vala_list_get (_param_list, _param_index);
8276
param = (gchar*) _tmp26_;
8327
_tmp24_ = vala_list_get (_param_list, _param_index);
8328
param = (gchar*) _tmp24_;
8277
8329
vala_lambda_expression_add_parameter (lambda, param);
8278
8330
_g_free0 (param);
8279
8331
}
8358
8410
ValaTokenType _tmp3_;
8359
8411
GError * _inner_error_ = NULL;
8360
8412
g_return_val_if_fail (self != NULL, NULL);
8361
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
8413
vala_parser_get_location (self, &_tmp0_);
8414
_tmp1_ = _tmp0_;
8362
8415
begin = _tmp1_;
8363
8416
_tmp2_ = vala_parser_parse_conditional_expression (self, &_inner_error_);
8364
8417
expr = _tmp2_;
8408
8461
ValaSourceReference* _tmp8_ = NULL;
8409
8462
ValaSourceReference* _tmp9_;
8410
8463
ValaAssignment* _tmp10_ = NULL;
8411
ValaExpression* _tmp11_;
8412
8464
vala_parser_next (self);
8413
8465
_tmp7_ = vala_parser_parse_expression (self, &_inner_error_);
8414
8466
rhs = _tmp7_;
8427
8479
_tmp8_ = vala_parser_get_src (self, &begin);
8428
8480
_tmp9_ = _tmp8_;
8429
8481
_tmp10_ = vala_assignment_new (expr, rhs, operator, _tmp9_);
8430
_tmp11_ = (ValaExpression*) _tmp10_;
8431
8482
_vala_code_node_unref0 (expr);
8432
expr = _tmp11_;
8483
expr = (ValaExpression*) _tmp10_;
8433
8484
_vala_source_reference_unref0 (_tmp9_);
8434
8485
_vala_code_node_unref0 (rhs);
8435
8486
} else {
8436
ValaTokenType _tmp12_;
8437
_tmp12_ = vala_parser_current (self);
8438
if (_tmp12_ == VALA_TOKEN_TYPE_OP_GT) {
8487
ValaTokenType _tmp11_;
8488
_tmp11_ = vala_parser_current (self);
8489
if (_tmp11_ == VALA_TOKEN_TYPE_OP_GT) {
8439
8490
gchar* first_gt_pos;
8440
gboolean _tmp13_ = FALSE;
8441
ValaTokenType _tmp14_;
8491
gboolean _tmp12_ = FALSE;
8492
ValaTokenType _tmp13_;
8442
8493
first_gt_pos = self->priv->tokens[self->priv->index].begin.pos;
8443
8494
vala_parser_next (self);
8444
_tmp14_ = vala_parser_current (self);
8445
if (_tmp14_ == VALA_TOKEN_TYPE_OP_GE) {
8446
_tmp13_ = self->priv->tokens[self->priv->index].begin.pos == (first_gt_pos + 1);
8495
_tmp13_ = vala_parser_current (self);
8496
if (_tmp13_ == VALA_TOKEN_TYPE_OP_GE) {
8497
_tmp12_ = self->priv->tokens[self->priv->index].begin.pos == (first_gt_pos + 1);
8447
8498
} else {
8448
_tmp13_ = FALSE;
8499
_tmp12_ = FALSE;
8449
8500
}
8450
if (_tmp13_) {
8451
ValaExpression* _tmp15_ = NULL;
8501
if (_tmp12_) {
8502
ValaExpression* _tmp14_ = NULL;
8452
8503
ValaExpression* rhs;
8453
ValaSourceReference* _tmp16_ = NULL;
8454
ValaSourceReference* _tmp17_;
8455
ValaAssignment* _tmp18_ = NULL;
8456
ValaExpression* _tmp19_;
8504
ValaSourceReference* _tmp15_ = NULL;
8505
ValaSourceReference* _tmp16_;
8506
ValaAssignment* _tmp17_ = NULL;
8457
8507
vala_parser_next (self);
8458
_tmp15_ = vala_parser_parse_expression (self, &_inner_error_);
8459
rhs = _tmp15_;
8508
_tmp14_ = vala_parser_parse_expression (self, &_inner_error_);
8509
rhs = _tmp14_;
8460
8510
if (_inner_error_ != NULL) {
8461
8511
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8462
8512
g_propagate_error (error, _inner_error_);
8469
8519
return NULL;
8470
8520
}
8471
8521
}
8472
_tmp16_ = vala_parser_get_src (self, &begin);
8473
_tmp17_ = _tmp16_;
8474
_tmp18_ = vala_assignment_new (expr, rhs, VALA_ASSIGNMENT_OPERATOR_SHIFT_RIGHT, _tmp17_);
8475
_tmp19_ = (ValaExpression*) _tmp18_;
8522
_tmp15_ = vala_parser_get_src (self, &begin);
8523
_tmp16_ = _tmp15_;
8524
_tmp17_ = vala_assignment_new (expr, rhs, VALA_ASSIGNMENT_OPERATOR_SHIFT_RIGHT, _tmp16_);
8476
8525
_vala_code_node_unref0 (expr);
8477
expr = _tmp19_;
8478
_vala_source_reference_unref0 (_tmp17_);
8526
expr = (ValaExpression*) _tmp17_;
8527
_vala_source_reference_unref0 (_tmp16_);
8479
8528
_vala_code_node_unref0 (rhs);
8480
8529
} else {
8481
8530
vala_parser_prev (self);
8503
8552
ValaStatement* stmt;
8504
8553
gboolean is_decl;
8505
8554
ValaComment* _tmp7_ = NULL;
8506
ValaComment* _tmp8_;
8507
ValaTokenType _tmp9_;
8555
ValaTokenType _tmp8_;
8508
8556
_tmp3_ = vala_parser_current (self);
8509
8557
if (_tmp3_ != VALA_TOKEN_TYPE_CLOSE_BRACE) {
8510
8558
ValaTokenType _tmp4_;
8533
8581
stmt = NULL;
8534
8582
is_decl = FALSE;
8535
8583
_tmp7_ = vala_scanner_pop_comment (self->priv->scanner);
8536
_tmp8_ = _tmp7_;
8537
8584
_vala_comment_unref0 (self->priv->comment);
8538
self->priv->comment = _tmp8_;
8539
_tmp9_ = vala_parser_current (self);
8540
switch (_tmp9_) {
8585
self->priv->comment = _tmp7_;
8586
_tmp8_ = vala_parser_current (self);
8587
switch (_tmp8_) {
8541
8588
case VALA_TOKEN_TYPE_OPEN_BRACE:
8542
8589
{
8543
ValaBlock* _tmp10_ = NULL;
8544
ValaBlock* _tmp11_;
8590
ValaBlock* _tmp9_ = NULL;
8591
ValaBlock* _tmp10_;
8592
_tmp9_ = vala_parser_parse_block (self, &_inner_error_);
8593
_tmp10_ = _tmp9_;
8594
if (_inner_error_ != NULL) {
8595
_vala_code_node_unref0 (stmt);
8596
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8597
goto __catch10_vala_parse_error;
8598
}
8599
_vala_code_node_unref0 (stmt);
8600
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
8601
g_clear_error (&_inner_error_);
8602
return;
8603
}
8604
_vala_code_node_unref0 (stmt);
8605
stmt = (ValaStatement*) _tmp10_;
8606
break;
8607
}
8608
case VALA_TOKEN_TYPE_SEMICOLON:
8609
{
8610
ValaStatement* _tmp11_ = NULL;
8545
8611
ValaStatement* _tmp12_;
8546
_tmp10_ = vala_parser_parse_block (self, &_inner_error_);
8547
_tmp11_ = _tmp10_;
8612
_tmp11_ = vala_parser_parse_empty_statement (self, &_inner_error_);
8613
_tmp12_ = _tmp11_;
8548
8614
if (_inner_error_ != NULL) {
8549
8615
_vala_code_node_unref0 (stmt);
8550
8616
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8555
8621
g_clear_error (&_inner_error_);
8556
8622
return;
8557
8623
}
8558
_tmp12_ = (ValaStatement*) _tmp11_;
8559
8624
_vala_code_node_unref0 (stmt);
8560
8625
stmt = _tmp12_;
8561
8626
break;
8562
8627
}
8563
case VALA_TOKEN_TYPE_SEMICOLON:
8628
case VALA_TOKEN_TYPE_IF:
8564
8629
{
8565
8630
ValaStatement* _tmp13_ = NULL;
8566
8631
ValaStatement* _tmp14_;
8567
ValaStatement* _tmp15_;
8568
_tmp13_ = vala_parser_parse_empty_statement (self, &_inner_error_);
8632
_tmp13_ = vala_parser_parse_if_statement (self, &_inner_error_);
8569
8633
_tmp14_ = _tmp13_;
8570
8634
if (_inner_error_ != NULL) {
8571
8635
_vala_code_node_unref0 (stmt);
8577
8641
g_clear_error (&_inner_error_);
8578
8642
return;
8579
8643
}
8580
_tmp15_ = _tmp14_;
8581
_vala_code_node_unref0 (stmt);
8582
stmt = _tmp15_;
8583
break;
8584
}
8585
case VALA_TOKEN_TYPE_IF:
8586
{
8587
ValaStatement* _tmp16_ = NULL;
8588
ValaStatement* _tmp17_;
8644
_vala_code_node_unref0 (stmt);
8645
stmt = _tmp14_;
8646
break;
8647
}
8648
case VALA_TOKEN_TYPE_SWITCH:
8649
{
8650
ValaStatement* _tmp15_ = NULL;
8651
ValaStatement* _tmp16_;
8652
_tmp15_ = vala_parser_parse_switch_statement (self, &_inner_error_);
8653
_tmp16_ = _tmp15_;
8654
if (_inner_error_ != NULL) {
8655
_vala_code_node_unref0 (stmt);
8656
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8657
goto __catch10_vala_parse_error;
8658
}
8659
_vala_code_node_unref0 (stmt);
8660
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
8661
g_clear_error (&_inner_error_);
8662
return;
8663
}
8664
_vala_code_node_unref0 (stmt);
8665
stmt = _tmp16_;
8666
break;
8667
}
8668
case VALA_TOKEN_TYPE_WHILE:
8669
{
8670
ValaStatement* _tmp17_ = NULL;
8589
8671
ValaStatement* _tmp18_;
8590
_tmp16_ = vala_parser_parse_if_statement (self, &_inner_error_);
8591
_tmp17_ = _tmp16_;
8672
_tmp17_ = vala_parser_parse_while_statement (self, &_inner_error_);
8673
_tmp18_ = _tmp17_;
8592
8674
if (_inner_error_ != NULL) {
8593
8675
_vala_code_node_unref0 (stmt);
8594
8676
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8599
8681
g_clear_error (&_inner_error_);
8600
8682
return;
8601
8683
}
8602
_tmp18_ = _tmp17_;
8603
8684
_vala_code_node_unref0 (stmt);
8604
8685
stmt = _tmp18_;
8605
8686
break;
8606
8687
}
8607
case VALA_TOKEN_TYPE_SWITCH:
8688
case VALA_TOKEN_TYPE_DO:
8608
8689
{
8609
8690
ValaStatement* _tmp19_ = NULL;
8610
8691
ValaStatement* _tmp20_;
8611
ValaStatement* _tmp21_;
8612
_tmp19_ = vala_parser_parse_switch_statement (self, &_inner_error_);
8692
_tmp19_ = vala_parser_parse_do_statement (self, &_inner_error_);
8613
8693
_tmp20_ = _tmp19_;
8614
8694
if (_inner_error_ != NULL) {
8615
8695
_vala_code_node_unref0 (stmt);
8621
8701
g_clear_error (&_inner_error_);
8622
8702
return;
8623
8703
}
8624
_tmp21_ = _tmp20_;
8625
_vala_code_node_unref0 (stmt);
8626
stmt = _tmp21_;
8627
break;
8628
}
8629
case VALA_TOKEN_TYPE_WHILE:
8630
{
8631
ValaStatement* _tmp22_ = NULL;
8632
ValaStatement* _tmp23_;
8704
_vala_code_node_unref0 (stmt);
8705
stmt = _tmp20_;
8706
break;
8707
}
8708
case VALA_TOKEN_TYPE_FOR:
8709
{
8710
ValaStatement* _tmp21_ = NULL;
8711
ValaStatement* _tmp22_;
8712
_tmp21_ = vala_parser_parse_for_statement (self, &_inner_error_);
8713
_tmp22_ = _tmp21_;
8714
if (_inner_error_ != NULL) {
8715
_vala_code_node_unref0 (stmt);
8716
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8717
goto __catch10_vala_parse_error;
8718
}
8719
_vala_code_node_unref0 (stmt);
8720
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
8721
g_clear_error (&_inner_error_);
8722
return;
8723
}
8724
_vala_code_node_unref0 (stmt);
8725
stmt = _tmp22_;
8726
break;
8727
}
8728
case VALA_TOKEN_TYPE_FOREACH:
8729
{
8730
ValaStatement* _tmp23_ = NULL;
8633
8731
ValaStatement* _tmp24_;
8634
_tmp22_ = vala_parser_parse_while_statement (self, &_inner_error_);
8635
_tmp23_ = _tmp22_;
8732
_tmp23_ = vala_parser_parse_foreach_statement (self, &_inner_error_);
8733
_tmp24_ = _tmp23_;
8636
8734
if (_inner_error_ != NULL) {
8637
8735
_vala_code_node_unref0 (stmt);
8638
8736
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8643
8741
g_clear_error (&_inner_error_);
8644
8742
return;
8645
8743
}
8646
_tmp24_ = _tmp23_;
8647
8744
_vala_code_node_unref0 (stmt);
8648
8745
stmt = _tmp24_;
8649
8746
break;
8650
8747
}
8651
case VALA_TOKEN_TYPE_DO:
8748
case VALA_TOKEN_TYPE_BREAK:
8652
8749
{
8653
8750
ValaStatement* _tmp25_ = NULL;
8654
8751
ValaStatement* _tmp26_;
8655
ValaStatement* _tmp27_;
8656
_tmp25_ = vala_parser_parse_do_statement (self, &_inner_error_);
8752
_tmp25_ = vala_parser_parse_break_statement (self, &_inner_error_);
8657
8753
_tmp26_ = _tmp25_;
8658
8754
if (_inner_error_ != NULL) {
8659
8755
_vala_code_node_unref0 (stmt);
8665
8761
g_clear_error (&_inner_error_);
8666
8762
return;
8667
8763
}
8668
_tmp27_ = _tmp26_;
8669
_vala_code_node_unref0 (stmt);
8670
stmt = _tmp27_;
8671
break;
8672
}
8673
case VALA_TOKEN_TYPE_FOR:
8674
{
8675
ValaStatement* _tmp28_ = NULL;
8676
ValaStatement* _tmp29_;
8764
_vala_code_node_unref0 (stmt);
8765
stmt = _tmp26_;
8766
break;
8767
}
8768
case VALA_TOKEN_TYPE_CONTINUE:
8769
{
8770
ValaStatement* _tmp27_ = NULL;
8771
ValaStatement* _tmp28_;
8772
_tmp27_ = vala_parser_parse_continue_statement (self, &_inner_error_);
8773
_tmp28_ = _tmp27_;
8774
if (_inner_error_ != NULL) {
8775
_vala_code_node_unref0 (stmt);
8776
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8777
goto __catch10_vala_parse_error;
8778
}
8779
_vala_code_node_unref0 (stmt);
8780
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
8781
g_clear_error (&_inner_error_);
8782
return;
8783
}
8784
_vala_code_node_unref0 (stmt);
8785
stmt = _tmp28_;
8786
break;
8787
}
8788
case VALA_TOKEN_TYPE_RETURN:
8789
{
8790
ValaStatement* _tmp29_ = NULL;
8677
8791
ValaStatement* _tmp30_;
8678
_tmp28_ = vala_parser_parse_for_statement (self, &_inner_error_);
8679
_tmp29_ = _tmp28_;
8680
if (_inner_error_ != NULL) {
8681
_vala_code_node_unref0 (stmt);
8682
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8683
goto __catch10_vala_parse_error;
8684
}
8685
_vala_code_node_unref0 (stmt);
8686
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
8687
g_clear_error (&_inner_error_);
8688
return;
8689
}
8792
_tmp29_ = vala_parser_parse_return_statement (self, &_inner_error_);
8690
8793
_tmp30_ = _tmp29_;
8794
if (_inner_error_ != NULL) {
8795
_vala_code_node_unref0 (stmt);
8796
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8797
goto __catch10_vala_parse_error;
8798
}
8799
_vala_code_node_unref0 (stmt);
8800
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
8801
g_clear_error (&_inner_error_);
8802
return;
8803
}
8691
8804
_vala_code_node_unref0 (stmt);
8692
8805
stmt = _tmp30_;
8693
8806
break;
8694
8807
}
8695
case VALA_TOKEN_TYPE_FOREACH:
8808
case VALA_TOKEN_TYPE_YIELD:
8696
8809
{
8697
8810
ValaStatement* _tmp31_ = NULL;
8698
8811
ValaStatement* _tmp32_;
8699
ValaStatement* _tmp33_;
8700
_tmp31_ = vala_parser_parse_foreach_statement (self, &_inner_error_);
8812
_tmp31_ = vala_parser_parse_yield_statement (self, &_inner_error_);
8701
8813
_tmp32_ = _tmp31_;
8702
8814
if (_inner_error_ != NULL) {
8703
8815
_vala_code_node_unref0 (stmt);
8709
8821
g_clear_error (&_inner_error_);
8710
8822
return;
8711
8823
}
8712
_tmp33_ = _tmp32_;
8713
_vala_code_node_unref0 (stmt);
8714
stmt = _tmp33_;
8715
break;
8716
}
8717
case VALA_TOKEN_TYPE_BREAK:
8718
{
8719
ValaStatement* _tmp34_ = NULL;
8720
ValaStatement* _tmp35_;
8824
_vala_code_node_unref0 (stmt);
8825
stmt = _tmp32_;
8826
break;
8827
}
8828
case VALA_TOKEN_TYPE_THROW:
8829
{
8830
ValaStatement* _tmp33_ = NULL;
8831
ValaStatement* _tmp34_;
8832
_tmp33_ = vala_parser_parse_throw_statement (self, &_inner_error_);
8833
_tmp34_ = _tmp33_;
8834
if (_inner_error_ != NULL) {
8835
_vala_code_node_unref0 (stmt);
8836
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8837
goto __catch10_vala_parse_error;
8838
}
8839
_vala_code_node_unref0 (stmt);
8840
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
8841
g_clear_error (&_inner_error_);
8842
return;
8843
}
8844
_vala_code_node_unref0 (stmt);
8845
stmt = _tmp34_;
8846
break;
8847
}
8848
case VALA_TOKEN_TYPE_TRY:
8849
{
8850
ValaStatement* _tmp35_ = NULL;
8721
8851
ValaStatement* _tmp36_;
8722
_tmp34_ = vala_parser_parse_break_statement (self, &_inner_error_);
8723
_tmp35_ = _tmp34_;
8724
if (_inner_error_ != NULL) {
8725
_vala_code_node_unref0 (stmt);
8726
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8727
goto __catch10_vala_parse_error;
8728
}
8729
_vala_code_node_unref0 (stmt);
8730
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
8731
g_clear_error (&_inner_error_);
8732
return;
8733
}
8852
_tmp35_ = vala_parser_parse_try_statement (self, &_inner_error_);
8734
8853
_tmp36_ = _tmp35_;
8854
if (_inner_error_ != NULL) {
8855
_vala_code_node_unref0 (stmt);
8856
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8857
goto __catch10_vala_parse_error;
8858
}
8859
_vala_code_node_unref0 (stmt);
8860
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
8861
g_clear_error (&_inner_error_);
8862
return;
8863
}
8735
8864
_vala_code_node_unref0 (stmt);
8736
8865
stmt = _tmp36_;
8737
8866
break;
8738
8867
}
8739
case VALA_TOKEN_TYPE_CONTINUE:
8868
case VALA_TOKEN_TYPE_LOCK:
8740
8869
{
8741
8870
ValaStatement* _tmp37_ = NULL;
8742
8871
ValaStatement* _tmp38_;
8743
ValaStatement* _tmp39_;
8744
_tmp37_ = vala_parser_parse_continue_statement (self, &_inner_error_);
8872
_tmp37_ = vala_parser_parse_lock_statement (self, &_inner_error_);
8745
8873
_tmp38_ = _tmp37_;
8746
8874
if (_inner_error_ != NULL) {
8747
8875
_vala_code_node_unref0 (stmt);
8753
8881
g_clear_error (&_inner_error_);
8754
8882
return;
8755
8883
}
8756
_tmp39_ = _tmp38_;
8757
_vala_code_node_unref0 (stmt);
8758
stmt = _tmp39_;
8759
break;
8760
}
8761
case VALA_TOKEN_TYPE_RETURN:
8762
{
8763
ValaStatement* _tmp40_ = NULL;
8764
ValaStatement* _tmp41_;
8765
ValaStatement* _tmp42_;
8766
_tmp40_ = vala_parser_parse_return_statement (self, &_inner_error_);
8767
_tmp41_ = _tmp40_;
8768
if (_inner_error_ != NULL) {
8769
_vala_code_node_unref0 (stmt);
8770
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8771
goto __catch10_vala_parse_error;
8772
}
8773
_vala_code_node_unref0 (stmt);
8774
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
8775
g_clear_error (&_inner_error_);
8776
return;
8777
}
8778
_tmp42_ = _tmp41_;
8779
_vala_code_node_unref0 (stmt);
8780
stmt = _tmp42_;
8781
break;
8782
}
8783
case VALA_TOKEN_TYPE_YIELD:
8784
{
8785
ValaStatement* _tmp43_ = NULL;
8786
ValaStatement* _tmp44_;
8787
ValaStatement* _tmp45_;
8788
_tmp43_ = vala_parser_parse_yield_statement (self, &_inner_error_);
8789
_tmp44_ = _tmp43_;
8790
if (_inner_error_ != NULL) {
8791
_vala_code_node_unref0 (stmt);
8792
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8793
goto __catch10_vala_parse_error;
8794
}
8795
_vala_code_node_unref0 (stmt);
8796
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
8797
g_clear_error (&_inner_error_);
8798
return;
8799
}
8800
_tmp45_ = _tmp44_;
8801
_vala_code_node_unref0 (stmt);
8802
stmt = _tmp45_;
8803
break;
8804
}
8805
case VALA_TOKEN_TYPE_THROW:
8806
{
8807
ValaStatement* _tmp46_ = NULL;
8808
ValaStatement* _tmp47_;
8809
ValaStatement* _tmp48_;
8810
_tmp46_ = vala_parser_parse_throw_statement (self, &_inner_error_);
8811
_tmp47_ = _tmp46_;
8812
if (_inner_error_ != NULL) {
8813
_vala_code_node_unref0 (stmt);
8814
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8815
goto __catch10_vala_parse_error;
8816
}
8817
_vala_code_node_unref0 (stmt);
8818
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
8819
g_clear_error (&_inner_error_);
8820
return;
8821
}
8822
_tmp48_ = _tmp47_;
8823
_vala_code_node_unref0 (stmt);
8824
stmt = _tmp48_;
8825
break;
8826
}
8827
case VALA_TOKEN_TYPE_TRY:
8828
{
8829
ValaStatement* _tmp49_ = NULL;
8830
ValaStatement* _tmp50_;
8831
ValaStatement* _tmp51_;
8832
_tmp49_ = vala_parser_parse_try_statement (self, &_inner_error_);
8833
_tmp50_ = _tmp49_;
8834
if (_inner_error_ != NULL) {
8835
_vala_code_node_unref0 (stmt);
8836
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8837
goto __catch10_vala_parse_error;
8838
}
8839
_vala_code_node_unref0 (stmt);
8840
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
8841
g_clear_error (&_inner_error_);
8842
return;
8843
}
8844
_tmp51_ = _tmp50_;
8845
_vala_code_node_unref0 (stmt);
8846
stmt = _tmp51_;
8847
break;
8848
}
8849
case VALA_TOKEN_TYPE_LOCK:
8850
{
8851
ValaStatement* _tmp52_ = NULL;
8852
ValaStatement* _tmp53_;
8853
ValaStatement* _tmp54_;
8854
_tmp52_ = vala_parser_parse_lock_statement (self, &_inner_error_);
8855
_tmp53_ = _tmp52_;
8856
if (_inner_error_ != NULL) {
8857
_vala_code_node_unref0 (stmt);
8858
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8859
goto __catch10_vala_parse_error;
8860
}
8861
_vala_code_node_unref0 (stmt);
8862
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
8863
g_clear_error (&_inner_error_);
8864
return;
8865
}
8866
_tmp54_ = _tmp53_;
8867
_vala_code_node_unref0 (stmt);
8868
stmt = _tmp54_;
8884
_vala_code_node_unref0 (stmt);
8885
stmt = _tmp38_;
8869
8886
break;
8870
8887
}
8871
8888
case VALA_TOKEN_TYPE_DELETE:
8872
8889
{
8873
ValaStatement* _tmp55_ = NULL;
8874
ValaStatement* _tmp56_;
8875
ValaStatement* _tmp57_;
8876
_tmp55_ = vala_parser_parse_delete_statement (self, &_inner_error_);
8877
_tmp56_ = _tmp55_;
8890
ValaStatement* _tmp39_ = NULL;
8891
ValaStatement* _tmp40_;
8892
_tmp39_ = vala_parser_parse_delete_statement (self, &_inner_error_);
8893
_tmp40_ = _tmp39_;
8878
8894
if (_inner_error_ != NULL) {
8879
8895
_vala_code_node_unref0 (stmt);
8880
8896
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8885
8901
g_clear_error (&_inner_error_);
8886
8902
return;
8887
8903
}
8888
_tmp57_ = _tmp56_;
8889
8904
_vala_code_node_unref0 (stmt);
8890
stmt = _tmp57_;
8905
stmt = _tmp40_;
8891
8906
break;
8892
8907
}
8893
8908
case VALA_TOKEN_TYPE_VAR:
8930
8945
case VALA_TOKEN_TYPE_STAR:
8931
8946
case VALA_TOKEN_TYPE_NEW:
8932
8947
{
8933
ValaStatement* _tmp58_ = NULL;
8934
ValaStatement* _tmp59_;
8935
ValaStatement* _tmp60_;
8936
_tmp58_ = vala_parser_parse_expression_statement (self, &_inner_error_);
8937
_tmp59_ = _tmp58_;
8948
ValaStatement* _tmp41_ = NULL;
8949
ValaStatement* _tmp42_;
8950
_tmp41_ = vala_parser_parse_expression_statement (self, &_inner_error_);
8951
_tmp42_ = _tmp41_;
8938
8952
if (_inner_error_ != NULL) {
8939
8953
_vala_code_node_unref0 (stmt);
8940
8954
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8945
8959
g_clear_error (&_inner_error_);
8946
8960
return;
8947
8961
}
8948
_tmp60_ = _tmp59_;
8949
8962
_vala_code_node_unref0 (stmt);
8950
stmt = _tmp60_;
8963
stmt = _tmp42_;
8951
8964
break;
8952
8965
}
8953
8966
default:
8954
8967
{
8955
gboolean _tmp61_;
8968
gboolean _tmp43_;
8956
8969
gboolean is_expr;
8957
_tmp61_ = vala_parser_is_expression (self, &_inner_error_);
8958
is_expr = _tmp61_;
8970
_tmp43_ = vala_parser_is_expression (self, &_inner_error_);
8971
is_expr = _tmp43_;
8959
8972
if (_inner_error_ != NULL) {
8960
8973
_vala_code_node_unref0 (stmt);
8961
8974
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8967
8980
return;
8968
8981
}
8969
8982
if (is_expr) {
8970
ValaStatement* _tmp62_ = NULL;
8971
ValaStatement* _tmp63_;
8972
ValaStatement* _tmp64_;
8973
_tmp62_ = vala_parser_parse_expression_statement (self, &_inner_error_);
8974
_tmp63_ = _tmp62_;
8983
ValaStatement* _tmp44_ = NULL;
8984
ValaStatement* _tmp45_;
8985
_tmp44_ = vala_parser_parse_expression_statement (self, &_inner_error_);
8986
_tmp45_ = _tmp44_;
8975
8987
if (_inner_error_ != NULL) {
8976
8988
_vala_code_node_unref0 (stmt);
8977
8989
if (_inner_error_->domain == VALA_PARSE_ERROR) {
8982
8994
g_clear_error (&_inner_error_);
8983
8995
return;
8984
8996
}
8985
_tmp64_ = _tmp63_;
8986
8997
_vala_code_node_unref0 (stmt);
8987
stmt = _tmp64_;
8998
stmt = _tmp45_;
8988
8999
} else {
8989
9000
is_decl = TRUE;
8990
9001
vala_parser_parse_local_variable_declarations (self, block, &_inner_error_);
9003
9014
}
9004
9015
}
9005
9016
if (!is_decl) {
9006
gboolean _tmp65_ = FALSE;
9007
ValaProfile _tmp66_;
9008
_tmp66_ = vala_code_context_get_profile (self->priv->context);
9009
if (_tmp66_ == VALA_PROFILE_DOVA) {
9010
_tmp65_ = VALA_IS_RETURN_STATEMENT (stmt);
9017
gboolean _tmp46_ = FALSE;
9018
ValaProfile _tmp47_;
9019
_tmp47_ = vala_code_context_get_profile (self->priv->context);
9020
if (_tmp47_ == VALA_PROFILE_DOVA) {
9021
_tmp46_ = VALA_IS_RETURN_STATEMENT (stmt);
9011
9022
} else {
9012
_tmp65_ = FALSE;
9023
_tmp46_ = FALSE;
9013
9024
}
9014
if (_tmp65_) {
9015
ValaReturnStatement* _tmp67_;
9025
if (_tmp46_) {
9026
ValaReturnStatement* _tmp48_;
9016
9027
ValaReturnStatement* ret_stmt;
9017
ValaExpression* _tmp68_ = NULL;
9018
_tmp67_ = _vala_code_node_ref0 (VALA_RETURN_STATEMENT (stmt));
9019
ret_stmt = _tmp67_;
9020
_tmp68_ = vala_return_statement_get_return_expression (ret_stmt);
9021
if (_tmp68_ != NULL) {
9022
ValaSourceReference* _tmp69_ = NULL;
9023
ValaMemberAccess* _tmp70_ = NULL;
9024
ValaMemberAccess* _tmp71_;
9025
ValaExpression* _tmp72_ = NULL;
9026
ValaSourceReference* _tmp73_ = NULL;
9027
ValaAssignment* _tmp74_ = NULL;
9028
ValaAssignment* _tmp75_;
9028
ValaExpression* _tmp49_ = NULL;
9029
_tmp48_ = _vala_code_node_ref0 (VALA_RETURN_STATEMENT (stmt));
9030
ret_stmt = _tmp48_;
9031
_tmp49_ = vala_return_statement_get_return_expression (ret_stmt);
9032
if (_tmp49_ != NULL) {
9033
ValaSourceReference* _tmp50_ = NULL;
9034
ValaMemberAccess* _tmp51_ = NULL;
9035
ValaMemberAccess* _tmp52_;
9036
ValaExpression* _tmp53_ = NULL;
9037
ValaSourceReference* _tmp54_ = NULL;
9038
ValaAssignment* _tmp55_ = NULL;
9039
ValaAssignment* _tmp56_;
9029
9040
ValaAssignment* assignment;
9030
ValaSourceReference* _tmp76_ = NULL;
9031
ValaExpressionStatement* _tmp77_ = NULL;
9032
ValaExpressionStatement* _tmp78_;
9033
_tmp69_ = vala_code_node_get_source_reference ((ValaCodeNode*) stmt);
9034
_tmp70_ = vala_member_access_new_simple ("result", _tmp69_);
9035
_tmp71_ = _tmp70_;
9036
_tmp72_ = vala_return_statement_get_return_expression (ret_stmt);
9037
_tmp73_ = vala_code_node_get_source_reference ((ValaCodeNode*) stmt);
9038
_tmp74_ = vala_assignment_new ((ValaExpression*) _tmp71_, _tmp72_, VALA_ASSIGNMENT_OPERATOR_SIMPLE, _tmp73_);
9039
assignment = (_tmp75_ = _tmp74_, _vala_code_node_unref0 (_tmp71_), _tmp75_);
9041
ValaSourceReference* _tmp57_ = NULL;
9042
ValaExpressionStatement* _tmp58_ = NULL;
9043
ValaExpressionStatement* _tmp59_;
9044
_tmp50_ = vala_code_node_get_source_reference ((ValaCodeNode*) stmt);
9045
_tmp51_ = vala_member_access_new_simple ("result", _tmp50_);
9046
_tmp52_ = _tmp51_;
9047
_tmp53_ = vala_return_statement_get_return_expression (ret_stmt);
9048
_tmp54_ = vala_code_node_get_source_reference ((ValaCodeNode*) stmt);
9049
_tmp55_ = vala_assignment_new ((ValaExpression*) _tmp52_, _tmp53_, VALA_ASSIGNMENT_OPERATOR_SIMPLE, _tmp54_);
9050
_tmp56_ = _tmp55_;
9051
_vala_code_node_unref0 (_tmp52_);
9052
assignment = _tmp56_;
9040
9053
vala_return_statement_set_return_expression (ret_stmt, NULL);
9041
_tmp76_ = vala_code_node_get_source_reference ((ValaCodeNode*) stmt);
9042
_tmp77_ = vala_expression_statement_new ((ValaExpression*) assignment, _tmp76_);
9043
_tmp78_ = _tmp77_;
9044
vala_block_add_statement (block, (ValaStatement*) _tmp78_);
9045
_vala_code_node_unref0 (_tmp78_);
9054
_tmp57_ = vala_code_node_get_source_reference ((ValaCodeNode*) stmt);
9055
_tmp58_ = vala_expression_statement_new ((ValaExpression*) assignment, _tmp57_);
9056
_tmp59_ = _tmp58_;
9057
vala_block_add_statement (block, (ValaStatement*) _tmp59_);
9058
_vala_code_node_unref0 (_tmp59_);
9046
9059
_vala_code_node_unref0 (assignment);
9047
9060
}
9048
9061
_vala_code_node_unref0 (ret_stmt);
9054
9067
__catch10_vala_parse_error:
9055
9068
{
9056
9069
GError * e;
9057
ValaParserRecoveryState _tmp79_;
9070
ValaParserRecoveryState _tmp60_;
9058
9071
e = _inner_error_;
9059
9072
_inner_error_ = NULL;
9060
_tmp79_ = vala_parser_recover (self);
9061
if (_tmp79_ != VALA_PARSER_RECOVERY_STATE_STATEMENT_BEGIN) {
9073
_tmp60_ = vala_parser_recover (self);
9074
if (_tmp60_ != VALA_PARSER_RECOVERY_STATE_STATEMENT_BEGIN) {
9062
9075
_g_error_free0 (e);
9063
9076
break;
9064
9077
}
9087
9100
ValaTokenType _tmp2_;
9088
9101
GError * _inner_error_ = NULL;
9089
9102
g_return_val_if_fail (self != NULL, FALSE);
9090
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
9103
vala_parser_get_location (self, &_tmp0_);
9104
_tmp1_ = _tmp0_;
9091
9105
begin = _tmp1_;
9092
9106
vala_parser_skip_type (self, &_inner_error_);
9093
9107
if (_inner_error_ != NULL) {
9137
9151
ValaBlock* result = NULL;
9138
9152
ValaTokenType _tmp0_;
9139
9153
ValaComment* _tmp2_ = NULL;
9140
ValaComment* _tmp3_;
9154
ValaSourceLocation _tmp3_ = {0};
9141
9155
ValaSourceLocation _tmp4_ = {0};
9142
ValaSourceLocation _tmp5_ = {0};
9143
ValaSourceReference* _tmp6_ = NULL;
9144
ValaSourceReference* _tmp7_;
9145
ValaBlock* _tmp8_ = NULL;
9146
ValaBlock* _tmp9_;
9156
ValaSourceReference* _tmp5_ = NULL;
9157
ValaSourceReference* _tmp6_;
9158
ValaBlock* _tmp7_ = NULL;
9159
ValaBlock* _tmp8_;
9147
9160
ValaBlock* block;
9148
ValaStatement* _tmp10_ = NULL;
9161
ValaStatement* _tmp9_ = NULL;
9149
9162
ValaStatement* stmt;
9150
gboolean _tmp11_ = FALSE;
9151
ValaProfile _tmp12_;
9163
gboolean _tmp10_ = FALSE;
9164
ValaProfile _tmp11_;
9152
9165
GError * _inner_error_ = NULL;
9153
9166
g_return_val_if_fail (self != NULL, NULL);
9154
9167
_tmp0_ = vala_parser_current (self);
9171
9184
return result;
9172
9185
}
9173
9186
_tmp2_ = vala_scanner_pop_comment (self->priv->scanner);
9174
_tmp3_ = _tmp2_;
9175
9187
_vala_comment_unref0 (self->priv->comment);
9176
self->priv->comment = _tmp3_;
9177
_tmp5_ = (vala_parser_get_location (self, &_tmp4_), _tmp4_);
9178
_tmp6_ = vala_parser_get_src (self, &_tmp5_);
9179
_tmp7_ = _tmp6_;
9180
_tmp8_ = vala_block_new (_tmp7_);
9181
block = (_tmp9_ = _tmp8_, _vala_source_reference_unref0 (_tmp7_), _tmp9_);
9182
_tmp10_ = vala_parser_parse_embedded_statement_without_block (self, &_inner_error_);
9183
stmt = _tmp10_;
9188
self->priv->comment = _tmp2_;
9189
vala_parser_get_location (self, &_tmp3_);
9190
_tmp4_ = _tmp3_;
9191
_tmp5_ = vala_parser_get_src (self, &_tmp4_);
9192
_tmp6_ = _tmp5_;
9193
_tmp7_ = vala_block_new (_tmp6_);
9194
_tmp8_ = _tmp7_;
9195
_vala_source_reference_unref0 (_tmp6_);
9196
block = _tmp8_;
9197
_tmp9_ = vala_parser_parse_embedded_statement_without_block (self, &_inner_error_);
9198
stmt = _tmp9_;
9184
9199
if (_inner_error_ != NULL) {
9185
9200
if (_inner_error_->domain == VALA_PARSE_ERROR) {
9186
9201
g_propagate_error (error, _inner_error_);
9193
9208
return NULL;
9194
9209
}
9195
9210
}
9196
_tmp12_ = vala_code_context_get_profile (self->priv->context);
9197
if (_tmp12_ == VALA_PROFILE_DOVA) {
9198
_tmp11_ = VALA_IS_RETURN_STATEMENT (stmt);
9211
_tmp11_ = vala_code_context_get_profile (self->priv->context);
9212
if (_tmp11_ == VALA_PROFILE_DOVA) {
9213
_tmp10_ = VALA_IS_RETURN_STATEMENT (stmt);
9199
9214
} else {
9200
_tmp11_ = FALSE;
9215
_tmp10_ = FALSE;
9201
9216
}
9202
if (_tmp11_) {
9203
ValaReturnStatement* _tmp13_;
9217
if (_tmp10_) {
9218
ValaReturnStatement* _tmp12_;
9204
9219
ValaReturnStatement* ret_stmt;
9205
ValaExpression* _tmp14_ = NULL;
9206
_tmp13_ = _vala_code_node_ref0 (VALA_RETURN_STATEMENT (stmt));
9207
ret_stmt = _tmp13_;
9208
_tmp14_ = vala_return_statement_get_return_expression (ret_stmt);
9209
if (_tmp14_ != NULL) {
9210
ValaMemberAccess* _tmp15_ = NULL;
9211
ValaMemberAccess* _tmp16_;
9212
ValaExpression* _tmp17_ = NULL;
9213
ValaAssignment* _tmp18_ = NULL;
9214
ValaAssignment* _tmp19_;
9220
ValaExpression* _tmp13_ = NULL;
9221
_tmp12_ = _vala_code_node_ref0 (VALA_RETURN_STATEMENT (stmt));
9222
ret_stmt = _tmp12_;
9223
_tmp13_ = vala_return_statement_get_return_expression (ret_stmt);
9224
if (_tmp13_ != NULL) {
9225
ValaMemberAccess* _tmp14_ = NULL;
9226
ValaMemberAccess* _tmp15_;
9227
ValaExpression* _tmp16_ = NULL;
9228
ValaAssignment* _tmp17_ = NULL;
9229
ValaAssignment* _tmp18_;
9215
9230
ValaAssignment* assignment;
9216
ValaExpressionStatement* _tmp20_ = NULL;
9217
ValaExpressionStatement* _tmp21_;
9218
_tmp15_ = vala_member_access_new_simple ("result", NULL);
9219
_tmp16_ = _tmp15_;
9220
_tmp17_ = vala_return_statement_get_return_expression (ret_stmt);
9221
_tmp18_ = vala_assignment_new ((ValaExpression*) _tmp16_, _tmp17_, VALA_ASSIGNMENT_OPERATOR_SIMPLE, NULL);
9222
assignment = (_tmp19_ = _tmp18_, _vala_code_node_unref0 (_tmp16_), _tmp19_);
9231
ValaExpressionStatement* _tmp19_ = NULL;
9232
ValaExpressionStatement* _tmp20_;
9233
_tmp14_ = vala_member_access_new_simple ("result", NULL);
9234
_tmp15_ = _tmp14_;
9235
_tmp16_ = vala_return_statement_get_return_expression (ret_stmt);
9236
_tmp17_ = vala_assignment_new ((ValaExpression*) _tmp15_, _tmp16_, VALA_ASSIGNMENT_OPERATOR_SIMPLE, NULL);
9237
_tmp18_ = _tmp17_;
9238
_vala_code_node_unref0 (_tmp15_);
9239
assignment = _tmp18_;
9223
9240
vala_return_statement_set_return_expression (ret_stmt, NULL);
9224
_tmp20_ = vala_expression_statement_new ((ValaExpression*) assignment, NULL);
9225
_tmp21_ = _tmp20_;
9226
vala_block_add_statement (block, (ValaStatement*) _tmp21_);
9227
_vala_code_node_unref0 (_tmp21_);
9241
_tmp19_ = vala_expression_statement_new ((ValaExpression*) assignment, NULL);
9242
_tmp20_ = _tmp19_;
9243
vala_block_add_statement (block, (ValaStatement*) _tmp20_);
9244
_vala_code_node_unref0 (_tmp20_);
9228
9245
_vala_code_node_unref0 (assignment);
9229
9246
}
9230
9247
_vala_code_node_unref0 (ret_stmt);
9538
9555
_tmp31_ = vala_parser_get_error (self, "embedded statement cannot be declaration ");
9539
9556
_tmp32_ = _tmp31_;
9540
9557
_tmp33_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp32_);
9541
_inner_error_ = (_tmp34_ = _tmp33_, _g_free0 (_tmp32_), _tmp34_);
9558
_tmp34_ = _tmp33_;
9559
_g_free0 (_tmp32_);
9560
_inner_error_ = _tmp34_;
9542
9561
if (_inner_error_->domain == VALA_PARSE_ERROR) {
9543
9562
g_propagate_error (error, _inner_error_);
9544
9563
return NULL;
9614
9633
_tmp41_ = vala_parser_get_error (self, "embedded statement cannot be declaration");
9615
9634
_tmp42_ = _tmp41_;
9616
9635
_tmp43_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp42_);
9617
_inner_error_ = (_tmp44_ = _tmp43_, _g_free0 (_tmp42_), _tmp44_);
9636
_tmp44_ = _tmp43_;
9637
_g_free0 (_tmp42_);
9638
_inner_error_ = _tmp44_;
9618
9639
if (_inner_error_->domain == VALA_PARSE_ERROR) {
9619
9640
g_propagate_error (error, _inner_error_);
9620
9641
return NULL;
9650
9671
gint _tmp18_;
9651
9672
GError * _inner_error_ = NULL;
9652
9673
g_return_val_if_fail (self != NULL, NULL);
9653
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
9674
vala_parser_get_location (self, &_tmp0_);
9675
_tmp1_ = _tmp0_;
9654
9676
begin = _tmp1_;
9655
9677
vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_BRACE, &_inner_error_);
9656
9678
if (_inner_error_ != NULL) {
9666
9688
_tmp2_ = vala_parser_get_src (self, &begin);
9667
9689
_tmp3_ = _tmp2_;
9668
9690
_tmp4_ = vala_block_new (_tmp3_);
9669
block = (_tmp5_ = _tmp4_, _vala_source_reference_unref0 (_tmp3_), _tmp5_);
9691
_tmp5_ = _tmp4_;
9692
_vala_source_reference_unref0 (_tmp3_);
9693
block = _tmp5_;
9670
9694
vala_parser_parse_statements (self, block, &_inner_error_);
9671
9695
if (_inner_error_ != NULL) {
9672
9696
if (_inner_error_->domain == VALA_PARSE_ERROR) {
9723
9747
ValaStatement* _tmp5_;
9724
9748
GError * _inner_error_ = NULL;
9725
9749
g_return_val_if_fail (self != NULL, NULL);
9726
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
9750
vala_parser_get_location (self, &_tmp0_);
9751
_tmp1_ = _tmp0_;
9727
9752
begin = _tmp1_;
9728
9753
vala_parser_expect (self, VALA_TOKEN_TYPE_SEMICOLON, &_inner_error_);
9729
9754
if (_inner_error_ != NULL) {
9739
9764
_tmp2_ = vala_parser_get_src (self, &begin);
9740
9765
_tmp3_ = _tmp2_;
9741
9766
_tmp4_ = vala_empty_statement_new (_tmp3_);
9742
result = (_tmp5_ = (ValaStatement*) _tmp4_, _vala_source_reference_unref0 (_tmp3_), _tmp5_);
9767
_tmp5_ = (ValaStatement*) _tmp4_;
9768
_vala_source_reference_unref0 (_tmp3_);
9769
result = _tmp5_;
9743
9770
return result;
9744
9771
}
9745
9772
9762
9789
g_return_if_fail (block != NULL);
9763
9790
_tmp0_ = vala_parser_accept (self, VALA_TOKEN_TYPE_VAR);
9764
9791
if (_tmp0_) {
9765
ValaDataType* _tmp1_;
9766
_tmp1_ = NULL;
9767
9792
_vala_code_node_unref0 (variable_type);
9768
variable_type = _tmp1_;
9793
variable_type = NULL;
9769
9794
} else {
9770
ValaDataType* _tmp2_ = NULL;
9771
ValaDataType* _tmp3_;
9772
ValaDataType* _tmp4_;
9773
_tmp2_ = vala_parser_parse_type (self, TRUE, TRUE, &_inner_error_);
9774
_tmp3_ = _tmp2_;
9795
ValaDataType* _tmp1_ = NULL;
9796
ValaDataType* _tmp2_;
9797
_tmp1_ = vala_parser_parse_type (self, TRUE, TRUE, &_inner_error_);
9798
_tmp2_ = _tmp1_;
9775
9799
if (_inner_error_ != NULL) {
9776
9800
if (_inner_error_->domain == VALA_PARSE_ERROR) {
9777
9801
g_propagate_error (error, _inner_error_);
9784
9808
return;
9785
9809
}
9786
9810
}
9787
_tmp4_ = _tmp3_;
9788
9811
_vala_code_node_unref0 (variable_type);
9789
variable_type = _tmp4_;
9812
variable_type = _tmp2_;
9790
9813
}
9791
9814
{
9792
gboolean _tmp5_;
9793
_tmp5_ = TRUE;
9815
gboolean _tmp3_;
9816
_tmp3_ = TRUE;
9794
9817
while (TRUE) {
9795
gboolean _tmp7_ = FALSE;
9818
gboolean _tmp5_ = FALSE;
9796
9819
ValaDataType* type_copy;
9797
ValaLocalVariable* _tmp43_ = NULL;
9820
ValaLocalVariable* _tmp40_ = NULL;
9798
9821
ValaLocalVariable* local;
9799
ValaSourceReference* _tmp44_ = NULL;
9800
ValaDeclarationStatement* _tmp45_ = NULL;
9801
ValaDeclarationStatement* _tmp46_;
9802
if (!_tmp5_) {
9803
gboolean _tmp6_;
9804
_tmp6_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
9805
if (!_tmp6_) {
9822
ValaSourceReference* _tmp41_ = NULL;
9823
ValaDeclarationStatement* _tmp42_ = NULL;
9824
ValaDeclarationStatement* _tmp43_;
9825
if (!_tmp3_) {
9826
gboolean _tmp4_;
9827
_tmp4_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
9828
if (!_tmp4_) {
9806
9829
break;
9807
9830
}
9808
9831
}
9809
_tmp5_ = FALSE;
9832
_tmp3_ = FALSE;
9810
9833
if (variable_type == NULL) {
9811
gboolean _tmp8_;
9812
_tmp8_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OPEN_PARENS);
9813
_tmp7_ = _tmp8_;
9834
gboolean _tmp6_;
9835
_tmp6_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OPEN_PARENS);
9836
_tmp5_ = _tmp6_;
9814
9837
} else {
9815
_tmp7_ = FALSE;
9838
_tmp5_ = FALSE;
9816
9839
}
9817
if (_tmp7_) {
9818
ValaSourceLocation _tmp9_ = {0};
9819
ValaSourceLocation _tmp10_ = {0};
9840
if (_tmp5_) {
9841
ValaSourceLocation _tmp7_ = {0};
9842
ValaSourceLocation _tmp8_ = {0};
9820
9843
ValaSourceLocation begin;
9821
gchar** _tmp11_ = NULL;
9844
gchar** _tmp9_ = NULL;
9822
9845
gchar** identifiers;
9823
9846
gint identifiers_length1;
9824
9847
gint _identifiers_size_;
9825
ValaExpression* _tmp16_ = NULL;
9848
ValaExpression* _tmp14_ = NULL;
9826
9849
ValaExpression* tuple;
9827
gchar* _tmp17_ = NULL;
9828
gchar* _tmp18_;
9829
ValaSourceReference* _tmp19_ = NULL;
9830
ValaSourceReference* _tmp20_;
9831
ValaLocalVariable* _tmp21_ = NULL;
9832
ValaLocalVariable* _tmp22_;
9850
gchar* _tmp15_ = NULL;
9851
gchar* _tmp16_;
9852
ValaSourceReference* _tmp17_ = NULL;
9853
ValaSourceReference* _tmp18_;
9854
ValaLocalVariable* _tmp19_ = NULL;
9855
ValaLocalVariable* _tmp20_;
9833
9856
ValaLocalVariable* tuple_local;
9834
ValaSourceReference* _tmp23_ = NULL;
9835
ValaDeclarationStatement* _tmp24_ = NULL;
9836
ValaDeclarationStatement* _tmp25_;
9837
_tmp10_ = (vala_parser_get_location (self, &_tmp9_), _tmp9_);
9838
begin = _tmp10_;
9839
_tmp11_ = g_new0 (gchar*, 0 + 1);
9840
identifiers = _tmp11_;
9857
ValaSourceReference* _tmp21_ = NULL;
9858
ValaDeclarationStatement* _tmp22_ = NULL;
9859
ValaDeclarationStatement* _tmp23_;
9860
vala_parser_get_location (self, &_tmp7_);
9861
_tmp8_ = _tmp7_;
9862
begin = _tmp8_;
9863
_tmp9_ = g_new0 (gchar*, 0 + 1);
9864
identifiers = _tmp9_;
9841
9865
identifiers_length1 = 0;
9842
9866
_identifiers_size_ = 0;
9843
9867
{
9844
gboolean _tmp12_;
9845
_tmp12_ = TRUE;
9868
gboolean _tmp10_;
9869
_tmp10_ = TRUE;
9846
9870
while (TRUE) {
9847
gchar* _tmp14_ = NULL;
9848
gchar* _tmp15_;
9849
if (!_tmp12_) {
9850
gboolean _tmp13_;
9851
_tmp13_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
9852
if (!_tmp13_) {
9871
gchar* _tmp12_ = NULL;
9872
gchar* _tmp13_;
9873
if (!_tmp10_) {
9874
gboolean _tmp11_;
9875
_tmp11_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
9876
if (!_tmp11_) {
9853
9877
break;
9854
9878
}
9855
9879
}
9856
_tmp12_ = FALSE;
9857
_tmp14_ = vala_parser_parse_identifier (self, &_inner_error_);
9858
_tmp15_ = _tmp14_;
9880
_tmp10_ = FALSE;
9881
_tmp12_ = vala_parser_parse_identifier (self, &_inner_error_);
9882
_tmp13_ = _tmp12_;
9859
9883
if (_inner_error_ != NULL) {
9860
9884
if (_inner_error_->domain == VALA_PARSE_ERROR) {
9861
9885
g_propagate_error (error, _inner_error_);
9870
9894
return;
9871
9895
}
9872
9896
}
9873
_vala_array_add12 (&identifiers, &identifiers_length1, &_identifiers_size_, _tmp15_);
9897
_vala_array_add12 (&identifiers, &identifiers_length1, &_identifiers_size_, _tmp13_);
9874
9898
}
9875
9899
}
9876
9900
vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_PARENS, &_inner_error_);
9903
9927
return;
9904
9928
}
9905
9929
}
9906
_tmp16_ = vala_parser_parse_expression (self, &_inner_error_);
9907
tuple = _tmp16_;
9930
_tmp14_ = vala_parser_parse_expression (self, &_inner_error_);
9931
tuple = _tmp14_;
9908
9932
if (_inner_error_ != NULL) {
9909
9933
if (_inner_error_->domain == VALA_PARSE_ERROR) {
9910
9934
g_propagate_error (error, _inner_error_);
9919
9943
return;
9920
9944
}
9921
9945
}
9922
_tmp17_ = vala_code_node_get_temp_name ();
9946
_tmp15_ = vala_code_node_get_temp_name ();
9947
_tmp16_ = _tmp15_;
9948
_tmp17_ = vala_parser_get_src (self, &begin);
9923
9949
_tmp18_ = _tmp17_;
9924
_tmp19_ = vala_parser_get_src (self, &begin);
9950
_tmp19_ = vala_local_variable_new (NULL, _tmp16_, tuple, _tmp18_);
9925
9951
_tmp20_ = _tmp19_;
9926
_tmp21_ = vala_local_variable_new (NULL, _tmp18_, tuple, _tmp20_);
9927
tuple_local = (_tmp22_ = _tmp21_, _vala_source_reference_unref0 (_tmp20_), _g_free0 (_tmp18_), _tmp22_);
9928
_tmp23_ = vala_code_node_get_source_reference ((ValaCodeNode*) tuple_local);
9929
_tmp24_ = vala_declaration_statement_new ((ValaSymbol*) tuple_local, _tmp23_);
9930
_tmp25_ = _tmp24_;
9931
vala_block_add_statement (block, (ValaStatement*) _tmp25_);
9932
_vala_code_node_unref0 (_tmp25_);
9952
_vala_source_reference_unref0 (_tmp18_);
9953
_g_free0 (_tmp16_);
9954
tuple_local = _tmp20_;
9955
_tmp21_ = vala_code_node_get_source_reference ((ValaCodeNode*) tuple_local);
9956
_tmp22_ = vala_declaration_statement_new ((ValaSymbol*) tuple_local, _tmp21_);
9957
_tmp23_ = _tmp22_;
9958
vala_block_add_statement (block, (ValaStatement*) _tmp23_);
9959
_vala_code_node_unref0 (_tmp23_);
9933
9960
{
9934
9961
gint i;
9935
9962
i = 0;
9936
9963
{
9937
gboolean _tmp26_;
9938
_tmp26_ = TRUE;
9964
gboolean _tmp24_;
9965
_tmp24_ = TRUE;
9939
9966
while (TRUE) {
9940
const gchar* _tmp27_ = NULL;
9967
const gchar* _tmp25_ = NULL;
9968
ValaSourceReference* _tmp26_ = NULL;
9969
ValaMemberAccess* _tmp27_ = NULL;
9970
ValaMemberAccess* temp_access;
9941
9971
ValaSourceReference* _tmp28_ = NULL;
9942
ValaMemberAccess* _tmp29_ = NULL;
9943
ValaMemberAccess* temp_access;
9944
ValaSourceReference* _tmp30_ = NULL;
9945
ValaElementAccess* _tmp31_ = NULL;
9972
ValaElementAccess* _tmp29_ = NULL;
9946
9973
ValaElementAccess* ea;
9947
gchar* _tmp32_ = NULL;
9948
gchar* _tmp33_;
9949
ValaIntegerLiteral* _tmp34_ = NULL;
9950
ValaIntegerLiteral* _tmp35_;
9974
gchar* _tmp30_ = NULL;
9975
gchar* _tmp31_;
9976
ValaIntegerLiteral* _tmp32_ = NULL;
9977
ValaIntegerLiteral* _tmp33_;
9978
ValaSourceReference* _tmp34_ = NULL;
9979
ValaLocalVariable* _tmp35_ = NULL;
9980
ValaLocalVariable* local;
9951
9981
ValaSourceReference* _tmp36_ = NULL;
9952
ValaLocalVariable* _tmp37_ = NULL;
9953
ValaLocalVariable* local;
9954
ValaSourceReference* _tmp38_ = NULL;
9955
ValaDeclarationStatement* _tmp39_ = NULL;
9956
ValaDeclarationStatement* _tmp40_;
9957
if (!_tmp26_) {
9982
ValaDeclarationStatement* _tmp37_ = NULL;
9983
ValaDeclarationStatement* _tmp38_;
9984
if (!_tmp24_) {
9958
9985
i++;
9959
9986
}
9960
_tmp26_ = FALSE;
9987
_tmp24_ = FALSE;
9961
9988
if (!(i < identifiers_length1)) {
9962
9989
break;
9963
9990
}
9964
_tmp27_ = vala_symbol_get_name ((ValaSymbol*) tuple_local);
9991
_tmp25_ = vala_symbol_get_name ((ValaSymbol*) tuple_local);
9992
_tmp26_ = vala_code_node_get_source_reference ((ValaCodeNode*) tuple_local);
9993
_tmp27_ = vala_member_access_new_simple (_tmp25_, _tmp26_);
9994
temp_access = _tmp27_;
9965
9995
_tmp28_ = vala_code_node_get_source_reference ((ValaCodeNode*) tuple_local);
9966
_tmp29_ = vala_member_access_new_simple (_tmp27_, _tmp28_);
9967
temp_access = _tmp29_;
9968
_tmp30_ = vala_code_node_get_source_reference ((ValaCodeNode*) tuple_local);
9969
_tmp31_ = vala_element_access_new ((ValaExpression*) temp_access, _tmp30_);
9970
ea = _tmp31_;
9971
_tmp32_ = g_strdup_printf ("%i", i);
9996
_tmp29_ = vala_element_access_new ((ValaExpression*) temp_access, _tmp28_);
9997
ea = _tmp29_;
9998
_tmp30_ = g_strdup_printf ("%i", i);
9999
_tmp31_ = _tmp30_;
10000
_tmp32_ = vala_integer_literal_new (_tmp31_, NULL);
9972
10001
_tmp33_ = _tmp32_;
9973
_tmp34_ = vala_integer_literal_new (_tmp33_, NULL);
9974
_tmp35_ = _tmp34_;
9975
vala_element_access_append_index (ea, (ValaExpression*) _tmp35_);
9976
_vala_code_node_unref0 (_tmp35_);
9977
_g_free0 (_tmp33_);
9978
_tmp36_ = vala_code_node_get_source_reference ((ValaCodeNode*) tuple_local);
9979
_tmp37_ = vala_local_variable_new (NULL, identifiers[i], (ValaExpression*) ea, _tmp36_);
9980
local = _tmp37_;
9981
_tmp38_ = vala_code_node_get_source_reference ((ValaCodeNode*) local);
9982
_tmp39_ = vala_declaration_statement_new ((ValaSymbol*) local, _tmp38_);
9983
_tmp40_ = _tmp39_;
9984
vala_block_add_statement (block, (ValaStatement*) _tmp40_);
9985
_vala_code_node_unref0 (_tmp40_);
10002
vala_element_access_append_index (ea, (ValaExpression*) _tmp33_);
10003
_vala_code_node_unref0 (_tmp33_);
10004
_g_free0 (_tmp31_);
10005
_tmp34_ = vala_code_node_get_source_reference ((ValaCodeNode*) tuple_local);
10006
_tmp35_ = vala_local_variable_new (NULL, identifiers[i], (ValaExpression*) ea, _tmp34_);
10007
local = _tmp35_;
10008
_tmp36_ = vala_code_node_get_source_reference ((ValaCodeNode*) local);
10009
_tmp37_ = vala_declaration_statement_new ((ValaSymbol*) local, _tmp36_);
10010
_tmp38_ = _tmp37_;
10011
vala_block_add_statement (block, (ValaStatement*) _tmp38_);
10012
_vala_code_node_unref0 (_tmp38_);
9986
10013
_vala_code_node_unref0 (local);
9987
10014
_vala_code_node_unref0 (ea);
9988
10015
_vala_code_node_unref0 (temp_access);
9996
10023
}
9997
10024
type_copy = NULL;
9998
10025
if (variable_type != NULL) {
9999
ValaDataType* _tmp41_ = NULL;
10000
ValaDataType* _tmp42_;
10001
_tmp41_ = vala_data_type_copy (variable_type);
10002
_tmp42_ = _tmp41_;
10026
ValaDataType* _tmp39_ = NULL;
10027
_tmp39_ = vala_data_type_copy (variable_type);
10003
10028
_vala_code_node_unref0 (type_copy);
10004
type_copy = _tmp42_;
10029
type_copy = _tmp39_;
10005
10030
}
10006
_tmp43_ = vala_parser_parse_local_variable (self, type_copy, &_inner_error_);
10007
local = _tmp43_;
10031
_tmp40_ = vala_parser_parse_local_variable (self, type_copy, &_inner_error_);
10032
local = _tmp40_;
10008
10033
if (_inner_error_ != NULL) {
10009
10034
if (_inner_error_->domain == VALA_PARSE_ERROR) {
10010
10035
g_propagate_error (error, _inner_error_);
10019
10044
return;
10020
10045
}
10021
10046
}
10022
_tmp44_ = vala_code_node_get_source_reference ((ValaCodeNode*) local);
10023
_tmp45_ = vala_declaration_statement_new ((ValaSymbol*) local, _tmp44_);
10024
_tmp46_ = _tmp45_;
10025
vala_block_add_statement (block, (ValaStatement*) _tmp46_);
10026
_vala_code_node_unref0 (_tmp46_);
10047
_tmp41_ = vala_code_node_get_source_reference ((ValaCodeNode*) local);
10048
_tmp42_ = vala_declaration_statement_new ((ValaSymbol*) local, _tmp41_);
10049
_tmp43_ = _tmp42_;
10050
vala_block_add_statement (block, (ValaStatement*) _tmp43_);
10051
_vala_code_node_unref0 (_tmp43_);
10027
10052
_vala_code_node_unref0 (local);
10028
10053
_vala_code_node_unref0 (type_copy);
10029
10054
}
10056
10081
ValaDataType* type;
10057
10082
ValaExpression* initializer;
10058
10083
gboolean _tmp4_;
10059
ValaSourceReference* _tmp8_ = NULL;
10060
ValaSourceReference* _tmp9_;
10061
ValaLocalVariable* _tmp10_ = NULL;
10062
ValaLocalVariable* _tmp11_;
10084
ValaSourceReference* _tmp7_ = NULL;
10085
ValaSourceReference* _tmp8_;
10086
ValaLocalVariable* _tmp9_ = NULL;
10087
ValaLocalVariable* _tmp10_;
10063
10088
GError * _inner_error_ = NULL;
10064
10089
g_return_val_if_fail (self != NULL, NULL);
10065
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
10090
vala_parser_get_location (self, &_tmp0_);
10091
_tmp1_ = _tmp0_;
10066
10092
begin = _tmp1_;
10067
10093
_tmp2_ = vala_parser_parse_identifier (self, &_inner_error_);
10068
10094
id = _tmp2_;
10095
10121
if (_tmp4_) {
10096
10122
ValaExpression* _tmp5_ = NULL;
10097
10123
ValaExpression* _tmp6_;
10098
ValaExpression* _tmp7_;
10099
10124
_tmp5_ = vala_parser_parse_expression (self, &_inner_error_);
10100
10125
_tmp6_ = _tmp5_;
10101
10126
if (_inner_error_ != NULL) {
10114
10139
return NULL;
10115
10140
}
10116
10141
}
10117
_tmp7_ = _tmp6_;
10118
10142
_vala_code_node_unref0 (initializer);
10119
initializer = _tmp7_;
10143
initializer = _tmp6_;
10120
10144
}
10121
_tmp8_ = vala_parser_get_src (self, &begin);
10122
_tmp9_ = _tmp8_;
10123
_tmp10_ = vala_local_variable_new (type, id, initializer, _tmp9_);
10124
result = (_tmp11_ = _tmp10_, _vala_source_reference_unref0 (_tmp9_), _tmp11_);
10145
_tmp7_ = vala_parser_get_src (self, &begin);
10146
_tmp8_ = _tmp7_;
10147
_tmp9_ = vala_local_variable_new (type, id, initializer, _tmp8_);
10148
_tmp10_ = _tmp9_;
10149
_vala_source_reference_unref0 (_tmp8_);
10150
result = _tmp10_;
10125
10151
_vala_code_node_unref0 (initializer);
10126
10152
_vala_code_node_unref0 (type);
10127
10153
_g_free0 (id);
10241
10267
GError * _inner_error_ = NULL;
10242
10268
g_return_val_if_fail (self != NULL, NULL);
10243
10269
g_return_val_if_fail (constant_type != NULL, NULL);
10244
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
10270
vala_parser_get_location (self, &_tmp0_);
10271
_tmp1_ = _tmp0_;
10245
10272
begin = _tmp1_;
10246
10273
_tmp2_ = vala_parser_parse_identifier (self, &_inner_error_);
10247
10274
id = _tmp2_;
10303
10330
_tmp5_ = vala_parser_get_src (self, &begin);
10304
10331
_tmp6_ = _tmp5_;
10305
10332
_tmp7_ = vala_constant_new (id, type, initializer, _tmp6_, NULL);
10306
result = (_tmp8_ = _tmp7_, _vala_source_reference_unref0 (_tmp6_), _tmp8_);
10333
_tmp8_ = _tmp7_;
10334
_vala_source_reference_unref0 (_tmp6_);
10335
result = _tmp8_;
10307
10336
_vala_code_node_unref0 (initializer);
10308
10337
_vala_code_node_unref0 (type);
10309
10338
_g_free0 (id);
10324
10353
ValaStatement* _tmp6_;
10325
10354
GError * _inner_error_ = NULL;
10326
10355
g_return_val_if_fail (self != NULL, NULL);
10327
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
10356
vala_parser_get_location (self, &_tmp0_);
10357
_tmp1_ = _tmp0_;
10328
10358
begin = _tmp1_;
10329
10359
_tmp2_ = vala_parser_parse_statement_expression (self, &_inner_error_);
10330
10360
expr = _tmp2_;
10354
10384
_tmp3_ = vala_parser_get_src (self, &begin);
10355
10385
_tmp4_ = _tmp3_;
10356
10386
_tmp5_ = vala_expression_statement_new (expr, _tmp4_);
10357
result = (_tmp6_ = (ValaStatement*) _tmp5_, _vala_source_reference_unref0 (_tmp4_), _tmp6_);
10387
_tmp6_ = (ValaStatement*) _tmp5_;
10388
_vala_source_reference_unref0 (_tmp4_);
10389
result = _tmp6_;
10358
10390
_vala_code_node_unref0 (expr);
10359
10391
return result;
10360
10392
}
10396
10428
ValaBlock* true_stmt;
10397
10429
ValaBlock* false_stmt;
10398
10430
gboolean _tmp5_;
10399
ValaIfStatement* _tmp9_ = NULL;
10431
ValaIfStatement* _tmp8_ = NULL;
10400
10432
GError * _inner_error_ = NULL;
10401
10433
g_return_val_if_fail (self != NULL, NULL);
10402
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
10434
vala_parser_get_location (self, &_tmp0_);
10435
_tmp1_ = _tmp0_;
10403
10436
begin = _tmp1_;
10404
10437
vala_parser_expect (self, VALA_TOKEN_TYPE_IF, &_inner_error_);
10405
10438
if (_inner_error_ != NULL) {
10471
10504
if (_tmp5_) {
10472
10505
ValaBlock* _tmp6_ = NULL;
10473
10506
ValaBlock* _tmp7_;
10474
ValaBlock* _tmp8_;
10475
10507
_tmp6_ = vala_parser_parse_embedded_statement (self, &_inner_error_);
10476
10508
_tmp7_ = _tmp6_;
10477
10509
if (_inner_error_ != NULL) {
10492
10524
return NULL;
10493
10525
}
10494
10526
}
10495
_tmp8_ = _tmp7_;
10496
10527
_vala_code_node_unref0 (false_stmt);
10497
false_stmt = _tmp8_;
10528
false_stmt = _tmp7_;
10498
10529
}
10499
_tmp9_ = vala_if_statement_new (condition, true_stmt, false_stmt, src);
10500
result = (ValaStatement*) _tmp9_;
10530
_tmp8_ = vala_if_statement_new (condition, true_stmt, false_stmt, src);
10531
result = (ValaStatement*) _tmp8_;
10501
10532
_vala_code_node_unref0 (false_stmt);
10502
10533
_vala_code_node_unref0 (true_stmt);
10503
10534
_vala_source_reference_unref0 (src);
10520
10551
ValaSwitchStatement* stmt;
10521
10552
GError * _inner_error_ = NULL;
10522
10553
g_return_val_if_fail (self != NULL, NULL);
10523
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
10554
vala_parser_get_location (self, &_tmp0_);
10555
_tmp1_ = _tmp0_;
10524
10556
begin = _tmp1_;
10525
10557
vala_parser_expect (self, VALA_TOKEN_TYPE_SWITCH, &_inner_error_);
10526
10558
if (_inner_error_ != NULL) {
10572
10604
_tmp3_ = vala_parser_get_src (self, &begin);
10573
10605
_tmp4_ = _tmp3_;
10574
10606
_tmp5_ = vala_switch_statement_new (condition, _tmp4_);
10575
stmt = (_tmp6_ = _tmp5_, _vala_source_reference_unref0 (_tmp4_), _tmp6_);
10607
_tmp6_ = _tmp5_;
10608
_vala_source_reference_unref0 (_tmp4_);
10609
stmt = _tmp6_;
10576
10610
vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_BRACE, &_inner_error_);
10577
10611
if (_inner_error_ != NULL) {
10578
10612
if (_inner_error_->domain == VALA_PARSE_ERROR) {
10602
10636
_tmp8_ = vala_parser_get_src (self, &begin);
10603
10637
_tmp9_ = _tmp8_;
10604
10638
_tmp10_ = vala_switch_section_new (_tmp9_);
10605
section = (_tmp11_ = _tmp10_, _vala_source_reference_unref0 (_tmp9_), _tmp11_);
10639
_tmp11_ = _tmp10_;
10640
_vala_source_reference_unref0 (_tmp9_);
10641
section = _tmp11_;
10606
10642
{
10607
10643
gboolean _tmp12_;
10608
10644
_tmp12_ = TRUE;
10765
10801
ValaStatement* _tmp7_;
10766
10802
GError * _inner_error_ = NULL;
10767
10803
g_return_val_if_fail (self != NULL, NULL);
10768
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
10804
vala_parser_get_location (self, &_tmp0_);
10805
_tmp1_ = _tmp0_;
10769
10806
begin = _tmp1_;
10770
10807
vala_parser_expect (self, VALA_TOKEN_TYPE_WHILE, &_inner_error_);
10771
10808
if (_inner_error_ != NULL) {
10831
10868
_tmp4_ = vala_parser_get_src (self, &begin);
10832
10869
_tmp5_ = _tmp4_;
10833
10870
_tmp6_ = vala_while_statement_new (condition, body, _tmp5_);
10834
result = (_tmp7_ = (ValaStatement*) _tmp6_, _vala_source_reference_unref0 (_tmp5_), _tmp7_);
10871
_tmp7_ = (ValaStatement*) _tmp6_;
10872
_vala_source_reference_unref0 (_tmp5_);
10873
result = _tmp7_;
10835
10874
_vala_code_node_unref0 (body);
10836
10875
_vala_code_node_unref0 (condition);
10837
10876
return result;
10853
10892
ValaStatement* _tmp7_;
10854
10893
GError * _inner_error_ = NULL;
10855
10894
g_return_val_if_fail (self != NULL, NULL);
10856
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
10895
vala_parser_get_location (self, &_tmp0_);
10896
_tmp1_ = _tmp0_;
10857
10897
begin = _tmp1_;
10858
10898
vala_parser_expect (self, VALA_TOKEN_TYPE_DO, &_inner_error_);
10859
10899
if (_inner_error_ != NULL) {
10951
10991
_tmp4_ = vala_parser_get_src (self, &begin);
10952
10992
_tmp5_ = _tmp4_;
10953
10993
_tmp6_ = vala_do_statement_new (body, condition, _tmp5_);
10954
result = (_tmp7_ = (ValaStatement*) _tmp6_, _vala_source_reference_unref0 (_tmp5_), _tmp7_);
10994
_tmp7_ = (ValaStatement*) _tmp6_;
10995
_vala_source_reference_unref0 (_tmp5_);
10996
result = _tmp7_;
10955
10997
_vala_code_node_unref0 (condition);
10956
10998
_vala_code_node_unref0 (body);
10957
10999
return result;
10968
11010
ValaArrayList* initializer_list;
10969
11011
gboolean _tmp3_;
10970
11012
ValaExpression* condition;
10971
ValaTokenType _tmp16_;
10972
ValaArrayList* _tmp20_ = NULL;
11013
ValaTokenType _tmp15_;
11014
ValaArrayList* _tmp18_ = NULL;
10973
11015
ValaArrayList* iterator_list;
10974
ValaTokenType _tmp21_;
10975
ValaSourceReference* _tmp27_ = NULL;
11016
ValaTokenType _tmp19_;
11017
ValaSourceReference* _tmp25_ = NULL;
10976
11018
ValaSourceReference* src;
10977
ValaBlock* _tmp28_ = NULL;
11019
ValaBlock* _tmp26_ = NULL;
10978
11020
ValaBlock* body;
10979
ValaForStatement* _tmp29_ = NULL;
11021
ValaForStatement* _tmp27_ = NULL;
10980
11022
ValaForStatement* stmt;
10981
11023
GError * _inner_error_ = NULL;
10982
11024
g_return_val_if_fail (self != NULL, NULL);
10983
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
11025
vala_parser_get_location (self, &_tmp0_);
11026
_tmp1_ = _tmp0_;
10984
11027
begin = _tmp1_;
10985
11028
block = NULL;
10986
11029
vala_parser_expect (self, VALA_TOKEN_TYPE_FOR, &_inner_error_);
11108
11151
ValaSourceReference* _tmp12_ = NULL;
11109
11152
ValaSourceReference* _tmp13_;
11110
11153
ValaBlock* _tmp14_ = NULL;
11111
ValaBlock* _tmp15_;
11112
11154
_tmp12_ = vala_parser_get_src (self, &begin);
11113
11155
_tmp13_ = _tmp12_;
11114
11156
_tmp14_ = vala_block_new (_tmp13_);
11115
_tmp15_ = _tmp14_;
11116
11157
_vala_code_node_unref0 (block);
11117
block = _tmp15_;
11158
block = _tmp14_;
11118
11159
_vala_source_reference_unref0 (_tmp13_);
11119
11160
vala_parser_parse_local_variable_declarations (self, block, &_inner_error_);
11120
11161
if (_inner_error_ != NULL) {
11134
11175
}
11135
11176
}
11136
11177
condition = NULL;
11137
_tmp16_ = vala_parser_current (self);
11138
if (_tmp16_ != VALA_TOKEN_TYPE_SEMICOLON) {
11139
ValaExpression* _tmp17_ = NULL;
11140
ValaExpression* _tmp18_;
11141
ValaExpression* _tmp19_;
11142
_tmp17_ = vala_parser_parse_expression (self, &_inner_error_);
11143
_tmp18_ = _tmp17_;
11178
_tmp15_ = vala_parser_current (self);
11179
if (_tmp15_ != VALA_TOKEN_TYPE_SEMICOLON) {
11180
ValaExpression* _tmp16_ = NULL;
11181
ValaExpression* _tmp17_;
11182
_tmp16_ = vala_parser_parse_expression (self, &_inner_error_);
11183
_tmp17_ = _tmp16_;
11144
11184
if (_inner_error_ != NULL) {
11145
11185
if (_inner_error_->domain == VALA_PARSE_ERROR) {
11146
11186
g_propagate_error (error, _inner_error_);
11157
11197
return NULL;
11158
11198
}
11159
11199
}
11160
_tmp19_ = _tmp18_;
11161
11200
_vala_code_node_unref0 (condition);
11162
condition = _tmp19_;
11201
condition = _tmp17_;
11163
11202
}
11164
11203
vala_parser_expect (self, VALA_TOKEN_TYPE_SEMICOLON, &_inner_error_);
11165
11204
if (_inner_error_ != NULL) {
11178
11217
return NULL;
11179
11218
}
11180
11219
}
11181
_tmp20_ = vala_array_list_new (VALA_TYPE_EXPRESSION, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
11182
iterator_list = _tmp20_;
11183
_tmp21_ = vala_parser_current (self);
11184
if (_tmp21_ != VALA_TOKEN_TYPE_CLOSE_PARENS) {
11220
_tmp18_ = vala_array_list_new (VALA_TYPE_EXPRESSION, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
11221
iterator_list = _tmp18_;
11222
_tmp19_ = vala_parser_current (self);
11223
if (_tmp19_ != VALA_TOKEN_TYPE_CLOSE_PARENS) {
11185
11224
{
11186
gboolean _tmp22_;
11187
_tmp22_ = TRUE;
11225
gboolean _tmp20_;
11226
_tmp20_ = TRUE;
11188
11227
while (TRUE) {
11189
ValaExpression* _tmp24_ = NULL;
11190
ValaExpression* _tmp25_;
11191
ValaExpression* _tmp26_;
11192
if (!_tmp22_) {
11193
gboolean _tmp23_;
11194
_tmp23_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
11195
if (!_tmp23_) {
11228
ValaExpression* _tmp22_ = NULL;
11229
ValaExpression* _tmp23_;
11230
ValaExpression* _tmp24_;
11231
if (!_tmp20_) {
11232
gboolean _tmp21_;
11233
_tmp21_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
11234
if (!_tmp21_) {
11196
11235
break;
11197
11236
}
11198
11237
}
11199
_tmp22_ = FALSE;
11200
_tmp24_ = vala_parser_parse_statement_expression (self, &_inner_error_);
11201
_tmp25_ = _tmp24_;
11238
_tmp20_ = FALSE;
11239
_tmp22_ = vala_parser_parse_statement_expression (self, &_inner_error_);
11240
_tmp23_ = _tmp22_;
11202
11241
if (_inner_error_ != NULL) {
11203
11242
if (_inner_error_->domain == VALA_PARSE_ERROR) {
11204
11243
g_propagate_error (error, _inner_error_);
11217
11256
return NULL;
11218
11257
}
11219
11258
}
11220
_tmp26_ = _tmp25_;
11221
vala_collection_add ((ValaCollection*) iterator_list, _tmp26_);
11222
_vala_code_node_unref0 (_tmp26_);
11259
_tmp24_ = _tmp23_;
11260
vala_collection_add ((ValaCollection*) iterator_list, _tmp24_);
11261
_vala_code_node_unref0 (_tmp24_);
11223
11262
}
11224
11263
}
11225
11264
}
11242
11281
return NULL;
11243
11282
}
11244
11283
}
11245
_tmp27_ = vala_parser_get_src (self, &begin);
11246
src = _tmp27_;
11247
_tmp28_ = vala_parser_parse_embedded_statement (self, &_inner_error_);
11248
body = _tmp28_;
11284
_tmp25_ = vala_parser_get_src (self, &begin);
11285
src = _tmp25_;
11286
_tmp26_ = vala_parser_parse_embedded_statement (self, &_inner_error_);
11287
body = _tmp26_;
11249
11288
if (_inner_error_ != NULL) {
11250
11289
if (_inner_error_->domain == VALA_PARSE_ERROR) {
11251
11290
g_propagate_error (error, _inner_error_);
11266
11305
return NULL;
11267
11306
}
11268
11307
}
11269
_tmp29_ = vala_for_statement_new (condition, body, src);
11270
stmt = _tmp29_;
11308
_tmp27_ = vala_for_statement_new (condition, body, src);
11309
stmt = _tmp27_;
11271
11310
{
11272
ValaArrayList* _tmp30_;
11311
ValaArrayList* _tmp28_;
11273
11312
ValaArrayList* _init_list;
11274
gint _tmp31_;
11313
gint _tmp29_;
11275
11314
gint _init_size;
11276
11315
gint _init_index;
11277
_tmp30_ = _vala_iterable_ref0 (initializer_list);
11278
_init_list = _tmp30_;
11279
_tmp31_ = vala_collection_get_size ((ValaCollection*) _init_list);
11280
_init_size = _tmp31_;
11316
_tmp28_ = _vala_iterable_ref0 (initializer_list);
11317
_init_list = _tmp28_;
11318
_tmp29_ = vala_collection_get_size ((ValaCollection*) _init_list);
11319
_init_size = _tmp29_;
11281
11320
_init_index = -1;
11282
11321
while (TRUE) {
11283
gpointer _tmp32_ = NULL;
11322
gpointer _tmp30_ = NULL;
11284
11323
ValaExpression* init;
11285
11324
_init_index = _init_index + 1;
11286
11325
if (!(_init_index < _init_size)) {
11287
11326
break;
11288
11327
}
11289
_tmp32_ = vala_list_get ((ValaList*) _init_list, _init_index);
11290
init = (ValaExpression*) _tmp32_;
11328
_tmp30_ = vala_list_get ((ValaList*) _init_list, _init_index);
11329
init = (ValaExpression*) _tmp30_;
11291
11330
vala_for_statement_add_initializer (stmt, init);
11292
11331
_vala_code_node_unref0 (init);
11293
11332
}
11294
11333
_vala_iterable_unref0 (_init_list);
11295
11334
}
11296
11335
{
11297
ValaArrayList* _tmp33_;
11336
ValaArrayList* _tmp31_;
11298
11337
ValaArrayList* _iter_list;
11299
gint _tmp34_;
11338
gint _tmp32_;
11300
11339
gint _iter_size;
11301
11340
gint _iter_index;
11302
_tmp33_ = _vala_iterable_ref0 (iterator_list);
11303
_iter_list = _tmp33_;
11304
_tmp34_ = vala_collection_get_size ((ValaCollection*) _iter_list);
11305
_iter_size = _tmp34_;
11341
_tmp31_ = _vala_iterable_ref0 (iterator_list);
11342
_iter_list = _tmp31_;
11343
_tmp32_ = vala_collection_get_size ((ValaCollection*) _iter_list);
11344
_iter_size = _tmp32_;
11306
11345
_iter_index = -1;
11307
11346
while (TRUE) {
11308
gpointer _tmp35_ = NULL;
11347
gpointer _tmp33_ = NULL;
11309
11348
ValaExpression* iter;
11310
11349
_iter_index = _iter_index + 1;
11311
11350
if (!(_iter_index < _iter_size)) {
11312
11351
break;
11313
11352
}
11314
_tmp35_ = vala_list_get ((ValaList*) _iter_list, _iter_index);
11315
iter = (ValaExpression*) _tmp35_;
11353
_tmp33_ = vala_list_get ((ValaList*) _iter_list, _iter_index);
11354
iter = (ValaExpression*) _tmp33_;
11316
11355
vala_for_statement_add_iterator (stmt, iter);
11317
11356
_vala_code_node_unref0 (iter);
11318
11357
}
11355
11394
ValaSourceLocation begin;
11356
11395
ValaDataType* type;
11357
11396
gboolean _tmp2_;
11358
gchar* _tmp9_ = NULL;
11397
gchar* _tmp8_ = NULL;
11359
11398
gchar* id;
11360
ValaExpression* _tmp10_ = NULL;
11399
ValaExpression* _tmp9_ = NULL;
11361
11400
ValaExpression* collection;
11362
ValaSourceReference* _tmp11_ = NULL;
11401
ValaSourceReference* _tmp10_ = NULL;
11363
11402
ValaSourceReference* src;
11364
ValaBlock* _tmp12_ = NULL;
11403
ValaBlock* _tmp11_ = NULL;
11365
11404
ValaBlock* body;
11366
ValaForeachStatement* _tmp13_ = NULL;
11405
ValaForeachStatement* _tmp12_ = NULL;
11367
11406
GError * _inner_error_ = NULL;
11368
11407
g_return_val_if_fail (self != NULL, NULL);
11369
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
11408
vala_parser_get_location (self, &_tmp0_);
11409
_tmp1_ = _tmp0_;
11370
11410
begin = _tmp1_;
11371
11411
vala_parser_expect (self, VALA_TOKEN_TYPE_FOREACH, &_inner_error_);
11372
11412
if (_inner_error_ != NULL) {
11395
11435
if (!_tmp2_) {
11396
11436
ValaDataType* _tmp3_ = NULL;
11397
11437
ValaDataType* _tmp4_;
11398
ValaDataType* _tmp5_;
11399
gboolean _tmp6_;
11438
gboolean _tmp5_;
11400
11439
_tmp3_ = vala_parser_parse_type (self, TRUE, TRUE, &_inner_error_);
11401
11440
_tmp4_ = _tmp3_;
11402
11441
if (_inner_error_ != NULL) {
11411
11450
return NULL;
11412
11451
}
11413
11452
}
11414
_tmp5_ = _tmp4_;
11415
11453
_vala_code_node_unref0 (type);
11416
type = _tmp5_;
11417
_tmp6_ = vala_parser_accept (self, VALA_TOKEN_TYPE_IN);
11418
if (_tmp6_) {
11419
ValaSourceReference* _tmp7_ = NULL;
11420
GError* _tmp8_ = NULL;
11421
_tmp7_ = vala_code_node_get_source_reference ((ValaCodeNode*) type);
11422
vala_report_error (_tmp7_, "syntax error, expected var or type");
11423
_tmp8_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, "expected var or type");
11424
_inner_error_ = _tmp8_;
11454
type = _tmp4_;
11455
_tmp5_ = vala_parser_accept (self, VALA_TOKEN_TYPE_IN);
11456
if (_tmp5_) {
11457
ValaSourceReference* _tmp6_ = NULL;
11458
GError* _tmp7_ = NULL;
11459
_tmp6_ = vala_code_node_get_source_reference ((ValaCodeNode*) type);
11460
vala_report_error (_tmp6_, "syntax error, expected var or type");
11461
_tmp7_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, "expected var or type");
11462
_inner_error_ = _tmp7_;
11425
11463
if (_inner_error_->domain == VALA_PARSE_ERROR) {
11426
11464
g_propagate_error (error, _inner_error_);
11427
11465
_vala_code_node_unref0 (type);
11434
11472
}
11435
11473
}
11436
11474
}
11437
_tmp9_ = vala_parser_parse_identifier (self, &_inner_error_);
11438
id = _tmp9_;
11475
_tmp8_ = vala_parser_parse_identifier (self, &_inner_error_);
11476
id = _tmp8_;
11439
11477
if (_inner_error_ != NULL) {
11440
11478
if (_inner_error_->domain == VALA_PARSE_ERROR) {
11441
11479
g_propagate_error (error, _inner_error_);
11463
11501
return NULL;
11464
11502
}
11465
11503
}
11466
_tmp10_ = vala_parser_parse_expression (self, &_inner_error_);
11467
collection = _tmp10_;
11504
_tmp9_ = vala_parser_parse_expression (self, &_inner_error_);
11505
collection = _tmp9_;
11468
11506
if (_inner_error_ != NULL) {
11469
11507
if (_inner_error_->domain == VALA_PARSE_ERROR) {
11470
11508
g_propagate_error (error, _inner_error_);
11496
11534
return NULL;
11497
11535
}
11498
11536
}
11499
_tmp11_ = vala_parser_get_src (self, &begin);
11500
src = _tmp11_;
11501
_tmp12_ = vala_parser_parse_embedded_statement (self, &_inner_error_);
11502
body = _tmp12_;
11537
_tmp10_ = vala_parser_get_src (self, &begin);
11538
src = _tmp10_;
11539
_tmp11_ = vala_parser_parse_embedded_statement (self, &_inner_error_);
11540
body = _tmp11_;
11503
11541
if (_inner_error_ != NULL) {
11504
11542
if (_inner_error_->domain == VALA_PARSE_ERROR) {
11505
11543
g_propagate_error (error, _inner_error_);
11518
11556
return NULL;
11519
11557
}
11520
11558
}
11521
_tmp13_ = vala_foreach_statement_new (type, id, collection, body, src);
11522
result = (ValaStatement*) _tmp13_;
11559
_tmp12_ = vala_foreach_statement_new (type, id, collection, body, src);
11560
result = (ValaStatement*) _tmp12_;
11523
11561
_vala_code_node_unref0 (body);
11524
11562
_vala_source_reference_unref0 (src);
11525
11563
_vala_code_node_unref0 (collection);
11540
11578
ValaStatement* _tmp5_;
11541
11579
GError * _inner_error_ = NULL;
11542
11580
g_return_val_if_fail (self != NULL, NULL);
11543
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
11581
vala_parser_get_location (self, &_tmp0_);
11582
_tmp1_ = _tmp0_;
11544
11583
begin = _tmp1_;
11545
11584
vala_parser_expect (self, VALA_TOKEN_TYPE_BREAK, &_inner_error_);
11546
11585
if (_inner_error_ != NULL) {
11567
11606
_tmp2_ = vala_parser_get_src (self, &begin);
11568
11607
_tmp3_ = _tmp2_;
11569
11608
_tmp4_ = vala_break_statement_new (_tmp3_);
11570
result = (_tmp5_ = (ValaStatement*) _tmp4_, _vala_source_reference_unref0 (_tmp3_), _tmp5_);
11609
_tmp5_ = (ValaStatement*) _tmp4_;
11610
_vala_source_reference_unref0 (_tmp3_);
11611
result = _tmp5_;
11571
11612
return result;
11572
11613
}
11573
11614
11583
11624
ValaStatement* _tmp5_;
11584
11625
GError * _inner_error_ = NULL;
11585
11626
g_return_val_if_fail (self != NULL, NULL);
11586
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
11627
vala_parser_get_location (self, &_tmp0_);
11628
_tmp1_ = _tmp0_;
11587
11629
begin = _tmp1_;
11588
11630
vala_parser_expect (self, VALA_TOKEN_TYPE_CONTINUE, &_inner_error_);
11589
11631
if (_inner_error_ != NULL) {
11610
11652
_tmp2_ = vala_parser_get_src (self, &begin);
11611
11653
_tmp3_ = _tmp2_;
11612
11654
_tmp4_ = vala_continue_statement_new (_tmp3_);
11613
result = (_tmp5_ = (ValaStatement*) _tmp4_, _vala_source_reference_unref0 (_tmp3_), _tmp5_);
11655
_tmp5_ = (ValaStatement*) _tmp4_;
11656
_vala_source_reference_unref0 (_tmp3_);
11657
result = _tmp5_;
11614
11658
return result;
11615
11659
}
11616
11660
11622
11666
ValaSourceLocation begin;
11623
11667
ValaExpression* expr;
11624
11668
ValaTokenType _tmp2_;
11625
ValaSourceReference* _tmp6_ = NULL;
11626
ValaSourceReference* _tmp7_;
11627
ValaReturnStatement* _tmp8_ = NULL;
11628
ValaStatement* _tmp9_;
11669
ValaSourceReference* _tmp5_ = NULL;
11670
ValaSourceReference* _tmp6_;
11671
ValaReturnStatement* _tmp7_ = NULL;
11672
ValaStatement* _tmp8_;
11629
11673
GError * _inner_error_ = NULL;
11630
11674
g_return_val_if_fail (self != NULL, NULL);
11631
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
11675
vala_parser_get_location (self, &_tmp0_);
11676
_tmp1_ = _tmp0_;
11632
11677
begin = _tmp1_;
11633
11678
vala_parser_expect (self, VALA_TOKEN_TYPE_RETURN, &_inner_error_);
11634
11679
if (_inner_error_ != NULL) {
11646
11691
if (_tmp2_ != VALA_TOKEN_TYPE_SEMICOLON) {
11647
11692
ValaExpression* _tmp3_ = NULL;
11648
11693
ValaExpression* _tmp4_;
11649
ValaExpression* _tmp5_;
11650
11694
_tmp3_ = vala_parser_parse_expression (self, &_inner_error_);
11651
11695
_tmp4_ = _tmp3_;
11652
11696
if (_inner_error_ != NULL) {
11661
11705
return NULL;
11662
11706
}
11663
11707
}
11664
_tmp5_ = _tmp4_;
11665
11708
_vala_code_node_unref0 (expr);
11666
expr = _tmp5_;
11709
expr = _tmp4_;
11667
11710
}
11668
11711
vala_parser_expect (self, VALA_TOKEN_TYPE_SEMICOLON, &_inner_error_);
11669
11712
if (_inner_error_ != NULL) {
11678
11721
return NULL;
11679
11722
}
11680
11723
}
11681
_tmp6_ = vala_parser_get_src (self, &begin);
11682
_tmp7_ = _tmp6_;
11683
_tmp8_ = vala_return_statement_new (expr, _tmp7_);
11684
result = (_tmp9_ = (ValaStatement*) _tmp8_, _vala_source_reference_unref0 (_tmp7_), _tmp9_);
11724
_tmp5_ = vala_parser_get_src (self, &begin);
11725
_tmp6_ = _tmp5_;
11726
_tmp7_ = vala_return_statement_new (expr, _tmp6_);
11727
_tmp8_ = (ValaStatement*) _tmp7_;
11728
_vala_source_reference_unref0 (_tmp6_);
11729
result = _tmp8_;
11685
11730
_vala_code_node_unref0 (expr);
11686
11731
return result;
11687
11732
}
11696
11741
ValaTokenType _tmp3_;
11697
11742
ValaExpression* expr;
11698
11743
gboolean _tmp7_;
11699
ValaSourceReference* _tmp11_ = NULL;
11700
ValaSourceReference* _tmp12_;
11701
ValaYieldStatement* _tmp13_ = NULL;
11702
ValaStatement* _tmp14_;
11744
ValaSourceReference* _tmp10_ = NULL;
11745
ValaSourceReference* _tmp11_;
11746
ValaYieldStatement* _tmp12_ = NULL;
11747
ValaStatement* _tmp13_;
11703
11748
GError * _inner_error_ = NULL;
11704
11749
g_return_val_if_fail (self != NULL, NULL);
11705
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
11750
vala_parser_get_location (self, &_tmp0_);
11751
_tmp1_ = _tmp0_;
11706
11752
begin = _tmp1_;
11707
11753
vala_parser_expect (self, VALA_TOKEN_TYPE_YIELD, &_inner_error_);
11708
11754
if (_inner_error_ != NULL) {
11747
11793
if (_tmp7_) {
11748
11794
ValaExpression* _tmp8_ = NULL;
11749
11795
ValaExpression* _tmp9_;
11750
ValaExpression* _tmp10_;
11751
11796
_tmp8_ = vala_parser_parse_expression (self, &_inner_error_);
11752
11797
_tmp9_ = _tmp8_;
11753
11798
if (_inner_error_ != NULL) {
11762
11807
return NULL;
11763
11808
}
11764
11809
}
11765
_tmp10_ = _tmp9_;
11766
11810
_vala_code_node_unref0 (expr);
11767
expr = _tmp10_;
11811
expr = _tmp9_;
11768
11812
}
11769
11813
vala_parser_expect (self, VALA_TOKEN_TYPE_SEMICOLON, &_inner_error_);
11770
11814
if (_inner_error_ != NULL) {
11779
11823
return NULL;
11780
11824
}
11781
11825
}
11782
_tmp11_ = vala_parser_get_src (self, &begin);
11783
_tmp12_ = _tmp11_;
11784
_tmp13_ = vala_yield_statement_new (expr, _tmp12_);
11785
result = (_tmp14_ = (ValaStatement*) _tmp13_, _vala_source_reference_unref0 (_tmp12_), _tmp14_);
11826
_tmp10_ = vala_parser_get_src (self, &begin);
11827
_tmp11_ = _tmp10_;
11828
_tmp12_ = vala_yield_statement_new (expr, _tmp11_);
11829
_tmp13_ = (ValaStatement*) _tmp12_;
11830
_vala_source_reference_unref0 (_tmp11_);
11831
result = _tmp13_;
11786
11832
_vala_code_node_unref0 (expr);
11787
11833
return result;
11788
11834
}
11801
11847
ValaStatement* _tmp6_;
11802
11848
GError * _inner_error_ = NULL;
11803
11849
g_return_val_if_fail (self != NULL, NULL);
11804
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
11850
vala_parser_get_location (self, &_tmp0_);
11851
_tmp1_ = _tmp0_;
11805
11852
begin = _tmp1_;
11806
11853
vala_parser_expect (self, VALA_TOKEN_TYPE_THROW, &_inner_error_);
11807
11854
if (_inner_error_ != NULL) {
11842
11889
_tmp3_ = vala_parser_get_src (self, &begin);
11843
11890
_tmp4_ = _tmp3_;
11844
11891
_tmp5_ = vala_throw_statement_new (expr, _tmp4_);
11845
result = (_tmp6_ = (ValaStatement*) _tmp5_, _vala_source_reference_unref0 (_tmp4_), _tmp6_);
11892
_tmp6_ = (ValaStatement*) _tmp5_;
11893
_vala_source_reference_unref0 (_tmp4_);
11894
result = _tmp6_;
11846
11895
_vala_code_node_unref0 (expr);
11847
11896
return result;
11848
11897
}
11859
11908
ValaArrayList* _tmp3_ = NULL;
11860
11909
ValaArrayList* catch_clauses;
11861
11910
ValaTokenType _tmp4_;
11862
ValaSourceReference* _tmp12_ = NULL;
11863
ValaSourceReference* _tmp13_;
11864
ValaTryStatement* _tmp14_ = NULL;
11865
ValaTryStatement* _tmp15_;
11911
ValaSourceReference* _tmp10_ = NULL;
11912
ValaSourceReference* _tmp11_;
11913
ValaTryStatement* _tmp12_ = NULL;
11914
ValaTryStatement* _tmp13_;
11866
11915
ValaTryStatement* stmt;
11867
11916
GError * _inner_error_ = NULL;
11868
11917
g_return_val_if_fail (self != NULL, NULL);
11869
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
11918
vala_parser_get_location (self, &_tmp0_);
11919
_tmp1_ = _tmp0_;
11870
11920
begin = _tmp1_;
11871
11921
vala_parser_expect (self, VALA_TOKEN_TYPE_TRY, &_inner_error_);
11872
11922
if (_inner_error_ != NULL) {
11918
11968
if (_tmp5_ == VALA_TOKEN_TYPE_FINALLY) {
11919
11969
ValaBlock* _tmp6_ = NULL;
11920
11970
ValaBlock* _tmp7_;
11921
ValaBlock* _tmp8_;
11922
11971
_tmp6_ = vala_parser_parse_finally_clause (self, &_inner_error_);
11923
11972
_tmp7_ = _tmp6_;
11924
11973
if (_inner_error_ != NULL) {
11937
11986
return NULL;
11938
11987
}
11939
11988
}
11940
_tmp8_ = _tmp7_;
11941
11989
_vala_code_node_unref0 (finally_clause);
11942
finally_clause = _tmp8_;
11990
finally_clause = _tmp7_;
11943
11991
}
11944
11992
} else {
11945
ValaBlock* _tmp9_ = NULL;
11946
ValaBlock* _tmp10_;
11947
ValaBlock* _tmp11_;
11948
_tmp9_ = vala_parser_parse_finally_clause (self, &_inner_error_);
11949
_tmp10_ = _tmp9_;
11993
ValaBlock* _tmp8_ = NULL;
11994
ValaBlock* _tmp9_;
11995
_tmp8_ = vala_parser_parse_finally_clause (self, &_inner_error_);
11996
_tmp9_ = _tmp8_;
11950
11997
if (_inner_error_ != NULL) {
11951
11998
if (_inner_error_->domain == VALA_PARSE_ERROR) {
11952
11999
g_propagate_error (error, _inner_error_);
11963
12010
return NULL;
11964
12011
}
11965
12012
}
11966
_tmp11_ = _tmp10_;
11967
12013
_vala_code_node_unref0 (finally_clause);
11968
finally_clause = _tmp11_;
12014
finally_clause = _tmp9_;
11969
12015
}
11970
_tmp12_ = vala_parser_get_src (self, &begin);
12016
_tmp10_ = vala_parser_get_src (self, &begin);
12017
_tmp11_ = _tmp10_;
12018
_tmp12_ = vala_try_statement_new (try_block, finally_clause, _tmp11_);
11971
12019
_tmp13_ = _tmp12_;
11972
_tmp14_ = vala_try_statement_new (try_block, finally_clause, _tmp13_);
11973
stmt = (_tmp15_ = _tmp14_, _vala_source_reference_unref0 (_tmp13_), _tmp15_);
12020
_vala_source_reference_unref0 (_tmp11_);
12021
stmt = _tmp13_;
11974
12022
{
11975
ValaArrayList* _tmp16_;
12023
ValaArrayList* _tmp14_;
11976
12024
ValaArrayList* _clause_list;
11977
gint _tmp17_;
12025
gint _tmp15_;
11978
12026
gint _clause_size;
11979
12027
gint _clause_index;
11980
_tmp16_ = _vala_iterable_ref0 (catch_clauses);
11981
_clause_list = _tmp16_;
11982
_tmp17_ = vala_collection_get_size ((ValaCollection*) _clause_list);
11983
_clause_size = _tmp17_;
12028
_tmp14_ = _vala_iterable_ref0 (catch_clauses);
12029
_clause_list = _tmp14_;
12030
_tmp15_ = vala_collection_get_size ((ValaCollection*) _clause_list);
12031
_clause_size = _tmp15_;
11984
12032
_clause_index = -1;
11985
12033
while (TRUE) {
11986
gpointer _tmp18_ = NULL;
12034
gpointer _tmp16_ = NULL;
11987
12035
ValaCatchClause* clause;
11988
12036
_clause_index = _clause_index + 1;
11989
12037
if (!(_clause_index < _clause_size)) {
11990
12038
break;
11991
12039
}
11992
_tmp18_ = vala_list_get ((ValaList*) _clause_list, _clause_index);
11993
clause = (ValaCatchClause*) _tmp18_;
12040
_tmp16_ = vala_list_get ((ValaList*) _clause_list, _clause_index);
12041
clause = (ValaCatchClause*) _tmp16_;
11994
12042
vala_try_statement_add_catch_clause (stmt, clause);
11995
12043
_vala_code_node_unref0 (clause);
11996
12044
}
12016
12064
ValaDataType* type;
12017
12065
gchar* id;
12018
12066
gboolean _tmp3_;
12019
ValaBlock* _tmp10_ = NULL;
12067
ValaBlock* _tmp8_ = NULL;
12020
12068
ValaBlock* block;
12021
ValaSourceReference* _tmp11_ = NULL;
12022
ValaSourceReference* _tmp12_;
12023
ValaCatchClause* _tmp13_ = NULL;
12024
ValaCatchClause* _tmp14_;
12069
ValaSourceReference* _tmp9_ = NULL;
12070
ValaSourceReference* _tmp10_;
12071
ValaCatchClause* _tmp11_ = NULL;
12072
ValaCatchClause* _tmp12_;
12025
12073
_tmp0_ = vala_parser_accept (self, VALA_TOKEN_TYPE_CATCH);
12026
12074
if (!_tmp0_) {
12027
12075
break;
12028
12076
}
12029
_tmp2_ = (vala_parser_get_location (self, &_tmp1_), _tmp1_);
12077
vala_parser_get_location (self, &_tmp1_);
12078
_tmp2_ = _tmp1_;
12030
12079
begin = _tmp2_;
12031
12080
type = NULL;
12032
12081
id = NULL;
12034
12083
if (_tmp3_) {
12035
12084
ValaDataType* _tmp4_ = NULL;
12036
12085
ValaDataType* _tmp5_;
12037
ValaDataType* _tmp6_;
12038
gchar* _tmp7_ = NULL;
12039
gchar* _tmp8_;
12040
gchar* _tmp9_;
12086
gchar* _tmp6_ = NULL;
12087
gchar* _tmp7_;
12041
12088
_tmp4_ = vala_parser_parse_type (self, TRUE, TRUE, &_inner_error_);
12042
12089
_tmp5_ = _tmp4_;
12043
12090
if (_inner_error_ != NULL) {
12054
12101
return;
12055
12102
}
12056
12103
}
12057
_tmp6_ = _tmp5_;
12058
12104
_vala_code_node_unref0 (type);
12059
type = _tmp6_;
12060
_tmp7_ = vala_parser_parse_identifier (self, &_inner_error_);
12061
_tmp8_ = _tmp7_;
12105
type = _tmp5_;
12106
_tmp6_ = vala_parser_parse_identifier (self, &_inner_error_);
12107
_tmp7_ = _tmp6_;
12062
12108
if (_inner_error_ != NULL) {
12063
12109
if (_inner_error_->domain == VALA_PARSE_ERROR) {
12064
12110
g_propagate_error (error, _inner_error_);
12073
12119
return;
12074
12120
}
12075
12121
}
12076
_tmp9_ = _tmp8_;
12077
12122
_g_free0 (id);
12078
id = _tmp9_;
12123
id = _tmp7_;
12079
12124
vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_PARENS, &_inner_error_);
12080
12125
if (_inner_error_ != NULL) {
12081
12126
if (_inner_error_->domain == VALA_PARSE_ERROR) {
12092
12137
}
12093
12138
}
12094
12139
}
12095
_tmp10_ = vala_parser_parse_block (self, &_inner_error_);
12096
block = _tmp10_;
12140
_tmp8_ = vala_parser_parse_block (self, &_inner_error_);
12141
block = _tmp8_;
12097
12142
if (_inner_error_ != NULL) {
12098
12143
if (_inner_error_->domain == VALA_PARSE_ERROR) {
12099
12144
g_propagate_error (error, _inner_error_);
12108
12153
return;
12109
12154
}
12110
12155
}
12111
_tmp11_ = vala_parser_get_src (self, &begin);
12156
_tmp9_ = vala_parser_get_src (self, &begin);
12157
_tmp10_ = _tmp9_;
12158
_tmp11_ = vala_catch_clause_new (type, id, block, _tmp10_);
12112
12159
_tmp12_ = _tmp11_;
12113
_tmp13_ = vala_catch_clause_new (type, id, block, _tmp12_);
12114
_tmp14_ = _tmp13_;
12115
vala_collection_add ((ValaCollection*) catch_clauses, _tmp14_);
12116
_vala_code_node_unref0 (_tmp14_);
12117
_vala_source_reference_unref0 (_tmp12_);
12160
vala_collection_add ((ValaCollection*) catch_clauses, _tmp12_);
12161
_vala_code_node_unref0 (_tmp12_);
12162
_vala_source_reference_unref0 (_tmp10_);
12118
12163
_vala_code_node_unref0 (block);
12119
12164
_g_free0 (id);
12120
12165
_vala_code_node_unref0 (type);
12171
12216
ValaStatement* _tmp7_;
12172
12217
GError * _inner_error_ = NULL;
12173
12218
g_return_val_if_fail (self != NULL, NULL);
12174
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
12219
vala_parser_get_location (self, &_tmp0_);
12220
_tmp1_ = _tmp0_;
12175
12221
begin = _tmp1_;
12176
12222
vala_parser_expect (self, VALA_TOKEN_TYPE_LOCK, &_inner_error_);
12177
12223
if (_inner_error_ != NULL) {
12237
12283
_tmp4_ = vala_parser_get_src (self, &begin);
12238
12284
_tmp5_ = _tmp4_;
12239
12285
_tmp6_ = vala_lock_statement_new (expr, stmt, _tmp5_);
12240
result = (_tmp7_ = (ValaStatement*) _tmp6_, _vala_source_reference_unref0 (_tmp5_), _tmp7_);
12286
_tmp7_ = (ValaStatement*) _tmp6_;
12287
_vala_source_reference_unref0 (_tmp5_);
12288
result = _tmp7_;
12241
12289
_vala_code_node_unref0 (stmt);
12242
12290
_vala_code_node_unref0 (expr);
12243
12291
return result;
12257
12305
ValaStatement* _tmp6_;
12258
12306
GError * _inner_error_ = NULL;
12259
12307
g_return_val_if_fail (self != NULL, NULL);
12260
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
12308
vala_parser_get_location (self, &_tmp0_);
12309
_tmp1_ = _tmp0_;
12261
12310
begin = _tmp1_;
12262
12311
vala_parser_expect (self, VALA_TOKEN_TYPE_DELETE, &_inner_error_);
12263
12312
if (_inner_error_ != NULL) {
12298
12347
_tmp3_ = vala_parser_get_src (self, &begin);
12299
12348
_tmp4_ = _tmp3_;
12300
12349
_tmp5_ = vala_delete_statement_new (expr, _tmp4_);
12301
result = (_tmp6_ = (ValaStatement*) _tmp5_, _vala_source_reference_unref0 (_tmp4_), _tmp6_);
12350
_tmp6_ = (ValaStatement*) _tmp5_;
12351
_vala_source_reference_unref0 (_tmp4_);
12352
result = _tmp6_;
12302
12353
_vala_code_node_unref0 (expr);
12303
12354
return result;
12304
12355
}
12336
12387
gchar* _tmp3_ = NULL;
12337
12388
gchar* _tmp4_;
12338
12389
gchar* _tmp5_;
12390
gchar* _tmp6_;
12339
12391
vala_parser_next (self);
12340
12392
_tmp3_ = vala_parser_get_last_string (self);
12341
12393
_tmp4_ = _tmp3_;
12342
result = (_tmp5_ = g_strconcat ("-", _tmp4_, NULL), _g_free0 (_tmp4_), _tmp5_);
12394
_tmp5_ = g_strconcat ("-", _tmp4_, NULL);
12395
_tmp6_ = _tmp5_;
12396
_g_free0 (_tmp4_);
12397
result = _tmp6_;
12343
12398
return result;
12344
12399
}
12345
12400
default:
12346
12401
{
12347
gchar* _tmp6_ = NULL;
12348
gchar* _tmp7_;
12349
GError* _tmp8_ = NULL;
12350
GError* _tmp9_;
12351
_tmp6_ = vala_parser_get_error (self, "expected number");
12352
_tmp7_ = _tmp6_;
12353
_tmp8_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp7_);
12354
_inner_error_ = (_tmp9_ = _tmp8_, _g_free0 (_tmp7_), _tmp9_);
12402
gchar* _tmp7_ = NULL;
12403
gchar* _tmp8_;
12404
GError* _tmp9_ = NULL;
12405
GError* _tmp10_;
12406
_tmp7_ = vala_parser_get_error (self, "expected number");
12407
_tmp8_ = _tmp7_;
12408
_tmp9_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp8_);
12409
_tmp10_ = _tmp9_;
12410
_g_free0 (_tmp8_);
12411
_inner_error_ = _tmp10_;
12355
12412
if (_inner_error_->domain == VALA_PARSE_ERROR) {
12356
12413
g_propagate_error (error, _inner_error_);
12357
12414
return NULL;
12365
12422
}
12366
12423
default:
12367
12424
{
12368
gchar* _tmp10_ = NULL;
12369
gchar* _tmp11_;
12370
GError* _tmp12_ = NULL;
12371
GError* _tmp13_;
12372
_tmp10_ = vala_parser_get_error (self, "expected literal");
12373
_tmp11_ = _tmp10_;
12374
_tmp12_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp11_);
12375
_inner_error_ = (_tmp13_ = _tmp12_, _g_free0 (_tmp11_), _tmp13_);
12425
gchar* _tmp11_ = NULL;
12426
gchar* _tmp12_;
12427
GError* _tmp13_ = NULL;
12428
GError* _tmp14_;
12429
_tmp11_ = vala_parser_get_error (self, "expected literal");
12430
_tmp12_ = _tmp11_;
12431
_tmp13_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp12_);
12432
_tmp14_ = _tmp13_;
12433
_g_free0 (_tmp12_);
12434
_inner_error_ = _tmp14_;
12376
12435
if (_inner_error_->domain == VALA_PARSE_ERROR) {
12377
12436
g_propagate_error (error, _inner_error_);
12378
12437
return NULL;
12429
12488
}
12430
12489
}
12431
12490
_tmp3_ = FALSE;
12432
_tmp6_ = (vala_parser_get_location (self, &_tmp5_), _tmp5_);
12491
vala_parser_get_location (self, &_tmp5_);
12492
_tmp6_ = _tmp5_;
12433
12493
begin = _tmp6_;
12434
12494
_tmp7_ = vala_parser_parse_identifier (self, &_inner_error_);
12435
12495
id = _tmp7_;
12448
12508
_tmp8_ = vala_parser_get_src (self, &begin);
12449
12509
_tmp9_ = _tmp8_;
12450
12510
_tmp10_ = vala_attribute_new (id, _tmp9_);
12451
attr = (_tmp11_ = _tmp10_, _vala_source_reference_unref0 (_tmp9_), _tmp11_);
12511
_tmp11_ = _tmp10_;
12512
_vala_source_reference_unref0 (_tmp9_);
12513
attr = _tmp11_;
12452
12514
_tmp12_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OPEN_PARENS);
12453
12515
if (_tmp12_) {
12454
12516
ValaTokenType _tmp13_;
12460
12522
while (TRUE) {
12461
12523
gchar* _tmp16_ = NULL;
12462
12524
gchar* _tmp17_;
12463
gchar* _tmp18_;
12464
gchar* _tmp19_ = NULL;
12525
gchar* _tmp18_ = NULL;
12526
gchar* _tmp19_;
12465
12527
gchar* _tmp20_;
12466
gchar* _tmp21_;
12467
12528
if (!_tmp14_) {
12468
12529
gboolean _tmp15_;
12469
12530
_tmp15_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
12490
12551
return NULL;
12491
12552
}
12492
12553
}
12493
_tmp18_ = _tmp17_;
12494
12554
_g_free0 (id);
12495
id = _tmp18_;
12555
id = _tmp17_;
12496
12556
vala_parser_expect (self, VALA_TOKEN_TYPE_ASSIGN, &_inner_error_);
12497
12557
if (_inner_error_ != NULL) {
12498
12558
if (_inner_error_->domain == VALA_PARSE_ERROR) {
12510
12570
return NULL;
12511
12571
}
12512
12572
}
12513
_tmp19_ = vala_parser_parse_attribute_value (self, &_inner_error_);
12573
_tmp18_ = vala_parser_parse_attribute_value (self, &_inner_error_);
12574
_tmp19_ = _tmp18_;
12575
if (_inner_error_ != NULL) {
12576
if (_inner_error_->domain == VALA_PARSE_ERROR) {
12577
g_propagate_error (error, _inner_error_);
12578
_vala_code_node_unref0 (attr);
12579
_g_free0 (id);
12580
_vala_iterable_unref0 (attrs);
12581
return NULL;
12582
} else {
12583
_vala_code_node_unref0 (attr);
12584
_g_free0 (id);
12585
_vala_iterable_unref0 (attrs);
12586
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
12587
g_clear_error (&_inner_error_);
12588
return NULL;
12589
}
12590
}
12514
12591
_tmp20_ = _tmp19_;
12515
if (_inner_error_ != NULL) {
12516
if (_inner_error_->domain == VALA_PARSE_ERROR) {
12517
g_propagate_error (error, _inner_error_);
12518
_vala_code_node_unref0 (attr);
12519
_g_free0 (id);
12520
_vala_iterable_unref0 (attrs);
12521
return NULL;
12522
} else {
12523
_vala_code_node_unref0 (attr);
12524
_g_free0 (id);
12525
_vala_iterable_unref0 (attrs);
12526
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
12527
g_clear_error (&_inner_error_);
12528
return NULL;
12529
}
12530
}
12531
_tmp21_ = _tmp20_;
12532
vala_attribute_add_argument (attr, id, _tmp21_);
12533
_g_free0 (_tmp21_);
12592
vala_attribute_add_argument (attr, id, _tmp20_);
12593
_g_free0 (_tmp20_);
12534
12594
}
12535
12595
}
12536
12596
}
12643
12703
GError * _inner_error_ = NULL;
12644
12704
g_return_if_fail (self != NULL);
12645
12705
g_return_if_fail (parent != NULL);
12646
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
12706
vala_parser_get_location (self, &_tmp0_);
12707
_tmp1_ = _tmp0_;
12647
12708
begin = _tmp1_;
12648
12709
_tmp2_ = vala_void_type_new (NULL);
12649
12710
_tmp3_ = _tmp2_;
12650
12711
_tmp4_ = vala_parser_get_src (self, &begin);
12651
12712
_tmp5_ = _tmp4_;
12652
12713
_tmp6_ = vala_method_new ("main", (ValaDataType*) _tmp3_, _tmp5_, NULL);
12653
method = (_tmp7_ = _tmp6_, _vala_source_reference_unref0 (_tmp5_), _vala_code_node_unref0 (_tmp3_), _tmp7_);
12714
_tmp7_ = _tmp6_;
12715
_vala_source_reference_unref0 (_tmp5_);
12716
_vala_code_node_unref0 (_tmp3_);
12717
method = _tmp7_;
12654
12718
_tmp8_ = vala_parser_get_src (self, &begin);
12655
12719
_tmp9_ = _tmp8_;
12656
12720
_tmp10_ = vala_block_new (_tmp9_);
12715
12779
12716
12780
static void vala_parser_parse_declaration (ValaParser* self, ValaSymbol* parent, gboolean root, GError** error) {
12717
12781
ValaComment* _tmp0_ = NULL;
12718
ValaComment* _tmp1_;
12719
ValaList* _tmp2_ = NULL;
12782
ValaList* _tmp1_ = NULL;
12720
12783
ValaList* attrs;
12784
ValaSourceLocation _tmp2_ = {0};
12721
12785
ValaSourceLocation _tmp3_ = {0};
12722
ValaSourceLocation _tmp4_ = {0};
12723
12786
ValaSourceLocation begin;
12724
ValaTokenType _tmp5_;
12787
ValaTokenType _tmp4_;
12725
12788
ValaTokenType last_keyword;
12726
ValaTokenType _tmp9_;
12727
gchar* _tmp22_ = NULL;
12728
gchar* _tmp23_;
12729
GError* _tmp24_ = NULL;
12730
GError* _tmp25_;
12789
ValaTokenType _tmp8_;
12790
gchar* _tmp21_ = NULL;
12791
gchar* _tmp22_;
12792
GError* _tmp23_ = NULL;
12793
GError* _tmp24_;
12731
12794
GError * _inner_error_ = NULL;
12732
12795
g_return_if_fail (self != NULL);
12733
12796
g_return_if_fail (parent != NULL);
12734
12797
_tmp0_ = vala_scanner_pop_comment (self->priv->scanner);
12735
_tmp1_ = _tmp0_;
12736
12798
_vala_comment_unref0 (self->priv->comment);
12737
self->priv->comment = _tmp1_;
12738
_tmp2_ = vala_parser_parse_attributes (self, &_inner_error_);
12739
attrs = _tmp2_;
12799
self->priv->comment = _tmp0_;
12800
_tmp1_ = vala_parser_parse_attributes (self, &_inner_error_);
12801
attrs = _tmp1_;
12740
12802
if (_inner_error_ != NULL) {
12741
12803
if (_inner_error_->domain == VALA_PARSE_ERROR) {
12742
12804
g_propagate_error (error, _inner_error_);
12747
12809
return;
12748
12810
}
12749
12811
}
12750
_tmp4_ = (vala_parser_get_location (self, &_tmp3_), _tmp3_);
12751
begin = _tmp4_;
12752
_tmp5_ = vala_parser_current (self);
12753
last_keyword = _tmp5_;
12812
vala_parser_get_location (self, &_tmp2_);
12813
_tmp3_ = _tmp2_;
12814
begin = _tmp3_;
12815
_tmp4_ = vala_parser_current (self);
12816
last_keyword = _tmp4_;
12754
12817
while (TRUE) {
12755
ValaTokenType _tmp6_;
12756
gboolean _tmp7_;
12757
ValaTokenType _tmp8_;
12758
_tmp6_ = vala_parser_current (self);
12759
_tmp7_ = vala_parser_is_declaration_keyword (self, _tmp6_);
12760
if (!_tmp7_) {
12818
ValaTokenType _tmp5_;
12819
gboolean _tmp6_;
12820
ValaTokenType _tmp7_;
12821
_tmp5_ = vala_parser_current (self);
12822
_tmp6_ = vala_parser_is_declaration_keyword (self, _tmp5_);
12823
if (!_tmp6_) {
12761
12824
break;
12762
12825
}
12763
_tmp8_ = vala_parser_current (self);
12764
last_keyword = _tmp8_;
12826
_tmp7_ = vala_parser_current (self);
12827
last_keyword = _tmp7_;
12765
12828
vala_parser_next (self);
12766
12829
}
12767
_tmp9_ = vala_parser_current (self);
12768
switch (_tmp9_) {
12830
_tmp8_ = vala_parser_current (self);
12831
switch (_tmp8_) {
12769
12832
case VALA_TOKEN_TYPE_CONSTRUCT:
12770
12833
{
12771
ValaProfile _tmp10_;
12772
_tmp10_ = vala_code_context_get_profile (self->priv->context);
12773
if (_tmp10_ == VALA_PROFILE_GOBJECT) {
12834
ValaProfile _tmp9_;
12835
_tmp9_ = vala_code_context_get_profile (self->priv->context);
12836
if (_tmp9_ == VALA_PROFILE_GOBJECT) {
12774
12837
vala_parser_rollback (self, &begin);
12775
12838
vala_parser_parse_constructor_declaration (self, parent, attrs, &_inner_error_);
12776
12839
if (_inner_error_ != NULL) {
12835
12898
case VALA_TOKEN_TYPE_NEW:
12836
12899
{
12837
12900
if (attrs != NULL) {
12838
gchar* _tmp11_ = NULL;
12839
gchar* _tmp12_;
12840
GError* _tmp13_ = NULL;
12841
GError* _tmp14_;
12842
_tmp11_ = vala_parser_get_error (self, "expected statement");
12843
_tmp12_ = _tmp11_;
12844
_tmp13_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp12_);
12845
_inner_error_ = (_tmp14_ = _tmp13_, _g_free0 (_tmp12_), _tmp14_);
12901
gchar* _tmp10_ = NULL;
12902
gchar* _tmp11_;
12903
GError* _tmp12_ = NULL;
12904
GError* _tmp13_;
12905
_tmp10_ = vala_parser_get_error (self, "expected statement");
12906
_tmp11_ = _tmp10_;
12907
_tmp12_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp11_);
12908
_tmp13_ = _tmp12_;
12909
_g_free0 (_tmp11_);
12910
_inner_error_ = _tmp13_;
12846
12911
if (_inner_error_->domain == VALA_PARSE_ERROR) {
12847
12912
g_propagate_error (error, _inner_error_);
12848
12913
_vala_iterable_unref0 (attrs);
12855
12920
}
12856
12921
}
12857
12922
if (!root) {
12858
gchar* _tmp15_ = NULL;
12859
gchar* _tmp16_;
12860
GError* _tmp17_ = NULL;
12861
GError* _tmp18_;
12862
_tmp15_ = vala_parser_get_error (self, "statements outside blocks allowed only in root namespace");
12863
_tmp16_ = _tmp15_;
12864
_tmp17_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp16_);
12865
_inner_error_ = (_tmp18_ = _tmp17_, _g_free0 (_tmp16_), _tmp18_);
12923
gchar* _tmp14_ = NULL;
12924
gchar* _tmp15_;
12925
GError* _tmp16_ = NULL;
12926
GError* _tmp17_;
12927
_tmp14_ = vala_parser_get_error (self, "statements outside blocks allowed only in root namespace");
12928
_tmp15_ = _tmp14_;
12929
_tmp16_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp15_);
12930
_tmp17_ = _tmp16_;
12931
_g_free0 (_tmp15_);
12932
_inner_error_ = _tmp17_;
12866
12933
if (_inner_error_->domain == VALA_PARSE_ERROR) {
12867
12934
g_propagate_error (error, _inner_error_);
12868
12935
_vala_iterable_unref0 (attrs);
12893
12960
}
12894
12961
default:
12895
12962
{
12896
ValaTokenType _tmp20_;
12963
ValaTokenType _tmp19_;
12897
12964
if (root) {
12898
gboolean _tmp19_;
12965
gboolean _tmp18_;
12899
12966
gboolean is_expr;
12900
_tmp19_ = vala_parser_is_expression (self, &_inner_error_);
12901
is_expr = _tmp19_;
12967
_tmp18_ = vala_parser_is_expression (self, &_inner_error_);
12968
is_expr = _tmp18_;
12902
12969
if (_inner_error_ != NULL) {
12903
12970
if (_inner_error_->domain == VALA_PARSE_ERROR) {
12904
12971
g_propagate_error (error, _inner_error_);
12943
13010
return;
12944
13011
}
12945
13012
}
12946
_tmp20_ = vala_parser_current (self);
12947
switch (_tmp20_) {
13013
_tmp19_ = vala_parser_current (self);
13014
switch (_tmp19_) {
12948
13015
case VALA_TOKEN_TYPE_OPEN_BRACE:
12949
13016
case VALA_TOKEN_TYPE_SEMICOLON:
12950
13017
case VALA_TOKEN_TYPE_COLON:
13087
13154
}
13088
13155
default:
13089
13156
{
13090
ValaTokenType _tmp21_;
13157
ValaTokenType _tmp20_;
13091
13158
vala_parser_skip_type (self, &_inner_error_);
13092
13159
if (_inner_error_ != NULL) {
13093
13160
if (_inner_error_->domain == VALA_PARSE_ERROR) {
13101
13168
return;
13102
13169
}
13103
13170
}
13104
_tmp21_ = vala_parser_current (self);
13105
switch (_tmp21_) {
13171
_tmp20_ = vala_parser_current (self);
13172
switch (_tmp20_) {
13106
13173
case VALA_TOKEN_TYPE_OPEN_PARENS:
13107
13174
{
13108
13175
vala_parser_rollback (self, &begin);
13238
13305
}
13239
13306
}
13240
13307
vala_parser_rollback (self, &begin);
13241
_tmp22_ = vala_parser_get_error (self, "expected declaration");
13242
_tmp23_ = _tmp22_;
13243
_tmp24_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp23_);
13244
_inner_error_ = (_tmp25_ = _tmp24_, _g_free0 (_tmp23_), _tmp25_);
13308
_tmp21_ = vala_parser_get_error (self, "expected declaration");
13309
_tmp22_ = _tmp21_;
13310
_tmp23_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp22_);
13311
_tmp24_ = _tmp23_;
13312
_g_free0 (_tmp22_);
13313
_inner_error_ = _tmp24_;
13245
13314
if (_inner_error_->domain == VALA_PARSE_ERROR) {
13246
13315
g_propagate_error (error, _inner_error_);
13247
13316
_vala_iterable_unref0 (attrs);
13436
13505
ValaNamespace* _tmp6_ = NULL;
13437
13506
ValaNamespace* _tmp7_;
13438
13507
ValaNamespace* ns;
13439
ValaSourceFile* _tmp9_ = NULL;
13440
ValaList* _tmp10_ = NULL;
13441
ValaList* _tmp11_;
13508
ValaSourceFile* _tmp8_ = NULL;
13509
ValaList* _tmp9_ = NULL;
13510
ValaList* _tmp10_;
13442
13511
ValaList* old_using_directives;
13443
ValaSourceFile* _tmp12_ = NULL;
13444
gboolean _tmp13_;
13445
ValaSymbol* _tmp18_;
13512
ValaSourceFile* _tmp11_ = NULL;
13513
gboolean _tmp12_;
13514
ValaSymbol* _tmp17_;
13446
13515
ValaSymbol* _result_;
13447
13516
GError * _inner_error_ = NULL;
13448
13517
g_return_if_fail (self != NULL);
13449
13518
g_return_if_fail (parent != NULL);
13450
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
13519
vala_parser_get_location (self, &_tmp0_);
13520
_tmp1_ = _tmp0_;
13451
13521
begin = _tmp1_;
13452
13522
vala_parser_expect (self, VALA_TOKEN_TYPE_NAMESPACE, &_inner_error_);
13453
13523
if (_inner_error_ != NULL) {
13476
13546
_tmp4_ = vala_parser_get_src (self, &begin);
13477
13547
_tmp5_ = _tmp4_;
13478
13548
_tmp6_ = vala_namespace_new (_tmp3_, _tmp5_);
13479
ns = (_tmp7_ = _tmp6_, _vala_source_reference_unref0 (_tmp5_), _tmp7_);
13549
_tmp7_ = _tmp6_;
13550
_vala_source_reference_unref0 (_tmp5_);
13551
ns = _tmp7_;
13480
13552
if (self->priv->comment != NULL) {
13481
ValaComment* _tmp8_;
13482
13553
vala_namespace_add_comment (ns, self->priv->comment);
13483
_tmp8_ = NULL;
13484
13554
_vala_comment_unref0 (self->priv->comment);
13485
self->priv->comment = _tmp8_;
13555
self->priv->comment = NULL;
13486
13556
}
13487
13557
vala_parser_set_attributes (self, (ValaCodeNode*) ns, attrs);
13488
13558
vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_BRACE, &_inner_error_);
13500
13570
return;
13501
13571
}
13502
13572
}
13503
_tmp9_ = vala_scanner_get_source_file (self->priv->scanner);
13504
_tmp10_ = vala_source_file_get_current_using_directives (_tmp9_);
13505
_tmp11_ = _vala_iterable_ref0 (_tmp10_);
13506
old_using_directives = _tmp11_;
13573
_tmp8_ = vala_scanner_get_source_file (self->priv->scanner);
13574
_tmp9_ = vala_source_file_get_current_using_directives (_tmp8_);
13575
_tmp10_ = _vala_iterable_ref0 (_tmp9_);
13576
old_using_directives = _tmp10_;
13507
13577
vala_parser_parse_using_directives (self, ns, &_inner_error_);
13508
13578
if (_inner_error_ != NULL) {
13509
13579
if (_inner_error_->domain == VALA_PARSE_ERROR) {
13538
13608
return;
13539
13609
}
13540
13610
}
13541
_tmp12_ = vala_scanner_get_source_file (self->priv->scanner);
13542
vala_source_file_set_current_using_directives (_tmp12_, old_using_directives);
13543
_tmp13_ = vala_parser_accept (self, VALA_TOKEN_TYPE_CLOSE_BRACE);
13544
if (!_tmp13_) {
13545
ValaReport* _tmp14_ = NULL;
13546
gint _tmp15_;
13547
_tmp14_ = vala_code_context_get_report (self->priv->context);
13548
_tmp15_ = vala_report_get_errors (_tmp14_);
13549
if (_tmp15_ == 0) {
13550
ValaSourceReference* _tmp16_ = NULL;
13551
ValaSourceReference* _tmp17_;
13552
_tmp16_ = vala_parser_get_current_src (self);
13553
_tmp17_ = _tmp16_;
13554
vala_report_error (_tmp17_, "expected `}'");
13555
_vala_source_reference_unref0 (_tmp17_);
13611
_tmp11_ = vala_scanner_get_source_file (self->priv->scanner);
13612
vala_source_file_set_current_using_directives (_tmp11_, old_using_directives);
13613
_tmp12_ = vala_parser_accept (self, VALA_TOKEN_TYPE_CLOSE_BRACE);
13614
if (!_tmp12_) {
13615
ValaReport* _tmp13_ = NULL;
13616
gint _tmp14_;
13617
_tmp13_ = vala_code_context_get_report (self->priv->context);
13618
_tmp14_ = vala_report_get_errors (_tmp13_);
13619
if (_tmp14_ == 0) {
13620
ValaSourceReference* _tmp15_ = NULL;
13621
ValaSourceReference* _tmp16_;
13622
_tmp15_ = vala_parser_get_current_src (self);
13623
_tmp16_ = _tmp15_;
13624
vala_report_error (_tmp16_, "expected `}'");
13625
_vala_source_reference_unref0 (_tmp16_);
13556
13626
}
13557
13627
}
13558
_tmp18_ = _vala_code_node_ref0 ((ValaSymbol*) ns);
13559
_result_ = _tmp18_;
13628
_tmp17_ = _vala_code_node_ref0 ((ValaSymbol*) ns);
13629
_result_ = _tmp17_;
13560
13630
while (TRUE) {
13561
ValaUnresolvedSymbol* _tmp19_ = NULL;
13562
ValaUnresolvedSymbol* _tmp20_;
13563
ValaUnresolvedSymbol* _tmp21_;
13564
ValaSymbol* _tmp22_ = NULL;
13565
ValaSymbol* _tmp29_;
13631
ValaUnresolvedSymbol* _tmp18_ = NULL;
13632
ValaUnresolvedSymbol* _tmp19_;
13633
ValaSymbol* _tmp20_ = NULL;
13634
ValaSymbol* _tmp25_;
13566
13635
ValaSymbol* next;
13567
ValaSymbol* _tmp30_;
13568
ValaSymbol* _tmp31_;
13636
ValaSymbol* _tmp26_;
13569
13637
if (!(sym != NULL)) {
13570
13638
break;
13571
13639
}
13572
_tmp19_ = vala_unresolved_symbol_get_inner (sym);
13573
_tmp20_ = _vala_code_node_ref0 (_tmp19_);
13574
_tmp21_ = _tmp20_;
13640
_tmp18_ = vala_unresolved_symbol_get_inner (sym);
13641
_tmp19_ = _vala_code_node_ref0 (_tmp18_);
13575
13642
_vala_code_node_unref0 (sym);
13576
sym = _tmp21_;
13643
sym = _tmp19_;
13577
13644
if (sym != NULL) {
13578
const gchar* _tmp23_ = NULL;
13579
ValaSourceReference* _tmp24_ = NULL;
13580
ValaNamespace* _tmp25_ = NULL;
13581
ValaSymbol* _tmp26_;
13582
_tmp23_ = vala_symbol_get_name ((ValaSymbol*) sym);
13583
_tmp24_ = vala_code_node_get_source_reference ((ValaCodeNode*) ns);
13584
_tmp25_ = vala_namespace_new (_tmp23_, _tmp24_);
13585
_tmp26_ = (ValaSymbol*) _tmp25_;
13586
_vala_code_node_unref0 (_tmp22_);
13587
_tmp22_ = _tmp26_;
13645
const gchar* _tmp21_ = NULL;
13646
ValaSourceReference* _tmp22_ = NULL;
13647
ValaNamespace* _tmp23_ = NULL;
13648
_tmp21_ = vala_symbol_get_name ((ValaSymbol*) sym);
13649
_tmp22_ = vala_code_node_get_source_reference ((ValaCodeNode*) ns);
13650
_tmp23_ = vala_namespace_new (_tmp21_, _tmp22_);
13651
_vala_code_node_unref0 (_tmp20_);
13652
_tmp20_ = (ValaSymbol*) _tmp23_;
13588
13653
} else {
13589
ValaSymbol* _tmp27_;
13590
ValaSymbol* _tmp28_;
13591
_tmp27_ = _vala_code_node_ref0 (parent);
13592
_tmp28_ = _tmp27_;
13593
_vala_code_node_unref0 (_tmp22_);
13594
_tmp22_ = _tmp28_;
13654
ValaSymbol* _tmp24_;
13655
_tmp24_ = _vala_code_node_ref0 (parent);
13656
_vala_code_node_unref0 (_tmp20_);
13657
_tmp20_ = _tmp24_;
13595
13658
}
13596
_tmp29_ = _vala_code_node_ref0 (_tmp22_);
13597
next = _tmp29_;
13659
_tmp25_ = _vala_code_node_ref0 (_tmp20_);
13660
next = _tmp25_;
13598
13661
vala_symbol_add_namespace (next, VALA_NAMESPACE (_result_));
13599
_tmp30_ = _vala_code_node_ref0 (next);
13600
_tmp31_ = _tmp30_;
13662
_tmp26_ = _vala_code_node_ref0 (next);
13601
13663
_vala_code_node_unref0 (_result_);
13602
_result_ = _tmp31_;
13664
_result_ = _tmp26_;
13603
13665
_vala_code_node_unref0 (next);
13604
_vala_code_node_unref0 (_tmp22_);
13666
_vala_code_node_unref0 (_tmp20_);
13605
13667
}
13606
13668
_vala_code_node_unref0 (_result_);
13607
13669
_vala_iterable_unref0 (old_using_directives);
13643
13705
}
13644
13706
}
13645
13707
_tmp1_ = FALSE;
13646
_tmp4_ = (vala_parser_get_location (self, &_tmp3_), _tmp3_);
13708
vala_parser_get_location (self, &_tmp3_);
13709
_tmp4_ = _tmp3_;
13647
13710
begin = _tmp4_;
13648
13711
_tmp5_ = vala_parser_parse_symbol_name (self, &_inner_error_);
13649
13712
sym = _tmp5_;
13660
13723
_tmp6_ = vala_parser_get_src (self, &begin);
13661
13724
_tmp7_ = _tmp6_;
13662
13725
_tmp8_ = vala_using_directive_new ((ValaSymbol*) sym, _tmp7_);
13663
ns_ref = (_tmp9_ = _tmp8_, _vala_source_reference_unref0 (_tmp7_), _tmp9_);
13726
_tmp9_ = _tmp8_;
13727
_vala_source_reference_unref0 (_tmp7_);
13728
ns_ref = _tmp9_;
13664
13729
_tmp10_ = vala_scanner_get_source_file (self->priv->scanner);
13665
13730
vala_source_file_add_using_directive (_tmp10_, ns_ref);
13666
13731
vala_namespace_add_using_directive (ns, ns_ref);
13713
13778
GError * _inner_error_ = NULL;
13714
13779
g_return_if_fail (self != NULL);
13715
13780
g_return_if_fail (parent != NULL);
13716
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
13781
vala_parser_get_location (self, &_tmp0_);
13782
_tmp1_ = _tmp0_;
13717
13783
begin = _tmp1_;
13718
13784
_tmp2_ = vala_parser_parse_access_modifier (self, VALA_SYMBOL_ACCESSIBILITY_PRIVATE);
13719
13785
access = _tmp2_;
13803
13869
_tmp14_ = vala_parser_get_src (self, &begin);
13804
13870
_tmp15_ = _tmp14_;
13805
13871
_tmp16_ = vala_class_new (_tmp13_, _tmp15_, self->priv->comment);
13806
cl = (_tmp17_ = _tmp16_, _vala_source_reference_unref0 (_tmp15_), _tmp17_);
13872
_tmp17_ = _tmp16_;
13873
_vala_source_reference_unref0 (_tmp15_);
13874
cl = _tmp17_;
13807
13875
vala_symbol_set_access ((ValaSymbol*) cl, access);
13808
13876
if ((flags & VALA_PARSER_MODIFIER_FLAGS_ABSTRACT) == VALA_PARSER_MODIFIER_FLAGS_ABSTRACT) {
13809
13877
vala_class_set_is_abstract (cl, TRUE);
13925
13993
while (TRUE) {
13926
13994
ValaUnresolvedSymbol* _tmp38_ = NULL;
13927
13995
ValaUnresolvedSymbol* _tmp39_;
13928
ValaUnresolvedSymbol* _tmp40_;
13929
ValaSymbol* _tmp41_ = NULL;
13930
ValaSymbol* _tmp48_;
13996
ValaSymbol* _tmp40_ = NULL;
13997
ValaSymbol* _tmp45_;
13931
13998
ValaSymbol* next;
13932
ValaSymbol* _tmp49_;
13933
ValaSymbol* _tmp50_;
13999
ValaSymbol* _tmp46_;
13934
14000
if (!(sym != NULL)) {
13935
14001
break;
13936
14002
}
13937
14003
_tmp38_ = vala_unresolved_symbol_get_inner (sym);
13938
14004
_tmp39_ = _vala_code_node_ref0 (_tmp38_);
13939
_tmp40_ = _tmp39_;
13940
14005
_vala_code_node_unref0 (sym);
13941
sym = _tmp40_;
14006
sym = _tmp39_;
13942
14007
if (sym != NULL) {
13943
const gchar* _tmp42_ = NULL;
13944
ValaSourceReference* _tmp43_ = NULL;
13945
ValaNamespace* _tmp44_ = NULL;
13946
ValaSymbol* _tmp45_;
13947
_tmp42_ = vala_symbol_get_name ((ValaSymbol*) sym);
13948
_tmp43_ = vala_code_node_get_source_reference ((ValaCodeNode*) cl);
13949
_tmp44_ = vala_namespace_new (_tmp42_, _tmp43_);
13950
_tmp45_ = (ValaSymbol*) _tmp44_;
13951
_vala_code_node_unref0 (_tmp41_);
13952
_tmp41_ = _tmp45_;
14008
const gchar* _tmp41_ = NULL;
14009
ValaSourceReference* _tmp42_ = NULL;
14010
ValaNamespace* _tmp43_ = NULL;
14011
_tmp41_ = vala_symbol_get_name ((ValaSymbol*) sym);
14012
_tmp42_ = vala_code_node_get_source_reference ((ValaCodeNode*) cl);
14013
_tmp43_ = vala_namespace_new (_tmp41_, _tmp42_);
14014
_vala_code_node_unref0 (_tmp40_);
14015
_tmp40_ = (ValaSymbol*) _tmp43_;
13953
14016
} else {
13954
ValaSymbol* _tmp46_;
13955
ValaSymbol* _tmp47_;
13956
_tmp46_ = _vala_code_node_ref0 (parent);
13957
_tmp47_ = _tmp46_;
13958
_vala_code_node_unref0 (_tmp41_);
13959
_tmp41_ = _tmp47_;
14017
ValaSymbol* _tmp44_;
14018
_tmp44_ = _vala_code_node_ref0 (parent);
14019
_vala_code_node_unref0 (_tmp40_);
14020
_tmp40_ = _tmp44_;
13960
14021
}
13961
_tmp48_ = _vala_code_node_ref0 (_tmp41_);
13962
next = _tmp48_;
14022
_tmp45_ = _vala_code_node_ref0 (_tmp40_);
14023
next = _tmp45_;
13963
14024
if (VALA_IS_NAMESPACE (_result_)) {
13964
14025
vala_symbol_add_namespace (next, VALA_NAMESPACE (_result_));
13965
14026
} else {
13966
14027
vala_symbol_add_class (next, VALA_CLASS (_result_));
13967
14028
}
13968
_tmp49_ = _vala_code_node_ref0 (next);
13969
_tmp50_ = _tmp49_;
14029
_tmp46_ = _vala_code_node_ref0 (next);
13970
14030
_vala_code_node_unref0 (_result_);
13971
_result_ = _tmp50_;
14031
_result_ = _tmp46_;
13972
14032
_vala_code_node_unref0 (next);
13973
_vala_code_node_unref0 (_tmp41_);
14033
_vala_code_node_unref0 (_tmp40_);
13974
14034
}
13975
14035
_vala_code_node_unref0 (_result_);
13976
14036
_vala_code_node_unref0 (cl);
13994
14054
gchar* id;
13995
14055
ValaDataType* _tmp6_ = NULL;
13996
14056
ValaDataType* _tmp7_;
13997
ValaDataType* _tmp8_;
13998
14057
ValaExpression* initializer;
13999
gboolean _tmp9_;
14000
ValaDataType* _tmp13_;
14001
ValaArrayType* _tmp14_;
14058
gboolean _tmp8_;
14059
ValaDataType* _tmp11_;
14060
ValaArrayType* _tmp12_;
14002
14061
ValaArrayType* array_type;
14003
ValaSourceReference* _tmp16_ = NULL;
14004
ValaSourceReference* _tmp17_;
14005
ValaConstant* _tmp18_ = NULL;
14006
ValaConstant* _tmp19_;
14062
ValaSourceReference* _tmp14_ = NULL;
14063
ValaSourceReference* _tmp15_;
14064
ValaConstant* _tmp16_ = NULL;
14065
ValaConstant* _tmp17_;
14007
14066
ValaConstant* c;
14008
gboolean _tmp20_ = FALSE;
14067
gboolean _tmp18_ = FALSE;
14009
14068
GError * _inner_error_ = NULL;
14010
14069
g_return_if_fail (self != NULL);
14011
14070
g_return_if_fail (parent != NULL);
14012
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
14071
vala_parser_get_location (self, &_tmp0_);
14072
_tmp1_ = _tmp0_;
14013
14073
begin = _tmp1_;
14014
14074
_tmp2_ = vala_parser_parse_access_modifier (self, VALA_SYMBOL_ACCESSIBILITY_PRIVATE);
14015
14075
access = _tmp2_;
14068
14128
return;
14069
14129
}
14070
14130
}
14071
_tmp8_ = _tmp7_;
14072
14131
_vala_code_node_unref0 (type);
14073
type = _tmp8_;
14132
type = _tmp7_;
14074
14133
initializer = NULL;
14075
_tmp9_ = vala_parser_accept (self, VALA_TOKEN_TYPE_ASSIGN);
14076
if (_tmp9_) {
14077
ValaExpression* _tmp10_ = NULL;
14078
ValaExpression* _tmp11_;
14079
ValaExpression* _tmp12_;
14080
_tmp10_ = vala_parser_parse_expression (self, &_inner_error_);
14081
_tmp11_ = _tmp10_;
14134
_tmp8_ = vala_parser_accept (self, VALA_TOKEN_TYPE_ASSIGN);
14135
if (_tmp8_) {
14136
ValaExpression* _tmp9_ = NULL;
14137
ValaExpression* _tmp10_;
14138
_tmp9_ = vala_parser_parse_expression (self, &_inner_error_);
14139
_tmp10_ = _tmp9_;
14082
14140
if (_inner_error_ != NULL) {
14083
14141
if (_inner_error_->domain == VALA_PARSE_ERROR) {
14084
14142
g_propagate_error (error, _inner_error_);
14095
14153
return;
14096
14154
}
14097
14155
}
14098
_tmp12_ = _tmp11_;
14099
14156
_vala_code_node_unref0 (initializer);
14100
initializer = _tmp12_;
14157
initializer = _tmp10_;
14101
14158
}
14102
14159
vala_parser_expect (self, VALA_TOKEN_TYPE_SEMICOLON, &_inner_error_);
14103
14160
if (_inner_error_ != NULL) {
14116
14173
return;
14117
14174
}
14118
14175
}
14119
_tmp14_ = _vala_code_node_ref0 ((_tmp13_ = type, VALA_IS_ARRAY_TYPE (_tmp13_) ? ((ValaArrayType*) _tmp13_) : NULL));
14120
array_type = _tmp14_;
14176
_tmp11_ = type;
14177
_tmp12_ = _vala_code_node_ref0 (VALA_IS_ARRAY_TYPE (_tmp11_) ? ((ValaArrayType*) _tmp11_) : NULL);
14178
array_type = _tmp12_;
14121
14179
if (array_type != NULL) {
14122
ValaDataType* _tmp15_ = NULL;
14123
_tmp15_ = vala_array_type_get_element_type (array_type);
14124
vala_data_type_set_value_owned (_tmp15_, FALSE);
14180
ValaDataType* _tmp13_ = NULL;
14181
_tmp13_ = vala_array_type_get_element_type (array_type);
14182
vala_data_type_set_value_owned (_tmp13_, FALSE);
14125
14183
}
14126
_tmp16_ = vala_parser_get_src (self, &begin);
14184
_tmp14_ = vala_parser_get_src (self, &begin);
14185
_tmp15_ = _tmp14_;
14186
_tmp16_ = vala_constant_new (id, type, initializer, _tmp15_, self->priv->comment);
14127
14187
_tmp17_ = _tmp16_;
14128
_tmp18_ = vala_constant_new (id, type, initializer, _tmp17_, self->priv->comment);
14129
c = (_tmp19_ = _tmp18_, _vala_source_reference_unref0 (_tmp17_), _tmp19_);
14188
_vala_source_reference_unref0 (_tmp15_);
14189
c = _tmp17_;
14130
14190
vala_symbol_set_access ((ValaSymbol*) c, access);
14131
14191
if ((flags & VALA_PARSER_MODIFIER_FLAGS_EXTERN) == VALA_PARSER_MODIFIER_FLAGS_EXTERN) {
14132
_tmp20_ = TRUE;
14192
_tmp18_ = TRUE;
14133
14193
} else {
14134
ValaSourceFile* _tmp21_ = NULL;
14135
ValaSourceFileType _tmp22_;
14136
_tmp21_ = vala_scanner_get_source_file (self->priv->scanner);
14137
_tmp22_ = vala_source_file_get_file_type (_tmp21_);
14138
_tmp20_ = _tmp22_ == VALA_SOURCE_FILE_TYPE_PACKAGE;
14194
ValaSourceFile* _tmp19_ = NULL;
14195
ValaSourceFileType _tmp20_;
14196
_tmp19_ = vala_scanner_get_source_file (self->priv->scanner);
14197
_tmp20_ = vala_source_file_get_file_type (_tmp19_);
14198
_tmp18_ = _tmp20_ == VALA_SOURCE_FILE_TYPE_PACKAGE;
14139
14199
}
14140
if (_tmp20_) {
14200
if (_tmp18_) {
14141
14201
vala_symbol_set_external ((ValaSymbol*) c, TRUE);
14142
14202
}
14143
14203
if ((flags & VALA_PARSER_MODIFIER_FLAGS_NEW) == VALA_PARSER_MODIFIER_FLAGS_NEW) {
14168
14228
gchar* id;
14169
14229
ValaDataType* _tmp7_ = NULL;
14170
14230
ValaDataType* _tmp8_;
14171
ValaDataType* _tmp9_;
14172
ValaSourceReference* _tmp10_ = NULL;
14173
ValaSourceReference* _tmp11_;
14174
ValaField* _tmp12_ = NULL;
14175
ValaField* _tmp13_;
14231
ValaSourceReference* _tmp9_ = NULL;
14232
ValaSourceReference* _tmp10_;
14233
ValaField* _tmp11_ = NULL;
14234
ValaField* _tmp12_;
14176
14235
ValaField* f;
14236
gboolean _tmp13_ = FALSE;
14177
14237
gboolean _tmp14_ = FALSE;
14178
gboolean _tmp15_ = FALSE;
14179
gboolean _tmp17_ = FALSE;
14180
gboolean _tmp20_;
14238
gboolean _tmp16_ = FALSE;
14239
gboolean _tmp19_;
14181
14240
GError * _inner_error_ = NULL;
14182
14241
g_return_if_fail (self != NULL);
14183
14242
g_return_if_fail (parent != NULL);
14184
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
14243
vala_parser_get_location (self, &_tmp0_);
14244
_tmp1_ = _tmp0_;
14185
14245
begin = _tmp1_;
14186
14246
_tmp2_ = vala_parser_parse_access_modifier (self, VALA_SYMBOL_ACCESSIBILITY_PRIVATE);
14187
14247
access = _tmp2_;
14233
14293
return;
14234
14294
}
14235
14295
}
14236
_tmp9_ = _tmp8_;
14237
14296
_vala_code_node_unref0 (type);
14238
type = _tmp9_;
14239
_tmp10_ = vala_parser_get_src (self, &begin);
14240
_tmp11_ = _tmp10_;
14241
_tmp12_ = vala_field_new (id, type, NULL, _tmp11_, self->priv->comment);
14242
f = (_tmp13_ = _tmp12_, _vala_source_reference_unref0 (_tmp11_), _tmp13_);
14297
type = _tmp8_;
14298
_tmp9_ = vala_parser_get_src (self, &begin);
14299
_tmp10_ = _tmp9_;
14300
_tmp11_ = vala_field_new (id, type, NULL, _tmp10_, self->priv->comment);
14301
_tmp12_ = _tmp11_;
14302
_vala_source_reference_unref0 (_tmp10_);
14303
f = _tmp12_;
14243
14304
vala_symbol_set_access ((ValaSymbol*) f, access);
14244
14305
vala_parser_set_attributes (self, (ValaCodeNode*) f, attrs);
14245
14306
if ((flags & VALA_PARSER_MODIFIER_FLAGS_STATIC) == VALA_PARSER_MODIFIER_FLAGS_STATIC) {
14250
14311
}
14251
14312
}
14252
14313
if ((flags & VALA_PARSER_MODIFIER_FLAGS_ABSTRACT) == VALA_PARSER_MODIFIER_FLAGS_ABSTRACT) {
14253
_tmp15_ = TRUE;
14254
} else {
14255
_tmp15_ = (flags & VALA_PARSER_MODIFIER_FLAGS_VIRTUAL) == VALA_PARSER_MODIFIER_FLAGS_VIRTUAL;
14256
}
14257
if (_tmp15_) {
14258
14314
_tmp14_ = TRUE;
14259
14315
} else {
14260
_tmp14_ = (flags & VALA_PARSER_MODIFIER_FLAGS_OVERRIDE) == VALA_PARSER_MODIFIER_FLAGS_OVERRIDE;
14316
_tmp14_ = (flags & VALA_PARSER_MODIFIER_FLAGS_VIRTUAL) == VALA_PARSER_MODIFIER_FLAGS_VIRTUAL;
14261
14317
}
14262
14318
if (_tmp14_) {
14263
ValaSourceReference* _tmp16_ = NULL;
14264
_tmp16_ = vala_code_node_get_source_reference ((ValaCodeNode*) f);
14265
vala_report_error (_tmp16_, "abstract, virtual, and override modifiers are not applicable to fields");
14319
_tmp13_ = TRUE;
14320
} else {
14321
_tmp13_ = (flags & VALA_PARSER_MODIFIER_FLAGS_OVERRIDE) == VALA_PARSER_MODIFIER_FLAGS_OVERRIDE;
14322
}
14323
if (_tmp13_) {
14324
ValaSourceReference* _tmp15_ = NULL;
14325
_tmp15_ = vala_code_node_get_source_reference ((ValaCodeNode*) f);
14326
vala_report_error (_tmp15_, "abstract, virtual, and override modifiers are not applicable to fields");
14266
14327
}
14267
14328
if ((flags & VALA_PARSER_MODIFIER_FLAGS_EXTERN) == VALA_PARSER_MODIFIER_FLAGS_EXTERN) {
14268
_tmp17_ = TRUE;
14329
_tmp16_ = TRUE;
14269
14330
} else {
14270
ValaSourceFile* _tmp18_ = NULL;
14271
ValaSourceFileType _tmp19_;
14272
_tmp18_ = vala_scanner_get_source_file (self->priv->scanner);
14273
_tmp19_ = vala_source_file_get_file_type (_tmp18_);
14274
_tmp17_ = _tmp19_ == VALA_SOURCE_FILE_TYPE_PACKAGE;
14331
ValaSourceFile* _tmp17_ = NULL;
14332
ValaSourceFileType _tmp18_;
14333
_tmp17_ = vala_scanner_get_source_file (self->priv->scanner);
14334
_tmp18_ = vala_source_file_get_file_type (_tmp17_);
14335
_tmp16_ = _tmp18_ == VALA_SOURCE_FILE_TYPE_PACKAGE;
14275
14336
}
14276
if (_tmp17_) {
14337
if (_tmp16_) {
14277
14338
vala_symbol_set_external ((ValaSymbol*) f, TRUE);
14278
14339
}
14279
14340
if ((flags & VALA_PARSER_MODIFIER_FLAGS_NEW) == VALA_PARSER_MODIFIER_FLAGS_NEW) {
14280
14341
vala_symbol_set_hides ((ValaSymbol*) f, TRUE);
14281
14342
}
14282
_tmp20_ = vala_parser_accept (self, VALA_TOKEN_TYPE_ASSIGN);
14283
if (_tmp20_) {
14284
ValaExpression* _tmp21_ = NULL;
14343
_tmp19_ = vala_parser_accept (self, VALA_TOKEN_TYPE_ASSIGN);
14344
if (_tmp19_) {
14345
ValaExpression* _tmp20_ = NULL;
14346
ValaExpression* _tmp21_;
14285
14347
ValaExpression* _tmp22_;
14286
ValaExpression* _tmp23_;
14287
_tmp21_ = vala_parser_parse_expression (self, &_inner_error_);
14348
_tmp20_ = vala_parser_parse_expression (self, &_inner_error_);
14349
_tmp21_ = _tmp20_;
14350
if (_inner_error_ != NULL) {
14351
if (_inner_error_->domain == VALA_PARSE_ERROR) {
14352
g_propagate_error (error, _inner_error_);
14353
_vala_code_node_unref0 (f);
14354
_g_free0 (id);
14355
_vala_code_node_unref0 (type);
14356
return;
14357
} else {
14358
_vala_code_node_unref0 (f);
14359
_g_free0 (id);
14360
_vala_code_node_unref0 (type);
14361
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
14362
g_clear_error (&_inner_error_);
14363
return;
14364
}
14365
}
14288
14366
_tmp22_ = _tmp21_;
14289
if (_inner_error_ != NULL) {
14290
if (_inner_error_->domain == VALA_PARSE_ERROR) {
14291
g_propagate_error (error, _inner_error_);
14292
_vala_code_node_unref0 (f);
14293
_g_free0 (id);
14294
_vala_code_node_unref0 (type);
14295
return;
14296
} else {
14297
_vala_code_node_unref0 (f);
14298
_g_free0 (id);
14299
_vala_code_node_unref0 (type);
14300
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
14301
g_clear_error (&_inner_error_);
14302
return;
14303
}
14304
}
14305
_tmp23_ = _tmp22_;
14306
vala_variable_set_initializer ((ValaVariable*) f, _tmp23_);
14307
_vala_code_node_unref0 (_tmp23_);
14367
vala_variable_set_initializer ((ValaVariable*) f, _tmp22_);
14368
_vala_code_node_unref0 (_tmp22_);
14308
14369
}
14309
14370
vala_parser_expect (self, VALA_TOKEN_TYPE_SEMICOLON, &_inner_error_);
14310
14371
if (_inner_error_ != NULL) {
14343
14404
ValaTokenType _tmp6_;
14344
14405
GError * _inner_error_ = NULL;
14345
14406
g_return_val_if_fail (self != NULL, NULL);
14346
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
14407
vala_parser_get_location (self, &_tmp0_);
14408
_tmp1_ = _tmp0_;
14347
14409
begin = _tmp1_;
14348
14410
vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_BRACE, &_inner_error_);
14349
14411
if (_inner_error_ != NULL) {
14359
14421
_tmp2_ = vala_parser_get_src (self, &begin);
14360
14422
_tmp3_ = _tmp2_;
14361
14423
_tmp4_ = vala_initializer_list_new (_tmp3_);
14362
initializer = (_tmp5_ = _tmp4_, _vala_source_reference_unref0 (_tmp3_), _tmp5_);
14424
_tmp5_ = _tmp4_;
14425
_vala_source_reference_unref0 (_tmp3_);
14426
initializer = _tmp5_;
14363
14427
_tmp6_ = vala_parser_current (self);
14364
14428
if (_tmp6_ != VALA_TOKEN_TYPE_CLOSE_BRACE) {
14365
14429
{
14426
14490
ValaTokenType _tmp6_;
14427
14491
GError * _inner_error_ = NULL;
14428
14492
g_return_val_if_fail (self != NULL, NULL);
14429
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
14493
vala_parser_get_location (self, &_tmp0_);
14494
_tmp1_ = _tmp0_;
14430
14495
begin = _tmp1_;
14431
14496
vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_BRACKET, &_inner_error_);
14432
14497
if (_inner_error_ != NULL) {
14442
14507
_tmp2_ = vala_parser_get_src (self, &begin);
14443
14508
_tmp3_ = _tmp2_;
14444
14509
_tmp4_ = vala_list_literal_new (_tmp3_);
14445
initializer = (_tmp5_ = _tmp4_, _vala_source_reference_unref0 (_tmp3_), _tmp5_);
14510
_tmp5_ = _tmp4_;
14511
_vala_source_reference_unref0 (_tmp3_);
14512
initializer = _tmp5_;
14446
14513
_tmp6_ = vala_parser_current (self);
14447
14514
if (_tmp6_ != VALA_TOKEN_TYPE_CLOSE_BRACKET) {
14448
14515
{
14510
14577
ValaTokenType _tmp6_;
14511
14578
GError * _inner_error_ = NULL;
14512
14579
g_return_val_if_fail (self != NULL, NULL);
14513
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
14580
vala_parser_get_location (self, &_tmp0_);
14581
_tmp1_ = _tmp0_;
14514
14582
begin = _tmp1_;
14515
14583
vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_BRACE, &_inner_error_);
14516
14584
if (_inner_error_ != NULL) {
14526
14594
_tmp2_ = vala_parser_get_src (self, &begin);
14527
14595
_tmp3_ = _tmp2_;
14528
14596
_tmp4_ = vala_set_literal_new (_tmp3_);
14529
set = (_tmp5_ = _tmp4_, _vala_source_reference_unref0 (_tmp3_), _tmp5_);
14597
_tmp5_ = _tmp4_;
14598
_vala_source_reference_unref0 (_tmp3_);
14599
set = _tmp5_;
14530
14600
first = TRUE;
14531
14601
_tmp6_ = vala_parser_current (self);
14532
14602
if (_tmp6_ != VALA_TOKEN_TYPE_CLOSE_BRACE) {
14628
14698
ValaTokenType _tmp6_;
14629
14699
GError * _inner_error_ = NULL;
14630
14700
g_return_val_if_fail (self != NULL, NULL);
14631
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
14701
vala_parser_get_location (self, &_tmp0_);
14702
_tmp1_ = _tmp0_;
14632
14703
begin = _tmp1_;
14633
14704
vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_BRACE, &_inner_error_);
14634
14705
if (_inner_error_ != NULL) {
14644
14715
_tmp2_ = vala_parser_get_src (self, &begin);
14645
14716
_tmp3_ = _tmp2_;
14646
14717
_tmp4_ = vala_map_literal_new (_tmp3_);
14647
map = (_tmp5_ = _tmp4_, _vala_source_reference_unref0 (_tmp3_), _tmp5_);
14718
_tmp5_ = _tmp4_;
14719
_vala_source_reference_unref0 (_tmp3_);
14720
map = _tmp5_;
14648
14721
_tmp6_ = vala_parser_current (self);
14649
14722
if (_tmp6_ != VALA_TOKEN_TYPE_CLOSE_BRACE) {
14650
14723
{
14759
14832
GError * _inner_error_ = NULL;
14760
14833
g_return_if_fail (self != NULL);
14761
14834
g_return_if_fail (parent != NULL);
14762
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
14835
vala_parser_get_location (self, &_tmp0_);
14836
_tmp1_ = _tmp0_;
14763
14837
begin = _tmp1_;
14764
14838
_tmp2_ = vala_parser_parse_access_modifier (self, VALA_SYMBOL_ACCESSIBILITY_PRIVATE);
14765
14839
access = _tmp2_;
14810
14884
_tmp7_ = vala_parser_get_src (self, &begin);
14811
14885
_tmp8_ = _tmp7_;
14812
14886
_tmp9_ = vala_method_new (id, type, _tmp8_, self->priv->comment);
14813
method = (_tmp10_ = _tmp9_, _vala_source_reference_unref0 (_tmp8_), _tmp10_);
14887
_tmp10_ = _tmp9_;
14888
_vala_source_reference_unref0 (_tmp8_);
14889
method = _tmp10_;
14814
14890
vala_symbol_set_access ((ValaSymbol*) method, access);
14815
14891
vala_parser_set_attributes (self, (ValaCodeNode*) method, attrs);
14816
14892
{
14912
14988
_tmp26_ = vala_parser_get_error (self, "only one of `abstract', `virtual', or `override' may be specified");
14913
14989
_tmp27_ = _tmp26_;
14914
14990
_tmp28_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp27_);
14915
_inner_error_ = (_tmp29_ = _tmp28_, _g_free0 (_tmp27_), _tmp29_);
14991
_tmp29_ = _tmp28_;
14992
_g_free0 (_tmp27_);
14993
_inner_error_ = _tmp29_;
14916
14994
if (_inner_error_->domain == VALA_PARSE_ERROR) {
14917
14995
g_propagate_error (error, _inner_error_);
14918
14996
_vala_code_node_unref0 (method);
14952
15030
"static methods");
14953
15031
_tmp33_ = _tmp32_;
14954
15032
_tmp34_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp33_);
14955
_inner_error_ = (_tmp35_ = _tmp34_, _g_free0 (_tmp33_), _tmp35_);
15033
_tmp35_ = _tmp34_;
15034
_g_free0 (_tmp33_);
15035
_inner_error_ = _tmp35_;
14956
15036
if (_inner_error_->domain == VALA_PARSE_ERROR) {
14957
15037
g_propagate_error (error, _inner_error_);
14958
15038
_vala_code_node_unref0 (method);
15073
15153
_tmp44_ = _tmp43_;
15074
15154
_tmp45_ = vala_code_node_get_source_reference ((ValaCodeNode*) method);
15075
15155
_tmp46_ = vala_unresolved_type_new_from_symbol (_tmp44_, _tmp45_);
15076
error_type = (_tmp47_ = _tmp46_, _vala_code_node_unref0 (_tmp44_), _vala_code_node_unref0 (_tmp42_), _tmp47_);
15156
_tmp47_ = _tmp46_;
15157
_vala_code_node_unref0 (_tmp44_);
15158
_vala_code_node_unref0 (_tmp42_);
15159
error_type = _tmp47_;
15077
15160
vala_code_node_add_error_type ((ValaCodeNode*) method, (ValaDataType*) error_type);
15078
15161
_tmp48_ = vala_parser_accept (self, VALA_TOKEN_TYPE_THROWS);
15079
15162
if (_tmp48_) {
15375
15458
ValaProperty* prop;
15376
15459
gboolean _tmp16_ = FALSE;
15377
15460
ValaProfile _tmp19_;
15378
gboolean _tmp90_ = FALSE;
15379
gboolean _tmp91_;
15461
gboolean _tmp87_ = FALSE;
15462
gboolean _tmp88_;
15380
15463
GError * _inner_error_ = NULL;
15381
15464
g_return_if_fail (self != NULL);
15382
15465
g_return_if_fail (parent != NULL);
15383
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
15466
vala_parser_get_location (self, &_tmp0_);
15467
_tmp1_ = _tmp0_;
15384
15468
begin = _tmp1_;
15385
15469
_tmp2_ = vala_parser_parse_access_modifier (self, VALA_SYMBOL_ACCESSIBILITY_PRIVATE);
15386
15470
access = _tmp2_;
15436
15520
_tmp11_ = vala_parser_get_src (self, &begin);
15437
15521
_tmp12_ = _tmp11_;
15438
15522
_tmp13_ = vala_property_new (id, type, NULL, NULL, _tmp12_, self->priv->comment);
15439
prop = (_tmp14_ = _tmp13_, _vala_source_reference_unref0 (_tmp12_), _tmp14_);
15523
_tmp14_ = _tmp13_;
15524
_vala_source_reference_unref0 (_tmp12_);
15525
prop = _tmp14_;
15440
15526
vala_symbol_set_access ((ValaSymbol*) prop, access);
15441
15527
vala_parser_set_attributes (self, (ValaCodeNode*) prop, attrs);
15442
15528
if ((flags & VALA_PARSER_MODIFIER_FLAGS_STATIC) == VALA_PARSER_MODIFIER_FLAGS_STATIC) {
15563
15649
_tmp30_ = vala_parser_get_error (self, "property default value already defined");
15564
15650
_tmp31_ = _tmp30_;
15565
15651
_tmp32_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp31_);
15566
_inner_error_ = (_tmp33_ = _tmp32_, _g_free0 (_tmp31_), _tmp33_);
15652
_tmp33_ = _tmp32_;
15653
_g_free0 (_tmp31_);
15654
_inner_error_ = _tmp33_;
15567
15655
if (_inner_error_->domain == VALA_PARSE_ERROR) {
15568
15656
g_propagate_error (error, _inner_error_);
15569
15657
_vala_code_node_unref0 (prop);
15636
15724
}
15637
15725
} else {
15638
15726
ValaComment* _tmp37_ = NULL;
15639
ValaComment* _tmp38_;
15727
ValaSourceLocation _tmp38_ = {0};
15640
15728
ValaSourceLocation _tmp39_ = {0};
15641
ValaSourceLocation _tmp40_ = {0};
15642
15729
ValaSourceLocation accessor_begin;
15643
ValaList* _tmp41_ = NULL;
15730
ValaList* _tmp40_ = NULL;
15644
15731
ValaList* accessor_attrs;
15645
ValaSymbolAccessibility _tmp42_;
15732
ValaSymbolAccessibility _tmp41_;
15646
15733
ValaSymbolAccessibility accessor_access;
15647
ValaDataType* _tmp43_ = NULL;
15734
ValaDataType* _tmp42_ = NULL;
15648
15735
ValaDataType* value_type;
15649
gboolean _tmp44_ = FALSE;
15650
ValaProfile _tmp45_;
15651
gboolean _tmp47_;
15736
gboolean _tmp43_ = FALSE;
15737
ValaProfile _tmp44_;
15738
gboolean _tmp46_;
15652
15739
_tmp37_ = vala_scanner_pop_comment (self->priv->scanner);
15653
_tmp38_ = _tmp37_;
15654
15740
_vala_comment_unref0 (self->priv->comment);
15655
self->priv->comment = _tmp38_;
15656
_tmp40_ = (vala_parser_get_location (self, &_tmp39_), _tmp39_);
15657
accessor_begin = _tmp40_;
15658
_tmp41_ = vala_parser_parse_attributes (self, &_inner_error_);
15659
accessor_attrs = _tmp41_;
15741
self->priv->comment = _tmp37_;
15742
vala_parser_get_location (self, &_tmp38_);
15743
_tmp39_ = _tmp38_;
15744
accessor_begin = _tmp39_;
15745
_tmp40_ = vala_parser_parse_attributes (self, &_inner_error_);
15746
accessor_attrs = _tmp40_;
15660
15747
if (_inner_error_ != NULL) {
15661
15748
if (_inner_error_->domain == VALA_PARSE_ERROR) {
15662
15749
g_propagate_error (error, _inner_error_);
15673
15760
return;
15674
15761
}
15675
15762
}
15676
_tmp42_ = vala_parser_parse_access_modifier (self, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
15677
accessor_access = _tmp42_;
15678
_tmp43_ = vala_data_type_copy (type);
15679
value_type = _tmp43_;
15680
_tmp45_ = vala_code_context_get_profile (self->priv->context);
15681
if (_tmp45_ != VALA_PROFILE_DOVA) {
15682
gboolean _tmp46_;
15683
_tmp46_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OWNED);
15684
_tmp44_ = _tmp46_;
15763
_tmp41_ = vala_parser_parse_access_modifier (self, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
15764
accessor_access = _tmp41_;
15765
_tmp42_ = vala_data_type_copy (type);
15766
value_type = _tmp42_;
15767
_tmp44_ = vala_code_context_get_profile (self->priv->context);
15768
if (_tmp44_ != VALA_PROFILE_DOVA) {
15769
gboolean _tmp45_;
15770
_tmp45_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OWNED);
15771
_tmp43_ = _tmp45_;
15685
15772
} else {
15686
_tmp44_ = FALSE;
15773
_tmp43_ = FALSE;
15687
15774
}
15688
vala_data_type_set_value_owned (value_type, _tmp44_);
15689
_tmp47_ = vala_parser_accept (self, VALA_TOKEN_TYPE_GET);
15690
if (_tmp47_) {
15691
ValaPropertyAccessor* _tmp48_ = NULL;
15775
vala_data_type_set_value_owned (value_type, _tmp43_);
15776
_tmp46_ = vala_parser_accept (self, VALA_TOKEN_TYPE_GET);
15777
if (_tmp46_) {
15778
ValaPropertyAccessor* _tmp47_ = NULL;
15692
15779
ValaBlock* block;
15693
gboolean _tmp53_;
15694
ValaSourceReference* _tmp57_ = NULL;
15695
ValaSourceReference* _tmp58_;
15780
gboolean _tmp52_;
15781
ValaSourceReference* _tmp55_ = NULL;
15782
ValaSourceReference* _tmp56_;
15783
ValaPropertyAccessor* _tmp57_ = NULL;
15784
ValaPropertyAccessor* _tmp58_;
15696
15785
ValaPropertyAccessor* _tmp59_ = NULL;
15697
ValaPropertyAccessor* _tmp60_;
15698
ValaPropertyAccessor* _tmp61_ = NULL;
15699
ValaPropertyAccessor* _tmp62_ = NULL;
15700
_tmp48_ = vala_property_get_get_accessor (prop);
15701
if (_tmp48_ != NULL) {
15702
gchar* _tmp49_ = NULL;
15703
gchar* _tmp50_;
15704
GError* _tmp51_ = NULL;
15705
GError* _tmp52_;
15706
_tmp49_ = vala_parser_get_error (self, "property get accessor already defined");
15707
_tmp50_ = _tmp49_;
15708
_tmp51_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp50_);
15709
_inner_error_ = (_tmp52_ = _tmp51_, _g_free0 (_tmp50_), _tmp52_);
15786
ValaPropertyAccessor* _tmp60_ = NULL;
15787
_tmp47_ = vala_property_get_get_accessor (prop);
15788
if (_tmp47_ != NULL) {
15789
gchar* _tmp48_ = NULL;
15790
gchar* _tmp49_;
15791
GError* _tmp50_ = NULL;
15792
GError* _tmp51_;
15793
_tmp48_ = vala_parser_get_error (self, "property get accessor already defined");
15794
_tmp49_ = _tmp48_;
15795
_tmp50_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp49_);
15796
_tmp51_ = _tmp50_;
15797
_g_free0 (_tmp49_);
15798
_inner_error_ = _tmp51_;
15710
15799
if (_inner_error_->domain == VALA_PARSE_ERROR) {
15711
15800
g_propagate_error (error, _inner_error_);
15712
15801
_vala_code_node_unref0 (value_type);
15730
15819
vala_data_type_set_value_owned (value_type, TRUE);
15731
15820
}
15732
15821
block = NULL;
15733
_tmp53_ = vala_parser_accept (self, VALA_TOKEN_TYPE_SEMICOLON);
15734
if (!_tmp53_) {
15735
ValaBlock* _tmp54_ = NULL;
15736
ValaBlock* _tmp55_;
15737
ValaBlock* _tmp56_;
15738
_tmp54_ = vala_parser_parse_block (self, &_inner_error_);
15739
_tmp55_ = _tmp54_;
15822
_tmp52_ = vala_parser_accept (self, VALA_TOKEN_TYPE_SEMICOLON);
15823
if (!_tmp52_) {
15824
ValaBlock* _tmp53_ = NULL;
15825
ValaBlock* _tmp54_;
15826
_tmp53_ = vala_parser_parse_block (self, &_inner_error_);
15827
_tmp54_ = _tmp53_;
15740
15828
if (_inner_error_ != NULL) {
15741
15829
if (_inner_error_->domain == VALA_PARSE_ERROR) {
15742
15830
g_propagate_error (error, _inner_error_);
15759
15847
return;
15760
15848
}
15761
15849
}
15762
_tmp56_ = _tmp55_;
15763
15850
_vala_code_node_unref0 (block);
15764
block = _tmp56_;
15851
block = _tmp54_;
15765
15852
vala_symbol_set_external ((ValaSymbol*) prop, FALSE);
15766
15853
}
15767
_tmp57_ = vala_parser_get_src (self, &accessor_begin);
15854
_tmp55_ = vala_parser_get_src (self, &accessor_begin);
15855
_tmp56_ = _tmp55_;
15856
_tmp57_ = vala_property_accessor_new (TRUE, FALSE, FALSE, value_type, block, _tmp56_, self->priv->comment);
15768
15857
_tmp58_ = _tmp57_;
15769
_tmp59_ = vala_property_accessor_new (TRUE, FALSE, FALSE, value_type, block, _tmp58_, self->priv->comment);
15770
_tmp60_ = _tmp59_;
15771
vala_property_set_get_accessor (prop, _tmp60_);
15772
_vala_code_node_unref0 (_tmp60_);
15773
_vala_source_reference_unref0 (_tmp58_);
15774
_tmp61_ = vala_property_get_get_accessor (prop);
15775
vala_parser_set_attributes (self, (ValaCodeNode*) _tmp61_, accessor_attrs);
15776
_tmp62_ = vala_property_get_get_accessor (prop);
15777
vala_symbol_set_access ((ValaSymbol*) _tmp62_, accessor_access);
15858
vala_property_set_get_accessor (prop, _tmp58_);
15859
_vala_code_node_unref0 (_tmp58_);
15860
_vala_source_reference_unref0 (_tmp56_);
15861
_tmp59_ = vala_property_get_get_accessor (prop);
15862
vala_parser_set_attributes (self, (ValaCodeNode*) _tmp59_, accessor_attrs);
15863
_tmp60_ = vala_property_get_get_accessor (prop);
15864
vala_symbol_set_access ((ValaSymbol*) _tmp60_, accessor_access);
15778
15865
_vala_code_node_unref0 (block);
15779
15866
} else {
15780
15867
gboolean writable = FALSE;
15781
15868
gboolean _construct = FALSE;
15782
gboolean _tmp63_;
15783
ValaPropertyAccessor* _tmp75_ = NULL;
15869
gboolean _tmp61_;
15870
ValaPropertyAccessor* _tmp73_ = NULL;
15784
15871
ValaBlock* block;
15785
gboolean _tmp80_;
15786
ValaSourceReference* _tmp84_ = NULL;
15787
ValaSourceReference* _tmp85_;
15872
gboolean _tmp78_;
15873
ValaSourceReference* _tmp81_ = NULL;
15874
ValaSourceReference* _tmp82_;
15875
ValaPropertyAccessor* _tmp83_ = NULL;
15876
ValaPropertyAccessor* _tmp84_;
15877
ValaPropertyAccessor* _tmp85_ = NULL;
15788
15878
ValaPropertyAccessor* _tmp86_ = NULL;
15789
ValaPropertyAccessor* _tmp87_;
15790
ValaPropertyAccessor* _tmp88_ = NULL;
15791
ValaPropertyAccessor* _tmp89_ = NULL;
15792
_tmp63_ = vala_parser_accept (self, VALA_TOKEN_TYPE_SET);
15793
if (_tmp63_) {
15794
gboolean _tmp64_ = FALSE;
15795
ValaProfile _tmp65_;
15879
_tmp61_ = vala_parser_accept (self, VALA_TOKEN_TYPE_SET);
15880
if (_tmp61_) {
15881
gboolean _tmp62_ = FALSE;
15882
ValaProfile _tmp63_;
15796
15883
writable = TRUE;
15797
_tmp65_ = vala_code_context_get_profile (self->priv->context);
15798
if (_tmp65_ == VALA_PROFILE_GOBJECT) {
15799
gboolean _tmp66_;
15800
_tmp66_ = vala_parser_accept (self, VALA_TOKEN_TYPE_CONSTRUCT);
15801
_tmp64_ = _tmp66_;
15884
_tmp63_ = vala_code_context_get_profile (self->priv->context);
15885
if (_tmp63_ == VALA_PROFILE_GOBJECT) {
15886
gboolean _tmp64_;
15887
_tmp64_ = vala_parser_accept (self, VALA_TOKEN_TYPE_CONSTRUCT);
15888
_tmp62_ = _tmp64_;
15802
15889
} else {
15803
_tmp64_ = FALSE;
15890
_tmp62_ = FALSE;
15804
15891
}
15805
_construct = _tmp64_;
15892
_construct = _tmp62_;
15806
15893
} else {
15807
gboolean _tmp67_ = FALSE;
15808
ValaProfile _tmp68_;
15809
_tmp68_ = vala_code_context_get_profile (self->priv->context);
15810
if (_tmp68_ == VALA_PROFILE_GOBJECT) {
15811
gboolean _tmp69_;
15812
_tmp69_ = vala_parser_accept (self, VALA_TOKEN_TYPE_CONSTRUCT);
15813
_tmp67_ = _tmp69_;
15894
gboolean _tmp65_ = FALSE;
15895
ValaProfile _tmp66_;
15896
_tmp66_ = vala_code_context_get_profile (self->priv->context);
15897
if (_tmp66_ == VALA_PROFILE_GOBJECT) {
15898
gboolean _tmp67_;
15899
_tmp67_ = vala_parser_accept (self, VALA_TOKEN_TYPE_CONSTRUCT);
15900
_tmp65_ = _tmp67_;
15814
15901
} else {
15815
_tmp67_ = FALSE;
15902
_tmp65_ = FALSE;
15816
15903
}
15817
if (_tmp67_) {
15818
gboolean _tmp70_;
15904
if (_tmp65_) {
15905
gboolean _tmp68_;
15819
15906
_construct = TRUE;
15820
_tmp70_ = vala_parser_accept (self, VALA_TOKEN_TYPE_SET);
15821
writable = _tmp70_;
15907
_tmp68_ = vala_parser_accept (self, VALA_TOKEN_TYPE_SET);
15908
writable = _tmp68_;
15822
15909
} else {
15823
gchar* _tmp71_ = NULL;
15824
gchar* _tmp72_;
15825
GError* _tmp73_ = NULL;
15826
GError* _tmp74_;
15827
_tmp71_ = vala_parser_get_error (self, "expected get, set, or construct");
15910
gchar* _tmp69_ = NULL;
15911
gchar* _tmp70_;
15912
GError* _tmp71_ = NULL;
15913
GError* _tmp72_;
15914
_tmp69_ = vala_parser_get_error (self, "expected get, set, or construct");
15915
_tmp70_ = _tmp69_;
15916
_tmp71_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp70_);
15828
15917
_tmp72_ = _tmp71_;
15829
_tmp73_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp72_);
15830
_inner_error_ = (_tmp74_ = _tmp73_, _g_free0 (_tmp72_), _tmp74_);
15918
_g_free0 (_tmp70_);
15919
_inner_error_ = _tmp72_;
15831
15920
if (_inner_error_->domain == VALA_PARSE_ERROR) {
15832
15921
g_propagate_error (error, _inner_error_);
15833
15922
_vala_code_node_unref0 (value_type);
15848
15937
}
15849
15938
}
15850
15939
}
15851
_tmp75_ = vala_property_get_set_accessor (prop);
15852
if (_tmp75_ != NULL) {
15853
gchar* _tmp76_ = NULL;
15854
gchar* _tmp77_;
15855
GError* _tmp78_ = NULL;
15856
GError* _tmp79_;
15857
_tmp76_ = vala_parser_get_error (self, "property set accessor already defined");
15940
_tmp73_ = vala_property_get_set_accessor (prop);
15941
if (_tmp73_ != NULL) {
15942
gchar* _tmp74_ = NULL;
15943
gchar* _tmp75_;
15944
GError* _tmp76_ = NULL;
15945
GError* _tmp77_;
15946
_tmp74_ = vala_parser_get_error (self, "property set accessor already defined");
15947
_tmp75_ = _tmp74_;
15948
_tmp76_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp75_);
15858
15949
_tmp77_ = _tmp76_;
15859
_tmp78_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp77_);
15860
_inner_error_ = (_tmp79_ = _tmp78_, _g_free0 (_tmp77_), _tmp79_);
15950
_g_free0 (_tmp75_);
15951
_inner_error_ = _tmp77_;
15861
15952
if (_inner_error_->domain == VALA_PARSE_ERROR) {
15862
15953
g_propagate_error (error, _inner_error_);
15863
15954
_vala_code_node_unref0 (value_type);
15878
15969
}
15879
15970
}
15880
15971
block = NULL;
15881
_tmp80_ = vala_parser_accept (self, VALA_TOKEN_TYPE_SEMICOLON);
15882
if (!_tmp80_) {
15883
ValaBlock* _tmp81_ = NULL;
15884
ValaBlock* _tmp82_;
15885
ValaBlock* _tmp83_;
15886
_tmp81_ = vala_parser_parse_block (self, &_inner_error_);
15887
_tmp82_ = _tmp81_;
15972
_tmp78_ = vala_parser_accept (self, VALA_TOKEN_TYPE_SEMICOLON);
15973
if (!_tmp78_) {
15974
ValaBlock* _tmp79_ = NULL;
15975
ValaBlock* _tmp80_;
15976
_tmp79_ = vala_parser_parse_block (self, &_inner_error_);
15977
_tmp80_ = _tmp79_;
15888
15978
if (_inner_error_ != NULL) {
15889
15979
if (_inner_error_->domain == VALA_PARSE_ERROR) {
15890
15980
g_propagate_error (error, _inner_error_);
15907
15997
return;
15908
15998
}
15909
15999
}
15910
_tmp83_ = _tmp82_;
15911
16000
_vala_code_node_unref0 (block);
15912
block = _tmp83_;
16001
block = _tmp80_;
15913
16002
vala_symbol_set_external ((ValaSymbol*) prop, FALSE);
15914
16003
}
15915
_tmp84_ = vala_parser_get_src (self, &accessor_begin);
15916
_tmp85_ = _tmp84_;
15917
_tmp86_ = vala_property_accessor_new (FALSE, writable, _construct, value_type, block, _tmp85_, self->priv->comment);
15918
_tmp87_ = _tmp86_;
15919
vala_property_set_set_accessor (prop, _tmp87_);
15920
_vala_code_node_unref0 (_tmp87_);
15921
_vala_source_reference_unref0 (_tmp85_);
15922
_tmp88_ = vala_property_get_set_accessor (prop);
15923
vala_parser_set_attributes (self, (ValaCodeNode*) _tmp88_, accessor_attrs);
15924
_tmp89_ = vala_property_get_set_accessor (prop);
15925
vala_symbol_set_access ((ValaSymbol*) _tmp89_, accessor_access);
16004
_tmp81_ = vala_parser_get_src (self, &accessor_begin);
16005
_tmp82_ = _tmp81_;
16006
_tmp83_ = vala_property_accessor_new (FALSE, writable, _construct, value_type, block, _tmp82_, self->priv->comment);
16007
_tmp84_ = _tmp83_;
16008
vala_property_set_set_accessor (prop, _tmp84_);
16009
_vala_code_node_unref0 (_tmp84_);
16010
_vala_source_reference_unref0 (_tmp82_);
16011
_tmp85_ = vala_property_get_set_accessor (prop);
16012
vala_parser_set_attributes (self, (ValaCodeNode*) _tmp85_, accessor_attrs);
16013
_tmp86_ = vala_property_get_set_accessor (prop);
16014
vala_symbol_set_access ((ValaSymbol*) _tmp86_, accessor_access);
15926
16015
_vala_code_node_unref0 (block);
15927
16016
}
15928
16017
_vala_code_node_unref0 (value_type);
15946
16035
return;
15947
16036
}
15948
16037
}
15949
_tmp91_ = vala_property_get_is_abstract (prop);
15950
if (!_tmp91_) {
15951
ValaSourceFileType _tmp92_;
15952
_tmp92_ = vala_symbol_get_source_type ((ValaSymbol*) prop);
15953
_tmp90_ = _tmp92_ == VALA_SOURCE_FILE_TYPE_SOURCE;
16038
_tmp88_ = vala_property_get_is_abstract (prop);
16039
if (!_tmp88_) {
16040
ValaSourceFileType _tmp89_;
16041
_tmp89_ = vala_symbol_get_source_type ((ValaSymbol*) prop);
16042
_tmp87_ = _tmp89_ == VALA_SOURCE_FILE_TYPE_SOURCE;
15954
16043
} else {
15955
_tmp90_ = FALSE;
16044
_tmp87_ = FALSE;
15956
16045
}
15957
if (_tmp90_) {
15958
gboolean _tmp93_ = FALSE;
15959
ValaPropertyAccessor* _tmp94_ = NULL;
16046
if (_tmp87_) {
16047
gboolean _tmp90_ = FALSE;
16048
ValaPropertyAccessor* _tmp91_ = NULL;
15960
16049
gboolean empty_get;
15961
gboolean _tmp97_ = FALSE;
15962
ValaPropertyAccessor* _tmp98_ = NULL;
16050
gboolean _tmp94_ = FALSE;
16051
ValaPropertyAccessor* _tmp95_ = NULL;
15963
16052
gboolean empty_set;
15964
gboolean _tmp103_ = FALSE;
15965
_tmp94_ = vala_property_get_get_accessor (prop);
15966
if (_tmp94_ != NULL) {
15967
ValaPropertyAccessor* _tmp95_ = NULL;
15968
ValaBlock* _tmp96_ = NULL;
15969
_tmp95_ = vala_property_get_get_accessor (prop);
15970
_tmp96_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp95_);
15971
_tmp93_ = _tmp96_ == NULL;
15972
} else {
15973
_tmp93_ = FALSE;
15974
}
15975
empty_get = _tmp93_;
15976
_tmp98_ = vala_property_get_set_accessor (prop);
15977
if (_tmp98_ != NULL) {
15978
ValaPropertyAccessor* _tmp99_ = NULL;
15979
ValaBlock* _tmp100_ = NULL;
15980
_tmp99_ = vala_property_get_set_accessor (prop);
15981
_tmp100_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp99_);
15982
_tmp97_ = _tmp100_ == NULL;
15983
} else {
15984
_tmp97_ = FALSE;
15985
}
15986
empty_set = _tmp97_;
16053
gboolean _tmp100_ = FALSE;
16054
_tmp91_ = vala_property_get_get_accessor (prop);
16055
if (_tmp91_ != NULL) {
16056
ValaPropertyAccessor* _tmp92_ = NULL;
16057
ValaBlock* _tmp93_ = NULL;
16058
_tmp92_ = vala_property_get_get_accessor (prop);
16059
_tmp93_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp92_);
16060
_tmp90_ = _tmp93_ == NULL;
16061
} else {
16062
_tmp90_ = FALSE;
16063
}
16064
empty_get = _tmp90_;
16065
_tmp95_ = vala_property_get_set_accessor (prop);
16066
if (_tmp95_ != NULL) {
16067
ValaPropertyAccessor* _tmp96_ = NULL;
16068
ValaBlock* _tmp97_ = NULL;
16069
_tmp96_ = vala_property_get_set_accessor (prop);
16070
_tmp97_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp96_);
16071
_tmp94_ = _tmp97_ == NULL;
16072
} else {
16073
_tmp94_ = FALSE;
16074
}
16075
empty_set = _tmp94_;
15987
16076
if (empty_get != empty_set) {
15988
16077
if (empty_get) {
15989
ValaSourceReference* _tmp101_ = NULL;
15990
_tmp101_ = vala_code_node_get_source_reference ((ValaCodeNode*) prop);
15991
vala_report_error (_tmp101_, "property getter must have a body");
16078
ValaSourceReference* _tmp98_ = NULL;
16079
_tmp98_ = vala_code_node_get_source_reference ((ValaCodeNode*) prop);
16080
vala_report_error (_tmp98_, "property getter must have a body");
15992
16081
} else {
15993
16082
if (empty_set) {
15994
ValaSourceReference* _tmp102_ = NULL;
15995
_tmp102_ = vala_code_node_get_source_reference ((ValaCodeNode*) prop);
15996
vala_report_error (_tmp102_, "property setter must have a body");
16083
ValaSourceReference* _tmp99_ = NULL;
16084
_tmp99_ = vala_code_node_get_source_reference ((ValaCodeNode*) prop);
16085
vala_report_error (_tmp99_, "property setter must have a body");
15997
16086
}
15998
16087
}
15999
16088
vala_code_node_set_error ((ValaCodeNode*) prop, TRUE);
16000
16089
}
16001
16090
if (empty_get) {
16002
_tmp103_ = empty_set;
16091
_tmp100_ = empty_set;
16003
16092
} else {
16004
_tmp103_ = FALSE;
16093
_tmp100_ = FALSE;
16005
16094
}
16006
if (_tmp103_) {
16007
ValaDataType* _tmp104_ = NULL;
16008
ValaDataType* _tmp105_ = NULL;
16095
if (_tmp100_) {
16096
ValaDataType* _tmp101_ = NULL;
16097
ValaDataType* _tmp102_ = NULL;
16009
16098
ValaDataType* variable_type;
16010
const gchar* _tmp106_ = NULL;
16011
gchar* _tmp107_ = NULL;
16012
gchar* _tmp108_;
16013
ValaExpression* _tmp109_ = NULL;
16014
ValaSourceReference* _tmp110_ = NULL;
16099
const gchar* _tmp103_ = NULL;
16100
gchar* _tmp104_ = NULL;
16101
gchar* _tmp105_;
16102
ValaExpression* _tmp106_ = NULL;
16103
ValaSourceReference* _tmp107_ = NULL;
16104
ValaField* _tmp108_ = NULL;
16105
ValaField* _tmp109_;
16106
ValaField* _tmp110_ = NULL;
16015
16107
ValaField* _tmp111_ = NULL;
16016
ValaField* _tmp112_;
16017
ValaField* _tmp113_ = NULL;
16018
ValaField* _tmp114_ = NULL;
16019
ValaMemberBinding _tmp115_;
16020
_tmp104_ = vala_property_get_property_type (prop);
16021
_tmp105_ = vala_data_type_copy (_tmp104_);
16022
variable_type = _tmp105_;
16023
_tmp106_ = vala_symbol_get_name ((ValaSymbol*) prop);
16024
_tmp107_ = g_strdup_printf ("_%s", _tmp106_);
16025
_tmp108_ = _tmp107_;
16026
_tmp109_ = vala_property_get_initializer (prop);
16027
_tmp110_ = vala_code_node_get_source_reference ((ValaCodeNode*) prop);
16028
_tmp111_ = vala_field_new (_tmp108_, variable_type, _tmp109_, _tmp110_, NULL);
16029
_tmp112_ = _tmp111_;
16030
vala_property_set_field (prop, _tmp112_);
16031
_vala_code_node_unref0 (_tmp112_);
16032
_g_free0 (_tmp108_);
16033
_tmp113_ = vala_property_get_field (prop);
16034
vala_symbol_set_access ((ValaSymbol*) _tmp113_, VALA_SYMBOL_ACCESSIBILITY_PRIVATE);
16035
_tmp114_ = vala_property_get_field (prop);
16036
_tmp115_ = vala_property_get_binding (prop);
16037
vala_field_set_binding (_tmp114_, _tmp115_);
16108
ValaMemberBinding _tmp112_;
16109
_tmp101_ = vala_property_get_property_type (prop);
16110
_tmp102_ = vala_data_type_copy (_tmp101_);
16111
variable_type = _tmp102_;
16112
_tmp103_ = vala_symbol_get_name ((ValaSymbol*) prop);
16113
_tmp104_ = g_strdup_printf ("_%s", _tmp103_);
16114
_tmp105_ = _tmp104_;
16115
_tmp106_ = vala_property_get_initializer (prop);
16116
_tmp107_ = vala_code_node_get_source_reference ((ValaCodeNode*) prop);
16117
_tmp108_ = vala_field_new (_tmp105_, variable_type, _tmp106_, _tmp107_, NULL);
16118
_tmp109_ = _tmp108_;
16119
vala_property_set_field (prop, _tmp109_);
16120
_vala_code_node_unref0 (_tmp109_);
16121
_g_free0 (_tmp105_);
16122
_tmp110_ = vala_property_get_field (prop);
16123
vala_symbol_set_access ((ValaSymbol*) _tmp110_, VALA_SYMBOL_ACCESSIBILITY_PRIVATE);
16124
_tmp111_ = vala_property_get_field (prop);
16125
_tmp112_ = vala_property_get_binding (prop);
16126
vala_field_set_binding (_tmp111_, _tmp112_);
16038
16127
_vala_code_node_unref0 (variable_type);
16039
16128
} else {
16040
ValaExpression* _tmp116_ = NULL;
16041
_tmp116_ = vala_property_get_initializer (prop);
16042
if (_tmp116_ != NULL) {
16043
ValaExpression* _tmp117_ = NULL;
16044
ValaSourceReference* _tmp118_ = NULL;
16045
_tmp117_ = vala_property_get_initializer (prop);
16046
_tmp118_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp117_);
16047
vala_report_error (_tmp118_, "only automatic properties can have default values");
16129
ValaExpression* _tmp113_ = NULL;
16130
_tmp113_ = vala_property_get_initializer (prop);
16131
if (_tmp113_ != NULL) {
16132
ValaExpression* _tmp114_ = NULL;
16133
ValaSourceReference* _tmp115_ = NULL;
16134
_tmp114_ = vala_property_get_initializer (prop);
16135
_tmp115_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp114_);
16136
vala_report_error (_tmp115_, "only automatic properties can have default values");
16048
16137
}
16049
16138
}
16050
16139
}
16077
16166
GError * _inner_error_ = NULL;
16078
16167
g_return_if_fail (self != NULL);
16079
16168
g_return_if_fail (parent != NULL);
16080
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
16169
vala_parser_get_location (self, &_tmp0_);
16170
_tmp1_ = _tmp0_;
16081
16171
begin = _tmp1_;
16082
16172
_tmp2_ = vala_parser_parse_access_modifier (self, VALA_SYMBOL_ACCESSIBILITY_PRIVATE);
16083
16173
access = _tmp2_;
16123
16213
_tmp6_ = vala_parser_get_src (self, &begin);
16124
16214
_tmp7_ = _tmp6_;
16125
16215
_tmp8_ = vala_signal_new (id, type, _tmp7_, self->priv->comment);
16126
sig = (_tmp9_ = _tmp8_, _vala_source_reference_unref0 (_tmp7_), _tmp9_);
16216
_tmp9_ = _tmp8_;
16217
_vala_source_reference_unref0 (_tmp7_);
16218
sig = _tmp9_;
16127
16219
vala_symbol_set_access ((ValaSymbol*) sig, access);
16128
16220
vala_parser_set_attributes (self, (ValaCodeNode*) sig, attrs);
16129
16221
if ((flags & VALA_PARSER_MODIFIER_FLAGS_STATIC) == VALA_PARSER_MODIFIER_FLAGS_STATIC) {
16134
16226
_tmp10_ = vala_parser_get_error (self, "`static' modifier not allowed on signals");
16135
16227
_tmp11_ = _tmp10_;
16136
16228
_tmp12_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp11_);
16137
_inner_error_ = (_tmp13_ = _tmp12_, _g_free0 (_tmp11_), _tmp13_);
16229
_tmp13_ = _tmp12_;
16230
_g_free0 (_tmp11_);
16231
_inner_error_ = _tmp13_;
16138
16232
if (_inner_error_->domain == VALA_PARSE_ERROR) {
16139
16233
g_propagate_error (error, _inner_error_);
16140
16234
_vala_code_node_unref0 (sig);
16158
16252
_tmp14_ = vala_parser_get_error (self, "`class' modifier not allowed on signals");
16159
16253
_tmp15_ = _tmp14_;
16160
16254
_tmp16_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp15_);
16161
_inner_error_ = (_tmp17_ = _tmp16_, _g_free0 (_tmp15_), _tmp17_);
16255
_tmp17_ = _tmp16_;
16256
_g_free0 (_tmp15_);
16257
_inner_error_ = _tmp17_;
16162
16258
if (_inner_error_->domain == VALA_PARSE_ERROR) {
16163
16259
g_propagate_error (error, _inner_error_);
16164
16260
_vala_code_node_unref0 (sig);
16305
16401
GError * _inner_error_ = NULL;
16306
16402
g_return_if_fail (self != NULL);
16307
16403
g_return_if_fail (parent != NULL);
16308
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
16404
vala_parser_get_location (self, &_tmp0_);
16405
_tmp1_ = _tmp0_;
16309
16406
begin = _tmp1_;
16310
16407
_tmp2_ = vala_parser_parse_member_declaration_modifiers (self);
16311
16408
flags = _tmp2_;
16328
16425
_tmp3_ = vala_parser_get_error (self, "`new' modifier not allowed on constructor");
16329
16426
_tmp4_ = _tmp3_;
16330
16427
_tmp5_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp4_);
16331
_inner_error_ = (_tmp6_ = _tmp5_, _g_free0 (_tmp4_), _tmp6_);
16428
_tmp6_ = _tmp5_;
16429
_g_free0 (_tmp4_);
16430
_inner_error_ = _tmp6_;
16332
16431
if (_inner_error_->domain == VALA_PARSE_ERROR) {
16333
16432
g_propagate_error (error, _inner_error_);
16334
16433
return;
16341
16440
_tmp7_ = vala_parser_get_src (self, &begin);
16342
16441
_tmp8_ = _tmp7_;
16343
16442
_tmp9_ = vala_constructor_new (_tmp8_);
16344
c = (_tmp10_ = _tmp9_, _vala_source_reference_unref0 (_tmp8_), _tmp10_);
16443
_tmp10_ = _tmp9_;
16444
_vala_source_reference_unref0 (_tmp8_);
16445
c = _tmp10_;
16345
16446
if ((flags & VALA_PARSER_MODIFIER_FLAGS_STATIC) == VALA_PARSER_MODIFIER_FLAGS_STATIC) {
16346
16447
vala_constructor_set_binding (c, VALA_MEMBER_BINDING_STATIC);
16347
16448
} else {
16390
16491
GError * _inner_error_ = NULL;
16391
16492
g_return_if_fail (self != NULL);
16392
16493
g_return_if_fail (parent != NULL);
16393
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
16494
vala_parser_get_location (self, &_tmp0_);
16495
_tmp1_ = _tmp0_;
16394
16496
begin = _tmp1_;
16395
16497
_tmp2_ = vala_parser_parse_member_declaration_modifiers (self);
16396
16498
flags = _tmp2_;
16448
16550
_tmp5_ = vala_parser_get_error (self, "`new' modifier not allowed on destructor");
16449
16551
_tmp6_ = _tmp5_;
16450
16552
_tmp7_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp6_);
16451
_inner_error_ = (_tmp8_ = _tmp7_, _g_free0 (_tmp6_), _tmp8_);
16553
_tmp8_ = _tmp7_;
16554
_g_free0 (_tmp6_);
16555
_inner_error_ = _tmp8_;
16452
16556
if (_inner_error_->domain == VALA_PARSE_ERROR) {
16453
16557
g_propagate_error (error, _inner_error_);
16454
16558
return;
16461
16565
_tmp9_ = vala_parser_get_src (self, &begin);
16462
16566
_tmp10_ = _tmp9_;
16463
16567
_tmp11_ = vala_destructor_new (_tmp10_);
16464
d = (_tmp12_ = _tmp11_, _vala_source_reference_unref0 (_tmp10_), _tmp12_);
16568
_tmp12_ = _tmp11_;
16569
_vala_source_reference_unref0 (_tmp10_);
16570
d = _tmp12_;
16465
16571
if ((flags & VALA_PARSER_MODIFIER_FLAGS_STATIC) == VALA_PARSER_MODIFIER_FLAGS_STATIC) {
16466
16572
vala_destructor_set_binding (d, VALA_MEMBER_BINDING_STATIC);
16467
16573
} else {
16505
16611
ValaList* type_param_list;
16506
16612
ValaDataType* base_type;
16507
16613
gboolean _tmp6_;
16508
const gchar* _tmp10_ = NULL;
16509
ValaSourceReference* _tmp11_ = NULL;
16510
ValaSourceReference* _tmp12_;
16511
ValaStruct* _tmp13_ = NULL;
16512
ValaStruct* _tmp14_;
16614
const gchar* _tmp9_ = NULL;
16615
ValaSourceReference* _tmp10_ = NULL;
16616
ValaSourceReference* _tmp11_;
16617
ValaStruct* _tmp12_ = NULL;
16618
ValaStruct* _tmp13_;
16513
16619
ValaStruct* st;
16514
gboolean _tmp15_ = FALSE;
16515
ValaSymbol* _tmp21_;
16620
gboolean _tmp14_ = FALSE;
16621
ValaSymbol* _tmp20_;
16516
16622
ValaSymbol* _result_;
16517
16623
GError * _inner_error_ = NULL;
16518
16624
g_return_if_fail (self != NULL);
16519
16625
g_return_if_fail (parent != NULL);
16520
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
16626
vala_parser_get_location (self, &_tmp0_);
16627
_tmp1_ = _tmp0_;
16521
16628
begin = _tmp1_;
16522
16629
_tmp2_ = vala_parser_parse_access_modifier (self, VALA_SYMBOL_ACCESSIBILITY_PRIVATE);
16523
16630
access = _tmp2_;
16565
16672
if (_tmp6_) {
16566
16673
ValaDataType* _tmp7_ = NULL;
16567
16674
ValaDataType* _tmp8_;
16568
ValaDataType* _tmp9_;
16569
16675
_tmp7_ = vala_parser_parse_type (self, TRUE, FALSE, &_inner_error_);
16570
16676
_tmp8_ = _tmp7_;
16571
16677
if (_inner_error_ != NULL) {
16584
16690
return;
16585
16691
}
16586
16692
}
16587
_tmp9_ = _tmp8_;
16588
16693
_vala_code_node_unref0 (base_type);
16589
base_type = _tmp9_;
16694
base_type = _tmp8_;
16590
16695
}
16591
_tmp10_ = vala_symbol_get_name ((ValaSymbol*) sym);
16592
_tmp11_ = vala_parser_get_src (self, &begin);
16593
_tmp12_ = _tmp11_;
16594
_tmp13_ = vala_struct_new (_tmp10_, _tmp12_, self->priv->comment);
16595
st = (_tmp14_ = _tmp13_, _vala_source_reference_unref0 (_tmp12_), _tmp14_);
16696
_tmp9_ = vala_symbol_get_name ((ValaSymbol*) sym);
16697
_tmp10_ = vala_parser_get_src (self, &begin);
16698
_tmp11_ = _tmp10_;
16699
_tmp12_ = vala_struct_new (_tmp9_, _tmp11_, self->priv->comment);
16700
_tmp13_ = _tmp12_;
16701
_vala_source_reference_unref0 (_tmp11_);
16702
st = _tmp13_;
16596
16703
vala_symbol_set_access ((ValaSymbol*) st, access);
16597
16704
if ((flags & VALA_PARSER_MODIFIER_FLAGS_EXTERN) == VALA_PARSER_MODIFIER_FLAGS_EXTERN) {
16598
_tmp15_ = TRUE;
16705
_tmp14_ = TRUE;
16599
16706
} else {
16600
ValaSourceFile* _tmp16_ = NULL;
16601
ValaSourceFileType _tmp17_;
16602
_tmp16_ = vala_scanner_get_source_file (self->priv->scanner);
16603
_tmp17_ = vala_source_file_get_file_type (_tmp16_);
16604
_tmp15_ = _tmp17_ == VALA_SOURCE_FILE_TYPE_PACKAGE;
16707
ValaSourceFile* _tmp15_ = NULL;
16708
ValaSourceFileType _tmp16_;
16709
_tmp15_ = vala_scanner_get_source_file (self->priv->scanner);
16710
_tmp16_ = vala_source_file_get_file_type (_tmp15_);
16711
_tmp14_ = _tmp16_ == VALA_SOURCE_FILE_TYPE_PACKAGE;
16605
16712
}
16606
if (_tmp15_) {
16713
if (_tmp14_) {
16607
16714
vala_symbol_set_external ((ValaSymbol*) st, TRUE);
16608
16715
}
16609
16716
vala_parser_set_attributes (self, (ValaCodeNode*) st, attrs);
16610
16717
{
16611
ValaList* _tmp18_;
16718
ValaList* _tmp17_;
16612
16719
ValaList* _type_param_list;
16613
gint _tmp19_;
16720
gint _tmp18_;
16614
16721
gint _type_param_size;
16615
16722
gint _type_param_index;
16616
_tmp18_ = _vala_iterable_ref0 (type_param_list);
16617
_type_param_list = _tmp18_;
16618
_tmp19_ = vala_collection_get_size ((ValaCollection*) _type_param_list);
16619
_type_param_size = _tmp19_;
16723
_tmp17_ = _vala_iterable_ref0 (type_param_list);
16724
_type_param_list = _tmp17_;
16725
_tmp18_ = vala_collection_get_size ((ValaCollection*) _type_param_list);
16726
_type_param_size = _tmp18_;
16620
16727
_type_param_index = -1;
16621
16728
while (TRUE) {
16622
gpointer _tmp20_ = NULL;
16729
gpointer _tmp19_ = NULL;
16623
16730
ValaTypeParameter* type_param;
16624
16731
_type_param_index = _type_param_index + 1;
16625
16732
if (!(_type_param_index < _type_param_size)) {
16626
16733
break;
16627
16734
}
16628
_tmp20_ = vala_list_get (_type_param_list, _type_param_index);
16629
type_param = (ValaTypeParameter*) _tmp20_;
16735
_tmp19_ = vala_list_get (_type_param_list, _type_param_index);
16736
type_param = (ValaTypeParameter*) _tmp19_;
16630
16737
vala_struct_add_type_parameter (st, type_param);
16631
16738
_vala_code_node_unref0 (type_param);
16632
16739
}
16654
16761
return;
16655
16762
}
16656
16763
}
16657
_tmp21_ = _vala_code_node_ref0 ((ValaSymbol*) st);
16658
_result_ = _tmp21_;
16764
_tmp20_ = _vala_code_node_ref0 ((ValaSymbol*) st);
16765
_result_ = _tmp20_;
16659
16766
while (TRUE) {
16660
ValaUnresolvedSymbol* _tmp22_ = NULL;
16661
ValaUnresolvedSymbol* _tmp23_;
16662
ValaUnresolvedSymbol* _tmp24_;
16663
ValaSymbol* _tmp25_ = NULL;
16664
ValaSymbol* _tmp32_;
16767
ValaUnresolvedSymbol* _tmp21_ = NULL;
16768
ValaUnresolvedSymbol* _tmp22_;
16769
ValaSymbol* _tmp23_ = NULL;
16770
ValaSymbol* _tmp28_;
16665
16771
ValaSymbol* next;
16666
ValaSymbol* _tmp33_;
16667
ValaSymbol* _tmp34_;
16772
ValaSymbol* _tmp29_;
16668
16773
if (!(sym != NULL)) {
16669
16774
break;
16670
16775
}
16671
_tmp22_ = vala_unresolved_symbol_get_inner (sym);
16672
_tmp23_ = _vala_code_node_ref0 (_tmp22_);
16673
_tmp24_ = _tmp23_;
16776
_tmp21_ = vala_unresolved_symbol_get_inner (sym);
16777
_tmp22_ = _vala_code_node_ref0 (_tmp21_);
16674
16778
_vala_code_node_unref0 (sym);
16675
sym = _tmp24_;
16779
sym = _tmp22_;
16676
16780
if (sym != NULL) {
16677
const gchar* _tmp26_ = NULL;
16678
ValaSourceReference* _tmp27_ = NULL;
16679
ValaNamespace* _tmp28_ = NULL;
16680
ValaSymbol* _tmp29_;
16681
_tmp26_ = vala_symbol_get_name ((ValaSymbol*) sym);
16682
_tmp27_ = vala_code_node_get_source_reference ((ValaCodeNode*) st);
16683
_tmp28_ = vala_namespace_new (_tmp26_, _tmp27_);
16684
_tmp29_ = (ValaSymbol*) _tmp28_;
16685
_vala_code_node_unref0 (_tmp25_);
16686
_tmp25_ = _tmp29_;
16781
const gchar* _tmp24_ = NULL;
16782
ValaSourceReference* _tmp25_ = NULL;
16783
ValaNamespace* _tmp26_ = NULL;
16784
_tmp24_ = vala_symbol_get_name ((ValaSymbol*) sym);
16785
_tmp25_ = vala_code_node_get_source_reference ((ValaCodeNode*) st);
16786
_tmp26_ = vala_namespace_new (_tmp24_, _tmp25_);
16787
_vala_code_node_unref0 (_tmp23_);
16788
_tmp23_ = (ValaSymbol*) _tmp26_;
16687
16789
} else {
16688
ValaSymbol* _tmp30_;
16689
ValaSymbol* _tmp31_;
16690
_tmp30_ = _vala_code_node_ref0 (parent);
16691
_tmp31_ = _tmp30_;
16692
_vala_code_node_unref0 (_tmp25_);
16693
_tmp25_ = _tmp31_;
16790
ValaSymbol* _tmp27_;
16791
_tmp27_ = _vala_code_node_ref0 (parent);
16792
_vala_code_node_unref0 (_tmp23_);
16793
_tmp23_ = _tmp27_;
16694
16794
}
16695
_tmp32_ = _vala_code_node_ref0 (_tmp25_);
16696
next = _tmp32_;
16795
_tmp28_ = _vala_code_node_ref0 (_tmp23_);
16796
next = _tmp28_;
16697
16797
if (VALA_IS_NAMESPACE (_result_)) {
16698
16798
vala_symbol_add_namespace (next, VALA_NAMESPACE (_result_));
16699
16799
} else {
16700
16800
vala_symbol_add_struct (next, VALA_STRUCT (_result_));
16701
16801
}
16702
_tmp33_ = _vala_code_node_ref0 (next);
16703
_tmp34_ = _tmp33_;
16802
_tmp29_ = _vala_code_node_ref0 (next);
16704
16803
_vala_code_node_unref0 (_result_);
16705
_result_ = _tmp34_;
16804
_result_ = _tmp29_;
16706
16805
_vala_code_node_unref0 (next);
16707
_vala_code_node_unref0 (_tmp25_);
16806
_vala_code_node_unref0 (_tmp23_);
16708
16807
}
16709
16808
_vala_code_node_unref0 (_result_);
16710
16809
_vala_code_node_unref0 (st);
16741
16840
GError * _inner_error_ = NULL;
16742
16841
g_return_if_fail (self != NULL);
16743
16842
g_return_if_fail (parent != NULL);
16744
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
16843
vala_parser_get_location (self, &_tmp0_);
16844
_tmp1_ = _tmp0_;
16745
16845
begin = _tmp1_;
16746
16846
_tmp2_ = vala_parser_parse_access_modifier (self, VALA_SYMBOL_ACCESSIBILITY_PRIVATE);
16747
16847
access = _tmp2_;
16829
16929
_tmp12_ = vala_parser_get_src (self, &begin);
16830
16930
_tmp13_ = _tmp12_;
16831
16931
_tmp14_ = vala_interface_new (_tmp11_, _tmp13_, self->priv->comment);
16832
iface = (_tmp15_ = _tmp14_, _vala_source_reference_unref0 (_tmp13_), _tmp15_);
16932
_tmp15_ = _tmp14_;
16933
_vala_source_reference_unref0 (_tmp13_);
16934
iface = _tmp15_;
16833
16935
vala_symbol_set_access ((ValaSymbol*) iface, access);
16834
16936
if ((flags & VALA_PARSER_MODIFIER_FLAGS_EXTERN) == VALA_PARSER_MODIFIER_FLAGS_EXTERN) {
16835
16937
_tmp16_ = TRUE;
16918
17020
while (TRUE) {
16919
17021
ValaUnresolvedSymbol* _tmp26_ = NULL;
16920
17022
ValaUnresolvedSymbol* _tmp27_;
16921
ValaUnresolvedSymbol* _tmp28_;
16922
ValaSymbol* _tmp29_ = NULL;
16923
ValaSymbol* _tmp36_;
17023
ValaSymbol* _tmp28_ = NULL;
17024
ValaSymbol* _tmp33_;
16924
17025
ValaSymbol* next;
16925
ValaSymbol* _tmp37_;
16926
ValaSymbol* _tmp38_;
17026
ValaSymbol* _tmp34_;
16927
17027
if (!(sym != NULL)) {
16928
17028
break;
16929
17029
}
16930
17030
_tmp26_ = vala_unresolved_symbol_get_inner (sym);
16931
17031
_tmp27_ = _vala_code_node_ref0 (_tmp26_);
16932
_tmp28_ = _tmp27_;
16933
17032
_vala_code_node_unref0 (sym);
16934
sym = _tmp28_;
17033
sym = _tmp27_;
16935
17034
if (sym != NULL) {
16936
const gchar* _tmp30_ = NULL;
16937
ValaSourceReference* _tmp31_ = NULL;
16938
ValaNamespace* _tmp32_ = NULL;
16939
ValaSymbol* _tmp33_;
16940
_tmp30_ = vala_symbol_get_name ((ValaSymbol*) sym);
16941
_tmp31_ = vala_code_node_get_source_reference ((ValaCodeNode*) iface);
16942
_tmp32_ = vala_namespace_new (_tmp30_, _tmp31_);
16943
_tmp33_ = (ValaSymbol*) _tmp32_;
16944
_vala_code_node_unref0 (_tmp29_);
16945
_tmp29_ = _tmp33_;
17035
const gchar* _tmp29_ = NULL;
17036
ValaSourceReference* _tmp30_ = NULL;
17037
ValaNamespace* _tmp31_ = NULL;
17038
_tmp29_ = vala_symbol_get_name ((ValaSymbol*) sym);
17039
_tmp30_ = vala_code_node_get_source_reference ((ValaCodeNode*) iface);
17040
_tmp31_ = vala_namespace_new (_tmp29_, _tmp30_);
17041
_vala_code_node_unref0 (_tmp28_);
17042
_tmp28_ = (ValaSymbol*) _tmp31_;
16946
17043
} else {
16947
ValaSymbol* _tmp34_;
16948
ValaSymbol* _tmp35_;
16949
_tmp34_ = _vala_code_node_ref0 (parent);
16950
_tmp35_ = _tmp34_;
16951
_vala_code_node_unref0 (_tmp29_);
16952
_tmp29_ = _tmp35_;
17044
ValaSymbol* _tmp32_;
17045
_tmp32_ = _vala_code_node_ref0 (parent);
17046
_vala_code_node_unref0 (_tmp28_);
17047
_tmp28_ = _tmp32_;
16953
17048
}
16954
_tmp36_ = _vala_code_node_ref0 (_tmp29_);
16955
next = _tmp36_;
17049
_tmp33_ = _vala_code_node_ref0 (_tmp28_);
17050
next = _tmp33_;
16956
17051
if (VALA_IS_NAMESPACE (_result_)) {
16957
17052
vala_symbol_add_namespace (next, VALA_NAMESPACE (_result_));
16958
17053
} else {
16959
17054
vala_symbol_add_interface (next, VALA_INTERFACE (_result_));
16960
17055
}
16961
_tmp37_ = _vala_code_node_ref0 (next);
16962
_tmp38_ = _tmp37_;
17056
_tmp34_ = _vala_code_node_ref0 (next);
16963
17057
_vala_code_node_unref0 (_result_);
16964
_result_ = _tmp38_;
17058
_result_ = _tmp34_;
16965
17059
_vala_code_node_unref0 (next);
16966
_vala_code_node_unref0 (_tmp29_);
17060
_vala_code_node_unref0 (_tmp28_);
16967
17061
}
16968
17062
_vala_code_node_unref0 (_result_);
16969
17063
_vala_code_node_unref0 (iface);
16990
17084
ValaEnum* _tmp9_;
16991
17085
ValaEnum* en;
16992
17086
gboolean _tmp10_ = FALSE;
16993
gboolean _tmp34_;
16994
ValaSymbol* _tmp36_;
17087
gboolean _tmp32_;
17088
ValaSymbol* _tmp34_;
16995
17089
ValaSymbol* _result_;
16996
17090
GError * _inner_error_ = NULL;
16997
17091
g_return_if_fail (self != NULL);
16998
17092
g_return_if_fail (parent != NULL);
16999
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
17093
vala_parser_get_location (self, &_tmp0_);
17094
_tmp1_ = _tmp0_;
17000
17095
begin = _tmp1_;
17001
17096
_tmp2_ = vala_parser_parse_access_modifier (self, VALA_SYMBOL_ACCESSIBILITY_PRIVATE);
17002
17097
access = _tmp2_;
17029
17124
_tmp6_ = vala_parser_get_src (self, &begin);
17030
17125
_tmp7_ = _tmp6_;
17031
17126
_tmp8_ = vala_enum_new (_tmp5_, _tmp7_, self->priv->comment);
17032
en = (_tmp9_ = _tmp8_, _vala_source_reference_unref0 (_tmp7_), _tmp9_);
17127
_tmp9_ = _tmp8_;
17128
_vala_source_reference_unref0 (_tmp7_);
17129
en = _tmp9_;
17033
17130
vala_symbol_set_access ((ValaSymbol*) en, access);
17034
17131
if ((flags & VALA_PARSER_MODIFIER_FLAGS_EXTERN) == VALA_PARSER_MODIFIER_FLAGS_EXTERN) {
17035
17132
_tmp10_ = TRUE;
17073
17170
gchar* _tmp23_ = NULL;
17074
17171
gchar* id;
17075
17172
ValaComment* _tmp24_ = NULL;
17076
ValaComment* _tmp25_;
17077
17173
ValaExpression* value;
17078
gboolean _tmp26_;
17079
ValaSourceReference* _tmp30_ = NULL;
17080
ValaSourceReference* _tmp31_;
17081
ValaEnumValue* _tmp32_ = NULL;
17082
ValaEnumValue* _tmp33_;
17174
gboolean _tmp25_;
17175
ValaSourceReference* _tmp28_ = NULL;
17176
ValaSourceReference* _tmp29_;
17177
ValaEnumValue* _tmp30_ = NULL;
17178
ValaEnumValue* _tmp31_;
17083
17179
ValaEnumValue* ev;
17084
17180
if (!_tmp13_) {
17085
17181
gboolean _tmp14_;
17121
17217
return;
17122
17218
}
17123
17219
}
17124
_tmp22_ = (vala_parser_get_location (self, &_tmp21_), _tmp21_);
17220
vala_parser_get_location (self, &_tmp21_);
17221
_tmp22_ = _tmp21_;
17125
17222
value_begin = _tmp22_;
17126
17223
_tmp23_ = vala_parser_parse_identifier (self, &_inner_error_);
17127
17224
id = _tmp23_;
17142
17239
}
17143
17240
}
17144
17241
_tmp24_ = vala_scanner_pop_comment (self->priv->scanner);
17145
_tmp25_ = _tmp24_;
17146
17242
_vala_comment_unref0 (self->priv->comment);
17147
self->priv->comment = _tmp25_;
17243
self->priv->comment = _tmp24_;
17148
17244
value = NULL;
17149
_tmp26_ = vala_parser_accept (self, VALA_TOKEN_TYPE_ASSIGN);
17150
if (_tmp26_) {
17151
ValaExpression* _tmp27_ = NULL;
17152
ValaExpression* _tmp28_;
17153
ValaExpression* _tmp29_;
17154
_tmp27_ = vala_parser_parse_expression (self, &_inner_error_);
17155
_tmp28_ = _tmp27_;
17245
_tmp25_ = vala_parser_accept (self, VALA_TOKEN_TYPE_ASSIGN);
17246
if (_tmp25_) {
17247
ValaExpression* _tmp26_ = NULL;
17248
ValaExpression* _tmp27_;
17249
_tmp26_ = vala_parser_parse_expression (self, &_inner_error_);
17250
_tmp27_ = _tmp26_;
17156
17251
if (_inner_error_ != NULL) {
17157
17252
if (_inner_error_->domain == VALA_PARSE_ERROR) {
17158
17253
g_propagate_error (error, _inner_error_);
17173
17268
return;
17174
17269
}
17175
17270
}
17176
_tmp29_ = _tmp28_;
17177
17271
_vala_code_node_unref0 (value);
17178
value = _tmp29_;
17272
value = _tmp27_;
17179
17273
}
17180
_tmp30_ = vala_parser_get_src (self, &value_begin);
17274
_tmp28_ = vala_parser_get_src (self, &value_begin);
17275
_tmp29_ = _tmp28_;
17276
_tmp30_ = vala_enum_value_new (id, value, _tmp29_, self->priv->comment);
17181
17277
_tmp31_ = _tmp30_;
17182
_tmp32_ = vala_enum_value_new (id, value, _tmp31_, self->priv->comment);
17183
ev = (_tmp33_ = _tmp32_, _vala_source_reference_unref0 (_tmp31_), _tmp33_);
17278
_vala_source_reference_unref0 (_tmp29_);
17279
ev = _tmp31_;
17184
17280
vala_symbol_set_access ((ValaSymbol*) ev, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
17185
17281
vala_parser_set_attributes (self, (ValaCodeNode*) ev, value_attrs);
17186
17282
vala_enum_add_value (en, ev);
17190
17286
_vala_iterable_unref0 (value_attrs);
17191
17287
}
17192
17288
}
17193
_tmp34_ = vala_parser_accept (self, VALA_TOKEN_TYPE_SEMICOLON);
17194
if (_tmp34_) {
17289
_tmp32_ = vala_parser_accept (self, VALA_TOKEN_TYPE_SEMICOLON);
17290
if (_tmp32_) {
17195
17291
while (TRUE) {
17196
ValaTokenType _tmp35_;
17197
_tmp35_ = vala_parser_current (self);
17198
if (!(_tmp35_ != VALA_TOKEN_TYPE_CLOSE_BRACE)) {
17292
ValaTokenType _tmp33_;
17293
_tmp33_ = vala_parser_current (self);
17294
if (!(_tmp33_ != VALA_TOKEN_TYPE_CLOSE_BRACE)) {
17199
17295
break;
17200
17296
}
17201
17297
vala_parser_parse_declaration (self, (ValaSymbol*) en, FALSE, &_inner_error_);
17230
17326
return;
17231
17327
}
17232
17328
}
17233
_tmp36_ = _vala_code_node_ref0 ((ValaSymbol*) en);
17234
_result_ = _tmp36_;
17329
_tmp34_ = _vala_code_node_ref0 ((ValaSymbol*) en);
17330
_result_ = _tmp34_;
17235
17331
while (TRUE) {
17236
ValaUnresolvedSymbol* _tmp37_ = NULL;
17237
ValaUnresolvedSymbol* _tmp38_;
17238
ValaUnresolvedSymbol* _tmp39_;
17239
ValaSymbol* _tmp40_ = NULL;
17240
ValaSymbol* _tmp47_;
17332
ValaUnresolvedSymbol* _tmp35_ = NULL;
17333
ValaUnresolvedSymbol* _tmp36_;
17334
ValaSymbol* _tmp37_ = NULL;
17335
ValaSymbol* _tmp42_;
17241
17336
ValaSymbol* next;
17242
ValaSymbol* _tmp48_;
17243
ValaSymbol* _tmp49_;
17337
ValaSymbol* _tmp43_;
17244
17338
if (!(sym != NULL)) {
17245
17339
break;
17246
17340
}
17247
_tmp37_ = vala_unresolved_symbol_get_inner (sym);
17248
_tmp38_ = _vala_code_node_ref0 (_tmp37_);
17249
_tmp39_ = _tmp38_;
17341
_tmp35_ = vala_unresolved_symbol_get_inner (sym);
17342
_tmp36_ = _vala_code_node_ref0 (_tmp35_);
17250
17343
_vala_code_node_unref0 (sym);
17251
sym = _tmp39_;
17344
sym = _tmp36_;
17252
17345
if (sym != NULL) {
17253
const gchar* _tmp41_ = NULL;
17254
ValaSourceReference* _tmp42_ = NULL;
17255
ValaNamespace* _tmp43_ = NULL;
17256
ValaSymbol* _tmp44_;
17257
_tmp41_ = vala_symbol_get_name ((ValaSymbol*) sym);
17258
_tmp42_ = vala_code_node_get_source_reference ((ValaCodeNode*) en);
17259
_tmp43_ = vala_namespace_new (_tmp41_, _tmp42_);
17260
_tmp44_ = (ValaSymbol*) _tmp43_;
17261
_vala_code_node_unref0 (_tmp40_);
17262
_tmp40_ = _tmp44_;
17346
const gchar* _tmp38_ = NULL;
17347
ValaSourceReference* _tmp39_ = NULL;
17348
ValaNamespace* _tmp40_ = NULL;
17349
_tmp38_ = vala_symbol_get_name ((ValaSymbol*) sym);
17350
_tmp39_ = vala_code_node_get_source_reference ((ValaCodeNode*) en);
17351
_tmp40_ = vala_namespace_new (_tmp38_, _tmp39_);
17352
_vala_code_node_unref0 (_tmp37_);
17353
_tmp37_ = (ValaSymbol*) _tmp40_;
17263
17354
} else {
17264
ValaSymbol* _tmp45_;
17265
ValaSymbol* _tmp46_;
17266
_tmp45_ = _vala_code_node_ref0 (parent);
17267
_tmp46_ = _tmp45_;
17268
_vala_code_node_unref0 (_tmp40_);
17269
_tmp40_ = _tmp46_;
17355
ValaSymbol* _tmp41_;
17356
_tmp41_ = _vala_code_node_ref0 (parent);
17357
_vala_code_node_unref0 (_tmp37_);
17358
_tmp37_ = _tmp41_;
17270
17359
}
17271
_tmp47_ = _vala_code_node_ref0 (_tmp40_);
17272
next = _tmp47_;
17360
_tmp42_ = _vala_code_node_ref0 (_tmp37_);
17361
next = _tmp42_;
17273
17362
if (VALA_IS_NAMESPACE (_result_)) {
17274
17363
vala_symbol_add_namespace (next, VALA_NAMESPACE (_result_));
17275
17364
} else {
17276
17365
vala_symbol_add_enum (next, VALA_ENUM (_result_));
17277
17366
}
17278
_tmp48_ = _vala_code_node_ref0 (next);
17279
_tmp49_ = _tmp48_;
17367
_tmp43_ = _vala_code_node_ref0 (next);
17280
17368
_vala_code_node_unref0 (_result_);
17281
_result_ = _tmp49_;
17369
_result_ = _tmp43_;
17282
17370
_vala_code_node_unref0 (next);
17283
_vala_code_node_unref0 (_tmp40_);
17371
_vala_code_node_unref0 (_tmp37_);
17284
17372
}
17285
17373
_vala_code_node_unref0 (_result_);
17286
17374
_vala_code_node_unref0 (en);
17305
17393
ValaErrorDomain* _tmp9_;
17306
17394
ValaErrorDomain* ed;
17307
17395
gboolean _tmp10_ = FALSE;
17308
gboolean _tmp34_;
17309
ValaSymbol* _tmp36_;
17396
gboolean _tmp33_;
17397
ValaSymbol* _tmp35_;
17310
17398
ValaSymbol* _result_;
17311
17399
GError * _inner_error_ = NULL;
17312
17400
g_return_if_fail (self != NULL);
17313
17401
g_return_if_fail (parent != NULL);
17314
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
17402
vala_parser_get_location (self, &_tmp0_);
17403
_tmp1_ = _tmp0_;
17315
17404
begin = _tmp1_;
17316
17405
_tmp2_ = vala_parser_parse_access_modifier (self, VALA_SYMBOL_ACCESSIBILITY_PRIVATE);
17317
17406
access = _tmp2_;
17344
17433
_tmp6_ = vala_parser_get_src (self, &begin);
17345
17434
_tmp7_ = _tmp6_;
17346
17435
_tmp8_ = vala_error_domain_new (_tmp5_, _tmp7_, self->priv->comment);
17347
ed = (_tmp9_ = _tmp8_, _vala_source_reference_unref0 (_tmp7_), _tmp9_);
17436
_tmp9_ = _tmp8_;
17437
_vala_source_reference_unref0 (_tmp7_);
17438
ed = _tmp9_;
17348
17439
vala_symbol_set_access ((ValaSymbol*) ed, access);
17349
17440
if ((flags & VALA_PARSER_MODIFIER_FLAGS_EXTERN) == VALA_PARSER_MODIFIER_FLAGS_EXTERN) {
17350
17441
_tmp10_ = TRUE;
17388
17479
gchar* _tmp23_ = NULL;
17389
17480
gchar* id;
17390
17481
ValaComment* _tmp24_ = NULL;
17391
ValaComment* _tmp25_;
17392
ValaSourceReference* _tmp26_ = NULL;
17393
ValaSourceReference* _tmp27_;
17394
ValaErrorCode* _tmp28_ = NULL;
17395
ValaErrorCode* _tmp29_;
17482
ValaSourceReference* _tmp25_ = NULL;
17483
ValaSourceReference* _tmp26_;
17484
ValaErrorCode* _tmp27_ = NULL;
17485
ValaErrorCode* _tmp28_;
17396
17486
ValaErrorCode* ec;
17397
gboolean _tmp30_;
17487
gboolean _tmp29_;
17398
17488
if (!_tmp13_) {
17399
17489
gboolean _tmp14_;
17400
17490
_tmp14_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
17435
17525
return;
17436
17526
}
17437
17527
}
17438
_tmp22_ = (vala_parser_get_location (self, &_tmp21_), _tmp21_);
17528
vala_parser_get_location (self, &_tmp21_);
17529
_tmp22_ = _tmp21_;
17439
17530
code_begin = _tmp22_;
17440
17531
_tmp23_ = vala_parser_parse_identifier (self, &_inner_error_);
17441
17532
id = _tmp23_;
17456
17547
}
17457
17548
}
17458
17549
_tmp24_ = vala_scanner_pop_comment (self->priv->scanner);
17459
_tmp25_ = _tmp24_;
17460
17550
_vala_comment_unref0 (self->priv->comment);
17461
self->priv->comment = _tmp25_;
17462
_tmp26_ = vala_parser_get_src (self, &code_begin);
17463
_tmp27_ = _tmp26_;
17464
_tmp28_ = vala_error_code_new (id, _tmp27_, self->priv->comment);
17465
ec = (_tmp29_ = _tmp28_, _vala_source_reference_unref0 (_tmp27_), _tmp29_);
17551
self->priv->comment = _tmp24_;
17552
_tmp25_ = vala_parser_get_src (self, &code_begin);
17553
_tmp26_ = _tmp25_;
17554
_tmp27_ = vala_error_code_new (id, _tmp26_, self->priv->comment);
17555
_tmp28_ = _tmp27_;
17556
_vala_source_reference_unref0 (_tmp26_);
17557
ec = _tmp28_;
17466
17558
vala_parser_set_attributes (self, (ValaCodeNode*) ec, code_attrs);
17467
_tmp30_ = vala_parser_accept (self, VALA_TOKEN_TYPE_ASSIGN);
17468
if (_tmp30_) {
17469
ValaExpression* _tmp31_ = NULL;
17559
_tmp29_ = vala_parser_accept (self, VALA_TOKEN_TYPE_ASSIGN);
17560
if (_tmp29_) {
17561
ValaExpression* _tmp30_ = NULL;
17562
ValaExpression* _tmp31_;
17470
17563
ValaExpression* _tmp32_;
17471
ValaExpression* _tmp33_;
17472
_tmp31_ = vala_parser_parse_expression (self, &_inner_error_);
17473
_tmp32_ = _tmp31_;
17564
_tmp30_ = vala_parser_parse_expression (self, &_inner_error_);
17565
_tmp31_ = _tmp30_;
17474
17566
if (_inner_error_ != NULL) {
17475
17567
if (_inner_error_->domain == VALA_PARSE_ERROR) {
17476
17568
g_propagate_error (error, _inner_error_);
17491
17583
return;
17492
17584
}
17493
17585
}
17494
_tmp33_ = _tmp32_;
17495
vala_error_code_set_value (ec, _tmp33_);
17496
_vala_code_node_unref0 (_tmp33_);
17586
_tmp32_ = _tmp31_;
17587
vala_error_code_set_value (ec, _tmp32_);
17588
_vala_code_node_unref0 (_tmp32_);
17497
17589
}
17498
17590
vala_error_domain_add_code (ed, ec);
17499
17591
_vala_code_node_unref0 (ec);
17501
17593
_vala_iterable_unref0 (code_attrs);
17502
17594
}
17503
17595
}
17504
_tmp34_ = vala_parser_accept (self, VALA_TOKEN_TYPE_SEMICOLON);
17505
if (_tmp34_) {
17596
_tmp33_ = vala_parser_accept (self, VALA_TOKEN_TYPE_SEMICOLON);
17597
if (_tmp33_) {
17506
17598
while (TRUE) {
17507
ValaTokenType _tmp35_;
17508
_tmp35_ = vala_parser_current (self);
17509
if (!(_tmp35_ != VALA_TOKEN_TYPE_CLOSE_BRACE)) {
17599
ValaTokenType _tmp34_;
17600
_tmp34_ = vala_parser_current (self);
17601
if (!(_tmp34_ != VALA_TOKEN_TYPE_CLOSE_BRACE)) {
17510
17602
break;
17511
17603
}
17512
17604
vala_parser_parse_declaration (self, (ValaSymbol*) ed, FALSE, &_inner_error_);
17541
17633
return;
17542
17634
}
17543
17635
}
17544
_tmp36_ = _vala_code_node_ref0 ((ValaSymbol*) ed);
17545
_result_ = _tmp36_;
17636
_tmp35_ = _vala_code_node_ref0 ((ValaSymbol*) ed);
17637
_result_ = _tmp35_;
17546
17638
while (TRUE) {
17547
ValaUnresolvedSymbol* _tmp37_ = NULL;
17548
ValaUnresolvedSymbol* _tmp38_;
17549
ValaUnresolvedSymbol* _tmp39_;
17550
ValaSymbol* _tmp40_ = NULL;
17551
ValaSymbol* _tmp47_;
17639
ValaUnresolvedSymbol* _tmp36_ = NULL;
17640
ValaUnresolvedSymbol* _tmp37_;
17641
ValaSymbol* _tmp38_ = NULL;
17642
ValaSymbol* _tmp43_;
17552
17643
ValaSymbol* next;
17553
ValaSymbol* _tmp48_;
17554
ValaSymbol* _tmp49_;
17644
ValaSymbol* _tmp44_;
17555
17645
if (!(sym != NULL)) {
17556
17646
break;
17557
17647
}
17558
_tmp37_ = vala_unresolved_symbol_get_inner (sym);
17559
_tmp38_ = _vala_code_node_ref0 (_tmp37_);
17560
_tmp39_ = _tmp38_;
17648
_tmp36_ = vala_unresolved_symbol_get_inner (sym);
17649
_tmp37_ = _vala_code_node_ref0 (_tmp36_);
17561
17650
_vala_code_node_unref0 (sym);
17562
sym = _tmp39_;
17651
sym = _tmp37_;
17563
17652
if (sym != NULL) {
17564
const gchar* _tmp41_ = NULL;
17565
ValaSourceReference* _tmp42_ = NULL;
17566
ValaNamespace* _tmp43_ = NULL;
17567
ValaSymbol* _tmp44_;
17568
_tmp41_ = vala_symbol_get_name ((ValaSymbol*) sym);
17569
_tmp42_ = vala_code_node_get_source_reference ((ValaCodeNode*) ed);
17570
_tmp43_ = vala_namespace_new (_tmp41_, _tmp42_);
17571
_tmp44_ = (ValaSymbol*) _tmp43_;
17572
_vala_code_node_unref0 (_tmp40_);
17573
_tmp40_ = _tmp44_;
17653
const gchar* _tmp39_ = NULL;
17654
ValaSourceReference* _tmp40_ = NULL;
17655
ValaNamespace* _tmp41_ = NULL;
17656
_tmp39_ = vala_symbol_get_name ((ValaSymbol*) sym);
17657
_tmp40_ = vala_code_node_get_source_reference ((ValaCodeNode*) ed);
17658
_tmp41_ = vala_namespace_new (_tmp39_, _tmp40_);
17659
_vala_code_node_unref0 (_tmp38_);
17660
_tmp38_ = (ValaSymbol*) _tmp41_;
17574
17661
} else {
17575
ValaSymbol* _tmp45_;
17576
ValaSymbol* _tmp46_;
17577
_tmp45_ = _vala_code_node_ref0 (parent);
17578
_tmp46_ = _tmp45_;
17579
_vala_code_node_unref0 (_tmp40_);
17580
_tmp40_ = _tmp46_;
17662
ValaSymbol* _tmp42_;
17663
_tmp42_ = _vala_code_node_ref0 (parent);
17664
_vala_code_node_unref0 (_tmp38_);
17665
_tmp38_ = _tmp42_;
17581
17666
}
17582
_tmp47_ = _vala_code_node_ref0 (_tmp40_);
17583
next = _tmp47_;
17667
_tmp43_ = _vala_code_node_ref0 (_tmp38_);
17668
next = _tmp43_;
17584
17669
if (VALA_IS_NAMESPACE (_result_)) {
17585
17670
vala_symbol_add_namespace (next, VALA_NAMESPACE (_result_));
17586
17671
} else {
17587
17672
vala_symbol_add_error_domain (next, VALA_ERROR_DOMAIN (_result_));
17588
17673
}
17589
_tmp48_ = _vala_code_node_ref0 (next);
17590
_tmp49_ = _tmp48_;
17674
_tmp44_ = _vala_code_node_ref0 (next);
17591
17675
_vala_code_node_unref0 (_result_);
17592
_result_ = _tmp49_;
17676
_result_ = _tmp44_;
17593
17677
_vala_code_node_unref0 (next);
17594
_vala_code_node_unref0 (_tmp40_);
17678
_vala_code_node_unref0 (_tmp38_);
17595
17679
}
17596
17680
_vala_code_node_unref0 (_result_);
17597
17681
_vala_code_node_unref0 (ed);
17774
17858
gboolean _tmp9_;
17775
17859
ValaProfile _tmp11_;
17776
17860
ValaDataType* type = NULL;
17777
gchar* _tmp21_ = NULL;
17861
gchar* _tmp18_ = NULL;
17778
17862
gchar* id;
17779
ValaDataType* _tmp22_ = NULL;
17780
ValaDataType* _tmp23_;
17781
ValaDataType* _tmp24_;
17782
ValaSourceReference* _tmp25_ = NULL;
17783
ValaSourceReference* _tmp26_;
17784
ValaParameter* _tmp27_ = NULL;
17785
ValaParameter* _tmp28_;
17863
ValaDataType* _tmp19_ = NULL;
17864
ValaDataType* _tmp20_;
17865
ValaSourceReference* _tmp21_ = NULL;
17866
ValaSourceReference* _tmp22_;
17867
ValaParameter* _tmp23_ = NULL;
17868
ValaParameter* _tmp24_;
17786
17869
ValaParameter* param;
17787
gboolean _tmp29_;
17870
gboolean _tmp25_;
17788
17871
GError * _inner_error_ = NULL;
17789
17872
g_return_val_if_fail (self != NULL, NULL);
17790
17873
_tmp0_ = vala_parser_parse_attributes (self, &_inner_error_);
17799
17882
return NULL;
17800
17883
}
17801
17884
}
17802
_tmp2_ = (vala_parser_get_location (self, &_tmp1_), _tmp1_);
17885
vala_parser_get_location (self, &_tmp1_);
17886
_tmp2_ = _tmp1_;
17803
17887
begin = _tmp2_;
17804
17888
_tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_ELLIPSIS);
17805
17889
if (_tmp3_) {
17810
17894
_tmp4_ = vala_parser_get_src (self, &begin);
17811
17895
_tmp5_ = _tmp4_;
17812
17896
_tmp6_ = vala_parameter_new_with_ellipsis (_tmp5_);
17813
result = (_tmp7_ = _tmp6_, _vala_source_reference_unref0 (_tmp5_), _tmp7_);
17897
_tmp7_ = _tmp6_;
17898
_vala_source_reference_unref0 (_tmp5_);
17899
result = _tmp7_;
17814
17900
_vala_iterable_unref0 (attrs);
17815
17901
return result;
17816
17902
}
17834
17920
if (direction == VALA_PARAMETER_DIRECTION_IN) {
17835
17921
ValaDataType* _tmp12_ = NULL;
17836
17922
ValaDataType* _tmp13_;
17837
ValaDataType* _tmp14_;
17838
17923
_tmp12_ = vala_parser_parse_type (self, FALSE, FALSE, &_inner_error_);
17839
17924
_tmp13_ = _tmp12_;
17840
17925
if (_inner_error_ != NULL) {
17851
17936
return NULL;
17852
17937
}
17853
17938
}
17854
_tmp14_ = _tmp13_;
17855
17939
_vala_code_node_unref0 (type);
17856
type = _tmp14_;
17940
type = _tmp13_;
17857
17941
} else {
17858
17942
if (direction == VALA_PARAMETER_DIRECTION_REF) {
17859
ValaDataType* _tmp15_ = NULL;
17860
ValaDataType* _tmp16_;
17943
ValaDataType* _tmp14_ = NULL;
17944
ValaDataType* _tmp15_;
17945
_tmp14_ = vala_parser_parse_type (self, TRUE, TRUE, &_inner_error_);
17946
_tmp15_ = _tmp14_;
17947
if (_inner_error_ != NULL) {
17948
if (_inner_error_->domain == VALA_PARSE_ERROR) {
17949
g_propagate_error (error, _inner_error_);
17950
_vala_code_node_unref0 (type);
17951
_vala_iterable_unref0 (attrs);
17952
return NULL;
17953
} else {
17954
_vala_code_node_unref0 (type);
17955
_vala_iterable_unref0 (attrs);
17956
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
17957
g_clear_error (&_inner_error_);
17958
return NULL;
17959
}
17960
}
17961
_vala_code_node_unref0 (type);
17962
type = _tmp15_;
17963
} else {
17964
ValaDataType* _tmp16_ = NULL;
17861
17965
ValaDataType* _tmp17_;
17862
_tmp15_ = vala_parser_parse_type (self, TRUE, TRUE, &_inner_error_);
17863
_tmp16_ = _tmp15_;
17966
_tmp16_ = vala_parser_parse_type (self, TRUE, FALSE, &_inner_error_);
17967
_tmp17_ = _tmp16_;
17864
17968
if (_inner_error_ != NULL) {
17865
17969
if (_inner_error_->domain == VALA_PARSE_ERROR) {
17866
17970
g_propagate_error (error, _inner_error_);
17875
17979
return NULL;
17876
17980
}
17877
17981
}
17878
_tmp17_ = _tmp16_;
17879
17982
_vala_code_node_unref0 (type);
17880
17983
type = _tmp17_;
17881
} else {
17882
ValaDataType* _tmp18_ = NULL;
17883
ValaDataType* _tmp19_;
17884
ValaDataType* _tmp20_;
17885
_tmp18_ = vala_parser_parse_type (self, TRUE, FALSE, &_inner_error_);
17886
_tmp19_ = _tmp18_;
17887
if (_inner_error_ != NULL) {
17888
if (_inner_error_->domain == VALA_PARSE_ERROR) {
17889
g_propagate_error (error, _inner_error_);
17890
_vala_code_node_unref0 (type);
17891
_vala_iterable_unref0 (attrs);
17892
return NULL;
17893
} else {
17894
_vala_code_node_unref0 (type);
17895
_vala_iterable_unref0 (attrs);
17896
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
17897
g_clear_error (&_inner_error_);
17898
return NULL;
17899
}
17900
}
17901
_tmp20_ = _tmp19_;
17902
_vala_code_node_unref0 (type);
17903
type = _tmp20_;
17904
}
17905
}
17906
_tmp21_ = vala_parser_parse_identifier (self, &_inner_error_);
17907
id = _tmp21_;
17908
if (_inner_error_ != NULL) {
17909
if (_inner_error_->domain == VALA_PARSE_ERROR) {
17910
g_propagate_error (error, _inner_error_);
17911
_vala_code_node_unref0 (type);
17912
_vala_iterable_unref0 (attrs);
17913
return NULL;
17914
} else {
17915
_vala_code_node_unref0 (type);
17916
_vala_iterable_unref0 (attrs);
17917
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
17918
g_clear_error (&_inner_error_);
17919
return NULL;
17920
}
17921
}
17922
_tmp22_ = vala_parser_parse_inline_array_type (self, type, &_inner_error_);
17923
_tmp23_ = _tmp22_;
17924
if (_inner_error_ != NULL) {
17925
if (_inner_error_->domain == VALA_PARSE_ERROR) {
17926
g_propagate_error (error, _inner_error_);
17927
_g_free0 (id);
17928
_vala_code_node_unref0 (type);
17929
_vala_iterable_unref0 (attrs);
17930
return NULL;
17931
} else {
17932
_g_free0 (id);
17933
_vala_code_node_unref0 (type);
17934
_vala_iterable_unref0 (attrs);
17935
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
17936
g_clear_error (&_inner_error_);
17937
return NULL;
17938
}
17939
}
17984
}
17985
}
17986
_tmp18_ = vala_parser_parse_identifier (self, &_inner_error_);
17987
id = _tmp18_;
17988
if (_inner_error_ != NULL) {
17989
if (_inner_error_->domain == VALA_PARSE_ERROR) {
17990
g_propagate_error (error, _inner_error_);
17991
_vala_code_node_unref0 (type);
17992
_vala_iterable_unref0 (attrs);
17993
return NULL;
17994
} else {
17995
_vala_code_node_unref0 (type);
17996
_vala_iterable_unref0 (attrs);
17997
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
17998
g_clear_error (&_inner_error_);
17999
return NULL;
18000
}
18001
}
18002
_tmp19_ = vala_parser_parse_inline_array_type (self, type, &_inner_error_);
18003
_tmp20_ = _tmp19_;
18004
if (_inner_error_ != NULL) {
18005
if (_inner_error_->domain == VALA_PARSE_ERROR) {
18006
g_propagate_error (error, _inner_error_);
18007
_g_free0 (id);
18008
_vala_code_node_unref0 (type);
18009
_vala_iterable_unref0 (attrs);
18010
return NULL;
18011
} else {
18012
_g_free0 (id);
18013
_vala_code_node_unref0 (type);
18014
_vala_iterable_unref0 (attrs);
18015
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
18016
g_clear_error (&_inner_error_);
18017
return NULL;
18018
}
18019
}
18020
_vala_code_node_unref0 (type);
18021
type = _tmp20_;
18022
_tmp21_ = vala_parser_get_src (self, &begin);
18023
_tmp22_ = _tmp21_;
18024
_tmp23_ = vala_parameter_new (id, type, _tmp22_);
17940
18025
_tmp24_ = _tmp23_;
17941
_vala_code_node_unref0 (type);
17942
type = _tmp24_;
17943
_tmp25_ = vala_parser_get_src (self, &begin);
17944
_tmp26_ = _tmp25_;
17945
_tmp27_ = vala_parameter_new (id, type, _tmp26_);
17946
param = (_tmp28_ = _tmp27_, _vala_source_reference_unref0 (_tmp26_), _tmp28_);
18026
_vala_source_reference_unref0 (_tmp22_);
18027
param = _tmp24_;
17947
18028
vala_parser_set_attributes (self, (ValaCodeNode*) param, attrs);
17948
18029
vala_parameter_set_direction (param, direction);
17949
18030
vala_parameter_set_params_array (param, params_array);
17950
_tmp29_ = vala_parser_accept (self, VALA_TOKEN_TYPE_ASSIGN);
17951
if (_tmp29_) {
17952
ValaExpression* _tmp30_ = NULL;
17953
ValaExpression* _tmp31_;
17954
ValaExpression* _tmp32_;
17955
_tmp30_ = vala_parser_parse_expression (self, &_inner_error_);
17956
_tmp31_ = _tmp30_;
18031
_tmp25_ = vala_parser_accept (self, VALA_TOKEN_TYPE_ASSIGN);
18032
if (_tmp25_) {
18033
ValaExpression* _tmp26_ = NULL;
18034
ValaExpression* _tmp27_;
18035
ValaExpression* _tmp28_;
18036
_tmp26_ = vala_parser_parse_expression (self, &_inner_error_);
18037
_tmp27_ = _tmp26_;
17957
18038
if (_inner_error_ != NULL) {
17958
18039
if (_inner_error_->domain == VALA_PARSE_ERROR) {
17959
18040
g_propagate_error (error, _inner_error_);
17972
18053
return NULL;
17973
18054
}
17974
18055
}
17975
_tmp32_ = _tmp31_;
17976
vala_variable_set_initializer ((ValaVariable*) param, _tmp32_);
17977
_vala_code_node_unref0 (_tmp32_);
18056
_tmp28_ = _tmp27_;
18057
vala_variable_set_initializer ((ValaVariable*) param, _tmp28_);
18058
_vala_code_node_unref0 (_tmp28_);
17978
18059
}
17979
18060
result = param;
17980
18061
_g_free0 (id);
17996
18077
ValaUnresolvedSymbol* sym;
17997
18078
ValaCreationMethod* method = NULL;
17998
18079
ValaUnresolvedSymbol* _tmp9_ = NULL;
17999
gboolean _tmp22_ = FALSE;
18000
gboolean _tmp23_ = FALSE;
18001
ValaTokenType _tmp25_;
18002
ValaProfile _tmp29_;
18003
gboolean _tmp57_;
18080
gboolean _tmp20_ = FALSE;
18081
gboolean _tmp21_ = FALSE;
18082
ValaTokenType _tmp23_;
18083
ValaProfile _tmp27_;
18084
gboolean _tmp55_;
18004
18085
GError * _inner_error_ = NULL;
18005
18086
g_return_if_fail (self != NULL);
18006
18087
g_return_if_fail (parent != NULL);
18007
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
18088
vala_parser_get_location (self, &_tmp0_);
18089
_tmp1_ = _tmp0_;
18008
18090
begin = _tmp1_;
18009
18091
_tmp2_ = vala_parser_parse_access_modifier (self, VALA_SYMBOL_ACCESSIBILITY_PRIVATE);
18010
18092
access = _tmp2_;
18030
18112
_tmp5_ = vala_parser_get_error (self, "`new' modifier not allowed on creation method");
18031
18113
_tmp6_ = _tmp5_;
18032
18114
_tmp7_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp6_);
18033
_inner_error_ = (_tmp8_ = _tmp7_, _g_free0 (_tmp6_), _tmp8_);
18115
_tmp8_ = _tmp7_;
18116
_g_free0 (_tmp6_);
18117
_inner_error_ = _tmp8_;
18034
18118
if (_inner_error_->domain == VALA_PARSE_ERROR) {
18035
18119
g_propagate_error (error, _inner_error_);
18036
18120
_vala_code_node_unref0 (sym);
18048
18132
ValaSourceReference* _tmp11_ = NULL;
18049
18133
ValaSourceReference* _tmp12_;
18050
18134
ValaCreationMethod* _tmp13_ = NULL;
18051
ValaCreationMethod* _tmp14_;
18052
18135
_tmp10_ = vala_symbol_get_name ((ValaSymbol*) sym);
18053
18136
_tmp11_ = vala_parser_get_src (self, &begin);
18054
18137
_tmp12_ = _tmp11_;
18055
18138
_tmp13_ = vala_creation_method_new (_tmp10_, NULL, _tmp12_, self->priv->comment);
18056
_tmp14_ = _tmp13_;
18057
18139
_vala_code_node_unref0 (method);
18058
method = _tmp14_;
18140
method = _tmp13_;
18059
18141
_vala_source_reference_unref0 (_tmp12_);
18060
18142
} else {
18061
ValaUnresolvedSymbol* _tmp15_ = NULL;
18143
ValaUnresolvedSymbol* _tmp14_ = NULL;
18144
const gchar* _tmp15_ = NULL;
18062
18145
const gchar* _tmp16_ = NULL;
18063
const gchar* _tmp17_ = NULL;
18064
ValaSourceReference* _tmp18_ = NULL;
18065
ValaSourceReference* _tmp19_;
18066
ValaCreationMethod* _tmp20_ = NULL;
18067
ValaCreationMethod* _tmp21_;
18068
_tmp15_ = vala_unresolved_symbol_get_inner (sym);
18069
_tmp16_ = vala_symbol_get_name ((ValaSymbol*) _tmp15_);
18070
_tmp17_ = vala_symbol_get_name ((ValaSymbol*) sym);
18071
_tmp18_ = vala_parser_get_src (self, &begin);
18072
_tmp19_ = _tmp18_;
18073
_tmp20_ = vala_creation_method_new (_tmp16_, _tmp17_, _tmp19_, self->priv->comment);
18074
_tmp21_ = _tmp20_;
18146
ValaSourceReference* _tmp17_ = NULL;
18147
ValaSourceReference* _tmp18_;
18148
ValaCreationMethod* _tmp19_ = NULL;
18149
_tmp14_ = vala_unresolved_symbol_get_inner (sym);
18150
_tmp15_ = vala_symbol_get_name ((ValaSymbol*) _tmp14_);
18151
_tmp16_ = vala_symbol_get_name ((ValaSymbol*) sym);
18152
_tmp17_ = vala_parser_get_src (self, &begin);
18153
_tmp18_ = _tmp17_;
18154
_tmp19_ = vala_creation_method_new (_tmp15_, _tmp16_, _tmp18_, self->priv->comment);
18075
18155
_vala_code_node_unref0 (method);
18076
method = _tmp21_;
18077
_vala_source_reference_unref0 (_tmp19_);
18156
method = _tmp19_;
18157
_vala_source_reference_unref0 (_tmp18_);
18078
18158
}
18079
18159
if ((flags & VALA_PARSER_MODIFIER_FLAGS_EXTERN) == VALA_PARSER_MODIFIER_FLAGS_EXTERN) {
18080
18160
vala_symbol_set_external ((ValaSymbol*) method, TRUE);
18081
18161
}
18082
18162
if ((flags & VALA_PARSER_MODIFIER_FLAGS_ABSTRACT) == VALA_PARSER_MODIFIER_FLAGS_ABSTRACT) {
18083
_tmp23_ = TRUE;
18084
} else {
18085
_tmp23_ = (flags & VALA_PARSER_MODIFIER_FLAGS_VIRTUAL) == VALA_PARSER_MODIFIER_FLAGS_VIRTUAL;
18086
}
18087
if (_tmp23_) {
18088
_tmp22_ = TRUE;
18089
} else {
18090
_tmp22_ = (flags & VALA_PARSER_MODIFIER_FLAGS_OVERRIDE) == VALA_PARSER_MODIFIER_FLAGS_OVERRIDE;
18091
}
18092
if (_tmp22_) {
18093
ValaSourceReference* _tmp24_ = NULL;
18094
_tmp24_ = vala_code_node_get_source_reference ((ValaCodeNode*) method);
18095
vala_report_error (_tmp24_, "abstract, virtual, and override modifiers are not applicable to creati" \
18163
_tmp21_ = TRUE;
18164
} else {
18165
_tmp21_ = (flags & VALA_PARSER_MODIFIER_FLAGS_VIRTUAL) == VALA_PARSER_MODIFIER_FLAGS_VIRTUAL;
18166
}
18167
if (_tmp21_) {
18168
_tmp20_ = TRUE;
18169
} else {
18170
_tmp20_ = (flags & VALA_PARSER_MODIFIER_FLAGS_OVERRIDE) == VALA_PARSER_MODIFIER_FLAGS_OVERRIDE;
18171
}
18172
if (_tmp20_) {
18173
ValaSourceReference* _tmp22_ = NULL;
18174
_tmp22_ = vala_code_node_get_source_reference ((ValaCodeNode*) method);
18175
vala_report_error (_tmp22_, "abstract, virtual, and override modifiers are not applicable to creati" \
18096
18176
"on methods");
18097
18177
}
18098
18178
if ((flags & VALA_PARSER_MODIFIER_FLAGS_ASYNC) == VALA_PARSER_MODIFIER_FLAGS_ASYNC) {
18113
18193
return;
18114
18194
}
18115
18195
}
18116
_tmp25_ = vala_parser_current (self);
18117
if (_tmp25_ != VALA_TOKEN_TYPE_CLOSE_PARENS) {
18196
_tmp23_ = vala_parser_current (self);
18197
if (_tmp23_ != VALA_TOKEN_TYPE_CLOSE_PARENS) {
18118
18198
{
18119
gboolean _tmp26_;
18120
_tmp26_ = TRUE;
18199
gboolean _tmp24_;
18200
_tmp24_ = TRUE;
18121
18201
while (TRUE) {
18122
ValaParameter* _tmp28_ = NULL;
18202
ValaParameter* _tmp26_ = NULL;
18123
18203
ValaParameter* param;
18124
if (!_tmp26_) {
18125
gboolean _tmp27_;
18126
_tmp27_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
18127
if (!_tmp27_) {
18204
if (!_tmp24_) {
18205
gboolean _tmp25_;
18206
_tmp25_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
18207
if (!_tmp25_) {
18128
18208
break;
18129
18209
}
18130
18210
}
18131
_tmp26_ = FALSE;
18132
_tmp28_ = vala_parser_parse_parameter (self, &_inner_error_);
18133
param = _tmp28_;
18211
_tmp24_ = FALSE;
18212
_tmp26_ = vala_parser_parse_parameter (self, &_inner_error_);
18213
param = _tmp26_;
18134
18214
if (_inner_error_ != NULL) {
18135
18215
if (_inner_error_->domain == VALA_PARSE_ERROR) {
18136
18216
g_propagate_error (error, _inner_error_);
18165
18245
return;
18166
18246
}
18167
18247
}
18168
_tmp29_ = vala_code_context_get_profile (self->priv->context);
18169
if (_tmp29_ == VALA_PROFILE_DOVA) {
18248
_tmp27_ = vala_code_context_get_profile (self->priv->context);
18249
if (_tmp27_ == VALA_PROFILE_DOVA) {
18250
ValaUnresolvedSymbol* _tmp28_ = NULL;
18251
ValaUnresolvedSymbol* _tmp29_;
18170
18252
ValaUnresolvedSymbol* _tmp30_ = NULL;
18171
18253
ValaUnresolvedSymbol* _tmp31_;
18172
ValaUnresolvedSymbol* _tmp32_ = NULL;
18173
ValaUnresolvedSymbol* _tmp33_;
18174
ValaSourceReference* _tmp34_ = NULL;
18175
ValaUnresolvedType* _tmp35_ = NULL;
18176
ValaUnresolvedType* _tmp36_;
18254
ValaSourceReference* _tmp32_ = NULL;
18255
ValaUnresolvedType* _tmp33_ = NULL;
18256
ValaUnresolvedType* _tmp34_;
18177
18257
ValaUnresolvedType* error_type;
18178
gboolean _tmp37_;
18179
_tmp30_ = vala_unresolved_symbol_new (NULL, "Dova", NULL);
18258
gboolean _tmp35_;
18259
_tmp28_ = vala_unresolved_symbol_new (NULL, "Dova", NULL);
18260
_tmp29_ = _tmp28_;
18261
_tmp30_ = vala_unresolved_symbol_new (_tmp29_, "Error", NULL);
18180
18262
_tmp31_ = _tmp30_;
18181
_tmp32_ = vala_unresolved_symbol_new (_tmp31_, "Error", NULL);
18182
_tmp33_ = _tmp32_;
18183
_tmp34_ = vala_code_node_get_source_reference ((ValaCodeNode*) method);
18184
_tmp35_ = vala_unresolved_type_new_from_symbol (_tmp33_, _tmp34_);
18185
error_type = (_tmp36_ = _tmp35_, _vala_code_node_unref0 (_tmp33_), _vala_code_node_unref0 (_tmp31_), _tmp36_);
18263
_tmp32_ = vala_code_node_get_source_reference ((ValaCodeNode*) method);
18264
_tmp33_ = vala_unresolved_type_new_from_symbol (_tmp31_, _tmp32_);
18265
_tmp34_ = _tmp33_;
18266
_vala_code_node_unref0 (_tmp31_);
18267
_vala_code_node_unref0 (_tmp29_);
18268
error_type = _tmp34_;
18186
18269
vala_code_node_add_error_type ((ValaCodeNode*) method, (ValaDataType*) error_type);
18187
_tmp37_ = vala_parser_accept (self, VALA_TOKEN_TYPE_THROWS);
18188
if (_tmp37_) {
18189
ValaSourceReference* _tmp42_ = NULL;
18270
_tmp35_ = vala_parser_accept (self, VALA_TOKEN_TYPE_THROWS);
18271
if (_tmp35_) {
18272
ValaSourceReference* _tmp40_ = NULL;
18190
18273
{
18191
gboolean _tmp38_;
18192
_tmp38_ = TRUE;
18274
gboolean _tmp36_;
18275
_tmp36_ = TRUE;
18193
18276
while (TRUE) {
18194
ValaDataType* _tmp40_ = NULL;
18195
ValaDataType* _tmp41_;
18196
if (!_tmp38_) {
18197
gboolean _tmp39_;
18198
_tmp39_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
18199
if (!_tmp39_) {
18277
ValaDataType* _tmp38_ = NULL;
18278
ValaDataType* _tmp39_;
18279
if (!_tmp36_) {
18280
gboolean _tmp37_;
18281
_tmp37_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
18282
if (!_tmp37_) {
18200
18283
break;
18201
18284
}
18202
18285
}
18203
_tmp38_ = FALSE;
18204
_tmp40_ = vala_parser_parse_type (self, TRUE, FALSE, &_inner_error_);
18205
_tmp41_ = _tmp40_;
18206
_vala_code_node_unref0 (_tmp41_);
18286
_tmp36_ = FALSE;
18287
_tmp38_ = vala_parser_parse_type (self, TRUE, FALSE, &_inner_error_);
18288
_tmp39_ = _tmp38_;
18289
_vala_code_node_unref0 (_tmp39_);
18207
18290
if (_inner_error_ != NULL) {
18208
18291
if (_inner_error_->domain == VALA_PARSE_ERROR) {
18209
18292
g_propagate_error (error, _inner_error_);
18222
18305
}
18223
18306
}
18224
18307
}
18225
_tmp42_ = vala_code_node_get_source_reference ((ValaCodeNode*) method);
18226
vala_report_warning (_tmp42_, "`throws' is ignored in the Dova profile");
18308
_tmp40_ = vala_code_node_get_source_reference ((ValaCodeNode*) method);
18309
vala_report_warning (_tmp40_, "`throws' is ignored in the Dova profile");
18227
18310
}
18228
18311
_vala_code_node_unref0 (error_type);
18229
18312
} else {
18230
gboolean _tmp43_;
18231
_tmp43_ = vala_parser_accept (self, VALA_TOKEN_TYPE_THROWS);
18232
if (_tmp43_) {
18313
gboolean _tmp41_;
18314
_tmp41_ = vala_parser_accept (self, VALA_TOKEN_TYPE_THROWS);
18315
if (_tmp41_) {
18233
18316
{
18234
gboolean _tmp44_;
18235
_tmp44_ = TRUE;
18317
gboolean _tmp42_;
18318
_tmp42_ = TRUE;
18236
18319
while (TRUE) {
18237
ValaDataType* _tmp46_ = NULL;
18238
ValaDataType* _tmp47_;
18239
ValaDataType* _tmp48_;
18240
if (!_tmp44_) {
18241
gboolean _tmp45_;
18242
_tmp45_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
18243
if (!_tmp45_) {
18320
ValaDataType* _tmp44_ = NULL;
18321
ValaDataType* _tmp45_;
18322
ValaDataType* _tmp46_;
18323
if (!_tmp42_) {
18324
gboolean _tmp43_;
18325
_tmp43_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
18326
if (!_tmp43_) {
18244
18327
break;
18245
18328
}
18246
18329
}
18247
_tmp44_ = FALSE;
18248
_tmp46_ = vala_parser_parse_type (self, TRUE, FALSE, &_inner_error_);
18249
_tmp47_ = _tmp46_;
18330
_tmp42_ = FALSE;
18331
_tmp44_ = vala_parser_parse_type (self, TRUE, FALSE, &_inner_error_);
18332
_tmp45_ = _tmp44_;
18250
18333
if (_inner_error_ != NULL) {
18251
18334
if (_inner_error_->domain == VALA_PARSE_ERROR) {
18252
18335
g_propagate_error (error, _inner_error_);
18261
18344
return;
18262
18345
}
18263
18346
}
18264
_tmp48_ = _tmp47_;
18265
vala_code_node_add_error_type ((ValaCodeNode*) method, _tmp48_);
18266
_vala_code_node_unref0 (_tmp48_);
18347
_tmp46_ = _tmp45_;
18348
vala_code_node_add_error_type ((ValaCodeNode*) method, _tmp46_);
18349
_vala_code_node_unref0 (_tmp46_);
18267
18350
}
18268
18351
}
18269
18352
}
18270
18353
}
18271
18354
while (TRUE) {
18272
gboolean _tmp49_;
18273
ValaExpression* _tmp50_ = NULL;
18274
ValaExpression* _tmp51_;
18275
ValaExpression* _tmp52_;
18276
_tmp49_ = vala_parser_accept (self, VALA_TOKEN_TYPE_REQUIRES);
18277
if (!_tmp49_) {
18355
gboolean _tmp47_;
18356
ValaExpression* _tmp48_ = NULL;
18357
ValaExpression* _tmp49_;
18358
ValaExpression* _tmp50_;
18359
_tmp47_ = vala_parser_accept (self, VALA_TOKEN_TYPE_REQUIRES);
18360
if (!_tmp47_) {
18278
18361
break;
18279
18362
}
18280
18363
vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_PARENS, &_inner_error_);
18292
18375
return;
18293
18376
}
18294
18377
}
18295
_tmp50_ = vala_parser_parse_expression (self, &_inner_error_);
18296
_tmp51_ = _tmp50_;
18378
_tmp48_ = vala_parser_parse_expression (self, &_inner_error_);
18379
_tmp49_ = _tmp48_;
18297
18380
if (_inner_error_ != NULL) {
18298
18381
if (_inner_error_->domain == VALA_PARSE_ERROR) {
18299
18382
g_propagate_error (error, _inner_error_);
18308
18391
return;
18309
18392
}
18310
18393
}
18311
_tmp52_ = _tmp51_;
18312
vala_method_add_precondition ((ValaMethod*) method, _tmp52_);
18313
_vala_code_node_unref0 (_tmp52_);
18394
_tmp50_ = _tmp49_;
18395
vala_method_add_precondition ((ValaMethod*) method, _tmp50_);
18396
_vala_code_node_unref0 (_tmp50_);
18314
18397
vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_PARENS, &_inner_error_);
18315
18398
if (_inner_error_ != NULL) {
18316
18399
if (_inner_error_->domain == VALA_PARSE_ERROR) {
18328
18411
}
18329
18412
}
18330
18413
while (TRUE) {
18331
gboolean _tmp53_;
18332
ValaExpression* _tmp54_ = NULL;
18333
ValaExpression* _tmp55_;
18334
ValaExpression* _tmp56_;
18335
_tmp53_ = vala_parser_accept (self, VALA_TOKEN_TYPE_ENSURES);
18336
if (!_tmp53_) {
18414
gboolean _tmp51_;
18415
ValaExpression* _tmp52_ = NULL;
18416
ValaExpression* _tmp53_;
18417
ValaExpression* _tmp54_;
18418
_tmp51_ = vala_parser_accept (self, VALA_TOKEN_TYPE_ENSURES);
18419
if (!_tmp51_) {
18337
18420
break;
18338
18421
}
18339
18422
vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_PARENS, &_inner_error_);
18351
18434
return;
18352
18435
}
18353
18436
}
18354
_tmp54_ = vala_parser_parse_expression (self, &_inner_error_);
18355
_tmp55_ = _tmp54_;
18437
_tmp52_ = vala_parser_parse_expression (self, &_inner_error_);
18438
_tmp53_ = _tmp52_;
18356
18439
if (_inner_error_ != NULL) {
18357
18440
if (_inner_error_->domain == VALA_PARSE_ERROR) {
18358
18441
g_propagate_error (error, _inner_error_);
18367
18450
return;
18368
18451
}
18369
18452
}
18370
_tmp56_ = _tmp55_;
18371
vala_method_add_postcondition ((ValaMethod*) method, _tmp56_);
18372
_vala_code_node_unref0 (_tmp56_);
18453
_tmp54_ = _tmp53_;
18454
vala_method_add_postcondition ((ValaMethod*) method, _tmp54_);
18455
_vala_code_node_unref0 (_tmp54_);
18373
18456
vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_PARENS, &_inner_error_);
18374
18457
if (_inner_error_ != NULL) {
18375
18458
if (_inner_error_->domain == VALA_PARSE_ERROR) {
18388
18471
}
18389
18472
vala_symbol_set_access ((ValaSymbol*) method, access);
18390
18473
vala_parser_set_attributes (self, (ValaCodeNode*) method, attrs);
18391
_tmp57_ = vala_parser_accept (self, VALA_TOKEN_TYPE_SEMICOLON);
18392
if (!_tmp57_) {
18393
ValaBlock* _tmp58_ = NULL;
18394
ValaBlock* _tmp59_;
18395
ValaBlock* _tmp60_;
18396
_tmp58_ = vala_parser_parse_block (self, &_inner_error_);
18397
_tmp59_ = _tmp58_;
18474
_tmp55_ = vala_parser_accept (self, VALA_TOKEN_TYPE_SEMICOLON);
18475
if (!_tmp55_) {
18476
ValaBlock* _tmp56_ = NULL;
18477
ValaBlock* _tmp57_;
18478
ValaBlock* _tmp58_;
18479
_tmp56_ = vala_parser_parse_block (self, &_inner_error_);
18480
_tmp57_ = _tmp56_;
18398
18481
if (_inner_error_ != NULL) {
18399
18482
if (_inner_error_->domain == VALA_PARSE_ERROR) {
18400
18483
g_propagate_error (error, _inner_error_);
18409
18492
return;
18410
18493
}
18411
18494
}
18412
_tmp60_ = _tmp59_;
18413
vala_subroutine_set_body ((ValaSubroutine*) method, _tmp60_);
18414
_vala_code_node_unref0 (_tmp60_);
18495
_tmp58_ = _tmp57_;
18496
vala_subroutine_set_body ((ValaSubroutine*) method, _tmp58_);
18497
_vala_code_node_unref0 (_tmp58_);
18415
18498
} else {
18416
ValaSourceFile* _tmp61_ = NULL;
18417
ValaSourceFileType _tmp62_;
18418
_tmp61_ = vala_scanner_get_source_file (self->priv->scanner);
18419
_tmp62_ = vala_source_file_get_file_type (_tmp61_);
18420
if (_tmp62_ == VALA_SOURCE_FILE_TYPE_PACKAGE) {
18499
ValaSourceFile* _tmp59_ = NULL;
18500
ValaSourceFileType _tmp60_;
18501
_tmp59_ = vala_scanner_get_source_file (self->priv->scanner);
18502
_tmp60_ = vala_source_file_get_file_type (_tmp59_);
18503
if (_tmp60_ == VALA_SOURCE_FILE_TYPE_PACKAGE) {
18421
18504
vala_symbol_set_external ((ValaSymbol*) method, TRUE);
18422
18505
}
18423
18506
}
18455
18538
GError * _inner_error_ = NULL;
18456
18539
g_return_if_fail (self != NULL);
18457
18540
g_return_if_fail (parent != NULL);
18458
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
18541
vala_parser_get_location (self, &_tmp0_);
18542
_tmp1_ = _tmp0_;
18459
18543
begin = _tmp1_;
18460
18544
_tmp2_ = vala_parser_parse_access_modifier (self, VALA_SYMBOL_ACCESSIBILITY_PRIVATE);
18461
18545
access = _tmp2_;
18480
18564
_tmp4_ = vala_parser_get_error (self, "`new' modifier not allowed on delegates");
18481
18565
_tmp5_ = _tmp4_;
18482
18566
_tmp6_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp5_);
18483
_inner_error_ = (_tmp7_ = _tmp6_, _g_free0 (_tmp5_), _tmp7_);
18567
_tmp7_ = _tmp6_;
18568
_g_free0 (_tmp5_);
18569
_inner_error_ = _tmp7_;
18484
18570
if (_inner_error_->domain == VALA_PARSE_ERROR) {
18485
18571
g_propagate_error (error, _inner_error_);
18486
18572
return;
18536
18622
_tmp12_ = vala_parser_get_src (self, &begin);
18537
18623
_tmp13_ = _tmp12_;
18538
18624
_tmp14_ = vala_delegate_new (_tmp11_, type, _tmp13_, self->priv->comment);
18539
d = (_tmp15_ = _tmp14_, _vala_source_reference_unref0 (_tmp13_), _tmp15_);
18625
_tmp15_ = _tmp14_;
18626
_vala_source_reference_unref0 (_tmp13_);
18627
d = _tmp15_;
18540
18628
vala_symbol_set_access ((ValaSymbol*) d, access);
18541
18629
vala_parser_set_attributes (self, (ValaCodeNode*) d, attrs);
18542
18630
if ((flags & VALA_PARSER_MODIFIER_FLAGS_STATIC) == VALA_PARSER_MODIFIER_FLAGS_STATIC) {
18686
18774
_tmp33_ = _tmp32_;
18687
18775
_tmp34_ = vala_code_node_get_source_reference ((ValaCodeNode*) d);
18688
18776
_tmp35_ = vala_unresolved_type_new_from_symbol (_tmp33_, _tmp34_);
18689
error_type = (_tmp36_ = _tmp35_, _vala_code_node_unref0 (_tmp33_), _vala_code_node_unref0 (_tmp31_), _tmp36_);
18777
_tmp36_ = _tmp35_;
18778
_vala_code_node_unref0 (_tmp33_);
18779
_vala_code_node_unref0 (_tmp31_);
18780
error_type = _tmp36_;
18690
18781
vala_code_node_add_error_type ((ValaCodeNode*) d, (ValaDataType*) error_type);
18691
18782
_tmp37_ = vala_parser_accept (self, VALA_TOKEN_TYPE_THROWS);
18692
18783
if (_tmp37_) {
18804
18895
while (TRUE) {
18805
18896
ValaUnresolvedSymbol* _tmp50_ = NULL;
18806
18897
ValaUnresolvedSymbol* _tmp51_;
18807
ValaUnresolvedSymbol* _tmp52_;
18808
ValaSymbol* _tmp53_ = NULL;
18809
ValaSymbol* _tmp60_;
18898
ValaSymbol* _tmp52_ = NULL;
18899
ValaSymbol* _tmp57_;
18810
18900
ValaSymbol* next;
18811
ValaSymbol* _tmp61_;
18812
ValaSymbol* _tmp62_;
18901
ValaSymbol* _tmp58_;
18813
18902
if (!(sym != NULL)) {
18814
18903
break;
18815
18904
}
18816
18905
_tmp50_ = vala_unresolved_symbol_get_inner (sym);
18817
18906
_tmp51_ = _vala_code_node_ref0 (_tmp50_);
18818
_tmp52_ = _tmp51_;
18819
18907
_vala_code_node_unref0 (sym);
18820
sym = _tmp52_;
18908
sym = _tmp51_;
18821
18909
if (sym != NULL) {
18822
const gchar* _tmp54_ = NULL;
18823
ValaSourceReference* _tmp55_ = NULL;
18824
ValaNamespace* _tmp56_ = NULL;
18825
ValaSymbol* _tmp57_;
18826
_tmp54_ = vala_symbol_get_name ((ValaSymbol*) sym);
18827
_tmp55_ = vala_code_node_get_source_reference ((ValaCodeNode*) d);
18828
_tmp56_ = vala_namespace_new (_tmp54_, _tmp55_);
18829
_tmp57_ = (ValaSymbol*) _tmp56_;
18830
_vala_code_node_unref0 (_tmp53_);
18831
_tmp53_ = _tmp57_;
18910
const gchar* _tmp53_ = NULL;
18911
ValaSourceReference* _tmp54_ = NULL;
18912
ValaNamespace* _tmp55_ = NULL;
18913
_tmp53_ = vala_symbol_get_name ((ValaSymbol*) sym);
18914
_tmp54_ = vala_code_node_get_source_reference ((ValaCodeNode*) d);
18915
_tmp55_ = vala_namespace_new (_tmp53_, _tmp54_);
18916
_vala_code_node_unref0 (_tmp52_);
18917
_tmp52_ = (ValaSymbol*) _tmp55_;
18832
18918
} else {
18833
ValaSymbol* _tmp58_;
18834
ValaSymbol* _tmp59_;
18835
_tmp58_ = _vala_code_node_ref0 (parent);
18836
_tmp59_ = _tmp58_;
18837
_vala_code_node_unref0 (_tmp53_);
18838
_tmp53_ = _tmp59_;
18919
ValaSymbol* _tmp56_;
18920
_tmp56_ = _vala_code_node_ref0 (parent);
18921
_vala_code_node_unref0 (_tmp52_);
18922
_tmp52_ = _tmp56_;
18839
18923
}
18840
_tmp60_ = _vala_code_node_ref0 (_tmp53_);
18841
next = _tmp60_;
18924
_tmp57_ = _vala_code_node_ref0 (_tmp52_);
18925
next = _tmp57_;
18842
18926
if (VALA_IS_NAMESPACE (_result_)) {
18843
18927
vala_symbol_add_namespace (next, VALA_NAMESPACE (_result_));
18844
18928
} else {
18845
18929
vala_symbol_add_delegate (next, VALA_DELEGATE (_result_));
18846
18930
}
18847
_tmp61_ = _vala_code_node_ref0 (next);
18848
_tmp62_ = _tmp61_;
18931
_tmp58_ = _vala_code_node_ref0 (next);
18849
18932
_vala_code_node_unref0 (_result_);
18850
_result_ = _tmp62_;
18933
_result_ = _tmp58_;
18851
18934
_vala_code_node_unref0 (next);
18852
_vala_code_node_unref0 (_tmp53_);
18935
_vala_code_node_unref0 (_tmp52_);
18853
18936
}
18854
18937
_vala_code_node_unref0 (_result_);
18855
18938
_vala_code_node_unref0 (d);
18891
18974
}
18892
18975
}
18893
18976
_tmp2_ = FALSE;
18894
_tmp5_ = (vala_parser_get_location (self, &_tmp4_), _tmp4_);
18977
vala_parser_get_location (self, &_tmp4_);
18978
_tmp5_ = _tmp4_;
18895
18979
begin = _tmp5_;
18896
18980
_tmp6_ = vala_parser_parse_identifier (self, &_inner_error_);
18897
18981
id = _tmp6_;
18933
19017
result = (ValaList*) list;
18934
19018
return result;
18935
19019
} else {
18936
ValaList* _tmp13_;
19020
ValaList* _tmp12_;
18937
19021
if (vala_parser__empty_type_parameter_list == NULL) {
18938
19022
ValaArrayList* _tmp11_ = NULL;
18939
ValaList* _tmp12_;
18940
19023
_tmp11_ = vala_array_list_new (VALA_TYPE_TYPEPARAMETER, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
18941
_tmp12_ = (ValaList*) _tmp11_;
18942
19024
_vala_iterable_unref0 (vala_parser__empty_type_parameter_list);
18943
vala_parser__empty_type_parameter_list = _tmp12_;
19025
vala_parser__empty_type_parameter_list = (ValaList*) _tmp11_;
18944
19026
}
18945
_tmp13_ = _vala_iterable_ref0 (vala_parser__empty_type_parameter_list);
18946
result = _tmp13_;
19027
_tmp12_ = _vala_iterable_ref0 (vala_parser__empty_type_parameter_list);
19028
result = _tmp12_;
18947
19029
return result;
18948
19030
}
18949
19031
}
19003
19085
gboolean _tmp2_;
19004
19086
GError * _inner_error_ = NULL;
19005
19087
g_return_val_if_fail (self != NULL, NULL);
19006
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
19088
vala_parser_get_location (self, &_tmp0_);
19089
_tmp1_ = _tmp0_;
19007
19090
begin = _tmp1_;
19008
19091
_tmp2_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OP_LT);
19009
19092
if (_tmp2_) {
19114
19197
gboolean first;
19115
19198
GError * _inner_error_ = NULL;
19116
19199
g_return_val_if_fail (self != NULL, NULL);
19117
_tmp1_ = (vala_parser_get_location (self, &_tmp0_), _tmp0_);
19200
vala_parser_get_location (self, &_tmp0_);
19201
_tmp1_ = _tmp0_;
19118
19202
begin = _tmp1_;
19119
19203
expr = NULL;
19120
19204
first = TRUE;
19127
19211
gboolean qualified;
19128
19212
gboolean _tmp5_ = FALSE;
19129
19213
gboolean _tmp6_ = FALSE;
19130
ValaList* _tmp11_ = NULL;
19214
ValaList* _tmp10_ = NULL;
19131
19215
ValaList* type_arg_list;
19132
ValaExpression* _tmp12_ = NULL;
19133
ValaSourceReference* _tmp13_ = NULL;
19134
ValaSourceReference* _tmp14_;
19135
ValaMemberAccess* _tmp15_ = NULL;
19136
ValaMemberAccess* _tmp16_;
19216
ValaExpression* _tmp11_ = NULL;
19217
ValaSourceReference* _tmp12_ = NULL;
19218
ValaSourceReference* _tmp13_;
19219
ValaMemberAccess* _tmp14_ = NULL;
19137
19220
if (!_tmp2_) {
19138
19221
gboolean _tmp3_;
19139
19222
_tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_DOT);
19172
19255
if (_tmp5_) {
19173
19256
gchar* _tmp8_ = NULL;
19174
19257
gchar* _tmp9_;
19175
gchar* _tmp10_;
19176
19258
_tmp8_ = vala_parser_parse_identifier (self, &_inner_error_);
19177
19259
_tmp9_ = _tmp8_;
19178
19260
if (_inner_error_ != NULL) {
19189
19271
return NULL;
19190
19272
}
19191
19273
}
19192
_tmp10_ = _tmp9_;
19193
19274
_g_free0 (id);
19194
id = _tmp10_;
19275
id = _tmp9_;
19195
19276
qualified = TRUE;
19196
19277
}
19197
_tmp11_ = vala_parser_parse_type_argument_list (self, FALSE, &_inner_error_);
19198
type_arg_list = _tmp11_;
19278
_tmp10_ = vala_parser_parse_type_argument_list (self, FALSE, &_inner_error_);
19279
type_arg_list = _tmp10_;
19199
19280
if (_inner_error_ != NULL) {
19200
19281
if (_inner_error_->domain == VALA_PARSE_ERROR) {
19201
19282
g_propagate_error (error, _inner_error_);
19211
19292
}
19212
19293
}
19213
19294
if (expr != NULL) {
19214
_tmp12_ = (ValaExpression*) expr;
19295
_tmp11_ = (ValaExpression*) expr;
19215
19296
} else {
19216
_tmp12_ = base_expr;
19297
_tmp11_ = base_expr;
19217
19298
}
19218
_tmp13_ = vala_parser_get_src (self, &begin);
19219
_tmp14_ = _tmp13_;
19220
_tmp15_ = vala_member_access_new (_tmp12_, id, _tmp14_);
19221
_tmp16_ = _tmp15_;
19299
_tmp12_ = vala_parser_get_src (self, &begin);
19300
_tmp13_ = _tmp12_;
19301
_tmp14_ = vala_member_access_new (_tmp11_, id, _tmp13_);
19222
19302
_vala_code_node_unref0 (expr);
19223
expr = _tmp16_;
19224
_vala_source_reference_unref0 (_tmp14_);
19303
expr = _tmp14_;
19304
_vala_source_reference_unref0 (_tmp13_);
19225
19305
vala_member_access_set_qualified (expr, qualified);
19226
19306
if (type_arg_list != NULL) {
19227
19307
{
19228
ValaList* _tmp17_;
19308
ValaList* _tmp15_;
19229
19309
ValaList* _type_arg_list;
19230
gint _tmp18_;
19310
gint _tmp16_;
19231
19311
gint _type_arg_size;
19232
19312
gint _type_arg_index;
19233
_tmp17_ = _vala_iterable_ref0 (type_arg_list);
19234
_type_arg_list = _tmp17_;
19235
_tmp18_ = vala_collection_get_size ((ValaCollection*) _type_arg_list);
19236
_type_arg_size = _tmp18_;
19313
_tmp15_ = _vala_iterable_ref0 (type_arg_list);
19314
_type_arg_list = _tmp15_;
19315
_tmp16_ = vala_collection_get_size ((ValaCollection*) _type_arg_list);
19316
_type_arg_size = _tmp16_;
19237
19317
_type_arg_index = -1;
19238
19318
while (TRUE) {
19239
gpointer _tmp19_ = NULL;
19319
gpointer _tmp17_ = NULL;
19240
19320
ValaDataType* type_arg;
19241
19321
_type_arg_index = _type_arg_index + 1;
19242
19322
if (!(_type_arg_index < _type_arg_size)) {
19243
19323
break;
19244
19324
}
19245
_tmp19_ = vala_list_get (_type_arg_list, _type_arg_index);
19246
type_arg = (ValaDataType*) _tmp19_;
19325
_tmp17_ = vala_list_get (_type_arg_list, _type_arg_index);
19326
type_arg = (ValaDataType*) _tmp17_;
19247
19327
vala_member_access_add_type_argument (expr, type_arg);
19248
19328
_vala_code_node_unref0 (type_arg);
19249
19329
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1