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_call_args",
"rparen",
"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 



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

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

#_reduce_103(val, _values, result) ⇒ Object

reduce 102 omitted



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

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

#_reduce_104(val, _values, result) ⇒ Object 



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

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

#_reduce_105(val, _values, result) ⇒ Object 



3522
3523
3524
3525
3526
 
# File 'opal/lib/opal/parser/grammar.rb', line 3522

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

#_reduce_107(val, _values, result) ⇒ Object

reduce 106 omitted



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

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

#_reduce_108(val, _values, result) ⇒ Object 



3536
3537
3538
3539
3540
 
# File 'opal/lib/opal/parser/grammar.rb', line 3536

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

#_reduce_11(val, _values, result) ⇒ Object 



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

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

#_reduce_12(val, _values, result) ⇒ Object 



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

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

#_reduce_13(val, _values, result) ⇒ Object 



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

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

#_reduce_14(val, _values, result) ⇒ Object 



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

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

#_reduce_15(val, _values, result) ⇒ Object 



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

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



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

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 



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

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

#_reduce_183(val, _values, result) ⇒ Object

reduce 182 omitted



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

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

#_reduce_184(val, _values, result) ⇒ Object 



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

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 



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

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

#_reduce_186(val, _values, result) ⇒ Object 



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

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 



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

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 



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

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



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

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

#_reduce_194(val, _values, result) ⇒ Object 



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

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

#_reduce_195(val, _values, result) ⇒ Object 



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

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

#_reduce_196(val, _values, result) ⇒ Object 



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

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

#_reduce_197(val, _values, result) ⇒ Object 



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

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

#_reduce_198(val, _values, result) ⇒ Object 



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

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

#_reduce_199(val, _values, result) ⇒ Object 



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

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



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

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

#_reduce_20(val, _values, result) ⇒ Object 



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

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

#_reduce_200(val, _values, result) ⇒ Object 



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

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

#_reduce_201(val, _values, result) ⇒ Object 



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

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 



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

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 



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

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 



3799
3800
3801
3802
3803
3804
3805
3806
3807
3808
3809
3810
 
# File 'opal/lib/opal/parser/grammar.rb', line 3799

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 



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

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

#_reduce_206(val, _values, result) ⇒ Object 



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

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

#_reduce_207(val, _values, result) ⇒ Object 



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

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

#_reduce_208(val, _values, result) ⇒ Object 



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

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

#_reduce_209(val, _values, result) ⇒ Object 



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

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

#_reduce_21(val, _values, result) ⇒ Object 



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

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

#_reduce_210(val, _values, result) ⇒ Object 



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

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

#_reduce_211(val, _values, result) ⇒ Object 



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

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

#_reduce_212(val, _values, result) ⇒ Object 



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

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

#_reduce_213(val, _values, result) ⇒ Object 



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

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

#_reduce_214(val, _values, result) ⇒ Object 



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

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

#_reduce_215(val, _values, result) ⇒ Object 



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

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 



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

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

#_reduce_217(val, _values, result) ⇒ Object 



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

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 



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

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

#_reduce_219(val, _values, result) ⇒ Object 



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

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

#_reduce_22(val, _values, result) ⇒ Object 



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

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

#_reduce_220(val, _values, result) ⇒ Object 



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

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

#_reduce_221(val, _values, result) ⇒ Object 



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

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

#_reduce_222(val, _values, result) ⇒ Object 



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

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

#_reduce_223(val, _values, result) ⇒ Object 



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

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

#_reduce_224(val, _values, result) ⇒ Object 



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

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

#_reduce_225(val, _values, result) ⇒ Object 



3934
3935
3936
3937
3938
 
# File 'opal/lib/opal/parser/grammar.rb', line 3934

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



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

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

#_reduce_229(val, _values, result) ⇒ Object 



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

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

#_reduce_23(val, _values, result) ⇒ Object 



3159
3160
3161
3162
3163
 
# File 'opal/lib/opal/parser/grammar.rb', line 3159

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

#_reduce_230(val, _values, result) ⇒ Object 



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

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

#_reduce_231(val, _values, result) ⇒ Object 



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

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

#_reduce_232(val, _values, result) ⇒ Object 



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

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

#_reduce_233(val, _values, result) ⇒ Object 



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

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

#_reduce_235(val, _values, result) ⇒ Object

reduce 234 omitted



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

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

#_reduce_237(val, _values, result) ⇒ Object

reduce 236 omitted



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

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

#_reduce_239(val, _values, result) ⇒ Object

reduce 238 omitted



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

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

#_reduce_240(val, _values, result) ⇒ Object 



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

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

#_reduce_241(val, _values, result) ⇒ Object 



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

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

#_reduce_242(val, _values, result) ⇒ Object 



4018
4019
4020
4021
4022
 
# File 'opal/lib/opal/parser/grammar.rb', line 4018

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

#_reduce_243(val, _values, result) ⇒ Object 



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

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

#_reduce_244(val, _values, result) ⇒ Object 



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

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

#_reduce_245(val, _values, result) ⇒ Object 



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

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

#_reduce_246(val, _values, result) ⇒ Object 



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

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

#_reduce_249(val, _values, result) ⇒ Object

reduce 248 omitted



4056
4057
4058
4059
4060
 
# File 'opal/lib/opal/parser/grammar.rb', line 4056

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

#_reduce_25(val, _values, result) ⇒ Object

reduce 24 omitted



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

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

#_reduce_250(val, _values, result) ⇒ Object 



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

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

#_reduce_252(val, _values, result) ⇒ Object

reduce 251 omitted



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

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

#_reduce_253(val, _values, result) ⇒ Object 



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

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

#_reduce_254(val, _values, result) ⇒ Object 



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

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

#_reduce_255(val, _values, result) ⇒ Object 



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

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

#_reduce_256(val, _values, result) ⇒ Object 



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

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

#_reduce_257(val, _values, result) ⇒ Object 



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

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

#_reduce_258(val, _values, result) ⇒ Object 



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

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

#_reduce_259(val, _values, result) ⇒ Object 



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

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

#_reduce_26(val, _values, result) ⇒ Object 



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

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

#_reduce_260(val, _values, result) ⇒ Object 



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

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

#_reduce_261(val, _values, result) ⇒ Object 



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

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

#_reduce_262(val, _values, result) ⇒ Object 



4132
4133
4134
4135
4136
4137
 
# File 'opal/lib/opal/parser/grammar.rb', line 4132

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

#_reduce_263(val, _values, result) ⇒ Object 



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

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

#_reduce_27(val, _values, result) ⇒ Object 



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

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

#_reduce_273(val, _values, result) ⇒ Object

reduce 272 omitted



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

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

#_reduce_274(val, _values, result) ⇒ Object 



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

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

#_reduce_275(val, _values, result) ⇒ Object 



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

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

#_reduce_276(val, _values, result) ⇒ Object 



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

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

#_reduce_277(val, _values, result) ⇒ Object 



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

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

#_reduce_278(val, _values, result) ⇒ Object 



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

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

#_reduce_279(val, _values, result) ⇒ Object 



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

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

#_reduce_280(val, _values, result) ⇒ Object 



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

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

#_reduce_281(val, _values, result) ⇒ Object 



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

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

#_reduce_282(val, _values, result) ⇒ Object 



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

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

#_reduce_283(val, _values, result) ⇒ Object 



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

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

#_reduce_284(val, _values, result) ⇒ Object 



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

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

#_reduce_285(val, _values, result) ⇒ Object 



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

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

#_reduce_286(val, _values, result) ⇒ Object 



4241
4242
4243
4244
4245
 
# File 'opal/lib/opal/parser/grammar.rb', line 4241

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

#_reduce_287(val, _values, result) ⇒ Object 



4247
4248
4249
4250
4251
 
# File 'opal/lib/opal/parser/grammar.rb', line 4247

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

#_reduce_288(val, _values, result) ⇒ Object 



4253
4254
4255
4256
4257
 
# File 'opal/lib/opal/parser/grammar.rb', line 4253

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

#_reduce_289(val, _values, result) ⇒ Object 



4259
4260
4261
4262
4263
4264
 
# File 'opal/lib/opal/parser/grammar.rb', line 4259

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

#_reduce_29(val, _values, result) ⇒ Object

reduce 28 omitted



3187
3188
3189
3190
3191
 
# File 'opal/lib/opal/parser/grammar.rb', line 3187

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

reduce 290 omitted



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

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

#_reduce_292(val, _values, result) ⇒ Object 



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

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

#_reduce_293(val, _values, result) ⇒ Object 



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

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

#_reduce_294(val, _values, result) ⇒ Object 



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

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

#_reduce_295(val, _values, result) ⇒ Object 



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

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

#_reduce_296(val, _values, result) ⇒ Object 



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

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

#_reduce_297(val, _values, result) ⇒ Object 



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

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

#_reduce_298(val, _values, result) ⇒ Object 



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

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

#_reduce_299(val, _values, result) ⇒ Object 



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

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

#_reduce_3(val, _values, result) ⇒ Object 



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

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

#_reduce_300(val, _values, result) ⇒ Object 



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

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

#_reduce_301(val, _values, result) ⇒ Object 



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

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

#_reduce_302(val, _values, result) ⇒ Object 



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

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

#_reduce_303(val, _values, result) ⇒ Object 



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

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

#_reduce_304(val, _values, result) ⇒ Object 



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

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

#_reduce_305(val, _values, result) ⇒ Object 



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

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

#_reduce_306(val, _values, result) ⇒ Object 



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

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

#_reduce_307(val, _values, result) ⇒ Object 



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

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

#_reduce_308(val, _values, result) ⇒ Object 



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

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

#_reduce_309(val, _values, result) ⇒ Object 



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

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

#_reduce_310(val, _values, result) ⇒ Object 



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

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

#_reduce_311(val, _values, result) ⇒ Object 



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

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

#_reduce_312(val, _values, result) ⇒ Object 



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

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

#_reduce_313(val, _values, result) ⇒ Object 



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

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

#_reduce_314(val, _values, result) ⇒ Object 



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

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

#_reduce_315(val, _values, result) ⇒ Object 



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

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

#_reduce_316(val, _values, result) ⇒ Object 



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

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

#_reduce_317(val, _values, result) ⇒ Object 



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

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

#_reduce_318(val, _values, result) ⇒ Object 



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

def _reduce_318(val, _values, result)
                      push_scope
                      lexer.lex_state = :expr_endfn
                    
    result
end

#_reduce_319(val, _values, result) ⇒ Object 



4443
4444
4445
4446
4447
4448
 
# File 'opal/lib/opal/parser/grammar.rb', line 4443

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

#_reduce_320(val, _values, result) ⇒ Object 



4450
4451
4452
4453
4454
 
# File 'opal/lib/opal/parser/grammar.rb', line 4450

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

#_reduce_321(val, _values, result) ⇒ Object 



4456
4457
4458
4459
4460
 
# File 'opal/lib/opal/parser/grammar.rb', line 4456

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

#_reduce_322(val, _values, result) ⇒ Object 



4462
4463
4464
4465
4466
 
# File 'opal/lib/opal/parser/grammar.rb', line 4462

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

#_reduce_33(val, _values, result) ⇒ Object

reduce 32 omitted



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

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

#_reduce_332(val, _values, result) ⇒ Object

reduce 331 omitted



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

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

#_reduce_333(val, _values, result) ⇒ Object 



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

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

#_reduce_334(val, _values, result) ⇒ Object 



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

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

#_reduce_337(val, _values, result) ⇒ Object

reduce 336 omitted



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

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

#_reduce_338(val, _values, result) ⇒ Object 



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

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

#_reduce_339(val, _values, result) ⇒ Object 



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

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

#_reduce_34(val, _values, result) ⇒ Object 



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

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

#_reduce_340(val, _values, result) ⇒ Object 



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

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

#_reduce_342(val, _values, result) ⇒ Object

reduce 341 omitted



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

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

#_reduce_343(val, _values, result) ⇒ Object 



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

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

#_reduce_344(val, _values, result) ⇒ Object 



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

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

#_reduce_345(val, _values, result) ⇒ Object 



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

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

#_reduce_347(val, _values, result) ⇒ Object

reduce 346 omitted



4563
4564
4565
4566
4567
 
# File 'opal/lib/opal/parser/grammar.rb', line 4563

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

#_reduce_348(val, _values, result) ⇒ Object 



4569
4570
4571
4572
4573
 
# File 'opal/lib/opal/parser/grammar.rb', line 4569

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

#_reduce_349(val, _values, result) ⇒ Object 



4575
4576
4577
4578
4579
 
# File 'opal/lib/opal/parser/grammar.rb', line 4575

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

#_reduce_35(val, _values, result) ⇒ Object 



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

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

#_reduce_350(val, _values, result) ⇒ Object 



4581
4582
4583
4584
4585
 
# File 'opal/lib/opal/parser/grammar.rb', line 4581

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

#_reduce_351(val, _values, result) ⇒ Object 



4587
4588
4589
4590
4591
 
# File 'opal/lib/opal/parser/grammar.rb', line 4587

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

#_reduce_352(val, _values, result) ⇒ Object 



4593
4594
4595
4596
4597
 
# File 'opal/lib/opal/parser/grammar.rb', line 4593

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

#_reduce_353(val, _values, result) ⇒ Object 



4599
4600
4601
4602
4603
 
# File 'opal/lib/opal/parser/grammar.rb', line 4599

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

#_reduce_354(val, _values, result) ⇒ Object 



4605
4606
4607
4608
4609
 
# File 'opal/lib/opal/parser/grammar.rb', line 4605

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

#_reduce_355(val, _values, result) ⇒ Object 



4611
4612
4613
4614
4615
 
# File 'opal/lib/opal/parser/grammar.rb', line 4611

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

#_reduce_356(val, _values, result) ⇒ Object 



4617
4618
4619
4620
4621
 
# File 'opal/lib/opal/parser/grammar.rb', line 4617

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

#_reduce_357(val, _values, result) ⇒ Object 



4623
4624
4625
4626
4627
 
# File 'opal/lib/opal/parser/grammar.rb', line 4623

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

#_reduce_358(val, _values, result) ⇒ Object 



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

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

#_reduce_359(val, _values, result) ⇒ Object 



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

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

#_reduce_360(val, _values, result) ⇒ Object 



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

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

#_reduce_361(val, _values, result) ⇒ Object 



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

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

#_reduce_362(val, _values, result) ⇒ Object 



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

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

#_reduce_363(val, _values, result) ⇒ Object 



4660
4661
4662
4663
4664
4665
 
# File 'opal/lib/opal/parser/grammar.rb', line 4660

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

#_reduce_364(val, _values, result) ⇒ Object 



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

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

#_reduce_367(val, _values, result) ⇒ Object

reduce 366 omitted



4678
4679
4680
4681
4682
 
# File 'opal/lib/opal/parser/grammar.rb', line 4678

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

#_reduce_368(val, _values, result) ⇒ Object 



4684
4685
4686
4687
4688
 
# File 'opal/lib/opal/parser/grammar.rb', line 4684

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

#_reduce_369(val, _values, result) ⇒ Object 



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

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

#_reduce_370(val, _values, result) ⇒ Object 



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

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

#_reduce_371(val, _values, result) ⇒ Object 



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

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

#_reduce_372(val, _values, result) ⇒ Object 



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

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

#_reduce_373(val, _values, result) ⇒ Object 



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

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

#_reduce_374(val, _values, result) ⇒ Object 



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

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

#_reduce_375(val, _values, result) ⇒ Object 



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

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

#_reduce_376(val, _values, result) ⇒ Object 



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

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

#_reduce_377(val, _values, result) ⇒ Object 



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

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

#_reduce_378(val, _values, result) ⇒ Object 



4748
4749
4750
4751
4752
 
# File 'opal/lib/opal/parser/grammar.rb', line 4748

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

#_reduce_379(val, _values, result) ⇒ Object 



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

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

#_reduce_38(val, _values, result) ⇒ Object

reduce 37 omitted



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

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

#_reduce_380(val, _values, result) ⇒ Object 



4762
4763
4764
4765
4766
 
# File 'opal/lib/opal/parser/grammar.rb', line 4762

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

#_reduce_382(val, _values, result) ⇒ Object

reduce 381 omitted



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

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



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

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

#_reduce_384(val, _values, result) ⇒ Object 



4785
4786
4787
4788
4789
 
# File 'opal/lib/opal/parser/grammar.rb', line 4785

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

#_reduce_387(val, _values, result) ⇒ Object

reduce 386 omitted



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

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

#_reduce_388(val, _values, result) ⇒ Object 



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

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

#_reduce_389(val, _values, result) ⇒ Object 



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

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

#_reduce_39(val, _values, result) ⇒ Object 



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

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

#_reduce_394(val, _values, result) ⇒ Object

reduce 393 omitted



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

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

#_reduce_396(val, _values, result) ⇒ Object

reduce 395 omitted



4829
4830
4831
4832
4833
 
# File 'opal/lib/opal/parser/grammar.rb', line 4829

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

#_reduce_397(val, _values, result) ⇒ Object 



4835
4836
4837
4838
4839
 
# File 'opal/lib/opal/parser/grammar.rb', line 4835

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

#_reduce_398(val, _values, result) ⇒ Object 



4841
4842
4843
4844
4845
 
# File 'opal/lib/opal/parser/grammar.rb', line 4841

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

#_reduce_399(val, _values, result) ⇒ Object 



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

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

#_reduce_4(val, _values, result) ⇒ Object 



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

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

#_reduce_40(val, _values, result) ⇒ Object 



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

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

#_reduce_400(val, _values, result) ⇒ Object 



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

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

#_reduce_401(val, _values, result) ⇒ Object 



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

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

#_reduce_402(val, _values, result) ⇒ Object 



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

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

#_reduce_403(val, _values, result) ⇒ Object 



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

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

#_reduce_404(val, _values, result) ⇒ Object 



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

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

#_reduce_405(val, _values, result) ⇒ Object 



4885
4886
4887
4888
4889
 
# File 'opal/lib/opal/parser/grammar.rb', line 4885

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

#_reduce_406(val, _values, result) ⇒ Object 



4891
4892
4893
4894
4895
 
# File 'opal/lib/opal/parser/grammar.rb', line 4891

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

#_reduce_407(val, _values, result) ⇒ Object 



4897
4898
4899
4900
4901
 
# File 'opal/lib/opal/parser/grammar.rb', line 4897

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

#_reduce_408(val, _values, result) ⇒ Object 



4903
4904
4905
4906
4907
 
# File 'opal/lib/opal/parser/grammar.rb', line 4903

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

#_reduce_409(val, _values, result) ⇒ Object 



4909
4910
4911
4912
4913
 
# File 'opal/lib/opal/parser/grammar.rb', line 4909

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

#_reduce_41(val, _values, result) ⇒ Object 



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

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

#_reduce_410(val, _values, result) ⇒ Object 



4915
4916
4917
4918
4919
 
# File 'opal/lib/opal/parser/grammar.rb', line 4915

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

#_reduce_411(val, _values, result) ⇒ Object 



4921
4922
4923
4924
4925
 
# File 'opal/lib/opal/parser/grammar.rb', line 4921

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

#_reduce_412(val, _values, result) ⇒ Object 



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

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

#_reduce_413(val, _values, result) ⇒ Object 



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

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

#_reduce_414(val, _values, result) ⇒ Object 



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

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

#_reduce_415(val, _values, result) ⇒ Object 



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

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

#_reduce_416(val, _values, result) ⇒ Object 



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

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

#_reduce_417(val, _values, result) ⇒ Object 



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

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

#_reduce_418(val, _values, result) ⇒ Object 



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

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



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

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

#_reduce_420(val, _values, result) ⇒ Object 



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

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

#_reduce_421(val, _values, result) ⇒ Object 



4990
4991
4992
4993
4994
 
# File 'opal/lib/opal/parser/grammar.rb', line 4990

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

#_reduce_422(val, _values, result) ⇒ Object 



4996
4997
4998
4999
5000
 
# File 'opal/lib/opal/parser/grammar.rb', line 4996

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

#_reduce_424(val, _values, result) ⇒ Object

reduce 423 omitted



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

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

#_reduce_425(val, _values, result) ⇒ Object 



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

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

#_reduce_430(val, _values, result) ⇒ Object

reduce 429 omitted



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

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

#_reduce_431(val, _values, result) ⇒ Object 



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

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

#_reduce_432(val, _values, result) ⇒ Object 



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

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

#_reduce_433(val, _values, result) ⇒ Object 



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

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

#_reduce_434(val, _values, result) ⇒ Object 



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

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

#_reduce_435(val, _values, result) ⇒ Object 



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

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

#_reduce_436(val, _values, result) ⇒ Object 



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

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

#_reduce_437(val, _values, result) ⇒ Object 



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

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

#_reduce_438(val, _values, result) ⇒ Object 



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

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

#_reduce_439(val, _values, result) ⇒ Object 



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

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

#_reduce_440(val, _values, result) ⇒ Object 



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

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

#_reduce_441(val, _values, result) ⇒ Object 



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

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

#_reduce_442(val, _values, result) ⇒ Object 



5097
5098
5099
5100
5101
 
# File 'opal/lib/opal/parser/grammar.rb', line 5097

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

#_reduce_443(val, _values, result) ⇒ Object 



5103
5104
5105
5106
5107
 
# File 'opal/lib/opal/parser/grammar.rb', line 5103

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

#_reduce_444(val, _values, result) ⇒ Object 



5109
5110
5111
5112
5113
 
# File 'opal/lib/opal/parser/grammar.rb', line 5109

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

#_reduce_445(val, _values, result) ⇒ Object 



5115
5116
5117
5118
5119
 
# File 'opal/lib/opal/parser/grammar.rb', line 5115

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

#_reduce_446(val, _values, result) ⇒ Object 



5121
5122
5123
5124
5125
 
# File 'opal/lib/opal/parser/grammar.rb', line 5121

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

#_reduce_447(val, _values, result) ⇒ Object 



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

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

#_reduce_448(val, _values, result) ⇒ Object 



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

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

#_reduce_449(val, _values, result) ⇒ Object 



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

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

#_reduce_450(val, _values, result) ⇒ Object 



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

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

#_reduce_452(val, _values, result) ⇒ Object

reduce 451 omitted



5153
5154
5155
5156
5157
 
# File 'opal/lib/opal/parser/grammar.rb', line 5153

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

#_reduce_453(val, _values, result) ⇒ Object 



5159
5160
5161
5162
5163
 
# File 'opal/lib/opal/parser/grammar.rb', line 5159

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

#_reduce_454(val, _values, result) ⇒ Object 



5165
5166
5167
5168
5169
 
# File 'opal/lib/opal/parser/grammar.rb', line 5165

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

#_reduce_455(val, _values, result) ⇒ Object 



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

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

#_reduce_456(val, _values, result) ⇒ Object 



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

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

#_reduce_459(val, _values, result) ⇒ Object

reduce 458 omitted



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

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

#_reduce_46(val, _values, result) ⇒ Object

reduce 45 omitted



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

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

#_reduce_460(val, _values, result) ⇒ Object 



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

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

#_reduce_461(val, _values, result) ⇒ Object 



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

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

#_reduce_462(val, _values, result) ⇒ Object 



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

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

#_reduce_463(val, _values, result) ⇒ Object 



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

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

#_reduce_464(val, _values, result) ⇒ Object 



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

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

#_reduce_465(val, _values, result) ⇒ Object 



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

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

#_reduce_466(val, _values, result) ⇒ Object 



5232
5233
5234
5235
5236
 
# File 'opal/lib/opal/parser/grammar.rb', line 5232

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

#_reduce_467(val, _values, result) ⇒ Object 



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

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

#_reduce_468(val, _values, result) ⇒ Object 



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

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

#_reduce_469(val, _values, result) ⇒ Object 



5250
5251
5252
5253
5254
 
# File 'opal/lib/opal/parser/grammar.rb', line 5250

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

#_reduce_47(val, _values, result) ⇒ Object 



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

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

#_reduce_470(val, _values, result) ⇒ Object 



5256
5257
5258
5259
5260
 
# File 'opal/lib/opal/parser/grammar.rb', line 5256

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

#_reduce_471(val, _values, result) ⇒ Object 



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

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

#_reduce_472(val, _values, result) ⇒ Object 



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

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

#_reduce_473(val, _values, result) ⇒ Object 



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

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

#_reduce_474(val, _values, result) ⇒ Object 



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

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

#_reduce_475(val, _values, result) ⇒ Object 



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

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

#_reduce_476(val, _values, result) ⇒ Object 



5292
5293
5294
5295
5296
 
# File 'opal/lib/opal/parser/grammar.rb', line 5292

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

#_reduce_477(val, _values, result) ⇒ Object 



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

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

#_reduce_478(val, _values, result) ⇒ Object 



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

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

#_reduce_479(val, _values, result) ⇒ Object 



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

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

#_reduce_48(val, _values, result) ⇒ Object 



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

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

#_reduce_480(val, _values, result) ⇒ Object 



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

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

#_reduce_482(val, _values, result) ⇒ Object

reduce 481 omitted



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

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

#_reduce_483(val, _values, result) ⇒ Object 



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

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

#_reduce_484(val, _values, result) ⇒ Object 



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

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

#_reduce_485(val, _values, result) ⇒ Object 



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

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

#_reduce_486(val, _values, result) ⇒ Object 



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

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

#_reduce_487(val, _values, result) ⇒ Object 



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

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

#_reduce_488(val, _values, result) ⇒ Object 



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

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

#_reduce_491(val, _values, result) ⇒ Object

reduce 490 omitted



5371
5372
5373
5374
5375
 
# File 'opal/lib/opal/parser/grammar.rb', line 5371

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

#_reduce_493(val, _values, result) ⇒ Object

reduce 492 omitted



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

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

#_reduce_494(val, _values, result) ⇒ Object 



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

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

#_reduce_5(val, _values, result) ⇒ Object 



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

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

#_reduce_500(val, _values, result) ⇒ Object

reduce 499 omitted



5402
5403
5404
5405
5406
 
# File 'opal/lib/opal/parser/grammar.rb', line 5402

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

#_reduce_501(val, _values, result) ⇒ Object 



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

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

#_reduce_502(val, _values, result) ⇒ Object 



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

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

#_reduce_503(val, _values, result) ⇒ Object 



5421
5422
5423
5424
5425
 
# File 'opal/lib/opal/parser/grammar.rb', line 5421

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

#_reduce_504(val, _values, result) ⇒ Object 



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

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

#_reduce_507(val, _values, result) ⇒ Object

reduce 506 omitted



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

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

#_reduce_508(val, _values, result) ⇒ Object 



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

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

#_reduce_511(val, _values, result) ⇒ Object

reduce 510 omitted



5454
5455
5456
5457
5458
 
# File 'opal/lib/opal/parser/grammar.rb', line 5454

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

#_reduce_512(val, _values, result) ⇒ Object 



5460
5461
5462
5463
5464
 
# File 'opal/lib/opal/parser/grammar.rb', line 5460

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

#_reduce_513(val, _values, result) ⇒ Object 



5466
5467
5468
5469
5470
 
# File 'opal/lib/opal/parser/grammar.rb', line 5466

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

#_reduce_514(val, _values, result) ⇒ Object 



5472
5473
5474
5475
5476
 
# File 'opal/lib/opal/parser/grammar.rb', line 5472

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

#_reduce_515(val, _values, result) ⇒ Object 



5478
5479
5480
5481
5482
 
# File 'opal/lib/opal/parser/grammar.rb', line 5478

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

#_reduce_516(val, _values, result) ⇒ Object 



5484
5485
5486
5487
5488
 
# File 'opal/lib/opal/parser/grammar.rb', line 5484

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

#_reduce_517(val, _values, result) ⇒ Object 



5490
5491
5492
5493
5494
 
# File 'opal/lib/opal/parser/grammar.rb', line 5490

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

#_reduce_518(val, _values, result) ⇒ Object 



5496
5497
5498
5499
5500
 
# File 'opal/lib/opal/parser/grammar.rb', line 5496

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

#_reduce_519(val, _values, result) ⇒ Object 



5502
5503
5504
5505
5506
 
# File 'opal/lib/opal/parser/grammar.rb', line 5502

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

#_reduce_520(val, _values, result) ⇒ Object 



5508
5509
5510
5511
5512
 
# File 'opal/lib/opal/parser/grammar.rb', line 5508

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

#_reduce_521(val, _values, result) ⇒ Object 



5514
5515
5516
5517
5518
 
# File 'opal/lib/opal/parser/grammar.rb', line 5514

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

#_reduce_53(val, _values, result) ⇒ Object

reduce 52 omitted



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

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

#_reduce_545(val, _values, result) ⇒ Object

reduce 544 omitted



5566
5567
5568
5569
5570
 
# File 'opal/lib/opal/parser/grammar.rb', line 5566

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

#_reduce_55(val, _values, result) ⇒ Object

reduce 54 omitted



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

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



3295
3296
3297
3298
3299
 
# File 'opal/lib/opal/parser/grammar.rb', line 3295

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



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

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

#_reduce_60(val, _values, result) ⇒ Object 



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

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

#_reduce_61(val, _values, result) ⇒ Object 



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

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

#_reduce_62(val, _values, result) ⇒ Object 



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

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

#_reduce_63(val, _values, result) ⇒ Object 



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

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

#_reduce_64(val, _values, result) ⇒ Object 



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

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

#_reduce_65(val, _values, result) ⇒ Object 



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

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

#_reduce_66(val, _values, result) ⇒ Object 



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

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

#_reduce_67(val, _values, result) ⇒ Object 



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

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

#_reduce_69(val, _values, result) ⇒ Object

reduce 68 omitted



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

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

#_reduce_7(val, _values, result) ⇒ Object

reduce 6 omitted



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

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

#_reduce_71(val, _values, result) ⇒ Object

reduce 70 omitted



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

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

#_reduce_72(val, _values, result) ⇒ Object 



3373
3374
3375
3376
3377
 
# File 'opal/lib/opal/parser/grammar.rb', line 3373

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

#_reduce_74(val, _values, result) ⇒ Object

reduce 73 omitted



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

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

#_reduce_75(val, _values, result) ⇒ Object 



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

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

#_reduce_76(val, _values, result) ⇒ Object 



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

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

#_reduce_77(val, _values, result) ⇒ Object 



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

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

#_reduce_8(val, _values, result) ⇒ Object 



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

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



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

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

#_reduce_81(val, _values, result) ⇒ Object 



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

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 



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

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

#_reduce_88(val, _values, result) ⇒ Object

reduce 87 omitted



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

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

#_reduce_89(val, _values, result) ⇒ Object 



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

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

#_reduce_9(val, _values, result) ⇒ Object 



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

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

#_reduce_90(val, _values, result) ⇒ Object 



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

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

#_reduce_91(val, _values, result) ⇒ Object 



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

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

#_reduce_92(val, _values, result) ⇒ Object 



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

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

#_reduce_93(val, _values, result) ⇒ Object 



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

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

#_reduce_94(val, _values, result) ⇒ Object 



3474
3475
3476
3477
3478
 
# File 'opal/lib/opal/parser/grammar.rb', line 3474

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

#_reduce_97(val, _values, result) ⇒ Object

reduce 96 omitted



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

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

#_reduce_98(val, _values, result) ⇒ Object 



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

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

#_reduce_99(val, _values, result) ⇒ Object 



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

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

#_reduce_none(val, _values, result) ⇒ Object 



5572
5573
5574
 
# File 'opal/lib/opal/parser/grammar.rb', line 5572

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