Class: Opal::Parser

Inherits:
Racc::Parser
  • Object
show all
Defined in:
lib/opal/parser.rb,
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 collapse

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",
"\"[email protected]\"",
"\"[email protected]\"",
"$start",
"program",
"top_compstmt",
"top_stmts",
"opt_terms",
"top_stmt",
"terms",
"stmt",
"bodystmt",
"compstmt",
"opt_rescue",
"opt_else",
"opt_ensure",
"stmts",
"fitem",
"undef_list",
"expr_value",
"lhs",
"command_call",
"mlhs",
"var_lhs",
"primary_value",
"aref_args",
"backref",
"mrhs",
"arg_value",
"expr",
"@1",
"arg",
"command",
"block_command",
"call_args",
"block_call",
"operation2",
"command_args",
"cmd_brace_block",
"opt_block_var",
"operation",
"mlhs_basic",
"mlhs_entry",
"mlhs_head",
"mlhs_item",
"mlhs_node",
"mlhs_post",
"variable",
"cname",
"cpath",
"fname",
"op",
"reswords",
"symbol",
"opt_nl",
"primary",
"none",
"args",
"trailer",
"assocs",
"paren_args",
"opt_paren_args",
"opt_block_arg",
"block_arg",
"call_args2",
"open_args",
"@2",
"literal",
"strings",
"xstring",
"regexp",
"words",
"awords",
"var_ref",
"assoc_list",
"brace_block",
"method_call",
"lambda",
"then",
"if_tail",
"do",
"case_body",
"for_var",
"superclass",
"term",
"f_arglist",
"singleton",
"dot_or_colon",
"@3",
"@4",
"@5",
"@6",
"@7",
"@8",
"@9",
"@10",
"@11",
"@12",
"@13",
"@14",
"@15",
"@16",
"@17",
"f_larglist",
"lambda_body",
"block_param",
"f_block_optarg",
"f_block_opt",
"block_args_tail",
"f_block_arg",
"opt_block_args_tail",
"f_arg",
"f_rest_arg",
"do_block",
"@18",
"operation3",
"@19",
"@20",
"cases",
"@21",
"exc_list",
"exc_var",
"numeric",
"dsym",
"string",
"string1",
"string_contents",
"xstring_contents",
"word_list",
"word",
"string_content",
"qword_list",
"string_dvar",
"@22",
"@23",
"sym",
"f_args",
"kwrest_mark",
"f_kwrest",
"f_label",
"f_kw",
"f_kwarg",
"args_tail",
"opt_f_block_arg",
"opt_args_tail",
"f_optarg",
"f_norm_arg",
"f_bad_arg",
"f_arg_item",
"f_margs",
"f_marg",
"f_marg_list",
"f_opt",
"restarg_mark",
"blkarg_mark",
"assoc" ]
Racc_debug_parser =
false

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#fileObject (readonly)

Returns the value of attribute file


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

def file
  @file
end

#lexerObject (readonly)

Returns the value of attribute lexer


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

def lexer
  @lexer
end

#scopeObject (readonly)

Returns the value of attribute scope


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

def scope
  @scope
end

Instance Method Details

#_reduce_10(val, _values, result) ⇒ Object


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

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

#_reduce_103(val, _values, result) ⇒ Object

reduce 102 omitted


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

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

#_reduce_104(val, _values, result) ⇒ Object


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

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

#_reduce_105(val, _values, result) ⇒ Object


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

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

#_reduce_107(val, _values, result) ⇒ Object

reduce 106 omitted


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

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

#_reduce_108(val, _values, result) ⇒ Object


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

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

#_reduce_11(val, _values, result) ⇒ Object


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

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

#_reduce_12(val, _values, result) ⇒ Object


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

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

#_reduce_13(val, _values, result) ⇒ Object


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

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

#_reduce_14(val, _values, result) ⇒ Object


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

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

#_reduce_15(val, _values, result) ⇒ Object


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

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

#_reduce_17(val, _values, result) ⇒ Object

reduce 16 omitted


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

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

#_reduce_18(val, _values, result) ⇒ Object


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

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

#_reduce_183(val, _values, result) ⇒ Object

reduce 182 omitted


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

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

#_reduce_184(val, _values, result) ⇒ Object


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

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

#_reduce_185(val, _values, result) ⇒ Object


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

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

#_reduce_186(val, _values, result) ⇒ Object


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

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

#_reduce_187(val, _values, result) ⇒ Object


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

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

#_reduce_19(val, _values, result) ⇒ Object


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

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

#_reduce_193(val, _values, result) ⇒ Object

reduce 192 omitted


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

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

#_reduce_194(val, _values, result) ⇒ Object


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

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

#_reduce_195(val, _values, result) ⇒ Object


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

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

#_reduce_196(val, _values, result) ⇒ Object


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

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

#_reduce_197(val, _values, result) ⇒ Object


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

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

#_reduce_198(val, _values, result) ⇒ Object


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

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

#_reduce_199(val, _values, result) ⇒ Object


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

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

#_reduce_2(val, _values, result) ⇒ Object

reduce 1 omitted


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

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

#_reduce_20(val, _values, result) ⇒ Object


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

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

#_reduce_200(val, _values, result) ⇒ Object


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

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

#_reduce_201(val, _values, result) ⇒ Object


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

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

#_reduce_202(val, _values, result) ⇒ Object


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

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

#_reduce_203(val, _values, result) ⇒ Object


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

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

#_reduce_204(val, _values, result) ⇒ Object


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

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

#_reduce_205(val, _values, result) ⇒ Object


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

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

#_reduce_206(val, _values, result) ⇒ Object


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

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

#_reduce_207(val, _values, result) ⇒ Object


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

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

#_reduce_208(val, _values, result) ⇒ Object


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

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

#_reduce_209(val, _values, result) ⇒ Object


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

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

#_reduce_21(val, _values, result) ⇒ Object


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

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

#_reduce_210(val, _values, result) ⇒ Object


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

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

#_reduce_211(val, _values, result) ⇒ Object


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

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

#_reduce_212(val, _values, result) ⇒ Object


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

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

#_reduce_213(val, _values, result) ⇒ Object


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

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

#_reduce_214(val, _values, result) ⇒ Object


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

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

#_reduce_215(val, _values, result) ⇒ Object


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

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

#_reduce_216(val, _values, result) ⇒ Object


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

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

#_reduce_217(val, _values, result) ⇒ Object


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

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

#_reduce_218(val, _values, result) ⇒ Object


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

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

#_reduce_219(val, _values, result) ⇒ Object


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

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

#_reduce_22(val, _values, result) ⇒ Object


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

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

#_reduce_220(val, _values, result) ⇒ Object


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

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

#_reduce_221(val, _values, result) ⇒ Object


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

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

#_reduce_222(val, _values, result) ⇒ Object


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

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

#_reduce_223(val, _values, result) ⇒ Object


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

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

#_reduce_224(val, _values, result) ⇒ Object


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

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

#_reduce_225(val, _values, result) ⇒ Object


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

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

#_reduce_228(val, _values, result) ⇒ Object

reduce 227 omitted


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

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

#_reduce_229(val, _values, result) ⇒ Object


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

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

#_reduce_23(val, _values, result) ⇒ Object


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

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

#_reduce_230(val, _values, result) ⇒ Object


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

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

#_reduce_231(val, _values, result) ⇒ Object


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

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

#_reduce_232(val, _values, result) ⇒ Object


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

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

#_reduce_233(val, _values, result) ⇒ Object


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

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

#_reduce_234(val, _values, result) ⇒ Object


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

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

#_reduce_237(val, _values, result) ⇒ Object

reduce 236 omitted


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

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

#_reduce_239(val, _values, result) ⇒ Object

reduce 238 omitted


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

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

#_reduce_240(val, _values, result) ⇒ Object


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

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

#_reduce_241(val, _values, result) ⇒ Object


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

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

#_reduce_242(val, _values, result) ⇒ Object


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

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

#_reduce_243(val, _values, result) ⇒ Object


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

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

#_reduce_246(val, _values, result) ⇒ Object

reduce 245 omitted


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

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

#_reduce_247(val, _values, result) ⇒ Object


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

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

#_reduce_249(val, _values, result) ⇒ Object

reduce 248 omitted


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

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

#_reduce_25(val, _values, result) ⇒ Object

reduce 24 omitted


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

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

#_reduce_250(val, _values, result) ⇒ Object


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

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

#_reduce_251(val, _values, result) ⇒ Object


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

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

#_reduce_252(val, _values, result) ⇒ Object


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

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

#_reduce_253(val, _values, result) ⇒ Object


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

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

#_reduce_254(val, _values, result) ⇒ Object


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

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

#_reduce_255(val, _values, result) ⇒ Object


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

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

#_reduce_256(val, _values, result) ⇒ Object


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

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

#_reduce_257(val, _values, result) ⇒ Object


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

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

#_reduce_258(val, _values, result) ⇒ Object


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

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

#_reduce_259(val, _values, result) ⇒ Object


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

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

#_reduce_26(val, _values, result) ⇒ Object


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

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

#_reduce_260(val, _values, result) ⇒ Object


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

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

#_reduce_27(val, _values, result) ⇒ Object


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

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

#_reduce_270(val, _values, result) ⇒ Object

reduce 269 omitted


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

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

#_reduce_271(val, _values, result) ⇒ Object


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

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

#_reduce_272(val, _values, result) ⇒ Object


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

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

#_reduce_273(val, _values, result) ⇒ Object


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

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

#_reduce_274(val, _values, result) ⇒ Object


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

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

#_reduce_275(val, _values, result) ⇒ Object


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

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

#_reduce_276(val, _values, result) ⇒ Object


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

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

#_reduce_277(val, _values, result) ⇒ Object


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

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

#_reduce_278(val, _values, result) ⇒ Object


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

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

#_reduce_279(val, _values, result) ⇒ Object


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

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

#_reduce_280(val, _values, result) ⇒ Object


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

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

#_reduce_281(val, _values, result) ⇒ Object


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

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

#_reduce_282(val, _values, result) ⇒ Object


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

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

#_reduce_283(val, _values, result) ⇒ Object


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

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

#_reduce_284(val, _values, result) ⇒ Object


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

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

#_reduce_285(val, _values, result) ⇒ Object


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

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

#_reduce_286(val, _values, result) ⇒ Object


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

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

#_reduce_288(val, _values, result) ⇒ Object

reduce 287 omitted


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

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

#_reduce_289(val, _values, result) ⇒ Object


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

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

#_reduce_29(val, _values, result) ⇒ Object

reduce 28 omitted


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

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

#_reduce_290(val, _values, result) ⇒ Object


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

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

#_reduce_291(val, _values, result) ⇒ Object


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

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

#_reduce_292(val, _values, result) ⇒ Object


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

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

#_reduce_293(val, _values, result) ⇒ Object


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

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

#_reduce_294(val, _values, result) ⇒ Object


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

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

#_reduce_295(val, _values, result) ⇒ Object


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

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

#_reduce_296(val, _values, result) ⇒ Object


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

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

#_reduce_297(val, _values, result) ⇒ Object


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

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

#_reduce_298(val, _values, result) ⇒ Object


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

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

#_reduce_299(val, _values, result) ⇒ Object


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

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

#_reduce_3(val, _values, result) ⇒ Object


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

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

#_reduce_300(val, _values, result) ⇒ Object


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

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

#_reduce_301(val, _values, result) ⇒ Object


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

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

#_reduce_302(val, _values, result) ⇒ Object


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

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

#_reduce_303(val, _values, result) ⇒ Object


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

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

#_reduce_304(val, _values, result) ⇒ Object


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

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

#_reduce_305(val, _values, result) ⇒ Object


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

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

#_reduce_306(val, _values, result) ⇒ Object


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

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

#_reduce_307(val, _values, result) ⇒ Object


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

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

#_reduce_308(val, _values, result) ⇒ Object


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

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

#_reduce_309(val, _values, result) ⇒ Object


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

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

#_reduce_310(val, _values, result) ⇒ Object


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

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

#_reduce_311(val, _values, result) ⇒ Object


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

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

#_reduce_312(val, _values, result) ⇒ Object


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

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

#_reduce_313(val, _values, result) ⇒ Object


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

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

#_reduce_314(val, _values, result) ⇒ Object


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

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

#_reduce_315(val, _values, result) ⇒ Object


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

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

#_reduce_316(val, _values, result) ⇒ Object


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

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

#_reduce_317(val, _values, result) ⇒ Object


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

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

#_reduce_318(val, _values, result) ⇒ Object


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

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

#_reduce_319(val, _values, result) ⇒ Object


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

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

#_reduce_329(val, _values, result) ⇒ Object

reduce 328 omitted


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

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

#_reduce_33(val, _values, result) ⇒ Object

reduce 32 omitted


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

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

#_reduce_330(val, _values, result) ⇒ Object


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

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

#_reduce_331(val, _values, result) ⇒ Object


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

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

#_reduce_334(val, _values, result) ⇒ Object

reduce 333 omitted


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

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

#_reduce_335(val, _values, result) ⇒ Object


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

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

#_reduce_336(val, _values, result) ⇒ Object


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

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

#_reduce_337(val, _values, result) ⇒ Object


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

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

#_reduce_339(val, _values, result) ⇒ Object

reduce 338 omitted


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

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

#_reduce_34(val, _values, result) ⇒ Object


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

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

#_reduce_340(val, _values, result) ⇒ Object


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

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

#_reduce_341(val, _values, result) ⇒ Object


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

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

#_reduce_342(val, _values, result) ⇒ Object


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

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

#_reduce_344(val, _values, result) ⇒ Object

reduce 343 omitted


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

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

#_reduce_345(val, _values, result) ⇒ Object


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

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

#_reduce_346(val, _values, result) ⇒ Object


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

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

#_reduce_347(val, _values, result) ⇒ Object


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

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

#_reduce_348(val, _values, result) ⇒ Object


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

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

#_reduce_349(val, _values, result) ⇒ Object


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

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

#_reduce_35(val, _values, result) ⇒ Object


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

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

#_reduce_350(val, _values, result) ⇒ Object


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

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

#_reduce_351(val, _values, result) ⇒ Object


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

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

#_reduce_352(val, _values, result) ⇒ Object


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

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

#_reduce_353(val, _values, result) ⇒ Object


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

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

#_reduce_354(val, _values, result) ⇒ Object


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

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

#_reduce_355(val, _values, result) ⇒ Object


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

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

#_reduce_356(val, _values, result) ⇒ Object


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

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

#_reduce_357(val, _values, result) ⇒ Object


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

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

#_reduce_358(val, _values, result) ⇒ Object


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

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

#_reduce_359(val, _values, result) ⇒ Object


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

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

#_reduce_360(val, _values, result) ⇒ Object


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

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

#_reduce_361(val, _values, result) ⇒ Object


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

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

#_reduce_364(val, _values, result) ⇒ Object

reduce 363 omitted


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

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

#_reduce_365(val, _values, result) ⇒ Object


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

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

#_reduce_366(val, _values, result) ⇒ Object


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

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

#_reduce_367(val, _values, result) ⇒ Object


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

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

#_reduce_368(val, _values, result) ⇒ Object


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

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

#_reduce_369(val, _values, result) ⇒ Object


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

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

#_reduce_370(val, _values, result) ⇒ Object


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

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

#_reduce_371(val, _values, result) ⇒ Object


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

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

#_reduce_372(val, _values, result) ⇒ Object


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

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

#_reduce_373(val, _values, result) ⇒ Object


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

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

#_reduce_374(val, _values, result) ⇒ Object


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

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

#_reduce_375(val, _values, result) ⇒ Object


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

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

#_reduce_376(val, _values, result) ⇒ Object


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

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

#_reduce_377(val, _values, result) ⇒ Object


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

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

#_reduce_379(val, _values, result) ⇒ Object

reduce 378 omitted


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

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

#_reduce_38(val, _values, result) ⇒ Object

reduce 37 omitted


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

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

#_reduce_380(val, _values, result) ⇒ Object


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

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

#_reduce_381(val, _values, result) ⇒ Object


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

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

#_reduce_384(val, _values, result) ⇒ Object

reduce 383 omitted


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

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

#_reduce_385(val, _values, result) ⇒ Object


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

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

#_reduce_386(val, _values, result) ⇒ Object


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

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

#_reduce_39(val, _values, result) ⇒ Object


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

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

#_reduce_391(val, _values, result) ⇒ Object

reduce 390 omitted


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

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

#_reduce_393(val, _values, result) ⇒ Object

reduce 392 omitted


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

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

#_reduce_394(val, _values, result) ⇒ Object


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

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

#_reduce_395(val, _values, result) ⇒ Object


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

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

#_reduce_396(val, _values, result) ⇒ Object


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

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

#_reduce_397(val, _values, result) ⇒ Object


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

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

#_reduce_398(val, _values, result) ⇒ Object


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

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

#_reduce_399(val, _values, result) ⇒ Object


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

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

#_reduce_4(val, _values, result) ⇒ Object


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

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

#_reduce_40(val, _values, result) ⇒ Object


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

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

#_reduce_400(val, _values, result) ⇒ Object


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

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

#_reduce_401(val, _values, result) ⇒ Object


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

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

#_reduce_402(val, _values, result) ⇒ Object


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

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

#_reduce_403(val, _values, result) ⇒ Object


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

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

#_reduce_404(val, _values, result) ⇒ Object


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

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

#_reduce_405(val, _values, result) ⇒ Object


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

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

#_reduce_406(val, _values, result) ⇒ Object


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

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

#_reduce_407(val, _values, result) ⇒ Object


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

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

#_reduce_408(val, _values, result) ⇒ Object


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

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

#_reduce_409(val, _values, result) ⇒ Object


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

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

#_reduce_41(val, _values, result) ⇒ Object


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

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

#_reduce_410(val, _values, result) ⇒ Object


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

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

#_reduce_411(val, _values, result) ⇒ Object


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

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

#_reduce_412(val, _values, result) ⇒ Object


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

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

#_reduce_413(val, _values, result) ⇒ Object


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

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

#_reduce_414(val, _values, result) ⇒ Object


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

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

#_reduce_415(val, _values, result) ⇒ Object


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

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

#_reduce_416(val, _values, result) ⇒ Object


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

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

#_reduce_417(val, _values, result) ⇒ Object


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

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

#_reduce_418(val, _values, result) ⇒ Object


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

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

#_reduce_419(val, _values, result) ⇒ Object


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

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

#_reduce_421(val, _values, result) ⇒ Object

reduce 420 omitted


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

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

#_reduce_422(val, _values, result) ⇒ Object


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

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

#_reduce_427(val, _values, result) ⇒ Object

reduce 426 omitted


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

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

#_reduce_428(val, _values, result) ⇒ Object


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

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

#_reduce_429(val, _values, result) ⇒ Object


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

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

#_reduce_430(val, _values, result) ⇒ Object


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

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

#_reduce_431(val, _values, result) ⇒ Object


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

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

#_reduce_432(val, _values, result) ⇒ Object


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

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

#_reduce_433(val, _values, result) ⇒ Object


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

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

#_reduce_434(val, _values, result) ⇒ Object


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

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

#_reduce_435(val, _values, result) ⇒ Object


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

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

#_reduce_436(val, _values, result) ⇒ Object


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

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

#_reduce_437(val, _values, result) ⇒ Object


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

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

#_reduce_438(val, _values, result) ⇒ Object


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

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

#_reduce_439(val, _values, result) ⇒ Object


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

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

#_reduce_440(val, _values, result) ⇒ Object


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

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

#_reduce_441(val, _values, result) ⇒ Object


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

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

#_reduce_442(val, _values, result) ⇒ Object


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

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

#_reduce_443(val, _values, result) ⇒ Object


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

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

#_reduce_444(val, _values, result) ⇒ Object


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

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

#_reduce_445(val, _values, result) ⇒ Object


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

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

#_reduce_446(val, _values, result) ⇒ Object


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

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

#_reduce_447(val, _values, result) ⇒ Object


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

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

#_reduce_449(val, _values, result) ⇒ Object

reduce 448 omitted


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

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

#_reduce_450(val, _values, result) ⇒ Object


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

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

#_reduce_451(val, _values, result) ⇒ Object


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

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

#_reduce_452(val, _values, result) ⇒ Object


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

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

#_reduce_453(val, _values, result) ⇒ Object


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

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

#_reduce_456(val, _values, result) ⇒ Object

reduce 455 omitted


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

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

#_reduce_457(val, _values, result) ⇒ Object


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

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

#_reduce_458(val, _values, result) ⇒ Object


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

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

#_reduce_459(val, _values, result) ⇒ Object


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

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

#_reduce_46(val, _values, result) ⇒ Object

reduce 45 omitted


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

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

#_reduce_460(val, _values, result) ⇒ Object


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

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

#_reduce_461(val, _values, result) ⇒ Object


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

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

#_reduce_462(val, _values, result) ⇒ Object


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

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

#_reduce_463(val, _values, result) ⇒ Object


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

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

#_reduce_464(val, _values, result) ⇒ Object


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

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

#_reduce_465(val, _values, result) ⇒ Object


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

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

#_reduce_466(val, _values, result) ⇒ Object


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

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

#_reduce_467(val, _values, result) ⇒ Object


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

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

#_reduce_468(val, _values, result) ⇒ Object


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

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

#_reduce_469(val, _values, result) ⇒ Object


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

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

#_reduce_47(val, _values, result) ⇒ Object


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

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

#_reduce_470(val, _values, result) ⇒ Object


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

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

#_reduce_471(val, _values, result) ⇒ Object


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

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

#_reduce_472(val, _values, result) ⇒ Object


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

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

#_reduce_473(val, _values, result) ⇒ Object


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

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

#_reduce_474(val, _values, result) ⇒ Object


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

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

#_reduce_475(val, _values, result) ⇒ Object


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

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

#_reduce_476(val, _values, result) ⇒ Object


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

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

#_reduce_477(val, _values, result) ⇒ Object


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

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

#_reduce_479(val, _values, result) ⇒ Object

reduce 478 omitted


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

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

#_reduce_48(val, _values, result) ⇒ Object


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

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

#_reduce_480(val, _values, result) ⇒ Object


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

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

#_reduce_481(val, _values, result) ⇒ Object


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

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

#_reduce_482(val, _values, result) ⇒ Object


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

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

#_reduce_483(val, _values, result) ⇒ Object


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

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

#_reduce_484(val, _values, result) ⇒ Object


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

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

#_reduce_485(val, _values, result) ⇒ Object


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

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

#_reduce_488(val, _values, result) ⇒ Object

reduce 487 omitted


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

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

#_reduce_490(val, _values, result) ⇒ Object

reduce 489 omitted


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

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

#_reduce_491(val, _values, result) ⇒ Object


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

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

#_reduce_497(val, _values, result) ⇒ Object

reduce 496 omitted


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

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

#_reduce_498(val, _values, result) ⇒ Object


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

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

#_reduce_499(val, _values, result) ⇒ Object


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

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

#_reduce_5(val, _values, result) ⇒ Object


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

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

#_reduce_500(val, _values, result) ⇒ Object


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

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

#_reduce_501(val, _values, result) ⇒ Object


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

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

#_reduce_504(val, _values, result) ⇒ Object

reduce 503 omitted


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

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

#_reduce_505(val, _values, result) ⇒ Object


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

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

#_reduce_508(val, _values, result) ⇒ Object

reduce 507 omitted


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

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

#_reduce_509(val, _values, result) ⇒ Object


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

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

#_reduce_510(val, _values, result) ⇒ Object


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

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

#_reduce_511(val, _values, result) ⇒ Object


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

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

#_reduce_512(val, _values, result) ⇒ Object


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

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

#_reduce_513(val, _values, result) ⇒ Object


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

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

#_reduce_514(val, _values, result) ⇒ Object


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

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

#_reduce_515(val, _values, result) ⇒ Object


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

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

#_reduce_516(val, _values, result) ⇒ Object


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

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

#_reduce_517(val, _values, result) ⇒ Object


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

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

#_reduce_518(val, _values, result) ⇒ Object


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

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

#_reduce_53(val, _values, result) ⇒ Object

reduce 52 omitted


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

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

#_reduce_542(val, _values, result) ⇒ Object

reduce 541 omitted


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

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

#_reduce_55(val, _values, result) ⇒ Object

reduce 54 omitted


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

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

#_reduce_57(val, _values, result) ⇒ Object

reduce 56 omitted


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

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

#_reduce_59(val, _values, result) ⇒ Object

reduce 58 omitted


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

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

#_reduce_60(val, _values, result) ⇒ Object


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

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

#_reduce_61(val, _values, result) ⇒ Object


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

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

#_reduce_62(val, _values, result) ⇒ Object


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

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

#_reduce_63(val, _values, result) ⇒ Object


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

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

#_reduce_64(val, _values, result) ⇒ Object


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

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

#_reduce_65(val, _values, result) ⇒ Object


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

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

#_reduce_66(val, _values, result) ⇒ Object


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

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

#_reduce_67(val, _values, result) ⇒ Object


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

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

#_reduce_69(val, _values, result) ⇒ Object

reduce 68 omitted


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

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

#_reduce_7(val, _values, result) ⇒ Object

reduce 6 omitted


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

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

#_reduce_71(val, _values, result) ⇒ Object

reduce 70 omitted


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

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

#_reduce_72(val, _values, result) ⇒ Object


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

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

#_reduce_74(val, _values, result) ⇒ Object

reduce 73 omitted


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

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

#_reduce_75(val, _values, result) ⇒ Object


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

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

#_reduce_76(val, _values, result) ⇒ Object


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

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

#_reduce_77(val, _values, result) ⇒ Object


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

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

#_reduce_8(val, _values, result) ⇒ Object


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

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

#_reduce_80(val, _values, result) ⇒ Object

reduce 79 omitted


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

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

#_reduce_81(val, _values, result) ⇒ Object


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

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

#_reduce_82(val, _values, result) ⇒ Object


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

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

#_reduce_88(val, _values, result) ⇒ Object

reduce 87 omitted


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

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

#_reduce_89(val, _values, result) ⇒ Object


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

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

#_reduce_9(val, _values, result) ⇒ Object


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

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

#_reduce_90(val, _values, result) ⇒ Object


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

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

#_reduce_91(val, _values, result) ⇒ Object


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

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

#_reduce_92(val, _values, result) ⇒ Object


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

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

#_reduce_93(val, _values, result) ⇒ Object


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

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

#_reduce_94(val, _values, result) ⇒ Object


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

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

#_reduce_97(val, _values, result) ⇒ Object

reduce 96 omitted


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

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

#_reduce_98(val, _values, result) ⇒ Object


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

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

#_reduce_99(val, _values, result) ⇒ Object


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

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

#_reduce_none(val, _values, result) ⇒ Object


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

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

#add_block_pass(arglist, block) ⇒ Object


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

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

#negate_num(sexp) ⇒ Object


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

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

#new___FILE__(tok) ⇒ Object


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

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

#new___LINE__(tok) ⇒ Object


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

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

#new_alias(kw, new, old) ⇒ Object


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

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

#new_and(lhs, tok, rhs) ⇒ Object


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

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

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


332
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
# File 'lib/opal/parser.rb', line 332

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


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

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

#new_array(start, args, finish) ⇒ Object


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

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

#new_assign(lhs, tok, rhs) ⇒ Object


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

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


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

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


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

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


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

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

#new_block(stmt = nil) ⇒ Object


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

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

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


402
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
# File 'lib/opal/parser.rb', line 402

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


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

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

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


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

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


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

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


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

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


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

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


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

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


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

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

#new_compstmt(block) ⇒ Object


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

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


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

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

#new_cvar(tok) ⇒ Object


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

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

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


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

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


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

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


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

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

#new_evstr(str) ⇒ Object


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

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

#new_false(tok) ⇒ Object


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

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

#new_float(tok) ⇒ Object


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

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

#new_gettable(ref) ⇒ Object


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

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


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

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

#new_hash(open, assocs, close) ⇒ Object


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

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

#new_ident(tok) ⇒ Object


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

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

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


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

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


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

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

#new_irange(beg, op, finish) ⇒ Object


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

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

#new_iter(args, body) ⇒ Object


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

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

#new_ivar(tok) ⇒ Object


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

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

#new_kwarg(name) ⇒ Object


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

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

#new_kwoptarg(name, val) ⇒ Object


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

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

#new_kwrestarg(name = nil) ⇒ Object


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

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


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

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

#new_next(kw, args = []) ⇒ Object


199
200
201
202
203
204
205
206
207
# File 'lib/opal/parser.rb', line 199

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


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

def new_nil(tok)
  s0(:nil, source(tok))
end

#new_not(kw, expr) ⇒ Object


316
317
318
# File 'lib/opal/parser.rb', line 316

def new_not(kw, expr)
  s1(:not, expr, source(kw))
end

#new_op_asgn(op, lhs, rhs) ⇒ Object


502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
# File 'lib/opal/parser.rb', line 502

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


519
520
521
522
523
524
# File 'lib/opal/parser.rb', line 519

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


466
467
468
469
470
# File 'lib/opal/parser.rb', line 466

def new_or(lhs, tok, rhs)
  sexp = s(:or, lhs, rhs)
  sexp.source = source(tok)
  sexp
end

#new_paren(open, expr, close) ⇒ Object


320
321
322
323
324
325
326
# File 'lib/opal/parser.rb', line 320

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


691
692
693
694
695
696
697
698
699
700
701
702
# File 'lib/opal/parser.rb', line 691

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


297
298
299
300
301
# File 'lib/opal/parser.rb', line 297

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


187
188
189
190
191
192
193
194
195
196
197
# File 'lib/opal/parser.rb', line 187

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


260
261
262
263
264
# File 'lib/opal/parser.rb', line 260

def new_sclass(kw, expr, body, end_tok)
  sexp = s(:sclass, expr, body)
  sexp.source = source(kw)
  sexp
end

#new_self(tok) ⇒ Object


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

def new_self(tok)
  s0(:self, source(tok))
end

#new_splat(tok, value) ⇒ Object


498
499
500
# File 'lib/opal/parser.rb', line 498

def new_splat(tok, value)
  s1(:splat, value, source(tok))
end

#new_str(str) ⇒ Object


673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
# File 'lib/opal/parser.rb', line 673

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


719
720
721
# File 'lib/opal/parser.rb', line 719

def new_str_content(tok)
  s1(:str, value(tok), source(tok))
end

#new_super(kw, args) ⇒ Object


625
626
627
628
629
630
631
632
633
634
# File 'lib/opal/parser.rb', line 625

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


165
166
167
# File 'lib/opal/parser.rb', line 165

def new_sym(tok)
  s1(:sym, value(tok).to_sym, source(tok))
end

#new_true(tok) ⇒ Object


111
112
113
# File 'lib/opal/parser.rb', line 111

def new_true(tok)
  s0(:true, source(tok))
end

#new_unary_call(op, recv) ⇒ Object


456
457
458
# File 'lib/opal/parser.rb', line 456

def new_unary_call(op, recv)
  new_call(recv, op, [])
end

#new_until(kw, test, body) ⇒ Object


291
292
293
294
295
# File 'lib/opal/parser.rb', line 291

def new_until(kw, test, body)
  sexp = s(:until, test, body)
  sexp.source = source(kw)
  sexp
end

#new_var_ref(ref) ⇒ Object


597
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
# File 'lib/opal/parser.rb', line 597

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


285
286
287
288
289
# File 'lib/opal/parser.rb', line 285

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


641
642
643
644
645
646
647
648
649
650
651
652
# File 'lib/opal/parser.rb', line 641

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


636
637
638
639
# File 'lib/opal/parser.rb', line 636

def new_yield(args)
  args ||= []
  s(:yield, *args)
end

#next_tokenObject


58
59
60
# File 'lib/opal/parser.rb', line 58

def next_token
  @lexer.next_token
end

#on_error(t, val, vstack) ⇒ Object


79
80
81
# File 'lib/opal/parser.rb', line 79

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


526
527
528
# File 'lib/opal/parser.rb', line 526

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
# File '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 => e
  if $DEBUG || $VERBOSE
    $stderr.puts
    $stderr.puts e
    $stderr.puts "Source: #{@file}:#{lexer.line}:#{lexer.column}"
    $stderr.puts source.split("\n")[lexer.line-1]
    $stderr.puts '~'*lexer.column + '^'
  end
  raise e
end

#parse_to_sexpObject


50
51
52
53
54
55
56
# File 'lib/opal/parser.rb', line 50

def parse_to_sexp
  push_scope
  result = do_parse
  pop_scope

  result
end

#pop_scopeObject


74
75
76
77
# File 'lib/opal/parser.rb', line 74

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

#push_scope(type = nil) ⇒ Object


66
67
68
69
70
71
72
# File 'lib/opal/parser.rb', line 66

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

#s(*parts) ⇒ Object


62
63
64
# File 'lib/opal/parser.rb', line 62

def s(*parts)
  Sexp.new(parts)
end

#s0(type, source) ⇒ Object


91
92
93
94
95
# File 'lib/opal/parser.rb', line 91

def s0(type, source)
  sexp = s(type)
  sexp.source = source
  sexp
end

#s1(type, first, source) ⇒ Object


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

def s1(type, first, source)
  sexp = s(type, first)
  sexp.source = source
  sexp
end

#source(tok) ⇒ Object


87
88
89
# File 'lib/opal/parser.rb', line 87

def source(tok)
  tok ? tok[1] : nil
end

#str_append(str, str2) ⇒ Object


704
705
706
707
708
709
710
711
712
713
714
715
716
717
# File 'lib/opal/parser.rb', line 704

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


83
84
85
# File 'lib/opal/parser.rb', line 83

def value(tok)
  tok[0]
end