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 



3230
3231
3232
3233
3234
 
# File 'opal/lib/opal/parser/grammar.rb', line 3230

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

#_reduce_100(val, _values, result) ⇒ Object 



3664
3665
3666
3667
3668
 
# File 'opal/lib/opal/parser/grammar.rb', line 3664

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

    result
end

#_reduce_103(val, _values, result) ⇒ Object

reduce 102 omitted



3674
3675
3676
3677
3678
 
# File 'opal/lib/opal/parser/grammar.rb', line 3674

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

#_reduce_104(val, _values, result) ⇒ Object 



3680
3681
3682
3683
3684
 
# File 'opal/lib/opal/parser/grammar.rb', line 3680

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

#_reduce_105(val, _values, result) ⇒ Object 



3686
3687
3688
3689
3690
 
# File 'opal/lib/opal/parser/grammar.rb', line 3686

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



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

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

#_reduce_11(val, _values, result) ⇒ Object 



3236
3237
3238
3239
3240
 
# File 'opal/lib/opal/parser/grammar.rb', line 3236

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

#_reduce_110(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_111(val, _values, result) ⇒ Object 



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

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

#_reduce_113(val, _values, result) ⇒ Object

reduce 112 omitted



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

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

#_reduce_114(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_12(val, _values, result) ⇒ Object 



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

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

#_reduce_13(val, _values, result) ⇒ Object 



3249
3250
3251
3252
3253
 
# File 'opal/lib/opal/parser/grammar.rb', line 3249

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

#_reduce_14(val, _values, result) ⇒ Object 



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

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

#_reduce_15(val, _values, result) ⇒ Object 



3261
3262
3263
3264
3265
 
# File 'opal/lib/opal/parser/grammar.rb', line 3261

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



3269
3270
3271
3272
3273
 
# File 'opal/lib/opal/parser/grammar.rb', line 3269

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 



3275
3276
3277
3278
3279
 
# File 'opal/lib/opal/parser/grammar.rb', line 3275

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

#_reduce_189(val, _values, result) ⇒ Object

reduce 188 omitted



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

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

#_reduce_19(val, _values, result) ⇒ Object 



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

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

#_reduce_190(val, _values, result) ⇒ Object 



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

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 



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

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

#_reduce_192(val, _values, result) ⇒ Object 



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

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 



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

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

#_reduce_194(val, _values, result) ⇒ Object 



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

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



3185
3186
3187
3188
3189
 
# File 'opal/lib/opal/parser/grammar.rb', line 3185

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

#_reduce_20(val, _values, result) ⇒ Object 



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

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



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

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

#_reduce_201(val, _values, result) ⇒ Object 



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

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

#_reduce_202(val, _values, result) ⇒ Object 



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

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

#_reduce_203(val, _values, result) ⇒ Object 



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

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

#_reduce_204(val, _values, result) ⇒ Object 



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

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

#_reduce_205(val, _values, result) ⇒ Object 



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

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

#_reduce_206(val, _values, result) ⇒ Object 



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

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

#_reduce_207(val, _values, result) ⇒ Object 



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

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

#_reduce_208(val, _values, result) ⇒ Object 



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

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 



3980
3981
3982
3983
3984
 
# File 'opal/lib/opal/parser/grammar.rb', line 3980

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 



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

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

#_reduce_210(val, _values, result) ⇒ Object 



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

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 



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

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 



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

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

#_reduce_213(val, _values, result) ⇒ Object 



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

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

#_reduce_214(val, _values, result) ⇒ Object 



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

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

#_reduce_215(val, _values, result) ⇒ Object 



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

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

#_reduce_216(val, _values, result) ⇒ Object 



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

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

#_reduce_217(val, _values, result) ⇒ Object 



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

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

#_reduce_218(val, _values, result) ⇒ Object 



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

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

#_reduce_219(val, _values, result) ⇒ Object 



4050
4051
4052
4053
4054
 
# File 'opal/lib/opal/parser/grammar.rb', line 4050

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

#_reduce_22(val, _values, result) ⇒ Object 



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

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

#_reduce_220(val, _values, result) ⇒ Object 



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

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

#_reduce_221(val, _values, result) ⇒ Object 



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

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

#_reduce_222(val, _values, result) ⇒ Object 



4068
4069
4070
4071
4072
 
# File 'opal/lib/opal/parser/grammar.rb', line 4068

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

#_reduce_223(val, _values, result) ⇒ Object 



4074
4075
4076
4077
4078
 
# File 'opal/lib/opal/parser/grammar.rb', line 4074

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

#_reduce_224(val, _values, result) ⇒ Object 



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

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

#_reduce_225(val, _values, result) ⇒ Object 



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

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

#_reduce_226(val, _values, result) ⇒ Object 



4092
4093
4094
4095
4096
 
# File 'opal/lib/opal/parser/grammar.rb', line 4092

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

#_reduce_227(val, _values, result) ⇒ Object 



4098
4099
4100
4101
4102
 
# File 'opal/lib/opal/parser/grammar.rb', line 4098

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

#_reduce_228(val, _values, result) ⇒ Object 



4104
4105
4106
4107
4108
 
# File 'opal/lib/opal/parser/grammar.rb', line 4104

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

#_reduce_229(val, _values, result) ⇒ Object 



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

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

#_reduce_23(val, _values, result) ⇒ Object 



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

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

#_reduce_230(val, _values, result) ⇒ Object 



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

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

#_reduce_231(val, _values, result) ⇒ Object 



4122
4123
4124
4125
4126
 
# File 'opal/lib/opal/parser/grammar.rb', line 4122

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

    result
end

#_reduce_232(val, _values, result) ⇒ Object 



4128
4129
4130
4131
 
# File 'opal/lib/opal/parser/grammar.rb', line 4128

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

#_reduce_233(val, _values, result) ⇒ Object 



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

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

#_reduce_234(val, _values, result) ⇒ Object 



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

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



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

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

#_reduce_238(val, _values, result) ⇒ Object 



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

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

#_reduce_239(val, _values, result) ⇒ Object 



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

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

#_reduce_240(val, _values, result) ⇒ Object 



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

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

#_reduce_241(val, _values, result) ⇒ Object 



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

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

#_reduce_242(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_243(val, _values, result) ⇒ Object 



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

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

#_reduce_245(val, _values, result) ⇒ Object

reduce 244 omitted



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

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

#_reduce_247(val, _values, result) ⇒ Object

reduce 246 omitted



4201
4202
4203
4204
4205
 
# File 'opal/lib/opal/parser/grammar.rb', line 4201

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

#_reduce_249(val, _values, result) ⇒ Object

reduce 248 omitted



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

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

#_reduce_25(val, _values, result) ⇒ Object

reduce 24 omitted



3313
3314
3315
3316
3317
 
# File 'opal/lib/opal/parser/grammar.rb', line 3313

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

#_reduce_250(val, _values, result) ⇒ Object 



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

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

#_reduce_251(val, _values, result) ⇒ Object 



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

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

#_reduce_252(val, _values, result) ⇒ Object 



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

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

#_reduce_253(val, _values, result) ⇒ Object 



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

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

#_reduce_254(val, _values, result) ⇒ Object 



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

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 



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

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 



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

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

#_reduce_259(val, _values, result) ⇒ Object

reduce 258 omitted



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

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

    result
end

#_reduce_26(val, _values, result) ⇒ Object 



3319
3320
3321
3322
3323
 
# File 'opal/lib/opal/parser/grammar.rb', line 3319

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

#_reduce_260(val, _values, result) ⇒ Object 



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

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

#_reduce_262(val, _values, result) ⇒ Object

reduce 261 omitted



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

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

#_reduce_263(val, _values, result) ⇒ Object 



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

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

#_reduce_264(val, _values, result) ⇒ Object 



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

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

#_reduce_265(val, _values, result) ⇒ Object 



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

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

#_reduce_266(val, _values, result) ⇒ Object 



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

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

#_reduce_267(val, _values, result) ⇒ Object 



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

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

#_reduce_268(val, _values, result) ⇒ Object 



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

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

#_reduce_269(val, _values, result) ⇒ Object 



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

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

#_reduce_27(val, _values, result) ⇒ Object 



3325
3326
3327
3328
3329
 
# File 'opal/lib/opal/parser/grammar.rb', line 3325

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

#_reduce_270(val, _values, result) ⇒ Object 



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

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

#_reduce_271(val, _values, result) ⇒ Object 



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

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

#_reduce_272(val, _values, result) ⇒ Object 



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

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 



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

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

#_reduce_283(val, _values, result) ⇒ Object

reduce 282 omitted



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

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

#_reduce_284(val, _values, result) ⇒ Object 



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

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

#_reduce_285(val, _values, result) ⇒ Object 



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

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

#_reduce_286(val, _values, result) ⇒ Object 



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

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

#_reduce_287(val, _values, result) ⇒ Object 



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

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

#_reduce_288(val, _values, result) ⇒ Object 



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

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

#_reduce_289(val, _values, result) ⇒ Object 



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

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

#_reduce_290(val, _values, result) ⇒ Object 



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

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

#_reduce_291(val, _values, result) ⇒ Object 



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

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

#_reduce_292(val, _values, result) ⇒ Object 



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

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

#_reduce_293(val, _values, result) ⇒ Object 



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

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

#_reduce_294(val, _values, result) ⇒ Object 



4440
4441
4442
4443
4444
 
# File 'opal/lib/opal/parser/grammar.rb', line 4440

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

#_reduce_295(val, _values, result) ⇒ Object 



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

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

#_reduce_296(val, _values, result) ⇒ Object 



4452
4453
4454
4455
4456
 
# File 'opal/lib/opal/parser/grammar.rb', line 4452

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

#_reduce_297(val, _values, result) ⇒ Object 



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

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

#_reduce_298(val, _values, result) ⇒ Object 



4464
4465
4466
4467
4468
 
# File 'opal/lib/opal/parser/grammar.rb', line 4464

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

#_reduce_299(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_3(val, _values, result) ⇒ Object 



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

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

#_reduce_30(val, _values, result) ⇒ Object

reduce 29 omitted



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

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 



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

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



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

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

#_reduce_303(val, _values, result) ⇒ Object 



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

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

#_reduce_304(val, _values, result) ⇒ Object 



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

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 



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

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 



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

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

#_reduce_307(val, _values, result) ⇒ Object 



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

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

#_reduce_308(val, _values, result) ⇒ Object 



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

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

#_reduce_309(val, _values, result) ⇒ Object 



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

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

#_reduce_310(val, _values, result) ⇒ Object 



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

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

#_reduce_311(val, _values, result) ⇒ Object 



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

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

#_reduce_312(val, _values, result) ⇒ Object 



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

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

#_reduce_313(val, _values, result) ⇒ Object 



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

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

#_reduce_314(val, _values, result) ⇒ Object 



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

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

#_reduce_315(val, _values, result) ⇒ Object 



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

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

#_reduce_316(val, _values, result) ⇒ Object 



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

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

#_reduce_317(val, _values, result) ⇒ Object 



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

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

#_reduce_318(val, _values, result) ⇒ Object 



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

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

#_reduce_319(val, _values, result) ⇒ Object 



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

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 



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

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

#_reduce_321(val, _values, result) ⇒ Object 



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

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

#_reduce_322(val, _values, result) ⇒ Object 



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

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 



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

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

#_reduce_324(val, _values, result) ⇒ Object 



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

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

#_reduce_325(val, _values, result) ⇒ Object 



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

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 



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

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

#_reduce_327(val, _values, result) ⇒ Object 



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

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 



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

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

#_reduce_329(val, _values, result) ⇒ Object 



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

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

#_reduce_330(val, _values, result) ⇒ Object 



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

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 



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

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

#_reduce_332(val, _values, result) ⇒ Object 



4673
4674
4675
4676
4677
 
# File 'opal/lib/opal/parser/grammar.rb', line 4673

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

    result
end

#_reduce_333(val, _values, result) ⇒ Object 



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

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

#_reduce_34(val, _values, result) ⇒ Object

reduce 33 omitted



3347
3348
3349
3350
3351
 
# File 'opal/lib/opal/parser/grammar.rb', line 3347

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



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

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 



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

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

    result
end

#_reduce_345(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_348(val, _values, result) ⇒ Object

reduce 347 omitted



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

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

    result
end

#_reduce_349(val, _values, result) ⇒ Object 



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

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

#_reduce_35(val, _values, result) ⇒ Object 



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

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

#_reduce_350(val, _values, result) ⇒ Object 



4738
4739
4740
4741
4742
 
# File 'opal/lib/opal/parser/grammar.rb', line 4738

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

    result
end

#_reduce_351(val, _values, result) ⇒ Object 



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

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



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

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

    result
end

#_reduce_354(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_355(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_356(val, _values, result) ⇒ Object 



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

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



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

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

    result
end

#_reduce_359(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_36(val, _values, result) ⇒ Object 



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

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

#_reduce_360(val, _values, result) ⇒ Object 



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

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

#_reduce_361(val, _values, result) ⇒ Object 



4798
4799
4800
4801
4802
 
# File 'opal/lib/opal/parser/grammar.rb', line 4798

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

#_reduce_362(val, _values, result) ⇒ Object 



4804
4805
4806
4807
4808
 
# File 'opal/lib/opal/parser/grammar.rb', line 4804

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

#_reduce_363(val, _values, result) ⇒ Object 



4810
4811
4812
4813
4814
 
# File 'opal/lib/opal/parser/grammar.rb', line 4810

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

#_reduce_364(val, _values, result) ⇒ Object 



4816
4817
4818
4819
4820
 
# File 'opal/lib/opal/parser/grammar.rb', line 4816

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 



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

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 



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

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 



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

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

#_reduce_368(val, _values, result) ⇒ Object 



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

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

#_reduce_369(val, _values, result) ⇒ Object 



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

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 



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

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

#_reduce_371(val, _values, result) ⇒ Object 



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

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

#_reduce_372(val, _values, result) ⇒ Object 



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

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

#_reduce_373(val, _values, result) ⇒ Object 



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

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

#_reduce_374(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_375(val, _values, result) ⇒ Object 



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

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

#_reduce_379(val, _values, result) ⇒ Object

reduce 378 omitted



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

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

    result
end

#_reduce_380(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_381(val, _values, result) ⇒ Object 



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

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

#_reduce_382(val, _values, result) ⇒ Object 



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

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

#_reduce_383(val, _values, result) ⇒ Object 



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

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

#_reduce_384(val, _values, result) ⇒ Object 



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

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

#_reduce_385(val, _values, result) ⇒ Object 



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

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

#_reduce_386(val, _values, result) ⇒ Object 



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

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

#_reduce_387(val, _values, result) ⇒ Object 



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

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

#_reduce_388(val, _values, result) ⇒ Object 



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

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

#_reduce_389(val, _values, result) ⇒ Object 



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

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

#_reduce_39(val, _values, result) ⇒ Object

reduce 38 omitted



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

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

#_reduce_390(val, _values, result) ⇒ Object 



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

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

#_reduce_391(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_392(val, _values, result) ⇒ Object 



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

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 



4987
4988
4989
4990
4991
 
# File 'opal/lib/opal/parser/grammar.rb', line 4987

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

    result
end

#_reduce_395(val, _values, result) ⇒ Object

reduce 394 omitted



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

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.push val[5].first if val[5]
                    
    result
end

#_reduce_396(val, _values, result) ⇒ Object 



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

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

#_reduce_397(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_4(val, _values, result) ⇒ Object 



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

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

#_reduce_40(val, _values, result) ⇒ Object 



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

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

#_reduce_400(val, _values, result) ⇒ Object

reduce 399 omitted



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

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

    result
end

#_reduce_401(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_402(val, _values, result) ⇒ Object 



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

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



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

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

    result
end

#_reduce_409(val, _values, result) ⇒ Object

reduce 408 omitted



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

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

    result
end

#_reduce_41(val, _values, result) ⇒ Object 



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

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

#_reduce_410(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_411(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_412(val, _values, result) ⇒ Object 



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

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

#_reduce_413(val, _values, result) ⇒ Object 



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

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

#_reduce_414(val, _values, result) ⇒ Object 



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

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

#_reduce_415(val, _values, result) ⇒ Object 



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

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

#_reduce_416(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_417(val, _values, result) ⇒ Object 



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

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 



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

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

    result
end

#_reduce_419(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_42(val, _values, result) ⇒ Object 



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

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

#_reduce_420(val, _values, result) ⇒ Object 



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

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

#_reduce_421(val, _values, result) ⇒ Object 



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

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

#_reduce_422(val, _values, result) ⇒ Object 



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

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

#_reduce_423(val, _values, result) ⇒ Object 



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

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

#_reduce_424(val, _values, result) ⇒ Object 



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

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

#_reduce_425(val, _values, result) ⇒ Object 



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

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

#_reduce_426(val, _values, result) ⇒ Object 



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

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

#_reduce_427(val, _values, result) ⇒ Object 



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

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

#_reduce_428(val, _values, result) ⇒ Object 



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

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

#_reduce_429(val, _values, result) ⇒ Object 



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

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

#_reduce_430(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_431(val, _values, result) ⇒ Object 



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

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 



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

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 



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

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

    result
end

#_reduce_434(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_435(val, _values, result) ⇒ Object 



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

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

#_reduce_437(val, _values, result) ⇒ Object

reduce 436 omitted



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

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

#_reduce_438(val, _values, result) ⇒ Object 



5236
5237
5238
5239
5240
 
# File 'opal/lib/opal/parser/grammar.rb', line 5236

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

    result
end

#_reduce_443(val, _values, result) ⇒ Object

reduce 442 omitted



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

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

#_reduce_444(val, _values, result) ⇒ Object 



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

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

#_reduce_445(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_446(val, _values, result) ⇒ Object 



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

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

#_reduce_447(val, _values, result) ⇒ Object 



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

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

#_reduce_448(val, _values, result) ⇒ Object 



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

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

#_reduce_449(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_450(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_451(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_452(val, _values, result) ⇒ Object 



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

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

#_reduce_453(val, _values, result) ⇒ Object 



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

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

#_reduce_454(val, _values, result) ⇒ Object 



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

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

#_reduce_455(val, _values, result) ⇒ Object 



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

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

#_reduce_456(val, _values, result) ⇒ Object 



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

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

#_reduce_457(val, _values, result) ⇒ Object 



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

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

#_reduce_458(val, _values, result) ⇒ Object 



5340
5341
5342
5343
5344
 
# File 'opal/lib/opal/parser/grammar.rb', line 5340

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

#_reduce_459(val, _values, result) ⇒ Object 



5346
5347
5348
5349
5350
 
# File 'opal/lib/opal/parser/grammar.rb', line 5346

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

#_reduce_460(val, _values, result) ⇒ Object 



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

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

#_reduce_461(val, _values, result) ⇒ Object 



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

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

#_reduce_462(val, _values, result) ⇒ Object 



5364
5365
5366
5367
5368
 
# File 'opal/lib/opal/parser/grammar.rb', line 5364

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

    result
end

#_reduce_463(val, _values, result) ⇒ Object 



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

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

#_reduce_465(val, _values, result) ⇒ Object

reduce 464 omitted



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

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

    result
end

#_reduce_466(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_467(val, _values, result) ⇒ Object 



5390
5391
5392
5393
5394
 
# File 'opal/lib/opal/parser/grammar.rb', line 5390

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

#_reduce_468(val, _values, result) ⇒ Object 



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

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

#_reduce_469(val, _values, result) ⇒ Object 



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

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



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

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

#_reduce_472(val, _values, result) ⇒ Object

reduce 471 omitted



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

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

#_reduce_473(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_474(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_475(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_476(val, _values, result) ⇒ Object 



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

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

#_reduce_477(val, _values, result) ⇒ Object 



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

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

#_reduce_478(val, _values, result) ⇒ Object 



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

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

#_reduce_479(val, _values, result) ⇒ Object 



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

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

#_reduce_48(val, _values, result) ⇒ Object 



3407
3408
3409
3410
3411
 
# File 'opal/lib/opal/parser/grammar.rb', line 3407

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

#_reduce_480(val, _values, result) ⇒ Object 



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

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

#_reduce_481(val, _values, result) ⇒ Object 



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

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

#_reduce_482(val, _values, result) ⇒ Object 



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

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

#_reduce_483(val, _values, result) ⇒ Object 



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

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

#_reduce_484(val, _values, result) ⇒ Object 



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

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

#_reduce_485(val, _values, result) ⇒ Object 



5493
5494
5495
5496
5497
 
# File 'opal/lib/opal/parser/grammar.rb', line 5493

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 



5499
5500
5501
5502
5503
 
# File 'opal/lib/opal/parser/grammar.rb', line 5499

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

#_reduce_487(val, _values, result) ⇒ Object 



5505
5506
5507
5508
5509
 
# File 'opal/lib/opal/parser/grammar.rb', line 5505

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

#_reduce_488(val, _values, result) ⇒ Object 



5511
5512
5513
5514
5515
 
# File 'opal/lib/opal/parser/grammar.rb', line 5511

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

#_reduce_489(val, _values, result) ⇒ Object 



5517
5518
5519
5520
5521
 
# File 'opal/lib/opal/parser/grammar.rb', line 5517

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

#_reduce_49(val, _values, result) ⇒ Object 



3413
3414
3415
3416
3417
 
# File 'opal/lib/opal/parser/grammar.rb', line 3413

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

#_reduce_490(val, _values, result) ⇒ Object 



5523
5524
5525
5526
5527
 
# File 'opal/lib/opal/parser/grammar.rb', line 5523

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

#_reduce_491(val, _values, result) ⇒ Object 



5529
5530
5531
5532
5533
 
# File 'opal/lib/opal/parser/grammar.rb', line 5529

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

#_reduce_492(val, _values, result) ⇒ Object 



5535
5536
5537
5538
5539
 
# File 'opal/lib/opal/parser/grammar.rb', line 5535

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

    result
end

#_reduce_493(val, _values, result) ⇒ Object 



5541
5542
5543
5544
5545
 
# File 'opal/lib/opal/parser/grammar.rb', line 5541

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

#_reduce_495(val, _values, result) ⇒ Object

reduce 494 omitted



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

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

#_reduce_496(val, _values, result) ⇒ Object 



5556
5557
5558
5559
5560
 
# File 'opal/lib/opal/parser/grammar.rb', line 5556

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

#_reduce_497(val, _values, result) ⇒ Object 



5562
5563
5564
5565
5566
 
# File 'opal/lib/opal/parser/grammar.rb', line 5562

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

#_reduce_498(val, _values, result) ⇒ Object 



5568
5569
5570
5571
5572
 
# File 'opal/lib/opal/parser/grammar.rb', line 5568

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

#_reduce_499(val, _values, result) ⇒ Object 



5574
5575
5576
5577
5578
 
# File 'opal/lib/opal/parser/grammar.rb', line 5574

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

#_reduce_5(val, _values, result) ⇒ Object 



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

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

#_reduce_500(val, _values, result) ⇒ Object 



5580
5581
5582
5583
5584
 
# File 'opal/lib/opal/parser/grammar.rb', line 5580

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

#_reduce_501(val, _values, result) ⇒ Object 



5586
5587
5588
5589
5590
 
# File 'opal/lib/opal/parser/grammar.rb', line 5586

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

    result
end

#_reduce_504(val, _values, result) ⇒ Object

reduce 503 omitted



5596
5597
5598
5599
5600
 
# File 'opal/lib/opal/parser/grammar.rb', line 5596

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

    result
end

#_reduce_506(val, _values, result) ⇒ Object

reduce 505 omitted



5604
5605
5606
5607
5608
 
# File 'opal/lib/opal/parser/grammar.rb', line 5604

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

    result
end

#_reduce_507(val, _values, result) ⇒ Object 



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

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

#_reduce_513(val, _values, result) ⇒ Object

reduce 512 omitted



5627
5628
5629
5630
5631
 
# File 'opal/lib/opal/parser/grammar.rb', line 5627

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

    result
end

#_reduce_514(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_515(val, _values, result) ⇒ Object 



5640
5641
5642
5643
5644
 
# File 'opal/lib/opal/parser/grammar.rb', line 5640

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 



5646
5647
5648
5649
5650
 
# File 'opal/lib/opal/parser/grammar.rb', line 5646

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

    result
end

#_reduce_517(val, _values, result) ⇒ Object 



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

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

#_reduce_520(val, _values, result) ⇒ Object

reduce 519 omitted



5663
5664
5665
5666
5667
 
# File 'opal/lib/opal/parser/grammar.rb', line 5663

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

    result
end

#_reduce_521(val, _values, result) ⇒ Object 



5669
5670
5671
5672
5673
 
# File 'opal/lib/opal/parser/grammar.rb', line 5669

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

#_reduce_524(val, _values, result) ⇒ Object

reduce 523 omitted



5679
5680
5681
5682
5683
 
# File 'opal/lib/opal/parser/grammar.rb', line 5679

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

    result
end

#_reduce_525(val, _values, result) ⇒ Object 



5685
5686
5687
5688
5689
 
# File 'opal/lib/opal/parser/grammar.rb', line 5685

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

    result
end

#_reduce_526(val, _values, result) ⇒ Object 



5691
5692
5693
5694
5695
 
# File 'opal/lib/opal/parser/grammar.rb', line 5691

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

#_reduce_527(val, _values, result) ⇒ Object 



5697
5698
5699
5700
5701
 
# File 'opal/lib/opal/parser/grammar.rb', line 5697

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

#_reduce_528(val, _values, result) ⇒ Object 



5703
5704
5705
5706
5707
 
# File 'opal/lib/opal/parser/grammar.rb', line 5703

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

#_reduce_529(val, _values, result) ⇒ Object 



5709
5710
5711
5712
5713
 
# File 'opal/lib/opal/parser/grammar.rb', line 5709

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

#_reduce_530(val, _values, result) ⇒ Object 



5715
5716
5717
5718
5719
 
# File 'opal/lib/opal/parser/grammar.rb', line 5715

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

#_reduce_531(val, _values, result) ⇒ Object 



5721
5722
5723
5724
5725
 
# File 'opal/lib/opal/parser/grammar.rb', line 5721

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

#_reduce_532(val, _values, result) ⇒ Object 



5727
5728
5729
5730
5731
 
# File 'opal/lib/opal/parser/grammar.rb', line 5727

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

#_reduce_533(val, _values, result) ⇒ Object 



5733
5734
5735
5736
5737
 
# File 'opal/lib/opal/parser/grammar.rb', line 5733

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

#_reduce_534(val, _values, result) ⇒ Object 



5739
5740
5741
5742
5743
 
# File 'opal/lib/opal/parser/grammar.rb', line 5739

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

    result
end

#_reduce_535(val, _values, result) ⇒ Object 



5745
5746
5747
5748
5749
 
# File 'opal/lib/opal/parser/grammar.rb', line 5745

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



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

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



5797
5798
5799
5800
5801
 
# File 'opal/lib/opal/parser/grammar.rb', line 5797

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

#_reduce_57(val, _values, result) ⇒ Object

reduce 56 omitted



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

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



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

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



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

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



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

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

#_reduce_64(val, _values, result) ⇒ Object 



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

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

#_reduce_65(val, _values, result) ⇒ Object 



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

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

#_reduce_66(val, _values, result) ⇒ Object 



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

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

#_reduce_67(val, _values, result) ⇒ Object 



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

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

#_reduce_68(val, _values, result) ⇒ Object 



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

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

#_reduce_69(val, _values, result) ⇒ Object 



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

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

#_reduce_7(val, _values, result) ⇒ Object

reduce 6 omitted



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

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

#_reduce_70(val, _values, result) ⇒ Object 



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

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

#_reduce_71(val, _values, result) ⇒ Object 



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

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

#_reduce_72(val, _values, result) ⇒ Object 



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

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 



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

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

#_reduce_74(val, _values, result) ⇒ Object 



3527
3528
3529
3530
3531
 
# File 'opal/lib/opal/parser/grammar.rb', line 3527

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

    result
end

#_reduce_75(val, _values, result) ⇒ Object 



3533
3534
3535
3536
3537
 
# File 'opal/lib/opal/parser/grammar.rb', line 3533

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

#_reduce_76(val, _values, result) ⇒ Object 



3539
3540
3541
3542
3543
 
# File 'opal/lib/opal/parser/grammar.rb', line 3539

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 



3545
3546
3547
3548
3549
 
# File 'opal/lib/opal/parser/grammar.rb', line 3545

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

    result
end

#_reduce_78(val, _values, result) ⇒ Object 



3551
3552
3553
3554
3555
 
# File 'opal/lib/opal/parser/grammar.rb', line 3551

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

#_reduce_79(val, _values, result) ⇒ Object 



3557
3558
3559
3560
3561
 
# File 'opal/lib/opal/parser/grammar.rb', line 3557

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

#_reduce_8(val, _values, result) ⇒ Object 



3218
3219
3220
3221
3222
 
# File 'opal/lib/opal/parser/grammar.rb', line 3218

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 



3563
3564
3565
3566
3567
 
# File 'opal/lib/opal/parser/grammar.rb', line 3563

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

#_reduce_81(val, _values, result) ⇒ Object 



3569
3570
3571
3572
3573
 
# File 'opal/lib/opal/parser/grammar.rb', line 3569

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

#_reduce_82(val, _values, result) ⇒ Object 



3575
3576
3577
3578
3579
 
# File 'opal/lib/opal/parser/grammar.rb', line 3575

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

    result
end

#_reduce_83(val, _values, result) ⇒ Object 



3581
3582
3583
3584
3585
 
# File 'opal/lib/opal/parser/grammar.rb', line 3581

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

    result
end

#_reduce_84(val, _values, result) ⇒ Object 



3587
3588
3589
3590
3591
 
# File 'opal/lib/opal/parser/grammar.rb', line 3587

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

#_reduce_85(val, _values, result) ⇒ Object 



3593
3594
3595
3596
3597
 
# File 'opal/lib/opal/parser/grammar.rb', line 3593

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

    result
end

#_reduce_86(val, _values, result) ⇒ Object 



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

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 



3606
3607
3608
3609
3610
 
# File 'opal/lib/opal/parser/grammar.rb', line 3606

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

#_reduce_9(val, _values, result) ⇒ Object 



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

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

#_reduce_93(val, _values, result) ⇒ Object

reduce 92 omitted



3622
3623
3624
3625
3626
 
# File 'opal/lib/opal/parser/grammar.rb', line 3622

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

#_reduce_94(val, _values, result) ⇒ Object 



3628
3629
3630
3631
3632
 
# File 'opal/lib/opal/parser/grammar.rb', line 3628

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

#_reduce_95(val, _values, result) ⇒ Object 



3634
3635
3636
3637
3638
 
# File 'opal/lib/opal/parser/grammar.rb', line 3634

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

#_reduce_96(val, _values, result) ⇒ Object 



3640
3641
3642
3643
3644
 
# File 'opal/lib/opal/parser/grammar.rb', line 3640

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

#_reduce_97(val, _values, result) ⇒ Object 



3646
3647
3648
3649
3650
 
# File 'opal/lib/opal/parser/grammar.rb', line 3646

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

#_reduce_98(val, _values, result) ⇒ Object 



3652
3653
3654
3655
3656
 
# File 'opal/lib/opal/parser/grammar.rb', line 3652

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

#_reduce_99(val, _values, result) ⇒ Object 



3658
3659
3660
3661
3662
 
# File 'opal/lib/opal/parser/grammar.rb', line 3658

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

#_reduce_none(val, _values, result) ⇒ Object 



5803
5804
5805
 
# File 'opal/lib/opal/parser/grammar.rb', line 5803

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