Class: Opal::Parser

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

Overview

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

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

Invalid ruby code will raise an exception.

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

Constant Summary

Racc_arg = 
[
racc_action_table,
racc_action_check,
racc_action_default,
racc_action_pointer,
racc_goto_table,
racc_goto_check,
racc_goto_default,
racc_goto_pointer,
racc_nt_base,
racc_reduce_table,
racc_token_table,
racc_shift_n,
racc_reduce_n,
racc_use_result_var ]
Racc_token_to_s_table = 
[
"$end",
"error",
"kCLASS",
"kMODULE",
"kDEF",
"kUNDEF",
"kBEGIN",
"kRESCUE",
"kENSURE",
"kEND",
"kIF",
"kUNLESS",
"kTHEN",
"kELSIF",
"kELSE",
"kCASE",
"kWHEN",
"kWHILE",
"kUNTIL",
"kFOR",
"kBREAK",
"kNEXT",
"kREDO",
"kRETRY",
"kIN",
"kDO",
"kDO_COND",
"kDO_BLOCK",
"kDO_LAMBDA",
"kRETURN",
"kYIELD",
"kSUPER",
"kSELF",
"kNIL",
"kTRUE",
"kFALSE",
"kAND",
"kOR",
"kNOT",
"kIF_MOD",
"kUNLESS_MOD",
"kWHILE_MOD",
"kUNTIL_MOD",
"kRESCUE_MOD",
"kALIAS",
"kDEFINED",
"klBEGIN",
"klEND",
"k__LINE__",
"k__FILE__",
"tIDENTIFIER",
"tFID",
"tGVAR",
"tIVAR",
"tCONSTANT",
"tLABEL",
"tCVAR",
"tNTH_REF",
"tBACK_REF",
"tSTRING_CONTENT",
"tINTEGER",
"tFLOAT",
"tREGEXP_END",
"tUPLUS",
"tUMINUS",
"tPOW",
"tCMP",
"tEQ",
"tEQQ",
"tNEQ",
"tGEQ",
"tLEQ",
"tANDOP",
"tOROP",
"tMATCH",
"tNMATCH",
"tJSDOT",
"tDOT",
"tDOT2",
"tDOT3",
"tAREF",
"tASET",
"tLSHFT",
"tRSHFT",
"tCOLON2",
"tCOLON3",
"tOP_ASGN",
"tASSOC",
"tLPAREN",
"tLPAREN2",
"tRPAREN",
"tLPAREN_ARG",
"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",
"tJSLBRACK",
"tDSTAR",
"tLABEL_END",
"tEQL",
"tLOWEST",
"\"-@NUM\"",
"\"+@NUM\"",
"$start",
"program",
"top_compstmt",
"top_stmts",
"opt_terms",
"top_stmt",
"terms",
"stmt",
"bodystmt",
"compstmt",
"opt_rescue",
"opt_else",
"opt_ensure",
"stmts",
"fitem",
"undef_list",
"expr_value",
"lhs",
"command_call",
"mlhs",
"var_lhs",
"primary_value",
"aref_args",
"backref",
"mrhs",
"arg_value",
"expr",
"@1",
"arg",
"command",
"block_command",
"call_args",
"block_call",
"operation2",
"command_args",
"cmd_brace_block",
"opt_block_var",
"operation",
"mlhs_basic",
"mlhs_entry",
"mlhs_head",
"mlhs_item",
"mlhs_node",
"mlhs_post",
"variable",
"cname",
"cpath",
"fname",
"op",
"reswords",
"symbol",
"opt_nl",
"primary",
"@2",
"@3",
"none",
"args",
"trailer",
"assocs",
"block_arg",
"paren_args",
"opt_call_args",
"rparen",
"opt_paren_args",
"opt_block_arg",
"call_args2",
"open_args",
"@4",
"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",
"@5",
"@6",
"@7",
"@8",
"@9",
"@10",
"@11",
"@12",
"@13",
"@14",
"@15",
"@16",
"@17",
"@18",
"@19",
"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",
"@20",
"operation3",
"@21",
"@22",
"cases",
"@23",
"exc_list",
"exc_var",
"numeric",
"dsym",
"string",
"string1",
"string_contents",
"xstring_contents",
"word_list",
"word",
"string_content",
"qword_list",
"string_dvar",
"@24",
"@25",
"sym",
"f_args",
"kwrest_mark",
"f_kwrest",
"f_label",
"f_kw",
"f_kwarg",
"args_tail",
"opt_f_block_arg",
"opt_args_tail",
"f_optarg",
"f_norm_arg",
"f_bad_arg",
"f_arg_item",
"f_margs",
"f_marg",
"f_marg_list",
"f_opt",
"restarg_mark",
"blkarg_mark",
"assoc" ]
Racc_debug_parser = 
false

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#file ⇒ Object (readonly)

Returns the value of attribute file



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

def file
  @file
end

#lexer ⇒ Object (readonly)

Returns the value of attribute lexer



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

def lexer
  @lexer
end

#scope ⇒ Object (readonly)

Returns the value of attribute scope



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

def scope
  @scope
end

Instance Method Details

#_reduce_10(val, _values, result) ⇒ Object 



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

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

#_reduce_100(val, _values, result) ⇒ Object 



3662
3663
3664
3665
3666
 
# File 'opal/lib/opal/parser/grammar.rb', line 3662

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

#_reduce_103(val, _values, result) ⇒ Object

reduce 102 omitted



3672
3673
3674
3675
3676
 
# File 'opal/lib/opal/parser/grammar.rb', line 3672

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

#_reduce_104(val, _values, result) ⇒ Object 



3678
3679
3680
3681
3682
 
# File 'opal/lib/opal/parser/grammar.rb', line 3678

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

#_reduce_105(val, _values, result) ⇒ Object 



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

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

#_reduce_109(val, _values, result) ⇒ Object

reduce 108 omitted



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

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

#_reduce_11(val, _values, result) ⇒ Object 



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

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

#_reduce_110(val, _values, result) ⇒ Object 



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

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

#_reduce_111(val, _values, result) ⇒ Object 



3710
3711
3712
3713
3714
 
# File 'opal/lib/opal/parser/grammar.rb', line 3710

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

#_reduce_113(val, _values, result) ⇒ Object

reduce 112 omitted



3718
3719
3720
3721
3722
 
# File 'opal/lib/opal/parser/grammar.rb', line 3718

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

#_reduce_114(val, _values, result) ⇒ Object 



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

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

#_reduce_12(val, _values, result) ⇒ Object 



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

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

#_reduce_13(val, _values, result) ⇒ Object 



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

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

#_reduce_14(val, _values, result) ⇒ Object 



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

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

#_reduce_15(val, _values, result) ⇒ Object 



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

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



3267
3268
3269
3270
3271
 
# File 'opal/lib/opal/parser/grammar.rb', line 3267

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 



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

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

#_reduce_189(val, _values, result) ⇒ Object

reduce 188 omitted



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

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

#_reduce_19(val, _values, result) ⇒ Object 



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

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

#_reduce_190(val, _values, result) ⇒ Object 



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

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

#_reduce_191(val, _values, result) ⇒ Object 



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

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

#_reduce_192(val, _values, result) ⇒ Object 



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

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

#_reduce_193(val, _values, result) ⇒ Object 



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

def _reduce_193(val, _values, result)
                      raise ".JS[...] #{val[4]} is not supported"
                    
    result
end

#_reduce_194(val, _values, result) ⇒ Object 



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

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

#_reduce_2(val, _values, result) ⇒ Object

reduce 1 omitted



3183
3184
3185
3186
3187
 
# File 'opal/lib/opal/parser/grammar.rb', line 3183

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

#_reduce_20(val, _values, result) ⇒ Object 



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

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

#_reduce_200(val, _values, result) ⇒ Object

reduce 199 omitted



3924
3925
3926
3927
3928
 
# File 'opal/lib/opal/parser/grammar.rb', line 3924

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

#_reduce_201(val, _values, result) ⇒ Object 



3930
3931
3932
3933
3934
 
# File 'opal/lib/opal/parser/grammar.rb', line 3930

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

#_reduce_202(val, _values, result) ⇒ Object 



3936
3937
3938
3939
3940
 
# File 'opal/lib/opal/parser/grammar.rb', line 3936

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

#_reduce_203(val, _values, result) ⇒ Object 



3942
3943
3944
3945
3946
 
# File 'opal/lib/opal/parser/grammar.rb', line 3942

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

#_reduce_204(val, _values, result) ⇒ Object 



3948
3949
3950
3951
3952
 
# File 'opal/lib/opal/parser/grammar.rb', line 3948

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

#_reduce_205(val, _values, result) ⇒ Object 



3954
3955
3956
3957
3958
 
# File 'opal/lib/opal/parser/grammar.rb', line 3954

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

#_reduce_206(val, _values, result) ⇒ Object 



3960
3961
3962
3963
3964
 
# File 'opal/lib/opal/parser/grammar.rb', line 3960

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

#_reduce_207(val, _values, result) ⇒ Object 



3966
3967
3968
3969
3970
 
# File 'opal/lib/opal/parser/grammar.rb', line 3966

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

#_reduce_208(val, _values, result) ⇒ Object 



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

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

#_reduce_209(val, _values, result) ⇒ Object 



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

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

#_reduce_21(val, _values, result) ⇒ Object 



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

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

#_reduce_210(val, _values, result) ⇒ Object 



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

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

#_reduce_211(val, _values, result) ⇒ Object 



3993
3994
3995
3996
3997
3998
3999
4000
4001
4002
4003
4004
 
# File 'opal/lib/opal/parser/grammar.rb', line 3993

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

#_reduce_212(val, _values, result) ⇒ Object 



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

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

#_reduce_213(val, _values, result) ⇒ Object 



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

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

#_reduce_214(val, _values, result) ⇒ Object 



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

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

#_reduce_215(val, _values, result) ⇒ Object 



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

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

#_reduce_216(val, _values, result) ⇒ Object 



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

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

#_reduce_217(val, _values, result) ⇒ Object 



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

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

#_reduce_218(val, _values, result) ⇒ Object 



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

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

#_reduce_219(val, _values, result) ⇒ Object 



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

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

#_reduce_22(val, _values, result) ⇒ Object 



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

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

#_reduce_220(val, _values, result) ⇒ Object 



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

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

#_reduce_221(val, _values, result) ⇒ Object 



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

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

#_reduce_222(val, _values, result) ⇒ Object 



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

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

#_reduce_223(val, _values, result) ⇒ Object 



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

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

#_reduce_224(val, _values, result) ⇒ Object 



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

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

#_reduce_225(val, _values, result) ⇒ Object 



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

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

#_reduce_226(val, _values, result) ⇒ Object 



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

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

#_reduce_227(val, _values, result) ⇒ Object 



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

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

#_reduce_228(val, _values, result) ⇒ Object 



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

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

#_reduce_229(val, _values, result) ⇒ Object 



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

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

#_reduce_23(val, _values, result) ⇒ Object 



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

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

#_reduce_230(val, _values, result) ⇒ Object 



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

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

#_reduce_231(val, _values, result) ⇒ Object 



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

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

#_reduce_232(val, _values, result) ⇒ Object 



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

def _reduce_232(val, _values, result)
 lexer.cond_push 1 
    result
end

#_reduce_233(val, _values, result) ⇒ Object 



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

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

#_reduce_234(val, _values, result) ⇒ Object 



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

def _reduce_234(val, _values, result)
                      result = new_if(val[1], val[0], val[3], val[6])
                    
    result
end

#_reduce_237(val, _values, result) ⇒ Object

reduce 236 omitted



4146
4147
4148
4149
4150
 
# File 'opal/lib/opal/parser/grammar.rb', line 4146

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

#_reduce_238(val, _values, result) ⇒ Object 



4152
4153
4154
4155
4156
 
# File 'opal/lib/opal/parser/grammar.rb', line 4152

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

#_reduce_239(val, _values, result) ⇒ Object 



4158
4159
4160
4161
4162
 
# File 'opal/lib/opal/parser/grammar.rb', line 4158

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

#_reduce_240(val, _values, result) ⇒ Object 



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

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

#_reduce_241(val, _values, result) ⇒ Object 



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

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

#_reduce_242(val, _values, result) ⇒ Object 



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

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

#_reduce_243(val, _values, result) ⇒ Object 



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

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

#_reduce_245(val, _values, result) ⇒ Object

reduce 244 omitted



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

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

#_reduce_247(val, _values, result) ⇒ Object

reduce 246 omitted



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

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

#_reduce_249(val, _values, result) ⇒ Object

reduce 248 omitted



4207
4208
4209
4210
4211
 
# File 'opal/lib/opal/parser/grammar.rb', line 4207

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

#_reduce_25(val, _values, result) ⇒ Object

reduce 24 omitted



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

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

#_reduce_250(val, _values, result) ⇒ Object 



4213
4214
4215
4216
4217
4218
 
# File 'opal/lib/opal/parser/grammar.rb', line 4213

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

#_reduce_251(val, _values, result) ⇒ Object 



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

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

#_reduce_252(val, _values, result) ⇒ Object 



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

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

#_reduce_253(val, _values, result) ⇒ Object 



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

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

#_reduce_254(val, _values, result) ⇒ Object 



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

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

#_reduce_255(val, _values, result) ⇒ Object 



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

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

#_reduce_256(val, _values, result) ⇒ Object 



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

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

#_reduce_259(val, _values, result) ⇒ Object

reduce 258 omitted



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

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

#_reduce_26(val, _values, result) ⇒ Object 



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

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

#_reduce_260(val, _values, result) ⇒ Object 



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

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

#_reduce_262(val, _values, result) ⇒ Object

reduce 261 omitted



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

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

#_reduce_263(val, _values, result) ⇒ Object 



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

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

#_reduce_264(val, _values, result) ⇒ Object 



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

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

#_reduce_265(val, _values, result) ⇒ Object 



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

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

#_reduce_266(val, _values, result) ⇒ Object 



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

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

#_reduce_267(val, _values, result) ⇒ Object 



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

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

#_reduce_268(val, _values, result) ⇒ Object 



4316
4317
4318
4319
4320
 
# File 'opal/lib/opal/parser/grammar.rb', line 4316

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

#_reduce_269(val, _values, result) ⇒ Object 



4322
4323
4324
4325
4326
 
# File 'opal/lib/opal/parser/grammar.rb', line 4322

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

#_reduce_27(val, _values, result) ⇒ Object 



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

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

#_reduce_270(val, _values, result) ⇒ Object 



4328
4329
4330
4331
4332
 
# File 'opal/lib/opal/parser/grammar.rb', line 4328

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

#_reduce_271(val, _values, result) ⇒ Object 



4334
4335
4336
4337
4338
4339
 
# File 'opal/lib/opal/parser/grammar.rb', line 4334

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

#_reduce_272(val, _values, result) ⇒ Object 



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

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

#_reduce_273(val, _values, result) ⇒ Object 



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

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

#_reduce_283(val, _values, result) ⇒ Object

reduce 282 omitted



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

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

#_reduce_284(val, _values, result) ⇒ Object 



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

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

#_reduce_285(val, _values, result) ⇒ Object 



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

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

#_reduce_286(val, _values, result) ⇒ Object 



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

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

#_reduce_287(val, _values, result) ⇒ Object 



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

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

#_reduce_288(val, _values, result) ⇒ Object 



4402
4403
4404
4405
4406
 
# File 'opal/lib/opal/parser/grammar.rb', line 4402

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

#_reduce_289(val, _values, result) ⇒ Object 



4408
4409
4410
4411
4412
 
# File 'opal/lib/opal/parser/grammar.rb', line 4408

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

#_reduce_290(val, _values, result) ⇒ Object 



4414
4415
4416
4417
4418
 
# File 'opal/lib/opal/parser/grammar.rb', line 4414

def _reduce_290(val, _values, result)
                      result = new_js_call val[0], [:[], []], val[2]
                    
    result
end

#_reduce_291(val, _values, result) ⇒ Object 



4420
4421
4422
4423
4424
 
# File 'opal/lib/opal/parser/grammar.rb', line 4420

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

#_reduce_292(val, _values, result) ⇒ Object 



4426
4427
4428
4429
4430
 
# File 'opal/lib/opal/parser/grammar.rb', line 4426

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

#_reduce_293(val, _values, result) ⇒ Object 



4432
4433
4434
4435
4436
 
# File 'opal/lib/opal/parser/grammar.rb', line 4432

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

#_reduce_294(val, _values, result) ⇒ Object 



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

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

#_reduce_295(val, _values, result) ⇒ Object 



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

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

#_reduce_296(val, _values, result) ⇒ Object 



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

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

#_reduce_297(val, _values, result) ⇒ Object 



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

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

#_reduce_298(val, _values, result) ⇒ Object 



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

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

#_reduce_299(val, _values, result) ⇒ Object 



4468
4469
4470
4471
4472
 
# File 'opal/lib/opal/parser/grammar.rb', line 4468

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

#_reduce_3(val, _values, result) ⇒ Object 



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

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

#_reduce_30(val, _values, result) ⇒ Object

reduce 29 omitted



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

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

#_reduce_300(val, _values, result) ⇒ Object 



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

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

#_reduce_302(val, _values, result) ⇒ Object

reduce 301 omitted



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

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

#_reduce_303(val, _values, result) ⇒ Object 



4490
4491
4492
4493
4494
 
# File 'opal/lib/opal/parser/grammar.rb', line 4490

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

#_reduce_304(val, _values, result) ⇒ Object 



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

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

#_reduce_305(val, _values, result) ⇒ Object 



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

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

#_reduce_306(val, _values, result) ⇒ Object 



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

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

#_reduce_307(val, _values, result) ⇒ Object 



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

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

#_reduce_308(val, _values, result) ⇒ Object 



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

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

#_reduce_309(val, _values, result) ⇒ Object 



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

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

#_reduce_310(val, _values, result) ⇒ Object 



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

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

#_reduce_311(val, _values, result) ⇒ Object 



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

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

#_reduce_312(val, _values, result) ⇒ Object 



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

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

#_reduce_313(val, _values, result) ⇒ Object 



4552
4553
4554
4555
4556
 
# File 'opal/lib/opal/parser/grammar.rb', line 4552

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

#_reduce_314(val, _values, result) ⇒ Object 



4558
4559
4560
4561
4562
 
# File 'opal/lib/opal/parser/grammar.rb', line 4558

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

#_reduce_315(val, _values, result) ⇒ Object 



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

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

#_reduce_316(val, _values, result) ⇒ Object 



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

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

#_reduce_317(val, _values, result) ⇒ Object 



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

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

#_reduce_318(val, _values, result) ⇒ Object 



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

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

#_reduce_319(val, _values, result) ⇒ Object 



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

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

#_reduce_320(val, _values, result) ⇒ Object 



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

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

#_reduce_321(val, _values, result) ⇒ Object 



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

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

#_reduce_322(val, _values, result) ⇒ Object 



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

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

#_reduce_323(val, _values, result) ⇒ Object 



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

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

#_reduce_324(val, _values, result) ⇒ Object 



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

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

#_reduce_325(val, _values, result) ⇒ Object 



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

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

#_reduce_326(val, _values, result) ⇒ Object 



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

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

#_reduce_327(val, _values, result) ⇒ Object 



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

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

#_reduce_328(val, _values, result) ⇒ Object 



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

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

#_reduce_329(val, _values, result) ⇒ Object 



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

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

#_reduce_330(val, _values, result) ⇒ Object 



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

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

#_reduce_331(val, _values, result) ⇒ Object 



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

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

#_reduce_332(val, _values, result) ⇒ Object 



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

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

#_reduce_333(val, _values, result) ⇒ Object 



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

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

#_reduce_34(val, _values, result) ⇒ Object

reduce 33 omitted



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

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

#_reduce_343(val, _values, result) ⇒ Object

reduce 342 omitted



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

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

#_reduce_344(val, _values, result) ⇒ Object 



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

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

#_reduce_345(val, _values, result) ⇒ Object 



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

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

#_reduce_348(val, _values, result) ⇒ Object

reduce 347 omitted



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

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

#_reduce_349(val, _values, result) ⇒ Object 



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

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

#_reduce_35(val, _values, result) ⇒ Object 



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

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

#_reduce_350(val, _values, result) ⇒ Object 



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

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

#_reduce_351(val, _values, result) ⇒ Object 



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

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

#_reduce_353(val, _values, result) ⇒ Object

reduce 352 omitted



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

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

#_reduce_354(val, _values, result) ⇒ Object 



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

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

#_reduce_355(val, _values, result) ⇒ Object 



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

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

#_reduce_356(val, _values, result) ⇒ Object 



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

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

#_reduce_358(val, _values, result) ⇒ Object

reduce 357 omitted



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

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

#_reduce_359(val, _values, result) ⇒ Object 



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

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

#_reduce_36(val, _values, result) ⇒ Object 



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

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

#_reduce_360(val, _values, result) ⇒ Object 



4790
4791
4792
4793
4794
 
# File 'opal/lib/opal/parser/grammar.rb', line 4790

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

#_reduce_361(val, _values, result) ⇒ Object 



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

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

#_reduce_362(val, _values, result) ⇒ Object 



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

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

#_reduce_363(val, _values, result) ⇒ Object 



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

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

#_reduce_364(val, _values, result) ⇒ Object 



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

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

#_reduce_365(val, _values, result) ⇒ Object 



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

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

#_reduce_366(val, _values, result) ⇒ Object 



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

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

#_reduce_367(val, _values, result) ⇒ Object 



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

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

#_reduce_368(val, _values, result) ⇒ Object 



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

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

#_reduce_369(val, _values, result) ⇒ Object 



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

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

#_reduce_370(val, _values, result) ⇒ Object 



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

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

#_reduce_371(val, _values, result) ⇒ Object 



4856
4857
4858
4859
4860
 
# File 'opal/lib/opal/parser/grammar.rb', line 4856

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

#_reduce_372(val, _values, result) ⇒ Object 



4862
4863
4864
4865
4866
 
# File 'opal/lib/opal/parser/grammar.rb', line 4862

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

#_reduce_373(val, _values, result) ⇒ Object 



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

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

#_reduce_374(val, _values, result) ⇒ Object 



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

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

#_reduce_375(val, _values, result) ⇒ Object 



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

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

#_reduce_379(val, _values, result) ⇒ Object

reduce 378 omitted



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

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

#_reduce_380(val, _values, result) ⇒ Object 



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

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

#_reduce_381(val, _values, result) ⇒ Object 



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

def _reduce_381(val, _values, result)
                      result = new_js_call(val[0], val[2], val[3])
                    
    result
end

#_reduce_382(val, _values, result) ⇒ Object 



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

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

#_reduce_383(val, _values, result) ⇒ Object 



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

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

#_reduce_384(val, _values, result) ⇒ Object 



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

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

#_reduce_385(val, _values, result) ⇒ Object 



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

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

#_reduce_386(val, _values, result) ⇒ Object 



4937
4938
4939
4940
4941
 
# File 'opal/lib/opal/parser/grammar.rb', line 4937

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

#_reduce_387(val, _values, result) ⇒ Object 



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

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

#_reduce_388(val, _values, result) ⇒ Object 



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

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

#_reduce_389(val, _values, result) ⇒ Object 



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

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

#_reduce_39(val, _values, result) ⇒ Object

reduce 38 omitted



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

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

#_reduce_390(val, _values, result) ⇒ Object 



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

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

#_reduce_391(val, _values, result) ⇒ Object 



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

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

#_reduce_392(val, _values, result) ⇒ Object 



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

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

#_reduce_393(val, _values, result) ⇒ Object 



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

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

#_reduce_395(val, _values, result) ⇒ Object

reduce 394 omitted



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

def _reduce_395(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.concat val[5] if val[5]
                    
    result
end

#_reduce_396(val, _values, result) ⇒ Object 



5002
5003
5004
5005
5006
 
# File 'opal/lib/opal/parser/grammar.rb', line 5002

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

#_reduce_397(val, _values, result) ⇒ Object 



5008
5009
5010
5011
5012
 
# File 'opal/lib/opal/parser/grammar.rb', line 5008

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

#_reduce_4(val, _values, result) ⇒ Object 



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

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

#_reduce_40(val, _values, result) ⇒ Object 



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

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

#_reduce_400(val, _values, result) ⇒ Object

reduce 399 omitted



5018
5019
5020
5021
5022
 
# File 'opal/lib/opal/parser/grammar.rb', line 5018

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

#_reduce_401(val, _values, result) ⇒ Object 



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

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

#_reduce_402(val, _values, result) ⇒ Object 



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

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

#_reduce_407(val, _values, result) ⇒ Object

reduce 406 omitted



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

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

#_reduce_409(val, _values, result) ⇒ Object

reduce 408 omitted



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

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

#_reduce_41(val, _values, result) ⇒ Object 



3379
3380
3381
3382
3383
 
# File 'opal/lib/opal/parser/grammar.rb', line 3379

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

#_reduce_410(val, _values, result) ⇒ Object 



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

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

#_reduce_411(val, _values, result) ⇒ Object 



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

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

#_reduce_412(val, _values, result) ⇒ Object 



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

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

#_reduce_413(val, _values, result) ⇒ Object 



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

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

#_reduce_414(val, _values, result) ⇒ Object 



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

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

#_reduce_415(val, _values, result) ⇒ Object 



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

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

#_reduce_416(val, _values, result) ⇒ Object 



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

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

#_reduce_417(val, _values, result) ⇒ Object 



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

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

#_reduce_418(val, _values, result) ⇒ Object 



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

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

#_reduce_419(val, _values, result) ⇒ Object 



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

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

#_reduce_42(val, _values, result) ⇒ Object 



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

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

#_reduce_420(val, _values, result) ⇒ Object 



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

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

#_reduce_421(val, _values, result) ⇒ Object 



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

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

#_reduce_422(val, _values, result) ⇒ Object 



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

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

#_reduce_423(val, _values, result) ⇒ Object 



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

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

#_reduce_424(val, _values, result) ⇒ Object 



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

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

#_reduce_425(val, _values, result) ⇒ Object 



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

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

#_reduce_426(val, _values, result) ⇒ Object 



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

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

#_reduce_427(val, _values, result) ⇒ Object 



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

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

#_reduce_428(val, _values, result) ⇒ Object 



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

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

#_reduce_429(val, _values, result) ⇒ Object 



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

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

#_reduce_430(val, _values, result) ⇒ Object 



5181
5182
5183
5184
5185
5186
 
# File 'opal/lib/opal/parser/grammar.rb', line 5181

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

#_reduce_431(val, _values, result) ⇒ Object 



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

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



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

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

#_reduce_433(val, _values, result) ⇒ Object 



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

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

#_reduce_434(val, _values, result) ⇒ Object 



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

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

#_reduce_435(val, _values, result) ⇒ Object 



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

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

#_reduce_437(val, _values, result) ⇒ Object

reduce 436 omitted



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

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

#_reduce_438(val, _values, result) ⇒ Object 



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

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

#_reduce_443(val, _values, result) ⇒ Object

reduce 442 omitted



5248
5249
5250
5251
5252
 
# File 'opal/lib/opal/parser/grammar.rb', line 5248

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

#_reduce_444(val, _values, result) ⇒ Object 



5254
5255
5256
5257
5258
 
# File 'opal/lib/opal/parser/grammar.rb', line 5254

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

#_reduce_445(val, _values, result) ⇒ Object 



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

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

#_reduce_446(val, _values, result) ⇒ Object 



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

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

#_reduce_447(val, _values, result) ⇒ Object 



5272
5273
5274
5275
5276
 
# File 'opal/lib/opal/parser/grammar.rb', line 5272

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

#_reduce_448(val, _values, result) ⇒ Object 



5278
5279
5280
5281
5282
 
# File 'opal/lib/opal/parser/grammar.rb', line 5278

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

#_reduce_449(val, _values, result) ⇒ Object 



5284
5285
5286
5287
5288
 
# File 'opal/lib/opal/parser/grammar.rb', line 5284

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

#_reduce_450(val, _values, result) ⇒ Object 



5290
5291
5292
5293
5294
 
# File 'opal/lib/opal/parser/grammar.rb', line 5290

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

#_reduce_451(val, _values, result) ⇒ Object 



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

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

#_reduce_452(val, _values, result) ⇒ Object 



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

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

#_reduce_453(val, _values, result) ⇒ Object 



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

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

#_reduce_454(val, _values, result) ⇒ Object 



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

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

#_reduce_455(val, _values, result) ⇒ Object 



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

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

#_reduce_456(val, _values, result) ⇒ Object 



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

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

#_reduce_457(val, _values, result) ⇒ Object 



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

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

#_reduce_458(val, _values, result) ⇒ Object 



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

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

#_reduce_459(val, _values, result) ⇒ Object 



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

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

#_reduce_460(val, _values, result) ⇒ Object 



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

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

#_reduce_461(val, _values, result) ⇒ Object 



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

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

#_reduce_462(val, _values, result) ⇒ Object 



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

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

#_reduce_463(val, _values, result) ⇒ Object 



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

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

#_reduce_465(val, _values, result) ⇒ Object

reduce 464 omitted



5376
5377
5378
5379
5380
 
# File 'opal/lib/opal/parser/grammar.rb', line 5376

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

#_reduce_466(val, _values, result) ⇒ Object 



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

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

#_reduce_467(val, _values, result) ⇒ Object 



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

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

#_reduce_468(val, _values, result) ⇒ Object 



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

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

#_reduce_469(val, _values, result) ⇒ Object 



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

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

#_reduce_47(val, _values, result) ⇒ Object

reduce 46 omitted



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

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

#_reduce_472(val, _values, result) ⇒ Object

reduce 471 omitted



5412
5413
5414
5415
5416
 
# File 'opal/lib/opal/parser/grammar.rb', line 5412

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

#_reduce_473(val, _values, result) ⇒ Object 



5418
5419
5420
5421
5422
 
# File 'opal/lib/opal/parser/grammar.rb', line 5418

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

#_reduce_474(val, _values, result) ⇒ Object 



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

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

#_reduce_475(val, _values, result) ⇒ Object 



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

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

#_reduce_476(val, _values, result) ⇒ Object 



5436
5437
5438
5439
5440
 
# File 'opal/lib/opal/parser/grammar.rb', line 5436

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

#_reduce_477(val, _values, result) ⇒ Object 



5442
5443
5444
5445
5446
 
# File 'opal/lib/opal/parser/grammar.rb', line 5442

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

#_reduce_478(val, _values, result) ⇒ Object 



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

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

#_reduce_479(val, _values, result) ⇒ Object 



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

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

#_reduce_48(val, _values, result) ⇒ Object 



3405
3406
3407
3408
3409
 
# File 'opal/lib/opal/parser/grammar.rb', line 3405

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

#_reduce_480(val, _values, result) ⇒ Object 



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

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

#_reduce_481(val, _values, result) ⇒ Object 



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

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

#_reduce_482(val, _values, result) ⇒ Object 



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

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

#_reduce_483(val, _values, result) ⇒ Object 



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

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

#_reduce_484(val, _values, result) ⇒ Object 



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

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

#_reduce_485(val, _values, result) ⇒ Object 



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

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

#_reduce_486(val, _values, result) ⇒ Object 



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

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

#_reduce_487(val, _values, result) ⇒ Object 



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

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

#_reduce_488(val, _values, result) ⇒ Object 



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

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

#_reduce_489(val, _values, result) ⇒ Object 



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

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

#_reduce_49(val, _values, result) ⇒ Object 



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

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

#_reduce_490(val, _values, result) ⇒ Object 



5521
5522
5523
5524
5525
 
# File 'opal/lib/opal/parser/grammar.rb', line 5521

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

#_reduce_491(val, _values, result) ⇒ Object 



5527
5528
5529
5530
5531
 
# File 'opal/lib/opal/parser/grammar.rb', line 5527

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

#_reduce_492(val, _values, result) ⇒ Object 



5533
5534
5535
5536
5537
 
# File 'opal/lib/opal/parser/grammar.rb', line 5533

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

#_reduce_493(val, _values, result) ⇒ Object 



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

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

#_reduce_495(val, _values, result) ⇒ Object

reduce 494 omitted



5547
5548
5549
5550
5551
5552
 
# File 'opal/lib/opal/parser/grammar.rb', line 5547

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

#_reduce_496(val, _values, result) ⇒ Object 



5554
5555
5556
5557
5558
 
# File 'opal/lib/opal/parser/grammar.rb', line 5554

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

#_reduce_497(val, _values, result) ⇒ Object 



5560
5561
5562
5563
5564
 
# File 'opal/lib/opal/parser/grammar.rb', line 5560

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

#_reduce_498(val, _values, result) ⇒ Object 



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

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

#_reduce_499(val, _values, result) ⇒ Object 



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

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

#_reduce_5(val, _values, result) ⇒ Object 



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

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

#_reduce_500(val, _values, result) ⇒ Object 



5578
5579
5580
5581
5582
 
# File 'opal/lib/opal/parser/grammar.rb', line 5578

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

#_reduce_501(val, _values, result) ⇒ Object 



5584
5585
5586
5587
5588
 
# File 'opal/lib/opal/parser/grammar.rb', line 5584

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

#_reduce_504(val, _values, result) ⇒ Object

reduce 503 omitted



5594
5595
5596
5597
5598
 
# File 'opal/lib/opal/parser/grammar.rb', line 5594

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

#_reduce_506(val, _values, result) ⇒ Object

reduce 505 omitted



5602
5603
5604
5605
5606
 
# File 'opal/lib/opal/parser/grammar.rb', line 5602

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

#_reduce_507(val, _values, result) ⇒ Object 



5608
5609
5610
5611
5612
5613
 
# File 'opal/lib/opal/parser/grammar.rb', line 5608

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

#_reduce_513(val, _values, result) ⇒ Object

reduce 512 omitted



5625
5626
5627
5628
5629
 
# File 'opal/lib/opal/parser/grammar.rb', line 5625

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

#_reduce_514(val, _values, result) ⇒ Object 



5631
5632
5633
5634
5635
5636
 
# File 'opal/lib/opal/parser/grammar.rb', line 5631

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

#_reduce_515(val, _values, result) ⇒ Object 



5638
5639
5640
5641
5642
 
# File 'opal/lib/opal/parser/grammar.rb', line 5638

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

#_reduce_516(val, _values, result) ⇒ Object 



5644
5645
5646
5647
5648
 
# File 'opal/lib/opal/parser/grammar.rb', line 5644

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

#_reduce_517(val, _values, result) ⇒ Object 



5650
5651
5652
5653
5654
5655
 
# File 'opal/lib/opal/parser/grammar.rb', line 5650

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

#_reduce_520(val, _values, result) ⇒ Object

reduce 519 omitted



5661
5662
5663
5664
5665
 
# File 'opal/lib/opal/parser/grammar.rb', line 5661

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

#_reduce_521(val, _values, result) ⇒ Object 



5667
5668
5669
5670
5671
 
# File 'opal/lib/opal/parser/grammar.rb', line 5667

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

#_reduce_524(val, _values, result) ⇒ Object

reduce 523 omitted



5677
5678
5679
5680
5681
 
# File 'opal/lib/opal/parser/grammar.rb', line 5677

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

#_reduce_525(val, _values, result) ⇒ Object 



5683
5684
5685
5686
5687
 
# File 'opal/lib/opal/parser/grammar.rb', line 5683

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

#_reduce_526(val, _values, result) ⇒ Object 



5689
5690
5691
5692
5693
 
# File 'opal/lib/opal/parser/grammar.rb', line 5689

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

#_reduce_527(val, _values, result) ⇒ Object 



5695
5696
5697
5698
5699
 
# File 'opal/lib/opal/parser/grammar.rb', line 5695

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

#_reduce_528(val, _values, result) ⇒ Object 



5701
5702
5703
5704
5705
 
# File 'opal/lib/opal/parser/grammar.rb', line 5701

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

#_reduce_529(val, _values, result) ⇒ Object 



5707
5708
5709
5710
5711
 
# File 'opal/lib/opal/parser/grammar.rb', line 5707

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

#_reduce_530(val, _values, result) ⇒ Object 



5713
5714
5715
5716
5717
 
# File 'opal/lib/opal/parser/grammar.rb', line 5713

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

#_reduce_531(val, _values, result) ⇒ Object 



5719
5720
5721
5722
5723
 
# File 'opal/lib/opal/parser/grammar.rb', line 5719

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

#_reduce_532(val, _values, result) ⇒ Object 



5725
5726
5727
5728
5729
 
# File 'opal/lib/opal/parser/grammar.rb', line 5725

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

#_reduce_533(val, _values, result) ⇒ Object 



5731
5732
5733
5734
5735
 
# File 'opal/lib/opal/parser/grammar.rb', line 5731

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

#_reduce_534(val, _values, result) ⇒ Object 



5737
5738
5739
5740
5741
 
# File 'opal/lib/opal/parser/grammar.rb', line 5737

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

#_reduce_535(val, _values, result) ⇒ Object 



5743
5744
5745
5746
5747
 
# File 'opal/lib/opal/parser/grammar.rb', line 5743

def _reduce_535(val, _values, result)
                      result = [s(:sym, source(val[1]).to_sym), val[3]]
                    
    result
end

#_reduce_55(val, _values, result) ⇒ Object

reduce 54 omitted



3427
3428
3429
3430
3431
 
# File 'opal/lib/opal/parser/grammar.rb', line 3427

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

#_reduce_559(val, _values, result) ⇒ Object

reduce 558 omitted



5795
5796
5797
5798
5799
 
# File 'opal/lib/opal/parser/grammar.rb', line 5795

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

#_reduce_57(val, _values, result) ⇒ Object

reduce 56 omitted



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

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

#_reduce_59(val, _values, result) ⇒ Object

reduce 58 omitted



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

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

#_reduce_61(val, _values, result) ⇒ Object

reduce 60 omitted



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

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

#_reduce_63(val, _values, result) ⇒ Object

reduce 62 omitted



3459
3460
3461
3462
3463
 
# File 'opal/lib/opal/parser/grammar.rb', line 3459

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

#_reduce_64(val, _values, result) ⇒ Object 



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

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

#_reduce_65(val, _values, result) ⇒ Object 



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

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

#_reduce_66(val, _values, result) ⇒ Object 



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

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

#_reduce_67(val, _values, result) ⇒ Object 



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

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

#_reduce_68(val, _values, result) ⇒ Object 



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

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

#_reduce_69(val, _values, result) ⇒ Object 



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

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

#_reduce_7(val, _values, result) ⇒ Object

reduce 6 omitted



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

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

#_reduce_70(val, _values, result) ⇒ Object 



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

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

#_reduce_71(val, _values, result) ⇒ Object 



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

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

#_reduce_72(val, _values, result) ⇒ Object 



3513
3514
3515
3516
3517
 
# File 'opal/lib/opal/parser/grammar.rb', line 3513

def _reduce_72(val, _values, result)
                     result = (val[0] << s(:splat, val[2])).concat(val[4].children)
                   
    result
end

#_reduce_73(val, _values, result) ⇒ Object 



3519
3520
3521
3522
3523
 
# File 'opal/lib/opal/parser/grammar.rb', line 3519

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

#_reduce_74(val, _values, result) ⇒ Object 



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

def _reduce_74(val, _values, result)
                      result = (val[0] << s(:splat)).concat(val[3].children)
                    
    result
end

#_reduce_75(val, _values, result) ⇒ Object 



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

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

#_reduce_76(val, _values, result) ⇒ Object 



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

def _reduce_76(val, _values, result)
                      result = s(:array, s(:splat, val[1])).concat(val[3].children)
                    
    result
end

#_reduce_77(val, _values, result) ⇒ Object 



3543
3544
3545
3546
3547
 
# File 'opal/lib/opal/parser/grammar.rb', line 3543

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

#_reduce_78(val, _values, result) ⇒ Object 



3549
3550
3551
3552
3553
 
# File 'opal/lib/opal/parser/grammar.rb', line 3549

def _reduce_78(val, _values, result)
                      result = s(:array, s(:splat)).concat(val[2].children)
                    
    result
end

#_reduce_79(val, _values, result) ⇒ Object 



3555
3556
3557
3558
3559
 
# File 'opal/lib/opal/parser/grammar.rb', line 3555

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

#_reduce_8(val, _values, result) ⇒ Object 



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

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 



3561
3562
3563
3564
3565
 
# File 'opal/lib/opal/parser/grammar.rb', line 3561

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

#_reduce_81(val, _values, result) ⇒ Object 



3567
3568
3569
3570
3571
 
# File 'opal/lib/opal/parser/grammar.rb', line 3567

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

#_reduce_82(val, _values, result) ⇒ Object 



3573
3574
3575
3576
3577
 
# File 'opal/lib/opal/parser/grammar.rb', line 3573

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

#_reduce_83(val, _values, result) ⇒ Object 



3579
3580
3581
3582
3583
 
# File 'opal/lib/opal/parser/grammar.rb', line 3579

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

#_reduce_84(val, _values, result) ⇒ Object 



3585
3586
3587
3588
3589
 
# File 'opal/lib/opal/parser/grammar.rb', line 3585

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

#_reduce_85(val, _values, result) ⇒ Object 



3591
3592
3593
3594
3595
 
# File 'opal/lib/opal/parser/grammar.rb', line 3591

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

#_reduce_86(val, _values, result) ⇒ Object 



3597
3598
3599
3600
3601
3602
 
# File 'opal/lib/opal/parser/grammar.rb', line 3597

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

#_reduce_87(val, _values, result) ⇒ Object 



3604
3605
3606
3607
3608
 
# File 'opal/lib/opal/parser/grammar.rb', line 3604

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

#_reduce_9(val, _values, result) ⇒ Object 



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

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

#_reduce_93(val, _values, result) ⇒ Object

reduce 92 omitted



3620
3621
3622
3623
3624
 
# File 'opal/lib/opal/parser/grammar.rb', line 3620

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

#_reduce_94(val, _values, result) ⇒ Object 



3626
3627
3628
3629
3630
 
# File 'opal/lib/opal/parser/grammar.rb', line 3626

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

#_reduce_95(val, _values, result) ⇒ Object 



3632
3633
3634
3635
3636
 
# File 'opal/lib/opal/parser/grammar.rb', line 3632

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

#_reduce_96(val, _values, result) ⇒ Object 



3638
3639
3640
3641
3642
 
# File 'opal/lib/opal/parser/grammar.rb', line 3638

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

#_reduce_97(val, _values, result) ⇒ Object 



3644
3645
3646
3647
3648
 
# File 'opal/lib/opal/parser/grammar.rb', line 3644

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

#_reduce_98(val, _values, result) ⇒ Object 



3650
3651
3652
3653
3654
 
# File 'opal/lib/opal/parser/grammar.rb', line 3650

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

#_reduce_99(val, _values, result) ⇒ Object 



3656
3657
3658
3659
3660
 
# File 'opal/lib/opal/parser/grammar.rb', line 3656

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

#_reduce_none(val, _values, result) ⇒ Object 



5801
5802
5803
 
# File 'opal/lib/opal/parser/grammar.rb', line 5801

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

#add_block_pass(arglist, block) ⇒ Object 



503
504
505
506
 
# File 'opal/lib/opal/parser.rb', line 503

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

#negate_num(sexp) ⇒ Object 



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

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

#new___FILE__(tok) ⇒ Object 



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

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

#new___LINE__(tok) ⇒ Object 



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

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

#new_alias(kw, new, old) ⇒ Object 



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

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

#new_and(lhs, tok, rhs) ⇒ Object 



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

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

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



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

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 



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

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

#new_array(start, args, finish) ⇒ Object 



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

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

#new_assign(lhs, tok, rhs) ⇒ Object 



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

def new_assign(lhs, tok, rhs)
  case lhs.type
  when :iasgn, :cdecl, :lasgn, :gasgn, :cvdecl, :nth_ref
    lhs << rhs
    lhs
  when :call, :attrasgn, :jsattrasgn
    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 



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

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 



544
545
546
547
548
 
# File 'opal/lib/opal/parser.rb', line 544

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 



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

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

#new_block(stmt = nil) ⇒ Object 



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

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

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



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

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 



508
509
510
 
# File 'opal/lib/opal/parser.rb', line 508

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

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



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

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 



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

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 



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

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 



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

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 



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

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 



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

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

#new_compstmt(block) ⇒ Object 



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

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 



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

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

#new_cvar(tok) ⇒ Object 



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

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

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



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

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 



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

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 



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

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

#new_evstr(str) ⇒ Object 



689
690
691
 
# File 'opal/lib/opal/parser.rb', line 689

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

#new_false(tok) ⇒ Object 



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

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

#new_float(tok) ⇒ Object 



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

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

#new_gettable(ref) ⇒ Object 



597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
 
# File 'opal/lib/opal/parser.rb', line 597

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 



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

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

#new_hash(open, assocs, close) ⇒ Object 



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

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

#new_ident(tok) ⇒ Object 



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

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

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



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

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 



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

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

#new_irange(beg, op, finish) ⇒ Object 



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

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

#new_iter(args, body) ⇒ Object 



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

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

#new_ivar(tok) ⇒ Object 



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

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

#new_js_attrasgn(recv, args) ⇒ Object 



550
551
552
553
554
 
# File 'opal/lib/opal/parser.rb', line 550

def new_js_attrasgn(recv, args)
  arglist = s(:arglist, *args)
  sexp = s(:jsattrasgn, recv, nil, arglist)
  sexp
end

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



454
455
456
457
458
459
460
461
462
463
464
 
# File 'opal/lib/opal/parser.rb', line 454

def new_js_call(recv, meth, args = nil)
  if args
    sexp = s(:jscall, recv, value(meth).to_sym, s(:arglist, *args))
    sexp.source = source(meth)
  else
    sexp = s(:jscall, recv, value(meth).to_sym, nil)
    sexp.source = source(meth)
  end

  sexp
end

#new_kwarg(name) ⇒ Object 



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

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

#new_kwoptarg(name, val) ⇒ Object 



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

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

#new_kwrestarg(name = nil) ⇒ Object 



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

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 



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

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

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



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

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 



105
106
107
 
# File 'opal/lib/opal/parser.rb', line 105

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

#new_not(kw, expr) ⇒ Object 



318
319
320
 
# File 'opal/lib/opal/parser.rb', line 318

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

#new_op_asgn(op, lhs, rhs) ⇒ Object 



516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
 
# File 'opal/lib/opal/parser.rb', line 516

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 



533
534
535
536
537
538
 
# File 'opal/lib/opal/parser.rb', line 533

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 



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

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

#new_paren(open, expr, close) ⇒ Object 



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

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 



711
712
713
714
715
716
717
718
719
720
721
722
 
# File 'opal/lib/opal/parser.rb', line 711

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 



299
300
301
302
303
 
# File 'opal/lib/opal/parser.rb', line 299

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 



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

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 



262
263
264
265
266
 
# File 'opal/lib/opal/parser.rb', line 262

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

#new_self(tok) ⇒ Object 



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

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

#new_splat(tok, value) ⇒ Object 



512
513
514
 
# File 'opal/lib/opal/parser.rb', line 512

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

#new_str(str) ⇒ Object 



693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
 
# File 'opal/lib/opal/parser.rb', line 693

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 



739
740
741
 
# File 'opal/lib/opal/parser.rb', line 739

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

#new_super(kw, args) ⇒ Object 



645
646
647
648
649
650
651
652
653
654
 
# File 'opal/lib/opal/parser.rb', line 645

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 



167
168
169
 
# File 'opal/lib/opal/parser.rb', line 167

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

#new_true(tok) ⇒ Object 



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

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

#new_unary_call(op, recv) ⇒ Object 



470
471
472
 
# File 'opal/lib/opal/parser.rb', line 470

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

#new_until(kw, test, body) ⇒ Object 



293
294
295
296
297
 
# File 'opal/lib/opal/parser.rb', line 293

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

#new_var_ref(ref) ⇒ Object 



617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
 
# File 'opal/lib/opal/parser.rb', line 617

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 



287
288
289
290
291
 
# File 'opal/lib/opal/parser.rb', line 287

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 



661
662
663
664
665
666
667
668
669
670
671
672
 
# File 'opal/lib/opal/parser.rb', line 661

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 



656
657
658
659
 
# File 'opal/lib/opal/parser.rb', line 656

def new_yield(args)
  args ||= []
  s(:yield, *args)
end

#next_token ⇒ Object 



60
61
62
 
# File 'opal/lib/opal/parser.rb', line 60

def next_token
  @lexer.next_token
end

#on_error(t, val, vstack) ⇒ Object 



81
82
83
 
# File 'opal/lib/opal/parser.rb', line 81

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 



540
541
542
 
# File 'opal/lib/opal/parser.rb', line 540

def op_to_setter(op)
  "#{value(op)}=".to_sym
end

#parse(source, file = '(string)') ⇒ Opal::Sexp

Parse the given ruby source. An optional file can be given which is used for file context for some ruby expressions (e.g. __FILE__).

If the given ruby code is not valid ruby, then an error will be raised.

Parameters:

  • source (String) —

    ruby source code

  • file (String) (defaults to: '(string)') —

    filename for context of ruby code

Returns:

  • (Opal::Sexp) —

    sexp expression tree representing ruby code



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'opal/lib/opal/parser.rb', line 32

def parse(source, file = '(string)')
  @yydebug = true if !!ENV['RACC_DEBUG']
  @file = file
  @scopes = []
  @lexer = Lexer.new(source, file)
  @lexer.parser = self

  self.parse_to_sexp
rescue => error
  message = [
    nil,
    error.message,
    "Source: #{@file}:#{lexer.line}:#{lexer.column}",
    source.split("\n")[lexer.line-1],
    '~'*(lexer.column-1 > 0 ? lexer.column-1 : 0) + '^',
  ].join("\n")

  raise error.class, message, error.backtrace
end

#parse_to_sexp ⇒ Object 



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

def parse_to_sexp
  push_scope
  result = do_parse
  pop_scope

  result
end

#pop_scope ⇒ Object 



76
77
78
79
 
# File 'opal/lib/opal/parser.rb', line 76

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

#push_scope(type = nil) ⇒ Object 



68
69
70
71
72
73
74
 
# File 'opal/lib/opal/parser.rb', line 68

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

#s(*parts) ⇒ Object 



64
65
66
 
# File 'opal/lib/opal/parser.rb', line 64

def s(*parts)
  Sexp.new(parts)
end

#s0(type, source) ⇒ Object 



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

def s0(type, source)
  sexp = s(type)
  sexp.source = source
  sexp
end

#s1(type, first, source) ⇒ Object 



99
100
101
102
103
 
# File 'opal/lib/opal/parser.rb', line 99

def s1(type, first, source)
  sexp = s(type, first)
  sexp.source = source
  sexp
end

#source(tok) ⇒ Object 



89
90
91
 
# File 'opal/lib/opal/parser.rb', line 89

def source(tok)
  tok ? tok[1] : nil
end

#str_append(str, str2) ⇒ Object 



724
725
726
727
728
729
730
731
732
733
734
735
736
737
 
# File 'opal/lib/opal/parser.rb', line 724

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 



85
86
87
 
# File 'opal/lib/opal/parser.rb', line 85

def value(tok)
  tok[0]
end