Class: Opal::Parser

Inherits:
Racc::Parser
  • Object
show all
Defined in:
opal/lib/opal/parser.rb,
opal/lib/opal/parser/grammar.rb

Constant Summary

Racc_arg = 
[
racc_action_table,
racc_action_check,
racc_action_default,
racc_action_pointer,
racc_goto_table,
racc_goto_check,
racc_goto_default,
racc_goto_pointer,
racc_nt_base,
racc_reduce_table,
racc_token_table,
racc_shift_n,
racc_reduce_n,
racc_use_result_var ]
Racc_token_to_s_table = 
[
"$end",
"error",
"kCLASS",
"kMODULE",
"kDEF",
"kUNDEF",
"kBEGIN",
"kRESCUE",
"kENSURE",
"kEND",
"kIF",
"kUNLESS",
"kTHEN",
"kELSIF",
"kELSE",
"kCASE",
"kWHEN",
"kWHILE",
"kUNTIL",
"kFOR",
"kBREAK",
"kNEXT",
"kREDO",
"kRETRY",
"kIN",
"kDO",
"kDO_COND",
"kDO_BLOCK",
"kDO_LAMBDA",
"kRETURN",
"kYIELD",
"kSUPER",
"kSELF",
"kNIL",
"kTRUE",
"kFALSE",
"kAND",
"kOR",
"kNOT",
"kIF_MOD",
"kUNLESS_MOD",
"kWHILE_MOD",
"kUNTIL_MOD",
"kRESCUE_MOD",
"kALIAS",
"kDEFINED",
"klBEGIN",
"klEND",
"k__LINE__",
"k__FILE__",
"k__ENCODING__",
"tIDENTIFIER",
"tFID",
"tGVAR",
"tIVAR",
"tCONSTANT",
"tLABEL",
"tCVAR",
"tNTH_REF",
"tBACK_REF",
"tSTRING_CONTENT",
"tINTEGER",
"tFLOAT",
"tREGEXP_END",
"tUPLUS",
"tUMINUS",
"tUMINUS_NUM",
"tPOW",
"tCMP",
"tEQ",
"tEQQ",
"tNEQ",
"tGEQ",
"tLEQ",
"tANDOP",
"tOROP",
"tMATCH",
"tNMATCH",
"tDOT",
"tDOT2",
"tDOT3",
"tAREF",
"tASET",
"tLSHFT",
"tRSHFT",
"tCOLON2",
"tCOLON3",
"tOP_ASGN",
"tASSOC",
"tLPAREN",
"tLPAREN2",
"tRPAREN",
"tLPAREN_ARG",
"ARRAY_BEG",
"tRBRACK",
"tLBRACE",
"tLBRACE_ARG",
"tSTAR",
"tSTAR2",
"tAMPER",
"tAMPER2",
"tTILDE",
"tPERCENT",
"tDIVIDE",
"tPLUS",
"tMINUS",
"tLT",
"tGT",
"tPIPE",
"tBANG",
"tCARET",
"tLCURLY",
"tRCURLY",
"tBACK_REF2",
"tSYMBEG",
"tSTRING_BEG",
"tXSTRING_BEG",
"tREGEXP_BEG",
"tWORDS_BEG",
"tAWORDS_BEG",
"tSTRING_DBEG",
"tSTRING_DVAR",
"tSTRING_END",
"tSTRING",
"tSYMBOL",
"tNL",
"tEH",
"tCOLON",
"tCOMMA",
"tSPACE",
"tSEMI",
"tLAMBDA",
"tLAMBEG",
"tLBRACK2",
"tLBRACK",
"tEQL",
"tLOWEST",
"\"-@NUM\"",
"\"{\"",
"$start",
"program",
"top_compstmt",
"top_stmts",
"opt_terms",
"top_stmt",
"terms",
"stmt",
"bodystmt",
"compstmt",
"opt_rescue",
"opt_else",
"opt_ensure",
"stmts",
"fitem",
"undef_list",
"expr_value",
"lhs",
"command_call",
"mlhs",
"var_lhs",
"primary_value",
"aref_args",
"backref",
"mrhs",
"arg_value",
"expr",
"@1",
"arg",
"command",
"block_command",
"call_args",
"block_call",
"operation2",
"command_args",
"cmd_brace_block",
"opt_block_var",
"operation",
"mlhs_basic",
"mlhs_entry",
"mlhs_head",
"mlhs_item",
"mlhs_node",
"mlhs_post",
"variable",
"cname",
"cpath",
"fname",
"op",
"reswords",
"symbol",
"opt_nl",
"primary",
"none",
"args",
"trailer",
"assocs",
"paren_args",
"opt_paren_args",
"opt_block_arg",
"block_arg",
"call_args2",
"open_args",
"@2",
"literal",
"strings",
"xstring",
"regexp",
"words",
"awords",
"var_ref",
"assoc_list",
"brace_block",
"method_call",
"lambda",
"then",
"if_tail",
"do",
"case_body",
"superclass",
"term",
"f_arglist",
"singleton",
"dot_or_colon",
"@3",
"@4",
"@5",
"@6",
"@7",
"@8",
"@9",
"@10",
"@11",
"@12",
"@13",
"@14",
"@15",
"@16",
"@17",
"@18",
"f_larglist",
"lambda_body",
"block_param",
"@19",
"f_block_optarg",
"f_block_opt",
"block_args_tail",
"f_block_arg",
"opt_block_args_tail",
"f_arg",
"f_rest_arg",
"do_block",
"@20",
"operation3",
"@21",
"@22",
"cases",
"@23",
"exc_list",
"exc_var",
"numeric",
"dsym",
"string",
"string1",
"string_contents",
"xstring_contents",
"word_list",
"word",
"string_content",
"qword_list",
"string_dvar",
"@24",
"@25",
"sym",
"f_args",
"f_optarg",
"opt_f_block_arg",
"f_norm_arg",
"f_bad_arg",
"f_arg_item",
"f_margs",
"f_marg",
"f_marg_list",
"f_opt",
"restarg_mark",
"blkarg_mark",
"assoc" ]
Racc_debug_parser = 
false

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#file ⇒ Object (readonly)

Returns the value of attribute file



9
10
11
 
# File 'opal/lib/opal/parser.rb', line 9

def file
  @file
end

#lexer ⇒ Object (readonly)

Returns the value of attribute lexer



9
10
11
 
# File 'opal/lib/opal/parser.rb', line 9

def lexer
  @lexer
end

#scope ⇒ Object (readonly)

Returns the value of attribute scope



9
10
11
 
# File 'opal/lib/opal/parser.rb', line 9

def scope
  @scope
end

Instance Method Details

#_reduce_1(val, _values, result) ⇒ Object

reduce 0 omitted



2989
2990
2991
2992
2993
 
# File 'opal/lib/opal/parser/grammar.rb', line 2989

def _reduce_1(val, _values, result)
                      result = val[0]
                    
    result
end

#_reduce_10(val, _values, result) ⇒ Object 



3052
3053
3054
3055
3056
 
# File 'opal/lib/opal/parser/grammar.rb', line 3052

def _reduce_10(val, _values, result)
                      result = new_block
                    
    result
end

#_reduce_103(val, _values, result) ⇒ Object

reduce 102 omitted



3488
3489
3490
3491
3492
3493
 
# File 'opal/lib/opal/parser/grammar.rb', line 3488

def _reduce_103(val, _values, result)
                      lexer.lex_state = :expr_end
                      result = val[0]
                    
    result
end

#_reduce_104(val, _values, result) ⇒ Object 



3495
3496
3497
3498
3499
3500
 
# File 'opal/lib/opal/parser/grammar.rb', line 3495

def _reduce_104(val, _values, result)
                      lexer.lex_state = :expr_end
                      result = val[0]
                    
    result
end

#_reduce_105(val, _values, result) ⇒ Object 



3502
3503
3504
3505
3506
 
# File 'opal/lib/opal/parser/grammar.rb', line 3502

def _reduce_105(val, _values, result)
                      result = s(:sym, val[0].intern)
                    
    result
end

#_reduce_107(val, _values, result) ⇒ Object

reduce 106 omitted



3510
3511
3512
3513
3514
 
# File 'opal/lib/opal/parser/grammar.rb', line 3510

def _reduce_107(val, _values, result)
                      result = s(:undef, val[0])
                    
    result
end

#_reduce_108(val, _values, result) ⇒ Object 



3516
3517
3518
3519
3520
 
# File 'opal/lib/opal/parser/grammar.rb', line 3516

def _reduce_108(val, _values, result)
                      result = val[0] << val[2]
                    
    result
end

#_reduce_11(val, _values, result) ⇒ Object 



3058
3059
3060
3061
3062
 
# File 'opal/lib/opal/parser/grammar.rb', line 3058

def _reduce_11(val, _values, result)
                      result = new_block val[0]
                    
    result
end

#_reduce_12(val, _values, result) ⇒ Object 



3064
3065
3066
3067
3068
3069
 
# File 'opal/lib/opal/parser/grammar.rb', line 3064

def _reduce_12(val, _values, result)
                      val[0] << val[2]
                      result = val[0]
                    
    result
end

#_reduce_13(val, _values, result) ⇒ Object 



3071
3072
3073
3074
3075
 
# File 'opal/lib/opal/parser/grammar.rb', line 3071

def _reduce_13(val, _values, result)
                      lexer.lex_state = :expr_fname
                    
    result
end

#_reduce_14(val, _values, result) ⇒ Object 



3077
3078
3079
3080
3081
 
# File 'opal/lib/opal/parser/grammar.rb', line 3077

def _reduce_14(val, _values, result)
                      result = s(:alias, val[1], val[3])
                    
    result
end

#_reduce_15(val, _values, result) ⇒ Object 



3083
3084
3085
3086
3087
 
# File 'opal/lib/opal/parser/grammar.rb', line 3083

def _reduce_15(val, _values, result)
                      result = s(:valias, val[1].intern, val[2].intern)
                    
    result
end

#_reduce_17(val, _values, result) ⇒ Object

reduce 16 omitted



3091
3092
3093
3094
3095
 
# File 'opal/lib/opal/parser/grammar.rb', line 3091

def _reduce_17(val, _values, result)
                      result = s(:valias, val[1].intern, val[2].intern)
                    
    result
end

#_reduce_18(val, _values, result) ⇒ Object 



3097
3098
3099
3100
3101
 
# File 'opal/lib/opal/parser/grammar.rb', line 3097

def _reduce_18(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_183(val, _values, result) ⇒ Object

reduce 182 omitted



3670
3671
3672
3673
3674
 
# File 'opal/lib/opal/parser/grammar.rb', line 3670

def _reduce_183(val, _values, result)
                      result = new_assign val[0], val[2]
                    
    result
end

#_reduce_184(val, _values, result) ⇒ Object 



3676
3677
3678
3679
3680
 
# File 'opal/lib/opal/parser/grammar.rb', line 3676

def _reduce_184(val, _values, result)
                      result = new_assign val[0], s(:rescue_mod, val[2], val[4])
                    
    result
end

#_reduce_185(val, _values, result) ⇒ Object 



3682
3683
3684
3685
3686
 
# File 'opal/lib/opal/parser/grammar.rb', line 3682

def _reduce_185(val, _values, result)
                      result = new_op_asgn val[1].intern, val[0], val[2]
                    
    result
end

#_reduce_186(val, _values, result) ⇒ Object 



3688
3689
3690
3691
3692
3693
3694
3695
 
# File 'opal/lib/opal/parser/grammar.rb', line 3688

def _reduce_186(val, _values, result)
                      args = val[2]
                      args.type = :arglist if args.type == :array
                      result = s(:op_asgn1, val[0], val[2], val[4].intern, val[5])
                      result.line = val[0].line
                    
    result
end

#_reduce_187(val, _values, result) ⇒ Object 



3697
3698
3699
3700
3701
 
# File 'opal/lib/opal/parser/grammar.rb', line 3697

def _reduce_187(val, _values, result)
                      result = s(:op_asgn2, val[0], "#{val[2]}=".intern, val[3].intern, val[4])
                    
    result
end

#_reduce_19(val, _values, result) ⇒ Object 



3103
3104
3105
3106
3107
 
# File 'opal/lib/opal/parser/grammar.rb', line 3103

def _reduce_19(val, _values, result)
                      result = new_if val[2], val[0], nil
                    
    result
end

#_reduce_193(val, _values, result) ⇒ Object

reduce 192 omitted



3713
3714
3715
3716
3717
3718
 
# File 'opal/lib/opal/parser/grammar.rb', line 3713

def _reduce_193(val, _values, result)
                      result = s(:irange, val[0], val[2])
                      result.line = val[0].line
                    
    result
end

#_reduce_194(val, _values, result) ⇒ Object 



3720
3721
3722
3723
3724
3725
 
# File 'opal/lib/opal/parser/grammar.rb', line 3720

def _reduce_194(val, _values, result)
                      result = s(:erange, val[0], val[2])
                      result.line = val[0].line
                    
    result
end

#_reduce_195(val, _values, result) ⇒ Object 



3727
3728
3729
3730
3731
 
# File 'opal/lib/opal/parser/grammar.rb', line 3727

def _reduce_195(val, _values, result)
                      result = new_call val[0], :+", s(:arglist, val[2])
                    
    result
end

#_reduce_196(val, _values, result) ⇒ Object 



3733
3734
3735
3736
3737
 
# File 'opal/lib/opal/parser/grammar.rb', line 3733

def _reduce_196(val, _values, result)
                      result = new_call val[0], :-", s(:arglist, val[2])
                    
    result
end

#_reduce_197(val, _values, result) ⇒ Object 



3739
3740
3741
3742
3743
 
# File 'opal/lib/opal/parser/grammar.rb', line 3739

def _reduce_197(val, _values, result)
                      result = new_call val[0], :*", s(:arglist, val[2])
                    
    result
end

#_reduce_198(val, _values, result) ⇒ Object 



3745
3746
3747
3748
3749
 
# File 'opal/lib/opal/parser/grammar.rb', line 3745

def _reduce_198(val, _values, result)
                      result = new_call val[0], :/", s(:arglist, val[2])
                    
    result
end

#_reduce_199(val, _values, result) ⇒ Object 



3751
3752
3753
3754
3755
 
# File 'opal/lib/opal/parser/grammar.rb', line 3751

def _reduce_199(val, _values, result)
                      result = new_call val[0], :%", s(:arglist, val[2])
                    
    result
end

#_reduce_2(val, _values, result) ⇒ Object 



2995
2996
2997
2998
2999
3000
3001
3002
3003
3004
3005
 
# File 'opal/lib/opal/parser/grammar.rb', line 2995

def _reduce_2(val, _values, result)
                      comp = new_compstmt val[0]
                      if comp and comp.type == :begin and comp.size == 2
                        result = comp[1]
                        result.line = comp.line
                      else
                        result = comp
                      end
                    
    result
end

#_reduce_20(val, _values, result) ⇒ Object 



3109
3110
3111
3112
3113
 
# File 'opal/lib/opal/parser/grammar.rb', line 3109

def _reduce_20(val, _values, result)
                      result = new_if val[2], nil, val[0]
                    
    result
end

#_reduce_200(val, _values, result) ⇒ Object 



3757
3758
3759
3760
3761
 
# File 'opal/lib/opal/parser/grammar.rb', line 3757

def _reduce_200(val, _values, result)
                      result = new_call val[0], :**", s(:arglist, val[2])
                    
    result
end

#_reduce_203(val, _values, result) ⇒ Object

reduce 202 omitted



3767
3768
3769
3770
3771
3772
 
# File 'opal/lib/opal/parser/grammar.rb', line 3767

def _reduce_203(val, _values, result)
                      result = new_call val[1], :+@", s(:arglist)
                      result = val[1] if [:int, :float].include? val[1].type
                    
    result
end

#_reduce_204(val, _values, result) ⇒ Object 



3774
3775
3776
3777
3778
3779
3780
3781
3782
3783
3784
3785
 
# File 'opal/lib/opal/parser/grammar.rb', line 3774

def _reduce_204(val, _values, result)
                      result = new_call val[1], :-@", s(:arglist)
                      if val[1].type == :int
                        val[1][1] = -val[1][1]
                        result = val[1]
                      elsif val[1].type == :float
                        val[1][1] = -val[1][1].to_f
                        result = val[1]
                      end
                    
    result
end

#_reduce_205(val, _values, result) ⇒ Object 



3787
3788
3789
3790
3791
 
# File 'opal/lib/opal/parser/grammar.rb', line 3787

def _reduce_205(val, _values, result)
                      result = new_call val[0], :|", s(:arglist, val[2])
                    
    result
end

#_reduce_206(val, _values, result) ⇒ Object 



3793
3794
3795
3796
3797
 
# File 'opal/lib/opal/parser/grammar.rb', line 3793

def _reduce_206(val, _values, result)
                      result = new_call val[0], :^", s(:arglist, val[2])
                    
    result
end

#_reduce_207(val, _values, result) ⇒ Object 



3799
3800
3801
3802
3803
 
# File 'opal/lib/opal/parser/grammar.rb', line 3799

def _reduce_207(val, _values, result)
                      result = new_call val[0], :&", s(:arglist, val[2])
                    
    result
end

#_reduce_208(val, _values, result) ⇒ Object 



3805
3806
3807
3808
3809
 
# File 'opal/lib/opal/parser/grammar.rb', line 3805

def _reduce_208(val, _values, result)
                      result = new_call val[0], :<=>", s(:arglist, val[2])
                    
    result
end

#_reduce_209(val, _values, result) ⇒ Object 



3811
3812
3813
3814
3815
 
# File 'opal/lib/opal/parser/grammar.rb', line 3811

def _reduce_209(val, _values, result)
                      result = new_call val[0], :>", s(:arglist, val[2])
                    
    result
end

#_reduce_21(val, _values, result) ⇒ Object 



3115
3116
3117
3118
3119
 
# File 'opal/lib/opal/parser/grammar.rb', line 3115

def _reduce_21(val, _values, result)
                      result = s(:while, val[2], val[0], true)
                    
    result
end

#_reduce_210(val, _values, result) ⇒ Object 



3817
3818
3819
3820
3821
 
# File 'opal/lib/opal/parser/grammar.rb', line 3817

def _reduce_210(val, _values, result)
                      result = new_call val[0], :>=", s(:arglist, val[2])
                    
    result
end

#_reduce_211(val, _values, result) ⇒ Object 



3823
3824
3825
3826
3827
 
# File 'opal/lib/opal/parser/grammar.rb', line 3823

def _reduce_211(val, _values, result)
                      result = new_call val[0], :<", s(:arglist, val[2])
                    
    result
end

#_reduce_212(val, _values, result) ⇒ Object 



3829
3830
3831
3832
3833
 
# File 'opal/lib/opal/parser/grammar.rb', line 3829

def _reduce_212(val, _values, result)
                      result = new_call val[0], :<=", s(:arglist, val[2])
                    
    result
end

#_reduce_213(val, _values, result) ⇒ Object 



3835
3836
3837
3838
3839
 
# File 'opal/lib/opal/parser/grammar.rb', line 3835

def _reduce_213(val, _values, result)
                      result = new_call val[0], :==", s(:arglist, val[2])
                    
    result
end

#_reduce_214(val, _values, result) ⇒ Object 



3841
3842
3843
3844
3845
 
# File 'opal/lib/opal/parser/grammar.rb', line 3841

def _reduce_214(val, _values, result)
                      result = new_call val[0], :===", s(:arglist, val[2])
                    
    result
end

#_reduce_215(val, _values, result) ⇒ Object 



3847
3848
3849
3850
3851
 
# File 'opal/lib/opal/parser/grammar.rb', line 3847

def _reduce_215(val, _values, result)
                      result = s(:not, new_call(val[0], :==", s(:arglist, val[2])))
                    
    result
end

#_reduce_216(val, _values, result) ⇒ Object 



3853
3854
3855
3856
3857
 
# File 'opal/lib/opal/parser/grammar.rb', line 3853

def _reduce_216(val, _values, result)
                      result = new_call val[0], :=~", s(:arglist, val[2])
                    
    result
end

#_reduce_217(val, _values, result) ⇒ Object 



3859
3860
3861
3862
3863
 
# File 'opal/lib/opal/parser/grammar.rb', line 3859

def _reduce_217(val, _values, result)
                      result = s(:not, new_call(val[0], :=~", s(:arglist, val[2])))
                    
    result
end

#_reduce_218(val, _values, result) ⇒ Object 



3865
3866
3867
3868
3869
 
# File 'opal/lib/opal/parser/grammar.rb', line 3865

def _reduce_218(val, _values, result)
                      result = s(:not, val[1])
                    
    result
end

#_reduce_219(val, _values, result) ⇒ Object 



3871
3872
3873
3874
3875
 
# File 'opal/lib/opal/parser/grammar.rb', line 3871

def _reduce_219(val, _values, result)
                      result = new_call val[1], :~", s(:arglist)
                    
    result
end

#_reduce_22(val, _values, result) ⇒ Object 



3121
3122
3123
3124
3125
 
# File 'opal/lib/opal/parser/grammar.rb', line 3121

def _reduce_22(val, _values, result)
                      result = s(:until, val[2], val[0], true)
                    
    result
end

#_reduce_220(val, _values, result) ⇒ Object 



3877
3878
3879
3880
3881
 
# File 'opal/lib/opal/parser/grammar.rb', line 3877

def _reduce_220(val, _values, result)
                      result = new_call val[0], :<<", s(:arglist, val[2])
                    
    result
end

#_reduce_221(val, _values, result) ⇒ Object 



3883
3884
3885
3886
3887
 
# File 'opal/lib/opal/parser/grammar.rb', line 3883

def _reduce_221(val, _values, result)
                      result = new_call val[0], :>>", s(:arglist, val[2])
                    
    result
end

#_reduce_222(val, _values, result) ⇒ Object 



3889
3890
3891
3892
3893
3894
 
# File 'opal/lib/opal/parser/grammar.rb', line 3889

def _reduce_222(val, _values, result)
                      result = s(:and, val[0], val[2])
                      result.line = val[0].line
                    
    result
end

#_reduce_223(val, _values, result) ⇒ Object 



3896
3897
3898
3899
3900
3901
 
# File 'opal/lib/opal/parser/grammar.rb', line 3896

def _reduce_223(val, _values, result)
                      result = s(:or, val[0], val[2])
                      result.line = val[0].line
                    
    result
end

#_reduce_224(val, _values, result) ⇒ Object 



3903
3904
3905
3906
3907
 
# File 'opal/lib/opal/parser/grammar.rb', line 3903

def _reduce_224(val, _values, result)
                      result = s(:defined, val[2])
                    
    result
end

#_reduce_225(val, _values, result) ⇒ Object 



3909
3910
3911
3912
3913
3914
 
# File 'opal/lib/opal/parser/grammar.rb', line 3909

def _reduce_225(val, _values, result)
                      result = s(:if, val[0], val[2], val[4])
                      result.line = val[0].line
                    
    result
end

#_reduce_228(val, _values, result) ⇒ Object

reduce 227 omitted



3920
3921
3922
3923
3924
 
# File 'opal/lib/opal/parser/grammar.rb', line 3920

def _reduce_228(val, _values, result)
                      result = nil
                    
    result
end

#_reduce_229(val, _values, result) ⇒ Object 



3926
3927
3928
3929
3930
 
# File 'opal/lib/opal/parser/grammar.rb', line 3926

def _reduce_229(val, _values, result)
                      result = s(:array, val[0])
                    
    result
end

#_reduce_23(val, _values, result) ⇒ Object 



3127
3128
3129
3130
3131
 
# File 'opal/lib/opal/parser/grammar.rb', line 3127

def _reduce_23(val, _values, result)
                      result = s(:rescue_mod, val[0], val[2])
                    
    result
end

#_reduce_230(val, _values, result) ⇒ Object 



3932
3933
3934
3935
3936
 
# File 'opal/lib/opal/parser/grammar.rb', line 3932

def _reduce_230(val, _values, result)
                      result = val[0]
                    
    result
end

#_reduce_231(val, _values, result) ⇒ Object 



3938
3939
3940
3941
3942
3943
 
# File 'opal/lib/opal/parser/grammar.rb', line 3938

def _reduce_231(val, _values, result)
                      val[0] << s(:hash, *val[2])
                      result = val[0]
                    
    result
end

#_reduce_232(val, _values, result) ⇒ Object 



3945
3946
3947
3948
3949
 
# File 'opal/lib/opal/parser/grammar.rb', line 3945

def _reduce_232(val, _values, result)
                      result = s(:array, s(:hash, *val[0]))
                    
    result
end

#_reduce_233(val, _values, result) ⇒ Object 



3951
3952
3953
3954
3955
 
# File 'opal/lib/opal/parser/grammar.rb', line 3951

def _reduce_233(val, _values, result)
                      result = nil
                    
    result
end

#_reduce_234(val, _values, result) ⇒ Object 



3957
3958
3959
3960
3961
 
# File 'opal/lib/opal/parser/grammar.rb', line 3957

def _reduce_234(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_239(val, _values, result) ⇒ Object

reduce 238 omitted



3971
3972
3973
3974
3975
 
# File 'opal/lib/opal/parser/grammar.rb', line 3971

def _reduce_239(val, _values, result)
                      result = s(:array, val[0])
                    
    result
end

#_reduce_240(val, _values, result) ⇒ Object 



3977
3978
3979
3980
3981
3982
 
# File 'opal/lib/opal/parser/grammar.rb', line 3977

def _reduce_240(val, _values, result)
                      result = val[0]
                      add_block_pass val[0], val[1]
                    
    result
end

#_reduce_241(val, _values, result) ⇒ Object 



3984
3985
3986
3987
3988
3989
 
# File 'opal/lib/opal/parser/grammar.rb', line 3984

def _reduce_241(val, _values, result)
                      result = s(:arglist, s(:hash, *val[0]))
                      add_block_pass result, val[1]
                    
    result
end

#_reduce_242(val, _values, result) ⇒ Object 



3991
3992
3993
3994
3995
3996
 
# File 'opal/lib/opal/parser/grammar.rb', line 3991

def _reduce_242(val, _values, result)
                      result = val[0]
                      result << s(:hash, *val[2])
                    
    result
end

#_reduce_243(val, _values, result) ⇒ Object 



3998
3999
4000
4001
4002
4003
 
# File 'opal/lib/opal/parser/grammar.rb', line 3998

def _reduce_243(val, _values, result)
                      result = s(:arglist)
                      add_block_pass result, val[0]
                    
    result
end

#_reduce_246(val, _values, result) ⇒ Object

reduce 245 omitted



4009
4010
4011
4012
4013
 
# File 'opal/lib/opal/parser/grammar.rb', line 4009

def _reduce_246(val, _values, result)
                      lexer.cmdarg_push 1
                    
    result
end

#_reduce_247(val, _values, result) ⇒ Object 



4015
4016
4017
4018
4019
4020
 
# File 'opal/lib/opal/parser/grammar.rb', line 4015

def _reduce_247(val, _values, result)
                      lexer.cmdarg_pop
                      result = val[1]
                    
    result
end

#_reduce_249(val, _values, result) ⇒ Object

reduce 248 omitted



4024
4025
4026
4027
4028
 
# File 'opal/lib/opal/parser/grammar.rb', line 4024

def _reduce_249(val, _values, result)
                      result = nil
                    
    result
end

#_reduce_25(val, _values, result) ⇒ Object

reduce 24 omitted



3135
3136
3137
3138
3139
 
# File 'opal/lib/opal/parser/grammar.rb', line 3135

def _reduce_25(val, _values, result)
                      result = new_assign val[0], val[2]
                    
    result
end

#_reduce_250(val, _values, result) ⇒ Object 



4030
4031
4032
4033
4034
 
# File 'opal/lib/opal/parser/grammar.rb', line 4030

def _reduce_250(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_251(val, _values, result) ⇒ Object 



4036
4037
4038
4039
4040
 
# File 'opal/lib/opal/parser/grammar.rb', line 4036

def _reduce_251(val, _values, result)
                      result = s(:block_pass, val[1])
                    
    result
end

#_reduce_252(val, _values, result) ⇒ Object 



4042
4043
4044
4045
4046
 
# File 'opal/lib/opal/parser/grammar.rb', line 4042

def _reduce_252(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_253(val, _values, result) ⇒ Object 



4048
4049
4050
4051
4052
 
# File 'opal/lib/opal/parser/grammar.rb', line 4048

def _reduce_253(val, _values, result)
                      result = nil
                    
    result
end

#_reduce_254(val, _values, result) ⇒ Object 



4054
4055
4056
4057
4058
 
# File 'opal/lib/opal/parser/grammar.rb', line 4054

def _reduce_254(val, _values, result)
                      result = s(:array, val[0])
                    
    result
end

#_reduce_255(val, _values, result) ⇒ Object 



4060
4061
4062
4063
4064
 
# File 'opal/lib/opal/parser/grammar.rb', line 4060

def _reduce_255(val, _values, result)
                      result = s(:array, s(:splat, val[1]))
                    
    result
end

#_reduce_256(val, _values, result) ⇒ Object 



4066
4067
4068
4069
4070
 
# File 'opal/lib/opal/parser/grammar.rb', line 4066

def _reduce_256(val, _values, result)
                      result = val[0] << val[2]
                    
    result
end

#_reduce_257(val, _values, result) ⇒ Object 



4072
4073
4074
4075
4076
 
# File 'opal/lib/opal/parser/grammar.rb', line 4072

def _reduce_257(val, _values, result)
                      result  = val[0] << s(:splat, val[3])
                    
    result
end

#_reduce_258(val, _values, result) ⇒ Object 



4078
4079
4080
4081
4082
4083
 
# File 'opal/lib/opal/parser/grammar.rb', line 4078

def _reduce_258(val, _values, result)
                      val[0] << val[2]
                      result = val[0]
                    
    result
end

#_reduce_26(val, _values, result) ⇒ Object 



3141
3142
3143
3144
3145
 
# File 'opal/lib/opal/parser/grammar.rb', line 3141

def _reduce_26(val, _values, result)
                      result = s(:masgn, val[0], s(:to_ary, val[2]))
                    
    result
end

#_reduce_260(val, _values, result) ⇒ Object

reduce 259 omitted



4087
4088
4089
4090
4091
 
# File 'opal/lib/opal/parser/grammar.rb', line 4087

def _reduce_260(val, _values, result)
                      result = s(:splat, val[1])
                    
    result
end

#_reduce_27(val, _values, result) ⇒ Object 



3147
3148
3149
3150
3151
 
# File 'opal/lib/opal/parser/grammar.rb', line 3147

def _reduce_27(val, _values, result)
                      result = new_op_asgn val[1].intern, val[0], val[2]
                    
    result
end

#_reduce_270(val, _values, result) ⇒ Object

reduce 269 omitted



4111
4112
4113
4114
4115
 
# File 'opal/lib/opal/parser/grammar.rb', line 4111

def _reduce_270(val, _values, result)
                      result = lexer.line
                    
    result
end

#_reduce_271(val, _values, result) ⇒ Object 



4117
4118
4119
4120
4121
4122
 
# File 'opal/lib/opal/parser/grammar.rb', line 4117

def _reduce_271(val, _values, result)
                      result = s(:begin, val[2])
                      result.line = val[1]
                    
    result
end

#_reduce_272(val, _values, result) ⇒ Object 



4124
4125
4126
4127
4128
 
# File 'opal/lib/opal/parser/grammar.rb', line 4124

def _reduce_272(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_273(val, _values, result) ⇒ Object 



4130
4131
4132
4133
4134
 
# File 'opal/lib/opal/parser/grammar.rb', line 4130

def _reduce_273(val, _values, result)
                      result = s(:paren, val[1] || s(:nil))
                    
    result
end

#_reduce_274(val, _values, result) ⇒ Object 



4136
4137
4138
4139
4140
 
# File 'opal/lib/opal/parser/grammar.rb', line 4136

def _reduce_274(val, _values, result)
                      result = s(:colon2, val[0], val[2].intern)
                    
    result
end

#_reduce_275(val, _values, result) ⇒ Object 



4142
4143
4144
4145
4146
 
# File 'opal/lib/opal/parser/grammar.rb', line 4142

def _reduce_275(val, _values, result)
                      result = s(:colon3, val[1])
                    
    result
end

#_reduce_276(val, _values, result) ⇒ Object 



4148
4149
4150
4151
4152
 
# File 'opal/lib/opal/parser/grammar.rb', line 4148

def _reduce_276(val, _values, result)
                      result = new_call val[0], :[], val[2]
                    
    result
end

#_reduce_277(val, _values, result) ⇒ Object 



4154
4155
4156
4157
4158
 
# File 'opal/lib/opal/parser/grammar.rb', line 4154

def _reduce_277(val, _values, result)
                      result = val[1] || s(:array)
                    
    result
end

#_reduce_278(val, _values, result) ⇒ Object 



4160
4161
4162
4163
4164
 
# File 'opal/lib/opal/parser/grammar.rb', line 4160

def _reduce_278(val, _values, result)
                      result = s(:hash, *val[1])
                    
    result
end

#_reduce_279(val, _values, result) ⇒ Object 



4166
4167
4168
4169
4170
 
# File 'opal/lib/opal/parser/grammar.rb', line 4166

def _reduce_279(val, _values, result)
                      result = s(:return)
                    
    result
end

#_reduce_280(val, _values, result) ⇒ Object 



4172
4173
4174
4175
4176
 
# File 'opal/lib/opal/parser/grammar.rb', line 4172

def _reduce_280(val, _values, result)
                      result = new_yield val[2]
                    
    result
end

#_reduce_281(val, _values, result) ⇒ Object 



4178
4179
4180
4181
4182
 
# File 'opal/lib/opal/parser/grammar.rb', line 4178

def _reduce_281(val, _values, result)
                      result = s(:yield)
                    
    result
end

#_reduce_282(val, _values, result) ⇒ Object 



4184
4185
4186
4187
4188
 
# File 'opal/lib/opal/parser/grammar.rb', line 4184

def _reduce_282(val, _values, result)
                      result = s(:yield)
                    
    result
end

#_reduce_283(val, _values, result) ⇒ Object 



4190
4191
4192
4193
4194
 
# File 'opal/lib/opal/parser/grammar.rb', line 4190

def _reduce_283(val, _values, result)
                      result = s(:defined, val[3])
                    
    result
end

#_reduce_284(val, _values, result) ⇒ Object 



4196
4197
4198
4199
4200
4201
 
# File 'opal/lib/opal/parser/grammar.rb', line 4196

def _reduce_284(val, _values, result)
                      result = s(:not, val[2])
                      result.line = val[2].line
                    
    result
end

#_reduce_285(val, _values, result) ⇒ Object 



4203
4204
4205
4206
4207
 
# File 'opal/lib/opal/parser/grammar.rb', line 4203

def _reduce_285(val, _values, result)
                      result = s(:not, s(:nil))
                    
    result
end

#_reduce_286(val, _values, result) ⇒ Object 



4209
4210
4211
4212
4213
4214
 
# File 'opal/lib/opal/parser/grammar.rb', line 4209

def _reduce_286(val, _values, result)
                      result = new_call nil, val[0].intern, s(:arglist)
                      result << val[1]
                    
    result
end

#_reduce_288(val, _values, result) ⇒ Object

reduce 287 omitted



4218
4219
4220
4221
4222
4223
 
# File 'opal/lib/opal/parser/grammar.rb', line 4218

def _reduce_288(val, _values, result)
                      val[0] << val[1]
                      result = val[0]
                    
    result
end

#_reduce_289(val, _values, result) ⇒ Object 



4225
4226
4227
4228
4229
 
# File 'opal/lib/opal/parser/grammar.rb', line 4225

def _reduce_289(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_29(val, _values, result) ⇒ Object

reduce 28 omitted



3155
3156
3157
3158
3159
 
# File 'opal/lib/opal/parser/grammar.rb', line 3155

def _reduce_29(val, _values, result)
                      result = s(:op_asgn2, val[0], "#{val[2]}=".intern, val[3].intern, val[4])
                    
    result
end

#_reduce_290(val, _values, result) ⇒ Object 



4231
4232
4233
4234
4235
 
# File 'opal/lib/opal/parser/grammar.rb', line 4231

def _reduce_290(val, _values, result)
                      result = new_if val[1], val[3], val[4]
                    
    result
end

#_reduce_291(val, _values, result) ⇒ Object 



4237
4238
4239
4240
4241
 
# File 'opal/lib/opal/parser/grammar.rb', line 4237

def _reduce_291(val, _values, result)
                      result = new_if val[1], val[4], val[3]
                    
    result
end

#_reduce_292(val, _values, result) ⇒ Object 



4243
4244
4245
4246
4247
4248
 
# File 'opal/lib/opal/parser/grammar.rb', line 4243

def _reduce_292(val, _values, result)
                      lexer.cond_push 1
                      result = lexer.line
                    
    result
end

#_reduce_293(val, _values, result) ⇒ Object 



4250
4251
4252
4253
4254
 
# File 'opal/lib/opal/parser/grammar.rb', line 4250

def _reduce_293(val, _values, result)
                      lexer.cond_pop
                    
    result
end

#_reduce_294(val, _values, result) ⇒ Object 



4256
4257
4258
4259
4260
4261
 
# File 'opal/lib/opal/parser/grammar.rb', line 4256

def _reduce_294(val, _values, result)
                      result = s(:while, val[2], val[5], true)
                      result.line = val[1]
                    
    result
end

#_reduce_295(val, _values, result) ⇒ Object 



4263
4264
4265
4266
4267
4268
 
# File 'opal/lib/opal/parser/grammar.rb', line 4263

def _reduce_295(val, _values, result)
                      lexer.cond_push 1
                      result = lexer.line
                    
    result
end

#_reduce_296(val, _values, result) ⇒ Object 



4270
4271
4272
4273
4274
 
# File 'opal/lib/opal/parser/grammar.rb', line 4270

def _reduce_296(val, _values, result)
                      lexer.cond_pop
                    
    result
end

#_reduce_297(val, _values, result) ⇒ Object 



4276
4277
4278
4279
4280
4281
 
# File 'opal/lib/opal/parser/grammar.rb', line 4276

def _reduce_297(val, _values, result)
                      result = s(:until, val[2], val[5], true)
                      result.line = val[1]
                    
    result
end

#_reduce_298(val, _values, result) ⇒ Object 



4283
4284
4285
4286
4287
4288
 
# File 'opal/lib/opal/parser/grammar.rb', line 4283

def _reduce_298(val, _values, result)
                      result = s(:case, val[1], *val[3])
                      result.line = val[1].line
                    
    result
end

#_reduce_299(val, _values, result) ⇒ Object 



4290
4291
4292
4293
4294
4295
 
# File 'opal/lib/opal/parser/grammar.rb', line 4290

def _reduce_299(val, _values, result)
                      result = s(:case, nil, *val[2])
                      # result.line = val[2].line
                    
    result
end

#_reduce_3(val, _values, result) ⇒ Object 



3007
3008
3009
3010
3011
 
# File 'opal/lib/opal/parser/grammar.rb', line 3007

def _reduce_3(val, _values, result)
                      result = new_block
                    
    result
end

#_reduce_300(val, _values, result) ⇒ Object 



4297
4298
4299
4300
4301
4302
 
# File 'opal/lib/opal/parser/grammar.rb', line 4297

def _reduce_300(val, _values, result)
                      result = s(:case, nil, val[3])
                      # result.line = val[3].line
                    
    result
end

#_reduce_301(val, _values, result) ⇒ Object 



4304
4305
4306
4307
4308
 
# File 'opal/lib/opal/parser/grammar.rb', line 4304

def _reduce_301(val, _values, result)
                      # ...
                    
    result
end

#_reduce_302(val, _values, result) ⇒ Object 



4310
4311
4312
4313
4314
 
# File 'opal/lib/opal/parser/grammar.rb', line 4310

def _reduce_302(val, _values, result)
                      # ...
                    
    result
end

#_reduce_304(val, _values, result) ⇒ Object

reduce 303 omitted



4318
4319
4320
4321
4322
 
# File 'opal/lib/opal/parser/grammar.rb', line 4318

def _reduce_304(val, _values, result)
                      result = lexer.line
                    
    result
end

#_reduce_305(val, _values, result) ⇒ Object 



4324
4325
4326
4327
4328
 
# File 'opal/lib/opal/parser/grammar.rb', line 4324

def _reduce_305(val, _values, result)
                      # ...
                    
    result
end

#_reduce_306(val, _values, result) ⇒ Object 



4330
4331
4332
4333
4334
4335
4336
 
# File 'opal/lib/opal/parser/grammar.rb', line 4330

def _reduce_306(val, _values, result)
                      result = new_class val[2], val[3], val[5]
                      result.line = val[1]
                      result.end_line = lexer.line
                    
    result
end

#_reduce_307(val, _values, result) ⇒ Object 



4338
4339
4340
4341
4342
 
# File 'opal/lib/opal/parser/grammar.rb', line 4338

def _reduce_307(val, _values, result)
                      result = lexer.line
                    
    result
end

#_reduce_308(val, _values, result) ⇒ Object 



4344
4345
4346
4347
4348
 
# File 'opal/lib/opal/parser/grammar.rb', line 4344

def _reduce_308(val, _values, result)
                      # ...
                    
    result
end

#_reduce_309(val, _values, result) ⇒ Object 



4350
4351
4352
4353
4354
4355
 
# File 'opal/lib/opal/parser/grammar.rb', line 4350

def _reduce_309(val, _values, result)
                      result = new_sclass val[3], val[6]
                      result.line = val[2]
                    
    result
end

#_reduce_310(val, _values, result) ⇒ Object 



4357
4358
4359
4360
4361
 
# File 'opal/lib/opal/parser/grammar.rb', line 4357

def _reduce_310(val, _values, result)
                      result = lexer.line
                    
    result
end

#_reduce_311(val, _values, result) ⇒ Object 



4363
4364
4365
4366
4367
 
# File 'opal/lib/opal/parser/grammar.rb', line 4363

def _reduce_311(val, _values, result)
                      # ...
                    
    result
end

#_reduce_312(val, _values, result) ⇒ Object 



4369
4370
4371
4372
4373
4374
4375
 
# File 'opal/lib/opal/parser/grammar.rb', line 4369

def _reduce_312(val, _values, result)
                      result = new_module val[2], val[4]
                      result.line = val[1]
                      result.end_line = lexer.line
                    
    result
end

#_reduce_313(val, _values, result) ⇒ Object 



4377
4378
4379
4380
4381
4382
 
# File 'opal/lib/opal/parser/grammar.rb', line 4377

def _reduce_313(val, _values, result)
                      result = lexer.scope_line
                      push_scope
                    
    result
end

#_reduce_314(val, _values, result) ⇒ Object 



4384
4385
4386
4387
4388
4389
 
# File 'opal/lib/opal/parser/grammar.rb', line 4384

def _reduce_314(val, _values, result)
                      result = new_def val[2], nil, val[1], val[3], val[4]
                      pop_scope
                    
    result
end

#_reduce_315(val, _values, result) ⇒ Object 



4391
4392
4393
4394
4395
 
# File 'opal/lib/opal/parser/grammar.rb', line 4391

def _reduce_315(val, _values, result)
                       lexer.lex_state = :expr_fname
                    
    result
end

#_reduce_316(val, _values, result) ⇒ Object 



4397
4398
4399
4400
4401
4402
 
# File 'opal/lib/opal/parser/grammar.rb', line 4397

def _reduce_316(val, _values, result)
                      result = lexer.scope_line
                      push_scope
                    
    result
end

#_reduce_317(val, _values, result) ⇒ Object 



4404
4405
4406
4407
4408
4409
 
# File 'opal/lib/opal/parser/grammar.rb', line 4404

def _reduce_317(val, _values, result)
                      result = new_def val[5], val[1], val[4], val[6], val[7]
                      pop_scope
                    
    result
end

#_reduce_318(val, _values, result) ⇒ Object 



4411
4412
4413
4414
4415
 
# File 'opal/lib/opal/parser/grammar.rb', line 4411

def _reduce_318(val, _values, result)
                      result = s(:break)
                    
    result
end

#_reduce_319(val, _values, result) ⇒ Object 



4417
4418
4419
4420
4421
 
# File 'opal/lib/opal/parser/grammar.rb', line 4417

def _reduce_319(val, _values, result)
                      result = s(:next)
                    
    result
end

#_reduce_320(val, _values, result) ⇒ Object 



4423
4424
4425
4426
4427
 
# File 'opal/lib/opal/parser/grammar.rb', line 4423

def _reduce_320(val, _values, result)
                      result = s(:redo)
                    
    result
end

#_reduce_33(val, _values, result) ⇒ Object

reduce 32 omitted



3167
3168
3169
3170
3171
 
# File 'opal/lib/opal/parser/grammar.rb', line 3167

def _reduce_33(val, _values, result)
                      result = new_assign val[0], s(:svalue, val[2])
                    
    result
end

#_reduce_330(val, _values, result) ⇒ Object

reduce 329 omitted



4447
4448
4449
4450
4451
4452
 
# File 'opal/lib/opal/parser/grammar.rb', line 4447

def _reduce_330(val, _values, result)
                      result = new_call nil, :lambda, s(:arglist)
                      result << new_iter(val[0], val[1])
                    
    result
end

#_reduce_331(val, _values, result) ⇒ Object 



4454
4455
4456
4457
4458
 
# File 'opal/lib/opal/parser/grammar.rb', line 4454

def _reduce_331(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_332(val, _values, result) ⇒ Object 



4460
4461
4462
4463
4464
 
# File 'opal/lib/opal/parser/grammar.rb', line 4460

def _reduce_332(val, _values, result)
                      result = nil
                    
    result
end

#_reduce_335(val, _values, result) ⇒ Object

reduce 334 omitted



4470
4471
4472
4473
4474
 
# File 'opal/lib/opal/parser/grammar.rb', line 4470

def _reduce_335(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_336(val, _values, result) ⇒ Object 



4476
4477
4478
4479
4480
 
# File 'opal/lib/opal/parser/grammar.rb', line 4476

def _reduce_336(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_337(val, _values, result) ⇒ Object 



4482
4483
4484
4485
4486
 
# File 'opal/lib/opal/parser/grammar.rb', line 4482

def _reduce_337(val, _values, result)
                      result = val[0]
                    
    result
end

#_reduce_338(val, _values, result) ⇒ Object 



4488
4489
4490
4491
4492
 
# File 'opal/lib/opal/parser/grammar.rb', line 4488

def _reduce_338(val, _values, result)
                      result = lexer.line
                    
    result
end

#_reduce_339(val, _values, result) ⇒ Object 



4494
4495
4496
4497
4498
4499
 
# File 'opal/lib/opal/parser/grammar.rb', line 4494

def _reduce_339(val, _values, result)
                      result = s(:if, val[2], val[4], val[5])
                      result.line = val[1]
                    
    result
end

#_reduce_34(val, _values, result) ⇒ Object 



3173
3174
3175
3176
3177
 
# File 'opal/lib/opal/parser/grammar.rb', line 3173

def _reduce_34(val, _values, result)
                      result = s(:masgn, val[0], s(:to_ary, val[2]))
                    
    result
end

#_reduce_341(val, _values, result) ⇒ Object

reduce 340 omitted



4503
4504
4505
4506
4507
 
# File 'opal/lib/opal/parser/grammar.rb', line 4503

def _reduce_341(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_342(val, _values, result) ⇒ Object 



4509
4510
4511
4512
4513
 
# File 'opal/lib/opal/parser/grammar.rb', line 4509

def _reduce_342(val, _values, result)
                      result = s(:block, val[0])
                    
    result
end

#_reduce_343(val, _values, result) ⇒ Object 



4515
4516
4517
4518
4519
4520
 
# File 'opal/lib/opal/parser/grammar.rb', line 4515

def _reduce_343(val, _values, result)
                      val[0] << val[2]
                      result = val[0]
                    
    result
end

#_reduce_344(val, _values, result) ⇒ Object 



4522
4523
4524
4525
4526
 
# File 'opal/lib/opal/parser/grammar.rb', line 4522

def _reduce_344(val, _values, result)
                      result = new_assign new_assignable(s(:identifier, val[0].intern)), val[2]
                    
    result
end

#_reduce_346(val, _values, result) ⇒ Object

reduce 345 omitted



4530
4531
4532
4533
4534
 
# File 'opal/lib/opal/parser/grammar.rb', line 4530

def _reduce_346(val, _values, result)
                      result = 0
                    
    result
end

#_reduce_347(val, _values, result) ⇒ Object 



4536
4537
4538
4539
4540
 
# File 'opal/lib/opal/parser/grammar.rb', line 4536

def _reduce_347(val, _values, result)
                      result = 0
                    
    result
end

#_reduce_348(val, _values, result) ⇒ Object 



4542
4543
4544
4545
4546
 
# File 'opal/lib/opal/parser/grammar.rb', line 4542

def _reduce_348(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_349(val, _values, result) ⇒ Object 



4548
4549
4550
4551
4552
 
# File 'opal/lib/opal/parser/grammar.rb', line 4548

def _reduce_349(val, _values, result)
                      result = val[0]
                    
    result
end

#_reduce_35(val, _values, result) ⇒ Object 



3179
3180
3181
3182
3183
 
# File 'opal/lib/opal/parser/grammar.rb', line 3179

def _reduce_35(val, _values, result)
                      result = s(:masgn, val[0], val[2])
                    
    result
end

#_reduce_350(val, _values, result) ⇒ Object 



4554
4555
4556
4557
4558
 
# File 'opal/lib/opal/parser/grammar.rb', line 4554

def _reduce_350(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_351(val, _values, result) ⇒ Object 



4560
4561
4562
4563
4564
 
# File 'opal/lib/opal/parser/grammar.rb', line 4560

def _reduce_351(val, _values, result)
                      nil
                    
    result
end

#_reduce_352(val, _values, result) ⇒ Object 



4566
4567
4568
4569
4570
 
# File 'opal/lib/opal/parser/grammar.rb', line 4566

def _reduce_352(val, _values, result)
                      result = new_block_args val[0], val[2], val[4], val[5]
                    
    result
end

#_reduce_353(val, _values, result) ⇒ Object 



4572
4573
4574
4575
4576
 
# File 'opal/lib/opal/parser/grammar.rb', line 4572

def _reduce_353(val, _values, result)
                      result = new_block_args val[0], val[2], nil, val[3]
                    
    result
end

#_reduce_354(val, _values, result) ⇒ Object 



4578
4579
4580
4581
4582
 
# File 'opal/lib/opal/parser/grammar.rb', line 4578

def _reduce_354(val, _values, result)
                      result = new_block_args val[0], nil, val[2], val[3]
                    
    result
end

#_reduce_355(val, _values, result) ⇒ Object 



4584
4585
4586
4587
4588
 
# File 'opal/lib/opal/parser/grammar.rb', line 4584

def _reduce_355(val, _values, result)
                      result = new_block_args val[0], nil, nil, nil
                    
    result
end

#_reduce_356(val, _values, result) ⇒ Object 



4590
4591
4592
4593
4594
 
# File 'opal/lib/opal/parser/grammar.rb', line 4590

def _reduce_356(val, _values, result)
                      result = new_block_args val[0], nil, nil, val[1]
                    
    result
end

#_reduce_357(val, _values, result) ⇒ Object 



4596
4597
4598
4599
4600
 
# File 'opal/lib/opal/parser/grammar.rb', line 4596

def _reduce_357(val, _values, result)
                      result = new_block_args nil, val[0], val[2], val[3]
                    
    result
end

#_reduce_358(val, _values, result) ⇒ Object 



4602
4603
4604
4605
4606
 
# File 'opal/lib/opal/parser/grammar.rb', line 4602

def _reduce_358(val, _values, result)
                      result = new_block_args nil, val[0], nil, val[1]
                    
    result
end

#_reduce_359(val, _values, result) ⇒ Object 



4608
4609
4610
4611
4612
 
# File 'opal/lib/opal/parser/grammar.rb', line 4608

def _reduce_359(val, _values, result)
                      result = new_block_args nil, nil, val[0], val[1]
                    
    result
end

#_reduce_360(val, _values, result) ⇒ Object 



4614
4615
4616
4617
4618
 
# File 'opal/lib/opal/parser/grammar.rb', line 4614

def _reduce_360(val, _values, result)
                      result = new_block_args nil, nil, nil, val[0]
                    
    result
end

#_reduce_361(val, _values, result) ⇒ Object 



4620
4621
4622
4623
4624
4625
 
# File 'opal/lib/opal/parser/grammar.rb', line 4620

def _reduce_361(val, _values, result)
                      push_scope :block
                      result = lexer.line
                    
    result
end

#_reduce_362(val, _values, result) ⇒ Object 



4627
4628
4629
4630
4631
4632
4633
 
# File 'opal/lib/opal/parser/grammar.rb', line 4627

def _reduce_362(val, _values, result)
                      result = new_iter val[2], val[3]
                      result.line = val[1]
                      pop_scope
                    
    result
end

#_reduce_363(val, _values, result) ⇒ Object 



4635
4636
4637
4638
4639
4640
 
# File 'opal/lib/opal/parser/grammar.rb', line 4635

def _reduce_363(val, _values, result)
                      val[0] << val[1]
                      result = val[0]
                    
    result
end

#_reduce_366(val, _values, result) ⇒ Object

reduce 365 omitted



4646
4647
4648
4649
4650
 
# File 'opal/lib/opal/parser/grammar.rb', line 4646

def _reduce_366(val, _values, result)
                      result = new_call nil, val[0].intern, val[1]
                    
    result
end

#_reduce_367(val, _values, result) ⇒ Object 



4652
4653
4654
4655
4656
 
# File 'opal/lib/opal/parser/grammar.rb', line 4652

def _reduce_367(val, _values, result)
                      result = new_call val[0], val[2].intern, val[3]
                    
    result
end

#_reduce_368(val, _values, result) ⇒ Object 



4658
4659
4660
4661
4662
 
# File 'opal/lib/opal/parser/grammar.rb', line 4658

def _reduce_368(val, _values, result)
                      result = new_call val[0], :call, val[2]
                    
    result
end

#_reduce_369(val, _values, result) ⇒ Object 



4664
4665
4666
4667
4668
 
# File 'opal/lib/opal/parser/grammar.rb', line 4664

def _reduce_369(val, _values, result)
                      result = new_call val[0], val[2].intern, val[3]
                    
    result
end

#_reduce_370(val, _values, result) ⇒ Object 



4670
4671
4672
4673
4674
 
# File 'opal/lib/opal/parser/grammar.rb', line 4670

def _reduce_370(val, _values, result)
                      result = new_call val[0], val[2].intern, s(:arglist)
                    
    result
end

#_reduce_371(val, _values, result) ⇒ Object 



4676
4677
4678
4679
4680
 
# File 'opal/lib/opal/parser/grammar.rb', line 4676

def _reduce_371(val, _values, result)
                      result = new_super val[1]
                    
    result
end

#_reduce_372(val, _values, result) ⇒ Object 



4682
4683
4684
4685
4686
 
# File 'opal/lib/opal/parser/grammar.rb', line 4682

def _reduce_372(val, _values, result)
                      result = s(:super, nil)
                    
    result
end

#_reduce_373(val, _values, result) ⇒ Object 



4688
4689
4690
4691
4692
4693
 
# File 'opal/lib/opal/parser/grammar.rb', line 4688

def _reduce_373(val, _values, result)
                      push_scope :block
                      result = lexer.line
                    
    result
end

#_reduce_374(val, _values, result) ⇒ Object 



4695
4696
4697
4698
4699
4700
4701
 
# File 'opal/lib/opal/parser/grammar.rb', line 4695

def _reduce_374(val, _values, result)
                      result = new_iter val[2], val[3]
                      result.line = val[1]
                      pop_scope
                    
    result
end

#_reduce_375(val, _values, result) ⇒ Object 



4703
4704
4705
4706
4707
4708
 
# File 'opal/lib/opal/parser/grammar.rb', line 4703

def _reduce_375(val, _values, result)
                      push_scope :block
                      result = lexer.line
                    
    result
end

#_reduce_376(val, _values, result) ⇒ Object 



4710
4711
4712
4713
4714
4715
4716
 
# File 'opal/lib/opal/parser/grammar.rb', line 4710

def _reduce_376(val, _values, result)
                      result = new_iter val[2], val[3]
                      result.line = val[1]
                      pop_scope
                    
    result
end

#_reduce_377(val, _values, result) ⇒ Object 



4718
4719
4720
4721
4722
 
# File 'opal/lib/opal/parser/grammar.rb', line 4718

def _reduce_377(val, _values, result)
                      result = lexer.line
                    
    result
end

#_reduce_378(val, _values, result) ⇒ Object 



4724
4725
4726
4727
4728
4729
4730
4731
 
# File 'opal/lib/opal/parser/grammar.rb', line 4724

def _reduce_378(val, _values, result)
                      part = s(:when, val[2], val[4])
                      part.line = val[2].line
                      result = [part]
                      result.push *val[5] if val[5]
                    
    result
end

#_reduce_379(val, _values, result) ⇒ Object 



4733
4734
4735
4736
4737
 
# File 'opal/lib/opal/parser/grammar.rb', line 4733

def _reduce_379(val, _values, result)
                      result = [val[0]]
                    
    result
end

#_reduce_38(val, _values, result) ⇒ Object

reduce 37 omitted



3189
3190
3191
3192
3193
3194
 
# File 'opal/lib/opal/parser/grammar.rb', line 3189

def _reduce_38(val, _values, result)
                      result = s(:and, val[0], val[2])
                      result.line = val[0].line
                    
    result
end

#_reduce_381(val, _values, result) ⇒ Object

reduce 380 omitted



4741
4742
4743
4744
4745
4746
4747
4748
 
# File 'opal/lib/opal/parser/grammar.rb', line 4741

def _reduce_381(val, _values, result)
                      exc = val[1] || s(:array)
                      exc << new_assign(val[2], s(:gvar, '$!'.intern)) if val[2]
                      result = [s(:resbody, exc, val[4])]
                      result.push val[5].first if val[5]
                    
    result
end

#_reduce_382(val, _values, result) ⇒ Object 



4750
4751
4752
4753
4754
 
# File 'opal/lib/opal/parser/grammar.rb', line 4750

def _reduce_382(val, _values, result)
                      result = nil
                    
    result
end

#_reduce_383(val, _values, result) ⇒ Object 



4756
4757
4758
4759
4760
 
# File 'opal/lib/opal/parser/grammar.rb', line 4756

def _reduce_383(val, _values, result)
                      result = s(:array, val[0])
                    
    result
end

#_reduce_386(val, _values, result) ⇒ Object

reduce 385 omitted



4766
4767
4768
4769
4770
 
# File 'opal/lib/opal/parser/grammar.rb', line 4766

def _reduce_386(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_387(val, _values, result) ⇒ Object 



4772
4773
4774
4775
4776
 
# File 'opal/lib/opal/parser/grammar.rb', line 4772

def _reduce_387(val, _values, result)
                      result = nil
                    
    result
end

#_reduce_388(val, _values, result) ⇒ Object 



4778
4779
4780
4781
4782
 
# File 'opal/lib/opal/parser/grammar.rb', line 4778

def _reduce_388(val, _values, result)
                      result = val[1].nil? ? s(:nil) : val[1]
                    
    result
end

#_reduce_39(val, _values, result) ⇒ Object 



3196
3197
3198
3199
3200
3201
 
# File 'opal/lib/opal/parser/grammar.rb', line 3196

def _reduce_39(val, _values, result)
                      result = s(:or, val[0], val[2])
                      result.line = val[0].line
                    
    result
end

#_reduce_393(val, _values, result) ⇒ Object

reduce 392 omitted



4792
4793
4794
4795
4796
 
# File 'opal/lib/opal/parser/grammar.rb', line 4792

def _reduce_393(val, _values, result)
                      result = new_str val[0]
                    
    result
end

#_reduce_396(val, _values, result) ⇒ Object

reduce 395 omitted



4802
4803
4804
4805
4806
 
# File 'opal/lib/opal/parser/grammar.rb', line 4802

def _reduce_396(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_397(val, _values, result) ⇒ Object 



4808
4809
4810
4811
4812
 
# File 'opal/lib/opal/parser/grammar.rb', line 4808

def _reduce_397(val, _values, result)
                      result = s(:str, val[0])
                    
    result
end

#_reduce_398(val, _values, result) ⇒ Object 



4814
4815
4816
4817
4818
 
# File 'opal/lib/opal/parser/grammar.rb', line 4814

def _reduce_398(val, _values, result)
                      result = new_xstr val[1]
                    
    result
end

#_reduce_399(val, _values, result) ⇒ Object 



4820
4821
4822
4823
4824
 
# File 'opal/lib/opal/parser/grammar.rb', line 4820

def _reduce_399(val, _values, result)
                      result = new_regexp val[1], val[2]
                    
    result
end

#_reduce_4(val, _values, result) ⇒ Object 



3013
3014
3015
3016
3017
 
# File 'opal/lib/opal/parser/grammar.rb', line 3013

def _reduce_4(val, _values, result)
                      result = new_block val[0]
                    
    result
end

#_reduce_40(val, _values, result) ⇒ Object 



3203
3204
3205
3206
3207
3208
 
# File 'opal/lib/opal/parser/grammar.rb', line 3203

def _reduce_40(val, _values, result)
                      result = s(:not, val[1])
                      result.line = val[1].line
                    
    result
end

#_reduce_400(val, _values, result) ⇒ Object 



4826
4827
4828
4829
4830
 
# File 'opal/lib/opal/parser/grammar.rb', line 4826

def _reduce_400(val, _values, result)
                      result = s(:array)
                    
    result
end

#_reduce_401(val, _values, result) ⇒ Object 



4832
4833
4834
4835
4836
 
# File 'opal/lib/opal/parser/grammar.rb', line 4832

def _reduce_401(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_402(val, _values, result) ⇒ Object 



4838
4839
4840
4841
4842
 
# File 'opal/lib/opal/parser/grammar.rb', line 4838

def _reduce_402(val, _values, result)
                      result = s(:array)
                    
    result
end

#_reduce_403(val, _values, result) ⇒ Object 



4844
4845
4846
4847
4848
4849
4850
 
# File 'opal/lib/opal/parser/grammar.rb', line 4844

def _reduce_403(val, _values, result)
                      part = val[1]
                      part = s(:dstr, "", val[1]) if part.type == :evstr
                      result = val[0] << part
                    
    result
end

#_reduce_404(val, _values, result) ⇒ Object 



4852
4853
4854
4855
4856
 
# File 'opal/lib/opal/parser/grammar.rb', line 4852

def _reduce_404(val, _values, result)
                      result = val[0]
                    
    result
end

#_reduce_405(val, _values, result) ⇒ Object 



4858
4859
4860
4861
4862
 
# File 'opal/lib/opal/parser/grammar.rb', line 4858

def _reduce_405(val, _values, result)
                      result = val[0].concat([val[1]])
                    
    result
end

#_reduce_406(val, _values, result) ⇒ Object 



4864
4865
4866
4867
4868
 
# File 'opal/lib/opal/parser/grammar.rb', line 4864

def _reduce_406(val, _values, result)
                      result = s(:array)
                    
    result
end

#_reduce_407(val, _values, result) ⇒ Object 



4870
4871
4872
4873
4874
 
# File 'opal/lib/opal/parser/grammar.rb', line 4870

def _reduce_407(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_408(val, _values, result) ⇒ Object 



4876
4877
4878
4879
4880
 
# File 'opal/lib/opal/parser/grammar.rb', line 4876

def _reduce_408(val, _values, result)
                      result = s(:array)
                    
    result
end

#_reduce_409(val, _values, result) ⇒ Object 



4882
4883
4884
4885
4886
 
# File 'opal/lib/opal/parser/grammar.rb', line 4882

def _reduce_409(val, _values, result)
                      result = val[0] << s(:str, val[1])
                    
    result
end

#_reduce_41(val, _values, result) ⇒ Object 



3210
3211
3212
3213
3214
 
# File 'opal/lib/opal/parser/grammar.rb', line 3210

def _reduce_41(val, _values, result)
                      result = s(:not, val[1])
                    
    result
end

#_reduce_410(val, _values, result) ⇒ Object 



4888
4889
4890
4891
4892
 
# File 'opal/lib/opal/parser/grammar.rb', line 4888

def _reduce_410(val, _values, result)
                      result = nil
                    
    result
end

#_reduce_411(val, _values, result) ⇒ Object 



4894
4895
4896
4897
4898
 
# File 'opal/lib/opal/parser/grammar.rb', line 4894

def _reduce_411(val, _values, result)
                      result = str_append val[0], val[1]
                    
    result
end

#_reduce_412(val, _values, result) ⇒ Object 



4900
4901
4902
4903
4904
 
# File 'opal/lib/opal/parser/grammar.rb', line 4900

def _reduce_412(val, _values, result)
                      result = nil
                    
    result
end

#_reduce_413(val, _values, result) ⇒ Object 



4906
4907
4908
4909
4910
 
# File 'opal/lib/opal/parser/grammar.rb', line 4906

def _reduce_413(val, _values, result)
                      result = str_append val[0], val[1]
                    
    result
end

#_reduce_414(val, _values, result) ⇒ Object 



4912
4913
4914
4915
4916
 
# File 'opal/lib/opal/parser/grammar.rb', line 4912

def _reduce_414(val, _values, result)
                      result = s(:str, val[0])
                    
    result
end

#_reduce_415(val, _values, result) ⇒ Object 



4918
4919
4920
4921
4922
4923
 
# File 'opal/lib/opal/parser/grammar.rb', line 4918

def _reduce_415(val, _values, result)
                      result = lexer.strterm
                      lexer.strterm = nil
                    
    result
end

#_reduce_416(val, _values, result) ⇒ Object 



4925
4926
4927
4928
4929
4930
 
# File 'opal/lib/opal/parser/grammar.rb', line 4925

def _reduce_416(val, _values, result)
                      lexer.strterm = val[1]
                      result = s(:evstr, val[2])
                    
    result
end

#_reduce_417(val, _values, result) ⇒ Object 



4932
4933
4934
4935
4936
4937
4938
4939
4940
 
# File 'opal/lib/opal/parser/grammar.rb', line 4932

def _reduce_417(val, _values, result)
                      lexer.cond_push 0
                      lexer.cmdarg_push 0
                      result = lexer.strterm
                      lexer.strterm = nil
                      lexer.lex_state = :expr_beg
                    
    result
end

#_reduce_418(val, _values, result) ⇒ Object 



4942
4943
4944
4945
4946
4947
4948
4949
 
# File 'opal/lib/opal/parser/grammar.rb', line 4942

def _reduce_418(val, _values, result)
                      lexer.strterm = val[1]
                      lexer.cond_lexpop
                      lexer.cmdarg_lexpop
                      result = s(:evstr, val[2])
                    
    result
end

#_reduce_419(val, _values, result) ⇒ Object 



4951
4952
4953
4954
4955
 
# File 'opal/lib/opal/parser/grammar.rb', line 4951

def _reduce_419(val, _values, result)
                      result = s(:gvar, val[0].intern)
                    
    result
end

#_reduce_420(val, _values, result) ⇒ Object 



4957
4958
4959
4960
4961
 
# File 'opal/lib/opal/parser/grammar.rb', line 4957

def _reduce_420(val, _values, result)
                      result = s(:ivar, val[0].intern)
                    
    result
end

#_reduce_421(val, _values, result) ⇒ Object 



4963
4964
4965
4966
4967
 
# File 'opal/lib/opal/parser/grammar.rb', line 4963

def _reduce_421(val, _values, result)
                      result = s(:cvar, val[0].intern)
                    
    result
end

#_reduce_423(val, _values, result) ⇒ Object

reduce 422 omitted



4971
4972
4973
4974
4975
4976
 
# File 'opal/lib/opal/parser/grammar.rb', line 4971

def _reduce_423(val, _values, result)
                      result = s(:sym, val[1].intern)
                      lexer.lex_state = :expr_end
                    
    result
end

#_reduce_424(val, _values, result) ⇒ Object 



4978
4979
4980
4981
4982
 
# File 'opal/lib/opal/parser/grammar.rb', line 4978

def _reduce_424(val, _values, result)
                      result = s(:sym, val[0].intern)
                    
    result
end

#_reduce_429(val, _values, result) ⇒ Object

reduce 428 omitted



4992
4993
4994
4995
4996
 
# File 'opal/lib/opal/parser/grammar.rb', line 4992

def _reduce_429(val, _values, result)
                      result = new_dsym val[1]
                    
    result
end

#_reduce_430(val, _values, result) ⇒ Object 



4998
4999
5000
5001
5002
 
# File 'opal/lib/opal/parser/grammar.rb', line 4998

def _reduce_430(val, _values, result)
                      result = s(:int, val[0])
                    
    result
end

#_reduce_431(val, _values, result) ⇒ Object 



5004
5005
5006
5007
5008
 
# File 'opal/lib/opal/parser/grammar.rb', line 5004

def _reduce_431(val, _values, result)
                      result = s(:float, val[0])
                    
    result
end

#_reduce_434(val, _values, result) ⇒ Object

reduce 433 omitted



5014
5015
5016
5017
5018
 
# File 'opal/lib/opal/parser/grammar.rb', line 5014

def _reduce_434(val, _values, result)
                      result = s(:identifier, val[0].intern)
                    
    result
end

#_reduce_435(val, _values, result) ⇒ Object 



5020
5021
5022
5023
5024
 
# File 'opal/lib/opal/parser/grammar.rb', line 5020

def _reduce_435(val, _values, result)
                      result = s(:ivar, val[0].intern)
                    
    result
end

#_reduce_436(val, _values, result) ⇒ Object 



5026
5027
5028
5029
5030
 
# File 'opal/lib/opal/parser/grammar.rb', line 5026

def _reduce_436(val, _values, result)
                      result = s(:gvar, val[0].intern)
                    
    result
end

#_reduce_437(val, _values, result) ⇒ Object 



5032
5033
5034
5035
5036
 
# File 'opal/lib/opal/parser/grammar.rb', line 5032

def _reduce_437(val, _values, result)
                      result = s(:const, val[0].intern)
                    
    result
end

#_reduce_438(val, _values, result) ⇒ Object 



5038
5039
5040
5041
5042
 
# File 'opal/lib/opal/parser/grammar.rb', line 5038

def _reduce_438(val, _values, result)
                      result = s(:cvar, val[0].intern)
                    
    result
end

#_reduce_439(val, _values, result) ⇒ Object 



5044
5045
5046
5047
5048
 
# File 'opal/lib/opal/parser/grammar.rb', line 5044

def _reduce_439(val, _values, result)
                      result = s(:nil)
                    
    result
end

#_reduce_440(val, _values, result) ⇒ Object 



5050
5051
5052
5053
5054
 
# File 'opal/lib/opal/parser/grammar.rb', line 5050

def _reduce_440(val, _values, result)
                      result = s(:self)
                    
    result
end

#_reduce_441(val, _values, result) ⇒ Object 



5056
5057
5058
5059
5060
 
# File 'opal/lib/opal/parser/grammar.rb', line 5056

def _reduce_441(val, _values, result)
                      result = s(:true)
                    
    result
end

#_reduce_442(val, _values, result) ⇒ Object 



5062
5063
5064
5065
5066
 
# File 'opal/lib/opal/parser/grammar.rb', line 5062

def _reduce_442(val, _values, result)
                      result = s(:false)
                    
    result
end

#_reduce_443(val, _values, result) ⇒ Object 



5068
5069
5070
5071
5072
 
# File 'opal/lib/opal/parser/grammar.rb', line 5068

def _reduce_443(val, _values, result)
                      result = s(:str, self.file)
                    
    result
end

#_reduce_444(val, _values, result) ⇒ Object 



5074
5075
5076
5077
5078
 
# File 'opal/lib/opal/parser/grammar.rb', line 5074

def _reduce_444(val, _values, result)
                      result = s(:int, lexer.line)
                    
    result
end

#_reduce_445(val, _values, result) ⇒ Object 



5080
5081
5082
5083
5084
 
# File 'opal/lib/opal/parser/grammar.rb', line 5080

def _reduce_445(val, _values, result)
                      result = new_var_ref val[0]
                    
    result
end

#_reduce_446(val, _values, result) ⇒ Object 



5086
5087
5088
5089
5090
 
# File 'opal/lib/opal/parser/grammar.rb', line 5086

def _reduce_446(val, _values, result)
                      result = new_assignable val[0]
                    
    result
end

#_reduce_447(val, _values, result) ⇒ Object 



5092
5093
5094
5095
5096
 
# File 'opal/lib/opal/parser/grammar.rb', line 5092

def _reduce_447(val, _values, result)
                      result = s(:nth_ref, val[0])
                    
    result
end

#_reduce_449(val, _values, result) ⇒ Object

reduce 448 omitted



5100
5101
5102
5103
5104
 
# File 'opal/lib/opal/parser/grammar.rb', line 5100

def _reduce_449(val, _values, result)
                      result = nil
                    
    result
end

#_reduce_450(val, _values, result) ⇒ Object 



5106
5107
5108
5109
5110
 
# File 'opal/lib/opal/parser/grammar.rb', line 5106

def _reduce_450(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_451(val, _values, result) ⇒ Object 



5112
5113
5114
5115
5116
 
# File 'opal/lib/opal/parser/grammar.rb', line 5112

def _reduce_451(val, _values, result)
                      result = nil
                    
    result
end

#_reduce_452(val, _values, result) ⇒ Object 



5118
5119
5120
5121
5122
5123
 
# File 'opal/lib/opal/parser/grammar.rb', line 5118

def _reduce_452(val, _values, result)
                      result = val[1]
                      lexer.lex_state = :expr_beg
                    
    result
end

#_reduce_453(val, _values, result) ⇒ Object 



5125
5126
5127
5128
5129
 
# File 'opal/lib/opal/parser/grammar.rb', line 5125

def _reduce_453(val, _values, result)
                      result = val[0]
                    
    result
end

#_reduce_454(val, _values, result) ⇒ Object 



5131
5132
5133
5134
5135
 
# File 'opal/lib/opal/parser/grammar.rb', line 5131

def _reduce_454(val, _values, result)
                      result = new_args val[0], val[2], val[4], val[5]
                    
    result
end

#_reduce_455(val, _values, result) ⇒ Object 



5137
5138
5139
5140
5141
 
# File 'opal/lib/opal/parser/grammar.rb', line 5137

def _reduce_455(val, _values, result)
                      result = new_args val[0], val[2], nil, val[3]
                    
    result
end

#_reduce_456(val, _values, result) ⇒ Object 



5143
5144
5145
5146
5147
 
# File 'opal/lib/opal/parser/grammar.rb', line 5143

def _reduce_456(val, _values, result)
                      result = new_args val[0], nil, val[2], val[3]
                    
    result
end

#_reduce_457(val, _values, result) ⇒ Object 



5149
5150
5151
5152
5153
 
# File 'opal/lib/opal/parser/grammar.rb', line 5149

def _reduce_457(val, _values, result)
                      result = new_args val[0], nil, nil, val[1]
                    
    result
end

#_reduce_458(val, _values, result) ⇒ Object 



5155
5156
5157
5158
5159
 
# File 'opal/lib/opal/parser/grammar.rb', line 5155

def _reduce_458(val, _values, result)
                      result = new_args nil, val[0], val[2], val[3]
                    
    result
end

#_reduce_459(val, _values, result) ⇒ Object 



5161
5162
5163
5164
5165
 
# File 'opal/lib/opal/parser/grammar.rb', line 5161

def _reduce_459(val, _values, result)
                      result = new_args nil, val[0], nil, val[1]
                    
    result
end

#_reduce_46(val, _values, result) ⇒ Object

reduce 45 omitted



3224
3225
3226
3227
3228
3229
3230
 
# File 'opal/lib/opal/parser/grammar.rb', line 3224

def _reduce_46(val, _values, result)
                      args = val[1]
                      args = args[1] if args.size == 2
                      result = s(:return, args)
                    
    result
end

#_reduce_460(val, _values, result) ⇒ Object 



5167
5168
5169
5170
5171
 
# File 'opal/lib/opal/parser/grammar.rb', line 5167

def _reduce_460(val, _values, result)
                      result = new_args nil, nil, val[0], val[1]
                    
    result
end

#_reduce_461(val, _values, result) ⇒ Object 



5173
5174
5175
5176
5177
 
# File 'opal/lib/opal/parser/grammar.rb', line 5173

def _reduce_461(val, _values, result)
                      result = new_args nil, nil, nil, val[0]
                    
    result
end

#_reduce_462(val, _values, result) ⇒ Object 



5179
5180
5181
5182
5183
 
# File 'opal/lib/opal/parser/grammar.rb', line 5179

def _reduce_462(val, _values, result)
                      result = s(:args)
                    
    result
end

#_reduce_464(val, _values, result) ⇒ Object

reduce 463 omitted



5187
5188
5189
5190
5191
5192
 
# File 'opal/lib/opal/parser/grammar.rb', line 5187

def _reduce_464(val, _values, result)
                      result = val[0].intern
                      scope.add_local result
                    
    result
end

#_reduce_465(val, _values, result) ⇒ Object 



5194
5195
5196
5197
5198
 
# File 'opal/lib/opal/parser/grammar.rb', line 5194

def _reduce_465(val, _values, result)
                      raise 'formal argument cannot be a constant'
                    
    result
end

#_reduce_466(val, _values, result) ⇒ Object 



5200
5201
5202
5203
5204
 
# File 'opal/lib/opal/parser/grammar.rb', line 5200

def _reduce_466(val, _values, result)
                      raise 'formal argument cannot be an instance variable'
                    
    result
end

#_reduce_467(val, _values, result) ⇒ Object 



5206
5207
5208
5209
5210
 
# File 'opal/lib/opal/parser/grammar.rb', line 5206

def _reduce_467(val, _values, result)
                      raise 'formal argument cannot be a class variable'
                    
    result
end

#_reduce_468(val, _values, result) ⇒ Object 



5212
5213
5214
5215
5216
 
# File 'opal/lib/opal/parser/grammar.rb', line 5212

def _reduce_468(val, _values, result)
                      raise 'formal argument cannot be a global variable'
                    
    result
end

#_reduce_469(val, _values, result) ⇒ Object 



5218
5219
5220
5221
5222
 
# File 'opal/lib/opal/parser/grammar.rb', line 5218

def _reduce_469(val, _values, result)
                      result = val[0]
                    
    result
end

#_reduce_47(val, _values, result) ⇒ Object 



3232
3233
3234
3235
3236
3237
3238
 
# File 'opal/lib/opal/parser/grammar.rb', line 3232

def _reduce_47(val, _values, result)
                      args = val[1]
                      args = args[1] if args.size == 2
                      result = s(:break, args)
                    
    result
end

#_reduce_470(val, _values, result) ⇒ Object 



5224
5225
5226
5227
5228
 
# File 'opal/lib/opal/parser/grammar.rb', line 5224

def _reduce_470(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_471(val, _values, result) ⇒ Object 



5230
5231
5232
5233
5234
 
# File 'opal/lib/opal/parser/grammar.rb', line 5230

def _reduce_471(val, _values, result)
                      result = s(:lasgn, val[0])
                    
    result
end

#_reduce_473(val, _values, result) ⇒ Object

reduce 472 omitted



5238
5239
5240
5241
5242
 
# File 'opal/lib/opal/parser/grammar.rb', line 5238

def _reduce_473(val, _values, result)
                      result = s(:array, val[0])
                    
    result
end

#_reduce_474(val, _values, result) ⇒ Object 



5244
5245
5246
5247
5248
5249
 
# File 'opal/lib/opal/parser/grammar.rb', line 5244

def _reduce_474(val, _values, result)
                      val[0] << val[2]
                      result = val[0]
                    
    result
end

#_reduce_48(val, _values, result) ⇒ Object 



3240
3241
3242
3243
3244
3245
3246
 
# File 'opal/lib/opal/parser/grammar.rb', line 3240

def _reduce_48(val, _values, result)
                      args = val[1]
                      args = args[1] if args.size == 2
                      result = s(:next, args)
                    
    result
end

#_reduce_480(val, _values, result) ⇒ Object

reduce 479 omitted



5261
5262
5263
5264
5265
 
# File 'opal/lib/opal/parser/grammar.rb', line 5261

def _reduce_480(val, _values, result)
                      result = [val[0]]
                    
    result
end

#_reduce_481(val, _values, result) ⇒ Object 



5267
5268
5269
5270
5271
5272
 
# File 'opal/lib/opal/parser/grammar.rb', line 5267

def _reduce_481(val, _values, result)
                      val[0] << val[2]
                      result = val[0]
                    
    result
end

#_reduce_482(val, _values, result) ⇒ Object 



5274
5275
5276
5277
5278
 
# File 'opal/lib/opal/parser/grammar.rb', line 5274

def _reduce_482(val, _values, result)
                      result = new_assign new_assignable(s(:identifier, val[0].intern)), val[2]
                    
    result
end

#_reduce_483(val, _values, result) ⇒ Object 



5280
5281
5282
5283
5284
 
# File 'opal/lib/opal/parser/grammar.rb', line 5280

def _reduce_483(val, _values, result)
                      result = s(:block, val[0])
                    
    result
end

#_reduce_484(val, _values, result) ⇒ Object 



5286
5287
5288
5289
5290
5291
 
# File 'opal/lib/opal/parser/grammar.rb', line 5286

def _reduce_484(val, _values, result)
                      result = val[0]
                      val[0] << val[2]
                    
    result
end

#_reduce_487(val, _values, result) ⇒ Object

reduce 486 omitted



5297
5298
5299
5300
5301
 
# File 'opal/lib/opal/parser/grammar.rb', line 5297

def _reduce_487(val, _values, result)
                      result = "*#{val[1]}".intern
                    
    result
end

#_reduce_488(val, _values, result) ⇒ Object 



5303
5304
5305
5306
5307
 
# File 'opal/lib/opal/parser/grammar.rb', line 5303

def _reduce_488(val, _values, result)
                      result = :*"
                    
    result
end

#_reduce_491(val, _values, result) ⇒ Object

reduce 490 omitted



5313
5314
5315
5316
5317
 
# File 'opal/lib/opal/parser/grammar.rb', line 5313

def _reduce_491(val, _values, result)
                      result = "&#{val[1]}".intern
                    
    result
end

#_reduce_492(val, _values, result) ⇒ Object 



5319
5320
5321
5322
5323
 
# File 'opal/lib/opal/parser/grammar.rb', line 5319

def _reduce_492(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_493(val, _values, result) ⇒ Object 



5325
5326
5327
5328
5329
 
# File 'opal/lib/opal/parser/grammar.rb', line 5325

def _reduce_493(val, _values, result)
                      result = nil
                    
    result
end

#_reduce_494(val, _values, result) ⇒ Object 



5331
5332
5333
5334
5335
 
# File 'opal/lib/opal/parser/grammar.rb', line 5331

def _reduce_494(val, _values, result)
                      result = val[0]
                    
    result
end

#_reduce_495(val, _values, result) ⇒ Object 



5337
5338
5339
5340
5341
 
# File 'opal/lib/opal/parser/grammar.rb', line 5337

def _reduce_495(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_496(val, _values, result) ⇒ Object 



5343
5344
5345
5346
5347
 
# File 'opal/lib/opal/parser/grammar.rb', line 5343

def _reduce_496(val, _values, result)
                      result = []
                    
    result
end

#_reduce_497(val, _values, result) ⇒ Object 



5349
5350
5351
5352
5353
 
# File 'opal/lib/opal/parser/grammar.rb', line 5349

def _reduce_497(val, _values, result)
                      result = val[0]
                    
    result
end

#_reduce_498(val, _values, result) ⇒ Object 



5355
5356
5357
5358
5359
 
# File 'opal/lib/opal/parser/grammar.rb', line 5355

def _reduce_498(val, _values, result)
                      result = val[0]
                    
    result
end

#_reduce_499(val, _values, result) ⇒ Object 



5361
5362
5363
5364
5365
 
# File 'opal/lib/opal/parser/grammar.rb', line 5361

def _reduce_499(val, _values, result)
                      result = val[0].push *val[2]
                    
    result
end

#_reduce_5(val, _values, result) ⇒ Object 



3019
3020
3021
3022
3023
3024
 
# File 'opal/lib/opal/parser/grammar.rb', line 3019

def _reduce_5(val, _values, result)
                      val[0] << val[2]
                      result = val[0]
                    
    result
end

#_reduce_500(val, _values, result) ⇒ Object 



5367
5368
5369
5370
5371
 
# File 'opal/lib/opal/parser/grammar.rb', line 5367

def _reduce_500(val, _values, result)
                      result = [val[0], val[2]]
                    
    result
end

#_reduce_501(val, _values, result) ⇒ Object 



5373
5374
5375
5376
5377
 
# File 'opal/lib/opal/parser/grammar.rb', line 5373

def _reduce_501(val, _values, result)
                      result = [s(:sym, val[0].intern), val[1]]
                    
    result
end

#_reduce_525(val, _values, result) ⇒ Object

reduce 524 omitted



5425
5426
5427
5428
5429
 
# File 'opal/lib/opal/parser/grammar.rb', line 5425

def _reduce_525(val, _values, result)
                      result = nil
                    
    result
end

#_reduce_53(val, _values, result) ⇒ Object

reduce 52 omitted



3256
3257
3258
3259
3260
 
# File 'opal/lib/opal/parser/grammar.rb', line 3256

def _reduce_53(val, _values, result)
                      result = new_call nil, val[0].intern, val[1]
                    
    result
end

#_reduce_55(val, _values, result) ⇒ Object

reduce 54 omitted



3264
3265
3266
3267
3268
 
# File 'opal/lib/opal/parser/grammar.rb', line 3264

def _reduce_55(val, _values, result)
                      result = new_call val[0], val[2].intern, val[3]
                    
    result
end

#_reduce_57(val, _values, result) ⇒ Object

reduce 56 omitted



3272
3273
3274
3275
3276
 
# File 'opal/lib/opal/parser/grammar.rb', line 3272

def _reduce_57(val, _values, result)
                    result = new_call val[0], val[2].intern, val[3]
                  
    result
end

#_reduce_59(val, _values, result) ⇒ Object

reduce 58 omitted



3280
3281
3282
3283
3284
 
# File 'opal/lib/opal/parser/grammar.rb', line 3280

def _reduce_59(val, _values, result)
                      result = new_super val[1]
                    
    result
end

#_reduce_60(val, _values, result) ⇒ Object 



3286
3287
3288
3289
3290
 
# File 'opal/lib/opal/parser/grammar.rb', line 3286

def _reduce_60(val, _values, result)
                      result = new_yield val[1]
                    
    result
end

#_reduce_61(val, _values, result) ⇒ Object 



3292
3293
3294
3295
3296
 
# File 'opal/lib/opal/parser/grammar.rb', line 3292

def _reduce_61(val, _values, result)
                      result = val[0]
                    
    result
end

#_reduce_62(val, _values, result) ⇒ Object 



3298
3299
3300
3301
3302
 
# File 'opal/lib/opal/parser/grammar.rb', line 3298

def _reduce_62(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_63(val, _values, result) ⇒ Object 



3304
3305
3306
3307
3308
 
# File 'opal/lib/opal/parser/grammar.rb', line 3304

def _reduce_63(val, _values, result)
                      result = val[0]
                    
    result
end

#_reduce_64(val, _values, result) ⇒ Object 



3310
3311
3312
3313
3314
 
# File 'opal/lib/opal/parser/grammar.rb', line 3310

def _reduce_64(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_65(val, _values, result) ⇒ Object 



3316
3317
3318
3319
3320
 
# File 'opal/lib/opal/parser/grammar.rb', line 3316

def _reduce_65(val, _values, result)
                      result = val[0]
                    
    result
end

#_reduce_66(val, _values, result) ⇒ Object 



3322
3323
3324
3325
3326
 
# File 'opal/lib/opal/parser/grammar.rb', line 3322

def _reduce_66(val, _values, result)
                      result = val[0] << val[1]
                    
    result
end

#_reduce_67(val, _values, result) ⇒ Object 



3328
3329
3330
3331
3332
 
# File 'opal/lib/opal/parser/grammar.rb', line 3328

def _reduce_67(val, _values, result)
                      result = val[0] << s(:splat, val[2])
                    
    result
end

#_reduce_69(val, _values, result) ⇒ Object

reduce 68 omitted



3336
3337
3338
3339
3340
 
# File 'opal/lib/opal/parser/grammar.rb', line 3336

def _reduce_69(val, _values, result)
                      result = val[0] << s(:splat)
                    
    result
end

#_reduce_7(val, _values, result) ⇒ Object

reduce 6 omitted



3028
3029
3030
3031
3032
 
# File 'opal/lib/opal/parser/grammar.rb', line 3028

def _reduce_7(val, _values, result)
                      result = val[2]
                    
    result
end

#_reduce_71(val, _values, result) ⇒ Object

reduce 70 omitted



3344
3345
3346
3347
3348
 
# File 'opal/lib/opal/parser/grammar.rb', line 3344

def _reduce_71(val, _values, result)
                      result = s(:array, s(:splat, val[1]))
                    
    result
end

#_reduce_72(val, _values, result) ⇒ Object 



3350
3351
3352
3353
3354
 
# File 'opal/lib/opal/parser/grammar.rb', line 3350

def _reduce_72(val, _values, result)
                      result = s(:array, s(:splat))
                    
    result
end

#_reduce_74(val, _values, result) ⇒ Object

reduce 73 omitted



3358
3359
3360
3361
3362
 
# File 'opal/lib/opal/parser/grammar.rb', line 3358

def _reduce_74(val, _values, result)
                      result = val[0]
                    
    result
end

#_reduce_75(val, _values, result) ⇒ Object 



3364
3365
3366
3367
3368
 
# File 'opal/lib/opal/parser/grammar.rb', line 3364

def _reduce_75(val, _values, result)
                      result = val[1]
                    
    result
end

#_reduce_76(val, _values, result) ⇒ Object 



3370
3371
3372
3373
3374
 
# File 'opal/lib/opal/parser/grammar.rb', line 3370

def _reduce_76(val, _values, result)
                      result = s(:array, val[0])
                    
    result
end

#_reduce_77(val, _values, result) ⇒ Object 



3376
3377
3378
3379
3380
 
# File 'opal/lib/opal/parser/grammar.rb', line 3376

def _reduce_77(val, _values, result)
                      result = val[0] << val[1]
                    
    result
end

#_reduce_8(val, _values, result) ⇒ Object 



3034
3035
3036
3037
3038
 
# File 'opal/lib/opal/parser/grammar.rb', line 3034

def _reduce_8(val, _values, result)
                      result = new_body val[0], val[1], val[2], val[3]
                    
    result
end

#_reduce_80(val, _values, result) ⇒ Object

reduce 79 omitted



3386
3387
3388
3389
3390
 
# File 'opal/lib/opal/parser/grammar.rb', line 3386

def _reduce_80(val, _values, result)
                      result = new_assignable val[0]
                    
    result
end

#_reduce_81(val, _values, result) ⇒ Object 



3392
3393
3394
3395
3396
3397
3398
 
# File 'opal/lib/opal/parser/grammar.rb', line 3392

def _reduce_81(val, _values, result)
                      args = val[2]
                      args.type = :arglist if args.type == :array
                      result = s(:attrasgn, val[0], :[]=, args)
                    
    result
end

#_reduce_82(val, _values, result) ⇒ Object 



3400
3401
3402
3403
3404
 
# File 'opal/lib/opal/parser/grammar.rb', line 3400

def _reduce_82(val, _values, result)
                      result = new_call val[0], val[2].intern, s(:arglist)
                    
    result
end

#_reduce_88(val, _values, result) ⇒ Object

reduce 87 omitted



3416
3417
3418
3419
3420
 
# File 'opal/lib/opal/parser/grammar.rb', line 3416

def _reduce_88(val, _values, result)
                      result = new_assignable val[0]
                    
    result
end

#_reduce_89(val, _values, result) ⇒ Object 



3422
3423
3424
3425
3426
3427
3428
 
# File 'opal/lib/opal/parser/grammar.rb', line 3422

def _reduce_89(val, _values, result)
                      args = val[2]
                      args.type = :arglist if args.type == :array
                      result = s(:attrasgn, val[0], :[]=, args)
                    
    result
end

#_reduce_9(val, _values, result) ⇒ Object 



3040
3041
3042
3043
3044
3045
3046
3047
3048
3049
3050
 
# File 'opal/lib/opal/parser/grammar.rb', line 3040

def _reduce_9(val, _values, result)
                      comp = new_compstmt val[0]
                      if comp and comp.type == :begin and comp.size == 2
                        result = comp[1]
                        result.line = comp.line
                      else
                        result = comp
                      end
                    
    result
end

#_reduce_90(val, _values, result) ⇒ Object 



3430
3431
3432
3433
3434
 
# File 'opal/lib/opal/parser/grammar.rb', line 3430

def _reduce_90(val, _values, result)
                      result = s(:attrasgn, val[0], "#{val[2]}=".intern, s(:arglist))
                    
    result
end

#_reduce_91(val, _values, result) ⇒ Object 



3436
3437
3438
3439
3440
 
# File 'opal/lib/opal/parser/grammar.rb', line 3436

def _reduce_91(val, _values, result)
                      result = s(:attrasgn, val[0], "#{val[2]}=".intern, s(:arglist))
                    
    result
end

#_reduce_92(val, _values, result) ⇒ Object 



3442
3443
3444
3445
3446
 
# File 'opal/lib/opal/parser/grammar.rb', line 3442

def _reduce_92(val, _values, result)
                      result = s(:attrasgn, val[0], "#{val[2]}=".intern, s(:arglist))
                    
    result
end

#_reduce_93(val, _values, result) ⇒ Object 



3448
3449
3450
3451
3452
 
# File 'opal/lib/opal/parser/grammar.rb', line 3448

def _reduce_93(val, _values, result)
                      result = s(:colon2, val[0], val[2].intern)
                    
    result
end

#_reduce_94(val, _values, result) ⇒ Object 



3454
3455
3456
3457
3458
 
# File 'opal/lib/opal/parser/grammar.rb', line 3454

def _reduce_94(val, _values, result)
                      result = s(:colon3, val[1].intern)
                    
    result
end

#_reduce_97(val, _values, result) ⇒ Object

reduce 96 omitted



3464
3465
3466
3467
3468
 
# File 'opal/lib/opal/parser/grammar.rb', line 3464

def _reduce_97(val, _values, result)
                      result = s(:colon3, val[1].intern)
                    
    result
end

#_reduce_98(val, _values, result) ⇒ Object 



3470
3471
3472
3473
3474
 
# File 'opal/lib/opal/parser/grammar.rb', line 3470

def _reduce_98(val, _values, result)
                      result = val[0].intern
                    
    result
end

#_reduce_99(val, _values, result) ⇒ Object 



3476
3477
3478
3479
3480
 
# File 'opal/lib/opal/parser/grammar.rb', line 3476

def _reduce_99(val, _values, result)
                      result = s(:colon2, val[0], val[2].intern)
                    
    result
end

#_reduce_none(val, _values, result) ⇒ Object 



5431
5432
5433
 
# File 'opal/lib/opal/parser/grammar.rb', line 5431

def _reduce_none(val, _values, result)
  val[0]
end

#add_block_pass(arglist, block) ⇒ Object 



217
218
219
220
 
# File 'opal/lib/opal/parser.rb', line 217

def add_block_pass(arglist, block)
  arglist << block if block
  arglist
end

#new_args(norm, opt, rest, block) ⇒ Object 



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'opal/lib/opal/parser.rb', line 120

def new_args(norm, opt, rest, block)
  res = s(:args)

  if norm
    norm.each do |arg|
      scope.add_local arg
      res << arg
    end
  end

  if opt
    opt[1..-1].each do |_opt|
      res << _opt[1]
    end
  end

  if rest
    res << rest
    rest_str = rest.to_s[1..-1]
    scope.add_local rest_str.to_sym unless rest_str.empty?
  end

  if block
    res << block
    scope.add_local block.to_s[1..-1].to_sym
  end

  res << opt if opt

  res
end

#new_assign(lhs, rhs) ⇒ Object 



240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
 
# File 'opal/lib/opal/parser.rb', line 240

def new_assign(lhs, rhs)
  case lhs.type
  when :iasgn, :cdecl, :lasgn, :gasgn, :cvdecl, :nth_ref
    lhs << rhs
    lhs
  when :call, :attrasgn
    lhs.last << rhs
    lhs
  when :colon2
    lhs << rhs
    lhs.type = :casgn
    lhs
  when :colon3
    lhs << rhs
    lhs.type = :casgn3
    lhs
  else
    raise "Bad lhs for new_assign: #{lhs.type}"
  end
end

#new_assignable(ref) ⇒ Object 



261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
 
# File 'opal/lib/opal/parser.rb', line 261

def new_assignable(ref)
  case ref.type
  when :ivar
    ref.type = :iasgn
  when :const
    ref.type = :cdecl
  when :identifier
    scope.add_local ref[1] unless scope.has_local? ref[1]
    ref.type = :lasgn
  when :gvar
    ref.type = :gasgn
  when :cvar
    ref.type = :cvdecl
  else
    raise "Bad new_assignable type: #{ref.type}"
  end

  ref
end

#new_block(stmt = nil) ⇒ Object 



54
55
56
57
58
 
# File 'opal/lib/opal/parser.rb', line 54

def new_block(stmt = nil)
  s = s(:block)
  s << stmt if stmt
  s
end

#new_block_args(norm, opt, rest, block) ⇒ Object 



152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
 
# File 'opal/lib/opal/parser.rb', line 152

def new_block_args(norm, opt, rest, block)
  res = s(:array)

  if norm
    norm.each do |arg|
      if arg.is_a? Symbol
        scope.add_local arg
        res << s(:lasgn, arg)
      else
        res << arg
      end
    end
  end

  if opt
    opt[1..-1].each do |_opt|
      res << s(:lasgn, _opt[1])
    end
  end

  if rest
    r = rest.to_s[1..-1].to_sym
    res << s(:splat, s(:lasgn, r))
    scope.add_local r
  end

  if block
    b = block.to_s[1..-1].to_sym
    res << s(:block_pass, s(:lasgn, b))
    scope.add_local b
  end

  res << opt if opt

  args = res.size == 2 && norm ? res[1] : s(:masgn, res)

  if args.type == :array
    s(:masgn, args)
  else
    args
  end
end

#new_body(compstmt, res, els, ens) ⇒ Object 



71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'opal/lib/opal/parser.rb', line 71

def new_body(compstmt, res, els, ens)
  s = compstmt || s(:block)
  s.line = compstmt.line if compstmt

  if res
    s = s(:rescue, s)
    res.each { |r| s << r }
    s << els if els
  end

  ens ? s(:ensure, s, ens) : s
end

#new_call(recv, meth, args = nil) ⇒ Object 



195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
 
# File 'opal/lib/opal/parser.rb', line 195

def new_call(recv, meth, args = nil)
  call = s(:call, recv, meth)
  args = s(:arglist) unless args
  args.type = :arglist if args.type == :array
  call << args

  if recv
    call.line = recv.line
  elsif args[1]
    call.line = args[1].line
  end

  # fix arglist spilling over into next line if no args
  if args.length == 1
    args.line = call.line
  else
    args.line = args[1].line
  end

  call
end

#new_class(path, sup, body) ⇒ Object 



94
95
96
 
# File 'opal/lib/opal/parser.rb', line 94

def new_class(path, sup, body)
  s(:class, path, sup, body)
end

#new_compstmt(block) ⇒ Object 



60
61
62
63
64
65
66
67
68
69
 
# File 'opal/lib/opal/parser.rb', line 60

def new_compstmt(block)
  if block.size == 1
    nil
  elsif block.size == 2
    block[1]
  else
    block.line = block[1].line
    block
  end
end

#new_def(line, recv, name, args, body) ⇒ Object 



84
85
86
87
88
89
90
91
92
 
# File 'opal/lib/opal/parser.rb', line 84

def new_def(line, recv, name, args, body)
  body = s(:block, body) if body.type != :block
  body << s(:nil) if body.size == 1
  args.line = line
  s = s(:def, recv, name.to_sym, args, body)
  s.line = line
  s.end_line = @lexer.line
  s
end

#new_dsym(str) ⇒ Object 



350
351
352
353
354
355
356
357
358
359
360
361
 
# File 'opal/lib/opal/parser.rb', line 350

def new_dsym(str)
  return s(:nil) unless str
  case str.type
  when :str
    str.type = :sym
    str[1] = str[1].to_sym
  when :dstr
    str.type = :dsym
  end

  str
end

#new_gettable(ref) ⇒ Object 



281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
 
# File 'opal/lib/opal/parser.rb', line 281

def new_gettable(ref)
  res = case ref.type
        when :lasgn
          s(:lvar, ref[1])
        when :iasgn
          s(:ivar, ref[1])
        when :gasgn
          s(:gvar, ref[1])
        when :cvdecl
          s(:cvar, ref[1])
        else
          raise "Bad new_gettable ref: #{ref.type}"
        end

  res.line = ref.line
  res
end

#new_if(expr, stmt, tail) ⇒ Object 



113
114
115
116
117
118
 
# File 'opal/lib/opal/parser.rb', line 113

def new_if(expr, stmt, tail)
  s = s(:if, expr, stmt, tail)
  s.line = expr.line
  s.end_line = @lexer.line
  s
end

#new_iter(args, body) ⇒ Object 



106
107
108
109
110
111
 
# File 'opal/lib/opal/parser.rb', line 106

def new_iter(args, body)
  s = s(:iter, args)
  s << body if body
  s.end_line = @lexer.line
  s
end

#new_module(path, body) ⇒ Object 



102
103
104
 
# File 'opal/lib/opal/parser.rb', line 102

def new_module(path, body)
  s(:module, path, body)
end

#new_op_asgn(op, lhs, rhs) ⇒ Object 



222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
 
# File 'opal/lib/opal/parser.rb', line 222

def new_op_asgn(op, lhs, rhs)
  case op
  when :||"
    result = s(:op_asgn_or, new_gettable(lhs))
    result << (lhs << rhs)
  when :&&"
    result = s(:op_asgn_and, new_gettable(lhs))
    result << (lhs << rhs)
  else
    result = lhs
    result << new_call(new_gettable(lhs), op, s(:arglist, rhs))

  end

  result.line = lhs.line
  result
end

#new_regexp(reg, ending) ⇒ Object 



381
382
383
384
385
386
387
388
389
390
391
392
 
# File 'opal/lib/opal/parser.rb', line 381

def new_regexp(reg, ending)
  return s(:regexp, //) unless reg
  case reg.type
  when :str
    s(:regexp, Regexp.new(reg[1], ending))
  when :evstr
    s(:dregx, "", reg)
  when :dstr
    reg.type = :dregx
    reg
  end
end

#new_sclass(expr, body) ⇒ Object 



98
99
100
 
# File 'opal/lib/opal/parser.rb', line 98

def new_sclass(expr, body)
  s(:sclass, expr, body)
end

#new_str(str) ⇒ Object 



363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
 
# File 'opal/lib/opal/parser.rb', line 363

def new_str(str)
  # cover empty strings
  return s(:str, "") unless str
  # catch s(:str, "", other_str)
  if str.size == 3 and str[1] == "" and str.type == :str
    return str[2]
  # catch s(:str, "content", more_content)
  elsif str.type == :str && str.size > 3
    str.type = :dstr
    str
  # top level evstr should be a dstr
  elsif str.type == :evstr
    s(:dstr, "", str)
  else
    str
  end
end

#new_super(args) ⇒ Object 



324
325
326
327
328
329
330
331
332
 
# File 'opal/lib/opal/parser.rb', line 324

def new_super(args)
  args = (args || s(:arglist))

  if args.type == :array
    args.type = :arglist
  end

  s(:super, args)
end

#new_var_ref(ref) ⇒ Object 



299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
 
# File 'opal/lib/opal/parser.rb', line 299

def new_var_ref(ref)
  case ref.type
  when :self, :nil, :true, :false, :line, :file
    ref
  when :const
    ref
  when :ivar, :gvar, :cvar
    ref
  when :int
    # this is when we passed __LINE__ which is converted into :int
    ref
  when :str
    # returns for __FILE__ as it is converted into str
    ref
  when :identifier
    if scope.has_local? ref[1]
      s(:lvar, ref[1])
    else
      s(:call, nil, ref[1], s(:arglist))
    end
  else
    raise "Bad var_ref type: #{ref.type}"
  end
end

#new_xstr(str) ⇒ Object 



339
340
341
342
343
344
345
346
347
348
 
# File 'opal/lib/opal/parser.rb', line 339

def new_xstr(str)
  return s(:xstr, '') unless str
  case str.type
  when :str   then str.type = :xstr
  when :dstr  then str.type = :dxstr
  when :evstr then str = s(:dxstr, '', str)
  end

  str
end

#new_yield(args) ⇒ Object 



334
335
336
337
 
# File 'opal/lib/opal/parser.rb', line 334

def new_yield(args)
  args = (args || s(:arglist))[1..-1]
  s(:yield, *args)
end

#next_token ⇒ Object 



27
28
29
 
# File 'opal/lib/opal/parser.rb', line 27

def next_token
  @lexer.next_token
end

#on_error(t, val, vstack) ⇒ Object 



50
51
52
 
# File 'opal/lib/opal/parser.rb', line 50

def on_error(t, val, vstack)
  raise "parse error on value #{val.inspect} (#{token_to_str(t) || '?'}) :#{@file}:#{lexer.line}"
end

#parse(source, file = '(string)') ⇒ Object 



11
12
13
14
15
16
17
 
# File 'opal/lib/opal/parser.rb', line 11

def parse(source, file = '(string)')
  @lexer = Lexer.new(source, file)
  @file = file
  @scopes = []

  self.parse_to_sexp
end

#parse_to_sexp ⇒ Object 



19
20
21
22
23
24
25
 
# File 'opal/lib/opal/parser.rb', line 19

def parse_to_sexp
  push_scope
  result = do_parse
  pop_scope

  result
end

#pop_scope ⇒ Object 



45
46
47
48
 
# File 'opal/lib/opal/parser.rb', line 45

def pop_scope
  @scopes.pop
  @scope = @scopes.last
end

#push_scope(type = nil) ⇒ Object 



37
38
39
40
41
42
43
 
# File 'opal/lib/opal/parser.rb', line 37

def push_scope(type = nil)
  top = @scopes.last
  scope = ParserScope.new type
  scope.parent = top
  @scopes << scope
  @scope = scope
end

#s(*parts) ⇒ Object 



31
32
33
34
35
 
# File 'opal/lib/opal/parser.rb', line 31

def s(*parts)
  sexp = Sexp.new(parts)
  sexp.line = @lexer.line
  sexp
end

#str_append(str, str2) ⇒ Object 



394
395
396
397
398
399
400
401
402
403
404
405
406
407
 
# File 'opal/lib/opal/parser.rb', line 394

def str_append(str, str2)
  return str2 unless str
  return str unless str2

  if str.type == :evstr
    str = s(:dstr, "", str)
  elsif str.type == :str
    str = s(:dstr, str[1])
  else
    #puts str.type
  end
  str << str2
  str
end