Class: Opal::Parser

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

Overview

Parser is used to parse a string of ruby code into a tree of Sexp to represent the given ruby source code. The Compiler used this tree of sexp expressions, and turns them into the resulting javascript code.

Usually, you would want to use Compiler directly, but this class can be useful for debugging the compiler, as well as building tools around the opal compiler to view the code structure.

Invalid ruby code will raise an exception.

Opal::Parser.new.parse "ruby code"
# => sexp tree

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",
"tDSTAR",
"tEQL",
"tLOWEST",
"\"-@NUM\"",
"\"+@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",
"for_var",
"superclass",
"term",
"f_arglist",
"singleton",
"dot_or_colon",
"@3",
"@4",
"@5",
"@6",
"@7",
"@8",
"@9",
"@10",
"@11",
"@12",
"@13",
"@14",
"@15",
"@16",
"@17",
"f_larglist",
"lambda_body",
"block_param",
"f_block_optarg",
"f_block_opt",
"block_args_tail",
"f_block_arg",
"opt_block_args_tail",
"f_arg",
"f_rest_arg",
"do_block",
"@18",
"operation3",
"@19",
"@20",
"cases",
"@21",
"exc_list",
"exc_var",
"numeric",
"dsym",
"string",
"string1",
"string_contents",
"xstring_contents",
"word_list",
"word",
"string_content",
"qword_list",
"string_dvar",
"@22",
"@23",
"sym",
"f_args",
"kwrest_mark",
"f_kwrest",
"f_label",
"f_kw",
"f_kwarg",
"args_tail",
"opt_f_block_arg",
"opt_args_tail",
"f_optarg",
"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



22
23
24
 
# File 'opal/lib/opal/parser.rb', line 22

def file
  @file
end

#lexer ⇒ Object (readonly)

Returns the value of attribute lexer



22
23
24
 
# File 'opal/lib/opal/parser.rb', line 22

def lexer
  @lexer
end

#scope ⇒ Object (readonly)

Returns the value of attribute scope



22
23
24
 
# File 'opal/lib/opal/parser.rb', line 22

def scope
  @scope
end

Instance Method Details

#_reduce_10(val, _values, result) ⇒ Object 



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

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

#_reduce_103(val, _values, result) ⇒ Object

reduce 102 omitted



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

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

#_reduce_104(val, _values, result) ⇒ Object 



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

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

#_reduce_105(val, _values, result) ⇒ Object 



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

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

#_reduce_107(val, _values, result) ⇒ Object

reduce 106 omitted



3524
3525
3526
3527
3528
 
# File 'opal/lib/opal/parser/grammar.rb', line 3524

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

#_reduce_108(val, _values, result) ⇒ Object 



3530
3531
3532
3533
3534
 
# File 'opal/lib/opal/parser/grammar.rb', line 3530

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

#_reduce_11(val, _values, result) ⇒ Object 



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

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

#_reduce_12(val, _values, result) ⇒ Object 



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

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

#_reduce_13(val, _values, result) ⇒ Object 



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

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

#_reduce_14(val, _values, result) ⇒ Object 



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

def _reduce_14(val, _values, result)
                      result = new_alias(val[0], val[1], val[3])
                    
    result
end

#_reduce_15(val, _values, result) ⇒ Object 



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

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

#_reduce_17(val, _values, result) ⇒ Object

reduce 16 omitted



3117
3118
3119
3120
3121
 
# File 'opal/lib/opal/parser/grammar.rb', line 3117

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

#_reduce_18(val, _values, result) ⇒ Object 



3123
3124
3125
3126
3127
 
# File 'opal/lib/opal/parser/grammar.rb', line 3123

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

#_reduce_183(val, _values, result) ⇒ Object

reduce 182 omitted



3684
3685
3686
3687
3688
 
# File 'opal/lib/opal/parser/grammar.rb', line 3684

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

#_reduce_184(val, _values, result) ⇒ Object 



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

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

#_reduce_185(val, _values, result) ⇒ Object 



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

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

#_reduce_186(val, _values, result) ⇒ Object 



3702
3703
3704
3705
3706
 
# File 'opal/lib/opal/parser/grammar.rb', line 3702

def _reduce_186(val, _values, result)
                      result = new_op_asgn1(val[0], val[2], val[4], val[5])
                    
    result
end

#_reduce_187(val, _values, result) ⇒ Object 



3708
3709
3710
3711
3712
 
# File 'opal/lib/opal/parser/grammar.rb', line 3708

def _reduce_187(val, _values, result)
                      result = s(:op_asgn2, val[0], op_to_setter(val[2]), value(val[3]).to_sym, val[4])
                    
    result
end

#_reduce_19(val, _values, result) ⇒ Object 



3129
3130
3131
3132
3133
 
# File 'opal/lib/opal/parser/grammar.rb', line 3129

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

#_reduce_193(val, _values, result) ⇒ Object

reduce 192 omitted



3724
3725
3726
3727
3728
 
# File 'opal/lib/opal/parser/grammar.rb', line 3724

def _reduce_193(val, _values, result)
                      result = new_irange(val[0], val[1], val[2])
                    
    result
end

#_reduce_194(val, _values, result) ⇒ Object 



3730
3731
3732
3733
3734
 
# File 'opal/lib/opal/parser/grammar.rb', line 3730

def _reduce_194(val, _values, result)
                      result = new_erange(val[0], val[1], val[2])
                    
    result
end

#_reduce_195(val, _values, result) ⇒ Object 



3736
3737
3738
3739
3740
 
# File 'opal/lib/opal/parser/grammar.rb', line 3736

def _reduce_195(val, _values, result)
                      result = new_binary_call(val[0], val[1], val[2])
                    
    result
end

#_reduce_196(val, _values, result) ⇒ Object 



3742
3743
3744
3745
3746
 
# File 'opal/lib/opal/parser/grammar.rb', line 3742

def _reduce_196(val, _values, result)
                      result = new_binary_call(val[0], val[1], val[2])
                    
    result
end

#_reduce_197(val, _values, result) ⇒ Object 



3748
3749
3750
3751
3752
 
# File 'opal/lib/opal/parser/grammar.rb', line 3748

def _reduce_197(val, _values, result)
                      result = new_binary_call(val[0], val[1], val[2])
                    
    result
end

#_reduce_198(val, _values, result) ⇒ Object 



3754
3755
3756
3757
3758
 
# File 'opal/lib/opal/parser/grammar.rb', line 3754

def _reduce_198(val, _values, result)
                      result = new_binary_call(val[0], val[1], val[2])
                    
    result
end

#_reduce_199(val, _values, result) ⇒ Object 



3760
3761
3762
3763
3764
 
# File 'opal/lib/opal/parser/grammar.rb', line 3760

def _reduce_199(val, _values, result)
                      result = new_binary_call(val[0], val[1], val[2])
                    
    result
end

#_reduce_2(val, _values, result) ⇒ Object

reduce 1 omitted



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

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

#_reduce_20(val, _values, result) ⇒ Object 



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

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

#_reduce_200(val, _values, result) ⇒ Object 



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

def _reduce_200(val, _values, result)
                      result = new_binary_call(val[0], val[1], val[2])
                    
    result
end

#_reduce_201(val, _values, result) ⇒ Object 



3772
3773
3774
3775
3776
 
# File 'opal/lib/opal/parser/grammar.rb', line 3772

def _reduce_201(val, _values, result)
                      result = new_call new_binary_call(new_int(val[1]), val[2], val[3]), [:-@", []], []
                    
    result
end

#_reduce_202(val, _values, result) ⇒ Object 



3778
3779
3780
3781
3782
 
# File 'opal/lib/opal/parser/grammar.rb', line 3778

def _reduce_202(val, _values, result)
                      result = new_call new_binary_call(new_float(val[1]), val[2], val[3]), [:-@", []], []
                    
    result
end

#_reduce_203(val, _values, result) ⇒ Object 



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

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

#_reduce_204(val, _values, result) ⇒ Object 



3793
3794
3795
3796
3797
3798
3799
3800
3801
3802
3803
3804
 
# File 'opal/lib/opal/parser/grammar.rb', line 3793

def _reduce_204(val, _values, result)
                      result = new_call val[1], [:-@", []], []
                      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 



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

def _reduce_205(val, _values, result)
                      result = new_binary_call(val[0], val[1], val[2])
                    
    result
end

#_reduce_206(val, _values, result) ⇒ Object 



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

def _reduce_206(val, _values, result)
                      result = new_binary_call(val[0], val[1], val[2])
                    
    result
end

#_reduce_207(val, _values, result) ⇒ Object 



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

def _reduce_207(val, _values, result)
                      result = new_binary_call(val[0], val[1], val[2])
                    
    result
end

#_reduce_208(val, _values, result) ⇒ Object 



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

def _reduce_208(val, _values, result)
                      result = new_binary_call(val[0], val[1], val[2])
                    
    result
end

#_reduce_209(val, _values, result) ⇒ Object 



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

def _reduce_209(val, _values, result)
                      result = new_binary_call(val[0], val[1], val[2])
                    
    result
end

#_reduce_21(val, _values, result) ⇒ Object 



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

def _reduce_21(val, _values, result)
                      result = new_while(val[1], val[2], val[0])
                    
    result
end

#_reduce_210(val, _values, result) ⇒ Object 



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

def _reduce_210(val, _values, result)
                      result = new_binary_call(val[0], val[1], val[2])
                    
    result
end

#_reduce_211(val, _values, result) ⇒ Object 



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

def _reduce_211(val, _values, result)
                      result = new_binary_call(val[0], val[1], val[2])
                    
    result
end

#_reduce_212(val, _values, result) ⇒ Object 



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

def _reduce_212(val, _values, result)
                      result = new_binary_call(val[0], val[1], val[2])
                    
    result
end

#_reduce_213(val, _values, result) ⇒ Object 



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

def _reduce_213(val, _values, result)
                      result = new_binary_call(val[0], val[1], val[2])
                    
    result
end

#_reduce_214(val, _values, result) ⇒ Object 



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

def _reduce_214(val, _values, result)
                      result = new_binary_call(val[0], val[1], val[2])
                    
    result
end

#_reduce_215(val, _values, result) ⇒ Object 



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

def _reduce_215(val, _values, result)
                      result = new_unary_call(['!', []], new_binary_call(
                                 val[0], ['==', []], val[2]))
                    
    result
end

#_reduce_216(val, _values, result) ⇒ Object 



3873
3874
3875
3876
3877
 
# File 'opal/lib/opal/parser/grammar.rb', line 3873

def _reduce_216(val, _values, result)
                      result = new_binary_call(val[0], val[1], val[2])
                    
    result
end

#_reduce_217(val, _values, result) ⇒ Object 



3879
3880
3881
3882
3883
3884
 
# File 'opal/lib/opal/parser/grammar.rb', line 3879

def _reduce_217(val, _values, result)
                      result = new_not(val[1], new_binary_call(
                                 val[0], ['=~', []], val[2]))
                    
    result
end

#_reduce_218(val, _values, result) ⇒ Object 



3886
3887
3888
3889
3890
 
# File 'opal/lib/opal/parser/grammar.rb', line 3886

def _reduce_218(val, _values, result)
                      result = new_unary_call(val[0], val[1])
                    
    result
end

#_reduce_219(val, _values, result) ⇒ Object 



3892
3893
3894
3895
3896
 
# File 'opal/lib/opal/parser/grammar.rb', line 3892

def _reduce_219(val, _values, result)
                      result = new_unary_call(val[0], val[1])
                    
    result
end

#_reduce_22(val, _values, result) ⇒ Object 



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

def _reduce_22(val, _values, result)
                      result = new_until(val[1], val[2], val[0])
                    
    result
end

#_reduce_220(val, _values, result) ⇒ Object 



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

def _reduce_220(val, _values, result)
                      result = new_binary_call(val[0], val[1], val[2])
                    
    result
end

#_reduce_221(val, _values, result) ⇒ Object 



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

def _reduce_221(val, _values, result)
                      result = new_binary_call(val[0], val[1], val[2])
                    
    result
end

#_reduce_222(val, _values, result) ⇒ Object 



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

def _reduce_222(val, _values, result)
                      result = new_and(val[0], val[1], val[2])
                    
    result
end

#_reduce_223(val, _values, result) ⇒ Object 



3916
3917
3918
3919
3920
 
# File 'opal/lib/opal/parser/grammar.rb', line 3916

def _reduce_223(val, _values, result)
                      result = new_or(val[0], val[1], val[2])
                    
    result
end

#_reduce_224(val, _values, result) ⇒ Object 



3922
3923
3924
3925
3926
 
# File 'opal/lib/opal/parser/grammar.rb', line 3922

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

#_reduce_225(val, _values, result) ⇒ Object 



3928
3929
3930
3931
3932
 
# File 'opal/lib/opal/parser/grammar.rb', line 3928

def _reduce_225(val, _values, result)
                      result = new_if(val[1], val[0], val[2], val[4])
                    
    result
end

#_reduce_228(val, _values, result) ⇒ Object

reduce 227 omitted



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

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

#_reduce_229(val, _values, result) ⇒ Object 



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

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

#_reduce_23(val, _values, result) ⇒ Object 



3153
3154
3155
3156
3157
 
# File 'opal/lib/opal/parser/grammar.rb', line 3153

def _reduce_23(val, _values, result)
                      result = new_rescue_mod(val[1], val[0], val[2])
                    
    result
end

#_reduce_230(val, _values, result) ⇒ Object 



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

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

#_reduce_231(val, _values, result) ⇒ Object 



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

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

#_reduce_232(val, _values, result) ⇒ Object 



3963
3964
3965
3966
3967
 
# File 'opal/lib/opal/parser/grammar.rb', line 3963

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

#_reduce_233(val, _values, result) ⇒ Object 



3969
3970
3971
3972
3973
 
# File 'opal/lib/opal/parser/grammar.rb', line 3969

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

#_reduce_234(val, _values, result) ⇒ Object 



3975
3976
3977
3978
3979
 
# File 'opal/lib/opal/parser/grammar.rb', line 3975

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

#_reduce_237(val, _values, result) ⇒ Object

reduce 236 omitted



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

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

#_reduce_239(val, _values, result) ⇒ Object

reduce 238 omitted



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

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

#_reduce_240(val, _values, result) ⇒ Object 



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

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

#_reduce_241(val, _values, result) ⇒ Object 



4006
4007
4008
4009
4010
4011
 
# File 'opal/lib/opal/parser/grammar.rb', line 4006

def _reduce_241(val, _values, result)
                      result = [new_hash(nil, val[0], nil)]
                      add_block_pass result, val[1]
                    
    result
end

#_reduce_242(val, _values, result) ⇒ Object 



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

def _reduce_242(val, _values, result)
                      result = val[0]
                      result << new_hash(nil, val[2], nil)
                    
    result
end

#_reduce_243(val, _values, result) ⇒ Object 



4020
4021
4022
4023
4024
4025
 
# File 'opal/lib/opal/parser/grammar.rb', line 4020

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

#_reduce_246(val, _values, result) ⇒ Object

reduce 245 omitted



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

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

#_reduce_247(val, _values, result) ⇒ Object 



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

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

#_reduce_249(val, _values, result) ⇒ Object

reduce 248 omitted



4046
4047
4048
4049
4050
 
# File 'opal/lib/opal/parser/grammar.rb', line 4046

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

#_reduce_25(val, _values, result) ⇒ Object

reduce 24 omitted



3161
3162
3163
3164
3165
 
# File 'opal/lib/opal/parser/grammar.rb', line 3161

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

#_reduce_250(val, _values, result) ⇒ Object 



4052
4053
4054
4055
4056
 
# File 'opal/lib/opal/parser/grammar.rb', line 4052

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

#_reduce_251(val, _values, result) ⇒ Object 



4058
4059
4060
4061
4062
 
# File 'opal/lib/opal/parser/grammar.rb', line 4058

def _reduce_251(val, _values, result)
                      result = new_block_pass(val[0], val[1])
                    
    result
end

#_reduce_252(val, _values, result) ⇒ Object 



4064
4065
4066
4067
4068
 
# File 'opal/lib/opal/parser/grammar.rb', line 4064

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

#_reduce_253(val, _values, result) ⇒ Object 



4070
4071
4072
4073
4074
 
# File 'opal/lib/opal/parser/grammar.rb', line 4070

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

#_reduce_254(val, _values, result) ⇒ Object 



4076
4077
4078
4079
4080
 
# File 'opal/lib/opal/parser/grammar.rb', line 4076

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

#_reduce_255(val, _values, result) ⇒ Object 



4082
4083
4084
4085
4086
 
# File 'opal/lib/opal/parser/grammar.rb', line 4082

def _reduce_255(val, _values, result)
                      result = [new_splat(val[0], val[1])]
                    
    result
end

#_reduce_256(val, _values, result) ⇒ Object 



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

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

#_reduce_257(val, _values, result) ⇒ Object 



4094
4095
4096
4097
4098
 
# File 'opal/lib/opal/parser/grammar.rb', line 4094

def _reduce_257(val, _values, result)
                      result  = val[0] << new_splat(val[2], val[3])
                    
    result
end

#_reduce_258(val, _values, result) ⇒ Object 



4100
4101
4102
4103
4104
4105
 
# File 'opal/lib/opal/parser/grammar.rb', line 4100

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

#_reduce_259(val, _values, result) ⇒ Object 



4107
4108
4109
4110
4111
4112
 
# File 'opal/lib/opal/parser/grammar.rb', line 4107

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

#_reduce_26(val, _values, result) ⇒ Object 



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

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

#_reduce_260(val, _values, result) ⇒ Object 



4114
4115
4116
4117
4118
 
# File 'opal/lib/opal/parser/grammar.rb', line 4114

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

#_reduce_27(val, _values, result) ⇒ Object 



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

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

#_reduce_270(val, _values, result) ⇒ Object

reduce 269 omitted



4138
4139
4140
4141
4142
 
# File 'opal/lib/opal/parser/grammar.rb', line 4138

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

#_reduce_271(val, _values, result) ⇒ Object 



4144
4145
4146
4147
4148
 
# File 'opal/lib/opal/parser/grammar.rb', line 4144

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

#_reduce_272(val, _values, result) ⇒ Object 



4150
4151
4152
4153
4154
 
# File 'opal/lib/opal/parser/grammar.rb', line 4150

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

#_reduce_273(val, _values, result) ⇒ Object 



4156
4157
4158
4159
4160
 
# File 'opal/lib/opal/parser/grammar.rb', line 4156

def _reduce_273(val, _values, result)
                      result = new_paren(val[0], val[1], val[2])
                    
    result
end

#_reduce_274(val, _values, result) ⇒ Object 



4162
4163
4164
4165
4166
 
# File 'opal/lib/opal/parser/grammar.rb', line 4162

def _reduce_274(val, _values, result)
                      result = new_colon2(val[0], val[1], val[2])
                    
    result
end

#_reduce_275(val, _values, result) ⇒ Object 



4168
4169
4170
4171
4172
 
# File 'opal/lib/opal/parser/grammar.rb', line 4168

def _reduce_275(val, _values, result)
                      result = new_colon3(val[0], val[1])
                    
    result
end

#_reduce_276(val, _values, result) ⇒ Object 



4174
4175
4176
4177
4178
 
# File 'opal/lib/opal/parser/grammar.rb', line 4174

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

#_reduce_277(val, _values, result) ⇒ Object 



4180
4181
4182
4183
4184
 
# File 'opal/lib/opal/parser/grammar.rb', line 4180

def _reduce_277(val, _values, result)
                      result = new_array(val[0], val[1], val[2])
                    
    result
end

#_reduce_278(val, _values, result) ⇒ Object 



4186
4187
4188
4189
4190
 
# File 'opal/lib/opal/parser/grammar.rb', line 4186

def _reduce_278(val, _values, result)
                      result = new_hash(val[0], val[1], val[2])
                    
    result
end

#_reduce_279(val, _values, result) ⇒ Object 



4192
4193
4194
4195
4196
 
# File 'opal/lib/opal/parser/grammar.rb', line 4192

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

#_reduce_280(val, _values, result) ⇒ Object 



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

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

#_reduce_281(val, _values, result) ⇒ Object 



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

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

#_reduce_282(val, _values, result) ⇒ Object 



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

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

#_reduce_283(val, _values, result) ⇒ Object 



4216
4217
4218
4219
4220
 
# File 'opal/lib/opal/parser/grammar.rb', line 4216

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

#_reduce_284(val, _values, result) ⇒ Object 



4222
4223
4224
4225
4226
 
# File 'opal/lib/opal/parser/grammar.rb', line 4222

def _reduce_284(val, _values, result)
                      result = new_unary_call(['!', []], val[2])
                    
    result
end

#_reduce_285(val, _values, result) ⇒ Object 



4228
4229
4230
4231
4232
 
# File 'opal/lib/opal/parser/grammar.rb', line 4228

def _reduce_285(val, _values, result)
                      result = new_unary_call(['!', []], new_nil(val[0]))
                    
    result
end

#_reduce_286(val, _values, result) ⇒ Object 



4234
4235
4236
4237
4238
4239
 
# File 'opal/lib/opal/parser/grammar.rb', line 4234

def _reduce_286(val, _values, result)
                      result = new_call(nil, val[0], [])
                      result << val[1]
                    
    result
end

#_reduce_288(val, _values, result) ⇒ Object

reduce 287 omitted



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

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

#_reduce_289(val, _values, result) ⇒ Object 



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

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

#_reduce_29(val, _values, result) ⇒ Object

reduce 28 omitted



3181
3182
3183
3184
3185
 
# File 'opal/lib/opal/parser/grammar.rb', line 3181

def _reduce_29(val, _values, result)
                      result = s(:op_asgn2, val[0], op_to_setter(val[2]), value(val[3]).to_sym, val[4])
                    
    result
end

#_reduce_290(val, _values, result) ⇒ Object 



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

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

#_reduce_291(val, _values, result) ⇒ Object 



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

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

#_reduce_292(val, _values, result) ⇒ Object 



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

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

#_reduce_293(val, _values, result) ⇒ Object 



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

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

#_reduce_294(val, _values, result) ⇒ Object 



4281
4282
4283
4284
4285
 
# File 'opal/lib/opal/parser/grammar.rb', line 4281

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

#_reduce_295(val, _values, result) ⇒ Object 



4287
4288
4289
4290
4291
4292
 
# File 'opal/lib/opal/parser/grammar.rb', line 4287

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

#_reduce_296(val, _values, result) ⇒ Object 



4294
4295
4296
4297
4298
 
# File 'opal/lib/opal/parser/grammar.rb', line 4294

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

#_reduce_297(val, _values, result) ⇒ Object 



4300
4301
4302
4303
4304
 
# File 'opal/lib/opal/parser/grammar.rb', line 4300

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

#_reduce_298(val, _values, result) ⇒ Object 



4306
4307
4308
4309
4310
 
# File 'opal/lib/opal/parser/grammar.rb', line 4306

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

#_reduce_299(val, _values, result) ⇒ Object 



4312
4313
4314
4315
4316
 
# File 'opal/lib/opal/parser/grammar.rb', line 4312

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

#_reduce_3(val, _values, result) ⇒ Object 



3039
3040
3041
3042
3043
 
# File 'opal/lib/opal/parser/grammar.rb', line 3039

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

#_reduce_300(val, _values, result) ⇒ Object 



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

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

#_reduce_301(val, _values, result) ⇒ Object 



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

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

#_reduce_302(val, _values, result) ⇒ Object 



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

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

#_reduce_303(val, _values, result) ⇒ Object 



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

def _reduce_303(val, _values, result)
                      result = s(:for, val[4], val[1], val[7])
                    
    result
end

#_reduce_304(val, _values, result) ⇒ Object 



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

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

#_reduce_305(val, _values, result) ⇒ Object 



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

def _reduce_305(val, _values, result)
                      result = new_class val[0], val[1], val[2], val[4], val[5]
                    
    result
end

#_reduce_306(val, _values, result) ⇒ Object 



4355
4356
4357
4358
4359
 
# File 'opal/lib/opal/parser/grammar.rb', line 4355

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

#_reduce_307(val, _values, result) ⇒ Object 



4361
4362
4363
4364
4365
 
# File 'opal/lib/opal/parser/grammar.rb', line 4361

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

#_reduce_308(val, _values, result) ⇒ Object 



4367
4368
4369
4370
4371
 
# File 'opal/lib/opal/parser/grammar.rb', line 4367

def _reduce_308(val, _values, result)
                      result = new_sclass(val[0], val[3], val[6], val[7])
                    
    result
end

#_reduce_309(val, _values, result) ⇒ Object 



4373
4374
4375
4376
4377
 
# File 'opal/lib/opal/parser/grammar.rb', line 4373

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

#_reduce_310(val, _values, result) ⇒ Object 



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

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

#_reduce_311(val, _values, result) ⇒ Object 



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

def _reduce_311(val, _values, result)
                      result = new_module(val[0], val[2], val[4], val[5])
                    
    result
end

#_reduce_312(val, _values, result) ⇒ Object 



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

def _reduce_312(val, _values, result)
                      push_scope
                    
    result
end

#_reduce_313(val, _values, result) ⇒ Object 



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

def _reduce_313(val, _values, result)
                      result = new_def(val[0], nil, val[1], val[3], val[4], val[5])
                      pop_scope
                    
    result
end

#_reduce_314(val, _values, result) ⇒ Object 



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

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

#_reduce_315(val, _values, result) ⇒ Object 



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

def _reduce_315(val, _values, result)
                      push_scope
                    
    result
end

#_reduce_316(val, _values, result) ⇒ Object 



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

def _reduce_316(val, _values, result)
                      result = new_def(val[0], val[1], val[4], val[6], val[7], val[8])
                      pop_scope
                    
    result
end

#_reduce_317(val, _values, result) ⇒ Object 



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

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

#_reduce_318(val, _values, result) ⇒ Object 



4429
4430
4431
4432
4433
 
# File 'opal/lib/opal/parser/grammar.rb', line 4429

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

#_reduce_319(val, _values, result) ⇒ Object 



4435
4436
4437
4438
4439
 
# File 'opal/lib/opal/parser/grammar.rb', line 4435

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

#_reduce_329(val, _values, result) ⇒ Object

reduce 328 omitted



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

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

#_reduce_33(val, _values, result) ⇒ Object

reduce 32 omitted



3193
3194
3195
3196
3197
 
# File 'opal/lib/opal/parser/grammar.rb', line 3193

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

#_reduce_330(val, _values, result) ⇒ Object 



4466
4467
4468
4469
4470
 
# File 'opal/lib/opal/parser/grammar.rb', line 4466

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

#_reduce_331(val, _values, result) ⇒ Object 



4472
4473
4474
4475
4476
 
# File 'opal/lib/opal/parser/grammar.rb', line 4472

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

#_reduce_334(val, _values, result) ⇒ Object

reduce 333 omitted



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

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

#_reduce_335(val, _values, result) ⇒ Object 



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

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

#_reduce_336(val, _values, result) ⇒ Object 



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

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

#_reduce_337(val, _values, result) ⇒ Object 



4500
4501
4502
4503
4504
 
# File 'opal/lib/opal/parser/grammar.rb', line 4500

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

#_reduce_339(val, _values, result) ⇒ Object

reduce 338 omitted



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

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

#_reduce_34(val, _values, result) ⇒ Object 



3199
3200
3201
3202
3203
 
# File 'opal/lib/opal/parser/grammar.rb', line 3199

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

#_reduce_340(val, _values, result) ⇒ Object 



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

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

#_reduce_341(val, _values, result) ⇒ Object 



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

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

#_reduce_342(val, _values, result) ⇒ Object 



4527
4528
4529
4530
4531
4532
 
# File 'opal/lib/opal/parser/grammar.rb', line 4527

def _reduce_342(val, _values, result)
                      result = new_assign(new_assignable(new_ident(
                                  val[0])), val[1], val[2])
                    
    result
end

#_reduce_344(val, _values, result) ⇒ Object

reduce 343 omitted



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

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

#_reduce_345(val, _values, result) ⇒ Object 



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

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

#_reduce_346(val, _values, result) ⇒ Object 



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

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

#_reduce_347(val, _values, result) ⇒ Object 



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

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

#_reduce_348(val, _values, result) ⇒ Object 



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

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

#_reduce_349(val, _values, result) ⇒ Object 



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

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

#_reduce_35(val, _values, result) ⇒ Object 



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

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

#_reduce_350(val, _values, result) ⇒ Object 



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

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

#_reduce_351(val, _values, result) ⇒ Object 



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

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

#_reduce_352(val, _values, result) ⇒ Object 



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

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

#_reduce_353(val, _values, result) ⇒ Object 



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

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

#_reduce_354(val, _values, result) ⇒ Object 



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

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

#_reduce_355(val, _values, result) ⇒ Object 



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

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

#_reduce_356(val, _values, result) ⇒ Object 



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

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

#_reduce_357(val, _values, result) ⇒ Object 



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

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

#_reduce_358(val, _values, result) ⇒ Object 



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

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

#_reduce_359(val, _values, result) ⇒ Object 



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

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

#_reduce_360(val, _values, result) ⇒ Object 



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

def _reduce_360(val, _values, result)
                      result = new_iter val[2], val[3]
                      pop_scope
                    
    result
end

#_reduce_361(val, _values, result) ⇒ Object 



4640
4641
4642
4643
4644
4645
 
# File 'opal/lib/opal/parser/grammar.rb', line 4640

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

#_reduce_364(val, _values, result) ⇒ Object

reduce 363 omitted



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

def _reduce_364(val, _values, result)
                      result = new_call(nil, val[0], val[1])
                    
    result
end

#_reduce_365(val, _values, result) ⇒ Object 



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

def _reduce_365(val, _values, result)
                      result = new_call(val[0], val[2], val[3])
                    
    result
end

#_reduce_366(val, _values, result) ⇒ Object 



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

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

#_reduce_367(val, _values, result) ⇒ Object 



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

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

#_reduce_368(val, _values, result) ⇒ Object 



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

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

#_reduce_369(val, _values, result) ⇒ Object 



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

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

#_reduce_370(val, _values, result) ⇒ Object 



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

def _reduce_370(val, _values, result)
                      result = new_super(val[0], nil)
                    
    result
end

#_reduce_371(val, _values, result) ⇒ Object 



4693
4694
4695
4696
4697
4698
 
# File 'opal/lib/opal/parser/grammar.rb', line 4693

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

#_reduce_372(val, _values, result) ⇒ Object 



4700
4701
4702
4703
4704
4705
 
# File 'opal/lib/opal/parser/grammar.rb', line 4700

def _reduce_372(val, _values, result)
                      result = new_iter val[2], val[3]
                      pop_scope
                    
    result
end

#_reduce_373(val, _values, result) ⇒ Object 



4707
4708
4709
4710
4711
4712
 
# File 'opal/lib/opal/parser/grammar.rb', line 4707

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

#_reduce_374(val, _values, result) ⇒ Object 



4714
4715
4716
4717
4718
4719
 
# File 'opal/lib/opal/parser/grammar.rb', line 4714

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

#_reduce_375(val, _values, result) ⇒ Object 



4721
4722
4723
4724
4725
 
# File 'opal/lib/opal/parser/grammar.rb', line 4721

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

#_reduce_376(val, _values, result) ⇒ Object 



4727
4728
4729
4730
4731
4732
4733
 
# File 'opal/lib/opal/parser/grammar.rb', line 4727

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

#_reduce_377(val, _values, result) ⇒ Object 



4735
4736
4737
4738
4739
 
# File 'opal/lib/opal/parser/grammar.rb', line 4735

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

#_reduce_379(val, _values, result) ⇒ Object

reduce 378 omitted



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

def _reduce_379(val, _values, result)
                      exc = val[1] || s(:array)
                      exc << new_assign(val[2], 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_38(val, _values, result) ⇒ Object

reduce 37 omitted



3215
3216
3217
3218
3219
 
# File 'opal/lib/opal/parser/grammar.rb', line 3215

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

#_reduce_380(val, _values, result) ⇒ Object 



4752
4753
4754
4755
4756
 
# File 'opal/lib/opal/parser/grammar.rb', line 4752

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

#_reduce_381(val, _values, result) ⇒ Object 



4758
4759
4760
4761
4762
 
# File 'opal/lib/opal/parser/grammar.rb', line 4758

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

#_reduce_384(val, _values, result) ⇒ Object

reduce 383 omitted



4768
4769
4770
4771
4772
 
# File 'opal/lib/opal/parser/grammar.rb', line 4768

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

#_reduce_385(val, _values, result) ⇒ Object 



4774
4775
4776
4777
4778
 
# File 'opal/lib/opal/parser/grammar.rb', line 4774

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

#_reduce_386(val, _values, result) ⇒ Object 



4780
4781
4782
4783
4784
 
# File 'opal/lib/opal/parser/grammar.rb', line 4780

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

#_reduce_39(val, _values, result) ⇒ Object 



3221
3222
3223
3224
3225
 
# File 'opal/lib/opal/parser/grammar.rb', line 3221

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

#_reduce_391(val, _values, result) ⇒ Object

reduce 390 omitted



4794
4795
4796
4797
4798
 
# File 'opal/lib/opal/parser/grammar.rb', line 4794

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

#_reduce_393(val, _values, result) ⇒ Object

reduce 392 omitted



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

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

#_reduce_394(val, _values, result) ⇒ Object 



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

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

#_reduce_395(val, _values, result) ⇒ Object 



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

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

#_reduce_396(val, _values, result) ⇒ Object 



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

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

#_reduce_397(val, _values, result) ⇒ Object 



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

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

#_reduce_398(val, _values, result) ⇒ Object 



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

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

#_reduce_399(val, _values, result) ⇒ Object 



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

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

#_reduce_4(val, _values, result) ⇒ Object 



3045
3046
3047
3048
3049
 
# File 'opal/lib/opal/parser/grammar.rb', line 3045

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

#_reduce_40(val, _values, result) ⇒ Object 



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

def _reduce_40(val, _values, result)
                      result = new_unary_call(['!', []], val[1])
                    
    result
end

#_reduce_400(val, _values, result) ⇒ Object 



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

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

#_reduce_401(val, _values, result) ⇒ Object 



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

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

#_reduce_402(val, _values, result) ⇒ Object 



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

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

#_reduce_403(val, _values, result) ⇒ Object 



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

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

#_reduce_404(val, _values, result) ⇒ Object 



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

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

#_reduce_405(val, _values, result) ⇒ Object 



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

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

#_reduce_406(val, _values, result) ⇒ Object 



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

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

#_reduce_407(val, _values, result) ⇒ Object 



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

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

#_reduce_408(val, _values, result) ⇒ Object 



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

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

#_reduce_409(val, _values, result) ⇒ Object 



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

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

#_reduce_41(val, _values, result) ⇒ Object 



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

def _reduce_41(val, _values, result)
                      result = new_unary_call(val[0], val[1])
                    
    result
end

#_reduce_410(val, _values, result) ⇒ Object 



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

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

#_reduce_411(val, _values, result) ⇒ Object 



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

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

#_reduce_412(val, _values, result) ⇒ Object 



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

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

#_reduce_413(val, _values, result) ⇒ Object 



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

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

#_reduce_414(val, _values, result) ⇒ Object 



4931
4932
4933
4934
4935
4936
 
# File 'opal/lib/opal/parser/grammar.rb', line 4931

def _reduce_414(val, _values, result)
                      lexer.strterm = val[1]
                      result = new_evstr(val[2])
                    
    result
end

#_reduce_415(val, _values, result) ⇒ Object 



4938
4939
4940
4941
4942
4943
4944
4945
4946
 
# File 'opal/lib/opal/parser/grammar.rb', line 4938

def _reduce_415(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_416(val, _values, result) ⇒ Object 



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

def _reduce_416(val, _values, result)
                      lexer.strterm = val[1]
                      lexer.cond_lexpop
                      lexer.cmdarg_lexpop
                      result = new_evstr(val[2])
                    
    result
end

#_reduce_417(val, _values, result) ⇒ Object 



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

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

#_reduce_418(val, _values, result) ⇒ Object 



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

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

#_reduce_419(val, _values, result) ⇒ Object 



4969
4970
4971
4972
4973
 
# File 'opal/lib/opal/parser/grammar.rb', line 4969

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

#_reduce_421(val, _values, result) ⇒ Object

reduce 420 omitted



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

def _reduce_421(val, _values, result)
                      result = new_sym(val[1])
                      lexer.lex_state = :expr_end
                    
    result
end

#_reduce_422(val, _values, result) ⇒ Object 



4984
4985
4986
4987
4988
 
# File 'opal/lib/opal/parser/grammar.rb', line 4984

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

#_reduce_427(val, _values, result) ⇒ Object

reduce 426 omitted



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

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

#_reduce_428(val, _values, result) ⇒ Object 



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

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

#_reduce_429(val, _values, result) ⇒ Object 



5010
5011
5012
5013
5014
 
# File 'opal/lib/opal/parser/grammar.rb', line 5010

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

#_reduce_430(val, _values, result) ⇒ Object 



5016
5017
5018
5019
5020
 
# File 'opal/lib/opal/parser/grammar.rb', line 5016

def _reduce_430(val, _values, result)
                    result = negate_num(new_int(val[1]))
                  
    result
end

#_reduce_431(val, _values, result) ⇒ Object 



5022
5023
5024
5025
5026
 
# File 'opal/lib/opal/parser/grammar.rb', line 5022

def _reduce_431(val, _values, result)
                    result = negate_num(new_float(val[1]))
                  
    result
end

#_reduce_432(val, _values, result) ⇒ Object 



5028
5029
5030
5031
5032
 
# File 'opal/lib/opal/parser/grammar.rb', line 5028

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

#_reduce_433(val, _values, result) ⇒ Object 



5034
5035
5036
5037
5038
 
# File 'opal/lib/opal/parser/grammar.rb', line 5034

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

#_reduce_434(val, _values, result) ⇒ Object 



5040
5041
5042
5043
5044
 
# File 'opal/lib/opal/parser/grammar.rb', line 5040

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

#_reduce_435(val, _values, result) ⇒ Object 



5046
5047
5048
5049
5050
 
# File 'opal/lib/opal/parser/grammar.rb', line 5046

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

#_reduce_436(val, _values, result) ⇒ Object 



5052
5053
5054
5055
5056
 
# File 'opal/lib/opal/parser/grammar.rb', line 5052

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

#_reduce_437(val, _values, result) ⇒ Object 



5058
5059
5060
5061
5062
 
# File 'opal/lib/opal/parser/grammar.rb', line 5058

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

#_reduce_438(val, _values, result) ⇒ Object 



5064
5065
5066
5067
5068
 
# File 'opal/lib/opal/parser/grammar.rb', line 5064

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

#_reduce_439(val, _values, result) ⇒ Object 



5070
5071
5072
5073
5074
 
# File 'opal/lib/opal/parser/grammar.rb', line 5070

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

#_reduce_440(val, _values, result) ⇒ Object 



5076
5077
5078
5079
5080
 
# File 'opal/lib/opal/parser/grammar.rb', line 5076

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

#_reduce_441(val, _values, result) ⇒ Object 



5082
5083
5084
5085
5086
 
# File 'opal/lib/opal/parser/grammar.rb', line 5082

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

#_reduce_442(val, _values, result) ⇒ Object 



5088
5089
5090
5091
5092
 
# File 'opal/lib/opal/parser/grammar.rb', line 5088

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

#_reduce_443(val, _values, result) ⇒ Object 



5094
5095
5096
5097
5098
 
# File 'opal/lib/opal/parser/grammar.rb', line 5094

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

#_reduce_444(val, _values, result) ⇒ Object 



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

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

#_reduce_445(val, _values, result) ⇒ Object 



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

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

#_reduce_446(val, _values, result) ⇒ Object 



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

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

#_reduce_447(val, _values, result) ⇒ Object 



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

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

#_reduce_449(val, _values, result) ⇒ Object

reduce 448 omitted



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

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

#_reduce_450(val, _values, result) ⇒ Object 



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

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

#_reduce_451(val, _values, result) ⇒ Object 



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

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

#_reduce_452(val, _values, result) ⇒ Object 



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

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

#_reduce_453(val, _values, result) ⇒ Object 



5151
5152
5153
5154
5155
 
# File 'opal/lib/opal/parser/grammar.rb', line 5151

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

#_reduce_456(val, _values, result) ⇒ Object

reduce 455 omitted



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

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

#_reduce_457(val, _values, result) ⇒ Object 



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

def _reduce_457(val, _values, result)
                      result = new_kwrestarg()
                    
    result
end

#_reduce_458(val, _values, result) ⇒ Object 



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

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

#_reduce_459(val, _values, result) ⇒ Object 



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

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

#_reduce_46(val, _values, result) ⇒ Object

reduce 45 omitted



3247
3248
3249
3250
3251
 
# File 'opal/lib/opal/parser/grammar.rb', line 3247

def _reduce_46(val, _values, result)
                      result = new_return(val[0], val[1])
                    
    result
end

#_reduce_460(val, _values, result) ⇒ Object 



5185
5186
5187
5188
5189
 
# File 'opal/lib/opal/parser/grammar.rb', line 5185

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

#_reduce_461(val, _values, result) ⇒ Object 



5191
5192
5193
5194
5195
 
# File 'opal/lib/opal/parser/grammar.rb', line 5191

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

#_reduce_462(val, _values, result) ⇒ Object 



5197
5198
5199
5200
5201
5202
 
# File 'opal/lib/opal/parser/grammar.rb', line 5197

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

#_reduce_463(val, _values, result) ⇒ Object 



5204
5205
5206
5207
5208
 
# File 'opal/lib/opal/parser/grammar.rb', line 5204

def _reduce_463(val, _values, result)
                      result = new_args_tail(val[0], val[2], val[3])
                    
    result
end

#_reduce_464(val, _values, result) ⇒ Object 



5210
5211
5212
5213
5214
 
# File 'opal/lib/opal/parser/grammar.rb', line 5210

def _reduce_464(val, _values, result)
                      result = new_args_tail(val[0], nil, val[1])
                    
    result
end

#_reduce_465(val, _values, result) ⇒ Object 



5216
5217
5218
5219
5220
 
# File 'opal/lib/opal/parser/grammar.rb', line 5216

def _reduce_465(val, _values, result)
                      result = new_args_tail(nil, val[0], val[1])
                    
    result
end

#_reduce_466(val, _values, result) ⇒ Object 



5222
5223
5224
5225
5226
 
# File 'opal/lib/opal/parser/grammar.rb', line 5222

def _reduce_466(val, _values, result)
                      result = new_args_tail(nil, nil, val[0])
                    
    result
end

#_reduce_467(val, _values, result) ⇒ Object 



5228
5229
5230
5231
5232
 
# File 'opal/lib/opal/parser/grammar.rb', line 5228

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

#_reduce_468(val, _values, result) ⇒ Object 



5234
5235
5236
5237
5238
 
# File 'opal/lib/opal/parser/grammar.rb', line 5234

def _reduce_468(val, _values, result)
                      result = new_args_tail(nil, nil, nil)
                    
    result
end

#_reduce_469(val, _values, result) ⇒ Object 



5240
5241
5242
5243
5244
 
# File 'opal/lib/opal/parser/grammar.rb', line 5240

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

#_reduce_47(val, _values, result) ⇒ Object 



3253
3254
3255
3256
3257
 
# File 'opal/lib/opal/parser/grammar.rb', line 3253

def _reduce_47(val, _values, result)
                      result = new_break(val[0], val[1])
                    
    result
end

#_reduce_470(val, _values, result) ⇒ Object 



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

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

#_reduce_471(val, _values, result) ⇒ Object 



5252
5253
5254
5255
5256
 
# File 'opal/lib/opal/parser/grammar.rb', line 5252

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

#_reduce_472(val, _values, result) ⇒ Object 



5258
5259
5260
5261
5262
 
# File 'opal/lib/opal/parser/grammar.rb', line 5258

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

#_reduce_473(val, _values, result) ⇒ Object 



5264
5265
5266
5267
5268
 
# File 'opal/lib/opal/parser/grammar.rb', line 5264

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

#_reduce_474(val, _values, result) ⇒ Object 



5270
5271
5272
5273
5274
 
# File 'opal/lib/opal/parser/grammar.rb', line 5270

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

#_reduce_475(val, _values, result) ⇒ Object 



5276
5277
5278
5279
5280
 
# File 'opal/lib/opal/parser/grammar.rb', line 5276

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

#_reduce_476(val, _values, result) ⇒ Object 



5282
5283
5284
5285
5286
 
# File 'opal/lib/opal/parser/grammar.rb', line 5282

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

#_reduce_477(val, _values, result) ⇒ Object 



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

def _reduce_477(val, _values, result)
                      result = new_args(nil, nil, nil, nil)
                    
    result
end

#_reduce_479(val, _values, result) ⇒ Object

reduce 478 omitted



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

def _reduce_479(val, _values, result)
                      result = value(val[0]).to_sym
                      scope.add_local result
                    
    result
end

#_reduce_48(val, _values, result) ⇒ Object 



3259
3260
3261
3262
3263
 
# File 'opal/lib/opal/parser/grammar.rb', line 3259

def _reduce_48(val, _values, result)
                      result = new_next(val[0], val[1])
                    
    result
end

#_reduce_480(val, _values, result) ⇒ Object 



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

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

#_reduce_481(val, _values, result) ⇒ Object 



5309
5310
5311
5312
5313
 
# File 'opal/lib/opal/parser/grammar.rb', line 5309

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

#_reduce_482(val, _values, result) ⇒ Object 



5315
5316
5317
5318
5319
 
# File 'opal/lib/opal/parser/grammar.rb', line 5315

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

#_reduce_483(val, _values, result) ⇒ Object 



5321
5322
5323
5324
5325
 
# File 'opal/lib/opal/parser/grammar.rb', line 5321

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

#_reduce_484(val, _values, result) ⇒ Object 



5327
5328
5329
5330
5331
 
# File 'opal/lib/opal/parser/grammar.rb', line 5327

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

#_reduce_485(val, _values, result) ⇒ Object 



5333
5334
5335
5336
5337
 
# File 'opal/lib/opal/parser/grammar.rb', line 5333

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

#_reduce_488(val, _values, result) ⇒ Object

reduce 487 omitted



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

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

#_reduce_490(val, _values, result) ⇒ Object

reduce 489 omitted



5351
5352
5353
5354
5355
 
# File 'opal/lib/opal/parser/grammar.rb', line 5351

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

#_reduce_491(val, _values, result) ⇒ Object 



5357
5358
5359
5360
5361
5362
 
# File 'opal/lib/opal/parser/grammar.rb', line 5357

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

#_reduce_497(val, _values, result) ⇒ Object

reduce 496 omitted



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

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

#_reduce_498(val, _values, result) ⇒ Object 



5380
5381
5382
5383
5384
5385
 
# File 'opal/lib/opal/parser/grammar.rb', line 5380

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

#_reduce_499(val, _values, result) ⇒ Object 



5387
5388
5389
5390
5391
 
# File 'opal/lib/opal/parser/grammar.rb', line 5387

def _reduce_499(val, _values, result)
                      result = new_assign(new_assignable(new_ident(val[0])), val[1], val[2])
                    
    result
end

#_reduce_5(val, _values, result) ⇒ Object 



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

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

#_reduce_500(val, _values, result) ⇒ Object 



5393
5394
5395
5396
5397
 
# File 'opal/lib/opal/parser/grammar.rb', line 5393

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

#_reduce_501(val, _values, result) ⇒ Object 



5399
5400
5401
5402
5403
5404
 
# File 'opal/lib/opal/parser/grammar.rb', line 5399

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

#_reduce_504(val, _values, result) ⇒ Object

reduce 503 omitted



5410
5411
5412
5413
5414
 
# File 'opal/lib/opal/parser/grammar.rb', line 5410

def _reduce_504(val, _values, result)
                      result = "*#{value(val[1])}".to_sym
                    
    result
end

#_reduce_505(val, _values, result) ⇒ Object 



5416
5417
5418
5419
5420
 
# File 'opal/lib/opal/parser/grammar.rb', line 5416

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

#_reduce_508(val, _values, result) ⇒ Object

reduce 507 omitted



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

def _reduce_508(val, _values, result)
                      result = "&#{value(val[1])}".to_sym
                    
    result
end

#_reduce_509(val, _values, result) ⇒ Object 



5432
5433
5434
5435
5436
 
# File 'opal/lib/opal/parser/grammar.rb', line 5432

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

#_reduce_510(val, _values, result) ⇒ Object 



5438
5439
5440
5441
5442
 
# File 'opal/lib/opal/parser/grammar.rb', line 5438

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

#_reduce_511(val, _values, result) ⇒ Object 



5444
5445
5446
5447
5448
 
# File 'opal/lib/opal/parser/grammar.rb', line 5444

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

#_reduce_512(val, _values, result) ⇒ Object 



5450
5451
5452
5453
5454
 
# File 'opal/lib/opal/parser/grammar.rb', line 5450

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

#_reduce_513(val, _values, result) ⇒ Object 



5456
5457
5458
5459
5460
 
# File 'opal/lib/opal/parser/grammar.rb', line 5456

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

#_reduce_514(val, _values, result) ⇒ Object 



5462
5463
5464
5465
5466
 
# File 'opal/lib/opal/parser/grammar.rb', line 5462

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

#_reduce_515(val, _values, result) ⇒ Object 



5468
5469
5470
5471
5472
 
# File 'opal/lib/opal/parser/grammar.rb', line 5468

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

#_reduce_516(val, _values, result) ⇒ Object 



5474
5475
5476
5477
5478
 
# File 'opal/lib/opal/parser/grammar.rb', line 5474

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

#_reduce_517(val, _values, result) ⇒ Object 



5480
5481
5482
5483
5484
 
# File 'opal/lib/opal/parser/grammar.rb', line 5480

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

#_reduce_518(val, _values, result) ⇒ Object 



5486
5487
5488
5489
5490
 
# File 'opal/lib/opal/parser/grammar.rb', line 5486

def _reduce_518(val, _values, result)
                      result = [new_sym(val[0]), val[1]]
                    
    result
end

#_reduce_53(val, _values, result) ⇒ Object

reduce 52 omitted



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

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

#_reduce_542(val, _values, result) ⇒ Object

reduce 541 omitted



5538
5539
5540
5541
5542
 
# File 'opal/lib/opal/parser/grammar.rb', line 5538

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

#_reduce_55(val, _values, result) ⇒ Object

reduce 54 omitted



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

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

#_reduce_57(val, _values, result) ⇒ Object

reduce 56 omitted



3289
3290
3291
3292
3293
 
# File 'opal/lib/opal/parser/grammar.rb', line 3289

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

#_reduce_59(val, _values, result) ⇒ Object

reduce 58 omitted



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

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

#_reduce_60(val, _values, result) ⇒ Object 



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

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

#_reduce_61(val, _values, result) ⇒ Object 



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

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

#_reduce_62(val, _values, result) ⇒ Object 



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

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

#_reduce_63(val, _values, result) ⇒ Object 



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

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

#_reduce_64(val, _values, result) ⇒ Object 



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

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

#_reduce_65(val, _values, result) ⇒ Object 



3333
3334
3335
3336
3337
 
# File 'opal/lib/opal/parser/grammar.rb', line 3333

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

#_reduce_66(val, _values, result) ⇒ Object 



3339
3340
3341
3342
3343
 
# File 'opal/lib/opal/parser/grammar.rb', line 3339

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

#_reduce_67(val, _values, result) ⇒ Object 



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

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

#_reduce_69(val, _values, result) ⇒ Object

reduce 68 omitted



3353
3354
3355
3356
3357
 
# File 'opal/lib/opal/parser/grammar.rb', line 3353

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

#_reduce_7(val, _values, result) ⇒ Object

reduce 6 omitted



3060
3061
3062
3063
3064
 
# File 'opal/lib/opal/parser/grammar.rb', line 3060

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

#_reduce_71(val, _values, result) ⇒ Object

reduce 70 omitted



3361
3362
3363
3364
3365
 
# File 'opal/lib/opal/parser/grammar.rb', line 3361

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

#_reduce_72(val, _values, result) ⇒ Object 



3367
3368
3369
3370
3371
 
# File 'opal/lib/opal/parser/grammar.rb', line 3367

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

#_reduce_74(val, _values, result) ⇒ Object

reduce 73 omitted



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

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

#_reduce_75(val, _values, result) ⇒ Object 



3381
3382
3383
3384
3385
 
# File 'opal/lib/opal/parser/grammar.rb', line 3381

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

#_reduce_76(val, _values, result) ⇒ Object 



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

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

#_reduce_77(val, _values, result) ⇒ Object 



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

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

#_reduce_8(val, _values, result) ⇒ Object 



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

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



3403
3404
3405
3406
3407
 
# File 'opal/lib/opal/parser/grammar.rb', line 3403

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

#_reduce_81(val, _values, result) ⇒ Object 



3409
3410
3411
3412
3413
3414
 
# File 'opal/lib/opal/parser/grammar.rb', line 3409

def _reduce_81(val, _values, result)
                      args = val[2] ? val[2] : []
                      result = s(:attrasgn, val[0], :[]=, s(:arglist, *args))
                    
    result
end

#_reduce_82(val, _values, result) ⇒ Object 



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

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

#_reduce_88(val, _values, result) ⇒ Object

reduce 87 omitted



3432
3433
3434
3435
3436
 
# File 'opal/lib/opal/parser/grammar.rb', line 3432

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

#_reduce_89(val, _values, result) ⇒ Object 



3438
3439
3440
3441
3442
 
# File 'opal/lib/opal/parser/grammar.rb', line 3438

def _reduce_89(val, _values, result)
                      result = new_attrasgn(val[0], :[]=, val[2])
                    
    result
end

#_reduce_9(val, _values, result) ⇒ Object 



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

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

#_reduce_90(val, _values, result) ⇒ Object 



3444
3445
3446
3447
3448
 
# File 'opal/lib/opal/parser/grammar.rb', line 3444

def _reduce_90(val, _values, result)
                      result = new_attrasgn(val[0], op_to_setter(val[2]))
                    
    result
end

#_reduce_91(val, _values, result) ⇒ Object 



3450
3451
3452
3453
3454
 
# File 'opal/lib/opal/parser/grammar.rb', line 3450

def _reduce_91(val, _values, result)
                      result = new_attrasgn(val[0], op_to_setter(val[2]))
                    
    result
end

#_reduce_92(val, _values, result) ⇒ Object 



3456
3457
3458
3459
3460
 
# File 'opal/lib/opal/parser/grammar.rb', line 3456

def _reduce_92(val, _values, result)
                      result = new_attrasgn(val[0], op_to_setter(val[2]))
                    
    result
end

#_reduce_93(val, _values, result) ⇒ Object 



3462
3463
3464
3465
3466
 
# File 'opal/lib/opal/parser/grammar.rb', line 3462

def _reduce_93(val, _values, result)
                      result = new_colon2(val[0], val[1], val[2])
                    
    result
end

#_reduce_94(val, _values, result) ⇒ Object 



3468
3469
3470
3471
3472
 
# File 'opal/lib/opal/parser/grammar.rb', line 3468

def _reduce_94(val, _values, result)
                      result = new_colon3(val[0], val[1])
                    
    result
end

#_reduce_97(val, _values, result) ⇒ Object

reduce 96 omitted



3478
3479
3480
3481
3482
 
# File 'opal/lib/opal/parser/grammar.rb', line 3478

def _reduce_97(val, _values, result)
                      result = new_colon3(val[0], val[1])
                    
    result
end

#_reduce_98(val, _values, result) ⇒ Object 



3484
3485
3486
3487
3488
 
# File 'opal/lib/opal/parser/grammar.rb', line 3484

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

#_reduce_99(val, _values, result) ⇒ Object 



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

def _reduce_99(val, _values, result)
                      result = new_colon2(val[0], val[1], val[2])
                    
    result
end

#_reduce_none(val, _values, result) ⇒ Object 



5544
5545
5546
 
# File 'opal/lib/opal/parser/grammar.rb', line 5544

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

#add_block_pass(arglist, block) ⇒ Object 



490
491
492
493
 
# File 'opal/lib/opal/parser.rb', line 490

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

#negate_num(sexp) ⇒ Object 



485
486
487
488
 
# File 'opal/lib/opal/parser.rb', line 485

def negate_num(sexp)
  sexp.array[1] = -sexp.array[1]
  sexp
end

#new___FILE__(tok) ⇒ Object 



120
121
122
 
# File 'opal/lib/opal/parser.rb', line 120

def new___FILE__(tok)
  s1(:str, self.file, source(tok))
end

#new___LINE__(tok) ⇒ Object 



124
125
126
 
# File 'opal/lib/opal/parser.rb', line 124

def new___LINE__(tok)
  s1(:int, lexer.line, source(tok))
end

#new_alias(kw, new, old) ⇒ Object 



170
171
172
173
174
 
# File 'opal/lib/opal/parser.rb', line 170

def new_alias(kw, new, old)
  sexp = s(:alias, new, old)
  sexp.source = source(kw)
  sexp
end

#new_and(lhs, tok, rhs) ⇒ Object 



461
462
463
464
465
 
# File 'opal/lib/opal/parser.rb', line 461

def new_and(lhs, tok, rhs)
  sexp = s(:and, lhs, rhs)
  sexp.source = source(tok)
  sexp
end

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



333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
 
# File 'opal/lib/opal/parser.rb', line 333

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

  if norm
    norm.each do |arg|
      scope.add_local arg
      res << s(:arg, arg)
    end
  end

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

  if rest
    restname = rest.to_s[1..-1]

    if restname.empty?
      res << s(:restarg)
    else
      res << s(:restarg, restname.to_sym)
      scope.add_local restname.to_sym
    end
  end

  # kwarg
  if tail and tail[0]
    tail[0].each do |kwarg|
      res << kwarg
    end
  end

  # kwrestarg
  if tail and tail[1]
    res << tail[1]
  end

  # block
  if tail and tail[2]
    blockname = tail[2].to_s[1..-1].to_sym
    scope.add_local blockname
    res << s(:blockarg, blockname)
  end

  res
end

#new_args_tail(kwarg, kwrest, block) ⇒ Object 



329
330
331
 
# File 'opal/lib/opal/parser.rb', line 329

def new_args_tail(kwarg, kwrest, block)
  [kwarg, kwrest, block]
end

#new_array(start, args, finish) ⇒ Object 



304
305
306
307
308
309
 
# File 'opal/lib/opal/parser.rb', line 304

def new_array(start, args, finish)
  args ||= []
  sexp = s(:array, *args)
  sexp.source = source(start)
  sexp
end

#new_assign(lhs, tok, rhs) ⇒ Object 



537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
 
# File 'opal/lib/opal/parser.rb', line 537

def new_assign(lhs, tok, 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 



558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
 
# File 'opal/lib/opal/parser.rb', line 558

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 SyntaxError, "Bad new_assignable type: #{ref.type}"
  end

  ref
end

#new_attrasgn(recv, op, args = []) ⇒ Object 



531
532
533
534
535
 
# File 'opal/lib/opal/parser.rb', line 531

def new_attrasgn(recv, op, args=[])
  arglist = s(:arglist, *args)
  sexp = s(:attrasgn, recv, op, arglist)
  sexp
end

#new_binary_call(recv, meth, arg) ⇒ Object 



453
454
455
 
# File 'opal/lib/opal/parser.rb', line 453

def new_binary_call(recv, meth, arg)
  new_call(recv, meth, [arg])
end

#new_block(stmt = nil) ⇒ Object 



210
211
212
213
214
 
# File 'opal/lib/opal/parser.rb', line 210

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

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



403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
 
# File 'opal/lib/opal/parser.rb', line 403

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 << new_splat(nil, 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_block_pass(amper_tok, val) ⇒ Object 



495
496
497
 
# File 'opal/lib/opal/parser.rb', line 495

def new_block_pass(amper_tok, val)
  s1(:block_pass, val, source(amper_tok))
end

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



234
235
236
237
238
239
240
241
242
243
244
 
# File 'opal/lib/opal/parser.rb', line 234

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

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

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

#new_break(kw, args = nil) ⇒ Object 



176
177
178
179
180
181
182
183
184
185
186
 
# File 'opal/lib/opal/parser.rb', line 176

def new_break(kw, args=nil)
  if args.nil?
    sexp = s(:break)
  elsif args.length == 1
    sexp = s(:break, args[0])
  else
    sexp = s(:break, s(:array, *args))
  end

  sexp
end

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



446
447
448
449
450
451
 
# File 'opal/lib/opal/parser.rb', line 446

def new_call(recv, meth, args = nil)
  args ||= []
  sexp = s(:call, recv, value(meth).to_sym, s(:arglist, *args))
  sexp.source = source(meth)
  sexp
end

#new_class(start, path, sup, body, endt) ⇒ Object 



255
256
257
258
259
 
# File 'opal/lib/opal/parser.rb', line 255

def new_class(start, path, sup, body, endt)
  sexp = s(:class, path, sup, body)
  sexp.source = source(start)
  sexp
end

#new_colon2(lhs, tok, name) ⇒ Object 



156
157
158
159
160
 
# File 'opal/lib/opal/parser.rb', line 156

def new_colon2(lhs, tok, name)
  sexp = s(:colon2, lhs, value(name).to_sym)
  sexp.source = source(tok)
  sexp
end

#new_colon3(tok, name) ⇒ Object 



162
163
164
 
# File 'opal/lib/opal/parser.rb', line 162

def new_colon3(tok, name)
  s1(:colon3, value(name).to_sym, source(name))
end

#new_compstmt(block) ⇒ Object 



216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
 
# File 'opal/lib/opal/parser.rb', line 216

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

  if comp && comp.type == :begin && comp.size == 2
    result = comp[1]
  else
    result = comp
  end

  result
end

#new_const(tok) ⇒ Object 



152
153
154
 
# File 'opal/lib/opal/parser.rb', line 152

def new_const(tok)
  s1(:const, value(tok).to_sym, source(tok))
end

#new_cvar(tok) ⇒ Object 



148
149
150
 
# File 'opal/lib/opal/parser.rb', line 148

def new_cvar(tok)
  s1(:cvar, value(tok).to_sym, source(tok))
end

#new_def(kw, recv, name, args, body, end_tok) ⇒ Object 



246
247
248
249
250
251
252
253
 
# File 'opal/lib/opal/parser.rb', line 246

def new_def(kw, recv, name, args, body, end_tok)
  body = s(:block, body) if body.type != :block
  body << s(:nil) if body.size == 1

  sexp = s(:def, recv, value(name).to_sym, args, body)
  sexp.source = source(kw)
  sexp
end

#new_dsym(str) ⇒ Object 



655
656
657
658
659
660
661
662
663
664
665
666
667
668
 
# File 'opal/lib/opal/parser.rb', line 655

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

  str
end

#new_erange(beg, op, finish) ⇒ Object 



479
480
481
482
483
 
# File 'opal/lib/opal/parser.rb', line 479

def new_erange(beg, op, finish)
  sexp = s(:erange, beg, finish)
  sexp.source = source(op)
  sexp
end

#new_evstr(str) ⇒ Object 



670
671
672
 
# File 'opal/lib/opal/parser.rb', line 670

def new_evstr(str)
  s(:evstr, str)
end

#new_false(tok) ⇒ Object 



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

def new_false(tok)
  s0(:false, source(tok))
end

#new_float(tok) ⇒ Object 



136
137
138
 
# File 'opal/lib/opal/parser.rb', line 136

def new_float(tok)
  s1(:float, value(tok), source(tok))
end

#new_gettable(ref) ⇒ Object 



578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
 
# File 'opal/lib/opal/parser.rb', line 578

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])
        when :cdecl
          s(:const, ref[1])
        else
          raise "Bad new_gettable ref: #{ref.type}"
        end

  res.source = ref.source
  res
end

#new_gvar(tok) ⇒ Object 



144
145
146
 
# File 'opal/lib/opal/parser.rb', line 144

def new_gvar(tok)
  s1(:gvar, value(tok).to_sym, source(tok))
end

#new_hash(open, assocs, close) ⇒ Object 



311
312
313
314
315
 
# File 'opal/lib/opal/parser.rb', line 311

def new_hash(open, assocs, close)
  sexp = s(:hash, *assocs)
  sexp.source = source(open)
  sexp
end

#new_ident(tok) ⇒ Object 



128
129
130
 
# File 'opal/lib/opal/parser.rb', line 128

def new_ident(tok)
  s1(:identifier, value(tok).to_sym, source(tok))
end

#new_if(if_tok, expr, stmt, tail) ⇒ Object 



280
281
282
283
284
 
# File 'opal/lib/opal/parser.rb', line 280

def new_if(if_tok, expr, stmt, tail)
  sexp = s(:if, expr, stmt, tail)
  sexp.source = source(if_tok)
  sexp
end

#new_int(tok) ⇒ Object 



132
133
134
 
# File 'opal/lib/opal/parser.rb', line 132

def new_int(tok)
  s1(:int, value(tok), source(tok))
end

#new_irange(beg, op, finish) ⇒ Object 



473
474
475
476
477
 
# File 'opal/lib/opal/parser.rb', line 473

def new_irange(beg, op, finish)
  sexp = s(:irange, beg, finish)
  sexp.source = source(op)
  sexp
end

#new_iter(args, body) ⇒ Object 



273
274
275
276
277
278
 
# File 'opal/lib/opal/parser.rb', line 273

def new_iter(args, body)
  args ||= nil
  s = s(:iter, args)
  s << body if body
  s
end

#new_ivar(tok) ⇒ Object 



140
141
142
 
# File 'opal/lib/opal/parser.rb', line 140

def new_ivar(tok)
  s1(:ivar, value(tok).to_sym, source(tok))
end

#new_kwarg(name) ⇒ Object 



382
383
384
385
 
# File 'opal/lib/opal/parser.rb', line 382

def new_kwarg(name)
  scope.add_local name[1]
  s(:kwarg, name[1])
end

#new_kwoptarg(name, val) ⇒ Object 



387
388
389
390
 
# File 'opal/lib/opal/parser.rb', line 387

def new_kwoptarg(name, val)
  scope.add_local name[1]
  s(:kwoptarg, name[1], val)
end

#new_kwrestarg(name = nil) ⇒ Object 



392
393
394
395
396
397
398
399
400
401
 
# File 'opal/lib/opal/parser.rb', line 392

def new_kwrestarg(name = nil)
  result = s(:kwrestarg)

  if name
    scope.add_local name[0].to_sym
    result << name[0].to_sym
  end

  result
end

#new_module(kw, path, body, end_tok) ⇒ Object 



267
268
269
270
271
 
# File 'opal/lib/opal/parser.rb', line 267

def new_module(kw, path, body, end_tok)
  sexp = s(:module, path, body)
  sexp.source = source(kw)
  sexp
end

#new_next(kw, args = []) ⇒ Object 



200
201
202
203
204
205
206
207
208
 
# File 'opal/lib/opal/parser.rb', line 200

def new_next(kw, args=[])
  if args.length == 1
    sexp = s(:next, args[0])
  else
    sexp = s(:next, s(:array, *args))
  end

  sexp
end

#new_nil(tok) ⇒ Object 



104
105
106
 
# File 'opal/lib/opal/parser.rb', line 104

def new_nil(tok)
  s0(:nil, source(tok))
end

#new_not(kw, expr) ⇒ Object 



317
318
319
 
# File 'opal/lib/opal/parser.rb', line 317

def new_not(kw, expr)
  s1(:not, expr, source(kw))
end

#new_op_asgn(op, lhs, rhs) ⇒ Object 



503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
 
# File 'opal/lib/opal/parser.rb', line 503

def new_op_asgn(op, lhs, rhs)
  case value(op).to_sym
  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, [rhs])

  end

  result
end

#new_op_asgn1(lhs, args, op, rhs) ⇒ Object 



520
521
522
523
524
525
 
# File 'opal/lib/opal/parser.rb', line 520

def new_op_asgn1(lhs, args, op, rhs)
  arglist = s(:arglist, *args)
  sexp = s(:op_asgn1, lhs, arglist, value(op), rhs)
  sexp.source = source(op)
  sexp
end

#new_or(lhs, tok, rhs) ⇒ Object 



467
468
469
470
471
 
# File 'opal/lib/opal/parser.rb', line 467

def new_or(lhs, tok, rhs)
  sexp = s(:or, lhs, rhs)
  sexp.source = source(tok)
  sexp
end

#new_paren(open, expr, close) ⇒ Object 



321
322
323
324
325
326
327
 
# File 'opal/lib/opal/parser.rb', line 321

def new_paren(open, expr, close)
  if expr.nil? or expr == [:block]
    s1(:paren, s0(:nil, source(open)), source(open))
  else
    s1(:paren, expr, source(open))
  end
end

#new_regexp(reg, ending) ⇒ Object 



692
693
694
695
696
697
698
699
700
701
702
703
 
# File 'opal/lib/opal/parser.rb', line 692

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

#new_rescue_mod(kw, expr, resc) ⇒ Object 



298
299
300
301
302
 
# File 'opal/lib/opal/parser.rb', line 298

def new_rescue_mod(kw, expr, resc)
  sexp = s(:rescue_mod, expr, resc)
  sexp.source = source(kw)
  sexp
end

#new_return(kw, args = nil) ⇒ Object 



188
189
190
191
192
193
194
195
196
197
198
 
# File 'opal/lib/opal/parser.rb', line 188

def new_return(kw, args=nil)
  if args.nil?
    sexp = s(:return)
  elsif args.length == 1
    sexp = s(:return, args[0])
  else
    sexp = s(:return, s(:array, *args))
  end

  sexp
end

#new_sclass(kw, expr, body, end_tok) ⇒ Object 



261
262
263
264
265
 
# File 'opal/lib/opal/parser.rb', line 261

def new_sclass(kw, expr, body, end_tok)
  sexp = s(:sclass, expr, body)
  sexp.source = source(kw)
  sexp
end

#new_self(tok) ⇒ Object 



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

def new_self(tok)
  s0(:self, source(tok))
end

#new_splat(tok, value) ⇒ Object 



499
500
501
 
# File 'opal/lib/opal/parser.rb', line 499

def new_splat(tok, value)
  s1(:splat, value, source(tok))
end

#new_str(str) ⇒ Object 



674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
 
# File 'opal/lib/opal/parser.rb', line 674

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_str_content(tok) ⇒ Object 



720
721
722
 
# File 'opal/lib/opal/parser.rb', line 720

def new_str_content(tok)
  s1(:str, value(tok), source(tok))
end

#new_super(kw, args) ⇒ Object 



626
627
628
629
630
631
632
633
634
635
 
# File 'opal/lib/opal/parser.rb', line 626

def new_super(kw, args)
  if args.nil?
    sexp = s(:super, nil)
  else
    sexp = s(:super, s(:arglist, *args))
  end

  sexp.source = source(kw)
  sexp
end

#new_sym(tok) ⇒ Object 



166
167
168
 
# File 'opal/lib/opal/parser.rb', line 166

def new_sym(tok)
  s1(:sym, value(tok).to_sym, source(tok))
end

#new_true(tok) ⇒ Object 



112
113
114
 
# File 'opal/lib/opal/parser.rb', line 112

def new_true(tok)
  s0(:true, source(tok))
end

#new_unary_call(op, recv) ⇒ Object 



457
458
459
 
# File 'opal/lib/opal/parser.rb', line 457

def new_unary_call(op, recv)
  new_call(recv, op, [])
end

#new_until(kw, test, body) ⇒ Object 



292
293
294
295
296
 
# File 'opal/lib/opal/parser.rb', line 292

def new_until(kw, test, body)
  sexp = s(:until, test, body)
  sexp.source = source(kw)
  sexp
end

#new_var_ref(ref) ⇒ Object 



598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
 
# File 'opal/lib/opal/parser.rb', line 598

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
    result = if scope.has_local? ref[1]
              s(:lvar, ref[1])
            else
              s(:call, nil, ref[1], s(:arglist))
            end

    result.source = ref.source
    result
  else
    raise "Bad var_ref type: #{ref.type}"
  end
end

#new_while(kw, test, body) ⇒ Object 



286
287
288
289
290
 
# File 'opal/lib/opal/parser.rb', line 286

def new_while(kw, test, body)
  sexp = s(:while, test, body)
  sexp.source = source(kw)
  sexp
end

#new_xstr(start_t, str, end_t) ⇒ Object 



642
643
644
645
646
647
648
649
650
651
652
653
 
# File 'opal/lib/opal/parser.rb', line 642

def new_xstr(start_t, str, end_t)
  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.source = source(start_t)

  str
end

#new_yield(args) ⇒ Object 



637
638
639
640
 
# File 'opal/lib/opal/parser.rb', line 637

def new_yield(args)
  args ||= []
  s(:yield, *args)
end

#next_token ⇒ Object 



59
60
61
 
# File 'opal/lib/opal/parser.rb', line 59

def next_token
  @lexer.next_token
end

#on_error(t, val, vstack) ⇒ Object 



80
81
82
 
# File 'opal/lib/opal/parser.rb', line 80

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

#op_to_setter(op) ⇒ Object 



527
528
529
 
# File 'opal/lib/opal/parser.rb', line 527

def op_to_setter(op)
  "#{value(op)}=".to_sym
end

#parse(source, file = '(string)') ⇒ Opal::Sexp

Parse the given ruby source. An optional file can be given which is used for file context for some ruby expressions (e.g. __FILE__).

If the given ruby code is not valid ruby, then an error will be raised.

Parameters:

  • source (String) —

    ruby source code

  • file (String) (defaults to: '(string)') —

    filename for context of ruby code

Returns:

  • (Opal::Sexp) —

    sexp expression tree representing ruby code



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'opal/lib/opal/parser.rb', line 32

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

  self.parse_to_sexp
rescue => error
  message = [
    nil,
    error.message,
    "Source: #{@file}:#{lexer.line}:#{lexer.column}",
    source.split("\n")[lexer.line-1],
    '~'*(lexer.column-1) + '^',
  ].join("\n")

  raise error.class, message
end

#parse_to_sexp ⇒ Object 



51
52
53
54
55
56
57
 
# File 'opal/lib/opal/parser.rb', line 51

def parse_to_sexp
  push_scope
  result = do_parse
  pop_scope

  result
end

#pop_scope ⇒ Object 



75
76
77
78
 
# File 'opal/lib/opal/parser.rb', line 75

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

#push_scope(type = nil) ⇒ Object 



67
68
69
70
71
72
73
 
# File 'opal/lib/opal/parser.rb', line 67

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

#s(*parts) ⇒ Object 



63
64
65
 
# File 'opal/lib/opal/parser.rb', line 63

def s(*parts)
  Sexp.new(parts)
end

#s0(type, source) ⇒ Object 



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

def s0(type, source)
  sexp = s(type)
  sexp.source = source
  sexp
end

#s1(type, first, source) ⇒ Object 



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

def s1(type, first, source)
  sexp = s(type, first)
  sexp.source = source
  sexp
end

#source(tok) ⇒ Object 



88
89
90
 
# File 'opal/lib/opal/parser.rb', line 88

def source(tok)
  tok ? tok[1] : nil
end

#str_append(str, str2) ⇒ Object 



705
706
707
708
709
710
711
712
713
714
715
716
717
718
 
# File 'opal/lib/opal/parser.rb', line 705

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

#value(tok) ⇒ Object 



84
85
86
 
# File 'opal/lib/opal/parser.rb', line 84

def value(tok)
  tok[0]
end